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 
42 namespace BLOCXX_NAMESPACE
43 {
44 
45 template<class T1>
46 bool StrictWeakOrdering(const T1& lhs1, const T1& rhs1)
47 {
48  return lhs1 < rhs1;
49 }
50 template<class T1, class T2>
51 bool 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 }
58 template<class T1, class T2, class T3>
59 bool 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 }
68 template<class T1, class T2, class T3, class T4>
69 bool 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 }
80 template<class T1, class T2, class T3, class T4, class T5>
81 bool 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 }
94 template<class T1, class T2, class T3, class T4, class T5, class T6>
95 bool 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 }
110 template<class T1, class T2, class T3, class T4, class T5, class T6, class
111 T7>
112 bool 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 }
129 template<class T1, class T2, class T3, class T4, class T5, class T6, class
130 T7, class T8>
131 bool 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 }
150 template<class T1, class T2, class T3, class T4, class T5, class T6, class
151 T7, class T8, class T9>
152 bool 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 }
173 template<class T1, class T2, class T3, class T4, class T5, class T6, class
174 T7, class T8, class T9, class T10>
175 bool 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
Generated by   doxygen 1.8.2