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 <lunchbox/refPtr.h>      // used inline
#include <lunchbox/referenced.h>  // base class
#include <boost/noncopyable.hpp> // 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