misc/collector.cpp at master · alien43/misc · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
#if 0
template<class Stats_>
class AbstractCollectorHolder {
public:
    typedef Stats_ Stats;

    virtual Stats collect(const Stats&, const Stats&) const = 0;
};

template<class Collector>
class CollectorHolder : public AbstractCollectorHolder<
    typename boost::result_of<Collector()>::type
    > {
public:

    explicit CollectorHolder(Collector collector)
        : collector_(collector)
    {}

    virtual Stats collect(const Stats& lhs, const Stats& rhs) const
    {
        return collector_(lhs, rhs);
    }

private:
    const Collector collector_;
};


template<class Stats>
class AnyCollector {
public:
    typedef Stats result_type;

    AnyCollector()
        : collectorHolder_(new CollectorHolder< std::plus<Stats> >(
            std::plus<Stats>()))
    {}

    template<class Collector>
    AnyCollector(Collector collector)
        : collectorHolder_(new CollectorHolder<Collector>(collector))
    {}

    Stats operator() (const Stats& lhs, const Stats& rhs) const
    {
        return collectorHolder_->collect(lhs, rhs);
    }

private:
    boost::scoped_ptr< AbstractCollectorHolder<Stats> > collectorHolder_;
};

template<class Collector>
AnyCollector<typename boost::result_of<Collector()>::type>
createAnyCollector(Collector collector)
{
    return AnyCollector<typename boost::result_of<Collector()>::type>(collector);
}


template<class T>
void test(T t, AnyCollector<T> collector = AnyCollector<T>())
{
    cerr << t << "\n" << collector(t, t) << endl;
}


int main_()
{
    vector<int> a;
    a += 1, 5, 4, 3;

    createAnyCollector(std::multiplies<int>());

    test(5);
    test(5, createAnyCollector(std::multiplies<int>()));


    return 0;
}
#endif