blocxx
StrictWeakOrdering.hpp
Go to the documentation of this file.
1/*******************************************************************************
2* Copyright (C) 2005, Vintela, Inc. All rights reserved.
3* Copyright (C) 2006, Novell, Inc. All rights reserved.
4*
5* Redistribution and use in source and binary forms, with or without
6* modification, are permitted provided that the following conditions are met:
7*
8* * Redistributions of source code must retain the above copyright notice,
9* this list of conditions and the following disclaimer.
10* * Redistributions in binary form must reproduce the above copyright
11* notice, this list of conditions and the following disclaimer in the
12* documentation and/or other materials provided with the distribution.
13* * Neither the name of
14* Vintela, Inc.,
15* nor Novell, Inc.,
16* nor the names of its contributors or employees may be used to
17* endorse or promote products derived from this software without
18* specific prior written permission.
19*
20* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
24* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30* POSSIBILITY OF SUCH DAMAGE.
31*******************************************************************************/
32
33
38#ifndef BLOCXX_STRICT_WEAK_ORDERING_HPP_INCLUDE_GUARD_
39#define BLOCXX_STRICT_WEAK_ORDERING_HPP_INCLUDE_GUARD_
40#include "blocxx/BLOCXX_config.h"
41
42namespace BLOCXX_NAMESPACE
43{
44
45template<class T1>
46bool StrictWeakOrdering(const T1& lhs1, const T1& rhs1)
47{
48 return lhs1 < rhs1;
49}
50template<class T1, class T2>
51bool StrictWeakOrdering(const T1& lhs1, const T1& rhs1,
52 const T2& lhs2, const T2& rhs2)
53{
54 if (lhs1 < rhs1) return true;
55 else if (rhs1 < lhs1) return false;
56 else return StrictWeakOrdering(lhs2, rhs2);
57}
58template<class T1, class T2, class T3>
59bool StrictWeakOrdering(const T1& lhs1, const T1& rhs1,
60 const T2& lhs2, const T2& rhs2,
61 const T3& lhs3, const T3& rhs3)
62{
63 if (lhs1 < rhs1) return true;
64 else if (rhs1 < lhs1) return false;
65 else return StrictWeakOrdering(lhs2, rhs2,
66 lhs3, rhs3);
67}
68template<class T1, class T2, class T3, class T4>
69bool StrictWeakOrdering(const T1& lhs1, const T1& rhs1,
70 const T2& lhs2, const T2& rhs2,
71 const T3& lhs3, const T3& rhs3,
72 const T4& lhs4, const T4& rhs4)
73{
74 if (lhs1 < rhs1) return true;
75 else if (rhs1 < lhs1) return false;
76 else return StrictWeakOrdering(lhs2, rhs2,
77 lhs3, rhs3,
78 lhs4, rhs4);
79}
80template<class T1, class T2, class T3, class T4, class T5>
81bool StrictWeakOrdering(const T1& lhs1, const T1& rhs1,
82 const T2& lhs2, const T2& rhs2,
83 const T3& lhs3, const T3& rhs3,
84 const T4& lhs4, const T4& rhs4,
85 const T5& lhs5, const T5& rhs5)
86{
87 if (lhs1 < rhs1) return true;
88 else if (rhs1 < lhs1) return false;
89 else return StrictWeakOrdering(lhs2, rhs2,
90 lhs3, rhs3,
91 lhs4, rhs4,
92 lhs5, rhs5);
93}
94template<class T1, class T2, class T3, class T4, class T5, class T6>
95bool StrictWeakOrdering(const T1& lhs1, const T1& rhs1,
96 const T2& lhs2, const T2& rhs2,
97 const T3& lhs3, const T3& rhs3,
98 const T4& lhs4, const T4& rhs4,
99 const T5& lhs5, const T5& rhs5,
100 const T6& lhs6, const T6& rhs6)
101{
102 if (lhs1 < rhs1) return true;
103 else if (rhs1 < lhs1) return false;
104 else return StrictWeakOrdering(lhs2, rhs2,
105 lhs3, rhs3,
106 lhs4, rhs4,
107 lhs5, rhs5,
108 lhs6, rhs6);
109}
110template<class T1, class T2, class T3, class T4, class T5, class T6, class
111T7>
112bool StrictWeakOrdering(const T1& lhs1, const T1& rhs1,
113 const T2& lhs2, const T2& rhs2,
114 const T3& lhs3, const T3& rhs3,
115 const T4& lhs4, const T4& rhs4,
116 const T5& lhs5, const T5& rhs5,
117 const T6& lhs6, const T6& rhs6,
118 const T7& lhs7, const T7& rhs7)
119{
120 if (lhs1 < rhs1) return true;
121 else if (rhs1 < lhs1) return false;
122 else return StrictWeakOrdering(lhs2, rhs2,
123 lhs3, rhs3,
124 lhs4, rhs4,
125 lhs5, rhs5,
126 lhs6, rhs6,
127 lhs7, rhs7);
128}
129template<class T1, class T2, class T3, class T4, class T5, class T6, class
130T7, class T8>
131bool StrictWeakOrdering(const T1& lhs1, const T1& rhs1,
132 const T2& lhs2, const T2& rhs2,
133 const T3& lhs3, const T3& rhs3,
134 const T4& lhs4, const T4& rhs4,
135 const T5& lhs5, const T5& rhs5,
136 const T6& lhs6, const T6& rhs6,
137 const T7& lhs7, const T7& rhs7,
138 const T8& lhs8, const T8& rhs8)
139{
140 if (lhs1 < rhs1) return true;
141 else if (rhs1 < lhs1) return false;
142 else return StrictWeakOrdering(lhs2, rhs2,
143 lhs3, rhs3,
144 lhs4, rhs4,
145 lhs5, rhs5,
146 lhs6, rhs6,
147 lhs7, rhs7,
148 lhs8, rhs8);
149}
150template<class T1, class T2, class T3, class T4, class T5, class T6, class
151T7, class T8, class T9>
152bool StrictWeakOrdering(const T1& lhs1, const T1& rhs1,
153 const T2& lhs2, const T2& rhs2,
154 const T3& lhs3, const T3& rhs3,
155 const T4& lhs4, const T4& rhs4,
156 const T5& lhs5, const T5& rhs5,
157 const T6& lhs6, const T6& rhs6,
158 const T7& lhs7, const T7& rhs7,
159 const T8& lhs8, const T8& rhs8,
160 const T9& lhs9, const T9& rhs9)
161{
162 if (lhs1 < rhs1) return true;
163 else if (rhs1 < lhs1) return false;
164 else return StrictWeakOrdering(lhs2, rhs2,
165 lhs3, rhs3,
166 lhs4, rhs4,
167 lhs5, rhs5,
168 lhs6, rhs6,
169 lhs7, rhs7,
170 lhs8, rhs8,
171 lhs9, rhs9);
172}
173template<class T1, class T2, class T3, class T4, class T5, class T6, class
174T7, class T8, class T9, class T10>
175bool StrictWeakOrdering(const T1& lhs1, const T1& rhs1,
176 const T2& lhs2, const T2& rhs2,
177 const T3& lhs3, const T3& rhs3,
178 const T4& lhs4, const T4& rhs4,
179 const T5& lhs5, const T5& rhs5,
180 const T6& lhs6, const T6& rhs6,
181 const T7& lhs7, const T7& rhs7,
182 const T8& lhs8, const T8& rhs8,
183 const T9& lhs9, const T9& rhs9,
184 const T10& lhs10, const T10& rhs10)
185{
186 if (lhs1 < rhs1) return true;
187 else if (rhs1 < lhs1) return false;
188 else return StrictWeakOrdering(lhs2, rhs2,
189 lhs3, rhs3,
190 lhs4, rhs4,
191 lhs5, rhs5,
192 lhs6, rhs6,
193 lhs7, rhs7,
194 lhs8, rhs8,
195 lhs9, rhs9,
196 lhs10, rhs10);
197}
198
199} // end namespace BLOCXX_NAMESPACE
200
201#endif
BLOCXX_NAMESPACE
Taken from RFC 1321.
Definition AppenderLogger.cpp:48
BLOCXX_NAMESPACE::operator==
bool operator==(const Array< T > &x, const Array< T > &y)
Definition ArrayImpl.hpp:434
BLOCXX_NAMESPACE::StrictWeakOrdering
bool StrictWeakOrdering(const T1 &lhs1, const T1 &rhs1)
Definition StrictWeakOrdering.hpp:46
Generated by doxygen 1.10.0