Future.h

#pragma once

#include <fsdk/Def.h>
#include <fsdk/Types/Result.h>

//
//  Future.h
//  inc
//
//  Created by k.delimbetov on 28.05.2018.
//

#include <cstdint>

namespace fsdk_internal {
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    template <typename T>
    class FutureImpl;
    template <typename T>
    class PromiseImpl;
#endif
} // namespace fsdk_internal

namespace fsdk {
    enum class ExecutionPolicy : uint8_t {
        Sync, 
        Async 
    };

    enum class FuturePromiseState : uint8_t {
        Empty,     
        Promised,  
        Fulfilled, 
        CancelRequested, 
        Canceled,        
        Failed,          
        Broken           
    };

    class Noncopyable {
    protected:
        Noncopyable() = default;
        ~Noncopyable() = default;

    private:
        Noncopyable(const Noncopyable&) = delete;
        Noncopyable& operator=(const Noncopyable&) = delete;
    };

    template <typename T>
    class Promise;

    enum class FutureError : uint8_t {
        Ok,           
        InvalidInput, 
        NotPromised,  
        NotFulfilled, 
        NonWaitable,  
        Timeout,      
        Internal      
    };

    template <typename T>
    class FSDK_API Future : Noncopyable {
    public:
        using USec = int32_t;
        using Error = FutureError;
        using DataType = T;

        // MARK: Base
        Future() noexcept;
        Future(Future&& mv) noexcept;
        Future& operator=(Future&&) noexcept;
        ~Future();

        static void swap(Future& first, Future& second) noexcept;

        // MARK: Interface
        Result<Error> cancel(const ExecutionPolicy policy) noexcept;

        FuturePromiseState state() const noexcept;

        Result<Error> takeInto(DataType& container) noexcept;

        Result<Error> wait() const noexcept;

        Result<Error> waitFor(const USec usec) const noexcept;

    private:
#ifndef DOXYGEN_SHOULD_SKIP_THIS
        Future(fsdk_internal::FutureImpl<T>* impl) noexcept;

        friend class Promise<T>;

        // MARK: Internal
        fsdk_internal::FutureImpl<T>* m_pimpl = nullptr;
#endif
    };

    enum class PromiseError : uint8_t {
        Ok,                 
        Internal,           
        StateNotCancelable, 
        StateNotFailable, 
        StateNotFulfillable,           
        StateDoesntAllowFutureCreation 
    };

    template <typename T>
    class FSDK_API Promise : Noncopyable {
    public:
        using Error = PromiseError;
        using DataType = T;

        // MARK: Base
        Promise() noexcept;
        Promise(Promise&&) noexcept;
        Promise& operator=(Promise&&) noexcept;
        ~Promise();

        static void swap(Promise& first, Promise& second) noexcept;

        // MARK: Interface
        Result<Error> cancel() noexcept;

        Result<Error> fail() noexcept;

        Result<Error> fulfill(DataType&& promisedData) noexcept;

        Future<DataType> future(Result<Error>& error) noexcept;

        FuturePromiseState state() const noexcept;

    private:
#ifndef DOXYGEN_SHOULD_SKIP_THIS
        // MARK: Internal
        fsdk_internal::PromiseImpl<T>* m_pimpl = nullptr;
#endif
    };

    template <>
    struct ErrorTraits<FutureError> {
        static bool isOk(const FutureError error) noexcept {
            return error == FutureError::Ok;
        }

        static const char* toString(const FutureError error) noexcept {
            switch(error) {
            case FutureError::Ok:
                return "Ok";
            case FutureError::InvalidInput:
                return "Invalid data is given as input to some method";
            case FutureError::NotPromised:
                return "Error if you call @see Future::cancel on not Promised state";
            case FutureError::NotFulfilled:
                return "Error if you call @see Future::takeInto on not Fulfilled state";
            case FutureError::NonWaitable:
                return "Error if you try to @see Future::wait on non waitable state";
            case FutureError::Timeout:
                return "Error if your @see Future::waitFor method ran out of time";
            case FutureError::Internal:
                return "Some internal error";
            default:
                return "Unknown error";
            }
        }
    };

    template <>
    struct ErrorTraits<PromiseError> {
        static bool isOk(const PromiseError error) noexcept {
            return error == PromiseError::Ok;
        }

        static const char* toString(const PromiseError error) noexcept {
            switch(error) {
            case PromiseError::Ok:
                return "Ok";
            case PromiseError::Internal:
                return "Internal error.";
            case PromiseError::StateNotCancelable:
                return "Error if you call @see Promise::cancel on not CancelRequested state.";
            case PromiseError::StateNotFailable:
                return "Error if you call @see Promise::fail on not Promised and not CancelRequested state.";
            case PromiseError::StateNotFulfillable:
                return "Error if you call @see Promise::fulfill on not Promised state.";
            case PromiseError::StateDoesntAllowFutureCreation:
                return "Error if you call @see Promise::future on not Empty state.";
            default:
                return "Unknown error";
            }
        }
    };
} // namespace fsdk