BVB Source Codes

mars Show scoped_enum.hpp Source code

Return Download mars: download scoped_enum.hpp Source code - Download mars Source code - Type:.hpp
  1. //  scoped_enum.hpp  ---------------------------------------------------------//
  2.  
  3. //  Copyright Beman Dawes, 2009
  4. //  Copyright (C) 2011-2012 Vicente J. Botet Escriba
  5. //  Copyright (C) 2012 Anthony Williams
  6.  
  7. //  Distributed under the Boost Software License, Version 1.0.
  8. //  See http://www.boost.org/LICENSE_1_0.txt
  9.  
  10. #ifndef BOOST_CORE_SCOPED_ENUM_HPP
  11. #define BOOST_CORE_SCOPED_ENUM_HPP
  12.  
  13. #include <boost/config.hpp>
  14.  
  15. #ifdef BOOST_HAS_PRAGMA_ONCE
  16. #pragma once
  17. #endif
  18.  
  19. namespace mars_boost {} namespace boost = mars_boost; namespace mars_boost
  20. {
  21.  
  22. #ifdef BOOST_NO_CXX11_SCOPED_ENUMS
  23.  
  24.   /**
  25.    * Meta-function to get the native enum type associated to an enum class or its emulation.
  26.    */
  27.   template <typename EnumType>
  28.   struct native_type
  29.   {
  30.     /**
  31.      * The member typedef type names the native enum type associated to the scoped enum,
  32.      * which is it self if the compiler supports scoped enums or EnumType::enum_type if it is an emulated scoped enum.
  33.      */
  34.     typedef typename EnumType::enum_type type;
  35.   };
  36.  
  37.   /**
  38.    * Casts a scoped enum to its underlying type.
  39.    *
  40.    * This function is useful when working with scoped enum classes, which doens't implicitly convert to the underlying type.
  41.    * @param v A scoped enum.
  42.    * @returns The underlying type.
  43.    * @throws No-throws.
  44.    */
  45.   template <typename UnderlyingType, typename EnumType>
  46.   UnderlyingType underlying_cast(EnumType v)
  47.   {
  48.     return v.get_underlying_value_();
  49.   }
  50.  
  51.   /**
  52.    * Casts a scoped enum to its native enum type.
  53.    *
  54.    * This function is useful to make programs portable when the scoped enum emulation can not be use where native enums can.
  55.    *
  56.    * EnumType the scoped enum type
  57.    *
  58.    * @param v A scoped enum.
  59.    * @returns The native enum value.
  60.    * @throws No-throws.
  61.    */
  62.   template <typename EnumType>
  63.   inline
  64.   typename EnumType::enum_type native_value(EnumType e)
  65.   {
  66.     return e.get_native_value_();
  67.   }
  68.  
  69. #else  // BOOST_NO_CXX11_SCOPED_ENUMS
  70.  
  71.   template <typename EnumType>
  72.   struct native_type
  73.   {
  74.     typedef EnumType type;
  75.   };
  76.  
  77.   template <typename UnderlyingType, typename EnumType>
  78.   UnderlyingType underlying_cast(EnumType v)
  79.   {
  80.     return static_cast<UnderlyingType>(v);
  81.   }
  82.  
  83.   template <typename EnumType>
  84.   inline
  85.   EnumType native_value(EnumType e)
  86.   {
  87.     return e;
  88.   }
  89.  
  90. #endif // BOOST_NO_CXX11_SCOPED_ENUMS
  91. }
  92.  
  93.  
  94. #ifdef BOOST_NO_CXX11_SCOPED_ENUMS
  95.  
  96. #ifndef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
  97.  
  98. #define BOOST_SCOPED_ENUM_UT_DECLARE_CONVERSION_OPERATOR \
  99.      explicit operator underlying_type() const BOOST_NOEXCEPT { return get_underlying_value_(); }
  100.  
  101. #else
  102.  
  103. #define BOOST_SCOPED_ENUM_UT_DECLARE_CONVERSION_OPERATOR
  104.  
  105. #endif
  106.  
  107. /**
  108.  * Start a declaration of a scoped enum.
  109.  *
  110.  * @param EnumType The new scoped enum.
  111.  * @param UnderlyingType The underlying type.
  112.  */
  113. #define BOOST_SCOPED_ENUM_UT_DECLARE_BEGIN(EnumType, UnderlyingType)    \
  114.     struct EnumType {                                                   \
  115.         typedef void is_boost_scoped_enum_tag;                          \
  116.         typedef UnderlyingType underlying_type;                         \
  117.         EnumType() BOOST_NOEXCEPT {}                                    \
  118.         explicit EnumType(underlying_type v) BOOST_NOEXCEPT : v_(v) {}                 \
  119.         underlying_type get_underlying_value_() const BOOST_NOEXCEPT { return v_; }    \
  120.         BOOST_SCOPED_ENUM_UT_DECLARE_CONVERSION_OPERATOR                \
  121.     private:                                                            \
  122.         underlying_type v_;                                             \
  123.         typedef EnumType self_type;                                     \
  124.     public:                                                             \
  125.         enum enum_type
  126.  
  127. #define BOOST_SCOPED_ENUM_DECLARE_END2() \
  128.         enum_type get_native_value_() const BOOST_NOEXCEPT { return enum_type(v_); } \
  129.         friend bool operator ==(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)==enum_type(rhs.v_); } \
  130.         friend bool operator ==(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)==rhs; } \
  131.         friend bool operator ==(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs==enum_type(rhs.v_); } \
  132.         friend bool operator !=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)!=enum_type(rhs.v_); } \
  133.         friend bool operator !=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)!=rhs; } \
  134.         friend bool operator !=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs!=enum_type(rhs.v_); } \
  135.         friend bool operator <(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<enum_type(rhs.v_); } \
  136.         friend bool operator <(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<rhs; } \
  137.         friend bool operator <(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs<enum_type(rhs.v_); } \
  138.         friend bool operator <=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<=enum_type(rhs.v_); } \
  139.         friend bool operator <=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<=rhs; } \
  140.         friend bool operator <=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs<=enum_type(rhs.v_); } \
  141.         friend bool operator >(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>enum_type(rhs.v_); } \
  142.         friend bool operator >(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>rhs; } \
  143.         friend bool operator >(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs>enum_type(rhs.v_); } \
  144.         friend bool operator >=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>=enum_type(rhs.v_); } \
  145.         friend bool operator >=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>=rhs; } \
  146.         friend bool operator >=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs>=enum_type(rhs.v_); } \
  147.     };
  148.  
  149. #define BOOST_SCOPED_ENUM_DECLARE_END(EnumType) \
  150.     ; \
  151.     EnumType(enum_type v) BOOST_NOEXCEPT : v_(v) {}                 \
  152.     BOOST_SCOPED_ENUM_DECLARE_END2()
  153.  
  154. /**
  155.  * Starts a declaration of a scoped enum with the default int underlying type.
  156.  *
  157.  * @param EnumType The new scoped enum.
  158.  */
  159. #define BOOST_SCOPED_ENUM_DECLARE_BEGIN(EnumType) \
  160.   BOOST_SCOPED_ENUM_UT_DECLARE_BEGIN(EnumType,int)
  161.  
  162. /**
  163.  * Name of the native enum type.
  164.  *
  165.  * @param EnumType The new scoped enum.
  166.  */
  167. #define BOOST_SCOPED_ENUM_NATIVE(EnumType) EnumType::enum_type
  168. /**
  169.  * Forward declares an scoped enum.
  170.  *
  171.  * @param EnumType The scoped enum.
  172.  */
  173. #define BOOST_SCOPED_ENUM_FORWARD_DECLARE(EnumType) struct EnumType
  174.  
  175. #else  // BOOST_NO_CXX11_SCOPED_ENUMS
  176.  
  177. #define BOOST_SCOPED_ENUM_UT_DECLARE_BEGIN(EnumType,UnderlyingType) enum class EnumType : UnderlyingType
  178. #define BOOST_SCOPED_ENUM_DECLARE_BEGIN(EnumType) enum class EnumType
  179. #define BOOST_SCOPED_ENUM_DECLARE_END2()
  180. #define BOOST_SCOPED_ENUM_DECLARE_END(EnumType) ;
  181.  
  182. #define BOOST_SCOPED_ENUM_NATIVE(EnumType) EnumType
  183. #define BOOST_SCOPED_ENUM_FORWARD_DECLARE(EnumType) enum class EnumType
  184.  
  185. #endif  // BOOST_NO_CXX11_SCOPED_ENUMS
  186.  
  187. // Deprecated macros
  188. #define BOOST_SCOPED_ENUM_START(name) BOOST_SCOPED_ENUM_DECLARE_BEGIN(name)
  189. #define BOOST_SCOPED_ENUM_END BOOST_SCOPED_ENUM_DECLARE_END2()
  190. #define BOOST_SCOPED_ENUM(name) BOOST_SCOPED_ENUM_NATIVE(name)
  191.  
  192. #endif  // BOOST_CORE_SCOPED_ENUM_HPP
  193.  
downloadscoped_enum.hpp Source code - Download mars Source code
Related Source Codes/Software:
Hero - Elegant transition library for iOS & tvOS 2017-06-09
deep-photo-styletransfer - Code and data for paper "Deep Photo Style Transfer... 2017-06-09
mastodon - A GNU Social-compatible microblogging server ... 2017-06-09
plyr - A simple HTML5, YouTube and Vimeo player ... 2017-06-08
prepack - Prepack is a partial evaluator for JavaScript. Pre... 2017-06-08
Public-APIs - 2017-06-09
lottie-ios - An iOS library to natively render After Effects ve... 2017-06-09
Awesome-Hacking - A collection of various awesome lists for hackers,... 2017-06-09
algorithms - Minimal examples of data structures and algorithms... 2017-06-10
lectures - Oxford Deep NLP 2017 course 2017-06-10
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top