200 lines
6.4 KiB
Plaintext
200 lines
6.4 KiB
Plaintext
// Boost string_algo library compare.hpp header file -------------------------//
|
|
|
|
// Copyright Pavol Droba 2002-2006.
|
|
//
|
|
// Distributed under the Boost Software License, Version 1.0.
|
|
// (See accompanying file LICENSE_1_0.txt or copy at
|
|
// http://www.boost.org/LICENSE_1_0.txt)
|
|
|
|
// See http://www.boost.org/ for updates, documentation, and revision history.
|
|
|
|
#ifndef BOOST_STRING_COMPARE_HPP
|
|
#define BOOST_STRING_COMPARE_HPP
|
|
|
|
#include <boost/algorithm/string/config.hpp>
|
|
#include <locale>
|
|
|
|
/*! \file
|
|
Defines element comparison predicates. Many algorithms in this library can
|
|
take an additional argument with a predicate used to compare elements.
|
|
This makes it possible, for instance, to have case insensitive versions
|
|
of the algorithms.
|
|
*/
|
|
|
|
namespace boost {
|
|
namespace algorithm {
|
|
|
|
// is_equal functor -----------------------------------------------//
|
|
|
|
//! is_equal functor
|
|
/*!
|
|
Standard STL equal_to only handle comparison between arguments
|
|
of the same type. This is a less restrictive version which wraps operator ==.
|
|
*/
|
|
struct is_equal
|
|
{
|
|
//! Function operator
|
|
/*!
|
|
Compare two operands for equality
|
|
*/
|
|
template< typename T1, typename T2 >
|
|
bool operator()( const T1& Arg1, const T2& Arg2 ) const
|
|
{
|
|
return Arg1==Arg2;
|
|
}
|
|
};
|
|
|
|
//! case insensitive version of is_equal
|
|
/*!
|
|
Case insensitive comparison predicate. Comparison is done using
|
|
specified locales.
|
|
*/
|
|
struct is_iequal
|
|
{
|
|
//! Constructor
|
|
/*!
|
|
\param Loc locales used for comparison
|
|
*/
|
|
is_iequal( const std::locale& Loc=std::locale() ) :
|
|
m_Loc( Loc ) {}
|
|
|
|
//! Function operator
|
|
/*!
|
|
Compare two operands. Case is ignored.
|
|
*/
|
|
template< typename T1, typename T2 >
|
|
bool operator()( const T1& Arg1, const T2& Arg2 ) const
|
|
{
|
|
#if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
|
|
return std::toupper(Arg1)==std::toupper(Arg2);
|
|
#else
|
|
return std::toupper<T1>(Arg1,m_Loc)==std::toupper<T2>(Arg2,m_Loc);
|
|
#endif
|
|
}
|
|
|
|
private:
|
|
std::locale m_Loc;
|
|
};
|
|
|
|
// is_less functor -----------------------------------------------//
|
|
|
|
//! is_less functor
|
|
/*!
|
|
Convenient version of standard std::less. Operation is templated, therefore it is
|
|
not required to specify the exact types upon the construction
|
|
*/
|
|
struct is_less
|
|
{
|
|
//! Functor operation
|
|
/*!
|
|
Compare two operands using > operator
|
|
*/
|
|
template< typename T1, typename T2 >
|
|
bool operator()( const T1& Arg1, const T2& Arg2 ) const
|
|
{
|
|
return Arg1<Arg2;
|
|
}
|
|
};
|
|
|
|
|
|
//! case insensitive version of is_less
|
|
/*!
|
|
Case insensitive comparison predicate. Comparison is done using
|
|
specified locales.
|
|
*/
|
|
struct is_iless
|
|
{
|
|
//! Constructor
|
|
/*!
|
|
\param Loc locales used for comparison
|
|
*/
|
|
is_iless( const std::locale& Loc=std::locale() ) :
|
|
m_Loc( Loc ) {}
|
|
|
|
//! Function operator
|
|
/*!
|
|
Compare two operands. Case is ignored.
|
|
*/
|
|
template< typename T1, typename T2 >
|
|
bool operator()( const T1& Arg1, const T2& Arg2 ) const
|
|
{
|
|
#if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
|
|
return std::toupper(Arg1)<std::toupper(Arg2);
|
|
#else
|
|
return std::toupper<T1>(Arg1,m_Loc)<std::toupper<T2>(Arg2,m_Loc);
|
|
#endif
|
|
}
|
|
|
|
private:
|
|
std::locale m_Loc;
|
|
};
|
|
|
|
// is_not_greater functor -----------------------------------------------//
|
|
|
|
//! is_not_greater functor
|
|
/*!
|
|
Convenient version of standard std::not_greater_to. Operation is templated, therefore it is
|
|
not required to specify the exact types upon the construction
|
|
*/
|
|
struct is_not_greater
|
|
{
|
|
//! Functor operation
|
|
/*!
|
|
Compare two operands using > operator
|
|
*/
|
|
template< typename T1, typename T2 >
|
|
bool operator()( const T1& Arg1, const T2& Arg2 ) const
|
|
{
|
|
return Arg1<=Arg2;
|
|
}
|
|
};
|
|
|
|
|
|
//! case insensitive version of is_not_greater
|
|
/*!
|
|
Case insensitive comparison predicate. Comparison is done using
|
|
specified locales.
|
|
*/
|
|
struct is_not_igreater
|
|
{
|
|
//! Constructor
|
|
/*!
|
|
\param Loc locales used for comparison
|
|
*/
|
|
is_not_igreater( const std::locale& Loc=std::locale() ) :
|
|
m_Loc( Loc ) {}
|
|
|
|
//! Function operator
|
|
/*!
|
|
Compare two operands. Case is ignored.
|
|
*/
|
|
template< typename T1, typename T2 >
|
|
bool operator()( const T1& Arg1, const T2& Arg2 ) const
|
|
{
|
|
#if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
|
|
return std::toupper(Arg1)<=std::toupper(Arg2);
|
|
#else
|
|
return std::toupper<T1>(Arg1,m_Loc)<=std::toupper<T2>(Arg2,m_Loc);
|
|
#endif
|
|
}
|
|
|
|
private:
|
|
std::locale m_Loc;
|
|
};
|
|
|
|
|
|
} // namespace algorithm
|
|
|
|
// pull names to the boost namespace
|
|
using algorithm::is_equal;
|
|
using algorithm::is_iequal;
|
|
using algorithm::is_less;
|
|
using algorithm::is_iless;
|
|
using algorithm::is_not_greater;
|
|
using algorithm::is_not_igreater;
|
|
|
|
} // namespace boost
|
|
|
|
|
|
#endif // BOOST_STRING_COMPARE_HPP
|