ceph/src/boost/libs/vmd/include/boost/vmd/detail/equal.hpp

   1
   2 //  (C) Copyright Edward Diener 2011-2015
   3 //  Use, modification and distribution are subject to the Boost Software License,
   4 //  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
   5 //  http://www.boost.org/LICENSE_1_0.txt).
   6
   7 #if !defined(BOOST_VMD_DETAIL_EQUAL_HPP)
   8 #define BOOST_VMD_DETAIL_EQUAL_HPP
   9
  10 #include <boost/preprocessor/cat.hpp>
  11 #include <boost/preprocessor/detail/auto_rec.hpp>
  12 #include <boost/preprocessor/facilities/empty.hpp>
  13 #include <boost/preprocessor/facilities/overload.hpp>
  14 #include <boost/preprocessor/logical/compl.hpp>
  15 #include <boost/vmd/detail/recurse/equal/equal_headers.hpp>
  16 #include <boost/vmd/is_identifier.hpp>
  17 #include <boost/vmd/is_empty_list.hpp>
  18 #include <boost/vmd/detail/not_empty.hpp>
  19
  20 #include <boost/vmd/detail/recurse/equal/equal_1.hpp>
  21 #include <boost/vmd/detail/recurse/equal/equal_2.hpp>
  22 #include <boost/vmd/detail/recurse/equal/equal_3.hpp>
  23 #include <boost/vmd/detail/recurse/equal/equal_4.hpp>
  24 #include <boost/vmd/detail/recurse/equal/equal_5.hpp>
  25 #include <boost/vmd/detail/recurse/equal/equal_6.hpp>
  26 #include <boost/vmd/detail/recurse/equal/equal_7.hpp>
  27 #include <boost/vmd/detail/recurse/equal/equal_8.hpp>
  28 #include <boost/vmd/detail/recurse/equal/equal_9.hpp>
  29 #include <boost/vmd/detail/recurse/equal/equal_10.hpp>
  30 #include <boost/vmd/detail/recurse/equal/equal_11.hpp>
  31 #include <boost/vmd/detail/recurse/equal/equal_12.hpp>
  32 #include <boost/vmd/detail/recurse/equal/equal_13.hpp>
  33 #include <boost/vmd/detail/recurse/equal/equal_14.hpp>
  34 #include <boost/vmd/detail/recurse/equal/equal_15.hpp>
  35 #include <boost/vmd/detail/recurse/equal/equal_16.hpp>
  36
  37 #define BOOST_VMD_DETAIL_EQUAL_SIMPLE_D_1(d,vseq1,vseq2) BOOST_VMD_DETAIL_EQUAL_1_D(d,vseq1,vseq2)
  38 #define BOOST_VMD_DETAIL_EQUAL_SIMPLE_D_2(d,vseq1,vseq2) BOOST_VMD_DETAIL_EQUAL_2_D(d,vseq1,vseq2)
  39 #define BOOST_VMD_DETAIL_EQUAL_SIMPLE_D_3(d,vseq1,vseq2) BOOST_VMD_DETAIL_EQUAL_3_D(d,vseq1,vseq2)
  40 #define BOOST_VMD_DETAIL_EQUAL_SIMPLE_D_4(d,vseq1,vseq2) BOOST_VMD_DETAIL_EQUAL_4_D(d,vseq1,vseq2)
  41 #define BOOST_VMD_DETAIL_EQUAL_SIMPLE_D_5(d,vseq1,vseq2) BOOST_VMD_DETAIL_EQUAL_5_D(d,vseq1,vseq2)
  42 #define BOOST_VMD_DETAIL_EQUAL_SIMPLE_D_6(d,vseq1,vseq2) BOOST_VMD_DETAIL_EQUAL_6_D(d,vseq1,vseq2)
  43 #define BOOST_VMD_DETAIL_EQUAL_SIMPLE_D_7(d,vseq1,vseq2) BOOST_VMD_DETAIL_EQUAL_7_D(d,vseq1,vseq2)
  44 #define BOOST_VMD_DETAIL_EQUAL_SIMPLE_D_8(d,vseq1,vseq2) BOOST_VMD_DETAIL_EQUAL_8_D(d,vseq1,vseq2)
  45 #define BOOST_VMD_DETAIL_EQUAL_SIMPLE_D_9(d,vseq1,vseq2) BOOST_VMD_DETAIL_EQUAL_9_D(d,vseq1,vseq2)
  46 #define BOOST_VMD_DETAIL_EQUAL_SIMPLE_D_10(d,vseq1,vseq2) BOOST_VMD_DETAIL_EQUAL_10_D(d,vseq1,vseq2)
  47 #define BOOST_VMD_DETAIL_EQUAL_SIMPLE_D_11(d,vseq1,vseq2) BOOST_VMD_DETAIL_EQUAL_11_D(d,vseq1,vseq2)
  48 #define BOOST_VMD_DETAIL_EQUAL_SIMPLE_D_12(d,vseq1,vseq2) BOOST_VMD_DETAIL_EQUAL_12_D(d,vseq1,vseq2)
  49 #define BOOST_VMD_DETAIL_EQUAL_SIMPLE_D_13(d,vseq1,vseq2) BOOST_VMD_DETAIL_EQUAL_13_D(d,vseq1,vseq2)
  50 #define BOOST_VMD_DETAIL_EQUAL_SIMPLE_D_14(d,vseq1,vseq2) BOOST_VMD_DETAIL_EQUAL_14_D(d,vseq1,vseq2)
  51 #define BOOST_VMD_DETAIL_EQUAL_SIMPLE_D_15(d,vseq1,vseq2) BOOST_VMD_DETAIL_EQUAL_15_D(d,vseq1,vseq2)
  52 #define BOOST_VMD_DETAIL_EQUAL_SIMPLE_D_16(d,vseq1,vseq2) BOOST_VMD_DETAIL_EQUAL_16_D(d,vseq1,vseq2)
  53
  54 #define BOOST_VMD_DETAIL_EQUAL_SIMPLE_AUTO_REC_D(n) \
  55     BOOST_VMD_DETAIL_EQUAL_IS_1 \
  56         ( \
  57         BOOST_VMD_DETAIL_EQUAL_SIMPLE_D_ ## n(1,,) \
  58         ) \
  59 /**/
  60
  61 #define BOOST_VMD_DETAIL_EQUAL_SIMPLE_D \
  62     BOOST_PP_CAT \
  63         ( \
  64         BOOST_VMD_DETAIL_EQUAL_SIMPLE_D_, \
  65         BOOST_PP_AUTO_REC(BOOST_VMD_DETAIL_EQUAL_SIMPLE_AUTO_REC_D,16) \
  66         ) \
  67 /**/
  68
  69
  70 #define BOOST_VMD_DETAIL_EQUAL_CNI_CHK(vseq1,vseq2,vtype) \
  71     BOOST_PP_IIF \
  72         ( \
  73         BOOST_PP_BITOR \
  74             ( \
  75             BOOST_PP_BITOR \
  76                 ( \
  77                 BOOST_VMD_DETAIL_EQUAL_TYPE(vtype,BOOST_VMD_TYPE_ARRAY), \
  78                 BOOST_VMD_DETAIL_EQUAL_TYPE(vtype,BOOST_VMD_TYPE_LIST) \
  79                 ), \
  80             BOOST_PP_BITOR \
  81                 ( \
  82                 BOOST_VMD_DETAIL_EQUAL_TYPE(vtype,BOOST_VMD_TYPE_SEQ), \
  83                 BOOST_VMD_DETAIL_EQUAL_TYPE(vtype,BOOST_VMD_TYPE_TUPLE) \
  84                 ) \
  85             ), \
  86         BOOST_VMD_DETAIL_DATA_EQUAL, \
  87         BOOST_VMD_DETAIL_EQUAL_CNI_SMP \
  88         ) \
  89     (vseq1,vseq2,vtype) \
  90 /**/
  91
  92 #define BOOST_VMD_DETAIL_EQUAL_CNI_CHK_D(d,vseq1,vseq2,vtype) \
  93     BOOST_PP_IIF \
  94         ( \
  95         BOOST_PP_BITOR \
  96             ( \
  97             BOOST_PP_BITOR \
  98                 ( \
  99                 BOOST_VMD_DETAIL_EQUAL_TYPE_D(d,vtype,BOOST_VMD_TYPE_ARRAY), \
 100                 BOOST_VMD_DETAIL_EQUAL_TYPE_D(d,vtype,BOOST_VMD_TYPE_LIST) \
 101                 ), \
 102             BOOST_PP_BITOR \
 103                 ( \
 104                 BOOST_VMD_DETAIL_EQUAL_TYPE_D(d,vtype,BOOST_VMD_TYPE_SEQ), \
 105                 BOOST_VMD_DETAIL_EQUAL_TYPE_D(d,vtype,BOOST_VMD_TYPE_TUPLE) \
 106                 ) \
 107             ), \
 108         BOOST_VMD_DETAIL_DATA_EQUAL_D, \
 109         BOOST_VMD_DETAIL_EQUAL_CNI_SMP_D \
 110         ) \
 111     (d,vseq1,vseq2,vtype) \
 112 /**/
 113
 114 #define BOOST_VMD_DETAIL_EQUAL_VSEQ(vseq1,vseq2,vtype) \
 115     BOOST_VMD_DETAIL_DATA_EQUAL \
 116         ( \
 117         BOOST_VMD_TO_SEQ(vseq1), \
 118         BOOST_VMD_TO_SEQ(vseq2), \
 119         BOOST_VMD_TYPE_SEQ \
 120         ) \
 121 /**/
 122
 123 #define BOOST_VMD_DETAIL_EQUAL_VSEQ_D(d,vseq1,vseq2,vtype) \
 124     BOOST_VMD_DETAIL_DATA_EQUAL_D \
 125         ( \
 126         d, \
 127         BOOST_VMD_TO_SEQ_D(d,vseq1), \
 128         BOOST_VMD_TO_SEQ_D(d,vseq2), \
 129         BOOST_VMD_TYPE_SEQ \
 130         ) \
 131 /**/
 132
 133 #define BOOST_VMD_DETAIL_EQUAL_CNI(vseq1,vseq2,vtype) \
 134     BOOST_PP_IIF \
 135         ( \
 136         BOOST_VMD_DETAIL_EQUAL_TYPE \
 137             ( \
 138             vtype, \
 139             BOOST_VMD_TYPE_SEQUENCE \
 140             ), \
 141         BOOST_VMD_DETAIL_EQUAL_VSEQ, \
 142         BOOST_VMD_DETAIL_EQUAL_CNI_CHK \
 143         ) \
 144     (vseq1,vseq2,vtype) \
 145 /**/
 146
 147 #define BOOST_VMD_DETAIL_EQUAL_CNI_D(d,vseq1,vseq2,vtype) \
 148     BOOST_PP_IIF \
 149         ( \
 150         BOOST_VMD_DETAIL_EQUAL_TYPE_D \
 151             ( \
 152             d, \
 153             vtype, \
 154             BOOST_VMD_TYPE_SEQUENCE \
 155             ), \
 156         BOOST_VMD_DETAIL_EQUAL_VSEQ_D, \
 157         BOOST_VMD_DETAIL_EQUAL_CNI_CHK_D \
 158         ) \
 159     (d,vseq1,vseq2,vtype) \
 160 /**/
 161
 162 #define BOOST_VMD_DETAIL_EQUAL_TEST_TYPE_CHECK_TUPLE(vseq1,vtype1,type) \
 163     BOOST_PP_BITOR \
 164         ( \
 165         BOOST_VMD_DETAIL_EQUAL_TYPE \
 166             ( \
 167             BOOST_VMD_TYPE_ARRAY, \
 168             vtype1 \
 169             ), \
 170         BOOST_PP_BITAND \
 171             ( \
 172             BOOST_VMD_DETAIL_EQUAL_TYPE \
 173                 ( \
 174                 BOOST_VMD_TYPE_LIST, \
 175                 vtype1 \
 176                 ), \
 177             BOOST_PP_COMPL \
 178                 ( \
 179                 BOOST_VMD_IS_EMPTY_LIST(vseq1) \
 180                 ) \
 181             ) \
 182         ) \
 183 /**/
 184
 185 #define BOOST_VMD_DETAIL_EQUAL_TEST_TYPE_CHECK_TUPLE_D(d,vseq1,vtype1,type) \
 186     BOOST_PP_BITOR \
 187         ( \
 188         BOOST_VMD_DETAIL_EQUAL_TYPE_D \
 189             ( \
 190             d, \
 191             BOOST_VMD_TYPE_ARRAY, \
 192             vtype1 \
 193             ), \
 194         BOOST_PP_BITAND \
 195             ( \
 196             BOOST_VMD_DETAIL_EQUAL_TYPE_D \
 197                 ( \
 198                 d, \
 199                 BOOST_VMD_TYPE_LIST, \
 200                 vtype1 \
 201                 ), \
 202             BOOST_PP_COMPL \
 203                 ( \
 204                 BOOST_VMD_IS_EMPTY_LIST_D(d,vseq1) \
 205                 ) \
 206             ) \
 207         ) \
 208 /**/
 209
 210 #define BOOST_VMD_DETAIL_EQUAL_TEST_TYPE_CHECK_IDENTIFIER(vseq1,vtype1,type) \
 211     BOOST_VMD_IDENTITY_RESULT \
 212         ( \
 213         BOOST_PP_IIF \
 214             ( \
 215             BOOST_VMD_DETAIL_EQUAL_TYPE \
 216                 ( \
 217                 BOOST_VMD_TYPE_IDENTIFIER, \
 218                 type \
 219                 ), \
 220             BOOST_VMD_IS_IDENTIFIER, \
 221             BOOST_VMD_IDENTITY(0) \
 222             ) \
 223         (vseq1) \
 224         ) \
 225 /**/
 226
 227 #define BOOST_VMD_DETAIL_EQUAL_TEST_TYPE_CHECK_IDENTIFIER_D(d,vseq1,vtype1,type) \
 228     BOOST_VMD_IDENTITY_RESULT \
 229         ( \
 230         BOOST_PP_IIF \
 231             ( \
 232             BOOST_VMD_DETAIL_EQUAL_TYPE_D \
 233                 ( \
 234                 d, \
 235                 BOOST_VMD_TYPE_IDENTIFIER, \
 236                 type \
 237                 ), \
 238             BOOST_VMD_IS_IDENTIFIER_D, \
 239             BOOST_VMD_IDENTITY(0) \
 240             ) \
 241         (d,vseq1) \
 242         ) \
 243 /**/
 244
 245 #define BOOST_VMD_DETAIL_EQUAL_TEST_TYPE_CHECK(vseq1,vtype1,type) \
 246     BOOST_PP_IIF \
 247         ( \
 248         BOOST_VMD_DETAIL_EQUAL_TYPE \
 249             ( \
 250             BOOST_VMD_TYPE_TUPLE, \
 251             type \
 252             ), \
 253         BOOST_VMD_DETAIL_EQUAL_TEST_TYPE_CHECK_TUPLE, \
 254         BOOST_VMD_DETAIL_EQUAL_TEST_TYPE_CHECK_IDENTIFIER \
 255         ) \
 256     (vseq1,vtype1,type) \
 257 /**/
 258
 259 #define BOOST_VMD_DETAIL_EQUAL_TEST_TYPE_CHECK_D(d,vseq1,vtype1,type) \
 260     BOOST_PP_IIF \
 261         ( \
 262         BOOST_VMD_DETAIL_EQUAL_TYPE_D \
 263             ( \
 264             d, \
 265             BOOST_VMD_TYPE_TUPLE, \
 266             type \
 267             ), \
 268         BOOST_VMD_DETAIL_EQUAL_TEST_TYPE_CHECK_TUPLE_D, \
 269         BOOST_VMD_DETAIL_EQUAL_TEST_TYPE_CHECK_IDENTIFIER_D \
 270         ) \
 271     (d,vseq1,vtype1,type) \
 272 /**/
 273
 274 #define BOOST_VMD_DETAIL_EQUAL_TEST_TYPE(vseq1,vtype1,type) \
 275     BOOST_VMD_IDENTITY_RESULT \
 276         ( \
 277         BOOST_PP_IIF \
 278             ( \
 279             BOOST_VMD_DETAIL_EQUAL_TYPE \
 280                 ( \
 281                 vtype1, \
 282                 type \
 283                 ), \
 284             BOOST_VMD_IDENTITY(1), \
 285             BOOST_VMD_DETAIL_EQUAL_TEST_TYPE_CHECK \
 286             ) \
 287         (vseq1,vtype1,type)    \
 288         ) \
 289 /**/
 290
 291 #define BOOST_VMD_DETAIL_EQUAL_TEST_TYPE_D(d,vseq1,vtype1,type) \
 292     BOOST_VMD_IDENTITY_RESULT \
 293         ( \
 294         BOOST_PP_IIF \
 295             ( \
 296             BOOST_VMD_DETAIL_EQUAL_TYPE_D \
 297                 ( \
 298                 d, \
 299                 vtype1, \
 300                 type \
 301                 ), \
 302             BOOST_VMD_IDENTITY(1), \
 303             BOOST_VMD_DETAIL_EQUAL_TEST_TYPE_CHECK_D \
 304             ) \
 305         (d,vseq1,vtype1,type)    \
 306         ) \
 307 /**/
 308
 309 #define BOOST_VMD_DETAIL_EQUAL_WT_CHECK(vseq1,vseq2,vtype1,vtype2,type) \
 310     BOOST_VMD_IDENTITY_RESULT \
 311         ( \
 312         BOOST_PP_IIF \
 313             ( \
 314             BOOST_PP_BITAND \
 315                 ( \
 316                 BOOST_VMD_DETAIL_EQUAL_TYPE \
 317                     ( \
 318                     vtype1, \
 319                     vtype2 \
 320                     ), \
 321                 BOOST_VMD_IDENTITY_RESULT \
 322                     ( \
 323                     BOOST_PP_IIF \
 324                         ( \
 325                         BOOST_VMD_DETAIL_NOT_EMPTY(type), \
 326                         BOOST_VMD_DETAIL_EQUAL_TEST_TYPE, \
 327                         BOOST_VMD_IDENTITY(1) \
 328                         ) \
 329                     (vseq1,vtype1,type) \
 330                     ) \
 331                 ), \
 332             BOOST_VMD_DETAIL_EQUAL_CNI, \
 333             BOOST_VMD_IDENTITY(0) \
 334             ) \
 335         (vseq1,vseq2,vtype1) \
 336         ) \
 337 /**/
 338
 339 #define BOOST_VMD_DETAIL_EQUAL_WT_CHECK_D(d,vseq1,vseq2,vtype1,vtype2,type) \
 340     BOOST_VMD_IDENTITY_RESULT \
 341         ( \
 342         BOOST_PP_IIF \
 343             ( \
 344             BOOST_PP_BITAND \
 345                 ( \
 346                 BOOST_VMD_DETAIL_EQUAL_TYPE_D \
 347                     ( \
 348                     d, \
 349                     vtype1, \
 350                     vtype2 \
 351                     ), \
 352                 BOOST_VMD_IDENTITY_RESULT \
 353                     ( \
 354                     BOOST_PP_IIF \
 355                         ( \
 356                         BOOST_VMD_DETAIL_NOT_EMPTY(type), \
 357                         BOOST_VMD_DETAIL_EQUAL_TEST_TYPE_D, \
 358                         BOOST_VMD_IDENTITY(1) \
 359                         ) \
 360                     (d,vseq1,vtype1,type) \
 361                     ) \
 362                 ), \
 363             BOOST_VMD_DETAIL_EQUAL_CNI_D, \
 364             BOOST_VMD_IDENTITY(0) \
 365             ) \
 366         (d,vseq1,vseq2,vtype1) \
 367         ) \
 368 /**/
 369
 370 #define BOOST_VMD_DETAIL_EQUAL_WT_CONVERT(vseq1,vseq2,vtype1,vtype2,type) \
 371     BOOST_VMD_DETAIL_EQUAL_WT_CHECK \
 372         ( \
 373         vseq1, \
 374         vseq2, \
 375         BOOST_VMD_DETAIL_ADJUST_TUPLE_TYPE(vseq1,vtype1), \
 376         BOOST_VMD_DETAIL_ADJUST_TUPLE_TYPE(vseq2,vtype2), \
 377         type \
 378         ) \
 379 /**/
 380
 381 #define BOOST_VMD_DETAIL_EQUAL_WT_CONVERT_D(d,vseq1,vseq2,vtype1,vtype2,type) \
 382     BOOST_VMD_DETAIL_EQUAL_WT_CHECK_D \
 383         ( \
 384         d, \
 385         vseq1, \
 386         vseq2, \
 387         BOOST_VMD_DETAIL_ADJUST_TUPLE_TYPE_D(d,vseq1,vtype1), \
 388         BOOST_VMD_DETAIL_ADJUST_TUPLE_TYPE_D(d,vseq2,vtype2), \
 389         type \
 390         ) \
 391 /**/
 392
 393 #define BOOST_VMD_DETAIL_EQUAL_WT(vseq1,vseq2,vtype1,vtype2,type) \
 394     BOOST_VMD_IDENTITY_RESULT \
 395         ( \
 396         BOOST_PP_IIF \
 397             ( \
 398             BOOST_VMD_DETAIL_EQUAL_IS_TUPLE_MISMATCH(vseq1,vseq2,vtype1,vtype2), \
 399             BOOST_VMD_IDENTITY(0), \
 400             BOOST_VMD_DETAIL_EQUAL_WT_CONVERT \
 401             ) \
 402         (vseq1,vseq2,vtype1,vtype2,type) \
 403         ) \
 404 /**/
 405
 406 #define BOOST_VMD_DETAIL_EQUAL_WT_D(d,vseq1,vseq2,vtype1,vtype2,type) \
 407     BOOST_VMD_IDENTITY_RESULT \
 408         ( \
 409         BOOST_PP_IIF \
 410             ( \
 411             BOOST_VMD_DETAIL_EQUAL_IS_TUPLE_MISMATCH_D(d,vseq1,vseq2,vtype1,vtype2), \
 412             BOOST_VMD_IDENTITY(0), \
 413             BOOST_VMD_DETAIL_EQUAL_WT_CONVERT_D \
 414             ) \
 415         (d,vseq1,vseq2,vtype1,vtype2,type) \
 416         ) \
 417 /**/
 418
 419 #define BOOST_VMD_DETAIL_EQUAL_GTYPE(vseq1,vseq2,type) \
 420     BOOST_VMD_DETAIL_EQUAL_WT \
 421         ( \
 422         vseq1, \
 423         vseq2, \
 424         BOOST_VMD_GET_TYPE(vseq1,BOOST_VMD_RETURN_TYPE_TUPLE), \
 425         BOOST_VMD_GET_TYPE(vseq2,BOOST_VMD_RETURN_TYPE_TUPLE), \
 426         type \
 427         ) \
 428 /**/
 429
 430 #define BOOST_VMD_DETAIL_EQUAL_GTYPE_D(d,vseq1,vseq2,type) \
 431     BOOST_VMD_DETAIL_EQUAL_WT_D \
 432         ( \
 433         d, \
 434         vseq1, \
 435         vseq2, \
 436         BOOST_VMD_GET_TYPE_D(d,vseq1,BOOST_VMD_RETURN_TYPE_TUPLE), \
 437         BOOST_VMD_GET_TYPE_D(d,vseq2,BOOST_VMD_RETURN_TYPE_TUPLE), \
 438         type \
 439         ) \
 440 /**/
 441
 442 #define BOOST_VMD_DETAIL_EQUAL_EBP(vseq1,vseq2,be1,be2,type) \
 443     BOOST_VMD_IDENTITY_RESULT \
 444         ( \
 445         BOOST_PP_IIF \
 446             ( \
 447             BOOST_PP_BITAND \
 448                 ( \
 449                 BOOST_VMD_DETAIL_EQUAL_CHK_MATCH(be1,be2), \
 450                 BOOST_VMD_DETAIL_EQUAL_CHK_PARENS_MATCH(vseq1,vseq2) \
 451                 ), \
 452             BOOST_VMD_DETAIL_EQUAL_GTYPE, \
 453             BOOST_VMD_IDENTITY(0) \
 454             ) \
 455         (vseq1,vseq2,type) \
 456         ) \
 457 /**/
 458
 459 #define BOOST_VMD_DETAIL_EQUAL_EBP_D(d,vseq1,vseq2,be1,be2,type) \
 460     BOOST_VMD_IDENTITY_RESULT \
 461         ( \
 462         BOOST_PP_IIF \
 463             ( \
 464             BOOST_PP_BITAND \
 465                 ( \
 466                 BOOST_VMD_DETAIL_EQUAL_CHK_MATCH(be1,be2), \
 467                 BOOST_VMD_DETAIL_EQUAL_CHK_PARENS_MATCH(vseq1,vseq2) \
 468                 ), \
 469             BOOST_VMD_DETAIL_EQUAL_GTYPE_D, \
 470             BOOST_VMD_IDENTITY(0) \
 471             ) \
 472         (d,vseq1,vseq2,type) \
 473         ) \
 474 /**/
 475
 476 #define BOOST_VMD_DETAIL_EQUAL_EMPTY(vseq1,vseq2,be1,be2,type) \
 477     BOOST_PP_IIF \
 478         ( \
 479         BOOST_PP_BITAND(be1,be2), \
 480         BOOST_VMD_DETAIL_EQUAL_BOTH_EMPTY, \
 481         BOOST_VMD_DETAIL_EQUAL_EBP \
 482         ) \
 483     (vseq1,vseq2,be1,be2,type) \
 484 /**/
 485
 486 #define BOOST_VMD_DETAIL_EQUAL_EMPTY_D(d,vseq1,vseq2,be1,be2,type) \
 487     BOOST_PP_IIF \
 488         ( \
 489         BOOST_PP_BITAND(be1,be2), \
 490         BOOST_VMD_DETAIL_EQUAL_BOTH_EMPTY, \
 491         BOOST_VMD_DETAIL_EQUAL_EBP_D \
 492         ) \
 493     (d,vseq1,vseq2,be1,be2,type) \
 494 /**/
 495
 496 #define BOOST_VMD_DETAIL_EQUAL_OV1(vseq1,vseq2) \
 497     BOOST_VMD_DETAIL_EQUAL_EMPTY \
 498         ( \
 499         vseq1, \
 500         vseq2, \
 501         BOOST_VMD_IS_EMPTY(vseq1), \
 502         BOOST_VMD_IS_EMPTY(vseq2), \
 503         ) \
 504 /**/
 505
 506 #define BOOST_VMD_DETAIL_EQUAL_OV2(vseq1,vseq2,type) \
 507     BOOST_VMD_DETAIL_EQUAL_EMPTY \
 508         ( \
 509         vseq1, \
 510         vseq2, \
 511         BOOST_VMD_IS_EMPTY(vseq1), \
 512         BOOST_VMD_IS_EMPTY(vseq2), \
 513         type \
 514         ) \
 515 /**/
 516
 517 #define BOOST_VMD_DETAIL_EQUAL_D_OV1(d,vseq1,vseq2) \
 518     BOOST_VMD_DETAIL_EQUAL_EMPTY_D \
 519         ( \
 520         d, \
 521         vseq1, \
 522         vseq2, \
 523         BOOST_VMD_IS_EMPTY(vseq1), \
 524         BOOST_VMD_IS_EMPTY(vseq2), \
 525         ) \
 526 /**/
 527
 528 #define BOOST_VMD_DETAIL_EQUAL_D_OV2(d,vseq1,vseq2,type) \
 529     BOOST_VMD_DETAIL_EQUAL_EMPTY_D \
 530         ( \
 531         d, \
 532         vseq1, \
 533         vseq2, \
 534         BOOST_VMD_IS_EMPTY(vseq1), \
 535         BOOST_VMD_IS_EMPTY(vseq2), \
 536         type \
 537         ) \
 538 /**/
 539
 540 #if BOOST_VMD_MSVC
 541
 542 #define BOOST_VMD_DETAIL_EQUAL(vseq1,...) \
 543     BOOST_PP_CAT(BOOST_PP_OVERLOAD(BOOST_VMD_DETAIL_EQUAL_OV,__VA_ARGS__)(vseq1,__VA_ARGS__),BOOST_PP_EMPTY()) \
 544 /**/
 545
 546 #define BOOST_VMD_DETAIL_EQUAL_D(d,vseq1,...) \
 547     BOOST_PP_CAT(BOOST_PP_OVERLOAD(BOOST_VMD_DETAIL_EQUAL_D_OV,__VA_ARGS__)(d,vseq1,__VA_ARGS__),BOOST_PP_EMPTY()) \
 548 /**/
 549
 550 #else
 551
 552 #define BOOST_VMD_DETAIL_EQUAL(vseq1,...) \
 553     BOOST_PP_OVERLOAD(BOOST_VMD_DETAIL_EQUAL_OV,__VA_ARGS__)(vseq1,__VA_ARGS__) \
 554 /**/
 555
 556 #define BOOST_VMD_DETAIL_EQUAL_D(d,vseq1,...) \
 557     BOOST_PP_OVERLOAD(BOOST_VMD_DETAIL_EQUAL_D_OV,__VA_ARGS__)(d,vseq1,__VA_ARGS__) \
 558 /**/
 559
 560 #endif
 561
 562 #endif /* BOOST_VMD_DETAIL_EQUAL_HPP */