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 <exception>
#include <future>
#include <type_traits>
#include <utility>
 
#include <OnixS/CME/MDH/ABI.h>
 
namespace OnixS {
 
namespace System {
class FutureSharedState;
}
 
} // namespace OnixS
 
ONIXS_CME_MDH_THREADING_NAMESPACE_BEGIN
 
namespace Implementation {
 
class FutureHelper;

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

    ONIXS_CMEMDH_EXPORTED bool is_ready() const;

    ONIXS_CMEMDH_EXPORTED bool has_value() const;

    ONIXS_CMEMDH_EXPORTED bool has_exception() const;

    ONIXS_CMEMDH_EXPORTED std::exception_ptr get_exception_ptr() const;
 
    enum
    {
        InfiniteTimeout = -1
    };

    ONIXS_CMEMDH_EXPORTED std::future_status wait(int timeoutInMs = InfiniteTimeout) const;
 
protected:
    FutureBase() noexcept = default;
 
    ONIXS_CMEMDH_EXPORTED FutureBase(const FutureBase& other) noexcept;
 
    ONIXS_CMEMDH_EXPORTED FutureBase& operator=(const FutureBase& other) noexcept;
 
    ONIXS_CMEMDH_EXPORTED FutureBase(FutureBase&& other) noexcept;
 
    ONIXS_CMEMDH_EXPORTED FutureBase& operator=(FutureBase&& other) noexcept;
 
    struct moving_init_t{};

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

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

    ONIXS_CMEMDH_EXPORTED ~FutureBase() noexcept;
 
    ONIXS_CMEMDH_EXPORTED void swap(FutureBase& other) noexcept;
 
    ONIXS_CMEMDH_EXPORTED const void* getValuePtr() const;
 
    ONIXS_CMEMDH_EXPORTED void getVoid() const;
 
private:
    const System::FutureSharedState* state_ = nullptr;
 
    friend class FutureHelper;
};
 
template <typename T>
struct FutureGetReturn
{
    typedef const T& Type;
};
 
template <>
struct FutureGetReturn<void>
{
    typedef void Type;
};
 
} // namespace Implementation

template <typename T>
class SharedFuture : public Implementation::FutureBase
{
    static_assert(!std::is_reference<T>::value, "SharedFuture does not support reference result types");
 
public:
    SharedFuture() noexcept = default;

    SharedFuture(const SharedFuture& other) noexcept = default;

    SharedFuture& operator=(const SharedFuture& other) noexcept = default;
 
    SharedFuture(SharedFuture&& other) noexcept = default;
 
    SharedFuture& operator=(SharedFuture&& other) noexcept = default;

    typename Implementation::FutureGetReturn<T>::Type get() const
    {
        return *reinterpret_cast<const T*>(getValuePtr());
    }

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

    SharedFuture(const System::FutureSharedState* state, moving_init_t t) noexcept
        : FutureBase(state, t)
    {}
 
    friend class Implementation::FutureHelper;
};

using Event = SharedFuture<void>;

template <>
inline void SharedFuture<void>::get() const
{
    getVoid();
}
 
ONIXS_CME_MDH_THREADING_NAMESPACE_END