ceph/src/boost/libs/type_traits/test/has_binary_classes.hpp

   1 //  (C) Copyright Frederic Bron 2009-2011.
   2 //  Use, modification and distribution are subject to the
   3 //  Boost Software License, Version 1.0. (See accompanying file
   4 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   5
   6 #ifndef TT_HAS_BINARY_CLASSES_HPP
   7 #define TT_HAS_BINARY_CLASSES_HPP
   8
   9 struct ret { };
  10 ret ret_val;
  11
  12 class C000 { C000(); public: C000(int) { } };
  13 void operator+(C000, C000) { }
  14
  15 class C001 { C001(); public: C001(int) { } };
  16 ret  operator+(C001, C001) { return ret_val; }
  17
  18 class C002 { C002(); public: C002(int) { } };
  19 ret  const operator+(C002, C002) { return ret_val; }
  20
  21 class C005 { C005(); public: C005(int) { } };
  22 ret  & operator+(C005, C005) { return ret_val; }
  23
  24 class C006 { C006(); public: C006(int) { } };
  25 ret  const & operator+(C006, C006) { return ret_val; }
  26
  27 class C009 { C009(); public: C009(int) { } };
  28 void operator+(C009, C009 const) { }
  29
  30 class C010 { C010(); public: C010(int) { } };
  31 ret  operator+(C010, C010 const) { return ret_val; }
  32
  33 class C011 { C011(); public: C011(int) { } };
  34 ret  const operator+(C011, C011 const) { return ret_val; }
  35
  36 class C014 { C014(); public: C014(int) { } };
  37 ret  & operator+(C014, C014 const) { return ret_val; }
  38
  39 class C015 { C015(); public: C015(int) { } };
  40 ret  const & operator+(C015, C015 const) { return ret_val; }
  41
  42 class C036 { C036(); public: C036(int) { } };
  43 void operator+(C036, C036 &) { }
  44
  45 class C037 { C037(); public: C037(int) { } };
  46 ret  operator+(C037, C037 &) { return ret_val; }
  47
  48 class C038 { C038(); public: C038(int) { } };
  49 ret  const operator+(C038, C038 &) { return ret_val; }
  50
  51 class C041 { C041(); public: C041(int) { } };
  52 ret  & operator+(C041, C041 &) { return ret_val; }
  53
  54 class C042 { C042(); public: C042(int) { } };
  55 ret  const & operator+(C042, C042 &) { return ret_val; }
  56
  57 class C045 { C045(); public: C045(int) { } };
  58 void operator+(C045, C045 const &) { }
  59
  60 class C046 { C046(); public: C046(int) { } };
  61 ret  operator+(C046, C046 const &) { return ret_val; }
  62
  63 class C047 { C047(); public: C047(int) { } };
  64 ret  const operator+(C047, C047 const &) { return ret_val; }
  65
  66 class C050 { C050(); public: C050(int) { } };
  67 ret  & operator+(C050, C050 const &) { return ret_val; }
  68
  69 class C051 { C051(); public: C051(int) { } };
  70 ret  const & operator+(C051, C051 const &) { return ret_val; }
  71
  72 class C072 { C072(); public: C072(int) { } };
  73 void operator+(C072 const, C072) { }
  74
  75 class C073 { C073(); public: C073(int) { } };
  76 ret  operator+(C073 const, C073) { return ret_val; }
  77
  78 class C074 { C074(); public: C074(int) { } };
  79 ret  const operator+(C074 const, C074) { return ret_val; }
  80
  81 class C077 { C077(); public: C077(int) { } };
  82 ret  & operator+(C077 const, C077) { return ret_val; }
  83
  84 class C078 { C078(); public: C078(int) { } };
  85 ret  const & operator+(C078 const, C078) { return ret_val; }
  86
  87 class C081 { C081(); public: C081(int) { } };
  88 void operator+(C081 const, C081 const) { }
  89
  90 class C082 { C082(); public: C082(int) { } };
  91 ret  operator+(C082 const, C082 const) { return ret_val; }
  92
  93 class C083 { C083(); public: C083(int) { } };
  94 ret  const operator+(C083 const, C083 const) { return ret_val; }
  95
  96 class C086 { C086(); public: C086(int) { } };
  97 ret  & operator+(C086 const, C086 const) { return ret_val; }
  98
  99 class C087 { C087(); public: C087(int) { } };
 100 ret  const & operator+(C087 const, C087 const) { return ret_val; }
 101
 102 class C108 { C108(); public: C108(int) { } };
 103 void operator+(C108 const, C108 &) { }
 104
 105 class C109 { C109(); public: C109(int) { } };
 106 ret  operator+(C109 const, C109 &) { return ret_val; }
 107
 108 class C110 { C110(); public: C110(int) { } };
 109 ret  const operator+(C110 const, C110 &) { return ret_val; }
 110
 111 class C113 { C113(); public: C113(int) { } };
 112 ret  & operator+(C113 const, C113 &) { return ret_val; }
 113
 114 class C114 { C114(); public: C114(int) { } };
 115 ret  const & operator+(C114 const, C114 &) { return ret_val; }
 116
 117 class C117 { C117(); public: C117(int) { } };
 118 void operator+(C117 const, C117 const &) { }
 119
 120 class C118 { C118(); public: C118(int) { } };
 121 ret  operator+(C118 const, C118 const &) { return ret_val; }
 122
 123 class C119 { C119(); public: C119(int) { } };
 124 ret  const operator+(C119 const, C119 const &) { return ret_val; }
 125
 126 class C122 { C122(); public: C122(int) { } };
 127 ret  & operator+(C122 const, C122 const &) { return ret_val; }
 128
 129 class C123 { C123(); public: C123(int) { } };
 130 ret  const & operator+(C123 const, C123 const &) { return ret_val; }
 131
 132 class C288 { C288(); public: C288(int) { } };
 133 void operator+(C288 &, C288) { }
 134
 135 class C289 { C289(); public: C289(int) { } };
 136 ret  operator+(C289 &, C289) { return ret_val; }
 137
 138 class C290 { C290(); public: C290(int) { } };
 139 ret  const operator+(C290 &, C290) { return ret_val; }
 140
 141 class C293 { C293(); public: C293(int) { } };
 142 ret  & operator+(C293 &, C293) { return ret_val; }
 143
 144 class C294 { C294(); public: C294(int) { } };
 145 ret  const & operator+(C294 &, C294) { return ret_val; }
 146
 147 class C297 { C297(); public: C297(int) { } };
 148 void operator+(C297 &, C297 const) { }
 149
 150 class C298 { C298(); public: C298(int) { } };
 151 ret  operator+(C298 &, C298 const) { return ret_val; }
 152
 153 class C299 { C299(); public: C299(int) { } };
 154 ret  const operator+(C299 &, C299 const) { return ret_val; }
 155
 156 class C302 { C302(); public: C302(int) { } };
 157 ret  & operator+(C302 &, C302 const) { return ret_val; }
 158
 159 class C303 { C303(); public: C303(int) { } };
 160 ret  const & operator+(C303 &, C303 const) { return ret_val; }
 161
 162 class C324 { C324(); public: C324(int) { } };
 163 void operator+(C324 &, C324 &) { }
 164
 165 class C325 { C325(); public: C325(int) { } };
 166 ret  operator+(C325 &, C325 &) { return ret_val; }
 167
 168 class C326 { C326(); public: C326(int) { } };
 169 ret  const operator+(C326 &, C326 &) { return ret_val; }
 170
 171 class C329 { C329(); public: C329(int) { } };
 172 ret  & operator+(C329 &, C329 &) { return ret_val; }
 173
 174 class C330 { C330(); public: C330(int) { } };
 175 ret  const & operator+(C330 &, C330 &) { return ret_val; }
 176
 177 class C333 { C333(); public: C333(int) { } };
 178 void operator+(C333 &, C333 const &) { }
 179
 180 class C334 { C334(); public: C334(int) { } };
 181 ret  operator+(C334 &, C334 const &) { return ret_val; }
 182
 183 class C335 { C335(); public: C335(int) { } };
 184 ret  const operator+(C335 &, C335 const &) { return ret_val; }
 185
 186 class C338 { C338(); public: C338(int) { } };
 187 ret  & operator+(C338 &, C338 const &) { return ret_val; }
 188
 189 class C339 { C339(); public: C339(int) { } };
 190 ret  const & operator+(C339 &, C339 const &) { return ret_val; }
 191
 192 class C360 { C360(); public: C360(int) { } };
 193 void operator+(C360 const &, C360) { }
 194
 195 class C361 { C361(); public: C361(int) { } };
 196 ret  operator+(C361 const &, C361) { return ret_val; }
 197
 198 class C362 { C362(); public: C362(int) { } };
 199 ret  const operator+(C362 const &, C362) { return ret_val; }
 200
 201 class C365 { C365(); public: C365(int) { } };
 202 ret  & operator+(C365 const &, C365) { return ret_val; }
 203
 204 class C366 { C366(); public: C366(int) { } };
 205 ret  const & operator+(C366 const &, C366) { return ret_val; }
 206
 207 class C369 { C369(); public: C369(int) { } };
 208 void operator+(C369 const &, C369 const) { }
 209
 210 class C370 { C370(); public: C370(int) { } };
 211 ret  operator+(C370 const &, C370 const) { return ret_val; }
 212
 213 class C371 { C371(); public: C371(int) { } };
 214 ret  const operator+(C371 const &, C371 const) { return ret_val; }
 215
 216 class C374 { C374(); public: C374(int) { } };
 217 ret  & operator+(C374 const &, C374 const) { return ret_val; }
 218
 219 class C375 { C375(); public: C375(int) { } };
 220 ret  const & operator+(C375 const &, C375 const) { return ret_val; }
 221
 222 class C396 { C396(); public: C396(int) { } };
 223 void operator+(C396 const &, C396 &) { }
 224
 225 class C397 { C397(); public: C397(int) { } };
 226 ret  operator+(C397 const &, C397 &) { return ret_val; }
 227
 228 class C398 { C398(); public: C398(int) { } };
 229 ret  const operator+(C398 const &, C398 &) { return ret_val; }
 230
 231 class C401 { C401(); public: C401(int) { } };
 232 ret  & operator+(C401 const &, C401 &) { return ret_val; }
 233
 234 class C402 { C402(); public: C402(int) { } };
 235 ret  const & operator+(C402 const &, C402 &) { return ret_val; }
 236
 237 class C405 { C405(); public: C405(int) { } };
 238 void operator+(C405 const &, C405 const &) { }
 239
 240 class C406 { C406(); public: C406(int) { } };
 241 ret  operator+(C406 const &, C406 const &) { return ret_val; }
 242
 243 class C407 { C407(); public: C407(int) { } };
 244 ret  const operator+(C407 const &, C407 const &) { return ret_val; }
 245
 246 class C410 { C410(); public: C410(int) { } };
 247 ret  & operator+(C410 const &, C410 const &) { return ret_val; }
 248
 249 class C411 { C411(); public: C411(int) { } };
 250 ret  const & operator+(C411 const &, C411 const &) { return ret_val; }
 251
 252 #endif