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 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 dtl { 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 dtl::enable_if 134 < dtl::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 dtl { 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 : dtl::uses_allocator_imp<T, Allocator> 165 {}; 166 167 }} //namespace boost::container 168 169 #endif //BOOST_CONTAINER_USES_ALLOCATOR_HPP 170