Combinatory.hpp

/* ***** BEGIN LICENSE BLOCK *****
 * FW4SPL - Copyright (C) IRCAD, 2009-2017.
 * Distributed under the terms of the GNU Lesser General Public License (LGPL) as
 * published by the Free Software Foundation.
 * ****** END LICENSE BLOCK ****** */

// fwTools - copyright (C) 2005 IRCAD.
#ifndef __FWTOOLS_COMBINATORY_HPP__
#define __FWTOOLS_COMBINATORY_HPP__

#include <boost/mpl/accumulate.hpp>
#include <boost/mpl/apply.hpp>
#include <boost/mpl/back_inserter.hpp>
#include <boost/mpl/copy.hpp>
#include <boost/mpl/empty.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/placeholders.hpp>
#include <boost/mpl/push_front.hpp>
#include <boost/mpl/transform.hpp>
#include <boost/mpl/vector.hpp>

namespace fwTools
{

struct AppendValueFirst
{
    template<class TYPE, class SETOFSET>
    struct apply
    {

        typedef BOOST_DEDUCED_TYPENAME boost::mpl::eval_if< boost::mpl::empty<SETOFSET>,
                                                            boost::mpl::vector< boost::mpl::vector<TYPE> >,
                                                            boost::mpl::transform< SETOFSET,
                                                                                   boost::mpl::push_front< boost::mpl::
                                                                                                           _1, TYPE > >
                                                            >::type type;
    };
};

struct make_vector
{
    template<class T>
    struct apply
    {
        typedef BOOST_DEDUCED_TYPENAME boost::mpl::vector< T >:: type type;
    };
};

struct makeSetOfSingletons
{
    template<class Set>
    struct apply
    {
        typedef BOOST_DEDUCED_TYPENAME boost::mpl::transform<Set, make_vector >::type type;
    };
};

struct BinaryCartesianProductRecurser
{
    template< class Set1, class MultiSet >
    struct apply
    {
        typedef BOOST_DEDUCED_TYPENAME boost::mpl::accumulate< Set1,
                                                               boost::mpl::vector<>,
                                                               boost::mpl::copy<   boost::mpl::apply2< AppendValueFirst,
                                                                                                       boost::mpl::_2,
                                                                                                       MultiSet >,
                                                                                   boost::mpl::back_inserter< boost::mpl
                                                                                                              ::_1>  >

                                                               >::type type;
    };
};

struct BinaryCartesianProduct
{
    template< class Set1, class Set2 >
    struct apply
    {
        typedef BOOST_DEDUCED_TYPENAME boost::mpl::apply1< makeSetOfSingletons,  Set2>::type Set2WithSingletons;

        typedef BOOST_DEDUCED_TYPENAME boost::mpl::apply2<BinaryCartesianProductRecurser, Set1,
                                                          Set2WithSingletons >::type type;
    };
};

struct CartesianProduct
{
    template< class MultiSet >
    struct apply
    {
        typedef BOOST_DEDUCED_TYPENAME boost::mpl::reverse_fold<   MultiSet,
                                                                   boost::mpl::vector<>,
                                                                   boost::mpl::apply2< BinaryCartesianProductRecurser,
                                                                                       boost::mpl::_2, boost::mpl::_1 >
                                                                   >::type type;
    };
};

} //end namespace fwTools

#endif /*__FWTOOLS_COMBINATORY_HPP__*/