Async.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/Foundation/Chrono.hpp"
#include "CeresEngine/Foundation/Exception.hpp"
 
#include <continuable/continuable.hpp>
#include <continuable/external/asio.hpp>
 
namespace CeresEngine {
 
    template<typename... Args> using Async = cti::continuable<Args...>;
 
    template<typename... Args> using Promise = cti::promise<Args...>;
 
    template<typename... Args> using AsyncResult = cti::result<Args...>;
 
    template<typename... Args, typename Continuation> constexpr auto async(Continuation&& continuation) {
        return cti::make_continuable<Args...>(std::forward<Continuation>(continuation));
    }
 
    template<typename... Args> auto async_ready(Args&&... args) { return cti::make_ready_continuable<Args...>(std::forward<Args>(args)...); }
 
    template<typename... Args, typename Exception> constexpr auto async_except(Exception&& exception) {
        return cti::make_exceptional_continuable<Args...>(std::forward<Exception>(exception));
    }
 
    // ---------------------------------------------------------------------------------------------
 
    using cti::populate;
    using cti::promisify;
    using cti::when_all;
    using cti::when_any;
    using cti::when_seq;
 
    
    template <typename Mapper, typename... T> inline decltype(auto) async_map(Mapper&& mapper, T&&... pack) {
        return cti::map_pack(std::forward<Mapper>(mapper), std::forward<T>(pack)...);
    }
 
    template <typename... T> constexpr decltype(auto) async_spread(T&&... args) {
        return cti::spread_this(std::forward<T>(args)...);
    }
 
    template <typename Mapper, typename... T>
    void async_traverse(Mapper&& mapper, T&&... pack) {
        return cti::traverse_pack(std::forward<Mapper>(mapper), std::forward<T>(pack)...);
    }
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename Data, typename Annotation, typename Transform>
    static decltype(auto) operator>>(cti::continuable_base<Data, Annotation>&& continuable, Transform&& transform) {
        return std::forward<decltype(continuable)>(continuable).apply(std::forward<Transform>(transform));
    }
 
    inline auto wait() {
        return cti::transforms::wait(); //
    }
 
    template<class Rep, class Period> inline auto wait(const TTimeInterval<Rep, Period>& timeout) {
        return cti::transforms::wait_for(timeout); //
    }
 
    template<class Clock, class Duration> inline auto wait(const TDate<Clock, Duration>& timeout) {
        return cti::transforms::wait_until(timeout); //
    }
 
    constexpr cti::use_continuable_raw_t useContinuable{};
 
} // namespace CeresEngine