amxc_variant.h

Go to the documentation of this file.

/****************************************************************************
**
** SPDX-License-Identifier: BSD-2-Clause-Patent
**
** SPDX-FileCopyrightText: Copyright (c) 2023 SoftAtHome
**
** Redistribution and use in source and binary forms, with or without modification,
** are permitted provided that the following conditions are met:
**
** 1. Redistributions of source code must retain the above copyright notice,
** this list of conditions and the following disclaimer.
**
** 2. Redistributions in binary form must reproduce the above copyright notice,
** this list of conditions and the following disclaimer in the documentation
** and/or other materials provided with the distribution.
**
** Subject to the terms and conditions of this license, each copyright holder
** and contributor hereby grants to those receiving rights under this license
** a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable
** (except for failure to satisfy the conditions of this license) patent license
** to make, have made, use, offer to sell, sell, import, and otherwise transfer
** this software, where such license applies only to those patent claims, already
** acquired or hereafter acquired, licensable by such copyright holder or contributor
** that are necessarily infringed by:
**
** (a) their Contribution(s) (the licensed copyrights of copyright holders and
** non-copyrightable additions of contributors, in source or binary form) alone;
** or
**
** (b) combination of their Contribution(s) with the work of authorship to which
** such Contribution(s) was added by such copyright holder or contributor, if,
** at the time the Contribution is added, such addition causes such combination
** to be necessarily infringed. The patent license shall not apply to any other
** combinations which include the Contribution.
**
** Except as expressly stated above, no rights or licenses from any copyright
** holder or contributor is granted under this license, whether expressly, by
** implication, estoppel or otherwise.
**
** DISCLAIMER
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
** AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
** LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
** SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
** CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
** OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
** USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
**
****************************************************************************/
 
#if !defined(__AMXC_VARIANT_H__)
#define __AMXC_VARIANT_H__
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
 
#include <amxc/amxc_htable.h>
#include <amxc/amxc_llist.h>
#include <amxc/amxc_string.h>
#include <amxc/amxc_timestamp.h>
#include <amxc/amxc_common.h>
 
#define AMXC_VAR_ID_INVALID      UINT32_MAX
#define AMXC_VAR_ID_NULL         0
#define AMXC_VAR_ID_CSTRING      1
#define AMXC_VAR_ID_INT8         2
#define AMXC_VAR_ID_INT16        3
#define AMXC_VAR_ID_INT32        4
#define AMXC_VAR_ID_INT64        5
#define AMXC_VAR_ID_UINT8        6
#define AMXC_VAR_ID_UINT16       7
#define AMXC_VAR_ID_UINT32       8
#define AMXC_VAR_ID_UINT64       9
#define AMXC_VAR_ID_FLOAT        10
#define AMXC_VAR_ID_DOUBLE       11
#define AMXC_VAR_ID_BOOL         12
#define AMXC_VAR_ID_LIST         13
#define AMXC_VAR_ID_HTABLE       14
#define AMXC_VAR_ID_FD           15
#define AMXC_VAR_ID_TIMESTAMP    16
#define AMXC_VAR_ID_CSV_STRING   17
#define AMXC_VAR_ID_SSV_STRING   18
#define AMXC_VAR_ID_ANY          19
#define AMXC_VAR_ID_CUSTOM_BASE  20
#define AMXC_VAR_ID_MAX          UINT32_MAX
 
#define AMXC_VAR_NAME_NULL       "null"
#define AMXC_VAR_NAME_CSTRING    "cstring_t"
#define AMXC_VAR_NAME_INT8       "int8_t"
#define AMXC_VAR_NAME_INT16      "int16_t"
#define AMXC_VAR_NAME_INT32      "int32_t"
#define AMXC_VAR_NAME_INT64      "int64_t"
#define AMXC_VAR_NAME_UINT8      "uint8_t"
#define AMXC_VAR_NAME_UINT16     "uint16_t"
#define AMXC_VAR_NAME_UINT32     "uint32_t"
#define AMXC_VAR_NAME_UINT64     "uint64_t"
#define AMXC_VAR_NAME_FLOAT      "float"
#define AMXC_VAR_NAME_DOUBLE     "double"
#define AMXC_VAR_NAME_BOOL       "bool"          
#define AMXC_VAR_NAME_LIST       "amxc_llist_t"
#define AMXC_VAR_NAME_HTABLE     "amxc_htable_t"
#define AMXC_VAR_NAME_FD         "fd_t"
#define AMXC_VAR_NAME_TIMESTAMP  "amxc_ts_t"
#define AMXC_VAR_NAME_CSV_STRING "csv_string_t"  
#define AMXC_VAR_NAME_SSV_STRING "ssv_string_t"  
#define AMXC_VAR_FLAG_DEFAULT   0x00
#define AMXC_VAR_FLAG_COPY      0x01
#define AMXC_VAR_FLAG_UPDATE    0x02
#define AMXC_VAR_FLAG_NO_INDEX    0x04
#define AMXC_VAR_FLAG_AUTO_ADD    0x08
 
#define GET_ARG(a, n) amxc_var_get_key(a, n, AMXC_VAR_FLAG_DEFAULT)
#define GET_BOOL(a, n) amxc_var_dyncast(bool, n == NULL ? a : GET_ARG(a, n))
#define GET_CHAR(a, n) amxc_var_constcast(cstring_t, n == NULL ? a : GET_ARG(a, n))
#define GET_UINT32(a, n) amxc_var_dyncast(uint32_t, n == NULL ? a : GET_ARG(a, n))
#define GET_INT32(a, n) amxc_var_dyncast(int32_t, n == NULL ? a : GET_ARG(a, n))
 
#define GETI_ARG(a, i) amxc_var_get_index(a, i, AMXC_VAR_FLAG_DEFAULT)
#define GETI_BOOL(a, i) amxc_var_dyncast(bool, GETI_ARG(a, i))
#define GETI_CHAR(a, i) amxc_var_constcast(cstring_t, GETI_ARG(a, i))
#define GETI_UINT32(a, i) amxc_var_dyncast(uint32_t, GETI_ARG(a, i))
#define GETI_INT32(a, i) amxc_var_dyncast(int32_t, GETI_ARG(a, i))
 
#define GETP_ARG(a, p) amxc_var_get_path(a, p, AMXC_VAR_FLAG_DEFAULT)
#define GETP_BOOL(a, p) amxc_var_dyncast(bool, p == NULL ? a : GETP_ARG(a, p))
#define GETP_CHAR(a, p) amxc_var_constcast(cstring_t, p == NULL ? a : GETP_ARG(a, p))
#define GETP_UINT32(a, p) amxc_var_dyncast(uint32_t, p == NULL ? a : GETP_ARG(a, p))
#define GETP_INT32(a, p) amxc_var_dyncast(int32_t, p == NULL ? a : GETP_ARG(a, p))
 
#define cstring_t char*
#define csv_string_t char*
#define ssv_string_t char*
 
#define fd_t int
 
#define amxc_var_set(type, var, data) amxc_var_set_ ## type(var, data)
 
#define amxc_var_add(type, var, data) amxc_var_add_new_ ## type(var, data)
 
#define amxc_var_add_key(type, var, key, data) amxc_var_add_new_key_ ## type(var, key, data)
 
#define amxc_var_dyncast(type, var) amxc_var_get_ ## type(var)
 
#define amxc_var_constcast(type, var) amxc_var_get_const_ ## type(var)
 
#define amxc_var_take(type, var) amxc_var_take_ ## type(var)
 
#define amxc_var_push(type, var, val) amxc_var_push_ ## type(var, val)
 
#define amxc_var_from_htable_it(ht_it) \
    ((amxc_var_t*) (((char*) ht_it) - offsetof(amxc_var_t, hit)))
 
#define amxc_var_from_llist_it(ll_it) \
    ((amxc_var_t*) (((char*) ll_it) - offsetof(amxc_var_t, lit)))
 
#define amxc_var_for_each(var, var_list) \
    for(amxc_var_t* var = amxc_var_get_first(var_list), \
        * var ## _next = amxc_var_get_next(var); \
        var; \
        var = var ## _next, \
        var ## _next = amxc_var_get_next(var))
 
#define amxc_var_for_each_reverse(var, var_list) \
    for(amxc_var_t* var = amxc_var_get_last(var_list), \
        * var ## _prev = amxc_var_get_previous(var); \
        var; \
        var = var ## _prev, \
        var ## _prev = amxc_var_get_previous(var))
 
 
typedef struct _amxc_var {
    amxc_llist_it_t lit;        
    amxc_htable_it_t hit;       
    uint32_t type_id;           
    union
    {
        char* s;                
        int8_t i8;              
        int16_t i16;            
        int32_t i32;            
        int64_t i64;            
        uint8_t ui8;            
        uint16_t ui16;          
        uint32_t ui32;          
        uint64_t ui64;          
        float f;                
        double d;               
        bool b;                 
        amxc_llist_t vl;        
        amxc_htable_t vm;       
        int fd;                 
        amxc_ts_t ts;           
        void* data;             
    } data;                     
} amxc_var_t;
 
int amxc_var_new(amxc_var_t** var);
 
void amxc_var_delete(amxc_var_t** var);
 
int amxc_var_init(amxc_var_t* const var);
 
void amxc_var_clean(amxc_var_t* const var);
 
int amxc_var_set_type(amxc_var_t* const var, const uint32_t type);
 
int amxc_var_copy(amxc_var_t* const dest, const amxc_var_t* const src);
 
int amxc_var_move(amxc_var_t* const dest, amxc_var_t* const src);
 
int amxc_var_convert(amxc_var_t* const dest,
                     const amxc_var_t* src,
                     const uint32_t type_id);
 
int amxc_var_cast(amxc_var_t* const var,
                  const uint32_t type_id);
int amxc_var_compare(const amxc_var_t* const var1,
                     const amxc_var_t* const var2,
                     int* const result);
 
AMXC_INLINE
void amxc_var_take_it(amxc_var_t* const var) {
    if(var != NULL) {
        amxc_llist_it_take(&var->lit);
        amxc_htable_it_take(&var->hit);
    }
}
 
amxc_var_t* amxc_var_get_key(const amxc_var_t* const var,
                             const char* const key,
                             const int flags);
int amxc_var_set_key(amxc_var_t* const var,
                     const char* const key,
                     amxc_var_t* data,
                     const int flags);
 
AMXC_INLINE
amxc_var_t* amxc_var_take_key(amxc_var_t* const var,
                              const char* const key) {
    amxc_var_t* rv = amxc_var_get_key(var, key, AMXC_VAR_FLAG_DEFAULT);
    amxc_var_take_it(rv);
    return rv;
}
 
amxc_var_t* amxc_var_get_index(const amxc_var_t* const var,
                               const int64_t index,
                               const int flags);
int amxc_var_set_index(amxc_var_t* const var,
                       const int64_t index,
                       amxc_var_t* data,
                       const int flags);
 
AMXC_INLINE
amxc_var_t* amxc_var_take_index(amxc_var_t* const var,
                                const int64_t index) {
    amxc_var_t* rv = amxc_var_get_index(var, index, AMXC_VAR_FLAG_DEFAULT);
    amxc_var_take_it(rv);
    return rv;
}
 
amxc_var_t* amxc_var_add_new_key(amxc_var_t* const var,
                                 const char* key);
 
amxc_var_t* amxc_var_add_new(amxc_var_t* const var);
 
amxc_var_t* amxc_var_get_path(const amxc_var_t* const var,
                              const char* const path,
                              const int flags);
 
amxc_var_t* amxc_var_get_pathf(const amxc_var_t* const var,
                               const int flags,
                               const char* const fmt,
                               ...
                               ) __attribute__ ((format(printf, 3, 4)));
 
int amxc_var_set_path(amxc_var_t* const var,
                      const char* const path,
                      amxc_var_t* data,
                      const int flags);
 
int amxc_var_set_pathf(amxc_var_t* const var,
                       amxc_var_t* data,
                       const int flags,
                       const char* const fmt,
                       ...
                       ) __attribute__ ((format(printf, 4, 5)));
 
amxc_var_t* amxc_var_get_first(const amxc_var_t* const var);
 
amxc_var_t* amxc_var_get_last(const amxc_var_t* const var);
 
amxc_var_t* amxc_var_get_next(const amxc_var_t* const var);
 
amxc_var_t* amxc_var_get_previous(const amxc_var_t* const var);
 
amxc_var_t* amxc_var_get_parent(const amxc_var_t* const var);
 
const char* amxc_var_key(const amxc_var_t* const var);
 
uint32_t amxc_var_type_of(const amxc_var_t* const var);
 
const char* amxc_var_type_name_of(const amxc_var_t* const var);
 
AMXC_INLINE
bool amxc_var_is_null(const amxc_var_t* const var) {
    return var == NULL ? true : (var->type_id == AMXC_VAR_ID_NULL);
}
 
void variant_list_it_free(amxc_llist_it_t* it);
 
void variant_htable_it_free(const char* key, amxc_htable_it_t* it);
 
int amxc_var_dump(const amxc_var_t* const var, int fd);
 
int amxc_var_dump_stream(const amxc_var_t* const var, FILE* stream);
 
int amxc_var_log(const amxc_var_t* const var);
 
int amxc_var_set_bool(amxc_var_t* const var, bool boolean);
int amxc_var_set_int8_t(amxc_var_t* const var, int8_t val);
int amxc_var_set_uint8_t(amxc_var_t* const var, uint8_t val);
int amxc_var_set_int16_t(amxc_var_t* const var, int16_t val);
int amxc_var_set_uint16_t(amxc_var_t* const var, uint16_t val);
int amxc_var_set_int32_t(amxc_var_t* const var, int32_t val);
int amxc_var_set_uint32_t(amxc_var_t* const var, uint32_t val);
int amxc_var_set_int64_t(amxc_var_t* const var, int64_t val);
int amxc_var_set_uint64_t(amxc_var_t* const var, uint64_t val);
int amxc_var_set_cstring_t(amxc_var_t* const var, const char* const val);
int amxc_var_set_csv_string_t(amxc_var_t* const var, const char* const val);
int amxc_var_set_ssv_string_t(amxc_var_t* const var, const char* const val);
int amxc_var_set_double(amxc_var_t* var, double val);
int amxc_var_set_fd_t(amxc_var_t* var, int val);
int amxc_var_set_amxc_ts_t(amxc_var_t* var, amxc_ts_t* val);
 
bool amxc_var_get_bool(const amxc_var_t* const var);
int8_t amxc_var_get_int8_t(const amxc_var_t* const var);
uint8_t amxc_var_get_uint8_t(const amxc_var_t* const var);
int16_t amxc_var_get_int16_t(const amxc_var_t* const var);
uint16_t amxc_var_get_uint16_t(const amxc_var_t* var);
int32_t amxc_var_get_int32_t(const amxc_var_t* const var);
uint32_t amxc_var_get_uint32_t(const amxc_var_t* var);
int64_t amxc_var_get_int64_t(const amxc_var_t* const var);
uint64_t amxc_var_get_uint64_t(const amxc_var_t* const var);
char* amxc_var_get_cstring_t(const amxc_var_t* const var);
amxc_htable_t* amxc_var_get_amxc_htable_t(const amxc_var_t* const var);
amxc_llist_t* amxc_var_get_amxc_llist_t(const amxc_var_t* const var);
double amxc_var_get_double(const amxc_var_t* var);
int amxc_var_get_fd_t(const amxc_var_t* var);
amxc_ts_t* amxc_var_get_amxc_ts_t(const amxc_var_t* var);
 
AMXC_INLINE
char* amxc_var_get_csv_string_t(const amxc_var_t* const var) {
    return amxc_var_get_cstring_t(var);
}
 
AMXC_INLINE
char* amxc_var_get_ssv_string_t(const amxc_var_t* const var) {
    return amxc_var_get_cstring_t(var);
}
 
const char* amxc_var_get_const_cstring_t(const amxc_var_t* const var);
const amxc_htable_t* amxc_var_get_const_amxc_htable_t(const amxc_var_t* const var);
const amxc_llist_t* amxc_var_get_const_amxc_llist_t(const amxc_var_t* const var);
bool amxc_var_get_const_bool(const amxc_var_t* const var);
int8_t amxc_var_get_const_int8_t(const amxc_var_t* const var);
int16_t amxc_var_get_const_int16_t(const amxc_var_t* const var);
int32_t amxc_var_get_const_int32_t(const amxc_var_t* const var);
int64_t amxc_var_get_const_int64_t(const amxc_var_t* const var);
uint8_t amxc_var_get_const_uint8_t(const amxc_var_t* const var);
uint16_t amxc_var_get_const_uint16_t(const amxc_var_t* const var);
uint32_t amxc_var_get_const_uint32_t(const amxc_var_t* const var);
uint64_t amxc_var_get_const_uint64_t(const amxc_var_t* const var);
double amxc_var_get_const_double(const amxc_var_t* const var);
fd_t amxc_var_get_const_fd_t(const amxc_var_t* const var);
const amxc_ts_t* amxc_var_get_const_amxc_ts_t(const amxc_var_t* const var);
 
AMXC_INLINE
const char* amxc_var_get_const_csv_string_t(const amxc_var_t* const var) {
    return amxc_var_get_const_cstring_t(var);
}
 
AMXC_INLINE
const char* amxc_var_get_const_ssv_string_t(const amxc_var_t* const var) {
    return amxc_var_get_const_cstring_t(var);
}
 
amxc_var_t* amxc_var_add_new_bool(amxc_var_t* const var, bool boolean);
amxc_var_t* amxc_var_add_new_int8_t(amxc_var_t* const var, int8_t val);
amxc_var_t* amxc_var_add_new_uint8_t(amxc_var_t* const var, uint8_t val);
amxc_var_t* amxc_var_add_new_int16_t(amxc_var_t* const var, int16_t val);
amxc_var_t* amxc_var_add_new_uint16_t(amxc_var_t* const var, uint16_t val);
amxc_var_t* amxc_var_add_new_int32_t(amxc_var_t* const var, int32_t val);
amxc_var_t* amxc_var_add_new_uint32_t(amxc_var_t* const var, uint32_t val);
amxc_var_t* amxc_var_add_new_int64_t(amxc_var_t* const var, int64_t val);
amxc_var_t* amxc_var_add_new_uint64_t(amxc_var_t* const var, uint64_t val);
amxc_var_t* amxc_var_add_new_cstring_t(amxc_var_t* const var, const char* const val);
amxc_var_t* amxc_var_add_new_csv_string_t(amxc_var_t* const var, const char* const val);
amxc_var_t* amxc_var_add_new_ssv_string_t(amxc_var_t* const var, const char* const val);
amxc_var_t* amxc_var_add_new_double(amxc_var_t* const var, double val);
amxc_var_t* amxc_var_add_new_fd_t(amxc_var_t* const var, int val);
amxc_var_t* amxc_var_add_new_amxc_ts_t(amxc_var_t* const var, amxc_ts_t* ts);
 
amxc_var_t* amxc_var_add_new_amxc_llist_t(amxc_var_t* const var,
                                          const amxc_llist_t* list);
 
amxc_var_t* amxc_var_add_new_amxc_htable_t(amxc_var_t* const var,
                                           const amxc_htable_t* htable);
 
amxc_var_t* amxc_var_add_new_key_bool(amxc_var_t* const var, const char* key, bool boolean);
amxc_var_t* amxc_var_add_new_key_int8_t(amxc_var_t* const var, const char* key, int8_t val);
amxc_var_t* amxc_var_add_new_key_uint8_t(amxc_var_t* const var, const char* key, uint8_t val);
amxc_var_t* amxc_var_add_new_key_int16_t(amxc_var_t* const var, const char* key, int16_t val);
amxc_var_t* amxc_var_add_new_key_uint16_t(amxc_var_t* const var, const char* key, uint16_t val);
amxc_var_t* amxc_var_add_new_key_int32_t(amxc_var_t* const var, const char* key, int32_t val);
amxc_var_t* amxc_var_add_new_key_uint32_t(amxc_var_t* const var, const char* key, uint32_t val);
amxc_var_t* amxc_var_add_new_key_int64_t(amxc_var_t* const var, const char* key, int64_t val);
amxc_var_t* amxc_var_add_new_key_uint64_t(amxc_var_t* const var, const char* key, uint64_t val);
amxc_var_t* amxc_var_add_new_key_cstring_t(amxc_var_t* const var, const char* key, const char* const val);
amxc_var_t* amxc_var_add_new_key_csv_string_t(amxc_var_t* const var, const char* key, const char* const val);
amxc_var_t* amxc_var_add_new_key_ssv_string_t(amxc_var_t* const var, const char* key, const char* const val);
amxc_var_t* amxc_var_add_new_key_double(amxc_var_t* const var, const char* key, double val);
amxc_var_t* amxc_var_add_new_key_fd_t(amxc_var_t* const var, const char* key, int val);
amxc_var_t* amxc_var_add_new_key_amxc_ts_t(amxc_var_t* const var, const char* key, amxc_ts_t* ts);
 
amxc_var_t* amxc_var_add_new_key_amxc_llist_t(amxc_var_t* const var,
                                              const char* key,
                                              const amxc_llist_t* list);
 
amxc_var_t* amxc_var_add_new_key_amxc_htable_t(amxc_var_t* const var,
                                               const char* key,
                                               const amxc_htable_t* htable);
 
cstring_t amxc_var_take_cstring_t(amxc_var_t* const var);
amxc_string_t* amxc_var_take_amxc_string_t(amxc_var_t* const var);
 
AMXC_INLINE
cstring_t amxc_var_take_csv_string_t(amxc_var_t* const var) {
    return amxc_var_take_cstring_t(var);
}
 
AMXC_INLINE
cstring_t amxc_var_take_ssv_string_t(amxc_var_t* const var) {
    return amxc_var_take_cstring_t(var);
}
 
int amxc_var_push_cstring_t(amxc_var_t* const var, char* val);
int amxc_var_push_csv_string_t(amxc_var_t* const var, char* val);
int amxc_var_push_ssv_string_t(amxc_var_t* const var, char* val);
int amxc_var_push_amxc_string_t(amxc_var_t* const var, amxc_string_t* val);
 
#ifdef __cplusplus
}
#endif
 
#endif // __AMXC_VARIANT_H__