libs/container/test/movable_int.hpp

   1 ///////////////////////////////////////////////////////////////////////////
   2 //
   3 // (C) Copyright Ion Gaztanaga 2006. Distributed under the Boost
   4 // Software License, Version 1.0. (See accompanying file
   5 // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   6 //
   7 // See http://www.boost.org/libs/container for documentation.
   8 //
   9 ///////////////////////////////////////////////////////////////////////////
  10
  11 #ifndef BOOST_CONTAINER_TEST_MOVABLE_INT_HEADER
  12 #define BOOST_CONTAINER_TEST_MOVABLE_INT_HEADER
  13
  14 #include <boost/container/detail/config_begin.hpp>
  15 #include <boost/container/detail/workaround.hpp>
  16 #include <boost/move/move.hpp>
  17
  18 namespace boost {
  19 namespace container {
  20 namespace test {
  21
  22 template<class T>
  23 struct is_copyable;
  24
  25 template<>
  26 struct is_copyable<int>
  27 {
  28    static const bool value = true;
  29 };
  30
  31
  32 class movable_int
  33 {
  34    BOOST_MOVABLE_BUT_NOT_COPYABLE(movable_int)
  35
  36    public:
  37    movable_int()
  38       :  m_int(0)
  39    {}
  40
  41    explicit movable_int(int a)
  42       :  m_int(a)
  43    {}
  44
  45    movable_int(BOOST_RV_REF(movable_int) mmi)
  46       :  m_int(mmi.m_int)
  47    {  mmi.m_int = 0; }
  48
  49    movable_int & operator= (BOOST_RV_REF(movable_int) mmi)
  50    {  this->m_int = mmi.m_int;   mmi.m_int = 0;  return *this;  }
  51
  52    movable_int & operator= (int i)
  53    {  this->m_int = i;  return *this;  }
  54
  55    bool operator ==(const movable_int &mi) const
  56    {  return this->m_int == mi.m_int;   }
  57
  58    bool operator !=(const movable_int &mi) const
  59    {  return this->m_int != mi.m_int;   }
  60
  61    bool operator <(const movable_int &mi) const
  62    {  return this->m_int < mi.m_int;   }
  63
  64    bool operator <=(const movable_int &mi) const
  65    {  return this->m_int <= mi.m_int;   }
  66
  67    bool operator >=(const movable_int &mi) const
  68    {  return this->m_int >= mi.m_int;   }
  69
  70    bool operator >(const movable_int &mi) const
  71    {  return this->m_int > mi.m_int;   }
  72
  73    int get_int() const
  74    {  return m_int;  }
  75
  76    private:
  77    int m_int;
  78 };
  79
  80 template<class E, class T>
  81 std::basic_ostream<E, T> & operator<<
  82    (std::basic_ostream<E, T> & os, movable_int const & p)
  83
  84 {
  85     os << p.get_int();
  86     return os;
  87 }
  88
  89
  90 template<>
  91 struct is_copyable<movable_int>
  92 {
  93    static const bool value = false;
  94 };
  95
  96 class movable_and_copyable_int
  97 {
  98    BOOST_COPYABLE_AND_MOVABLE(movable_and_copyable_int)
  99
 100    public:
 101    movable_and_copyable_int()
 102       :  m_int(0)
 103    {}
 104
 105    explicit movable_and_copyable_int(int a)
 106       :  m_int(a)
 107    {}
 108
 109    movable_and_copyable_int(const movable_and_copyable_int& mmi)
 110       :  m_int(mmi.m_int)
 111    {}
 112
 113    movable_and_copyable_int(BOOST_RV_REF(movable_and_copyable_int) mmi)
 114       :  m_int(mmi.m_int)
 115    {  mmi.m_int = 0; }
 116
 117    movable_and_copyable_int &operator= (BOOST_COPY_ASSIGN_REF(movable_and_copyable_int) mi)
 118    {  this->m_int = mi.m_int;    return *this;  }
 119
 120    movable_and_copyable_int & operator= (BOOST_RV_REF(movable_and_copyable_int) mmi)
 121    {  this->m_int = mmi.m_int;   mmi.m_int = 0;    return *this;  }
 122
 123    movable_and_copyable_int & operator= (int i)
 124    {  this->m_int = i;  return *this;  }
 125
 126    bool operator ==(const movable_and_copyable_int &mi) const
 127    {  return this->m_int == mi.m_int;   }
 128
 129    bool operator !=(const movable_and_copyable_int &mi) const
 130    {  return this->m_int != mi.m_int;   }
 131
 132    bool operator <(const movable_and_copyable_int &mi) const
 133    {  return this->m_int < mi.m_int;   }
 134
 135    bool operator <=(const movable_and_copyable_int &mi) const
 136    {  return this->m_int <= mi.m_int;   }
 137
 138    bool operator >=(const movable_and_copyable_int &mi) const
 139    {  return this->m_int >= mi.m_int;   }
 140
 141    bool operator >(const movable_and_copyable_int &mi) const
 142    {  return this->m_int > mi.m_int;   }
 143
 144    int get_int() const
 145    {  return m_int;  }
 146
 147    private:
 148    int m_int;
 149 };
 150
 151 template<class E, class T>
 152 std::basic_ostream<E, T> & operator<<
 153    (std::basic_ostream<E, T> & os, movable_and_copyable_int const & p)
 154
 155 {
 156     os << p.get_int();
 157     return os;
 158 }
 159
 160 template<>
 161 struct is_copyable<movable_and_copyable_int>
 162 {
 163    static const bool value = true;
 164 };
 165
 166 class copyable_int
 167 {
 168    public:
 169    copyable_int()
 170       :  m_int(0)
 171    {}
 172
 173    explicit copyable_int(int a)
 174       :  m_int(a)
 175    {}
 176
 177    copyable_int(const copyable_int& mmi)
 178       :  m_int(mmi.m_int)
 179    {}
 180
 181    copyable_int & operator= (int i)
 182    {  this->m_int = i;  return *this;  }
 183
 184    bool operator ==(const copyable_int &mi) const
 185    {  return this->m_int == mi.m_int;   }
 186
 187    bool operator !=(const copyable_int &mi) const
 188    {  return this->m_int != mi.m_int;   }
 189
 190    bool operator <(const copyable_int &mi) const
 191    {  return this->m_int < mi.m_int;   }
 192
 193    bool operator <=(const copyable_int &mi) const
 194    {  return this->m_int <= mi.m_int;   }
 195
 196    bool operator >=(const copyable_int &mi) const
 197    {  return this->m_int >= mi.m_int;   }
 198
 199    bool operator >(const copyable_int &mi) const
 200    {  return this->m_int > mi.m_int;   }
 201
 202    int get_int() const
 203    {  return m_int;  }
 204
 205    private:
 206    int m_int;
 207 };
 208
 209 template<class E, class T>
 210 std::basic_ostream<E, T> & operator<<
 211    (std::basic_ostream<E, T> & os, copyable_int const & p)
 212
 213 {
 214     os << p.get_int();
 215     return os;
 216 }
 217
 218 template<>
 219 struct is_copyable<copyable_int>
 220 {
 221    static const bool value = true;
 222 };
 223
 224 class non_copymovable_int
 225 {
 226    non_copymovable_int(const non_copymovable_int& mmi);
 227    non_copymovable_int & operator= (const non_copymovable_int &mi);
 228
 229    public:
 230    non_copymovable_int()
 231       :  m_int(0)
 232    {}
 233
 234    explicit non_copymovable_int(int a)
 235       :  m_int(a)
 236    {}
 237
 238    bool operator ==(const non_copymovable_int &mi) const
 239    {  return this->m_int == mi.m_int;   }
 240
 241    bool operator !=(const non_copymovable_int &mi) const
 242    {  return this->m_int != mi.m_int;   }
 243
 244    bool operator <(const non_copymovable_int &mi) const
 245    {  return this->m_int < mi.m_int;   }
 246
 247    bool operator <=(const non_copymovable_int &mi) const
 248    {  return this->m_int <= mi.m_int;   }
 249
 250    bool operator >=(const non_copymovable_int &mi) const
 251    {  return this->m_int >= mi.m_int;   }
 252
 253    bool operator >(const non_copymovable_int &mi) const
 254    {  return this->m_int > mi.m_int;   }
 255
 256    int get_int() const
 257    {  return m_int;  }
 258
 259    private:
 260    int m_int;
 261 };
 262
 263 }  //namespace test {
 264 }  //namespace container {
 265 }  //namespace boost {
 266
 267 #include <boost/container/detail/config_end.hpp>
 268
 269 #endif   //#ifndef BOOST_CONTAINER_TEST_MOVABLE_INT_HEADER