blocxx

StrictWeakOrdering.hpp

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