collect.hpp

 
#pragma once
 
#include "../asrtc/collect.h"
#include "../asrtl/asrt_assert.h"
#include "../asrtl/log.h"
#include "../asrtl/status_to_str.h"
#include "../asrtlpp/callback.hpp"
#include "../asrtlpp/flat_type_traits.hpp"
#include "../asrtlpp/task.hpp"
#include "../asrtlpp/util.hpp"
 
namespace asrt
{
 
ASRT_NODISCARD inline status init(
    ref< asrt_collect_server > srv,
    asrt_node&                 prev,
    asrt_allocator             alloc,
    uint32_t                   tree_block_cap,
    uint32_t                   tree_node_cap )
{
        return asrt_collect_server_init( srv, &prev, alloc, tree_block_cap, tree_node_cap );
}
 
ASRT_NODISCARD inline status send_ready(
    ref< asrt_collect_server >            srv,
    flat_id                               root_id,
    callback< asrt_collect_ready_ack_cb > ack_cb,
    uint32_t                              timeout )
{
        return asrt_collect_server_send_ready( srv, root_id, timeout, ack_cb.fn, ack_cb.ptr );
}
 
inline asrt_flat_tree const& tree( ref< asrt_collect_server > srv )
{
        return *asrt_collect_server_tree( srv );
}
 
ASRT_NODISCARD inline flat_id next_node_id( ref< asrt_collect_server > srv )
{
        return srv->next_node_id;
}
 
inline void deinit( ref< asrt_collect_server > srv )
{
        asrt_collect_server_deinit( srv );
}
 
struct _collect_send_ready_ctx
{
        using completion_signatures =
            ecor::completion_signatures< ecor::set_value_t(), ecor::set_error_t( status ) >;
 
        asrt_collect_server* srv;
        flat_id              root_id;
        uint32_t             timeout;
 
        template < typename OP >
        void start( OP& op )
        {
                auto s = asrt_collect_server_send_ready(
                    srv,
                    root_id,
                    timeout,
                    +[]( void* p, enum asrt_status s ) {
                            auto& o = *static_cast< OP* >( p );
                            if ( s == ASRT_SUCCESS )
                                    o.receiver.set_value();
                            else
                                    o.receiver.set_error( s );
                    },
                    &op );
                if ( s != ASRT_SUCCESS )
                        op.receiver.set_error( s );
        }
};
 
using collect_send_ready_sender = ecor::sender_from< _collect_send_ready_ctx >;
 
inline ecor::sender auto send_ready(
    ref< asrt_collect_server > srv,
    flat_id                    root_id,
    uint32_t                   timeout )
{
        return collect_send_ready_sender{ { srv, root_id, timeout } };
}
 
}  // namespace asrt