collect.h

 
#ifndef ASRT_COLLECT_CLIENT_H
#define ASRT_COLLECT_CLIENT_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include "../asrtl/chann.h"
#include "../asrtl/collect_proto.h"
#include "../asrtl/flat_tree.h"
 
typedef asrt_send_done_cb asrt_collect_done_cb;
 
enum asrt_collect_client_state
{
        ASRT_COLLECT_CLIENT_IDLE = 0,
        ASRT_COLLECT_CLIENT_READY_RECV,
        ASRT_COLLECT_CLIENT_READY_SENT,
        ASRT_COLLECT_CLIENT_ACTIVE,
        ASRT_COLLECT_CLIENT_APPEND_SENT,
        ASRT_COLLECT_CLIENT_ERROR,
};
 
struct asrt_collect_client
{
        struct asrt_node node;
 
        enum asrt_collect_client_state state;
        asrt_flat_id                   root_id;       
        asrt_flat_id                   next_node_id;  
 
        struct asrt_u8d1msg            ready_ack_msg;
        struct asrt_collect_append_msg append_msg;
 
        asrt_collect_done_cb append_done_cb;  
        void*                append_done_ptr;
};
 
enum asrt_status asrt_collect_client_init(
    struct asrt_collect_client* client,
    struct asrt_node*           prev );
 
void asrt_collect_client_deinit( struct asrt_collect_client* client );
 
enum asrt_status asrt_collect_client_append(
    struct asrt_collect_client*   client,
    asrt_flat_id                  parent_id,
    char const*                   key,
    struct asrt_flat_value const* value,
    asrt_flat_id*                 out_id,
    asrt_collect_done_cb          done_cb,
    void*                         done_ptr );
 
static inline enum asrt_status asrt_collect_client_append_object(
    struct asrt_collect_client* client,
    asrt_flat_id                parent_id,
    char const*                 key,
    asrt_flat_id*               out_id,
    asrt_collect_done_cb        done_cb,
    void*                       done_ptr )
{
        struct asrt_flat_value v = { .type = ASRT_FLAT_CTYPE_OBJECT };
        return asrt_collect_client_append( client, parent_id, key, &v, out_id, done_cb, done_ptr );
}
 
static inline enum asrt_status asrt_collect_client_append_array(
    struct asrt_collect_client* client,
    asrt_flat_id                parent_id,
    char const*                 key,
    asrt_flat_id*               out_id,
    asrt_collect_done_cb        done_cb,
    void*                       done_ptr )
{
        struct asrt_flat_value v = { .type = ASRT_FLAT_CTYPE_ARRAY };
        return asrt_collect_client_append( client, parent_id, key, &v, out_id, done_cb, done_ptr );
}
 
static inline enum asrt_status asrt_collect_client_append_u32(
    struct asrt_collect_client* client,
    asrt_flat_id                parent_id,
    char const*                 key,
    uint32_t                    val,
    asrt_collect_done_cb        done_cb,
    void*                       done_ptr )
{
        struct asrt_flat_value v = { .type = ASRT_FLAT_STYPE_U32 };
        v.data.s.u32_val         = val;
        return asrt_collect_client_append( client, parent_id, key, &v, NULL, done_cb, done_ptr );
}
 
static inline enum asrt_status asrt_collect_client_append_i32(
    struct asrt_collect_client* client,
    asrt_flat_id                parent_id,
    char const*                 key,
    int32_t                     val,
    asrt_collect_done_cb        done_cb,
    void*                       done_ptr )
{
        struct asrt_flat_value v = { .type = ASRT_FLAT_STYPE_I32 };
        v.data.s.i32_val         = val;
        return asrt_collect_client_append( client, parent_id, key, &v, NULL, done_cb, done_ptr );
}
 
static inline enum asrt_status asrt_collect_client_append_str(
    struct asrt_collect_client* client,
    asrt_flat_id                parent_id,
    char const*                 key,
    char const*                 val,
    asrt_collect_done_cb        done_cb,
    void*                       done_ptr )
{
        struct asrt_flat_value v = { .type = ASRT_FLAT_STYPE_STR };
        v.data.s.str_val         = val;
        return asrt_collect_client_append( client, parent_id, key, &v, NULL, done_cb, done_ptr );
}
 
static inline enum asrt_status asrt_collect_client_append_bool(
    struct asrt_collect_client* client,
    asrt_flat_id                parent_id,
    char const*                 key,
    uint32_t                    val,
    asrt_collect_done_cb        done_cb,
    void*                       done_ptr )
{
        struct asrt_flat_value v = { .type = ASRT_FLAT_STYPE_BOOL };
        v.data.s.bool_val        = val;
        return asrt_collect_client_append( client, parent_id, key, &v, NULL, done_cb, done_ptr );
}
 
static inline enum asrt_status asrt_collect_client_append_float(
    struct asrt_collect_client* client,
    asrt_flat_id                parent_id,
    char const*                 key,
    float                       val,
    asrt_collect_done_cb        done_cb,
    void*                       done_ptr )
{
        struct asrt_flat_value v = { .type = ASRT_FLAT_STYPE_FLOAT };
        v.data.s.float_val       = val;
        return asrt_collect_client_append( client, parent_id, key, &v, NULL, done_cb, done_ptr );
}
 
static inline enum asrt_status asrt_collect_client_append_null(
    struct asrt_collect_client* client,
    asrt_flat_id                parent_id,
    char const*                 key,
    asrt_collect_done_cb        done_cb,
    void*                       done_ptr )
{
        struct asrt_flat_value v = { .type = ASRT_FLAT_STYPE_NULL };
        return asrt_collect_client_append( client, parent_id, key, &v, NULL, done_cb, done_ptr );
}
 
static inline asrt_flat_id asrt_collect_client_root_id( struct asrt_collect_client const* client )
{
        return client->root_id;
}
 
static inline uint8_t asrt_collect_client_is_busy( struct asrt_collect_client const* client )
{
        return client->state == ASRT_COLLECT_CLIENT_READY_SENT ||
               client->state == ASRT_COLLECT_CLIENT_APPEND_SENT;
}
 
#ifdef __cplusplus
}
#endif
 
#endif  // ASRT_COLLECT_CLIENT_H