#include <boost/tuple/tuple.hpp>
#include <boost/tuple/tuple_io.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repeat_from_to.hpp>
#include <boost/preprocessor/arithmetic/mul.hpp>
#include <boost/preprocessor/punctuation/comma_if.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/find.hpp>
#include <boost/mpl/unique.hpp>
#include <boost/mpl/size.hpp>
#include <Boost/mpl/at.hpp>
#include <boost/type_traits/is_same.hpp>
#include <string>
#include <iostream>

#ifndef FAKIE_TAGGED_TUPLE_MAX_ARITY
# define FAKIE_TAGGED_TUPLE_MAX_ARITY 10
#elif FAKIE_TAGGED_TUPLE_MAX_ARITY > 10
#error boost::tuples doesn't support arity > 10
#endif

namespace fakie
{

#define FAKIE_TAGGED_TUPLE_DETAIL_TYPES(z, n, text)\
    BOOST_PP_COMMA_IF(n) BOOST_PP_CAT(text, BOOST_PP_MUL(2, n))

#define FAKIE_TAGGED_TUPLE_DETAIL_VALUES(z, n, text)\
    BOOST_PP_COMMA_IF(n) BOOST_PP_CAT(text, BOOST_PP_ADD(BOOST_PP_MUL(2, n), 1))

#define FAKIE_TAGGED_TUPLE_DETAIL_MPL_2_TUPLE(z, n, text)\
    BOOST_PP_COMMA_IF(n)\
    typename boost::mpl::if_<\
        boost::is_same<BOOST_PP_CAT(text, BOOST_PP_MUL(2, n)), boost::mpl::na>,\
        boost::tuples::null_type,\
        BOOST_PP_CAT(text, BOOST_PP_MUL(2, n))\
    >::type

    template<typename Types, typename Names>
    struct detail_check_types_and_names
        : boost::enable_if_c<boost::mpl::size<Types>::type::value == boost::mpl::size<Names>::type::value>
        , boost::enable_if<boost::is_same<typename boost::mpl::unique<Types>::type, Types> >
    {
    };

    template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PP_MUL(2, FAKIE_TAGGED_TUPLE_MAX_ARITY), typename T, boost::mpl::na)>
    struct tagged_tuple
        : boost::tuple<BOOST_PP_REPEAT(FAKIE_TAGGED_TUPLE_MAX_ARITY, FAKIE_TAGGED_TUPLE_DETAIL_MPL_2_TUPLE, T)>
    {
        typedef boost::mpl::vector<BOOST_PP_REPEAT(FAKIE_TAGGED_TUPLE_MAX_ARITY, FAKIE_TAGGED_TUPLE_DETAIL_TYPES, T)>  Types;
        typedef boost::mpl::vector<BOOST_PP_REPEAT(FAKIE_TAGGED_TUPLE_MAX_ARITY, FAKIE_TAGGED_TUPLE_DETAIL_VALUES, T)> Names;
        typedef boost::tuple<BOOST_PP_REPEAT(FAKIE_TAGGED_TUPLE_MAX_ARITY, FAKIE_TAGGED_TUPLE_DETAIL_MPL_2_TUPLE, T)>  Base;
#undef FAKIE_TAGGED_TUPLE_DETAIL_TYPES
#undef FAKIE_TAGGED_TUPLE_DETAIL_VALUES
#undef FAKIE_TAGGED_TUPLE_DETAIL_MPL_2_TUPLE

#define FAKIE_TAGGED_TUPLE_DETAIL_CTORS(z, n, text)\
        template<BOOST_PP_ENUM_PARAMS(n, typename U)>\
        tagged_tuple(BOOST_PP_ENUM_BINARY_PARAMS(n, U, & u), detail_check_types_and_names<Types, Names> * = 0)\
            : Base(BOOST_PP_ENUM_PARAMS(n, u)) {}

        tagged_tuple(detail_check_types_and_names<Types, Names> * = 0) {}

        BOOST_PP_REPEAT_FROM_TO(1, FAKIE_TAGGED_TUPLE_MAX_ARITY, FAKIE_TAGGED_TUPLE_DETAIL_CTORS, _)

#undef  FAKIE_TAGGED_TUPLE_DETAIL_CTORS

        using Base::get;

        template<typename T>
        typename boost::tuples::access_traits<
            typename boost::mpl::at_c<
                Types, 
                boost::mpl::find<Names, T>::type::pos::value
            >::type
        >::non_const_type get ()
        {
            return boost::tuples::get<boost::mpl::find<Names, T>::type::pos::value>(*this);
        }

        template<typename T>
        typename boost::tuples::access_traits<
            typename boost::mpl::at_c<
                Types, 
                boost::mpl::find<Names, T>::type::pos::value
            >::type
        >::const_type get () const
        {
            return boost::tuples::get<boost::mpl::find<Names, T>::type::pos::value>(*this);
        }
    };
}

class name_t {};
class value_t {};

int main()
{
    using namespace fakie;

    tagged_tuple<std::string, name_t, int, value_t> s;
    
    s.get<name_t>()   = "Hello World";
    s.get<value_t>()  = 2005;

    std::cout << s << ' '
              << sizeof(s) << ' '
              << sizeof(boost::tuple<std::string, int>) << ' '
              << sizeof(std::string) + sizeof(int);

    return 0;
}