Line data    Source code

       1             : //  Boost string_algo library compare.hpp header file  -------------------------//
       2             : 
       3             : //  Copyright Pavol Droba 2002-2006.
       4             : //
       5             : // Distributed under the Boost Software License, Version 1.0.
       6             : //    (See accompanying file LICENSE_1_0.txt or copy at
       7             : //          http://www.boost.org/LICENSE_1_0.txt)
       8             : 
       9             : //  See http://www.boost.org/ for updates, documentation, and revision history.
      10             : 
      11             : #ifndef BOOST_STRING_COMPARE_HPP
      12             : #define BOOST_STRING_COMPARE_HPP
      13             : 
      14             : #include <boost/algorithm/string/config.hpp>
      15             : #include <locale>
      16             : 
      17             : /*! \file
      18             :     Defines element comparison predicates. Many algorithms in this library can
      19             :     take an additional argument with a predicate used to compare elements.
      20             :     This makes it possible, for instance, to have case insensitive versions
      21             :     of the algorithms.
      22             : */
      23             : 
      24             : namespace boost {
      25             :     namespace algorithm {
      26             : 
      27             :         //  is_equal functor  -----------------------------------------------//
      28             : 
      29             :         //! is_equal functor
      30             :         /*!
      31             :             Standard STL equal_to only handle comparison between arguments
      32             :             of the same type. This is a less restrictive version which wraps operator ==.
      33             :         */
      34             :         struct is_equal
      35             :         {
      36             :             //! Function operator
      37             :             /*!
      38             :                 Compare two operands for equality
      39             :             */
      40             :             template< typename T1, typename T2 >
      41      221120 :                 bool operator()( const T1& Arg1, const T2& Arg2 ) const
      42             :             {
      43             :                 return Arg1==Arg2;
      44             :             }
      45             :         };
      46             : 
      47             :         //! case insensitive version of is_equal
      48             :         /*!
      49             :             Case insensitive comparison predicate. Comparison is done using
      50             :             specified locales.
      51             :         */
      52           0 :         struct is_iequal
      53             :         {
      54             :             //! Constructor
      55             :             /*!
      56             :                 \param Loc locales used for comparison
      57             :             */
      58           0 :             is_iequal( const std::locale& Loc=std::locale() ) :
      59           0 :                 m_Loc( Loc ) {}
      60             : 
      61             :             //! Function operator
      62             :             /*!
      63             :                 Compare two operands. Case is ignored.
      64             :             */
      65             :             template< typename T1, typename T2 >
      66             :                 bool operator()( const T1& Arg1, const T2& Arg2 ) const
      67             :             {
      68             :                 #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
      69             :                     return std::toupper(Arg1)==std::toupper(Arg2);
      70             :                 #else
      71             :                     return std::toupper<T1>(Arg1,m_Loc)==std::toupper<T2>(Arg2,m_Loc);
      72             :                 #endif
      73             :             }
      74             : 
      75             :         private:
      76             :             std::locale m_Loc;
      77             :         };
      78             : 
      79             :         //  is_less functor  -----------------------------------------------//
      80             : 
      81             :         //! is_less functor
      82             :         /*!
      83             :             Convenient version of standard std::less. Operation is templated, therefore it is 
      84             :             not required to specify the exact types upon the construction
      85             :          */
      86             :         struct is_less
      87             :         {
      88             :             //! Functor operation
      89             :             /*!
      90             :                 Compare two operands using > operator
      91             :              */
      92             :             template< typename T1, typename T2 >
      93             :                 bool operator()( const T1& Arg1, const T2& Arg2 ) const
      94             :             {
      95             :                 return Arg1<Arg2;
      96             :             }
      97             :         };
      98             : 
      99             : 
     100             :         //! case insensitive version of is_less
     101             :         /*!
     102             :             Case insensitive comparison predicate. Comparison is done using
     103             :             specified locales.
     104             :         */
     105             :         struct is_iless
     106             :         {
     107             :             //! Constructor
     108             :             /*!
     109             :                 \param Loc locales used for comparison
     110             :             */
     111             :             is_iless( const std::locale& Loc=std::locale() ) :
     112             :                 m_Loc( Loc ) {}
     113             : 
     114             :             //! Function operator
     115             :             /*!
     116             :                 Compare two operands. Case is ignored.
     117             :             */
     118             :             template< typename T1, typename T2 >
     119             :                 bool operator()( const T1& Arg1, const T2& Arg2 ) const
     120             :             {
     121             :                 #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
     122             :                     return std::toupper(Arg1)<std::toupper(Arg2);
     123             :                 #else
     124             :                     return std::toupper<T1>(Arg1,m_Loc)<std::toupper<T2>(Arg2,m_Loc);
     125             :                 #endif
     126             :             }
     127             : 
     128             :         private:
     129             :             std::locale m_Loc;
     130             :         };
     131             : 
     132             :         //  is_not_greater functor  -----------------------------------------------//
     133             : 
     134             :         //! is_not_greater functor
     135             :         /*!
     136             :             Convenient version of standard std::not_greater_to. Operation is templated, therefore it is 
     137             :             not required to specify the exact types upon the construction
     138             :          */
     139             :         struct is_not_greater
     140             :         {
     141             :             //! Functor operation
     142             :             /*!
     143             :                 Compare two operands using > operator
     144             :              */
     145             :             template< typename T1, typename T2 >
     146             :                 bool operator()( const T1& Arg1, const T2& Arg2 ) const
     147             :             {
     148             :                 return Arg1<=Arg2;
     149             :             }
     150             :         };
     151             : 
     152             : 
     153             :         //! case insensitive version of is_not_greater
     154             :         /*!
     155             :             Case insensitive comparison predicate. Comparison is done using
     156             :             specified locales.
     157             :         */
     158             :         struct is_not_igreater
     159             :         {
     160             :             //! Constructor
     161             :             /*!
     162             :                 \param Loc locales used for comparison
     163             :             */
     164             :             is_not_igreater( const std::locale& Loc=std::locale() ) :
     165             :                 m_Loc( Loc ) {}
     166             : 
     167             :             //! Function operator
     168             :             /*!
     169             :                 Compare two operands. Case is ignored.
     170             :             */
     171             :             template< typename T1, typename T2 >
     172             :                 bool operator()( const T1& Arg1, const T2& Arg2 ) const
     173             :             {
     174             :                 #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
     175             :                     return std::toupper(Arg1)<=std::toupper(Arg2);
     176             :                 #else
     177             :                     return std::toupper<T1>(Arg1,m_Loc)<=std::toupper<T2>(Arg2,m_Loc);
     178             :                 #endif
     179             :             }
     180             : 
     181             :         private:
     182             :             std::locale m_Loc;
     183             :         };
     184             : 
     185             : 
     186             :     } // namespace algorithm
     187             : 
     188             :     // pull names to the boost namespace
     189             :     using algorithm::is_equal;
     190             :     using algorithm::is_iequal;
     191             :     using algorithm::is_less;
     192             :     using algorithm::is_iless;
     193             :     using algorithm::is_not_greater;
     194             :     using algorithm::is_not_igreater;
     195             : 
     196             : } // namespace boost
     197             : 
     198             : 
     199             : #endif  // BOOST_STRING_COMPARE_HPP