boost/intrusive/pack_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/intrusive for documentation. // ///////////////////////////////////////////////////////////////////////////// #ifndef BOOST_INTRUSIVE_PACK_OPTIONS_HPP #define BOOST_INTRUSIVE_PACK_OPTIONS_HPP #include <boost/intrusive/detail/config_begin.hpp> #if defined(BOOST_HAS_PRAGMA_ONCE) # pragma once #endif #include <cstddef> namespace boost { namespace intrusive { #ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) template<class Prev, class Next> struct do_pack { //Use "pack" member template to pack options typedef typename Next::template pack<Prev> type; }; template<class Prev> struct do_pack<Prev, void> { //Avoid packing "void" to shorten template names typedef Prev type; }; template < class DefaultOptions , class O1 = void , class O2 = void , class O3 = void , class O4 = void , class O5 = void , class O6 = void , class O7 = void , class O8 = void , class O9 = void , class O10 = void , class O11 = void > struct pack_options { // join options typedef typename do_pack < typename do_pack < typename do_pack < typename do_pack < typename do_pack < typename do_pack < typename do_pack < typename do_pack < typename do_pack < typename do_pack < typename do_pack < DefaultOptions , O1 >::type , O2 >::type , O3 >::type , O4 >::type , O5 >::type , O6 >::type , O7 >::type , O8 >::type , O9 >::type , O10 >::type , O11 >::type type; }; #else //index_tuple template<std::size_t... Indexes> struct index_tuple{}; //build_number_seq template<std::size_t Num, typename Tuple = index_tuple<> > struct build_number_seq; template<std::size_t Num, std::size_t... Indexes> struct build_number_seq<Num, index_tuple<Indexes...> > : build_number_seq<Num - 1, index_tuple<Indexes..., sizeof...(Indexes)> > {}; template<std::size_t... Indexes> struct build_number_seq<0, index_tuple<Indexes...> > { typedef index_tuple<Indexes...> type; }; template<class ...Types> struct typelist {}; //invert_typelist template<class T> struct invert_typelist; template<std::size_t I, typename Tuple> struct typelist_element; template<std::size_t I, typename Head, typename... Tail> struct typelist_element<I, typelist<Head, Tail...> > { typedef typename typelist_element<I-1, typelist<Tail...> >::type type; }; template<typename Head, typename... Tail> struct typelist_element<0, typelist<Head, Tail...> > { typedef Head type; }; template<std::size_t ...Ints, class ...Types> typelist<typename typelist_element<(sizeof...(Types) - 1) - Ints, typelist<Types...> >::type...> inverted_typelist(index_tuple<Ints...>, typelist<Types...>) { return typelist<typename typelist_element<(sizeof...(Types) - 1) - Ints, typelist<Types...> >::type...>(); } //sizeof_typelist template<class Typelist> struct sizeof_typelist; template<class ...Types> struct sizeof_typelist< typelist<Types...> > { static const std::size_t value = sizeof...(Types); }; //invert_typelist_impl template<class Typelist, class Indexes> struct invert_typelist_impl; template<class Typelist, std::size_t ...Ints> struct invert_typelist_impl< Typelist, index_tuple<Ints...> > { static const std::size_t last_idx = sizeof_typelist<Typelist>::value - 1; typedef typelist <typename typelist_element<last_idx - Ints, Typelist>::type...> type; }; template<class Typelist, std::size_t Int> struct invert_typelist_impl< Typelist, index_tuple<Int> > { typedef Typelist type; }; template<class Typelist> struct invert_typelist_impl< Typelist, index_tuple<> > { typedef Typelist type; }; //invert_typelist template<class Typelist> struct invert_typelist; template<class ...Types> struct invert_typelist< typelist<Types...> > { typedef typelist<Types...> typelist_t; typedef typename build_number_seq<sizeof...(Types)>::type indexes_t; typedef typename invert_typelist_impl<typelist_t, indexes_t>::type type; }; //Do pack template<class Typelist> struct do_pack; template<> struct do_pack<typelist<> >; template<class Prev> struct do_pack<typelist<Prev> > { typedef Prev type; }; template<class Prev, class Last> struct do_pack<typelist<Prev, Last> > { typedef typename Prev::template pack<Last> type; }; template<class ...Others> struct do_pack<typelist<void, Others...> > { typedef typename do_pack<typelist<Others...> >::type type; }; template<class Prev, class ...Others> struct do_pack<typelist<Prev, Others...> > { typedef typename Prev::template pack <typename do_pack<typelist<Others...> >::type> type; }; template<class DefaultOptions, class ...Options> struct pack_options { typedef typelist<DefaultOptions, Options...> typelist_t; typedef typename invert_typelist<typelist_t>::type inverted_typelist; typedef typename do_pack<inverted_typelist>::type type; }; #endif //!defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) #define BOOST_INTRUSIVE_OPTION_TYPE(OPTION_NAME, TYPE, TYPEDEF_EXPR, TYPEDEF_NAME) \ template< class TYPE> \ struct OPTION_NAME \ { \ template<class Base> \ struct pack : Base \ { \ typedef TYPEDEF_EXPR TYPEDEF_NAME; \ }; \ }; \ // #define BOOST_INTRUSIVE_OPTION_CONSTANT(OPTION_NAME, TYPE, VALUE, CONSTANT_NAME) \ template< TYPE VALUE> \ struct OPTION_NAME \ { \ template<class Base> \ struct pack : Base \ { \ static const TYPE CONSTANT_NAME = VALUE; \ }; \ }; \ // #else //#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED //! This class is a utility that takes: //! - a default options class defining initial static constant //! and typedefs //! - several options defined with BOOST_INTRUSIVE_OPTION_CONSTANT and //! BOOST_INTRUSIVE_OPTION_TYPE //! //! and packs them together in a new type that defines all options as //! member typedefs or static constant values. Given options of form: //! //! \code //! BOOST_INTRUSIVE_OPTION_TYPE(my_pointer, VoidPointer, VoidPointer, my_pointer_type) //! BOOST_INTRUSIVE_OPTION_CONSTANT(incremental, bool, Enabled, is_incremental) //! \endcode //! //! the following expression //! //! \code //! //! struct default_options //! { //! typedef long int_type; //! static const int int_constant = -1; //! }; //! //! pack_options< default_options, my_pointer<void*>, incremental<true> >::type //! \endcode //! //! will create a type that will contain the following typedefs/constants //! //! \code //! struct unspecified_type //! { //! //Default options //! typedef long int_type; //! static const int int_constant = -1; //! //! //Packed options (will ovewrite any default option) //! typedef void* my_pointer_type; //! static const bool is_incremental = true; //! }; //! \endcode //! //! If an option is specified in the default options argument and later //! redefined as an option, the last definition will prevail. template<class DefaultOptions, class ...Options> struct pack_options { typedef unspecified_type type; }; //! Defines an option class of name OPTION_NAME that can be used to specify a type //! of type TYPE... //! //! \code //! struct OPTION_NAME<class TYPE> //! { unspecified_content }; //! \endcode //! //! ...that after being combined with //! <code>boost::intrusive::pack_options</code>, //! will typedef TYPE as a typedef of name TYPEDEF_NAME. Example: //! //! \code //! //[includes and namespaces omitted for brevity] //! //! //This macro will create the following class: //! // template<class VoidPointer> //! // struct my_pointer //! // { unspecified_content }; //! BOOST_INTRUSIVE_OPTION_TYPE(my_pointer, VoidPointer, boost::remove_pointer<VoidPointer>::type, my_pointer_type) //! //! struct empty_default{}; //! //! typedef pack_options< empty_default, typename my_pointer<void*> >::type::my_pointer_type type; //! //! BOOST_STATIC_ASSERT(( boost::is_same<type, void>::value )); //! //! \endcode #define BOOST_INTRUSIVE_OPTION_TYPE(OPTION_NAME, TYPE, TYPEDEF_EXPR, TYPEDEF_NAME) //! Defines an option class of name OPTION_NAME that can be used to specify a constant //! of type TYPE with value VALUE... //! //! \code //! struct OPTION_NAME<TYPE VALUE> //! { unspecified_content }; //! \endcode //! //! ...that after being combined with //! <code>boost::intrusive::pack_options</code>, //! will contain a CONSTANT_NAME static constant of value VALUE. Example: //! //! \code //! //[includes and namespaces omitted for brevity] //! //! //This macro will create the following class: //! // template<bool Enabled> //! // struct incremental //! // { unspecified_content }; //! BOOST_INTRUSIVE_OPTION_CONSTANT(incremental, bool, Enabled, is_incremental) //! //! struct empty_default{}; //! //! const bool is_incremental = pack_options< empty_default, incremental<true> >::type::is_incremental; //! //! BOOST_STATIC_ASSERT(( is_incremental == true )); //! //! \endcode #define BOOST_INTRUSIVE_OPTION_CONSTANT(OPTION_NAME, TYPE, VALUE, CONSTANT_NAME) #endif //#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED } //namespace intrusive { } //namespace boost { #include <boost/intrusive/detail/config_end.hpp> #endif //#ifndef BOOST_INTRUSIVE_PACK_OPTIONS_HPP