generic-variant.hh

Go to the documentation of this file.

#ifndef MISC_GENERIC_VARIANT_HH
# define MISC_GENERIC_VARIANT_HH

# include <boost/variant.hpp>
# include <boost/preprocessor/repetition/repeat_from_to.hpp>

# define MISC_GENERIC_VARIANT_AUX_DECLARE_PARAMS_IMPL(z, N, T)               \
   typename BOOST_PP_CAT(T, N) = BOOST_PP_CAT(boost::detail::variant::void, N)

# define MISC_GENERIC_VARIANT_AUX_DECLARE_PARAMS        \
    BOOST_PP_ENUM(                                      \
          BOOST_VARIANT_LIMIT_TYPES                     \
        , MISC_GENERIC_VARIANT_AUX_DECLARE_PARAMS_IMPL  \
        , T                                             \
        )


// Distinct void ``tags'' trick, copied from boost/variant/variant_fwd.hpp.
# define BOOST_VARIANT_DETAIL_DEFINE_VOID_N(z, N, _)    \
    struct BOOST_PP_CAT(void, N);                      \
                                                        \
    template<>                                          \
    struct convert_void< BOOST_PP_CAT(void, N) >        \
    {                                                   \
        typedef mpl::na type;                           \
    };

namespace boost
{
  namespace detail
  {
    namespace variant
    {
      BOOST_PP_REPEAT(
            BOOST_VARIANT_LIMIT_TYPES
          , BOOST_VARIANT_DETAIL_DEFINE_VOID_N
          , _
          )
    }
  }
}

# undef BOOST_VARIANT_DETAIL_DEFINE_VOID_N

namespace misc
{

  template < MISC_GENERIC_VARIANT_AUX_DECLARE_PARAMS >
  class generic_variant;

} // namespace misc

# undef MISC_GENERIC_VARIANT_AUX_DECLARE_PARAMS_IMPL
# undef MISC_GENERIC_VARIANT_AUX_DECLARE_PARAMS

# define MISC_GENERIC_VARIANT_CONVERSION_OPERATOR_DECL(z, N, T) \
   operator BOOST_PP_CAT(T,N) & ();
# define MISC_GENERIC_VARIANT_CONST_CONVERSION_OPERATOR_DECL(z, N, T)   \
   operator const BOOST_PP_CAT(T,N) & () const;



namespace misc
{
  template <typename T0_, BOOST_VARIANT_ENUM_SHIFTED_PARAMS(typename T)>
  class generic_variant :
    public boost::variant<T0_, BOOST_VARIANT_ENUM_SHIFTED_PARAMS(T)>
  {
  public:
    typedef generic_variant<T0_, BOOST_VARIANT_ENUM_SHIFTED_PARAMS(T)>
      self_type;
    typedef boost::variant<T0_, BOOST_VARIANT_ENUM_SHIFTED_PARAMS(T)>
      super_type;

    generic_variant();
    template <typename U> generic_variant(const U& rhs);

    template <typename U> self_type& operator=(const U&);

    operator T0_& ();
    BOOST_PP_REPEAT_FROM_TO(
          1
        , BOOST_VARIANT_LIMIT_TYPES
        , MISC_GENERIC_VARIANT_CONVERSION_OPERATOR_DECL
        , T
        )

    operator const T0_& () const;
    BOOST_PP_REPEAT_FROM_TO(
          1
        , BOOST_VARIANT_LIMIT_TYPES
        , MISC_GENERIC_VARIANT_CONST_CONVERSION_OPERATOR_DECL
        , T
        )
  };

} // namespace misc

# undef MISC_GENERIC_VARIANT_CONST_CONVERSION_OPERATOR_DECL
# undef MISC_GENERIC_VARIANT_CONVERSION_OPERATOR_DECL

# include <misc/generic-variant.hxx>

#endif // !MISC_GENERIC_VARIANT_HH