StrictWeakOrdering.hpp

Go to the documentation of this file.
00001 /*******************************************************************************
00002 * Copyright (C) 2004 Vintela, Inc. All rights reserved.
00003 * Copyright (C) 2005 Novell, Inc. All rights reserved.
00004 *
00005 * Redistribution and use in source and binary forms, with or without
00006 * modification, are permitted provided that the following conditions are met:
00007 *
00008 *  - Redistributions of source code must retain the above copyright notice,
00009 *    this list of conditions and the following disclaimer.
00010 *
00011 *  - Redistributions in binary form must reproduce the above copyright notice,
00012 *    this list of conditions and the following disclaimer in the documentation
00013 *    and/or other materials provided with the distribution.
00014 *
00015 *  - Neither the name of Vintela, Inc., Novell, Inc., nor the names of its
00016 *    contributors may be used to endorse or promote products derived from this
00017 *    software without specific prior written permission.
00018 *
00019 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
00020 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
00021 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
00022 * ARE DISCLAIMED. IN NO EVENT SHALL Vintela, Inc., Novell, Inc., OR THE 
00023 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
00024 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 
00025 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 
00026 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
00027 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
00028 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
00029 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00030 *******************************************************************************/
00031 
00032 
00037 #ifndef BLOCXX_STRICT_WEAK_ORDERING_HPP_INCLUDE_GUARD_
00038 #define BLOCXX_STRICT_WEAK_ORDERING_HPP_INCLUDE_GUARD_
00039 #include "blocxx/BLOCXX_config.h"
00040 
00041 namespace BLOCXX_NAMESPACE
00042 {
00043 
00044 template<class T1>
00045 bool StrictWeakOrdering(const T1& lhs1, const T1& rhs1)
00046 {
00047    return lhs1 < rhs1;
00048 }
00049 template<class T1, class T2>
00050 bool StrictWeakOrdering(const T1& lhs1, const T1& rhs1,
00051       const T2& lhs2, const T2& rhs2)
00052 {
00053    if (lhs1 < rhs1) return true;
00054    else if (rhs1 < lhs1) return false;
00055    else return StrictWeakOrdering(lhs2, rhs2);
00056 }
00057 template<class T1, class T2, class T3>
00058 bool StrictWeakOrdering(const T1& lhs1, const T1& rhs1,
00059       const T2& lhs2, const T2& rhs2,
00060       const T3& lhs3, const T3& rhs3)
00061 {
00062    if (lhs1 < rhs1) return true;
00063    else if (rhs1 < lhs1) return false;
00064    else return StrictWeakOrdering(lhs2, rhs2,
00065          lhs3, rhs3);
00066 }
00067 template<class T1, class T2, class T3, class T4>
00068 bool StrictWeakOrdering(const T1& lhs1, const T1& rhs1,
00069       const T2& lhs2, const T2& rhs2,
00070       const T3& lhs3, const T3& rhs3,
00071       const T4& lhs4, const T4& rhs4)
00072 {
00073    if (lhs1 < rhs1) return true;
00074    else if (rhs1 < lhs1) return false;
00075    else return StrictWeakOrdering(lhs2, rhs2,
00076          lhs3, rhs3,
00077          lhs4, rhs4);
00078 }
00079 template<class T1, class T2, class T3, class T4, class T5>
00080 bool StrictWeakOrdering(const T1& lhs1, const T1& rhs1,
00081       const T2& lhs2, const T2& rhs2,
00082       const T3& lhs3, const T3& rhs3,
00083       const T4& lhs4, const T4& rhs4,
00084       const T5& lhs5, const T5& rhs5)
00085 {
00086    if (lhs1 < rhs1) return true;
00087    else if (rhs1 < lhs1) return false;
00088    else return StrictWeakOrdering(lhs2, rhs2,
00089          lhs3, rhs3,
00090          lhs4, rhs4,
00091          lhs5, rhs5);
00092 }
00093 template<class T1, class T2, class T3, class T4, class T5, class T6>
00094 bool StrictWeakOrdering(const T1& lhs1, const T1& rhs1,
00095       const T2& lhs2, const T2& rhs2,
00096       const T3& lhs3, const T3& rhs3,
00097       const T4& lhs4, const T4& rhs4,
00098       const T5& lhs5, const T5& rhs5,
00099       const T6& lhs6, const T6& rhs6)
00100 {
00101    if (lhs1 < rhs1) return true;
00102    else if (rhs1 < lhs1) return false;
00103    else return StrictWeakOrdering(lhs2, rhs2,
00104          lhs3, rhs3,
00105          lhs4, rhs4,
00106          lhs5, rhs5,
00107          lhs6, rhs6);
00108 }
00109 template<class T1, class T2, class T3, class T4, class T5, class T6, class
00110 T7>
00111 bool StrictWeakOrdering(const T1& lhs1, const T1& rhs1,
00112       const T2& lhs2, const T2& rhs2,
00113       const T3& lhs3, const T3& rhs3,
00114       const T4& lhs4, const T4& rhs4,
00115       const T5& lhs5, const T5& rhs5,
00116       const T6& lhs6, const T6& rhs6,
00117       const T7& lhs7, const T7& rhs7)
00118 {
00119    if (lhs1 < rhs1) return true;
00120    else if (rhs1 < lhs1) return false;
00121    else return StrictWeakOrdering(lhs2, rhs2,
00122          lhs3, rhs3,
00123          lhs4, rhs4,
00124          lhs5, rhs5,
00125          lhs6, rhs6,
00126          lhs7, rhs7);
00127 }
00128 template<class T1, class T2, class T3, class T4, class T5, class T6, class
00129 T7, class T8>
00130 bool StrictWeakOrdering(const T1& lhs1, const T1& rhs1,
00131       const T2& lhs2, const T2& rhs2,
00132       const T3& lhs3, const T3& rhs3,
00133       const T4& lhs4, const T4& rhs4,
00134       const T5& lhs5, const T5& rhs5,
00135       const T6& lhs6, const T6& rhs6,
00136       const T7& lhs7, const T7& rhs7,
00137       const T8& lhs8, const T8& rhs8)
00138 {
00139    if (lhs1 < rhs1) return true;
00140    else if (rhs1 < lhs1) return false;
00141    else return StrictWeakOrdering(lhs2, rhs2,
00142          lhs3, rhs3,
00143          lhs4, rhs4,
00144          lhs5, rhs5,
00145          lhs6, rhs6,
00146          lhs7, rhs7,
00147          lhs8, rhs8);
00148 }
00149 template<class T1, class T2, class T3, class T4, class T5, class T6, class
00150 T7, class T8, class T9>
00151 bool StrictWeakOrdering(const T1& lhs1, const T1& rhs1,
00152       const T2& lhs2, const T2& rhs2,
00153       const T3& lhs3, const T3& rhs3,
00154       const T4& lhs4, const T4& rhs4,
00155       const T5& lhs5, const T5& rhs5,
00156       const T6& lhs6, const T6& rhs6,
00157       const T7& lhs7, const T7& rhs7,
00158       const T8& lhs8, const T8& rhs8,
00159       const T9& lhs9, const T9& rhs9)
00160 {
00161    if (lhs1 < rhs1) return true;
00162    else if (rhs1 < lhs1) return false;
00163    else return StrictWeakOrdering(lhs2, rhs2,
00164          lhs3, rhs3,
00165          lhs4, rhs4,
00166          lhs5, rhs5,
00167          lhs6, rhs6,
00168          lhs7, rhs7,
00169          lhs8, rhs8,
00170          lhs9, rhs9);
00171 }
00172 template<class T1, class T2, class T3, class T4, class T5, class T6, class
00173 T7, class T8, class T9, class T10>
00174 bool StrictWeakOrdering(const T1& lhs1, const T1& rhs1,
00175       const T2& lhs2, const T2& rhs2,
00176       const T3& lhs3, const T3& rhs3,
00177       const T4& lhs4, const T4& rhs4,
00178       const T5& lhs5, const T5& rhs5,
00179       const T6& lhs6, const T6& rhs6,
00180       const T7& lhs7, const T7& rhs7,
00181       const T8& lhs8, const T8& rhs8,
00182       const T9& lhs9, const T9& rhs9,
00183       const T10& lhs10, const T10& rhs10)
00184 {
00185    if (lhs1 < rhs1) return true;
00186    else if (rhs1 < lhs1) return false;
00187    else return StrictWeakOrdering(lhs2, rhs2,
00188          lhs3, rhs3,
00189          lhs4, rhs4,
00190          lhs5, rhs5,
00191          lhs6, rhs6,
00192          lhs7, rhs7,
00193          lhs8, rhs8,
00194          lhs9, rhs9,
00195          lhs10, rhs10);
00196 }
00197 
00198 } // end namespace BLOCXX_NAMESPACE
00199 
00200 #endif

Generated on Fri Jun 16 15:39:09 2006 for blocxx by  doxygen 1.4.6