ceph/src/boost/libs/type_index/include/boost/type_index/type_index_facade.hpp

   1 //
   2 // Copyright (c) Antony Polukhin, 2013-2015.
   3 //
   4 //
   5 // Distributed under the Boost Software License, Version 1.0. (See accompanying
   6 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   7 //
   8
   9 #ifndef BOOST_TYPE_INDEX_TYPE_INDEX_FACADE_HPP
  10 #define BOOST_TYPE_INDEX_TYPE_INDEX_FACADE_HPP
  11
  12 #include <boost/config.hpp>
  13 #include <string>
  14 #include <cstring>
  15
  16 #if !defined(BOOST_NO_IOSTREAM)
  17 #if !defined(BOOST_NO_IOSFWD)
  18 #include <iosfwd>               // for std::basic_ostream
  19 #else
  20 #include <ostream>
  21 #endif
  22 #endif
  23
  24 #ifdef BOOST_HAS_PRAGMA_ONCE
  25 # pragma once
  26 #endif
  27
  28 // Forward declaration from #include <boost/functional/hash_fwd.hpp>
  29 namespace boost {
  30     template <class It> std::size_t hash_range(It, It);
  31 }
  32
  33 namespace boost { namespace typeindex {
  34
  35 /// \class type_index_facade
  36 ///
  37 /// This class takes care about the comparison operators, hash functions and
  38 /// ostream operators. Use this class as a public base class for defining new
  39 /// type_info-conforming classes.
  40 ///
  41 /// \b Example:
  42 /// \code
  43 /// class stl_type_index: public type_index_facade<stl_type_index, std::type_info>
  44 /// {
  45 /// public:
  46 ///     typedef std::type_info type_info_t;
  47 /// private:
  48 ///     const type_info_t* data_;
  49 ///
  50 /// public:
  51 ///     stl_type_index(const type_info_t& data) noexcept
  52 ///         : data_(&data)
  53 ///     {}
  54 /// // ...
  55 /// };
  56 /// \endcode
  57 ///
  58 /// \tparam Derived Class derived from type_index_facade.
  59 /// \tparam TypeInfo Class that will be used as a base type_info class.
  60 /// \note Take a look at the protected methods. They are \b not \b defined in type_index_facade.
  61 /// Protected member functions raw_name() \b must be defined in Derived class. All the other
  62 /// methods are mandatory.
  63 /// \see 'Making a custom type_index' section for more information about
  64 /// creating your own type_index using type_index_facade.
  65 template <class Derived, class TypeInfo>
  66 class type_index_facade {
  67 private:
  68     /// @cond
  69     BOOST_CXX14_CONSTEXPR const Derived & derived() const BOOST_NOEXCEPT {
  70       return *static_cast<Derived const*>(this);
  71     }
  72     /// @endcond
  73 public:
  74     typedef TypeInfo                                type_info_t;
  75
  76     /// \b Override: This function \b may be redefined in Derived class. Overrides \b must not throw.
  77     /// \return Name of a type. By default returns Derived::raw_name().
  78     inline const char* name() const BOOST_NOEXCEPT {
  79         return derived().raw_name();
  80     }
  81
  82     /// \b Override: This function \b may be redefined in Derived class. Overrides may throw.
  83     /// \return Human readable type name. By default returns Derived::name().
  84     inline std::string pretty_name() const {
  85         return derived().name();
  86     }
  87
  88     /// \b Override: This function \b may be redefined in Derived class. Overrides \b must not throw.
  89     /// \return True if two types are equal. By default compares types by raw_name().
  90     inline bool equal(const Derived& rhs) const BOOST_NOEXCEPT {
  91         const char* const left = derived().raw_name();
  92         const char* const right = rhs.raw_name();
  93         return left == right || !std::strcmp(left, right);
  94     }
  95
  96     /// \b Override: This function \b may be redefined in Derived class. Overrides \b must not throw.
  97     /// \return True if rhs is greater than this. By default compares types by raw_name().
  98     inline bool before(const Derived& rhs) const BOOST_NOEXCEPT {
  99         const char* const left = derived().raw_name();
 100         const char* const right = rhs.raw_name();
 101         return left != right && std::strcmp(left, right) < 0;
 102     }
 103
 104     /// \b Override: This function \b may be redefined in Derived class. Overrides \b must not throw.
 105     /// \return Hash code of a type. By default hashes types by raw_name().
 106     /// \note <boost/functional/hash.hpp> has to be included if this function is used.
 107     inline std::size_t hash_code() const BOOST_NOEXCEPT {
 108         const char* const name_raw = derived().raw_name();
 109         return boost::hash_range(name_raw, name_raw + std::strlen(name_raw));
 110     }
 111
 112 #if defined(BOOST_TYPE_INDEX_DOXYGEN_INVOKED)
 113 protected:
 114     /// \b Override: This function \b must be redefined in Derived class. Overrides \b must not throw.
 115     /// \return Pointer to unredable/raw type name.
 116     inline const char* raw_name() const BOOST_NOEXCEPT;
 117
 118     /// \b Override: This function \b may be redefined in Derived class. Overrides \b must not throw.
 119     /// \return Const reference to underlying low level type_info_t.
 120     inline const type_info_t& type_info() const BOOST_NOEXCEPT;
 121
 122     /// This is a factory method that is used to create instances of Derived classes.
 123     /// boost::typeindex::type_id() will call this method, if Derived has same type as boost::typeindex::type_index.
 124     ///
 125     /// \b Override: This function \b may be redefined and made public in Derived class. Overrides \b must not throw.
 126     /// Overrides \b must remove const, volatile && and & modifiers from T.
 127     /// \tparam T Type for which type_index must be created.
 128     /// \return type_index for type T.
 129     template <class T>
 130     static Derived type_id() BOOST_NOEXCEPT;
 131
 132     /// This is a factory method that is used to create instances of Derived classes.
 133     /// boost::typeindex::type_id_with_cvr() will call this method, if Derived has same type as boost::typeindex::type_index.
 134     ///
 135     /// \b Override: This function \b may be redefined and made public in Derived class. Overrides \b must not throw.
 136     /// Overrides \b must \b not remove const, volatile && and & modifiers from T.
 137     /// \tparam T Type for which type_index must be created.
 138     /// \return type_index for type T.
 139     template <class T>
 140     static Derived type_id_with_cvr() BOOST_NOEXCEPT;
 141
 142     /// This is a factory method that is used to create instances of Derived classes.
 143     /// boost::typeindex::type_id_runtime(const T&) will call this method, if Derived has same type as boost::typeindex::type_index.
 144     ///
 145     /// \b Override: This function \b may be redefined and made public in Derived class.
 146     /// \param variable Variable which runtime type will be stored in type_index.
 147     /// \return type_index with runtime type of variable.
 148     template <class T>
 149     static Derived type_id_runtime(const T& variable) BOOST_NOEXCEPT;
 150
 151 #endif
 152
 153 };
 154
 155 /// @cond
 156 template <class Derived, class TypeInfo>
 157 BOOST_CXX14_CONSTEXPR inline bool operator == (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
 158     return static_cast<Derived const&>(lhs).equal(static_cast<Derived const&>(rhs));
 159 }
 160
 161 template <class Derived, class TypeInfo>
 162 BOOST_CXX14_CONSTEXPR inline bool operator < (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
 163     return static_cast<Derived const&>(lhs).before(static_cast<Derived const&>(rhs));
 164 }
 165
 166
 167
 168 template <class Derived, class TypeInfo>
 169 BOOST_CXX14_CONSTEXPR inline bool operator > (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
 170     return rhs < lhs;
 171 }
 172
 173 template <class Derived, class TypeInfo>
 174 BOOST_CXX14_CONSTEXPR inline bool operator <= (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
 175     return !(lhs > rhs);
 176 }
 177
 178 template <class Derived, class TypeInfo>
 179 BOOST_CXX14_CONSTEXPR inline bool operator >= (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
 180     return !(lhs < rhs);
 181 }
 182
 183 template <class Derived, class TypeInfo>
 184 BOOST_CXX14_CONSTEXPR inline bool operator != (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
 185     return !(lhs == rhs);
 186 }
 187
 188 // ######################### COMPARISONS with Derived ############################ //
 189 template <class Derived, class TypeInfo>
 190 inline bool operator == (const TypeInfo& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
 191     return Derived(lhs) == rhs;
 192 }
 193
 194 template <class Derived, class TypeInfo>
 195 inline bool operator < (const TypeInfo& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
 196     return Derived(lhs) < rhs;
 197 }
 198
 199 template <class Derived, class TypeInfo>
 200 inline bool operator > (const TypeInfo& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
 201     return rhs < Derived(lhs);
 202 }
 203
 204 template <class Derived, class TypeInfo>
 205 inline bool operator <= (const TypeInfo& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
 206     return !(Derived(lhs) > rhs);
 207 }
 208
 209 template <class Derived, class TypeInfo>
 210 inline bool operator >= (const TypeInfo& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
 211     return !(Derived(lhs) < rhs);
 212 }
 213
 214 template <class Derived, class TypeInfo>
 215 inline bool operator != (const TypeInfo& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
 216     return !(Derived(lhs) == rhs);
 217 }
 218
 219
 220 template <class Derived, class TypeInfo>
 221 inline bool operator == (const type_index_facade<Derived, TypeInfo>& lhs, const TypeInfo& rhs) BOOST_NOEXCEPT {
 222     return lhs == Derived(rhs);
 223 }
 224
 225 template <class Derived, class TypeInfo>
 226 inline bool operator < (const type_index_facade<Derived, TypeInfo>& lhs, const TypeInfo& rhs) BOOST_NOEXCEPT {
 227     return lhs < Derived(rhs);
 228 }
 229
 230 template <class Derived, class TypeInfo>
 231 inline bool operator > (const type_index_facade<Derived, TypeInfo>& lhs, const TypeInfo& rhs) BOOST_NOEXCEPT {
 232     return Derived(rhs) < lhs;
 233 }
 234
 235 template <class Derived, class TypeInfo>
 236 inline bool operator <= (const type_index_facade<Derived, TypeInfo>& lhs, const TypeInfo& rhs) BOOST_NOEXCEPT {
 237     return !(lhs > Derived(rhs));
 238 }
 239
 240 template <class Derived, class TypeInfo>
 241 inline bool operator >= (const type_index_facade<Derived, TypeInfo>& lhs, const TypeInfo& rhs) BOOST_NOEXCEPT {
 242     return !(lhs < Derived(rhs));
 243 }
 244
 245 template <class Derived, class TypeInfo>
 246 inline bool operator != (const type_index_facade<Derived, TypeInfo>& lhs, const TypeInfo& rhs) BOOST_NOEXCEPT {
 247     return !(lhs == Derived(rhs));
 248 }
 249
 250 // ######################### COMPARISONS with Derived END ############################ //
 251
 252 /// @endcond
 253
 254 #if defined(BOOST_TYPE_INDEX_DOXYGEN_INVOKED)
 255
 256 /// noexcept comparison operators for type_index_facade classes.
 257 bool operator ==, !=, <, ... (const type_index_facade& lhs, const type_index_facade& rhs) noexcept;
 258
 259 /// noexcept comparison operators for type_index_facade and it's TypeInfo classes.
 260 bool operator ==, !=, <, ... (const type_index_facade& lhs, const TypeInfo& rhs) noexcept;
 261
 262 /// noexcept comparison operators for type_index_facade's TypeInfo and type_index_facade classes.
 263 bool operator ==, !=, <, ... (const TypeInfo& lhs, const type_index_facade& rhs) noexcept;
 264
 265 #endif
 266
 267 #ifndef BOOST_NO_IOSTREAM
 268 #ifdef BOOST_NO_TEMPLATED_IOSTREAMS
 269 /// @cond
 270 /// Ostream operator that will output demangled name
 271 template <class Derived, class TypeInfo>
 272 inline std::ostream& operator<<(std::ostream& ostr, const type_index_facade<Derived, TypeInfo>& ind) {
 273     ostr << static_cast<Derived const&>(ind).pretty_name();
 274     return ostr;
 275 }
 276 /// @endcond
 277 #else
 278 /// Ostream operator that will output demangled name.
 279 template <class CharT, class TriatT, class Derived, class TypeInfo>
 280 inline std::basic_ostream<CharT, TriatT>& operator<<(
 281     std::basic_ostream<CharT, TriatT>& ostr,
 282     const type_index_facade<Derived, TypeInfo>& ind)
 283 {
 284     ostr << static_cast<Derived const&>(ind).pretty_name();
 285     return ostr;
 286 }
 287 #endif // BOOST_NO_TEMPLATED_IOSTREAMS
 288 #endif // BOOST_NO_IOSTREAM
 289
 290 /// This free function is used by Boost's unordered containers.
 291 /// \note <boost/functional/hash.hpp> has to be included if this function is used.
 292 template <class Derived, class TypeInfo>
 293 inline std::size_t hash_value(const type_index_facade<Derived, TypeInfo>& lhs) BOOST_NOEXCEPT {
 294     return static_cast<Derived const&>(lhs).hash_code();
 295 }
 296
 297 }} // namespace boost::typeindex
 298
 299 #endif // BOOST_TYPE_INDEX_TYPE_INDEX_FACADE_HPP
 300