another_take_on_bulk.cpp

#include <cstdlib>
#include <boost/optional.hpp>
#include <string>

using boost::optional;

template <typename T>
struct Future{};

template <typename T>
struct SimpleBulkTask {
    using Shape = size_t;
    Shape shape();
    void run(Shape s);
    T finalize(); // Called once all runs have *returned*
};

template <typename T>
struct FancyBulkTask {
    using Shape = size_t;
    Shape shape();
    Future<void> run(Shape s);
    T finalize(); // Called once all runs' Futures are *completed*
};

template <typename T>
struct OddBulkTask {
    using Shape = size_t;
    Shape shape();
    void run(Shape s);
    Future<T> finalize(); // Called once all runs have *returned*
};

template <typename T>
struct FancyOddBulkTask {
    using Shape = size_t;
    Shape shape();
    Future<void> run(Shape s);
    Future<T> finalize(); // Called once all runs' Futures are *completed*
};

template < typename SF, typename RF, typename F>
auto makeBulkTask(SF shapeFactory, RF resultFactory, F run) {
    using Result = decltype(resultFactory(shapeFactory()));

    struct SomeBulkTask {
        using Shape = decltype(shapeFactory);
        SF shapeFactory;
        RF resultFactory;
        F runner;
        optional<Result> result;

        Shape shape() {
            auto s = shapeFactory();
            result.emplace(resultFactory(s));
            return s;
        }

        auto run(Shape i) {
            return runner(shape(), *result);
        }

        auto finalize() {
            return std::move(*result);
        }

    };

    return SomeBulkTask{
        std::move(shapeFactory),
        std::move(resultFactory),
        std::move(run)
    };
}

struct BulkExec {
    // Returned Future is completed once the returned 
    template <typename T>
    Future<T> exec(AnyBulkTask<T>&& task);
};

struct ExampleFancyOddTask {
    // Fetches a week's worth of data, and sends it to a server for analysis.
    using Shape = size_t;
    Shape shape() { return 7; }

    std::string data[7];

    Future<void> run(Shape i) {
        return get("http://source/day/" + std::to_string(i))
            .then([this, i] (std::string res) { data[i] = std::move(res); });
    }

    Future<std::string> finalize() {
        return post("http://analyze.my.data/", to_json(data));
    }
};