ceph/src/boost/libs/move/test/order_type.hpp

   1 //////////////////////////////////////////////////////////////////////////////
   2 //
   3 // (C) Copyright Ion Gaztanaga 2015-2016.
   4 // Distributed under the Boost Software License, Version 1.0.
   5 // (See accompanying file LICENSE_1_0.txt or copy at
   6 // http://www.boost.org/LICENSE_1_0.txt)
   7 //
   8 // See http://www.boost.org/libs/move for documentation.
   9 //
  10 //////////////////////////////////////////////////////////////////////////////
  11
  12 #ifndef BOOST_MOVE_TEST_ORDER_TYPE_HPP
  13 #define BOOST_MOVE_TEST_ORDER_TYPE_HPP
  14
  15 #include <boost/config.hpp>
  16 #include <boost/move/core.hpp>
  17 #include <cstddef>
  18 #include <cstdio>
  19
  20 struct order_perf_type
  21 {
  22    public:
  23    std::size_t key;
  24    std::size_t val;
  25
  26    order_perf_type()
  27    {
  28       ++num_elements;
  29    }
  30
  31    order_perf_type(const order_perf_type& other)
  32       : key(other.key), val(other.val)
  33    {
  34       ++num_elements;
  35       ++num_copy;
  36    }
  37
  38    order_perf_type & operator=(const order_perf_type& other)
  39    {
  40       ++num_copy;
  41       key = other.key;
  42       val = other.val;
  43       return *this;
  44    }
  45
  46    ~order_perf_type ()
  47    {
  48       --num_elements;
  49    }
  50
  51    static void reset_stats()
  52    {
  53       num_compare=0;
  54       num_copy=0;
  55    }
  56
  57    friend bool operator< (const order_perf_type& left, const order_perf_type& right)
  58    {  ++num_compare; return left.key < right.key;  }
  59
  60    static boost::ulong_long_type num_compare;
  61    static boost::ulong_long_type num_copy;
  62    static boost::ulong_long_type num_elements;
  63 };
  64
  65 boost::ulong_long_type order_perf_type::num_compare = 0;
  66 boost::ulong_long_type order_perf_type::num_copy = 0;
  67 boost::ulong_long_type order_perf_type::num_elements = 0;
  68
  69
  70 struct order_move_type
  71 {
  72    BOOST_MOVABLE_BUT_NOT_COPYABLE(order_move_type)
  73
  74    public:
  75    std::size_t key;
  76    std::size_t val;
  77
  78    order_move_type()
  79       : key(0u), val(0u)
  80    {}
  81
  82    order_move_type(BOOST_RV_REF(order_move_type) other)
  83       : key(other.key), val(other.val)
  84    {
  85       other.key = other.val = std::size_t(-1);
  86    }
  87
  88    order_move_type & operator=(BOOST_RV_REF(order_move_type) other)
  89    {
  90       key = other.key;
  91       val = other.val;
  92       other.key = other.val = std::size_t(-2);
  93       return *this;
  94    }
  95
  96    friend bool operator< (const order_move_type& left, const order_move_type& right)
  97    {  return left.key < right.key;  }
  98
  99    ~order_move_type ()
 100    {
 101       key = val = std::size_t(-3);
 102    }
 103 };
 104
 105 struct order_type_less
 106 {
 107    template<class T>
 108    bool operator()(const T &a, T const &b) const
 109    {  return a < b;   }
 110 };
 111
 112 template<class T>
 113 inline bool is_order_type_ordered(T *elements, std::size_t element_count, bool stable = true)
 114 {
 115    for(std::size_t i = 1; i < element_count; ++i){
 116       if(order_type_less()(elements[i], elements[i-1])){
 117          std::printf("\n Ord KO !!!!");
 118          return false;
 119       }
 120       if( stable && !(order_type_less()(elements[i-1], elements[i])) && (elements[i-1].val > elements[i].val) ){
 121          std::printf("\n Stb KO !!!! ");
 122          return false;
 123       }
 124    }
 125    return true;
 126 }
 127
 128 namespace boost {
 129 namespace movelib {
 130 namespace detail_adaptive {
 131
 132
 133
 134 }}}
 135
 136 template<class T>
 137 inline bool is_key(T *elements, std::size_t element_count)
 138 {
 139    for(std::size_t i = 1; i < element_count; ++i){
 140       if(elements[i].key >= element_count){
 141          std::printf("\n Key.key KO !!!!");
 142          return false;
 143       }
 144       if(elements[i].val != std::size_t(-1)){
 145          std::printf("\n Key.val KO !!!!");
 146          return false;
 147       }
 148    }
 149    return true;
 150 }
 151
 152 template<class T>
 153 inline bool is_buffer(T *elements, std::size_t element_count)
 154 {
 155    for(std::size_t i = 1; i < element_count; ++i){
 156       if(elements[i].key != std::size_t(-1)){
 157          std::printf("\n Buf.key KO !!!!");
 158          return false;
 159       }
 160       if(elements[i].val >= element_count){
 161          std::printf("\n Buf.val KO !!!!");
 162          return false;
 163       }
 164    }
 165    return true;
 166 }
 167
 168
 169 #endif   //BOOST_MOVE_TEST_ORDER_TYPE_HPP