#define BOOST_THREAD_PROVIDES_FUTURE
#define BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION
#define BOOST_THREAD_PROVIDES_FUTURE_WHEN_ALL_WHEN_ANY

#include <iostream>
#include <iterator>
#include <type_traits>
#include <boost/assert.hpp>
#include <boost/thread.hpp>

using boost::future;
using boost::promise;
using boost::when_all;
using boost::make_ready_future;

struct Int
{
    size_t n;

    std::ostream& printme() const { return std::cout << "Int(" << n << ")"; }
    Int(size_t n) noexcept : n(n) { printme() << " borns" << std::endl; }
    Int(const Int& other) noexcept : n(other.n) { printme() << " borns" << std::endl; }
    Int& operator=(const Int& other) noexcept { n = other.n; return *this; }
    ~Int() noexcept { printme() << " dies" << std::endl; }
    operator size_t() noexcept { return n; }	
};

template<class T, size_t N = 1000>
future<void> iter(int K)
{
    std::cout << K << ": iter() started" << std::endl;

    static std::vector< promise<T> > p;
    p.resize(0);
    p.resize(N);

    std::cout << K << ": promise cleanup finished" << std::endl;

    std::vector< future<T> > f;
    f.reserve(N);

    for (size_t i = 0; i < N; ++i) {
        f.push_back(p[i].get_future());
    }

    auto ret = when_all(f.begin(), f.end()).then(
        [=](future< std::vector< future<T> > > fv) {
            auto v = fv.get();
            for (size_t i = 0; i < N; ++i) {
                BOOST_ASSERT(v.at(i).get() == i);
            }

            std::cout << K << ": when_all satisfied" << std::endl;
        }
    );
    
    for (size_t i = 0; i < N; ++i) {
        p[i].set_value(i);
    }

    std::cout << K << ": iter() finished" << std::endl;

    return std::move(ret);
}

int main()
{
    // Valgrind test
#if 0
    for (int k = 0; k < 5 ; ++k) {
        iter<Int, 2>(k).get();
    }
#else
    for (int k = 0; ; ++k) {
        iter<size_t, 10000>(k).get();
    }
#endif
}