Improved docs

diff --git a/cds/container/cuckoo_map.h b/cds/container/cuckoo_map.h
index 6423e16140a05f1b83923eb4623c2c73d77cfcbc..fd7df5dca1ae8a68fb6b6c7eca979949072e193b 100644 (file)
--- a/cds/container/cuckoo_map.h
+++ b/cds/container/cuckoo_map.h
@@ -122,7 +122,7 @@ namespace cds { namespace container {
         <b>About Cuckoo hashing</b>
 
             [From "The Art of Multiprocessor Programming"]
-            Cuckoo hashing is a hashing algorithm in which a newly added item displaces any earlier item
+            <a href="https://en.wikipedia.org/wiki/Cuckoo_hashing">Cuckoo hashing</a> is a hashing algorithm in which a newly added item displaces any earlier item
             occupying the same slot. For brevity, a table is a k-entry array of items. For a hash set f size
             N = 2k we use a two-entry array of tables, and two independent hash functions,
             <tt> h0, h1: KeyRange -> 0,...,k-1</tt>
@@ -160,14 +160,14 @@ namespace cds { namespace container {
             the average search complexity is <tt>O(PROBE_SET/2)</tt>.
             However, the overhead of sorting can eliminate a gain of ordered search.
 
-            The probe set is ordered if opt::compare or opt::less is specified in \p %CuckooSet
-            declaration. Otherwise, the probe set is unordered and \p %CuckooSet must contain
-            opt::equal_to option.
+            The probe set is ordered if \p compare or \p less is specified in \p Traits
+            template parameter. Otherwise, the probe set is unordered and \p Traits must contain
+            \p equal_to predicate.
 
         Template arguments:
         - \p Key - key type
         - \p T - the type stored in the map.
-        - \p Traits - map traits., default is \p cuckoo::traits.
+        - \p Traits - map traits, default is \p cuckoo::traits.
             It is possible to declare option-based set with \p cuckoo::make_traits metafunction
             result as \p Traits template argument.
 

diff --git a/cds/container/cuckoo_set.h b/cds/container/cuckoo_set.h
index fdea67817f4ec5a3b5e601dd990165a87564a37c..49a131b3d82bdc09e4f00a83e753c7fa25ea40b3 100644 (file)
--- a/cds/container/cuckoo_set.h
+++ b/cds/container/cuckoo_set.h
@@ -117,7 +117,7 @@ namespace cds { namespace container {
         <b>About Cuckoo hashing</b>
 
             [From "The Art of Multiprocessor Programming"]
-            Cuckoo hashing is a hashing algorithm in which a newly added item displaces any earlier item
+            <a href="https://en.wikipedia.org/wiki/Cuckoo_hashing">Cuckoo hashing</a> is a hashing algorithm in which a newly added item displaces any earlier item
             occupying the same slot. For brevity, a table is a k-entry array of items. For a hash set f size
             N = 2k we use a two-entry array of tables, and two independent hash functions,
             <tt> h0, h1: KeyRange -> 0,...,k-1</tt>
@@ -155,9 +155,9 @@ namespace cds { namespace container {
             the average search complexity is <tt>O(PROBE_SET/2)</tt>.
             However, the overhead of sorting can eliminate a gain of ordered search.
 
-            The probe set is ordered if opt::compare or opt::less is specified in \p %CuckooSet
-            declaration. Otherwise, the probe set is unordered and \p %CuckooSet must contain
-            opt::equal_to option.
+            The probe set is ordered if \p compare or \p less is specified in \p Traits
+            template parameter. Otherwise, the probe set is unordered and \p Traits must contain
+            \p equal_to predicate.
 
         Template arguments:
         - \p T - the type stored in the set.

diff --git a/cds/intrusive/cuckoo_set.h b/cds/intrusive/cuckoo_set.h
index 09b3cb408aa729f6c4c1289b06933c0d85a57c69..09c16590143f9bec6d4dacde7dba8d451a259ee7 100644 (file)
--- a/cds/intrusive/cuckoo_set.h
+++ b/cds/intrusive/cuckoo_set.h
@@ -1613,7 +1613,7 @@ namespace cds { namespace intrusive {
         <b>About Cuckoo hashing</b>
 
             [From <i>"The Art of Multiprocessor Programming"</i>]
-            Cuckoo hashing is a hashing algorithm in which a newly added item displaces any earlier item
+            <a href="https://en.wikipedia.org/wiki/Cuckoo_hashing">Cuckoo hashing</a> is a hashing algorithm in which a newly added item displaces any earlier item
             occupying the same slot. For brevity, a table is a k-entry array of items. For a hash set f size
             N = 2k we use a two-entry array of tables, and two independent hash functions,
             <tt> h0, h1: KeyRange -> 0,...,k-1</tt>
@@ -1651,9 +1651,9 @@ namespace cds { namespace intrusive {
             the average search complexity is <tt>O(PROBE_SET/2)</tt>.
             However, the overhead of sorting can eliminate a gain of ordered search.
 
-            The probe set is ordered if \p opt::compare or \p opt::less is specified in \p Traits template
+            The probe set is ordered if \p compare or \p less is specified in \p Traits template
             parameter. Otherwise, the probe set is unordered and \p Traits should provide
-            \p opt::equal_to option.
+            \p equal_to predicate.
 
             The \p cds::intrusive::cuckoo namespace contains \p %CuckooSet-related declarations.