Future.h

#pragma once
 
//
//  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 {
    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";
            }
        }
    };
}