ceph/src/boost/libs/test/include/boost/test/data/size.hpp

   1 //  (C) Copyright Gennadiy Rozental 2001.
   2 //  Distributed under the Boost Software License, Version 1.0.
   3 //  (See accompanying file LICENSE_1_0.txt or copy at
   4 //  http://www.boost.org/LICENSE_1_0.txt)
   5
   6 //  See http://www.boost.org/libs/test for the library home page.
   7 //
   8 //!@file
   9 //!@brief simple dataset size abstraction (can be infinite)
  10 // ***************************************************************************
  11
  12 #ifndef BOOST_TEST_DATA_SIZE_HPP_102211GER
  13 #define BOOST_TEST_DATA_SIZE_HPP_102211GER
  14
  15 // Boost.Test
  16 #include <boost/test/data/config.hpp>
  17
  18 // STL
  19 #include <iosfwd>
  20
  21 #include <boost/test/detail/suppress_warnings.hpp>
  22
  23 //____________________________________________________________________________//
  24
  25 namespace boost {
  26 namespace unit_test {
  27 namespace data {
  28
  29 // ************************************************************************** //
  30 // **************                    size_t                    ************** //
  31 // ************************************************************************** //
  32
  33 //! Utility for handling the size of a datasets
  34 class size_t {
  35     struct dummy { void nonnull() {} };
  36     typedef void (dummy::*safe_bool)();
  37 public:
  38     // Constructors
  39     size_t( std::size_t s = 0 )         : m_value( s ), m_infinity( false ) {}
  40     explicit        size_t( bool )      : m_value( 0 ), m_infinity( true ) {}
  41     template<typename T>
  42     size_t( T v )                       : m_value( static_cast<std::size_t>(v) ), m_infinity( false ) {}
  43
  44     // Access methods
  45     std::size_t     value() const       { return m_value; }
  46     bool            is_inf() const      { return m_infinity; }
  47     operator        safe_bool() const   { return is_inf() || m_value != 0 ? &dummy::nonnull : 0; }
  48
  49     // Unary operators
  50     data::size_t    operator--()        { if( !is_inf() ) m_value--; return *this; }
  51     data::size_t    operator--(int)     { data::size_t res(*this); if( !is_inf() ) m_value--; return res; }
  52     data::size_t    operator++()        { if( !is_inf() ) m_value++; return *this; }
  53     data::size_t    operator++(int)     { data::size_t res(*this); if( !is_inf() ) m_value++; return res; }
  54
  55     // Binary operators
  56     data::size_t&   operator+=( std::size_t rhs ) { if( !is_inf() ) m_value += rhs; return *this; }
  57     data::size_t&   operator+=( data::size_t rhs )
  58     {
  59         if( !is_inf() ) {
  60             if( rhs.is_inf() )
  61                 *this = rhs;
  62             else
  63                 m_value += rhs.value();
  64         }
  65         return *this;
  66     }
  67     data::size_t&   operator-=( std::size_t rhs ) { if( !is_inf() ) m_value -= rhs; return *this; }
  68     data::size_t&   operator-=( data::size_t rhs )
  69     {
  70         if( !is_inf() ) {
  71             if( value() < rhs.value() )
  72                 m_value = 0;
  73             else
  74                 m_value -= rhs.value();
  75         }
  76         return *this;
  77     }
  78
  79 private:
  80     // Data members
  81     std::size_t     m_value;
  82     bool            m_infinity;
  83 };
  84
  85 namespace { const data::size_t BOOST_TEST_DS_INFINITE_SIZE( true ); }
  86
  87 //____________________________________________________________________________//
  88
  89 // Binary operators
  90 inline bool operator>(data::size_t lhs, std::size_t rhs)    { return lhs.is_inf()  || (lhs.value() > rhs); }
  91 inline bool operator>(std::size_t lhs, data::size_t rhs)    { return !rhs.is_inf() && (lhs > rhs.value()); }
  92 inline bool operator>(data::size_t lhs, data::size_t rhs)   { return lhs.is_inf() ^ rhs.is_inf() ? lhs.is_inf() : lhs.value() > rhs.value(); }
  93
  94 inline bool operator>=(data::size_t lhs, std::size_t rhs )  { return lhs.is_inf()  || (lhs.value() >= rhs); }
  95 inline bool operator>=(std::size_t lhs, data::size_t rhs)   { return !rhs.is_inf() && (lhs >= rhs.value()); }
  96 inline bool operator>=(data::size_t lhs, data::size_t rhs)  { return lhs.is_inf() ^ rhs.is_inf() ? lhs.is_inf() : lhs.value() >= rhs.value(); }
  97
  98 inline bool operator<(data::size_t lhs, std::size_t rhs)    { return !lhs.is_inf() && (lhs.value() < rhs); }
  99 inline bool operator<(std::size_t lhs, data::size_t rhs)    { return rhs.is_inf()  || (lhs < rhs.value()); }
 100 inline bool operator<(data::size_t lhs, data::size_t rhs)   { return lhs.is_inf() ^ rhs.is_inf() ? rhs.is_inf() : lhs.value() < rhs.value(); }
 101
 102 inline bool operator<=(data::size_t lhs, std::size_t rhs)   { return !lhs.is_inf() && (lhs.value() <= rhs); }
 103 inline bool operator<=(std::size_t lhs, data::size_t rhs)   { return rhs.is_inf()  || (lhs <= rhs.value()); }
 104 inline bool operator<=(data::size_t lhs, data::size_t rhs)  { return lhs.is_inf() ^ rhs.is_inf() ? rhs.is_inf() : lhs.value() <= rhs.value(); }
 105
 106 inline bool operator==(data::size_t lhs, std::size_t rhs)   { return !lhs.is_inf() && (lhs.value() == rhs); }
 107 inline bool operator==(std::size_t lhs, data::size_t rhs)   { return !rhs.is_inf() && (lhs == rhs.value()); }
 108 inline bool operator==(data::size_t lhs, data::size_t rhs)  { return !(lhs.is_inf() ^ rhs.is_inf()) && lhs.value() == rhs.value(); }
 109
 110 inline bool operator!=(data::size_t lhs, std::size_t rhs)   { return lhs.is_inf() || (lhs.value() != rhs); }
 111 inline bool operator!=(std::size_t lhs, data::size_t rhs)   { return rhs.is_inf() || (lhs != rhs.value()); }
 112 inline bool operator!=(data::size_t lhs, data::size_t rhs)  { return lhs.is_inf() ^ rhs.is_inf() || lhs.value() != rhs.value(); }
 113
 114 inline data::size_t operator+(data::size_t lhs, std::size_t rhs)  { return lhs.is_inf() ? lhs : data::size_t( lhs.value()+rhs ); }
 115 inline data::size_t operator+(std::size_t lhs, data::size_t rhs)  { return rhs.is_inf() ? rhs : data::size_t( lhs+rhs.value() ); }
 116 inline data::size_t operator+(data::size_t lhs, data::size_t rhs) { return lhs.is_inf() || rhs.is_inf() ? data::size_t(true) : data::size_t( lhs.value()+rhs.value() ); }
 117
 118 inline data::size_t operator*(data::size_t lhs, std::size_t rhs)  { return lhs.is_inf() ? lhs : data::size_t( lhs.value()*rhs ); }
 119 inline data::size_t operator*(std::size_t lhs, data::size_t rhs)  { return rhs.is_inf() ? rhs : data::size_t( lhs*rhs.value() ); }
 120 inline data::size_t operator*(data::size_t lhs, data::size_t rhs) { return lhs.is_inf() || rhs.is_inf() ? data::size_t(true) : data::size_t( lhs.value()*rhs.value() ); }
 121
 122 //____________________________________________________________________________//
 123
 124 template<typename CharT1, typename Tr>
 125 inline std::basic_ostream<CharT1,Tr>&
 126 operator<<( std::basic_ostream<CharT1,Tr>& os, data::size_t const& s )
 127 {
 128     if( s.is_inf() )
 129         os << "infinity";
 130     else
 131         os << s.value();
 132
 133     return os;
 134 }
 135
 136 //____________________________________________________________________________//
 137
 138 } // namespace data
 139 } // namespace unit_test
 140 } // namespace boost
 141
 142 #include <boost/test/detail/enable_warnings.hpp>
 143
 144 #endif // BOOST_TEST_DATA_SIZE_HPP_102211GER
 145