BVB Source Codes

mars Show uses_allocator.hpp Source code

Return Download mars: download uses_allocator.hpp Source code - Download mars Source code - Type:.hpp
  1. //////////////////////////////////////////////////////////////////////////////
  2. //
  3. // (C) Copyright Ion Gaztanaga 2011-2013. 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_USES_ALLOCATOR_HPP
  12. #define BOOST_CONTAINER_USES_ALLOCATOR_HPP
  13.  
  14. #include <boost/container/uses_allocator_fwd.hpp>
  15. #include <boost/container/detail/type_traits.hpp>
  16.  
  17. namespace mars_boost {} namespace boost = mars_boost; namespace mars_boost {
  18. namespace container {
  19.  
  20. //! <b>Remark</b>: if a specialization constructible_with_allocator_suffix<X>::value is true, indicates that T may be constructed
  21. //! with an allocator as its last constructor argument.  Ideally, all constructors of T (including the
  22. //! copy and move constructors) should have a variant that accepts a final argument of
  23. //! allocator_type.
  24. //!
  25. //! <b>Requires</b>: if a specialization constructible_with_allocator_suffix<X>::value is true, T must have a nested type,
  26. //! allocator_type and at least one constructor for which allocator_type is the last
  27. //! parameter.  If not all constructors of T can be called with a final allocator_type argument,
  28. //! and if T is used in a context where a container must call such a constructor, then the program is
  29. //! ill-formed.
  30. //!
  31. //! <code>
  32. //!  template <class T, class Allocator = allocator<T> >
  33. //!  class Z {
  34. //!    public:
  35. //!      typedef Allocator allocator_type;
  36. //!
  37. //!    // Default constructor with optional allocator suffix
  38. //!    Z(const allocator_type& a = allocator_type());
  39. //!
  40. //!    // Copy constructor and allocator-extended copy constructor
  41. //!    Z(const Z& zz);
  42. //!    Z(const Z& zz, const allocator_type& a);
  43. //! };
  44. //!
  45. //! // Specialize trait for class template Z
  46. //! template <class T, class Allocator = allocator<T> >
  47. //! struct constructible_with_allocator_suffix<Z<T,Allocator> >
  48. //! { static const bool value = true;  };
  49. //! </code>
  50. //!
  51. //! <b>Note</b>: This trait is a workaround inspired by "N2554: The Scoped A Model (Rev 2)"
  52. //! (Pablo Halpern, 2008-02-29) to backport the scoped allocator model to C++03, as
  53. //! in C++03 there is no mechanism to detect if a type can be constructed from arbitrary arguments.
  54. //! Applications aiming portability with several compilers should always define this trait.
  55. //!
  56. //! In conforming C++11 compilers or compilers supporting SFINAE expressions
  57. //! (when BOOST_NO_SFINAE_EXPR is NOT defined), this trait is ignored and C++11 rules will be used
  58. //! to detect if a type should be constructed with suffix or prefix allocator arguments.
  59. template <class T>
  60. struct constructible_with_allocator_suffix
  61. {  static const bool value = false; };
  62.  
  63. //! <b>Remark</b>: if a specialization constructible_with_allocator_prefix<X>::value is true, indicates that T may be constructed
  64. //! with allocator_arg and T::allocator_type as its first two constructor arguments.
  65. //! Ideally, all constructors of T (including the copy and move constructors) should have a variant
  66. //! that accepts these two initial arguments.
  67. //!
  68. //! <b>Requires</b>: specialization constructible_with_allocator_prefix<X>::value is true, T must have a nested type,
  69. //! allocator_type and at least one constructor for which allocator_arg_t is the first
  70. //! parameter and allocator_type is the second parameter.  If not all constructors of T can be
  71. //! called with these initial arguments, and if T is used in a context where a container must call such
  72. //! a constructor, then the program is ill-formed.
  73. //!
  74. //! <code>
  75. //! template <class T, class Allocator = allocator<T> >
  76. //! class Y {
  77. //!    public:
  78. //!       typedef Allocator allocator_type;
  79. //!
  80. //!       // Default constructor with and allocator-extended default constructor
  81. //!       Y();
  82. //!       Y(allocator_arg_t, const allocator_type& a);
  83. //!
  84. //!       // Copy constructor and allocator-extended copy constructor
  85. //!       Y(const Y& yy);
  86. //!       Y(allocator_arg_t, const allocator_type& a, const Y& yy);
  87. //!
  88. //!       // Variadic constructor and allocator-extended variadic constructor
  89. //!       template<class ...Args> Y(Args&& args...);
  90. //!       template<class ...Args>
  91. //!       Y(allocator_arg_t, const allocator_type& a, BOOST_FWD_REF(Args)... args);
  92. //! };
  93. //!
  94. //! // Specialize trait for class template Y
  95. //! template <class T, class Allocator = allocator<T> >
  96. //! struct constructible_with_allocator_prefix<Y<T,Allocator> >
  97. //! { static const bool value = true;  };
  98. //!
  99. //! </code>
  100. //!
  101. //! <b>Note</b>: This trait is a workaround inspired by "N2554: The Scoped Allocator Model (Rev 2)"
  102. //! (Pablo Halpern, 2008-02-29) to backport the scoped allocator model to C++03, as
  103. //! in C++03 there is no mechanism to detect if a type can be constructed from arbitrary arguments.
  104. //! Applications aiming portability with several compilers should always define this trait.
  105. //!
  106. //! In conforming C++11 compilers or compilers supporting SFINAE expressions
  107. //! (when BOOST_NO_SFINAE_EXPR is NOT defined), this trait is ignored and C++11 rules will be used
  108. //! to detect if a type should be constructed with suffix or prefix allocator arguments.
  109. template <class T>
  110. struct constructible_with_allocator_prefix
  111. {  static const bool value = false; };
  112.  
  113. #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
  114.  
  115. namespace container_detail {
  116.  
  117. template<typename T, typename Allocator>
  118. struct uses_allocator_imp
  119. {
  120.    // Use SFINAE (Substitution Failure Is Not An Error) to detect the
  121.    // presence of an 'allocator_type' nested type convertilble from Allocator.
  122.    private:
  123.    typedef char yes_type;
  124.    struct no_type{ char dummy[2]; };
  125.  
  126.    // Match this function if T::allocator_type exists and is
  127.    // implicitly convertible from Allocator
  128.    template <class U>
  129.    static yes_type test(typename U::allocator_type);
  130.  
  131.    // Match this function if T::allocator_type exists and it's type is `erased_type`.
  132.    template <class U, class V>
  133.    static typename container_detail::enable_if
  134.       < container_detail::is_same<typename U::allocator_type, erased_type>
  135.       , yes_type
  136.       >::type  test(const V&);
  137.  
  138.    // Match this function if TypeT::allocator_type does not exist or is
  139.    // not convertible from Allocator.
  140.    template <typename U>
  141.    static no_type test(...);
  142.    static Allocator alloc;  // Declared but not defined
  143.  
  144.    public:
  145.    static const bool value = sizeof(test<T>(alloc)) == sizeof(yes_type);
  146. };
  147.  
  148. }  //namespace container_detail {
  149.  
  150. #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
  151.  
  152. //! <b>Remark</b>: Automatically detects whether T has a nested allocator_type that is convertible from
  153. //! Allocator. Meets the BinaryTypeTrait requirements ([meta.rqmts] 20.4.1). A program may
  154. //! specialize this type to define uses_allocator<X>::value as true for a T of user-defined type if T does not
  155. //! have a nested allocator_type but is nonetheless constructible using the specified Allocator where either:
  156. //! the first argument of a constructor has type allocator_arg_t and the second argument has type Alloc or
  157. //! the last argument of a constructor has type Alloc.
  158. //!
  159. //! <b>Result</b>: uses_allocator<T, Allocator>::value== true if a type T::allocator_type
  160. //! exists and either is_convertible<Alloc, T::allocator_type>::value != false or T::allocator_type
  161. //! is an alias `erased_type`. False otherwise.
  162. template <typename T, typename Allocator>
  163. struct uses_allocator
  164.    : container_detail::uses_allocator_imp<T, Allocator>
  165. {};
  166.  
  167. }} //namespace mars_boost::container
  168.  
  169. #endif   //BOOST_CONTAINER_USES_ALLOCATOR_HPP
  170.  
downloaduses_allocator.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