fusion_algorithms.hpp

Go to the documentation of this file.

//=======================================================================
// Copyright (c) 2013 Piotr Wygocki
//
// 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)
//=======================================================================
#ifndef PAAL_FUSION_ALGORITHMS_HPP
#define PAAL_FUSION_ALGORITHMS_HPP

#include "paal/utils/type_functions.hpp"

#include <boost/fusion/include/begin.hpp>

#include <functional>

namespace paal {
namespace data_structures {

class polymorfic_fold {
    struct Fold {
        template <typename Functor, typename IterEnd,
                  typename AccumulatorFunctor, typename AccumulatorData>
        typename std::result_of<AccumulatorFunctor(AccumulatorData)>::type
        operator()(Functor, AccumulatorFunctor accumulatorFunctor,
                   AccumulatorData accumulatorData, IterEnd, IterEnd) const {
            return accumulatorFunctor(accumulatorData);
        }

        template <typename Functor, typename IterBegin, typename IterEnd,
                  typename AccumulatorFunctor, typename AccumulatorData,
                  typename Dummy = typename std::enable_if<
                      !std::is_same<IterEnd, IterBegin>::value>::type>
        auto operator()(Functor f, AccumulatorFunctor accumulatorFunctor,
                        AccumulatorData accumulatorData, IterBegin begin,
                        IterEnd end) const
            -> typename std::result_of<Functor(
                typename boost::fusion::result_of::deref<IterBegin>::type,
                AccumulatorFunctor, AccumulatorData,
                // TODO Why this move is needed??? (without it doesn't compile
                // on clang-3.4)
                decltype(std::move(std::bind(
                    *this, f, std::placeholders::_1, std::placeholders::_2,
                    boost::fusion::next(begin), end))))>::type {
            auto continuation = std::bind(*this, f, std::placeholders::_1,
                                          std::placeholders::_2,
                                          boost::fusion::next(begin), end);

            return f(*begin, accumulatorFunctor, accumulatorData, continuation);
        }
    };

  public:
    template <typename Functor, typename AccumulatorFunctor, typename AccumulatorData, typename Sequence>
    auto operator()(Functor f, AccumulatorFunctor accumulatorFunctor,
                    AccumulatorData accumulatorData, Sequence &seq) const{
        return Fold {}
        (f, accumulatorFunctor, accumulatorData, boost::fusion::begin(seq),
         boost::fusion::end(seq));
    }
};

class Satisfy {
    template <typename Predicate, typename IterEnd>
    bool satisfy(Predicate, IterEnd, IterEnd) const {
        return false;
    }

    template <typename Predicate, typename IterBegin, typename IterEnd>
    bool satisfy(Predicate pred, IterBegin begin, IterEnd end) const {
        if (pred(*begin)) {
            return true;
        }
        return satisfy(pred, boost::fusion::next(begin), end);
    }

  public:
    template <typename Predicate, typename Seq>
    bool operator()(Predicate pred, Seq &seq) const {
        return satisfy(pred, boost::fusion::begin(seq),
                       boost::fusion::end(seq));
    }
};

} 
} 

#endif // PAAL_FUSION_ALGORITHMS_HPP