param.hpp

 
#pragma once
 
#include "../asrtc/param.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
{
 
using status = enum asrt_status;
 
ASRT_NODISCARD inline status init(
    ref< asrt_param_server > srv,
    asrt_node&               prev,
    asrt_allocator           alloc )
{
        return asrt_param_server_init( srv, &prev, alloc );
}
 
inline void set_tree( ref< asrt_param_server > srv, asrt_flat_tree const& tree )
{
        asrt_param_server_set_tree( srv, &tree );
}
 
ASRT_NODISCARD inline status send_ready(
    ref< asrt_param_server >            srv,
    flat_id                             root_id,
    callback< asrt_param_ready_ack_cb > ack_cb,
    uint32_t                            timeout )
{
        return asrt_param_server_send_ready( srv, root_id, timeout, ack_cb.fn, ack_cb.ptr );
}
 
inline void deinit( ref< asrt_param_server > srv )
{
        asrt_param_server_deinit( srv );
}
 
struct _param_send_ready_ctx
{
        using completion_signatures =
            ecor::completion_signatures< ecor::set_value_t(), ecor::set_error_t( status ) >;
 
        asrt_param_server* srv;
        flat_id            root_id;
        uint32_t           timeout;
 
        template < typename OP >
        void start( OP& op )
        {
                auto s = asrt_param_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 param_send_ready_sender = ecor::sender_from< _param_send_ready_ctx >;
 
inline ecor::sender auto send_ready(
    ref< asrt_param_server > srv,
    flat_id                  root_id,
    uint32_t                 timeout )
{
        return param_send_ready_sender{ { srv, root_id, timeout } };
}
 
}  // namespace asrt