task.hpp

 
#pragma once
 
#include "../asrtl/status.h"
 
#include <ecor/ecor.hpp>
 
namespace asrt
{
 
struct malloc_free_memory_resource
{
        void* allocate( std::size_t n, std::size_t ) { return malloc( n ); }
 
        void deallocate( void* p, std::size_t, std::size_t ) noexcept { std::free( p ); }
};
 
struct task_ctx
{
        task_ctx( auto& mem_res )
          : _memory_resource( mem_res )
        {
        }
 
        void tick() { _core.run_once(); }
 
        auto& query( ecor::get_memory_resource_t ) { return _memory_resource; }
 
        auto& query( ecor::get_task_core_t ) { return _core; }
 
        void reschedule( ecor::schedulable& s ) { _core.reschedule( s ); }
 
private:
        ecor::task_memory_resource _memory_resource;
        ecor::task_core            _core;
};
 
using status = asrt_status;
using ecor::suspend;
 
struct test_fail_t
{
};
static constexpr test_fail_t test_fail{};
 
struct task_cfg
{
        using extra_error_signatures = ecor::
            completion_signatures< ecor::set_error_t( status ), ecor::set_error_t( test_fail_t ) >;
        using trace_type = ecor::task_default_trace;
};
 
template < typename T >
using task = ecor::task< T, asrt::task_cfg >;
 
struct status_sender
{
        using sender_concept = ecor::sender_t;
        using completion_signatures =
            ecor::completion_signatures< ecor::set_value_t(), ecor::set_error_t( status ) >;
 
        asrt_status status;
 
        status_sender( asrt_status s )
          : status( s )
        {
        }
 
        template < ecor::receiver R >
        struct op
        {
                asrt_status s;
                R           recv;
 
                void start()
                {
                        if ( s == ASRT_SUCCESS )
                                recv.set_value();
                        else
                                recv.set_error( s );
                }
        };
 
        template < ecor::receiver R >
        auto connect( R&& r ) && noexcept
        {
                return op< R >{ status, (R&&) r };
        }
 
        constexpr      operator asrt_status() const { return status; }
        constexpr bool operator==( asrt_status st ) const { return status == st; }
};
 
}  // namespace asrt