cntr_assm.hpp

 
#pragma once
 
#include "../asrtc/cntr_assm.h"
#include "../asrtc/result.h"
#include "../asrtl/asrt_assert.h"
#include "../asrtlpp/callback.hpp"
#include "../asrtlpp/task.hpp"
#include "../asrtlpp/util.hpp"
 
namespace asrt
{
 
ASRT_NODISCARD inline enum asrt_status init( ref< asrt_cntr_assm > assm, asrt_allocator alloc )
{
        return asrt_cntr_assm_init( assm, alloc );
}
 
inline void tick( ref< asrt_cntr_assm > assm, uint32_t now )
{
        asrt_cntr_assm_tick( assm, now );
}
 
ASRT_NODISCARD inline enum asrt_status exec_test(
    ref< asrt_cntr_assm >             assm,
    asrt_flat_tree const*             tree,
    asrt_flat_id                      root_id,
    uint16_t                          tid,
    uint32_t                          timeout,
    callback< asrt_assembly_exec_cb > cb )
{
        return asrt_cntr_assm_exec_test( assm, tree, root_id, tid, timeout, cb.fn, cb.ptr );
}
 
inline void deinit( ref< asrt_cntr_assm > assm )
{
        asrt_cntr_assm_deinit( assm );
}
 
// ---------------------------------------------------------------------------
// Sender-based variants — for use with co_await in coroutine tasks.
 
struct _cntr_assm_exec_test_ctx
{
        using completion_signatures = ecor::
            completion_signatures< ecor::set_value_t( asrt_result ), ecor::set_error_t( status ) >;
 
        asrt_cntr_assm*       assm;
        asrt_flat_tree const* tree;
        asrt_flat_id          root_id;
        uint16_t              tid;
        uint32_t              timeout;
 
        template < typename OP >
        void start( OP& op )
        {
                auto s = asrt_cntr_assm_exec_test(
                    assm,
                    tree,
                    root_id,
                    tid,
                    timeout,
                    +[]( void* p, asrt_status s, asrt_result* res ) -> asrt_status {
                            auto& o = *static_cast< OP* >( p );
                            if ( s != ASRT_SUCCESS )
                                    o.receiver.set_error( s );
                            else
                                    o.receiver.set_value( *res );
                            return ASRT_SUCCESS;
                    },
                    &op );
                if ( s != ASRT_SUCCESS )
                        op.receiver.set_error( s );
        }
};
 
using cntr_assm_exec_test_sender = ecor::sender_from< _cntr_assm_exec_test_ctx >;
 
inline ecor::sender auto exec_test(
    ref< asrt_cntr_assm > assm,
    asrt_flat_tree const* tree,
    asrt_flat_id          root_id,
    uint16_t              tid,
    uint32_t              timeout )
{
        return cntr_assm_exec_test_sender{ { assm, tree, root_id, tid, timeout } };
}
 
}  // namespace asrt