future.h

/* Copyright (c) 2013-2015, Stefan.Eilemann@epfl.ch
 *
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License version 2.1 as published
 * by the Free Software Foundation.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef LUNCHBOX_FUTURE_H
#define LUNCHBOX_FUTURE_H

#include <boost/noncopyable.hpp> // base class
#include <lunchbox/refPtr.h>     // used inline
#include <lunchbox/referenced.h> // base class
#include <stdexcept>

namespace lunchbox
{
class FutureTimeout : public std::runtime_error
{
public:
    FutureTimeout()
        : std::runtime_error("")
    {
    }
};

template <class T>
class FutureImpl : public Referenced, public boost::noncopyable
{
public:
    virtual ~FutureImpl() {}
    virtual T wait(const uint32_t timeout = LB_TIMEOUT_INDEFINITE) = 0;

    virtual bool isReady() const = 0;
};

template <class T>
class Future
{
private:
    typedef void (Future<T>::*bool_t)() const;
    void bool_true() const {}
public:
    typedef RefPtr<FutureImpl<T> > Impl; 

    explicit Future(Impl impl)
        : impl_(impl)
    {
    }

    ~Future() {}
    T wait(const uint32_t timeout_ = LB_TIMEOUT_INDEFINITE)
    {
        return impl_->wait(timeout_);
    }

    bool isReady() const { return impl_->isReady(); }
    operator bool_t() { return wait() ? &Future<T>::bool_true : 0; }
    bool operator!() { return !wait(); }
    bool operator==(const T& rhs) { return wait() == rhs; }
    bool operator!=(const T& rhs) { return wait() != rhs; }
    bool operator<(const T& rhs) { return wait() < rhs; }
    bool operator>(const T& rhs) { return wait() > rhs; }
    bool operator<=(const T& rhs) { return wait() <= rhs; }
    bool operator>=(const T& rhs) { return wait() >= rhs; }

protected:
    Impl impl_;
};

typedef Future<bool> f_bool_t; 

template <>
class Future<void>
{
private:
    typedef void (Future<void>::*bool_t)() const;
    void bool_true() const {}
public:
    typedef RefPtr<FutureImpl<void> > Impl; 

    explicit Future(Impl impl)
        : impl_(impl)
    {
    }

    ~Future() {}
    void wait(const uint32_t timeout_ = LB_TIMEOUT_INDEFINITE)
    {
        impl_->wait(timeout_);
    }

    bool isReady() const { return impl_->isReady(); }
protected:
    Impl impl_;
};
}
#endif // LUNCHBOX_FUTURE_H