Question

I am having hard time using variadic template with the following problem.

Suppose that all the predicate functors are of the form,

class Pred1 {
public:
    Pred1( Args... ); // The signature Args... can vary class to class.

    template <typename T>
    bool operator()(T t);
};

Given those functors, I want to make a variadic template class which returns true if all the operator() of each predicate return true, i.e.,

template <typename... Preds>
class CombinePredAnd {
public:
    template <typename T>
    bool operator()(T t){
         // returns true if all of the Preds( Args... ).operator()(t) returns true;  
         // Args... should be passed when CombinePredAnd is constructed.
    }
};

To me, I have no idea to pass arguments to each constructor of Preds.
Could you give me some hint?
Also, if you have better design with the same functionality, please let me know.

Answer 1

Maybe like this:

#include <tuple>
#include <type_traits>

template <std::size_t N, std::size_t I, typename Tuple>
struct evaluate_all
{
    template <typename T>
    static bool eval(T const & t, Tuple const & preds)
    {
        return std::get<I>(preds)(t)
            && evaluate_all<N, I + 1, Tuple>::eval(t, preds);
    }
};

template <std::size_t N, typename Tuple>
struct evaluate_all<N, N, Tuple>
{
    template <typename T>
    static bool eval(T const &, Tuple const &)
    {
        return true;
    }
};

template <typename ...Preds>
struct conjunction
{
private:
    typedef std::tuple<Preds...> tuple_type;
    tuple_type preds;

public:
    conjunction(Preds const &... p) : preds(p...) { }

    template <typename T>
    bool operator()(T const & t) const
    {
        return evaluate_all<sizeof...(Preds), 0, tuple_type>::eval(t, preds);
    }
};

template <typename ...Preds>
conjunction<typename std::decay<Preds>::type...> make_conjunction(Preds &&... preds)
{
    return conjunction<typename std::decay<Preds>::type...>(std::forward<Preds>(preds)...);
}

Usage:

auto c = make_conjunction(MyPred(), YourPred(arg1, arg2, arg3));

if (c(10)) { /* ... */ }

Example:

#include <iostream>

typedef int T;

struct Pred1
{
    int a;
    Pred1(int n) : a(n) { }
    bool operator()(int n) const { return n >= a; }
};
struct Pred2
{
    int a;
    Pred2(int n) : a(n) { }
    bool operator()(int n) const { return n <= a; }
};

int main()
{
    auto c = make_conjunction(Pred1(1), Pred2(3));

    std::cout << "1: " << c(1) << "\n"
              << "5: " << c(4) << "\n";
}

Note: You could make the “conjunction” part of this approach parametric as well, so you can have conjunctions and disjunctions just by plugging in std::logical_and or std::logical_or.