Ticket #4755: main.cpp

#include <boost/fusion/include/map.hpp>
#include <boost/fusion/include/pair.hpp>
#include <boost/fusion/include/at_key.hpp>
#include <boost/fusion/include/mpl.hpp>

#include <boost/mpl/vector.hpp>
#include <boost/mpl/copy.hpp>
#include <boost/mpl/zip_view.hpp>
#include <boost/mpl/back_inserter.hpp>
#include <boost/mpl/for_each.hpp>
#include <boost/mpl/range_c.hpp>
#include <boost/mpl/transform.hpp>
#include <boost/mpl/placeholders.hpp>

namespace detail {

template <typename T>
struct add_pair_size
{
        typedef boost::fusion::pair<T, size_t> type;
};

template <typename TTypes>
struct types_to_size_type
{
        typedef typename boost::mpl::transform<
                TTypes,
                add_pair_size<boost::mpl::placeholders::_1>,
                boost::mpl::back_inserter<boost::mpl::vector<> > >::type size_seq;
        typedef typename boost::fusion::result_of::as_map<size_seq>::type type;
};

template <typename TTypes0, typename TSize0, typename TTypes1, typename TSize1>
struct copy_size
{
        copy_size(const TSize0& size0, TSize1& size1)
                : _size0(size0), _size1(size1)
        {}

        typedef void result_type;

        template <typename TIndex>
        void operator()(TIndex) const
        {
                typedef typename boost::mpl::at<TTypes0, TIndex>::type Type0;
                typedef typename boost::mpl::at<TTypes1, TIndex>::type Type1;

                boost::fusion::at_key<Type1>(_size1) = boost::fusion::at_key<Type0>(_size0);
        }

private:
        const TSize0& _size0;
        TSize1& _size1;
};

} // namespace detail

int main()
{
        typedef boost::mpl::vector<int, bool> Types0;
        typedef boost::mpl::vector<char, short> Types1;

        typedef boost::mpl::zip_view<boost::mpl::vector<Types0, Types1> > ZippedTypes;
        typedef boost::mpl::copy<ZippedTypes, boost::mpl::back_inserter<boost::mpl::vector<> > >::type ZippedTypesVector;

        typedef detail::types_to_size_type<Types0>::type Size0;
        Size0 size0;

        typedef detail::types_to_size_type<Types1>::type Size1;
        Size1 size1;

        typedef detail::types_to_size_type<ZippedTypes>::type ZippedSizeType;
        ZippedSizeType zippedSize;

        typedef boost::mpl::range_c<int, 0, boost::mpl::size<Types0>::type::value> IndexRange;

        boost::mpl::for_each<IndexRange>(detail::copy_size<Types0, Size0,
                                                                                                                                                           ZippedTypesVector, ZippedSizeType>(size0, zippedSize));
}