| // 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 |