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::unique_ptr<IExceptionWrapper>(new 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