Future.hpp

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
 
#pragma once
 
#include "Arp/System/Core/Arp.h"
#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 ARP_CXX_SYMBOL_EXPORT FutureBase
{
protected:
    struct ImplBase
    {
        bool               isCreatedByPromise = false;
        std::atomic<bool>  valueHasBeenSet;
        std::exception_ptr 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;
 
    bool IsValid() const;
    bool HasValue() const;
    bool HasException() const;
 
protected:
    virtual ImplBase&       GetPImpl() = 0;
    virtual const ImplBase& GetPImpl() const = 0;
    void                    CheckForValueAndException() const;
 
    void SetException(std::exception_ptr e);
    void Clear(bool isValid);
};
 
 
// -----------------------------------------------------------------------------
 
 
template<typename T>
class ARP_CXX_SYMBOL_EXPORT 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;
 
    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>
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 ARP_CXX_SYMBOL_EXPORT 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