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);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
#define __NULLABLE__ \
            /* do nothing */
 
#define __ZEROABLE__ \
            /* do nothing */
 
#define __UNUSED__ \
            __attribute__((unused))
 
#define __INLINE__ \
            __attribute__((always_inline)) static inline
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef /*-*/ void *buff_t;
typedef const void *BUFF_t;
 
typedef /*-*/ char *str_t;
typedef const char *STR_t;
 
/*--------------------------------------------------------------------------------------------------------------------*/
/* MEMORY                                                                                                             */
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_memory_initialize();
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
bool nyx_memory_finalize();
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__ZEROABLE__ size_t nyx_memory_free(
    __NULLABLE__ buff_t buff
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NULLABLE__ buff_t nyx_memory_alloc(
    __ZEROABLE__ size_t size
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NULLABLE__ buff_t nyx_memory_realloc(
    __NULLABLE__ buff_t buff,
    __ZEROABLE__ size_t size
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
/* LOGGER                                                                                                             */
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef enum nyx_log_level_e
{
    NYX_LOG_LEVEL_NONE    = 0,
    NYX_LOG_LEVEL_FATAL   = 1,
    NYX_LOG_LEVEL_ERROR   = 2,
    NYX_LOG_LEVEL_INFO    = 3,
    NYX_LOG_LEVEL_DEBUG   = 4,
    NYX_LOG_LEVEL_VERBOSE = 5,
 
} nyx_log_level_t;
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_set_log_level(
    nyx_log_level_t level
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void 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                                                                                                          */
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_generate_mac_addr(
    uint8_t result_mac[6],
    uint8_t mac0,
    uint8_t mac1,
    STR_t node_id
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NULLABLE__ str_t nyx_base64_encode(
    __NULLABLE__ size_t *result_len,
    __ZEROABLE__ size_t size,
    __NULLABLE__ BUFF_t buff
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NULLABLE__ buff_t nyx_base64_decode(
    __NULLABLE__ size_t *result_size,
    __ZEROABLE__ size_t len,
    __NULLABLE__ STR_t str
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
uint32_t nyx_hash32(
    __ZEROABLE__ size_t size,
    __NULLABLE__ BUFF_t buff,
    uint32_t seed
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
/* OBJECT                                                                                                             */
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
#define NYX_OBJECT_MAGIC 0x65656565U                                                            
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
#define NYX_FLAGS_DISABLED    ((uint64_t) 0x0000000000000001U)                                  
/* 0b0000000000000000000000000000000_0000000000000000000000000000000_01 */
 
#define NYX_FLAGS_BLOB_MASK   ((uint64_t) 0x00000001FFFFFFFCU)                                  
/* 0b0000000000000000000000000000000_1111111111111111111111111111111_00 */
 
#define NYX_FLAGS_STREAM_MASK ((uint64_t) 0xFFFFFFFE00000000U)                                  
/* 0b1111111111111111111111111111111_0000000000000000000000000000000_00 */
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef enum
{
    NYX_TYPE_NULL = 100,                                                                        
    NYX_TYPE_BOOLEAN = 101,                                                                     
    NYX_TYPE_NUMBER = 102,                                                                      
    NYX_TYPE_STRING = 103,                                                                      
    NYX_TYPE_DICT = 104,                                                                        
    NYX_TYPE_LIST = 105,                                                                        
 
} nyx_type_t;
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef struct nyx_object_s
{
    uint32_t magic;                                                                             
    uint64_t flags;                                                                             
 
    nyx_type_t type;                                                                            
 
    __NULLABLE__ struct nyx_node_s *node;                                                       
 
    __NULLABLE__ struct nyx_object_s *parent;                                                   
 
    __NULLABLE__ void (* in_callback)(
        struct nyx_object_s *object,                                                            
        bool modified                                                                           
    );                                                                                          
    __NULLABLE__ void (* out_callback)(
        struct nyx_object_s *object,                                                            
        bool modified                                                                           
    );                                                                                          
 
} nyx_object_t;
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_object_t *nyx_object_parse_buff(
    __ZEROABLE__ size_t size,
    __NULLABLE__ BUFF_t buff
);
 
__NULLABLE__ nyx_object_t *nyx_object_parse(
    __NULLABLE__ STR_t text
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_object_free(
    __NULLABLE__ nyx_object_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
bool nyx_object_equal(
    __NULLABLE__ const nyx_object_t *object1,
    __NULLABLE__ const nyx_object_t *object2
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
str_t nyx_object_to_string(
    __NULLABLE__ const nyx_object_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
str_t nyx_object_to_cstring(
    __NULLABLE__ const nyx_object_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
/* NULL                                                                                                               */
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef struct
{
    nyx_object_t base;                                                                          
 
} nyx_null_t;
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_null_t *nyx_null_new();
 
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 nyx_number_free(
    /*-*/ nyx_number_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
double nyx_number_get(
    const nyx_number_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
bool nyx_number_set_alt(
    /*-*/ nyx_number_t *object,
    double value,
    bool notify
);
 
__INLINE__ bool nyx_number_set(nyx_number_t *object, double value)
{
    return nyx_number_set_alt(object, value, true);
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
str_t nyx_number_to_string(
    const nyx_number_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__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 nyx_boolean_free(
    /*-*/ nyx_boolean_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
bool nyx_boolean_get(
    const nyx_boolean_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
bool nyx_boolean_set_alt(
    /*-*/ nyx_boolean_t *object,
    bool value,
    bool notify
);
 
__INLINE__ bool nyx_boolean_set(nyx_boolean_t *object, bool value)
{
    return nyx_boolean_set_alt(object, value, true);
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
str_t nyx_boolean_to_string(
    const nyx_boolean_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__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;                                                                          
 
    size_t length;                                                                              
    str_t value;                                                                                
 
    bool dyn;                                                                                   
 
} nyx_string_t;
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_string_t *nyx_string_new();
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
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,
    __NULLABLE__ size_t *result_size,
    __NULLABLE__ buff_t *result_buff,
    bool base64_decode
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
bool nyx_string_set_dup_alt(
    /*-*/ nyx_string_t *object,
    STR_t value,
    bool notify
);
 
__INLINE__ bool nyx_string_set_dup(nyx_string_t *object, STR_t value)
{
    return nyx_string_set_dup_alt(object, value, true);
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
bool nyx_string_set_ref_alt(
    /*-*/ nyx_string_t *object,
    STR_t value,
    bool notify
);
 
__INLINE__ bool nyx_string_set_ref(nyx_string_t *object, STR_t value)
{
    return nyx_string_set_ref_alt(object, value, true);
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
bool nyx_string_set_buff_alt(
    /*-*/ nyx_string_t *object,
    __ZEROABLE__ size_t size,
    __NULLABLE__ BUFF_t buff,
    bool base64_encode,
    bool notify
);
 
__INLINE__ bool nyx_string_set_buff(nyx_string_t *object, size_t size, BUFF_t buff, bool base64_encode)
{
    return nyx_string_set_buff_alt(object, size, buff, base64_encode, true);
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
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
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__INLINE__ nyx_string_t *nyx_string_from_dup(STR_t value)
{
    nyx_string_t *result = nyx_string_new();
 
    nyx_string_set_dup(result, value);
 
    return result;
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__INLINE__ nyx_string_t *nyx_string_from_ref(STR_t value)
{
    nyx_string_t *result = nyx_string_new();
 
    nyx_string_set_ref(result, value);
 
    return result;
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__INLINE__ nyx_string_t *nyx_string_from_buff(size_t size, BUFF_t buff, bool base64_encode)
{
    nyx_string_t *result = nyx_string_new();
 
    nyx_string_set_buff(result, size, buff, base64_encode);
 
    return result;
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
#define nyx_string_set nyx_string_set_dup
 
#define nyx_string_from nyx_string_from_dup
 
/*--------------------------------------------------------------------------------------------------------------------*/
/* DICT                                                                                                               */
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef struct
{
    nyx_object_t base;                                                                          
 
    struct nyx_dict_node_s *head;                                                               
    struct nyx_dict_node_s *tail;                                                               
 
} nyx_dict_t;
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef struct
{
    int idx;                                                                                    
 
    nyx_type_t type;                                                                            
 
    struct nyx_dict_node_s *head;                                                               
 
} nyx_dict_iter_t;
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
#define NYX_DICT_ITER(object) \
                ((nyx_dict_iter_t) {.idx = 0, .type = ((nyx_dict_t *) (object))->base.type, .head = ((nyx_dict_t *) (object))->head})
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_dict_new();
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
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_alt(
    /*-*/ nyx_dict_t *object,
    STR_t key,
    buff_t value,
    bool notify
);
 
__INLINE__ bool nyx_dict_set(nyx_dict_t *object, STR_t key, buff_t value)
{
    return nyx_dict_set_alt(object, key, value, true);
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
size_t nyx_dict_size(
    const nyx_dict_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
str_t nyx_dict_to_string(
    const nyx_dict_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__INLINE__ double nyx_dict_get_number(const nyx_dict_t *object, STR_t key)
{
    nyx_object_t *number = nyx_dict_get(object, key);
 
    return (number != NULL && number->type == NYX_TYPE_NUMBER) ? nyx_number_get((nyx_number_t *) number)
                                                               : nan("1")
    ;
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__INLINE__ STR_t nyx_dict_get_string(const nyx_dict_t *object, STR_t key)
{
    nyx_object_t *string = nyx_dict_get(object, key);
 
    return (string != NULL && string->type == NYX_TYPE_STRING) ? nyx_string_get((nyx_string_t *) string)
                                                               : NULL
    ;
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
/* LIST                                                                                                               */
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef struct
{
    nyx_object_t base;                                                                          
 
    struct nyx_list_node_s *head;                                                               
    struct nyx_list_node_s *tail;                                                               
 
} nyx_list_t;
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef struct
{
    int idx;                                                                                    
 
    nyx_type_t type;                                                                            
 
    struct nyx_list_node_s *head;                                                               
 
} nyx_list_iter_t;
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
#define NYX_LIST_ITER(object) \
                ((nyx_list_iter_t) {.idx = 0, .type = ((nyx_list_t *) (object))->base.type, .head = ((nyx_list_t *) (object))->head})
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_list_t *nyx_list_new();
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_list_free(
    /*-*/ nyx_list_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_list_clear(
    /*-*/ nyx_list_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_list_del(
    /*-*/ nyx_list_t *object,
    int idx
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
bool nyx_list_iterate(
    nyx_list_iter_t *iter,
    int *idx,
    nyx_object_t **object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_object_t *nyx_list_get(
    const nyx_list_t *object,
    int idx
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_list_t *nyx_list_set_alt(
    /*-*/ nyx_list_t *object,
    size_t idx,
    buff_t value,
    bool notify
);
 
__INLINE__ bool nyx_list_push(nyx_list_t *object, buff_t value)
{
    return nyx_list_set_alt(object, -1, value, true);
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
size_t nyx_list_size(
    const nyx_list_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
str_t nyx_list_to_string(
    const nyx_list_t *object
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__INLINE__ double nyx_list_get_number(const nyx_list_t *object, int 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")
    ;
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__INLINE__ STR_t nyx_list_get_string(const nyx_list_t *object, int 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                                                                                                             */
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef enum
{
    NYX_XML_ELEM,                                                                               
    NYX_XML_ATTR,                                                                               
    NYX_XML_COMMENT,                                                                            
    NYX_XML_CDATA,                                                                              
    NYX_XML_TEXT,                                                                               
 
} 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_xmldoc_t *nyx_xmldoc_parse_buff(
    __ZEROABLE__ size_t size,
    __NULLABLE__ BUFF_t buff
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_xmldoc_t *nyx_xmldoc_parse(
    __NULLABLE__ STR_t text
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_xmldoc_free(
    __NULLABLE__ nyx_xmldoc_t *xmldoc
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
str_t nyx_xmldoc_to_string(
    const nyx_xmldoc_t *xmldoc
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
/* VALIDATION                                                                                                         */
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
bool nyx_validation_initialize();
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
bool nyx_validation_finalize();
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
bool nyx_validation_check(
    __NULLABLE__ const nyx_xmldoc_t *xmldoc
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
/* TRANSFORM                                                                                                          */
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NULLABLE__ nyx_object_t *nyx_xmldoc_to_object(
    __NULLABLE__ const nyx_xmldoc_t *xmldoc,
    bool validate
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__NULLABLE__ nyx_xmldoc_t *nyx_object_to_xmldoc(
    __NULLABLE__ const nyx_object_t *object,
    bool validate
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
/* NYX                                                                                                               */
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
#define NYX_INDI_VERSION "1.7"
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef enum
{
    NYX_STATE_IDLE = 200,
    NYX_STATE_OK = 201,
    NYX_STATE_BUSY = 202,
    NYX_STATE_ALERT = 203,
 
} 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 = 300,
    NYX_PERM_WO = 301,
    NYX_PERM_RW = 302,
 
} 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 = 400,
    NYX_RULE_AT_MOST_ONE = 401,
    NYX_RULE_ANY_OF_MANY = 402,
 
} 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 = 500,
    NYX_ONOFF_OFF = 501,
 
} nyx_onoff_t;
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
STR_t nyx_onoff_to_str(
    nyx_onoff_t onoff
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_onoff_t nyx_str_to_onoff(
    STR_t onoff
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef enum
{
    NYX_BLOB_NEVER = 600,
    NYX_BLOB_ALSO = 601,
    NYX_BLOB_ONLY = 602,
 
} nyx_blob_t;
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
STR_t nyx_blob_to_str(
    nyx_blob_t blob
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_blob_t nyx_str_to_blob(
    STR_t blob
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef enum
{
    NYX_STREAM_NEVER = 700,
    NYX_STREAM_ALSO = 701,
    NYX_STREAM_ONLY = 702,
 
} nyx_stream_t;
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
STR_t nyx_stream_to_str(
    nyx_stream_t stream
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_stream_t nyx_str_to_stream(
    STR_t stream
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef struct
{
    __NULLABLE__ STR_t label;
    __NULLABLE__ STR_t group;
    __NULLABLE__ double timeout;
    __NULLABLE__ STR_t message;
 
} nyx_opts_t;
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_string_t *nyx_format_int_to_string(
    nyx_string_t *format,
    int value
);
 
int nyx_format_string_to_int(
    nyx_string_t *format,
    nyx_string_t *value
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_string_t *nyx_format_long_to_string(
    nyx_string_t *format,
    long value
);
 
long nyx_format_string_to_long(
    nyx_string_t *format,
    nyx_string_t *value
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_string_t *nyx_format_double_to_string(
    nyx_string_t *format,
    double value
);
 
double nyx_format_string_to_double(
    nyx_string_t *format,
    nyx_string_t *value
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_number_def_new(
    STR_t name,
    __NULLABLE__ STR_t label,
    STR_t format,
    double min,
    double max,
    double step,
    double value
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__INLINE__ bool nyx_number_def_set_int(nyx_dict_t *def, int value)
{
    nyx_string_t *format = (nyx_string_t *) nyx_dict_get(def, "@format");
 
    nyx_string_t *string = nyx_format_int_to_string(format, value);
 
    return nyx_dict_set(def, "$", string);
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__INLINE__ int nyx_number_def_get_int(const nyx_dict_t *def)
{
    nyx_string_t *format = (nyx_string_t *) nyx_dict_get(def, "@format");
 
    nyx_string_t *string = (nyx_string_t *) nyx_dict_get(def, "$");
 
    return nyx_format_string_to_int(format, string);
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__INLINE__ bool nyx_number_def_set_long(nyx_dict_t *def, long value)
{
    nyx_string_t *format = (nyx_string_t *) nyx_dict_get(def, "@format");
 
    nyx_string_t *string = nyx_format_long_to_string(format, value);
 
    return nyx_dict_set(def, "$", string);
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__INLINE__ long nyx_number_def_get_long(const nyx_dict_t *def)
{
    nyx_string_t *format = (nyx_string_t *) nyx_dict_get(def, "@format");
 
    nyx_string_t *string = (nyx_string_t *) nyx_dict_get(def, "$");
 
    return nyx_format_string_to_long(format, string);
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__INLINE__ bool nyx_number_def_set_double(nyx_dict_t *def, double value)
{
    nyx_string_t *format = (nyx_string_t *) nyx_dict_get(def, "@format");
 
    nyx_string_t *string = nyx_format_double_to_string(format, value);
 
    return nyx_dict_set(def, "$", string);
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__INLINE__ double nyx_number_def_get_double(const nyx_dict_t *def)
{
    nyx_string_t *format = (nyx_string_t *) nyx_dict_get(def, "@format");
 
    nyx_string_t *string = (nyx_string_t *) nyx_dict_get(def, "$");
 
    return nyx_format_string_to_double(format, string);
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_number_def_vector_new(
    STR_t device,
    STR_t name,
    nyx_state_t state,
    nyx_perm_t perm,
    nyx_dict_t *defs[],
    __NULLABLE__ const nyx_opts_t *opts
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_number_set_vector_new(
    const nyx_dict_t *def_vector
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_text_def_new(
    STR_t name,
    __NULLABLE__ STR_t label,
    STR_t value
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__INLINE__ bool nyx_text_def_set(nyx_dict_t *def, STR_t value)
{
    return  nyx_dict_set(def, "$", nyx_string_from(value));
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__INLINE__ STR_t nyx_text_def_get(const nyx_dict_t *def)
{
    return nyx_string_get((nyx_string_t *) nyx_dict_get(def, "$"));
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_text_def_vector_new(
    STR_t device,
    STR_t name,
    nyx_state_t state,
    nyx_perm_t perm,
    nyx_dict_t *defs[],
    __NULLABLE__ const nyx_opts_t *opts
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_text_set_vector_new(
    const nyx_dict_t *def_vector
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_light_def_new(
    STR_t name,
    __NULLABLE__ STR_t label,
    nyx_state_t value
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__INLINE__ bool nyx_light_def_set(nyx_dict_t *def, nyx_state_t value)
{
    return nyx_dict_set(def, "$", nyx_string_from(nyx_state_to_str(value)));
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__INLINE__ nyx_state_t nyx_light_def_get(const nyx_dict_t *def)
{
    return nyx_str_to_state(((nyx_string_t *) nyx_dict_get(def, "$"))->value);
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_light_def_vector_new(
    STR_t device,
    STR_t name,
    nyx_state_t state,
    nyx_dict_t *defs[],
    __NULLABLE__ const nyx_opts_t *opts
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_light_set_vector_new(
    const nyx_dict_t *def_vector
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_switch_def_new(
    STR_t name,
    __NULLABLE__ STR_t label,
    nyx_onoff_t value
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__INLINE__ bool nyx_switch_def_set(nyx_dict_t *def, nyx_onoff_t value)
{
    return nyx_dict_set(def, "$", nyx_string_from(nyx_onoff_to_str(value)));
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__INLINE__ nyx_onoff_t nyx_switch_def_get(const nyx_dict_t *def)
{
    return nyx_str_to_onoff(((nyx_string_t *) nyx_dict_get(def, "$"))->value);
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_switch_def_vector_new(
    STR_t device,
    STR_t name,
    nyx_state_t state,
    nyx_perm_t perm,
    nyx_rule_t rule,
    nyx_dict_t *defs[],
    __NULLABLE__ const  nyx_opts_t *opts
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_switch_set_vector_new(
    const nyx_dict_t *def_vector
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_blob_def_new(
    STR_t name,
    __NULLABLE__ STR_t label,
    STR_t value,
    STR_t format
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__INLINE__ bool nyx_blob_def_set(nyx_dict_t *def, size_t size, BUFF_t buff, bool base64_encode)
{
    return nyx_dict_set(def, "$", nyx_string_from_buff(size, buff, base64_encode));
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
__INLINE__ void nyx_blob_def_get(const nyx_dict_t *def, size_t *size, buff_t *buff, bool base64_decode)
{
    nyx_string_get_buff((nyx_string_t *) nyx_dict_get(def, "$"), size, buff, base64_decode);
}
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_blob_def_vector_new(
    STR_t device,
    STR_t name,
    nyx_state_t state,
    nyx_perm_t perm,
    nyx_dict_t *defs[],
    __NULLABLE__ const nyx_opts_t *opts
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_blob_set_vector_new(
    const nyx_dict_t *def_vector
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_stream_def_new(
    STR_t name,
    __NULLABLE__ STR_t label
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_stream_def_vector_new(
    STR_t device,
    STR_t name,
    nyx_state_t state,
    nyx_dict_t *defs[],
    __NULLABLE__ const nyx_opts_t *opts
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_stream_set_vector_new(
    const nyx_dict_t *def_vector
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_message_new(
    STR_t device,
    STR_t message
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_dict_t *nyx_del_property_new(
    STR_t device,
    __NULLABLE__ STR_t name,
    __NULLABLE__ STR_t message
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
/* NODE                                                                                                               */
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef struct nyx_node_s nyx_node_t;
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef enum
{
    NYX_EVENT_OPEN = 0,                                                                         
    NYX_EVENT_MSG = 1,                                                                          
 
} nyx_event_t;
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
typedef void (* nyx_mqtt_handler_t)(
    nyx_node_t *node,
    nyx_event_t event,
    size_t topic_size,
    BUFF_t topic_buff,
    size_t message_size,
    BUFF_t message_buff
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
nyx_node_t *nyx_node_initialize(
    STR_t node_id,
    nyx_dict_t *def_vectors[],
    
    __NULLABLE__ STR_t indi_url,
    
    __NULLABLE__ STR_t mqtt_url,
    __NULLABLE__ STR_t mqtt_username,
    __NULLABLE__ STR_t mqtt_password,
    
    __NULLABLE__ nyx_mqtt_handler_t mqtt_handler,
    
    __NULLABLE__ STR_t redis_url,
    __NULLABLE__ STR_t redis_username,
    __NULLABLE__ STR_t redis_password,
    
    int retry_ms,
    bool enable_xml,
    bool validate_xml
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_node_finalize(
    nyx_node_t *node,
    bool free_vectors
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_node_poll(
    nyx_node_t *node,
    int timeout_ms
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_node_enable(
    nyx_node_t *node,
    /*--------*/ STR_t device,
    __NULLABLE__ STR_t name,
    __NULLABLE__ STR_t message
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_node_disable(
    nyx_node_t *node,
    /*--------*/ STR_t device,
    __NULLABLE__ STR_t name,
    __NULLABLE__ STR_t message
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_node_send_message(
    nyx_node_t *node,
    STR_t device,
    STR_t message
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_mqtt_sub(
    nyx_node_t *node,
    STR_t topic
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
void nyx_mqtt_pub(
    nyx_node_t *node,
    STR_t topic,
    __ZEROABLE__ size_t message_size,
    __NULLABLE__ BUFF_t message_buff
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
bool nyx_stream_pub(
    nyx_node_t *node,
    STR_t device,
    STR_t stream,
    bool check,
    size_t max_len,
    __ZEROABLE__ size_t n_fields,
    const str_t field_names[],
    const size_t field_sizes[],
    const buff_t field_buffs[]
);
 
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
 
#ifndef ARDUINO
#  pragma clang diagnostic pop
#endif
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
#ifdef __cplusplus
}
#endif
 
/*--------------------------------------------------------------------------------------------------------------------*/
 
#endif /* NYX_NODE_H */
 
/*--------------------------------------------------------------------------------------------------------------------*/