RPCFuture.h

Go to the documentation of this file.

/*
 * Copyright (C) 2012 by
 *   MetraLabs GmbH (MLAB), GERMANY
 * and
 *   Neuroinformatics and Cognitive Robotics Labs (NICR) at TU Ilmenau, GERMANY
 * All rights reserved.
 *
 * Contact: info@mira-project.org
 *
 * Commercial Usage:
 *   Licensees holding valid commercial licenses may use this file in
 *   accordance with the commercial license agreement provided with the
 *   software or, alternatively, in accordance with the terms contained in
 *   a written agreement between you and MLAB or NICR.
 *
 * GNU General Public License Usage:
 *   Alternatively, this file may be used under the terms of the GNU
 *   General Public License version 3.0 as published by the Free Software
 *   Foundation and appearing in the file LICENSE.GPL3 included in the
 *   packaging of this file. Please review the following information to
 *   ensure the GNU General Public License version 3.0 requirements will be
 *   met: http://www.gnu.org/copyleft/gpl.html.
 *   Alternatively you may (at your option) use any later version of the GNU
 *   General Public License if such license has been publicly approved by
 *   MLAB and NICR (or its successors, if any).
 *
 * IN NO EVENT SHALL "MLAB" OR "NICR" BE LIABLE TO ANY PARTY FOR DIRECT,
 * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
 * THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF "MLAB" OR
 * "NICR" HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * "MLAB" AND "NICR" SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND "MLAB" AND "NICR" HAVE NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR MODIFICATIONS.
 */

#ifndef _MIRA_RPCFUTURE_H_
#define _MIRA_RPCFUTURE_H_

#ifndef Q_MOC_RUN
#include <boost/noncopyable.hpp>
#include <boost/thread/future.hpp>
#endif

#include <rpc/AbstractRPCClient.h>
#include <rpc/JSONRPCResponse.h>
#include <rpc/RPCError.h>

namespace mira {


template <typename R>
class RPCFutureCommon : boost::noncopyable
{
public:

    RPCFutureCommon() : mClient(NULL), mCallId("") {}

    RPCFutureCommon(AbstractRPCClient* client, const std::string& callId) :
        mClient(client), mCallId(callId) {}

    ~RPCFutureCommon()
    {
        // remove call upon destruction of this future
        if(mClient!=NULL)
            mClient->onDestructFuture(mCallId);
    }

public:

    const std::string& callId() { return mCallId; }

    // delegate to boost future

    bool isReady() const { return mFuture.is_ready(); }

    bool hasException() const { return mFuture.has_exception(); }

    bool hasValue() const { return mFuture.has_value(); }

    void wait() const { mFuture.wait(); }

    template<typename Duration>
    bool timedWait(Duration const& relTime) const {
        return mFuture.timed_wait(relTime);
    }

    bool timedWaitUntil(boost::system_time const& absTime) const {
        return mFuture.timed_wait_until(absTime);
    }

    void swap(RPCFutureCommon<R>& other) {
        mFuture.swap(other.mFuture);
        std::swap(mClient, other.mClient);
        std::swap(mCallId, other.mCallId);
    }


protected:
    AbstractRPCClient* mClient;
    std::string mCallId;
    boost::unique_future<R> mFuture;
};


template <typename R>
class RPCFuture : public RPCFutureCommon<R>
{
public:
    RPCFuture() {}

    RPCFuture(boost::unique_future<R> other, AbstractRPCClient* client,
              const std::string& callId) :
        RPCFutureCommon<R>(client, callId)
    {
        this->mFuture.swap(other);
    }

    RPCFuture(RPCFuture&& other) noexcept {
        this->swap(other);
    }

    RPCFuture& operator=(RPCFuture && other) noexcept {
        this->swap(other);
        return *this;
    }

public:


#if BOOST_VERSION / 100 % 1000 > 56
    typedef typename boost::detail::shared_state<R>::move_dest_type ReturnValue;
#else
    typedef typename boost::detail::future_traits<R>::move_dest_type ReturnValue;
#endif

    operator ReturnValue() { return this->mFuture.get(); }

    ReturnValue get(bool throwXRPC = true, bool recursive = true)
    {
        if (throwXRPC)
            return this->mFuture.get();

        try {
            return this->mFuture.get();
        }
        catch (XRPC& ex) {
            if (ex.hasOrigException())
                ex.raiseOrigException(recursive);

            throw; // throw XRPC if it has no original exception stored
        }
    }

};


template <>
class RPCFuture<void> : public RPCFutureCommon<void>
{
public:
    RPCFuture() {}

    RPCFuture(boost::unique_future<void> other, AbstractRPCClient* client,
              const std::string& callId) :
        RPCFutureCommon<void>(client, callId)
    {
        this->mFuture.swap(other);
    }

    RPCFuture(RPCFuture&& other) noexcept {
        this->swap(other);
    }

    RPCFuture& operator=(RPCFuture && other) noexcept {
        this->swap(other);
        return *this;
    }

    void get(bool throwXRPC = true, bool recursive = true)
    {
        if (throwXRPC) {
            this->mFuture.get();
        } else {
            try {
                this->mFuture.get();
            }
            catch (XRPC& ex) {
                if (ex.hasOrigException())
                    ex.raiseOrigException(recursive);

                throw; // throw XRPC if it has no original exception stored
            }
        }
    }

};


template <>
class RPCFuture<JSONRPCResponse> : public RPCFutureCommon<JSONRPCResponse>
{
public:
    RPCFuture() {}

    RPCFuture(boost::unique_future<JSONRPCResponse> other, AbstractRPCClient* client,
              const std::string& callId) :
        RPCFutureCommon<JSONRPCResponse>(client, callId)
    {
        this->mFuture.swap(other);
    }

    RPCFuture(RPCFuture&& other) noexcept {
        this->swap(other);
    }

    RPCFuture& operator=(RPCFuture && other) noexcept {
        this->swap(other);
        return *this;
    }

    json::Value get(bool throwXRPC = true, bool recursive = true)
    {
        if (throwXRPC)
            return this->mFuture.get().getResult();

        try {
            return this->mFuture.get().getResult();
        }
        catch (XRPC& ex) {
            if (ex.hasOrigException())
                ex.raiseOrigException(recursive);

            throw; // throw XRPC if it has no original exception stored
        }
    }

    json::Value getAnswer()
    {
        return this->mFuture.get().response;
    }

    bool hasException()
    {
        if (!this->mFuture.has_value())
            return false;
        try
        {
            get();
        }
        catch(...)
        {
            return true;
        }
        return false;
    }
};


}

#endif