PageRenderTime 22ms CodeModel.GetById 8ms app.highlight 12ms RepoModel.GetById 1ms app.codeStats 0ms

/Src/Dependencies/Boost/boost/tuple/tuple_comparison.hpp

http://hadesmem.googlecode.com/
C++ Header | 175 lines | 98 code | 36 blank | 41 comment | 8 complexity | 66e17b2fe64454e0c83f43dbd0400565 MD5 | raw file
  1// tuple_comparison.hpp -----------------------------------------------------
  2//  
  3// Copyright (C) 2001 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
  4// Copyright (C) 2001 Gary Powell (gary.powell@sierra.com)
  5//
  6// Distributed under the Boost Software License, Version 1.0. (See
  7// accompanying file LICENSE_1_0.txt or copy at
  8// http://www.boost.org/LICENSE_1_0.txt)
  9// 
 10// For more information, see http://www.boost.org
 11// 
 12// (The idea and first impl. of comparison operators was from Doug Gregor)
 13
 14// ----------------------------------------------------------------- 
 15
 16#ifndef BOOST_TUPLE_COMPARISON_HPP
 17#define BOOST_TUPLE_COMPARISON_HPP
 18
 19#include "boost/tuple/tuple.hpp"
 20
 21// -------------------------------------------------------------
 22// equality and comparison operators 
 23//
 24// == and != compare tuples elementwise
 25// <, >, <= and >= use lexicographical ordering
 26//
 27// Any operator between tuples of different length fails at compile time
 28// No dependencies between operators are assumed 
 29// (i.e. !(a<b)  does not imply a>=b, a!=b does not imply a==b etc.
 30// so any weirdnesses of elementary operators are respected).
 31//
 32// -------------------------------------------------------------
 33
 34
 35namespace boost {
 36namespace tuples {
 37
 38inline bool operator==(const null_type&, const null_type&) { return true; }
 39inline bool operator>=(const null_type&, const null_type&) { return true; }
 40inline bool operator<=(const null_type&, const null_type&) { return true; }
 41inline bool operator!=(const null_type&, const null_type&) { return false; }
 42inline bool operator<(const null_type&, const null_type&) { return false; }
 43inline bool operator>(const null_type&, const null_type&) { return false; }
 44
 45
 46namespace detail {
 47  // comparison operators check statically the length of its operands and
 48  // delegate the comparing task to the following functions. Hence
 49  // the static check is only made once (should help the compiler).  
 50  // These functions assume tuples to be of the same length.
 51
 52
 53template<class T1, class T2>
 54inline bool eq(const T1& lhs, const T2& rhs) {
 55  return lhs.get_head() == rhs.get_head() &&
 56         eq(lhs.get_tail(), rhs.get_tail());
 57}
 58template<>
 59inline bool eq<null_type,null_type>(const null_type&, const null_type&) { return true; }
 60
 61template<class T1, class T2>
 62inline bool neq(const T1& lhs, const T2& rhs) {
 63  return lhs.get_head() != rhs.get_head()  ||
 64         neq(lhs.get_tail(), rhs.get_tail());
 65}
 66template<>
 67inline bool neq<null_type,null_type>(const null_type&, const null_type&) { return false; }
 68
 69template<class T1, class T2>
 70inline bool lt(const T1& lhs, const T2& rhs) {
 71  return lhs.get_head() < rhs.get_head()  ||
 72          ( !(rhs.get_head() < lhs.get_head()) &&
 73            lt(lhs.get_tail(), rhs.get_tail()));
 74}
 75template<>
 76inline bool lt<null_type,null_type>(const null_type&, const null_type&) { return false; }
 77
 78template<class T1, class T2>
 79inline bool gt(const T1& lhs, const T2& rhs) {
 80  return lhs.get_head() > rhs.get_head()  ||
 81          ( !(rhs.get_head() > lhs.get_head()) &&
 82            gt(lhs.get_tail(), rhs.get_tail()));
 83}
 84template<>
 85inline bool gt<null_type,null_type>(const null_type&, const null_type&) { return false; }
 86
 87template<class T1, class T2>
 88inline bool lte(const T1& lhs, const T2& rhs) {
 89  return lhs.get_head() <= rhs.get_head()  &&
 90          ( !(rhs.get_head() <= lhs.get_head()) ||
 91            lte(lhs.get_tail(), rhs.get_tail()));
 92}
 93template<>
 94inline bool lte<null_type,null_type>(const null_type&, const null_type&) { return true; }
 95
 96template<class T1, class T2>
 97inline bool gte(const T1& lhs, const T2& rhs) {
 98  return lhs.get_head() >= rhs.get_head()  &&
 99          ( !(rhs.get_head() >= lhs.get_head()) ||
100            gte(lhs.get_tail(), rhs.get_tail()));
101}
102template<>
103inline bool gte<null_type,null_type>(const null_type&, const null_type&) { return true; }
104
105} // end of namespace detail
106
107
108// equal ----
109
110template<class T1, class T2, class S1, class S2>
111inline bool operator==(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
112{
113  // check that tuple lengths are equal
114  BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
115
116  return  detail::eq(lhs, rhs);
117}
118
119// not equal -----
120
121template<class T1, class T2, class S1, class S2>
122inline bool operator!=(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
123{
124
125  // check that tuple lengths are equal
126  BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
127
128  return detail::neq(lhs, rhs);
129}
130
131// <
132template<class T1, class T2, class S1, class S2>
133inline bool operator<(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
134{
135  // check that tuple lengths are equal
136  BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
137
138  return detail::lt(lhs, rhs);
139}
140
141// >
142template<class T1, class T2, class S1, class S2>
143inline bool operator>(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
144{
145  // check that tuple lengths are equal
146  BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
147
148  return detail::gt(lhs, rhs);
149}
150
151// <=
152template<class T1, class T2, class S1, class S2>
153inline bool operator<=(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
154{
155  // check that tuple lengths are equal
156  BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
157
158  return detail::lte(lhs, rhs);
159}
160
161// >=
162template<class T1, class T2, class S1, class S2>
163inline bool operator>=(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
164{
165  // check that tuple lengths are equal
166  BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
167
168  return detail::gte(lhs, rhs);
169}
170
171} // end of namespace tuples
172} // end of namespace boost
173
174
175#endif // BOOST_TUPLE_COMPARISON_HPP