Future.hpp

//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
 
#pragma once
 
#include "Arp/System/Core/Exception.hpp"
#include "Arp/System/Core/TypeName.hxx"
#include <atomic>
#include <memory>
 
 
namespace Arp { namespace System { namespace Nm { namespace Internal
{
template<typename T>
class Promise;
} // namespace Internal
 
 
// <summary>Proxy for the result of an asynchronous function call</summary>
class FutureBase
{
protected:
    class IExceptionWrapper
    {
    public:
        virtual ~IExceptionWrapper() = default;
        virtual void ReThrowException() = 0;
    };
 
 
    template<typename ExceptionType>
    class ExceptionWrapper : public IExceptionWrapper
    {
    public:
        explicit ExceptionWrapper(const ExceptionType& e) : exception(e)
        {
        }
 
        ~ExceptionWrapper() override = default;
 
        void ReThrowException() override
        {
            throw this->exception;
        }
 
    private:
        ExceptionType exception;
    };
 
 
    struct ImplBase
    {
        bool                               isCreatedByPromise = false;
        std::atomic<bool>                  valueHasBeenSet;
        std::unique_ptr<IExceptionWrapper> exception;
    };
 
public:
    FutureBase() = default;
    FutureBase(const FutureBase& other) = default;
    FutureBase(FutureBase&& other) noexcept = default;
    virtual ~FutureBase();
 
    FutureBase& operator=(const FutureBase& other) = default;
    FutureBase& operator=(FutureBase&& other) noexcept = default;
 
    const bool IsValid() const;
 
    const bool HasValue() const;
 
    const bool HasException() const;
 
protected:
    virtual ImplBase&       GetPImpl() = 0;
    virtual const ImplBase& GetPImpl() const = 0;
    void                    CheckForValueAndException() const;
 
    template<typename ExceptionType>
    void SetException(const ExceptionType& e);
 
    void Clear(bool isValid);
};
 
 
template<typename ExceptionType>
void FutureBase::SetException(const ExceptionType& e)
{
    this->GetPImpl().exception = std::make_unique<ExceptionWrapper<ExceptionType>>(e);
    this->GetPImpl().valueHasBeenSet.store(true);
}
 
 
// -----------------------------------------------------------------------------
 
 
template<typename T>
class Future : public FutureBase
{
private:
    friend Internal::Promise<T>;
 
    struct Impl : public ImplBase
    {
        T value = T{};
    };
 
    static Future CreateByPromise();
 
public:
    Future() = default;
    Future(const Future& other) = default;
    Future(Future&& other) noexcept = default;
    ~Future() override = default;
 
    Future& operator=(const Future& other) = default;
    Future& operator=(Future&& other) noexcept = default;
 
    const T GetValue() const;
 
private:
    void SetValue(const T& value);
 
    Impl& GetPImpl() override
    {
        return *(this->pImpl);
    }
 
    const Impl& GetPImpl() const override
    {
        return *(this->pImpl);
    }
 
private:
    std::shared_ptr<Impl> pImpl{std::make_shared<Impl>()};
};
 
 
template<typename T>
Future<T> Future<T>::CreateByPromise()
{
    Future result;
    result.pImpl->isCreatedByPromise = true;
    return result;
}
 
 
template<typename T>
const T Future<T>::GetValue() const
{
    this->CheckForValueAndException();
    return this->GetPImpl().value;
}
 
 
template<typename T>
void Future<T>::SetValue(const T& value)
{
    this->GetPImpl().value = value;
    this->GetPImpl().valueHasBeenSet.store(true);
}
 
 
// -----------------------------------------------------------------------------
 
 
template<>
class Future<void> : public FutureBase
{
private:
    friend Internal::Promise<void>;
    using Impl = ImplBase;
 
    static Future CreateByPromise();
 
public:
    Future();
 
    Future(const Future& other) = default;
    Future(Future&& other) = default;
    ~Future() override = default;
 
    Future& operator=(const Future& other) = default;
    Future& operator=(Future&& other) = default;
 
    void GetValue() const;
 
private:
    void SetValue();
 
    Impl&       GetPImpl() override;
    const Impl& GetPImpl() const override;
 
private:
    std::shared_ptr<Impl> pImpl;
};
 
 
}}} // end of namespace Arp::System::Nm