diff options
Diffstat (limited to 'src/third_party/boost-1.56.0/boost/tuple/tuple_comparison.hpp')
| -rw-r--r-- | src/third_party/boost-1.56.0/boost/tuple/tuple_comparison.hpp | 175 |
1 files changed, 0 insertions, 175 deletions
diff --git a/src/third_party/boost-1.56.0/boost/tuple/tuple_comparison.hpp b/src/third_party/boost-1.56.0/boost/tuple/tuple_comparison.hpp deleted file mode 100644 index 73723a15bc9..00000000000 --- a/src/third_party/boost-1.56.0/boost/tuple/tuple_comparison.hpp +++ /dev/null @@ -1,175 +0,0 @@ -// tuple_comparison.hpp ----------------------------------------------------- -// -// Copyright (C) 2001 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi) -// Copyright (C) 2001 Gary Powell (gary.powell@sierra.com) -// -// 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) -// -// For more information, see http://www.boost.org -// -// (The idea and first impl. of comparison operators was from Doug Gregor) - -// ----------------------------------------------------------------- - -#ifndef BOOST_TUPLE_COMPARISON_HPP -#define BOOST_TUPLE_COMPARISON_HPP - -#include "boost/tuple/tuple.hpp" - -// ------------------------------------------------------------- -// equality and comparison operators -// -// == and != compare tuples elementwise -// <, >, <= and >= use lexicographical ordering -// -// Any operator between tuples of different length fails at compile time -// No dependencies between operators are assumed -// (i.e. !(a<b) does not imply a>=b, a!=b does not imply a==b etc. -// so any weirdnesses of elementary operators are respected). -// -// ------------------------------------------------------------- - - -namespace boost { -namespace tuples { - -inline bool operator==(const null_type&, const null_type&) { return true; } -inline bool operator>=(const null_type&, const null_type&) { return true; } -inline bool operator<=(const null_type&, const null_type&) { return true; } -inline bool operator!=(const null_type&, const null_type&) { return false; } -inline bool operator<(const null_type&, const null_type&) { return false; } -inline bool operator>(const null_type&, const null_type&) { return false; } - - -namespace detail { - // comparison operators check statically the length of its operands and - // delegate the comparing task to the following functions. Hence - // the static check is only made once (should help the compiler). - // These functions assume tuples to be of the same length. - - -template<class T1, class T2> -inline bool eq(const T1& lhs, const T2& rhs) { - return lhs.get_head() == rhs.get_head() && - eq(lhs.get_tail(), rhs.get_tail()); -} -template<> -inline bool eq<null_type,null_type>(const null_type&, const null_type&) { return true; } - -template<class T1, class T2> -inline bool neq(const T1& lhs, const T2& rhs) { - return lhs.get_head() != rhs.get_head() || - neq(lhs.get_tail(), rhs.get_tail()); -} -template<> -inline bool neq<null_type,null_type>(const null_type&, const null_type&) { return false; } - -template<class T1, class T2> -inline bool lt(const T1& lhs, const T2& rhs) { - return lhs.get_head() < rhs.get_head() || - ( !(rhs.get_head() < lhs.get_head()) && - lt(lhs.get_tail(), rhs.get_tail())); -} -template<> -inline bool lt<null_type,null_type>(const null_type&, const null_type&) { return false; } - -template<class T1, class T2> -inline bool gt(const T1& lhs, const T2& rhs) { - return lhs.get_head() > rhs.get_head() || - ( !(rhs.get_head() > lhs.get_head()) && - gt(lhs.get_tail(), rhs.get_tail())); -} -template<> -inline bool gt<null_type,null_type>(const null_type&, const null_type&) { return false; } - -template<class T1, class T2> -inline bool lte(const T1& lhs, const T2& rhs) { - return lhs.get_head() <= rhs.get_head() && - ( !(rhs.get_head() <= lhs.get_head()) || - lte(lhs.get_tail(), rhs.get_tail())); -} -template<> -inline bool lte<null_type,null_type>(const null_type&, const null_type&) { return true; } - -template<class T1, class T2> -inline bool gte(const T1& lhs, const T2& rhs) { - return lhs.get_head() >= rhs.get_head() && - ( !(rhs.get_head() >= lhs.get_head()) || - gte(lhs.get_tail(), rhs.get_tail())); -} -template<> -inline bool gte<null_type,null_type>(const null_type&, const null_type&) { return true; } - -} // end of namespace detail - - -// equal ---- - -template<class T1, class T2, class S1, class S2> -inline bool operator==(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs) -{ - // check that tuple lengths are equal - BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value); - - return detail::eq(lhs, rhs); -} - -// not equal ----- - -template<class T1, class T2, class S1, class S2> -inline bool operator!=(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs) -{ - - // check that tuple lengths are equal - BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value); - - return detail::neq(lhs, rhs); -} - -// < -template<class T1, class T2, class S1, class S2> -inline bool operator<(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs) -{ - // check that tuple lengths are equal - BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value); - - return detail::lt(lhs, rhs); -} - -// > -template<class T1, class T2, class S1, class S2> -inline bool operator>(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs) -{ - // check that tuple lengths are equal - BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value); - - return detail::gt(lhs, rhs); -} - -// <= -template<class T1, class T2, class S1, class S2> -inline bool operator<=(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs) -{ - // check that tuple lengths are equal - BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value); - - return detail::lte(lhs, rhs); -} - -// >= -template<class T1, class T2, class S1, class S2> -inline bool operator>=(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs) -{ - // check that tuple lengths are equal - BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value); - - return detail::gte(lhs, rhs); -} - -} // end of namespace tuples -} // end of namespace boost - - -#endif // BOOST_TUPLE_COMPARISON_HPP |