Future.h

Go to the documentation of this file.

/*
* Copyright Onix Solutions Limited [OnixS]. All rights reserved.
*
* This software owned by Onix Solutions Limited [OnixS] and is protected by copyright law
* and international copyright treaties.
*
* Access to and use of the software is governed by the terms of the applicable OnixS Software
* Services Agreement (the Agreement) and Customer end user license agreements granting
* a non-assignable, non-transferable and non-exclusive license to use the software
* for it's own data processing purposes under the terms defined in the Agreement.
*
* Except as otherwise granted within the terms of the Agreement, copying or reproduction of any part
* of this source code or associated reference material to any other location for further reproduction
* or redistribution, and any amendments to this copyright notice, are expressly prohibited.
*
* Any reproduction or redistribution for sale or hiring of the Software not in accordance with
* the terms of the Agreement is a violation of copyright law.
*/
 
#pragma once
 
#include <OnixS/FIXEngine/ABI.h>
#include <OnixS/FIXEngine/Compiler.h>
#include <OnixS/FIXEngine/Threading/Definitions.h>
 
#include <exception>
 
namespace OnixS {
 
namespace System
{
    class FutureSharedState;
}
 
namespace Threading {

struct FutureStatus
{
    enum Enum
    {
        ready,
        timeout,
        deferred
    };
};
 
namespace Implementation {
 
class FutureHelper;
class PromiseBase;
 
// Implementation details.
class ValueBase
{
public:
 
    virtual ~ValueBase() = default;
    virtual ValueBase * clone() const = 0;
};

class FutureValue
{
public:
 
    FutureValue(ValueBase * value);
    FutureValue();
    FutureValue(const FutureValue & other);
    ~FutureValue();
 
    ValueBase * value() const { return value_; }
 
private:
 
    ValueBase * value_;
};

template<typename ValueType>
class Value : public ValueBase
{
    typedef Value<ValueType> Type;
 
public:
 
    static const ValueType & value(const ValueBase * value)
    {
        return static_cast<const Type*>(value)->value();
    }
 
    static ValueBase * create(const ValueType & value)
    {
        return new Type(value);
    }
 
    ValueBase * clone() const override
    {
        return create(value_);
    }
 
private:
 
    explicit Value(const ValueType & value) : value_(value) {}
 
    const ValueType & value() const { return value_; }
 
    const ValueType value_;
};

class FutureBase
{
public:
    bool valid() const noexcept
    {
        return state_ != nullptr;
    }

    ONIXS_FIXENGINE_API bool isReady() const;

    ONIXS_FIXENGINE_API bool hasValue() const;

    ONIXS_FIXENGINE_API bool hasException() const;

    ONIXS_FIXENGINE_API std::exception_ptr getExceptionPtr() const;
 
    enum { InfiniteTimeout = -1 };

    ONIXS_FIXENGINE_API FutureStatus::Enum wait(int timeoutInMs = InfiniteTimeout) const;
 
protected:
    FutureBase()
        : state_() {}
 
    ONIXS_FIXENGINE_API FutureBase(const FutureBase & other) noexcept;
 
    ONIXS_FIXENGINE_API FutureBase & operator=(const FutureBase & other) noexcept;
 
    ONIXS_FIXENGINE_API FutureBase(FutureBase && other) noexcept;
 
    ONIXS_FIXENGINE_API FutureBase & operator=(FutureBase && other) noexcept;
 
    struct moving_init_t {};

    ONIXS_FIXENGINE_API FutureBase(const System::FutureSharedState * state) noexcept;

    ONIXS_FIXENGINE_API FutureBase(const System::FutureSharedState * state, moving_init_t) noexcept;

    ONIXS_FIXENGINE_API  ~FutureBase() noexcept;
 
    ONIXS_FIXENGINE_API void swap(FutureBase & other) noexcept;
 
    ONIXS_FIXENGINE_API const FutureValue & getValue() const;
 
    ONIXS_FIXENGINE_API void getVoid() const;
 
private:
    const System::FutureSharedState * state_;
 
    friend class FutureHelper;
    friend class PromiseBase;
};
 
template<typename T>
struct FutureGetReturn
{
    typedef const T & Type;
};
 
template<>
struct FutureGetReturn<void>
{
    typedef void Type;
};
 
}

template <typename T>
class SharedFuture : public Implementation::FutureBase
{
public:
    SharedFuture() noexcept
        : FutureBase() {}

    SharedFuture(const SharedFuture<T> & other) noexcept
        : FutureBase(other) {}

    SharedFuture<T> & operator=(const SharedFuture<T> & other) noexcept
    {
        FutureBase::operator=(other);
        return *this;
    }
 
    SharedFuture(SharedFuture<T> && other) noexcept
        : FutureBase(std::move(other)) {}
 
    FutureBase & operator=(SharedFuture<T> && other) noexcept
    {
        FutureBase::operator=(std::move(other));
        return *this;
    }

    typename Implementation::FutureGetReturn<T>::Type get() const
    {
        return Implementation::Value<T>::value(getValue().value());
    }

    void swap(SharedFuture<T> & other) noexcept
    {
        FutureBase::swap(other);
    }
 
private:
    SharedFuture(const System::FutureSharedState * state)
        : FutureBase(state) {}

    SharedFuture(const System::FutureSharedState * state, moving_init_t t) noexcept
        : FutureBase(state, t) {}
 
    friend class Implementation::FutureHelper;
    friend class Implementation::PromiseBase;
};
 
template<>
inline void SharedFuture<void>::get() const
{
    getVoid();
}
 
namespace Implementation {

class PromiseBase
{
public:
    bool valid();
 
    ONIXS_FIXENGINE_API void setExceptionImpl();
 
protected:
    ONIXS_FIXENGINE_API PromiseBase() noexcept;
 
    ONIXS_FIXENGINE_API PromiseBase(const PromiseBase & other) noexcept;
 
    ONIXS_FIXENGINE_API PromiseBase & operator=(const PromiseBase & other) noexcept;
 
    ONIXS_FIXENGINE_API PromiseBase(PromiseBase && other) noexcept;
 
    ONIXS_FIXENGINE_API PromiseBase & operator=(PromiseBase && other) noexcept;

    ONIXS_FIXENGINE_API ~PromiseBase() noexcept;
 
    ONIXS_FIXENGINE_API void swap(PromiseBase & other) noexcept;
 
    ONIXS_FIXENGINE_API void setValue(ValueBase * value);
 
    ONIXS_FIXENGINE_API void setVoid();
 
 
    ONIXS_FIXENGINE_API SharedFuture<FutureValue> getFutureImpl() const;
 
    template<typename T>
    SharedFuture<T> getTypedFuture() const
    {
        return SharedFuture<T>(getFutureImpl().state_);
    }
 
private:

    struct Impl;
    Impl * impl_;
};
 
}

template <typename T>
class Promise : public Implementation::PromiseBase
{
public:
 
    Promise() noexcept
        : PromiseBase() {}

    Promise(const Promise<T> & other) noexcept
        : PromiseBase(other) {}

    Promise<T> & operator=(const Promise<T> & other) noexcept
    {
        PromiseBase::operator=(other);
        return *this;
    }
 
    Promise(Promise<T> && other) noexcept
        : PromiseBase(std::move(other)) {}
 
    Promise & operator=(Promise<T> && other) noexcept
    {
        PromiseBase::operator=(std::move(other));
        return *this;
    }

    void swap(Promise<T> & other) noexcept
    {
        PromiseBase::swap(other);
    }
 
    SharedFuture<T> getFuture() const
    {
        return getTypedFuture<T>();
    }

    void set(const T & value)
    {
        setValue(Implementation::Value<T>::create(value));
    }

    template<typename ExceptionType>
    void setException(const ExceptionType & exception)
    {
        try
        {
            throw exception;
        }
        catch(...)
        {
            setExceptionImpl();
        }
    }
};
 
template<>
class Promise<void> : public Implementation::PromiseBase
{
public:
 
    Promise() noexcept
        : PromiseBase() {}

    Promise(const Promise<void> & other) noexcept
        : PromiseBase(other) {}

    Promise<void> & operator=(const Promise<void> & other) noexcept
    {
        PromiseBase::operator=(other);
        return *this;
    }
 
    Promise(Promise<void> && other) noexcept
        : PromiseBase(std::move(other)) {}
 
    Promise & operator=(Promise<void> && other) noexcept
    {
        PromiseBase::operator=(std::move(other));
        return *this;
    }

    void swap(Promise<void> & other) noexcept
    {
        PromiseBase::swap(other);
    }
 
    SharedFuture<void> getFuture() const
    {
        return getTypedFuture<void>();
    }

    void set()
    {
        setVoid();
    }

    template<typename ExceptionType>
    void setException(const ExceptionType & exception)
    {
        try
        {
            throw exception;
        }
        catch(...)
        {
            setExceptionImpl();
        }
    }
};
 
}
}