nyx_node.h

/* NyxNode
 * Author: Jérôme ODIER <jerome.odier@lpsc.in2p3.fr>
 * SPDX-License-Identifier: GPL-2.0-only (Mongoose backend) or GPL-3.0+
 */
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
#ifndef NYX_NODE_H
#define NYX_NODE_H
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
#ifdef __cplusplus
extern "C" {
#endif
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
#ifndef ARDUINO
#  pragma clang diagnostic push
#  pragma ide diagnostic ignored "OCUnusedMacroInspection"
#  pragma ide diagnostic ignored "UnreachableCallsOfFunction"
#endif
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
double nan(const char *tag);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
#if !defined(__GNUC__) && !defined(__clang__) && !defined(__attribute__)
#  define __attribute__(x)
#endif
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
#define __NYX_NOTNULL__ \
            /* do nothing */
 
#define __NYX_NULLABLE__ \
            /* do nothing */
 
#define __NYX_ZEROABLE__ \
            /* do nothing */
 
#define __NYX_UNUSED__ \
            __attribute__ ((unused))
 
#define __NYX_INLINE__ \
            __attribute__ ((always_inline)) static inline
 
/*--------------------------------------------------------------------------------------------------------------------*/
/* MEMORY                                                                                                             */
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
#define buff_t /*-*/ void *                                                                     
#define BUFF_t const void *                                                                     
 
#define str_t /*-*/ char *                                                                      
#define STR_t const char *                                                                      
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
#define buffof(p) \
            ((buff_t *) (p))
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_memory_initialize(void);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
bool nyx_memory_finalize(void);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_ZEROABLE__ size_t nyx_memory_free(
    __NYX_NULLABLE__ buff_t buff
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_NULLABLE__ buff_t nyx_memory_alloc(
    __NYX_ZEROABLE__ size_t size
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_NULLABLE__ buff_t nyx_memory_realloc(
    __NYX_NULLABLE__ buff_t buff,
    __NYX_ZEROABLE__ size_t size
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_NULLABLE__ str_t nyx_string_dup(
    __NYX_NULLABLE__ STR_t s
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_NULLABLE__ str_t nyx_string_ndup(
    __NYX_NULLABLE__ STR_t s,
    __NYX_ZEROABLE__ size_t n
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
/* LOGGER                                                                                                             */
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef enum nyx_log_level_e
{
    NYX_LOG_LEVEL_NONE  = 100,
    NYX_LOG_LEVEL_FATAL = 101,
    NYX_LOG_LEVEL_ERROR = 102,
    NYX_LOG_LEVEL_WARN  = 103,
    NYX_LOG_LEVEL_INFO  = 104,
    NYX_LOG_LEVEL_DEBUG = 105,
    NYX_LOG_LEVEL_TRACE = 106,
 
} nyx_log_level_t;
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_set_log_level(
    nyx_log_level_t level
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void __attribute__((format(printf, 5, 6))) nyx_log(
    nyx_log_level_t level,
    STR_t file,
    STR_t func,
    int line,
    STR_t fmt,
    ...
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
#define NYX_LOG_FATAL(fmt, ...) \
            do { nyx_log(NYX_LOG_LEVEL_FATAL, __FILE__, __func__, __LINE__, fmt, ##__VA_ARGS__); } while(1)
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
#define NYX_LOG_ERROR(fmt, ...) \
            do { nyx_log(NYX_LOG_LEVEL_ERROR, __FILE__, __func__, __LINE__, fmt, ##__VA_ARGS__); } while(0)
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
#define NYX_LOG_INFO(fmt, ...) \
            do { nyx_log(NYX_LOG_LEVEL_INFO, __FILE__, __func__, __LINE__, fmt, ##__VA_ARGS__); } while(0)
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
#define NYX_LOG_DEBUG(fmt, ...) \
            do { nyx_log(NYX_LOG_LEVEL_DEBUG, __FILE__, __func__, __LINE__, fmt, ##__VA_ARGS__); } while(0)
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
#define NYX_LOG_VERBOSE(fmt, ...) \
            do { nyx_log(NYX_LOG_LEVEL_VERBOSE, __FILE__, __func__, __LINE__, fmt, ##__VA_ARGS__); } while(0)
 
/*--------------------------------------------------------------------------------------------------------------------*/
/* UTILITIES                                                                                                          */
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
uint32_t nyx_hash(
    __NYX_ZEROABLE__ size_t size,
    __NYX_NULLABLE__ BUFF_t buff,
    uint32_t seed
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_generate_mac_addr(
    uint8_t result_mac[6],
    uint8_t mac0,
    uint8_t mac1,
    STR_t node_id
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_NULLABLE__ str_t nyx_base64_encode(
    __NYX_NULLABLE__ size_t *result_len,
    __NYX_ZEROABLE__ size_t size,
    __NYX_NULLABLE__ BUFF_t buff
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_NULLABLE__ buff_t nyx_base64_decode(
    __NYX_NULLABLE__ size_t *result_size,
    __NYX_ZEROABLE__ size_t len,
    __NYX_NULLABLE__ STR_t str
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_NULLABLE__ buff_t nyx_zlib_deflate(
    __NYX_NULLABLE__ size_t *result_size,
    __NYX_ZEROABLE__ size_t size,
    __NYX_NULLABLE__ BUFF_t buff
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_NULLABLE__ buff_t nyx_zlib_inflate(
    __NYX_NOTNULL__ size_t *result_size,
    __NYX_ZEROABLE__ size_t size,
    __NYX_NULLABLE__ BUFF_t buff
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_NULLABLE__ str_t nyx_zlib_base64_deflate(
    __NYX_NULLABLE__ size_t *result_len,
    __NYX_ZEROABLE__ size_t size,
    __NYX_NULLABLE__ BUFF_t buff
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_NULLABLE__ buff_t nyx_zlib_base64_inflate(
    __NYX_NOTNULL__ size_t *result_size,
    __NYX_ZEROABLE__ size_t len,
    __NYX_NULLABLE__ STR_t str
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
/* OBJECT                                                                                                             */
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
#define NYX_OBJECT_MAGIC      UINT32_C(0x65656565)                                              
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
#define NYX_FLAGS_DISABLED    UINT64_C(0x0000000000000001)                                      // Flag indicating that the object is disabled.
    /* 0b0000000000000000000000000000000_0000000000000000000000000000000_01 */
 
#define NYX_FLAGS_BLOB_MASK   UINT64_C(0x00000001FFFFFFFC)                                      // Mask indicating the Nyx blob emission per client.
    /* 0b0000000000000000000000000000000_1111111111111111111111111111111_00 */
 
#define NYX_FLAGS_STREAM_MASK UINT64_C(0xFFFFFFFE00000000)                                      // Mask indicating the Nyx stream emission per client.
    /* 0b1111111111111111111111111111111_0000000000000000000000000000000_00 */
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef enum
{
    NYX_TYPE_NULL = 200,                                                                        
    NYX_TYPE_BOOLEAN = 201,                                                                     
    NYX_TYPE_NUMBER = 202,                                                                      
    NYX_TYPE_STRING = 203,                                                                      
    NYX_TYPE_DICT = 204,                                                                        
    NYX_TYPE_LIST = 205,                                                                        
 
} nyx_type_t;
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
struct nyx_dict_s;
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef struct nyx_object_s
{
    /*----------------------------------------------------------------------------------------------------------------*/
 
    uint32_t magic;                                                                             
    uint64_t flags;                                                                             
 
    nyx_type_t type;                                                                            
 
    /*----------------------------------------------------------------------------------------------------------------*/
 
    __NYX_NULLABLE__ struct nyx_node_s *node;                                                   
 
    __NYX_NULLABLE__ struct nyx_object_s *parent;                                               
 
    /*----------------------------------------------------------------------------------------------------------------*/
 
    union {
 
        __NYX_NULLABLE__ void *_ptr;                                                            
 
        __NYX_NULLABLE__ bool (* _int)(
            struct nyx_dict_s *vector,                                                          
            struct nyx_dict_s *prop,                                                            
            int new_value,                                                                      
            int old_value                                                                       
        );
 
        __NYX_NULLABLE__ bool (* _uint)(
            struct nyx_dict_s *vector,                                                          
            struct nyx_dict_s *prop,                                                            
            unsigned int new_value,                                                             
            unsigned int old_value                                                              
        );
 
        __NYX_NULLABLE__ bool (* _long)(
            struct nyx_dict_s *vector,                                                          
            struct nyx_dict_s *prop,                                                            
            long new_value,                                                                     
            long old_value                                                                      
        );
 
        __NYX_NULLABLE__ bool (* _ulong)(
            struct nyx_dict_s *vector,                                                          
            struct nyx_dict_s *prop,                                                            
            unsigned long new_value,                                                            
            unsigned long old_value                                                             
        );
 
        __NYX_NULLABLE__ bool (* _double)(
            struct nyx_dict_s *vector,                                                          
            struct nyx_dict_s *prop,                                                            
            double new_value,                                                                   
            double old_value                                                                    
        );
 
        __NYX_NULLABLE__ bool (* _str)(
            struct nyx_dict_s *vector,                                                          
            struct nyx_dict_s *prop,                                                            
            STR_t new_value,                                                                    
            STR_t old_value                                                                     
        );
 
        __NYX_NULLABLE__ bool (* _buffer)(
            struct nyx_dict_s *vector,                                                          
            struct nyx_dict_s *prop,                                                            
            size_t size,                                                                        
            BUFF_t buff                                                                         
        );
 
        __NYX_NULLABLE__ void (* _vector)(
            struct nyx_dict_s *vector,                                                          
            bool modified                                                                       
        );
 
    } in_callback;                                                                              
 
    /*----------------------------------------------------------------------------------------------------------------*/
 
    __NYX_NULLABLE__ void *ctx;                                                                 
 
    /*----------------------------------------------------------------------------------------------------------------*/
 
} nyx_object_t;
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_NULLABLE__ nyx_object_t *nyx_object_parse_buff(
    __NYX_ZEROABLE__ size_t size,
    __NYX_NULLABLE__ BUFF_t buff
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_NULLABLE__ nyx_object_t *nyx_object_parse(
    __NYX_NULLABLE__ STR_t string
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_object_free(
    __NYX_NULLABLE__ nyx_object_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
bool nyx_object_equal(
    __NYX_NULLABLE__ const nyx_object_t *object1,
    __NYX_NULLABLE__ const nyx_object_t *object2
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
str_t nyx_object_to_string(
    __NYX_NULLABLE__ const nyx_object_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
str_t nyx_object_to_cstring(
    __NYX_NULLABLE__ const nyx_object_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
/* NULL                                                                                                               */
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef struct
{
    nyx_object_t base;                                                                          
 
} nyx_null_t;
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_null_t *nyx_null_new(void);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_null_free(
    /*-*/ nyx_null_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
str_t nyx_null_to_string(
    const nyx_null_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
/* NUMBER                                                                                                             */
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef struct
{
    nyx_object_t base;                                                                          
 
    double value;                                                                               
 
} nyx_number_t;
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_number_t *nyx_number_new(void);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_number_free(
    /*-*/ nyx_number_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
double nyx_number_get(
    const nyx_number_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
bool nyx_number_set(
    /*-*/ nyx_number_t *object,
    double value
);
 
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
str_t nyx_number_to_string(
    const nyx_number_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_INLINE__ nyx_number_t *nyx_number_from(double value)
{
    nyx_number_t *result = nyx_number_new();
 
    nyx_number_set(result, value);
 
    return result;
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
/* BOOLEAN                                                                                                            */
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef struct
{
    nyx_object_t base;                                                                          
 
    bool value;                                                                                 
 
} nyx_boolean_t;
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_boolean_t *nyx_boolean_new(void);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_boolean_free(
    /*-*/ nyx_boolean_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
bool nyx_boolean_get(
    const nyx_boolean_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
bool nyx_boolean_set(
    /*-*/ nyx_boolean_t *object,
    bool value
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
str_t nyx_boolean_to_string(
    const nyx_boolean_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_INLINE__ nyx_boolean_t *nyx_boolean_from(bool value)
{
    nyx_boolean_t *result = nyx_boolean_new();
 
    nyx_boolean_set(result, value);
 
    return result;
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
/* STRING                                                                                                             */
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef struct
{
    nyx_object_t base;                                                                          
 
    bool managed;                                                                               
    size_t length;                                                                              
    str_t value;                                                                                
 
} nyx_string_t;
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_string_t *nyx_string_new(void);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_string_free(
    /*-*/ nyx_string_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
STR_t nyx_string_get(
    const nyx_string_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_string_get_buff(
    const nyx_string_t *object,
    __NYX_NULLABLE__ size_t *result_size,
    __NYX_NULLABLE__ buff_t *result_buff
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
bool nyx_string_set(
    /*-*/ nyx_string_t *object,
    STR_t value,
    bool managed
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
bool nyx_string_set_buff(
    /*-*/ nyx_string_t *object,
    size_t size,
    BUFF_t buff,
    bool managed
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
size_t nyx_string_length(
    const nyx_string_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
str_t nyx_string_to_string(
    const nyx_string_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
str_t nyx_string_to_cstring(
    const nyx_string_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_INLINE__ nyx_string_t *nyx_string_from_dup(STR_t value)
{
    nyx_string_t *result = nyx_string_new();
 
    nyx_string_set(result, nyx_string_dup(value), true);
 
    return result;
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_INLINE__ nyx_string_t *nyx_string_from_managed(STR_t value)
{
    nyx_string_t *result = nyx_string_new();
 
    nyx_string_set(result, value, true);
 
    return result;
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_INLINE__ nyx_string_t *nyx_string_from_unmanaged(STR_t value)
{
    nyx_string_t *result = nyx_string_new();
 
    nyx_string_set(result, value, false);
 
    return result;
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_INLINE__ nyx_string_t *nyx_string_from_buff_managed(size_t size, BUFF_t buff)
{
    nyx_string_t *result = nyx_string_new();
 
    nyx_string_set_buff(result, size, buff, true);
 
    return result;
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_INLINE__ nyx_string_t *nyx_string_from_buff_unmanaged(size_t size, BUFF_t buff)
{
    nyx_string_t *result = nyx_string_new();
 
    nyx_string_set_buff(result, size, buff, false);
 
    return result;
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
/* DICT                                                                                                               */
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef struct nyx_dict_s
{
    nyx_object_t base;                                                                          
 
    struct nyx_dict_node_s *head;                                                               
    struct nyx_dict_node_s *tail;                                                               
 
} nyx_dict_t;
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef struct
{
    size_t idx;                                                                                 
 
    struct nyx_dict_node_s *head;                                                               
 
} nyx_dict_iter_t;
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
#define NYX_DICT_ITER(dict) \
                ((nyx_dict_iter_t) {.idx = 0, .head = ((nyx_dict_t *) (dict))->head})
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_dict_new(void);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_dict_free(
    /*-*/ nyx_dict_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_dict_clear(
    /*-*/ nyx_dict_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_dict_del(
    /*-*/ nyx_dict_t *object,
    STR_t key
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
bool nyx_dict_iterate(
    nyx_dict_iter_t *iter,
    STR_t *key,
    nyx_object_t **object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_object_t *nyx_dict_get(
    const nyx_dict_t *object,
    STR_t key
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
bool nyx_dict_set(
    /*-*/ nyx_dict_t *object,
    STR_t key,
    void *value
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
size_t nyx_dict_size(
    const nyx_dict_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
str_t nyx_dict_to_string(
    const nyx_dict_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_INLINE__ bool nyx_dict_get_boolean(const nyx_dict_t *object, STR_t key)
{
    nyx_object_t *value = nyx_dict_get(object, key);
 
    return value != NULL && value->type == NYX_TYPE_BOOLEAN ? nyx_boolean_get((nyx_boolean_t *) value)
                                                            : false
    ;
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_INLINE__ double nyx_dict_get_number(const nyx_dict_t *object, STR_t key)
{
    nyx_object_t *value = nyx_dict_get(object, key);
 
    return value != NULL && value->type == NYX_TYPE_NUMBER ? nyx_number_get((nyx_number_t *) value)
                                                           : nan("1")
    ;
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_INLINE__ STR_t nyx_dict_get_string(const nyx_dict_t *object, STR_t key)
{
    nyx_object_t *value = nyx_dict_get(object, key);
 
    return value != NULL && value->type == NYX_TYPE_STRING ? nyx_string_get((nyx_string_t *) value)
                                                           : NULL
    ;
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
/* LIST                                                                                                               */
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef struct nyx_list_s
{
    nyx_object_t base;                                                                          
 
    struct nyx_list_node_s *head;                                                               
    struct nyx_list_node_s *tail;                                                               
 
} nyx_list_t;
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef struct
{
    size_t idx;                                                                                 
 
    struct nyx_list_node_s *head;                                                               
 
} nyx_list_iter_t;
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
#define NYX_LIST_ITER(list) \
                ((nyx_list_iter_t) {.idx = 0, .head = ((nyx_list_t *) (list))->head})
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_list_t *nyx_list_new(void);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_list_free(
    /*-*/ nyx_list_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_list_clear(
    /*-*/ nyx_list_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_list_del(
    /*-*/ nyx_list_t *object,
    size_t idx
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
bool nyx_list_iterate(
    nyx_list_iter_t *iter,
    size_t *idx,
    nyx_object_t **object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_object_t *nyx_list_get(
    const nyx_list_t *object,
    size_t idx
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
bool nyx_list_set(
    /*-*/ nyx_list_t *object,
    size_t idx,
    void *value
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_INLINE__ bool nyx_list_push(nyx_list_t *object, void *value)
{
    return nyx_list_set(object, (size_t) -1, value);
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
size_t nyx_list_size(
    const nyx_list_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
str_t nyx_list_to_string(
    const nyx_list_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_INLINE__ bool nyx_list_get_boolean(const nyx_list_t *object, size_t idx)
{
    nyx_object_t *boolean = nyx_list_get(object, idx);
 
    return boolean != NULL && boolean->type == NYX_TYPE_BOOLEAN ? nyx_boolean_get((nyx_boolean_t *) boolean)
                                                                : false
    ;
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_INLINE__ double nyx_list_get_number(const nyx_list_t *object, size_t idx)
{
    nyx_object_t *number = nyx_list_get(object, idx);
 
    return number != NULL && number->type == NYX_TYPE_NUMBER ? nyx_number_get((nyx_number_t *) number)
                                                             : nan("1")
    ;
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_INLINE__ STR_t nyx_list_get_string(const nyx_list_t *object, size_t idx)
{
    nyx_object_t *string = nyx_list_get(object, idx);
 
    return string != NULL && string->type == NYX_TYPE_STRING ? nyx_string_get((nyx_string_t *) string)
                                                             : NULL
    ;
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
/* XMLDOC                                                                                                             */
/*--------------------------------------------------------------------------------------------------------------------*/
#if !defined(ARDUINO)
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef enum
{
    NYX_XML_ELEM = 300,                                                                         
    NYX_XML_ATTR = 301,                                                                         
    NYX_XML_COMMENT = 302,                                                                      
    NYX_XML_CDATA = 303,                                                                        
    NYX_XML_TEXT = 304,                                                                         
 
} nyx_xml_type_t;
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef struct nyx_xmldoc_s
{
    str_t name;
    nyx_xml_type_t type;
    str_t data;
 
    struct nyx_xmldoc_s *next;
    struct nyx_xmldoc_s *parent;
 
    struct nyx_xmldoc_s *children;
    struct nyx_xmldoc_s *attributes;
 
    bool self_closing;
 
} nyx_xmldoc_t;
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_NULLABLE__ nyx_xmldoc_t *nyx_xmldoc_parse_buff(
    __NYX_ZEROABLE__ size_t size,
    __NYX_NULLABLE__ BUFF_t buff
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_NULLABLE__ nyx_xmldoc_t *nyx_xmldoc_parse(
    __NYX_NULLABLE__ STR_t string
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_xmldoc_free(
    __NYX_NULLABLE__ nyx_xmldoc_t *xmldoc
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
str_t nyx_xmldoc_to_string(
    const nyx_xmldoc_t *xmldoc
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
#endif
/*--------------------------------------------------------------------------------------------------------------------*/
/* TRANSFORM                                                                                                          */
/*--------------------------------------------------------------------------------------------------------------------*/
#if !defined(ARDUINO)
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_NULLABLE__ nyx_object_t *nyx_xmldoc_to_object(
    __NYX_NULLABLE__ const nyx_xmldoc_t *xmldoc
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_NULLABLE__ nyx_xmldoc_t *nyx_object_to_xmldoc(
    __NYX_NULLABLE__ const nyx_object_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
#endif
/*--------------------------------------------------------------------------------------------------------------------*/
/* NYX                                                                                                               */
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
#define NYX_INDI_VERSION "1.7"                                                                  
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef enum
{
    NYX_STATE_IDLE = 400,                                                                       
    NYX_STATE_OK = 401,                                                                         
    NYX_STATE_BUSY = 402,                                                                       
    NYX_STATE_ALERT = 403,                                                                      
 
} nyx_state_t;
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
STR_t nyx_state_to_str(
    nyx_state_t state
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_state_t nyx_str_to_state(
    STR_t state
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef enum
{
    NYX_PERM_RO = 500,                                                                          
    NYX_PERM_WO = 501,                                                                          
    NYX_PERM_RW = 502,                                                                          
 
} nyx_perm_t;
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
STR_t nyx_perm_to_str(
    nyx_perm_t perm
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_perm_t nyx_str_to_perm(
    STR_t perm
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef enum
{
    NYX_RULE_ONE_OF_MANY = 600,                                                                 
    NYX_RULE_AT_MOST_ONE = 601,                                                                 
    NYX_RULE_ANY_OF_MANY = 602,                                                                 
 
} nyx_rule_t;
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
STR_t nyx_rule_to_str(
    nyx_rule_t rule
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_rule_t nyx_str_to_rule(
    STR_t rule
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef enum
{
    NYX_ONOFF_ON = 700,                                                                         
    NYX_ONOFF_OFF = 701,                                                                        
 
} nyx_onoff_t;
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
STR_t nyx_onoff_to_str(
    nyx_onoff_t onoff
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_onoff_t nyx_str_to_onoff(
    STR_t onoff
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef struct
{
    __NYX_NULLABLE__ STR_t group;                                                                   
    __NYX_NULLABLE__ STR_t label;                                                                   
    __NYX_NULLABLE__ STR_t hints;                                                                   
    __NYX_NULLABLE__ STR_t message;                                                                 
    __NYX_ZEROABLE__ double timeout;                                                                
 
} nyx_opts_t;
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef struct
{
    /*----------------------------------------------------------------------------------------------------------------*/
 
    enum
    {
        NYX_VARIANT_TYPE_INT = 1000,
        NYX_VARIANT_TYPE_UINT = 1001,
        NYX_VARIANT_TYPE_LONG = 1002,
        NYX_VARIANT_TYPE_ULONG = 1003,
        NYX_VARIANT_TYPE_DOUBLE = 1004,
 
    } type;
 
    /*----------------------------------------------------------------------------------------------------------------*/
 
    union
    {
        int32_t _int;
        uint32_t _uint;
        int64_t _long;
        uint64_t _ulong;
        double _double;
 
    } value;
 
    /*----------------------------------------------------------------------------------------------------------------*/
 
} nyx_variant_t;
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_INLINE__ nyx_variant_t NYX_VARIANT_FROM_INT(int32_t value)
{
    #ifndef __cplusplus
    return (nyx_variant_t) {NYX_VARIANT_TYPE_INT, {._int = value}};
    #else
    return (nyx_variant_t) {nyx_variant_t::NYX_VARIANT_TYPE_INT, {._int = value}};
    #endif
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_INLINE__ nyx_variant_t NYX_VARIANT_FROM_UINT(uint32_t value)
{
    #ifndef __cplusplus
    return (nyx_variant_t) {NYX_VARIANT_TYPE_UINT, {._uint = value}};
    #else
    return (nyx_variant_t) {nyx_variant_t::NYX_VARIANT_TYPE_UINT, {._uint = value}};
    #endif
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_INLINE__ nyx_variant_t NYX_VARIANT_FROM_LONG(int64_t value)
{
    #ifndef __cplusplus
    return (nyx_variant_t) {NYX_VARIANT_TYPE_LONG, {._long = value}};
    #else
    return (nyx_variant_t) {nyx_variant_t::NYX_VARIANT_TYPE_LONG, {._long = value}};
    #endif
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_INLINE__ nyx_variant_t NYX_VARIANT_FROM_ULONG(uint64_t value)
{
    #ifndef __cplusplus
    return (nyx_variant_t) {NYX_VARIANT_TYPE_ULONG, {._ulong = value}};
    #else
    return (nyx_variant_t) {nyx_variant_t::NYX_VARIANT_TYPE_ULONG, {._ulong = value}};
    #endif
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_INLINE__ nyx_variant_t NYX_VARIANT_FROM_DOUBLE(double value)
{
    #ifndef __cplusplus
    return (nyx_variant_t) {NYX_VARIANT_TYPE_DOUBLE, {._double = value}};
    #else
    return (nyx_variant_t) {nyx_variant_t::NYX_VARIANT_TYPE_DOUBLE, {._double = value}};
    #endif
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_number_prop_new(
    STR_t name,
    __NYX_NULLABLE__ STR_t label,
    STR_t format,
    nyx_variant_t min,
    nyx_variant_t max,
    nyx_variant_t step,
    nyx_variant_t value
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_INLINE__ nyx_dict_t *nyx_number_prop_new_int(STR_t name,__NYX_NULLABLE__ STR_t label, STR_t format, int32_t min, int32_t max, int32_t step, int32_t value)
{
    return nyx_number_prop_new(name, label, format, NYX_VARIANT_FROM_INT(min), NYX_VARIANT_FROM_INT(max), NYX_VARIANT_FROM_INT(step), NYX_VARIANT_FROM_INT(value));
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_INLINE__ nyx_dict_t *nyx_number_prop_new_uint(STR_t name,__NYX_NULLABLE__ STR_t label, STR_t format, uint32_t min, uint32_t max, uint32_t step, uint32_t value)
{
    return nyx_number_prop_new(name, label, format, NYX_VARIANT_FROM_UINT(min), NYX_VARIANT_FROM_UINT(max), NYX_VARIANT_FROM_UINT(step), NYX_VARIANT_FROM_UINT(value));
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_INLINE__ nyx_dict_t *nyx_number_prop_new_long(STR_t name,__NYX_NULLABLE__ STR_t label, STR_t format, int64_t min, int64_t max, int64_t step, int64_t value)
{
    return nyx_number_prop_new(name, label, format, NYX_VARIANT_FROM_LONG(min), NYX_VARIANT_FROM_LONG(max), NYX_VARIANT_FROM_LONG(step), NYX_VARIANT_FROM_LONG(value));
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_INLINE__ nyx_dict_t *nyx_number_prop_new_ulong(STR_t name,__NYX_NULLABLE__ STR_t label, STR_t format, uint64_t min, uint64_t max, uint64_t step, uint64_t value)
{
    return nyx_number_prop_new(name, label, format, NYX_VARIANT_FROM_ULONG(min), NYX_VARIANT_FROM_ULONG(max), NYX_VARIANT_FROM_ULONG(step), NYX_VARIANT_FROM_ULONG(value));
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_INLINE__ nyx_dict_t *nyx_number_prop_new_double(STR_t name,__NYX_NULLABLE__ STR_t label, STR_t format, double min, double max, double step, double value)
{
    return nyx_number_prop_new(name, label, format, NYX_VARIANT_FROM_DOUBLE(min), NYX_VARIANT_FROM_DOUBLE(max), NYX_VARIANT_FROM_DOUBLE(step), NYX_VARIANT_FROM_DOUBLE(value));
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
bool nyx_number_prop_set(
    nyx_dict_t *prop,
    nyx_variant_t value
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_variant_t nyx_number_prop_get(
    const nyx_dict_t *prop
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_INLINE__ bool nyx_number_prop_set_int(nyx_dict_t *prop, int32_t value)
{
    return nyx_number_prop_set(prop, NYX_VARIANT_FROM_INT(value));
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_INLINE__ int32_t nyx_number_prop_get_int(const nyx_dict_t *prop)
{
    return nyx_number_prop_get(prop).value._int;
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_INLINE__ bool nyx_number_prop_set_uint(nyx_dict_t *prop, uint32_t value)
{
    return nyx_number_prop_set(prop, NYX_VARIANT_FROM_UINT(value));
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_INLINE__ uint32_t nyx_number_prop_get_uint(const nyx_dict_t *prop)
{
    return nyx_number_prop_get(prop).value._uint;
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_INLINE__ bool nyx_number_prop_set_long(nyx_dict_t *prop, int64_t value)
{
    return nyx_number_prop_set(prop, NYX_VARIANT_FROM_LONG(value));
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_INLINE__ int64_t nyx_number_prop_get_long(const nyx_dict_t *prop)
{
    return nyx_number_prop_get(prop).value._long;
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_INLINE__ bool nyx_number_prop_set_ulong(nyx_dict_t *prop, uint64_t value)
{
    return nyx_number_prop_set(prop, NYX_VARIANT_FROM_ULONG(value));
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_INLINE__ uint64_t nyx_number_prop_get_ulong(const nyx_dict_t *prop)
{
    return nyx_number_prop_get(prop).value._ulong;
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_INLINE__ bool nyx_number_prop_set_double(nyx_dict_t *prop, double value)
{
    return nyx_number_prop_set(prop, NYX_VARIANT_FROM_DOUBLE(value));
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_INLINE__ double nyx_number_prop_get_double(const nyx_dict_t *prop)
{
    return nyx_number_prop_get(prop).value._double;
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_number_vector_new(
    STR_t device,
    STR_t name,
    nyx_state_t state,
    nyx_perm_t perm,
    nyx_dict_t *props[],
    __NYX_NULLABLE__ const nyx_opts_t *opts
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_number_set_vector_new(
    const nyx_dict_t *vector
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_text_prop_new(
    STR_t name,
    __NYX_NULLABLE__ STR_t label,
    __NYX_NULLABLE__ STR_t value
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
bool nyx_text_prop_set(
    nyx_dict_t *prop,
    __NYX_NULLABLE__ STR_t value
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
STR_t nyx_text_prop_get(
    const nyx_dict_t *prop
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_text_vector_new(
    STR_t device,
    STR_t name,
    nyx_state_t state,
    nyx_perm_t perm,
    nyx_dict_t *props[],
    __NYX_NULLABLE__ const nyx_opts_t *opts
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_text_set_vector_new(
    const nyx_dict_t *vector
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_light_prop_new(
    STR_t name,
    __NYX_NULLABLE__ STR_t label,
    nyx_state_t value
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
bool nyx_light_prop_set(
    nyx_dict_t *prop,
    nyx_state_t value
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_state_t nyx_light_prop_get(
    const nyx_dict_t *prop
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_light_vector_new(
    STR_t device,
    STR_t name,
    nyx_state_t state,
    nyx_dict_t *props[],
    __NYX_NULLABLE__ const nyx_opts_t *opts
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_light_set_vector_new(
    const nyx_dict_t *vector
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_switch_prop_new(
    STR_t name,
    __NYX_NULLABLE__ STR_t label,
    nyx_onoff_t value
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
bool nyx_switch_prop_set(
    nyx_dict_t *prop,
    nyx_onoff_t value
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_onoff_t nyx_switch_prop_get(
    const nyx_dict_t *prop
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_switch_vector_new(
    STR_t device,
    STR_t name,
    nyx_state_t state,
    nyx_perm_t perm,
    nyx_rule_t rule,
    nyx_dict_t *props[],
    __NYX_NULLABLE__ const  nyx_opts_t *opts
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_switch_set_vector_new(
    const nyx_dict_t *vector
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_blob_prop_new(
    STR_t name,
    __NYX_NULLABLE__ STR_t label,
    __NYX_NULLABLE__ STR_t format,
    __NYX_ZEROABLE__ size_t size,
    __NYX_NULLABLE__ BUFF_t buff,
    bool managed
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
bool nyx_blob_prop_set_managed(
    nyx_dict_t *prop,
    __NYX_ZEROABLE__ size_t size,
    __NYX_NULLABLE__ BUFF_t buff
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
bool nyx_blob_prop_set_unmanaged(
    nyx_dict_t *prop,
    __NYX_ZEROABLE__ size_t size,
    __NYX_NULLABLE__ BUFF_t buff
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_blob_prop_get(
    const nyx_dict_t *prop,
    __NYX_NULLABLE__ size_t *size,
    __NYX_NULLABLE__ buff_t *buff
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_blob_vector_new(
    STR_t device,
    STR_t name,
    nyx_state_t state,
    nyx_perm_t perm,
    nyx_dict_t *props[],
    __NYX_NULLABLE__ const nyx_opts_t *opts
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_blob_set_vector_new(
    const nyx_dict_t *vector
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_stream_prop_new(
    STR_t name,
    __NYX_NULLABLE__ STR_t label
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_stream_vector_new(
    STR_t device,
    STR_t name,
    nyx_state_t state,
    nyx_dict_t *props[],
    __NYX_NULLABLE__ const nyx_opts_t *opts
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
bool nyx_stream_pub(
    const nyx_dict_t *vector,
    __NYX_ZEROABLE__ size_t n_fields,
    const size_t field_sizes[],
    const buff_t field_buffs[]
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_stream_set_vector_new(
    const nyx_dict_t *vector
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_message_new(
    STR_t device,
    __NYX_NULLABLE__ STR_t message
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_del_property_new(
    STR_t device,
    __NYX_NULLABLE__ STR_t name,
    __NYX_NULLABLE__ STR_t message
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
/* NODE                                                                                                               */
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef struct nyx_node_s nyx_node_t;
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef enum
{
    NYX_NODE_EVENT_OPEN = 1100,                                                                      
    NYX_NODE_EVENT_MSG = 1101,                                                                       
 
} nyx_event_type_t;
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef void (* nyx_mqtt_handler_t)(
    nyx_node_t *node,
    nyx_event_type_t event_type,
    size_t topic_size,
    BUFF_t topic_buff,
    size_t message_size,
    BUFF_t message_buff
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NYX_NULLABLE__ nyx_node_t *nyx_node_initialize(
    STR_t node_id,
    nyx_dict_t *vectors[],
    
    __NYX_NULLABLE__ STR_t indi_url,
    __NYX_NULLABLE__ STR_t mqtt_url,
    __NYX_NULLABLE__ STR_t nss_url,
    
    __NYX_NULLABLE__ STR_t mqtt_username,
    __NYX_NULLABLE__ STR_t mqtt_password,
    
    __NYX_NULLABLE__ nyx_mqtt_handler_t mqtt_handler,
    
    uint32_t retry_ms,
    bool enable_xml
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_node_finalize(
    nyx_node_t *node,
    bool free_vectors
    );
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_node_add_timer(
    const nyx_node_t *node,
    uint32_t interval_ms,
    void(* callback)(void *),
    void *arg
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_node_poll(
    const nyx_node_t *node,
    uint32_t timeout_ms
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
bool nyx_node_notify(
    __NYX_NULLABLE__ nyx_object_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_node_enable(
    const nyx_node_t *node,
    /*------------*/ STR_t device,
    __NYX_NULLABLE__ STR_t name,
    __NYX_NULLABLE__ STR_t message
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_node_disable(
    const nyx_node_t *node,
    /*------------*/ STR_t device,
    __NYX_NULLABLE__ STR_t name,
    __NYX_NULLABLE__ STR_t message
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_node_send_message(
    const nyx_node_t *node,
    STR_t device,
    __NYX_NULLABLE__ STR_t message
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_node_send_del_property(
    const nyx_node_t *node,
    STR_t device,
    __NYX_NULLABLE__ STR_t name,
    __NYX_NULLABLE__ STR_t message
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_mqtt_sub(
    const nyx_node_t *node,
    STR_t topic,
    int qos
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_mqtt_pub(
    const nyx_node_t *node,
    STR_t topic,
    __NYX_ZEROABLE__ size_t message_size,
    __NYX_NULLABLE__ BUFF_t message_buff,
    int qos
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_nss_pub(
    const nyx_node_t *node,
    STR_t device,
    STR_t stream,
    __NYX_ZEROABLE__ size_t n_fields,
    const uint32_t field_hashes[],
    const size_t field_sizes[],
    const buff_t field_buffs[]
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
#ifndef ARDUINO
#  pragma clang diagnostic pop
#endif
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
#ifdef __cplusplus
}
#endif
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
#endif /* NYX_NODE_H */
 
/*--------------------------------------------------------------------------------------------------------------------*/