ceph/src/boost/libs/convert/test/test.hpp

   1 // Copyright (c) 2009-2016 Vladimir Batov.
   2 // Use, modification and distribution are subject to the Boost Software License,
   3 // Version 1.0. See http://www.boost.org/LICENSE_1_0.txt.
   4
   5 #ifndef BOOST_CONVERT_TEST_HPP
   6 #define BOOST_CONVERT_TEST_HPP
   7
   8 #include <boost/convert/detail/config.hpp>
   9 #include <boost/make_default.hpp>
  10 #include <boost/static_assert.hpp>
  11 #include <string>
  12 #include <istream>
  13 #include <string.h> // For strlen, strcmp, memcpy
  14 #include <memory.h> // Is needed for 'memset'
  15 #include <stdio.h>
  16 #include <time.h>
  17
  18 #if defined(_MSC_VER)
  19 #   pragma warning(disable: 4189) // local variable is initialized but not referenced.
  20 #   pragma warning(disable: 4127) // conditional expression is constant.
  21 #   pragma warning(disable: 4100) // unreferenced formal parameter.
  22 #   pragma warning(disable: 4714) // marked as __forceinline not #endif
  23 #   pragma warning(disable: 4706)
  24 #   pragma warning(disable: 4005)
  25 #   pragma warning(disable: 4459) // declaration hides global declaration
  26 #   pragma warning(disable: 4456) // declaration hides previous local declaration
  27 #endif
  28
  29 //[change_declaration
  30 struct change
  31 {
  32     enum value_type { no, up, dn };
  33
  34     change(value_type v =no) : value_(v) {}
  35     bool operator==(change v) const { return value_ == v.value_; }
  36     value_type value() const { return value_; }
  37
  38     private: value_type value_;
  39 };
  40 //]
  41 //[change_stream_operators
  42 std::istream& operator>>(std::istream& stream, change& chg)
  43 {
  44     std::string str; stream >> str;
  45
  46     /**/ if (str == "up") chg = change::up;
  47     else if (str == "dn") chg = change::dn;
  48     else if (str == "no") chg = change::no;
  49     else stream.setstate(std::ios_base::failbit);
  50
  51     return stream;
  52 }
  53
  54 std::ostream& operator<<(std::ostream& stream, change const& chg)
  55 {
  56     return stream << (chg == change::up ? "up" : chg == change::dn ? "dn" : "no");
  57 }
  58 //]
  59 //[change_convert_operators
  60 inline void operator>>(change chg, boost::optional<std::string>& str)
  61 {
  62     str = chg == change::up ? "up" : chg == change::dn ? "dn" : "no";
  63 }
  64
  65 inline void operator>>(std::string const& str, boost::optional<change>& chg)
  66 {
  67     /**/ if (str == "up") chg = change::up;
  68     else if (str == "dn") chg = change::dn;
  69     else if (str == "no") chg = change::no;
  70 }
  71 //]
  72 //[direction_declaration
  73 struct direction
  74 {
  75     // Note: the class does NOT have the default constructor.
  76
  77     enum value_type { up, dn };
  78
  79     direction(value_type value) : value_(value) {}
  80     bool operator==(direction that) const { return value_ == that.value_; }
  81     value_type value() const { return value_; }
  82
  83     private: value_type value_;
  84 };
  85 //]
  86 //[direction_stream_operators
  87 std::istream& operator>>(std::istream& stream, direction& dir)
  88 {
  89     std::string str; stream >> str;
  90
  91     /**/ if (str == "up") dir = direction::up;
  92     else if (str == "dn") dir = direction::dn;
  93     else stream.setstate(std::ios_base::failbit);
  94
  95     return stream;
  96 }
  97 std::ostream& operator<<(std::ostream& stream, direction const& dir)
  98 {
  99     return stream << (dir.value() == direction::up ? "up" : "dn");
 100 }
 101 //]
 102 //[direction_declaration_make_default
 103 namespace boost
 104 {
 105     template<> inline direction make_default<direction>()
 106     {
 107         return direction(direction::up);
 108     }
 109 }
 110 //]
 111 // Quick and dirty small-string implementation for performance tests.
 112 //[my_string_declaration
 113 struct my_string
 114 {
 115     typedef my_string              this_type;
 116     typedef char                  value_type;
 117     typedef value_type*             iterator;
 118     typedef value_type const* const_iterator;
 119
 120     my_string ();
 121     my_string (const_iterator, const_iterator =0);
 122
 123     char const*    c_str () const { return storage_; }
 124     const_iterator begin () const { return storage_; }
 125     const_iterator   end () const { return storage_ + strlen(storage_); }
 126     this_type& operator= (char const*);
 127
 128     private:
 129
 130     static size_t const size_ = 12;
 131     char storage_[size_];
 132 };
 133 //]
 134 inline
 135 my_string::my_string()
 136 {
 137     storage_[0] = 0;
 138 }
 139
 140 inline
 141 my_string::my_string(const_iterator beg, const_iterator end)
 142 {
 143     std::size_t const sz = end ? (end - beg) : strlen(beg);
 144
 145     BOOST_ASSERT(sz < size_);
 146     memcpy(storage_, beg, sz); storage_[sz] = 0;
 147 }
 148
 149 inline
 150 my_string&
 151 my_string::operator=(char const* str)
 152 {
 153     BOOST_ASSERT(strlen(str) < size_);
 154     strcpy(storage_, str);
 155     return *this;
 156 }
 157
 158 inline bool operator==(char const* s1, my_string const& s2) { return strcmp(s1, s2.c_str()) == 0; }
 159 inline bool operator==(my_string const& s1, char const* s2) { return strcmp(s2, s1.c_str()) == 0; }
 160
 161 namespace test
 162 {
 163     struct cnv
 164     {
 165 #if defined(__QNXNTO__)
 166         static bool const     is_qnx = true;
 167 #else
 168         static bool const     is_qnx = false;
 169 #endif
 170
 171 #if defined(_MSC_VER) && _MSC_VER < 1900
 172         static bool const     is_msc = true;
 173         static bool const is_old_msc = true;
 174 #elif defined(_MSC_VER)
 175         static bool const     is_msc = true;
 176         static bool const is_old_msc = false;
 177 #elif defined(__MINGW32__)
 178         static bool const     is_msc = true;
 179         static bool const is_old_msc = true;
 180 #else
 181         static bool const     is_msc = false;
 182         static bool const is_old_msc = false;
 183 #endif
 184     };
 185 }
 186
 187 #endif // BOOST_CONVERT_TEST_HPP