///////////////////////////////////////////////////////////////////////////// // // (C) Copyright Ion Gaztanaga 2013-2013 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/container for documentation. // ///////////////////////////////////////////////////////////////////////////// #ifndef BOOST_CONTAINER_OPTIONS_HPP #define BOOST_CONTAINER_OPTIONS_HPP #ifndef BOOST_CONFIG_HPP # include <boost/config.hpp> #endif #if defined(BOOST_HAS_PRAGMA_ONCE) # pragma once #endif #include <boost/container/detail/config_begin.hpp> #include <boost/container/container_fwd.hpp> #include <boost/intrusive/pack_options.hpp> #include <boost/static_assert.hpp> namespace boost { namespace container { //////////////////////////////////////////////////////////////// // // // OPTIONS FOR ASSOCIATIVE TREE-BASED CONTAINERS // // //////////////////////////////////////////////////////////////// //! Enumeration used to configure ordered associative containers //! with a concrete tree implementation. enum tree_type_enum { red_black_tree, avl_tree, scapegoat_tree, splay_tree }; #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED) template<tree_type_enum TreeType, bool OptimizeSize> struct tree_opt { static const boost::container::tree_type_enum tree_type = TreeType; static const bool optimize_size = OptimizeSize; }; typedef tree_opt<red_black_tree, true> tree_assoc_defaults; #endif //!defined(BOOST_CONTAINER_DOXYGEN_INVOKED) //!This option setter specifies the underlying tree type //!(red-black, AVL, Scapegoat or Splay) for ordered associative containers BOOST_INTRUSIVE_OPTION_CONSTANT(tree_type, tree_type_enum, TreeType, tree_type) //!This option setter specifies if node size is optimized //!storing rebalancing data masked into pointers for ordered associative containers BOOST_INTRUSIVE_OPTION_CONSTANT(optimize_size, bool, Enabled, optimize_size) //! Helper metafunction to combine options into a single type to be used //! by \c boost::container::set, \c boost::container::multiset //! \c boost::container::map and \c boost::container::multimap. //! Supported options are: \c boost::container::optimize_size and \c boost::container::tree_type #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) || defined(BOOST_CONTAINER_VARIADIC_TEMPLATES) template<class ...Options> #else template<class O1 = void, class O2 = void, class O3 = void, class O4 = void> #endif struct tree_assoc_options { /// @cond typedef typename ::boost::intrusive::pack_options < tree_assoc_defaults, #if !defined(BOOST_CONTAINER_VARIADIC_TEMPLATES) O1, O2, O3, O4 #else Options... #endif >::type packed_options; typedef tree_opt<packed_options::tree_type, packed_options::optimize_size> implementation_defined; /// @endcond typedef implementation_defined type; }; #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) //! Helper alias metafunction to combine options into a single type to be used //! by tree-based associative containers template<class ...Options> using tree_assoc_options_t = typename boost::container::tree_assoc_options<Options...>::type; #endif //////////////////////////////////////////////////////////////// // // // OPTIONS FOR ASSOCIATIVE HASH-BASED CONTAINERS // // //////////////////////////////////////////////////////////////// #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED) template<bool StoreHash> struct hash_opt { static const bool store_hash = StoreHash; }; typedef hash_opt<false> hash_assoc_defaults; #endif //!defined(BOOST_CONTAINER_DOXYGEN_INVOKED) //!This option setter specifies if node size is optimized //!storing rebalancing data masked into pointers for ordered associative containers BOOST_INTRUSIVE_OPTION_CONSTANT(store_hash, bool, Enabled, store_hash) //! Helper metafunction to combine options into a single type to be used //! by \c boost::container::hash_set, \c boost::container::hash_multiset //! \c boost::container::hash_map and \c boost::container::hash_multimap. //! Supported options are: \c boost::container::store_hash #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) || defined(BOOST_CONTAINER_VARIADIC_TEMPLATES) template<class ...Options> #else template<class O1 = void, class O2 = void, class O3 = void, class O4 = void> #endif struct hash_assoc_options { /// @cond typedef typename ::boost::intrusive::pack_options < hash_assoc_defaults, #if !defined(BOOST_CONTAINER_VARIADIC_TEMPLATES) O1, O2, O3, O4 #else Options... #endif >::type packed_options; typedef hash_opt<packed_options::store_hash> implementation_defined; /// @endcond typedef implementation_defined type; }; #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) //! Helper alias metafunction to combine options into a single type to be used //! by hash-based associative containers template<class ...Options> using hash_assoc_options_t = typename boost::container::hash_assoc_options<Options...>::type; #endif //////////////////////////////////////////////////////////////// // // // OPTIONS FOR VECTOR-BASED CONTAINERS // // //////////////////////////////////////////////////////////////// #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED) template<class T, class Default> struct default_if_void { typedef T type; }; template<class Default> struct default_if_void<void, Default> { typedef Default type; }; #endif #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED) template<class AllocTraits, class StoredSizeType> struct get_stored_size_type_with_alloctraits { typedef StoredSizeType type; }; template<class AllocTraits> struct get_stored_size_type_with_alloctraits<AllocTraits, void> { typedef typename AllocTraits::size_type type; }; template<class GrowthType, class StoredSizeType> struct vector_opt { typedef GrowthType growth_factor_type; typedef StoredSizeType stored_size_type; template<class AllocTraits> struct get_stored_size_type : get_stored_size_type_with_alloctraits<AllocTraits, StoredSizeType> {}; }; class default_next_capacity; typedef vector_opt<void, void> vector_null_opt; template<class GrowthType, class StoredSizeType> struct devector_opt : vector_opt<GrowthType, StoredSizeType> {}; typedef devector_opt<void, void> devector_null_opt; #else //!defined(BOOST_CONTAINER_DOXYGEN_INVOKED) //!This growth factor argument specifies that the container should increase it's //!capacity a 50% when existing capacity is exhausted. struct growth_factor_50{}; //!This growth factor argument specifies that the container should increase it's //!capacity a 60% when existing capacity is exhausted. struct growth_factor_60{}; //!This growth factor argument specifies that the container should increase it's //!capacity a 100% (doubling its capacity) when existing capacity is exhausted. struct growth_factor_100{}; #endif //!defined(BOOST_CONTAINER_DOXYGEN_INVOKED) //!This option setter specifies the growth factor strategy of the underlying vector. //! //!\tparam GrowthFactor A function object that has the following signature:<br/><br/> //!`template<class SizeType>`<br/> //!`SizeType operator()(SizeType cur_cap, SizeType add_min_cap, SizeType max_cap) const;`.<br/><br/> //!`cur_cap` is the current capacity, `add_min_cap` is the minimum additional capacity //!we want to achieve and `max_cap` is the maximum capacity that the allocator or other //!factors allow. The implementation should return a value between `cur_cap` + `add_min_cap` //!and `max_cap`. `cur_cap` + `add_min_cap` is guaranteed not to overflow/wraparound, //! but the implementation should handle wraparound produced by the growth factor. //! //!Predefined growth factors that can be passed as arguments to this option are: //!\c boost::container::growth_factor_50 //!\c boost::container::growth_factor_60 //!\c boost::container::growth_factor_100 //! //!If this option is not specified, a default will be used by the container. BOOST_INTRUSIVE_OPTION_TYPE(growth_factor, GrowthFactor, GrowthFactor, growth_factor_type) //!This option specifies the unsigned integer type that a user wants the container //!to use to hold size-related information inside a container (e.g. current size, current capacity). //! //!\tparam StoredSizeType An unsigned integer type. It shall be smaller than than the size //! of the size_type deduced from `allocator_traits<A>::size_type` or the same type. //! //!If the maximum capacity() to be used is limited, a user can try to use 8-bit, 16-bit //!(e.g. in 32-bit machines), or 32-bit size types (e.g. in a 64 bit machine) to see if some //!memory can be saved for empty vectors. This could potentially performance benefits due to better //!cache usage. //! //!Note that alignment requirements can disallow theoretical space savings. Example: //!\c vector holds a pointer and two size types (for size and capacity), in a 32 bit machine //!a 8 bit size type (total size: 4 byte pointer + 2 x 1 byte sizes = 6 bytes) //!will not save space when comparing two 16-bit size types because usually //!a 32 bit alignment is required for vector and the size will be rounded to 8 bytes. In a 64-bit //!machine a 16 bit size type does not usually save memory when comparing to a 32-bit size type. //!Measure the size of the resulting container and do not assume a smaller \c stored_size //!will always lead to a smaller sizeof(container). //! //!If a user tries to insert more elements than representable by \c stored_size, vector //!will throw a length_error. //! //!If this option is not specified, `allocator_traits<A>::size_type` (usually std::size_t) will //!be used to store size-related information inside the container. BOOST_INTRUSIVE_OPTION_TYPE(stored_size, StoredSizeType, StoredSizeType, stored_size_type) //! Helper metafunction to combine options into a single type to be used //! by \c boost::container::vector. //! Supported options are: \c boost::container::growth_factor and \c boost::container::stored_size #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) || defined(BOOST_CONTAINER_VARIADIC_TEMPLATES) template<class ...Options> #else template<class O1 = void, class O2 = void, class O3 = void, class O4 = void> #endif struct vector_options { /// @cond typedef typename ::boost::intrusive::pack_options < vector_null_opt, #if !defined(BOOST_CONTAINER_VARIADIC_TEMPLATES) O1, O2, O3, O4 #else Options... #endif >::type packed_options; typedef vector_opt< typename packed_options::growth_factor_type , typename packed_options::stored_size_type> implementation_defined; /// @endcond typedef implementation_defined type; }; #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) //! Helper alias metafunction to combine options into a single type to be used //! by \c boost::container::vector. //! Supported options are: \c boost::container::growth_factor and \c boost::container::stored_size template<class ...Options> using vector_options_t = typename boost::container::vector_options<Options...>::type; #endif //////////////////////////////////////////////////////////////// // // // OPTIONS FOR SMALL-VECTOR CONTAINER // // //////////////////////////////////////////////////////////////// //! This option specifies the desired alignment for the value_type stored //! in the container. //! A value zero represents the natural alignment. //! //!\tparam Alignment An unsigned integer value. Must be power of two. BOOST_INTRUSIVE_OPTION_CONSTANT(inplace_alignment, std::size_t, Alignment, inplace_alignment) #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED) template<class GrowthType, std::size_t InplaceAlignment> struct small_vector_opt { typedef GrowthType growth_factor_type; static const std::size_t inplace_alignment = InplaceAlignment; }; typedef small_vector_opt<void, 0u> small_vector_null_opt; #endif //!defined(BOOST_CONTAINER_DOXYGEN_INVOKED) //! Helper metafunction to combine options into a single type to be used //! by \c boost::container::small_vector. //! Supported options are: \c boost::container::growth_factor and \c boost::container::inplace_alignment #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) || defined(BOOST_CONTAINER_VARIADIC_TEMPLATES) template<class ...Options> #else template<class O1 = void, class O2 = void, class O3 = void, class O4 = void> #endif struct small_vector_options { /// @cond typedef typename ::boost::intrusive::pack_options < small_vector_null_opt, #if !defined(BOOST_CONTAINER_VARIADIC_TEMPLATES) O1, O2, O3, O4 #else Options... #endif >::type packed_options; typedef small_vector_opt< typename packed_options::growth_factor_type , packed_options::inplace_alignment> implementation_defined; /// @endcond typedef implementation_defined type; }; #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) //! Helper alias metafunction to combine options into a single type to be used //! by \c boost::container::small_vector. //! Supported options are: \c boost::container::growth_factor and \c boost::container::stored_size template<class ...Options> using small_vector_options_t = typename boost::container::small_vector_options<Options...>::type; #endif //////////////////////////////////////////////////////////////// // // // OPTIONS FOR STATIC-VECTOR CONTAINER // // //////////////////////////////////////////////////////////////// //!This option specifies if the container will throw if in //!the static capacity is not sufficient to hold the required //!values. If false is specified, insufficient capacity will //!lead to BOOST_ASSERT, and if this assertion returns, to undefined behaviour, //!which potentially can lead to better static_vector performance. //!The default value is true. //! //!\tparam ThrowOnExhaustion A boolean value. True if throw is required. BOOST_INTRUSIVE_OPTION_CONSTANT(throw_on_overflow, bool, ThrowOnOverflow, throw_on_overflow) #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED) template<bool ThrowOnOverflow, std::size_t InplaceAlignment> struct static_vector_opt { static const bool throw_on_overflow = ThrowOnOverflow; static const std::size_t inplace_alignment = InplaceAlignment; }; typedef static_vector_opt<true, 0u> static_vector_null_opt; #endif //!defined(BOOST_CONTAINER_DOXYGEN_INVOKED) //! Helper metafunction to combine options into a single type to be used //! by \c boost::container::static_vector. //! Supported options are: \c boost::container::throw_on_overflow and \c boost::container::inplace_alignment #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) || defined(BOOST_CONTAINER_VARIADIC_TEMPLATES) template<class ...Options> #else template<class O1 = void, class O2 = void, class O3 = void, class O4 = void> #endif struct static_vector_options { /// @cond typedef typename ::boost::intrusive::pack_options < static_vector_null_opt, #if !defined(BOOST_CONTAINER_VARIADIC_TEMPLATES) O1, O2, O3, O4 #else Options... #endif >::type packed_options; typedef static_vector_opt< packed_options::throw_on_overflow , packed_options::inplace_alignment> implementation_defined; /// @endcond typedef implementation_defined type; }; #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) //! Helper alias metafunction to combine options into a single type to be used //! by \c boost::container::static_vector. //! Supported options are: \c boost::container::growth_factor and \c boost::container::stored_size template<class ...Options> using static_vector_options_t = typename boost::container::static_vector_options<Options...>::type; #endif //! Helper metafunction to combine options into a single type to be used //! by \c boost::container::devector. //! Supported options are: \c boost::container::growth_factor and \c boost::container::stored_size #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) || defined(BOOST_CONTAINER_VARIADIC_TEMPLATES) template<class ...Options> #else template<class O1 = void, class O2 = void, class O3 = void, class O4 = void> #endif struct devector_options { /// @cond typedef typename ::boost::intrusive::pack_options < devector_null_opt, #if !defined(BOOST_CONTAINER_VARIADIC_TEMPLATES) O1, O2, O3, O4 #else Options... #endif >::type packed_options; typedef devector_opt< typename packed_options::growth_factor_type , typename packed_options::stored_size_type> implementation_defined; /// @endcond typedef implementation_defined type; }; #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) //! Helper alias metafunction to combine options into a single type to be used //! by \c boost::container::devector. //! Supported options are: \c boost::container::growth_factor and \c boost::container::stored_size template<class ...Options> using devector_options_t = typename boost::container::devector_options<Options...>::type; #endif //////////////////////////////////////////////////////////////// // // // OPTIONS FOR DEQUE-BASED CONTAINERS // // //////////////////////////////////////////////////////////////// #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED) template<std::size_t BlockBytes, std::size_t BlockSize> struct deque_opt { static const std::size_t block_bytes = BlockBytes; static const std::size_t block_size = BlockSize; BOOST_STATIC_ASSERT_MSG(!(block_bytes && block_size), "block_bytes and block_size can't be specified at the same time"); }; typedef deque_opt<0u, 0u> deque_null_opt; #endif //! Helper metafunction to combine options into a single type to be used //! by \c boost::container::deque. //! Supported options are: \c boost::container::block_bytes #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) || defined(BOOST_CONTAINER_VARIADIC_TEMPLATES) template<class ...Options> #else template<class O1 = void, class O2 = void, class O3 = void, class O4 = void> #endif struct deque_options { /// @cond typedef typename ::boost::intrusive::pack_options < deque_null_opt, #if !defined(BOOST_CONTAINER_VARIADIC_TEMPLATES) O1, O2, O3, O4 #else Options... #endif >::type packed_options; typedef deque_opt< packed_options::block_bytes, packed_options::block_size > implementation_defined; /// @endcond typedef implementation_defined type; }; #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) //! Helper alias metafunction to combine options into a single type to be used //! by \c boost::container::deque. //! Supported options are: \c boost::container::block_bytes template<class ...Options> using deque_options_t = typename boost::container::deque_options<Options...>::type; #endif //!This option specifies the maximum size of a block in bytes: this delimites the number of contiguous elements //!that will be allocated by deque as min(1u, BlockBytes/sizeof(value_type)) //!A value zero represents the default value. //! //!\tparam BlockBytes An unsigned integer value. BOOST_INTRUSIVE_OPTION_CONSTANT(block_bytes, std::size_t, BlockBytes, block_bytes) //!This option specifies the size of a block, delimites the number of contiguous elements //!that will be allocated by deque as BlockSize. //!A value zero represents the default value. //! //!\tparam BlockBytes An unsigned integer value. BOOST_INTRUSIVE_OPTION_CONSTANT(block_size, std::size_t, BlockSize, block_size) } //namespace container { } //namespace boost { #include <boost/container/detail/config_end.hpp> #endif //#ifndef BOOST_CONTAINER_OPTIONS_HPP