]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
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 | ||
35 | namespace boost { | |
36 | namespace tuples { | |
37 | ||
38 | inline bool operator==(const null_type&, const null_type&) { return true; } | |
39 | inline bool operator>=(const null_type&, const null_type&) { return true; } | |
40 | inline bool operator<=(const null_type&, const null_type&) { return true; } | |
41 | inline bool operator!=(const null_type&, const null_type&) { return false; } | |
42 | inline bool operator<(const null_type&, const null_type&) { return false; } | |
43 | inline bool operator>(const null_type&, const null_type&) { return false; } | |
44 | ||
45 | ||
46 | namespace 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 | ||
53 | template<class T1, class T2> | |
54 | inline 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 | } | |
58 | template<> | |
59 | inline bool eq<null_type,null_type>(const null_type&, const null_type&) { return true; } | |
60 | ||
61 | template<class T1, class T2> | |
62 | inline 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 | } | |
66 | template<> | |
67 | inline bool neq<null_type,null_type>(const null_type&, const null_type&) { return false; } | |
68 | ||
69 | template<class T1, class T2> | |
70 | inline 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 | } | |
75 | template<> | |
76 | inline bool lt<null_type,null_type>(const null_type&, const null_type&) { return false; } | |
77 | ||
78 | template<class T1, class T2> | |
79 | inline 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 | } | |
84 | template<> | |
85 | inline bool gt<null_type,null_type>(const null_type&, const null_type&) { return false; } | |
86 | ||
87 | template<class T1, class T2> | |
88 | inline 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 | } | |
93 | template<> | |
94 | inline bool lte<null_type,null_type>(const null_type&, const null_type&) { return true; } | |
95 | ||
96 | template<class T1, class T2> | |
97 | inline 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 | } | |
102 | template<> | |
103 | inline 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 | ||
110 | template<class T1, class T2, class S1, class S2> | |
111 | inline 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 | ||
121 | template<class T1, class T2, class S1, class S2> | |
122 | inline 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 | // < | |
132 | template<class T1, class T2, class S1, class S2> | |
133 | inline 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 | // > | |
142 | template<class T1, class T2, class S1, class S2> | |
143 | inline 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 | // <= | |
152 | template<class T1, class T2, class S1, class S2> | |
153 | inline 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 | // >= | |
162 | template<class T1, class T2, class S1, class S2> | |
163 | inline 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 |