X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;ds=sidebyside;f=cds%2Fopt%2Fcompare.h;h=23c9cbdcc3d13adb3be7651bbc94e5dd8ddae8e8;hb=176fd6666fdad6bb0a33f0d6fd2674533100ac26;hp=24e5775e67ff91701e1d006d43a1b60eecc8b3ea;hpb=c34b46ba50daf781053c4cf6e517d94188c802ed;p=libcds.git

diff --git a/cds/opt/compare.h b/cds/opt/compare.h
index 24e5775e..23c9cbdc 100644
--- a/cds/opt/compare.h
+++ b/cds/opt/compare.h
@@ -1,4 +1,32 @@
-//$$CDS-header$$
+/*
+    This file is a part of libcds - Concurrent Data Structures library
+
+    (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2017
+
+    Source code repo: http://github.com/khizmax/libcds/
+    Download: http://sourceforge.net/projects/libcds/files/
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice, this
+      list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+    DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+    FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+    DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+    OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
 
 #ifndef CDSLIB_OPT_COMPARE_H
 #define CDSLIB_OPT_COMPARE_H
@@ -19,9 +47,9 @@ namespace cds { namespace opt {
     /**
         The option sets a type of a functor to compare keys.
         For comparing two keys \p k1 and \p k2 the functor must return:
-        - 1 if k1 > k2
-        - 0 if k1 == k2
-        - -1 if k1 < k2
+        - 1 if <tt> k1 > k2 </tt>
+        - 0 if <tt> k1 == k2 </tt>
+        - -1 if <tt> k1 < k2 </tt>
 
         \p Functor is a functor with following interface:
         \code
@@ -36,12 +64,12 @@ namespace cds { namespace opt {
         Note that the functor must return \p int, not a \p bool value.
 
         There are predefined type for \p Functor:
-        - the functor v::less_comparator that implements comparing functor through \p std::less predicate.
-        - the specialization of v::less_comparator functor intended for the string comparison
+        - the functor \p opt::v::less_comparator that implements comparing functor through \p std::less predicate.
+        - the specialization of \p opt::v::less_comparator functor intended for the string comparison
 
         You may implement your own comparing functor that satisfies \p Functor interface.
 
-        About relation between \ref opt::less and \ref opt::compare option setters see opt::less description.
+        About relation between \p %opt::less and \p %opt::compare option setters see \p opt::less description.
     */
     template <typename Functor>
     struct compare {
@@ -65,7 +93,7 @@ namespace cds { namespace opt {
             /// Operator that compares two value of type \p T
             int operator()(T const& v1, T const& v2)
             {
-                if ( std::less<T>()( v1, v2 ) )
+                if ( std::less<T>()( v1, v2 ))
                     return -1;
                 if ( std::less<T>()( v2, v1 ))
                     return 1;
@@ -75,7 +103,7 @@ namespace cds { namespace opt {
 
         /// Comparator specialization for \p std::string
         /**
-            This functor uses \p std::string::compare method instead of \p std::less predicate.
+            This functor uses \p std::string::compare() method instead of \p std::less predicate.
         */
         template <typename T, typename Traits, typename Alloc>
         struct less_comparator< std::basic_string<T, Traits, Alloc> >
@@ -121,11 +149,11 @@ namespace cds { namespace opt {
 
         Generally, the default type for \p Functor is \p std::less but it depends on the container used.
 
-        \par Relation between \p opt::less and opt::compare option setters
-        Unless otherwise specified, \p compare option setter has high priority. If opt::compare and opt::less options are specified
-        for a container, the opt::compare option is used:
+        \par Relation between opt::less and opt::compare option setters
+        Unless otherwise specified, \p opt::compare option setter has high priority.
+        If \p %opt::compare and \p %opt::less options are specified for a container, the \p %opt::compare option is used:
         \code
-        // Suppose, hypothetical map_type allows to specify
+        // Suppose, a hypothetical map_type allows to specify
         // cds::opt::less and cds::opt::compare options
 
         typedef map_type< std::string, int,
@@ -158,9 +186,9 @@ namespace cds { namespace opt {
             int operator ()( T const& t, Q const& q ) const
             {
                 less_functor f;
-                if ( f( t, q ) )
+                if ( f( t, q ))
                     return -1;
-                if ( f( q, t ) )
+                if ( f( q, t ))
                     return 1;
                 return 0;
             }
@@ -210,7 +238,7 @@ namespace cds { namespace opt {
     }   // namespace details
     //@endcond
 
-    /// [type-option] Option setter for \p equal_to predicate
+    /// [type-option] Option setter for \p opt::equal_to predicate
     /**
         The option sets a binary predicate that tests whether a value of a specified type is equal to another value of that type.
         \p Functor interface is similar to \p std::equal_to predicate interface.