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/CboeCFE/Trading/BOE/ABI.h>
 
#ifdef ONIXS_BATS_BOE_CXX11
#  include <utility>
#  include <exception>
#endif
 
namespace OnixS {
namespace System {
    class FutureSharedState;
}}
 
namespace OnixS {
namespace CboeCFE {
namespace Trading {
namespace BOE {
namespace Threading
{

struct FutureStatus
{
    enum Enum
    {
        ready,
        timeout,
        deferred
    };
};
 
namespace Implementation {
 
class FutureHelper;

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

    ONIXS_CBOE_CFE_BOE_API bool is_ready() const;

    ONIXS_CBOE_CFE_BOE_API bool has_value() const;

    ONIXS_CBOE_CFE_BOE_API bool has_exception() const;
 
    enum
    {
        InfiniteTimeout = -1
    };

    ONIXS_CBOE_CFE_BOE_API FutureStatus::Enum wait(int timeoutInMs) const;
 
protected:
    FutureBase()
      : state_()
    {}
 
    ONIXS_CBOE_CFE_BOE_API FutureBase(const FutureBase &other) ONIXS_BATS_BOE_NOEXCEPT;
 
    ONIXS_CBOE_CFE_BOE_API FutureBase &operator=(const FutureBase &other) ONIXS_BATS_BOE_NOEXCEPT;
 
#ifdef ONIXS_BATS_BOE_CXX11
 
    ONIXS_CBOE_CFE_BOE_API FutureBase(FutureBase &&other) ONIXS_BATS_BOE_NOEXCEPT;
 
    ONIXS_CBOE_CFE_BOE_API FutureBase &operator=(FutureBase &&other) ONIXS_BATS_BOE_NOEXCEPT;
 
#endif
 
    struct moving_init_t
    {};

    ONIXS_CBOE_CFE_BOE_API FutureBase(const System::FutureSharedState *state) ONIXS_BATS_BOE_NOEXCEPT;

    ONIXS_CBOE_CFE_BOE_API FutureBase(const System::FutureSharedState *state, moving_init_t) ONIXS_BATS_BOE_NOEXCEPT;

    ONIXS_CBOE_CFE_BOE_API ~FutureBase() ONIXS_BATS_BOE_NOEXCEPT;
 
    ONIXS_CBOE_CFE_BOE_API void swap(FutureBase &other) ONIXS_BATS_BOE_NOEXCEPT;
 
    ONIXS_CBOE_CFE_BOE_API const void *getValuePtr() const;
 
    ONIXS_CBOE_CFE_BOE_API void getVoid() const;
 
private:
    const System::FutureSharedState *state_;
 
    friend class FutureHelper;
};
 
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() ONIXS_BATS_BOE_NOEXCEPT
      : FutureBase() {}

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

    SharedFuture<T> &operator=(const SharedFuture<T> &other) ONIXS_BATS_BOE_NOEXCEPT
    {
        FutureBase::operator=(other);
        return *this;
    }
 
#ifdef ONIXS_BATS_BOE_CXX11
 
    SharedFuture(SharedFuture<T> &&other) ONIXS_BATS_BOE_NOEXCEPT
      : FutureBase(std::move(other))
    {}
 
    FutureBase &operator=(SharedFuture<T> &&other) ONIXS_BATS_BOE_NOEXCEPT
    {
        FutureBase::operator=(std::move(other));
        return *this;
    }
 
#endif

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

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

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