ceph/src/boost/libs/unordered/test/objects/exception.hpp

   1
   2 // Copyright 2006-2009 Daniel James.
   3 // Distributed under the Boost Software License, Version 1.0. (See accompanying
   4 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   5
   6 #if !defined(BOOST_UNORDERED_EXCEPTION_TEST_OBJECTS_HEADER)
   7 #define BOOST_UNORDERED_EXCEPTION_TEST_OBJECTS_HEADER
   8
   9 #include "../helpers/exception_test.hpp"
  10
  11 #include <cstddef>
  12 #include <iostream>
  13 #include <boost/limits.hpp>
  14 #include <new>
  15 #include "../helpers/fwd.hpp"
  16 #include "../helpers/memory.hpp"
  17
  18 namespace test
  19 {
  20 namespace exception
  21 {
  22     class object;
  23     class hash;
  24     class equal_to;
  25     template <class T> class allocator;
  26     object generate(object const*, random_generator);
  27
  28     struct true_type
  29     {
  30         enum { value = true };
  31     };
  32
  33     struct false_type
  34     {
  35         enum { value = false };
  36     };
  37
  38     class object
  39     {
  40     public:
  41         int tag1_, tag2_;
  42
  43         explicit object() : tag1_(0), tag2_(0)
  44         {
  45             UNORDERED_SCOPE(object::object()) {
  46                 UNORDERED_EPOINT("Mock object default constructor.");
  47             }
  48         }
  49
  50         explicit object(int t1, int t2 = 0) : tag1_(t1), tag2_(t2)
  51         {
  52             UNORDERED_SCOPE(object::object(int)) {
  53                 UNORDERED_EPOINT("Mock object constructor by value.");
  54             }
  55         }
  56
  57         object(object const& x)
  58              : tag1_(x.tag1_), tag2_(x.tag2_)
  59         {
  60             UNORDERED_SCOPE(object::object(object)) {
  61                 UNORDERED_EPOINT("Mock object copy constructor.");
  62             }
  63         }
  64
  65         ~object() {
  66             tag1_ = -1;
  67             tag2_ = -1;
  68         }
  69
  70         object& operator=(object const& x)
  71         {
  72             UNORDERED_SCOPE(object::operator=(object)) {
  73                 tag1_ = x.tag1_;
  74                 UNORDERED_EPOINT("Mock object assign operator 1.");
  75                 tag2_ = x.tag2_;
  76                 //UNORDERED_EPOINT("Mock object assign operator 2.");
  77             }
  78             return *this;
  79         }
  80
  81         friend bool operator==(object const& x1, object const& x2) {
  82             UNORDERED_SCOPE(operator==(object, object)) {
  83                 UNORDERED_EPOINT("Mock object equality operator.");
  84             }
  85
  86             return x1.tag1_ == x2.tag1_ && x1.tag2_ == x2.tag2_;
  87         }
  88
  89         friend bool operator!=(object const& x1, object const& x2) {
  90             UNORDERED_SCOPE(operator!=(object, object)) {
  91                 UNORDERED_EPOINT("Mock object inequality operator.");
  92             }
  93
  94             return !(x1.tag1_ == x2.tag1_ && x1.tag2_ == x2.tag2_);
  95         }
  96
  97         // None of the last few functions are used by the unordered associative
  98         // containers - so there aren't any exception points.
  99         friend bool operator<(object const& x1, object const& x2) {
 100             return x1.tag1_ < x2.tag1_ ||
 101                 (x1.tag1_ == x2.tag1_ && x1.tag2_ < x2.tag2_);
 102         }
 103
 104         friend object generate(object const*, random_generator g) {
 105             int* x = 0;
 106             return object(::test::generate(x, g), ::test::generate(x, g));
 107         }
 108
 109         friend std::ostream& operator<<(std::ostream& out, object const& o)
 110         {
 111             return out<<"("<<o.tag1_<<","<<o.tag2_<<")";
 112         }
 113     };
 114
 115     class hash
 116     {
 117         int tag_;
 118     public:
 119         hash(int t = 0) : tag_(t)
 120         {
 121             UNORDERED_SCOPE(hash::object()) {
 122                 UNORDERED_EPOINT("Mock hash default constructor.");
 123             }
 124         }
 125
 126         hash(hash const& x)
 127             : tag_(x.tag_)
 128         {
 129             UNORDERED_SCOPE(hash::hash(hash)) {
 130                 UNORDERED_EPOINT("Mock hash copy constructor.");
 131             }
 132         }
 133
 134         hash& operator=(hash const& x)
 135         {
 136             UNORDERED_SCOPE(hash::operator=(hash)) {
 137                 UNORDERED_EPOINT("Mock hash assign operator 1.");
 138                 tag_ = x.tag_;
 139                 UNORDERED_EPOINT("Mock hash assign operator 2.");
 140             }
 141             return *this;
 142         }
 143
 144         std::size_t operator()(object const& x) const {
 145             UNORDERED_SCOPE(hash::operator()(object)) {
 146                 UNORDERED_EPOINT("Mock hash function.");
 147             }
 148
 149             int result;
 150             switch(tag_) {
 151             case 1:
 152                 result = x.tag1_;
 153                 break;
 154             case 2:
 155                 result = x.tag2_;
 156                 break;
 157             default:
 158                 result = x.tag1_ + x.tag2_;
 159             }
 160             return static_cast<std::size_t>(result);
 161         }
 162
 163         friend bool operator==(hash const& x1, hash const& x2) {
 164             UNORDERED_SCOPE(operator==(hash, hash)) {
 165                 UNORDERED_EPOINT("Mock hash equality function.");
 166             }
 167             return x1.tag_ == x2.tag_;
 168         }
 169
 170         friend bool operator!=(hash const& x1, hash const& x2) {
 171             UNORDERED_SCOPE(hash::operator!=(hash, hash)) {
 172                 UNORDERED_EPOINT("Mock hash inequality function.");
 173             }
 174             return x1.tag_ != x2.tag_;
 175         }
 176     };
 177
 178     class equal_to
 179     {
 180         int tag_;
 181     public:
 182         equal_to(int t = 0) : tag_(t)
 183         {
 184             UNORDERED_SCOPE(equal_to::equal_to()) {
 185                 UNORDERED_EPOINT("Mock equal_to default constructor.");
 186             }
 187         }
 188
 189         equal_to(equal_to const& x)
 190             : tag_(x.tag_)
 191         {
 192             UNORDERED_SCOPE(equal_to::equal_to(equal_to)) {
 193                 UNORDERED_EPOINT("Mock equal_to copy constructor.");
 194             }
 195         }
 196
 197         equal_to& operator=(equal_to const& x)
 198         {
 199             UNORDERED_SCOPE(equal_to::operator=(equal_to)) {
 200                 UNORDERED_EPOINT("Mock equal_to assign operator 1.");
 201                 tag_ = x.tag_;
 202                 UNORDERED_EPOINT("Mock equal_to assign operator 2.");
 203             }
 204             return *this;
 205         }
 206
 207         bool operator()(object const& x1, object const& x2) const {
 208             UNORDERED_SCOPE(equal_to::operator()(object, object)) {
 209                 UNORDERED_EPOINT("Mock equal_to function.");
 210             }
 211
 212             switch(tag_) {
 213             case 1:
 214                 return x1.tag1_ == x2.tag1_;
 215             case 2:
 216                 return x1.tag2_ == x2.tag2_;
 217             default:
 218                 return x1 == x2;
 219             }
 220         }
 221
 222         friend bool operator==(equal_to const& x1, equal_to const& x2) {
 223             UNORDERED_SCOPE(operator==(equal_to, equal_to)) {
 224                 UNORDERED_EPOINT("Mock equal_to equality function.");
 225             }
 226             return x1.tag_ == x2.tag_;
 227         }
 228
 229         friend bool operator!=(equal_to const& x1, equal_to const& x2) {
 230             UNORDERED_SCOPE(operator!=(equal_to, equal_to)) {
 231                 UNORDERED_EPOINT("Mock equal_to inequality function.");
 232             }
 233             return x1.tag_ != x2.tag_;
 234         }
 235     };
 236
 237     template <class T>
 238     class allocator
 239     {
 240     public:
 241         int tag_;
 242         typedef std::size_t size_type;
 243         typedef std::ptrdiff_t difference_type;
 244         typedef T* pointer;
 245         typedef T const* const_pointer;
 246         typedef T& reference;
 247         typedef T const& const_reference;
 248         typedef T value_type;
 249
 250         template <class U> struct rebind { typedef allocator<U> other; };
 251
 252         explicit allocator(int t = 0) : tag_(t)
 253         {
 254             UNORDERED_SCOPE(allocator::allocator()) {
 255                 UNORDERED_EPOINT("Mock allocator default constructor.");
 256             }
 257             test::detail::tracker.allocator_ref();
 258         }
 259
 260         template <class Y> allocator(allocator<Y> const& x) : tag_(x.tag_)
 261         {
 262             UNORDERED_SCOPE(allocator::allocator()) {
 263                 UNORDERED_EPOINT("Mock allocator template copy constructor.");
 264             }
 265             test::detail::tracker.allocator_ref();
 266         }
 267
 268         allocator(allocator const& x) : tag_(x.tag_)
 269         {
 270             UNORDERED_SCOPE(allocator::allocator()) {
 271                 UNORDERED_EPOINT("Mock allocator copy constructor.");
 272             }
 273             test::detail::tracker.allocator_ref();
 274         }
 275
 276         ~allocator() {
 277             test::detail::tracker.allocator_unref();
 278         }
 279
 280         allocator& operator=(allocator const& x) {
 281             UNORDERED_SCOPE(allocator::allocator()) {
 282                 UNORDERED_EPOINT("Mock allocator assignment operator.");
 283                 tag_ = x.tag_;
 284             }
 285             return *this;
 286         }
 287
 288         // If address throws, then it can't be used in erase or the
 289         // destructor, which is very limiting. I need to check up on
 290         // this.
 291
 292         pointer address(reference r) {
 293             //UNORDERED_SCOPE(allocator::address(reference)) {
 294             //    UNORDERED_EPOINT("Mock allocator address function.");
 295             //}
 296             return pointer(&r);
 297         }
 298
 299         const_pointer address(const_reference r)  {
 300             //UNORDERED_SCOPE(allocator::address(const_reference)) {
 301             //    UNORDERED_EPOINT("Mock allocator const address function.");
 302             //}
 303             return const_pointer(&r);
 304         }
 305
 306         pointer allocate(size_type n) {
 307             T* ptr = 0;
 308             UNORDERED_SCOPE(allocator::allocate(size_type)) {
 309                 UNORDERED_EPOINT("Mock allocator allocate function.");
 310
 311                 using namespace std;
 312                 ptr = (T*) malloc(n * sizeof(T));
 313                 if(!ptr) throw std::bad_alloc();
 314             }
 315             test::detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
 316             return pointer(ptr);
 317
 318             //return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
 319         }
 320
 321         pointer allocate(size_type n, void const*)
 322         {
 323             T* ptr = 0;
 324             UNORDERED_SCOPE(allocator::allocate(size_type, const_pointer)) {
 325                 UNORDERED_EPOINT("Mock allocator allocate function.");
 326
 327                 using namespace std;
 328                 ptr = (T*) malloc(n * sizeof(T));
 329                 if(!ptr) throw std::bad_alloc();
 330             }
 331             test::detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
 332             return pointer(ptr);
 333
 334             //return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
 335         }
 336
 337         void deallocate(pointer p, size_type n)
 338         {
 339             //::operator delete((void*) p);
 340             if(p) {
 341                 test::detail::tracker.track_deallocate((void*) p, n, sizeof(T), tag_);
 342                 using namespace std;
 343                 free(p);
 344             }
 345         }
 346
 347         void construct(pointer p, T const& t) {
 348             UNORDERED_SCOPE(allocator::construct(T*, T)) {
 349                 UNORDERED_EPOINT("Mock allocator construct function.");
 350                 new(p) T(t);
 351             }
 352             test::detail::tracker.track_construct((void*) p, sizeof(T), tag_);
 353         }
 354
 355 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 356         template<class... Args> void construct(T* p, BOOST_FWD_REF(Args)... args) {
 357             UNORDERED_SCOPE(allocator::construct(pointer, BOOST_FWD_REF(Args)...)) {
 358                 UNORDERED_EPOINT("Mock allocator construct function.");
 359                 new(p) T(boost::forward<Args>(args)...);
 360             }
 361             test::detail::tracker.track_construct((void*) p, sizeof(T), tag_);
 362         }
 363 #endif
 364
 365         void destroy(T* p) {
 366             test::detail::tracker.track_destroy((void*) p, sizeof(T), tag_);
 367             p->~T();
 368         }
 369
 370         size_type max_size() const {
 371             UNORDERED_SCOPE(allocator::construct(pointer, T)) {
 372                 UNORDERED_EPOINT("Mock allocator max_size function.");
 373             }
 374             return (std::numeric_limits<std::size_t>::max)();
 375         }
 376
 377         typedef true_type propagate_on_container_copy_assignment;
 378         typedef true_type propagate_on_container_move_assignment;
 379         typedef true_type propagate_on_container_swap;
 380     };
 381
 382     template <class T>
 383     void swap(allocator<T>& x, allocator<T>& y)
 384     {
 385         std::swap(x.tag_, y.tag_);
 386     }
 387
 388     // It's pretty much impossible to write a compliant swap when these
 389     // two can throw. So they don't.
 390
 391     template <class T>
 392     inline bool operator==(allocator<T> const& x, allocator<T> const& y)
 393     {
 394         //UNORDERED_SCOPE(operator==(allocator, allocator)) {
 395         //    UNORDERED_EPOINT("Mock allocator equality operator.");
 396         //}
 397         return x.tag_ == y.tag_;
 398     }
 399
 400     template <class T>
 401     inline bool operator!=(allocator<T> const& x, allocator<T> const& y)
 402     {
 403         //UNORDERED_SCOPE(operator!=(allocator, allocator)) {
 404         //    UNORDERED_EPOINT("Mock allocator inequality operator.");
 405         //}
 406         return x.tag_ != y.tag_;
 407     }
 408
 409     template <class T>
 410     class allocator2
 411     {
 412     public:
 413         int tag_;
 414         typedef std::size_t size_type;
 415         typedef std::ptrdiff_t difference_type;
 416         typedef T* pointer;
 417         typedef T const* const_pointer;
 418         typedef T& reference;
 419         typedef T const& const_reference;
 420         typedef T value_type;
 421
 422         template <class U> struct rebind { typedef allocator2<U> other; };
 423
 424         explicit allocator2(int t = 0) : tag_(t)
 425         {
 426             UNORDERED_SCOPE(allocator2::allocator2()) {
 427                 UNORDERED_EPOINT("Mock allocator2 default constructor.");
 428             }
 429             test::detail::tracker.allocator_ref();
 430         }
 431
 432         allocator2(allocator<T> const& x) : tag_(x.tag_)
 433         {
 434             UNORDERED_SCOPE(allocator2::allocator2()) {
 435                 UNORDERED_EPOINT("Mock allocator2 constructor from allocator.");
 436             }
 437             test::detail::tracker.allocator_ref();
 438         }
 439
 440         template <class Y> allocator2(allocator2<Y> const& x) : tag_(x.tag_)
 441         {
 442             UNORDERED_SCOPE(allocator2::allocator2()) {
 443                 UNORDERED_EPOINT("Mock allocator2 template copy constructor.");
 444             }
 445             test::detail::tracker.allocator_ref();
 446         }
 447
 448         allocator2(allocator2 const& x) : tag_(x.tag_)
 449         {
 450             UNORDERED_SCOPE(allocator2::allocator2()) {
 451                 UNORDERED_EPOINT("Mock allocator2 copy constructor.");
 452             }
 453             test::detail::tracker.allocator_ref();
 454         }
 455
 456         ~allocator2() {
 457             test::detail::tracker.allocator_unref();
 458         }
 459
 460         allocator2& operator=(allocator2 const& x) {
 461             UNORDERED_SCOPE(allocator2::allocator2()) {
 462                 UNORDERED_EPOINT("Mock allocator2 assignment operator.");
 463                 tag_ = x.tag_;
 464             }
 465             return *this;
 466         }
 467
 468         // If address throws, then it can't be used in erase or the
 469         // destructor, which is very limiting. I need to check up on
 470         // this.
 471
 472         pointer address(reference r) {
 473             //UNORDERED_SCOPE(allocator2::address(reference)) {
 474             //    UNORDERED_EPOINT("Mock allocator2 address function.");
 475             //}
 476             return pointer(&r);
 477         }
 478
 479         const_pointer address(const_reference r)  {
 480             //UNORDERED_SCOPE(allocator2::address(const_reference)) {
 481             //    UNORDERED_EPOINT("Mock allocator2 const address function.");
 482             //}
 483             return const_pointer(&r);
 484         }
 485
 486         pointer allocate(size_type n) {
 487             T* ptr = 0;
 488             UNORDERED_SCOPE(allocator2::allocate(size_type)) {
 489                 UNORDERED_EPOINT("Mock allocator2 allocate function.");
 490
 491                 using namespace std;
 492                 ptr = (T*) malloc(n * sizeof(T));
 493                 if(!ptr) throw std::bad_alloc();
 494             }
 495             test::detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
 496             return pointer(ptr);
 497
 498             //return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
 499         }
 500
 501         pointer allocate(size_type n, void const*)
 502         {
 503             T* ptr = 0;
 504             UNORDERED_SCOPE(allocator2::allocate(size_type, const_pointer)) {
 505                 UNORDERED_EPOINT("Mock allocator2 allocate function.");
 506
 507                 using namespace std;
 508                 ptr = (T*) malloc(n * sizeof(T));
 509                 if(!ptr) throw std::bad_alloc();
 510             }
 511             test::detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
 512             return pointer(ptr);
 513
 514             //return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
 515         }
 516
 517         void deallocate(pointer p, size_type n)
 518         {
 519             //::operator delete((void*) p);
 520             if(p) {
 521                 test::detail::tracker.track_deallocate((void*) p, n, sizeof(T), tag_);
 522                 using namespace std;
 523                 free(p);
 524             }
 525         }
 526
 527         void construct(pointer p, T const& t) {
 528             UNORDERED_SCOPE(allocator2::construct(T*, T)) {
 529                 UNORDERED_EPOINT("Mock allocator2 construct function.");
 530                 new(p) T(t);
 531             }
 532             test::detail::tracker.track_construct((void*) p, sizeof(T), tag_);
 533         }
 534
 535 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 536         template<class... Args> void construct(T* p, BOOST_FWD_REF(Args)... args) {
 537             UNORDERED_SCOPE(allocator2::construct(pointer, BOOST_FWD_REF(Args)...)) {
 538                 UNORDERED_EPOINT("Mock allocator2 construct function.");
 539                 new(p) T(boost::forward<Args>(args)...);
 540             }
 541             test::detail::tracker.track_construct((void*) p, sizeof(T), tag_);
 542         }
 543 #endif
 544
 545         void destroy(T* p) {
 546             test::detail::tracker.track_destroy((void*) p, sizeof(T), tag_);
 547             p->~T();
 548         }
 549
 550         size_type max_size() const {
 551             UNORDERED_SCOPE(allocator2::construct(pointer, T)) {
 552                 UNORDERED_EPOINT("Mock allocator2 max_size function.");
 553             }
 554             return (std::numeric_limits<std::size_t>::max)();
 555         }
 556
 557         typedef false_type propagate_on_container_copy_assignment;
 558         typedef false_type propagate_on_container_move_assignment;
 559         typedef false_type propagate_on_container_swap;
 560     };
 561
 562     template <class T>
 563     void swap(allocator2<T>& x, allocator2<T>& y)
 564     {
 565         std::swap(x.tag_, y.tag_);
 566     }
 567
 568     // It's pretty much impossible to write a compliant swap when these
 569     // two can throw. So they don't.
 570
 571     template <class T>
 572     inline bool operator==(allocator2<T> const& x, allocator2<T> const& y)
 573     {
 574         //UNORDERED_SCOPE(operator==(allocator2, allocator2)) {
 575         //    UNORDERED_EPOINT("Mock allocator2 equality operator.");
 576         //}
 577         return x.tag_ == y.tag_;
 578     }
 579
 580     template <class T>
 581     inline bool operator!=(allocator2<T> const& x, allocator2<T> const& y)
 582     {
 583         //UNORDERED_SCOPE(operator!=(allocator2, allocator2)) {
 584         //    UNORDERED_EPOINT("Mock allocator2 inequality operator.");
 585         //}
 586         return x.tag_ != y.tag_;
 587     }
 588 }
 589 }
 590
 591 // Workaround for ADL deficient compilers
 592 #if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
 593 namespace test
 594 {
 595     test::exception::object generate(test::exception::object const* x,
 596         random_generator g) {
 597         return test::exception::generate(x, g);
 598     }
 599 }
 600 #endif
 601
 602 #endif
 603