Future.h

Go to the documentation of this file.

/* ============================================================
 *
 * This file is a part of the the RSC project.
 *
 * Copyright (C) 2011 by Johannes Wienke <jwienke at techfak dot uni-bielefeld dot de>
 *
 * This file may be licensed under the terms of the
 * GNU Lesser General Public License Version 3 (the ``LGPL''),
 * or (at your option) any later version.
 *
 * Software distributed under the License is distributed
 * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
 * express or implied. See the LGPL for the specific language
 * governing rights and limitations.
 *
 * You should have received a copy of the LGPL along with this
 * program. If not, go to http://www.gnu.org/licenses/lgpl.html
 * or write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * The development of this software was supported by:
 *   CoR-Lab, Research Institute for Cognition and Robotics
 *     Bielefeld University
 *
 * ============================================================ */

#pragma once

#include <stdexcept>

#include <boost/shared_ptr.hpp>
#include <boost/format.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/thread/condition.hpp>

#include "rsc/rscexports.h"

namespace rsc {
namespace threading {

class RSC_EXPORT FutureException: public std::runtime_error {
public:
    explicit FutureException(const std::string& message);
};

class RSC_EXPORT FutureTaskExecutionException: public FutureException {
public:

    explicit FutureTaskExecutionException(const std::string& msg);

};

class RSC_EXPORT FutureTimeoutException: public FutureException {
public:
    explicit FutureTimeoutException(const std::string& message);
};

template<class R>
class Future {
protected:
    typedef boost::mutex MutexType;
    typedef boost::condition ConditionType;
private:
    R result;
    bool taskFinished;
    bool taskError;
    std::string errorMsg;
    ConditionType condition;
    MutexType mutex;
public:

    Future() :
            taskFinished(false), taskError(false) {
    }

    R get() {
        return get(0);
    }

    R get(double timeout) {
        MutexType::scoped_lock lock(mutex);
        while (!taskFinished) {
            if (timeout <= 0) {
                condition.wait(lock);
            } else {
#if BOOST_VERSION >= 105000
                if (!condition.timed_wait(lock, boost::posix_time::microseconds(long(timeout) * 1000000))) {
#else
                boost::xtime xt;
                boost::xtime_get(&xt, boost::TIME_UTC);
                xt.sec += timeout;
                if (!condition.timed_wait(lock, xt)) {
#endif
                    throw FutureTimeoutException(
                            boost::str(
                                    boost::format(
                                            "Timeout while waiting for result. Waited %1% seconds.")
                                            % timeout));
                }
            }
        }

        if (taskError) {
            throw FutureTaskExecutionException(errorMsg);
        }

        return result;
    }

    bool isDone() {
        MutexType::scoped_lock lock(mutex);
        return taskFinished;
    }

    void set(R data) {
        result = data;
        {
            MutexType::scoped_lock lock(mutex);
            taskFinished = true;
            condition.notify_all();
        }
    }

    void setError(const std::string& message) {
        errorMsg = message;
        {
            MutexType::scoped_lock lock(mutex);
            taskFinished = true;
            taskError = true;
        }
        condition.notify_all();
    }
protected:
    MutexType& getMutex() {
        return this->mutex;
    }

    ConditionType& getCondition() {
        return this->condition;
    }
};

}
}