collect.hpp

 
#pragma once
 
#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"
#include "../asrtr/collect.h"
 
namespace asrt
{
 
template < typename T >
struct collect_append_traits;
 
template <>
struct collect_append_traits< uint32_t > : flat_type_traits< uint32_t >
{
        static constexpr auto member = &asrt_flat_scalar::u32_val;
};
 
template <>
struct collect_append_traits< int32_t > : flat_type_traits< int32_t >
{
        static constexpr auto member = &asrt_flat_scalar::i32_val;
};
 
template <>
struct collect_append_traits< float > : flat_type_traits< float >
{
        static constexpr auto member = &asrt_flat_scalar::float_val;
};
 
template <>
struct collect_append_traits< char const* > : flat_type_traits< char const* >
{
        static constexpr auto member = &asrt_flat_scalar::str_val;
};
 
template <>
struct collect_append_traits< bool > : flat_type_traits< bool >
{
        static constexpr auto member = &asrt_flat_scalar::bool_val;
};
 
template <>
struct collect_append_traits< obj > : flat_type_traits< obj >
{
};
 
template <>
struct collect_append_traits< arr > : flat_type_traits< arr >
{
};
 
template < typename T >
concept collect_scalar = collect_append_traits< T >::is_scalar;
 
template < typename T >
concept collect_container = !collect_append_traits< T >::is_scalar;
 
ASRT_NODISCARD inline status init( ref< asrt_collect_client > client, asrt_node& prev )
{
        return asrt_collect_client_init( client, &prev );
}
 
ASRT_NODISCARD inline flat_id root_id( ref< asrt_collect_client const > cc )
{
        return asrt_collect_client_root_id( cc );
}
 
template < typename T >
struct _collect_append_ctx;
 
template < collect_scalar T >
struct _collect_append_ctx< T >
{
        using completion_signatures =
            ecor::completion_signatures< ecor::set_value_t(), ecor::set_error_t( status ) >;
 
        asrt_collect_client* client;
        flat_id              parent;
        char const*          key;
        T                    val;
 
        template < typename OP >
        void start( OP& op )
        {
                using traits             = collect_append_traits< T >;
                using member_type        = decltype( asrt_flat_scalar{}.*traits::member );
                asrt_flat_value v        = { .type = traits::flat_type };
                v.data.s.*traits::member = static_cast< member_type >( val );
                auto s                   = asrt_collect_client_append(
                    client,
                    parent,
                    key,
                    &v,
                    nullptr,
                    +[]( void* ptr, enum asrt_status st ) {
                            auto* o = static_cast< OP* >( ptr );
                            if ( st == ASRT_SUCCESS )
                                    o->receiver.set_value();
                            else
                                    o->receiver.set_error( static_cast< status >( st ) );
                    },
                    &op );
                if ( s != ASRT_SUCCESS )
                        op.receiver.set_error( static_cast< status >( s ) );
        }
};
 
template < collect_container T >
struct _collect_append_ctx< T >
{
        using completion_signatures = ecor::
            completion_signatures< ecor::set_value_t( flat_id ), ecor::set_error_t( status ) >;
 
        asrt_collect_client* client;
        flat_id              parent;
        char const*          key;
        flat_id              out = 0;
 
        template < typename OP >
        void start( OP& op )
        {
                using traits      = collect_append_traits< T >;
                asrt_flat_value v = { .type = traits::flat_type };
                auto            s = asrt_collect_client_append(
                    client,
                    parent,
                    key,
                    &v,
                    &out,
                    +[]( void* ptr, enum asrt_status st ) {
                            auto* o = static_cast< OP* >( ptr );
                            if ( st == ASRT_SUCCESS )
                                    o->receiver.set_value( o->ctx.out );
                            else
                                    o->receiver.set_error( static_cast< status >( st ) );
                    },
                    &op );
                if ( s != ASRT_SUCCESS )
                        op.receiver.set_error( static_cast< status >( s ) );
        }
};
 
template < typename T >
        requires collect_scalar< T > || collect_container< T >
using collect_append_sender = ecor::sender_from< _collect_append_ctx< T > >;
 
template < collect_scalar T >
status append(
    ref< asrt_collect_client >    cc,
    flat_id                       parent,
    char const*                   key,
    T                             val,
    callback< asrt_send_done_cb > done_cb )
{
        using traits             = collect_append_traits< T >;
        using member_type        = decltype( asrt_flat_scalar{}.*traits::member );
        asrt_flat_value v        = { .type = traits::flat_type };
        v.data.s.*traits::member = static_cast< member_type >( val );
        return asrt_collect_client_append( cc, parent, key, &v, NULL, done_cb.fn, done_cb.ptr );
}
 
template < collect_scalar T >
ecor::sender auto append( ref< asrt_collect_client > cc, flat_id parent, char const* key, T val )
{
        return collect_append_sender< T >{ { cc, parent, key, val } };
}
 
template < collect_scalar T >
status append(
    ref< asrt_collect_client >    cc,
    flat_id                       parent,
    T                             val,
    callback< asrt_send_done_cb > done_cb )
{
        return append< T >( cc, parent, nullptr, val, done_cb );
}
 
template < collect_container T >
status append(
    ref< asrt_collect_client >    cc,
    flat_id                       parent,
    char const*                   key,
    flat_id&                      out,
    callback< asrt_send_done_cb > done_cb )
{
        using traits      = collect_append_traits< T >;
        asrt_flat_value v = { .type = traits::flat_type };
        return asrt_collect_client_append( cc, parent, key, &v, &out, done_cb.fn, done_cb.ptr );
}
 
template < collect_container T >
ecor::sender auto append( ref< asrt_collect_client > client, flat_id parent, char const* key )
{
        return collect_append_sender< T >{ { client, parent, key } };
}
 
template < collect_container T >
status append(
    ref< asrt_collect_client >    cc,
    flat_id                       parent,
    flat_id&                      out,
    callback< asrt_send_done_cb > done_cb )
{
        return append< T >( cc, parent, nullptr, out, done_cb );
}
 
template < collect_scalar T >
ecor::sender auto append( ref< asrt_collect_client > cc, flat_id parent, T val )
{
        return collect_append_sender< T >{ { cc, parent, nullptr, val } };
}
 
template < collect_container T >
ecor::sender auto append( ref< asrt_collect_client > client, flat_id parent )
{
        return collect_append_sender< T >{ { client, parent, nullptr } };
}
 
inline void deinit( ref< asrt_collect_client > client )
{
        asrt_collect_client_deinit( client );
}
 
}  // namespace asrt