third_party/boost/container/include/boost/container/options.hpp - platform/external/sdv/vsomeip - Git at Google

 /////////////////////////////////////////////////////////////////////////////
 //
 // (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
	/////////////////////////////////////////////////////////////////////////////
	//
	// (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