value.h

#ifndef BABELTRACE2_VALUE_H
#define BABELTRACE2_VALUE_H
 
/*
 * Copyright (c) 2010-2019 EfficiOS Inc. and Linux Foundation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
 
#ifndef __BT_IN_BABELTRACE_H
# error "Please include <babeltrace2/babeltrace.h> instead."
#endif
 
#include <stdint.h>
#include <stddef.h>
 
#include <babeltrace2/types.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef enum bt_value_type {
    BT_VALUE_TYPE_NULL      = 1 << 0,
 
    BT_VALUE_TYPE_BOOL      = 1 << 1,
 
    BT_VALUE_TYPE_INTEGER       = 1 << 2,
 
    BT_VALUE_TYPE_UNSIGNED_INTEGER  = (1 << 3) | BT_VALUE_TYPE_INTEGER,
 
    BT_VALUE_TYPE_SIGNED_INTEGER    = (1 << 4) | BT_VALUE_TYPE_INTEGER,
 
    BT_VALUE_TYPE_REAL      = 1 << 5,
 
    BT_VALUE_TYPE_STRING        = 1 << 6,
 
    BT_VALUE_TYPE_ARRAY     = 1 << 7,
 
    BT_VALUE_TYPE_MAP       = 1 << 8,
} bt_value_type;
 
extern bt_value_type bt_value_get_type(const bt_value *value);
 
static inline
bt_bool bt_value_type_is(const bt_value_type type,
        const bt_value_type other_type)
{
    return (type & other_type) == other_type;
}
 
static inline
bt_bool bt_value_is_null(const bt_value *value)
{
    return bt_value_get_type(value) == BT_VALUE_TYPE_NULL;
}
 
static inline
bt_bool bt_value_is_bool(const bt_value *value)
{
    return bt_value_get_type(value) == BT_VALUE_TYPE_BOOL;
}
 
static inline
bt_bool bt_value_is_unsigned_integer(const bt_value *value)
{
    return bt_value_get_type(value) == BT_VALUE_TYPE_UNSIGNED_INTEGER;
}
 
static inline
bt_bool bt_value_is_signed_integer(const bt_value *value)
{
    return bt_value_get_type(value) == BT_VALUE_TYPE_SIGNED_INTEGER;
}
 
static inline
bt_bool bt_value_is_real(const bt_value *value)
{
    return bt_value_get_type(value) == BT_VALUE_TYPE_REAL;
}
 
static inline
bt_bool bt_value_is_string(const bt_value *value)
{
    return bt_value_get_type(value) == BT_VALUE_TYPE_STRING;
}
 
static inline
bt_bool bt_value_is_array(const bt_value *value)
{
    return bt_value_get_type(value) == BT_VALUE_TYPE_ARRAY;
}
 
static inline
bt_bool bt_value_is_map(const bt_value *value)
{
    return bt_value_get_type(value) == BT_VALUE_TYPE_MAP;
}
 
extern bt_value *const bt_value_null;
 
extern bt_value *bt_value_bool_create(void);
 
extern bt_value *bt_value_bool_create_init(bt_bool raw_value);
 
extern void bt_value_bool_set(bt_value *value, bt_bool raw_value);
 
extern bt_bool bt_value_bool_get(const bt_value *value);
 
extern bt_value *bt_value_integer_unsigned_create(void);
 
extern bt_value *bt_value_integer_unsigned_create_init(uint64_t raw_value);
 
extern void bt_value_integer_unsigned_set(bt_value *value,
        uint64_t raw_value);
 
extern uint64_t bt_value_integer_unsigned_get(const bt_value *value);
 
extern bt_value *bt_value_integer_signed_create(void);
 
extern bt_value *bt_value_integer_signed_create_init(int64_t raw_value);
 
extern void bt_value_integer_signed_set(bt_value *value, int64_t raw_value);
 
extern int64_t bt_value_integer_signed_get(const bt_value *value);
 
extern bt_value *bt_value_real_create(void);
 
extern bt_value *bt_value_real_create_init(double raw_value);
 
extern void bt_value_real_set(bt_value *value, double raw_value);
 
extern double bt_value_real_get(const bt_value *value);
 
extern bt_value *bt_value_string_create(void);
 
extern bt_value *bt_value_string_create_init(const char *raw_value);
 
typedef enum bt_value_string_set_status {
    BT_VALUE_STRING_SET_STATUS_OK       = __BT_FUNC_STATUS_OK,
 
    BT_VALUE_STRING_SET_STATUS_MEMORY_ERROR = __BT_FUNC_STATUS_MEMORY_ERROR,
} bt_value_string_set_status;
 
extern bt_value_string_set_status bt_value_string_set(bt_value *value,
        const char *raw_value);
 
extern const char *bt_value_string_get(const bt_value *value);
 
extern bt_value *bt_value_array_create(void);
 
typedef enum bt_value_array_append_element_status {
    BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_OK         = __BT_FUNC_STATUS_OK,
 
    BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_MEMORY_ERROR   = __BT_FUNC_STATUS_MEMORY_ERROR,
} bt_value_array_append_element_status;
 
extern bt_value_array_append_element_status bt_value_array_append_element(
        bt_value *value, bt_value *element_value);
 
extern bt_value_array_append_element_status
bt_value_array_append_bool_element(bt_value *value, bt_bool raw_value);
 
extern bt_value_array_append_element_status
bt_value_array_append_unsigned_integer_element(bt_value *value,
        uint64_t raw_value);
 
extern bt_value_array_append_element_status
bt_value_array_append_signed_integer_element(bt_value *value,
        int64_t raw_value);
 
extern bt_value_array_append_element_status
bt_value_array_append_real_element(bt_value *value, double raw_value);
 
extern bt_value_array_append_element_status
bt_value_array_append_string_element(bt_value *value, const char *raw_value);
 
extern bt_value_array_append_element_status
bt_value_array_append_empty_array_element(bt_value *value,
        bt_value **element_value);
 
extern bt_value_array_append_element_status
bt_value_array_append_empty_map_element(bt_value *value,
        bt_value **element_value);
 
typedef enum bt_value_array_set_element_by_index_status {
    BT_VALUE_ARRAY_SET_ELEMENT_BY_INDEX_STATUS_OK       = __BT_FUNC_STATUS_OK,
 
    BT_VALUE_ARRAY_SET_ELEMENT_BY_INDEX_STATUS_MEMORY_ERROR = __BT_FUNC_STATUS_MEMORY_ERROR,
} bt_value_array_set_element_by_index_status;
 
extern bt_value_array_set_element_by_index_status
bt_value_array_set_element_by_index(bt_value *value, uint64_t index,
        bt_value *element_value);
 
extern bt_value *bt_value_array_borrow_element_by_index(bt_value *value,
        uint64_t index);
 
extern const bt_value *bt_value_array_borrow_element_by_index_const(
        const bt_value *value, uint64_t index);
 
extern uint64_t bt_value_array_get_length(const bt_value *value);
 
static inline
bt_bool bt_value_array_is_empty(const bt_value *value)
{
    return bt_value_array_get_length(value) == 0;
}
 
extern bt_value *bt_value_map_create(void);
 
typedef enum bt_value_map_insert_entry_status {
    BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK     = __BT_FUNC_STATUS_OK,
 
    BT_VALUE_MAP_INSERT_ENTRY_STATUS_MEMORY_ERROR   = __BT_FUNC_STATUS_MEMORY_ERROR,
} bt_value_map_insert_entry_status;
 
extern bt_value_map_insert_entry_status bt_value_map_insert_entry(
        bt_value *value, const char *key, bt_value *entry_value);
 
extern bt_value_map_insert_entry_status bt_value_map_insert_bool_entry(
        bt_value *value, const char *key, bt_bool raw_value);
 
extern bt_value_map_insert_entry_status
bt_value_map_insert_unsigned_integer_entry(bt_value *value, const char *key,
        uint64_t raw_value);
 
extern bt_value_map_insert_entry_status
bt_value_map_insert_signed_integer_entry(bt_value *value, const char *key,
        int64_t raw_value);
 
extern bt_value_map_insert_entry_status bt_value_map_insert_real_entry(
        bt_value *value, const char *key, double raw_value);
 
extern bt_value_map_insert_entry_status
bt_value_map_insert_string_entry(bt_value *value, const char *key,
        const char *raw_value);
 
extern bt_value_map_insert_entry_status
bt_value_map_insert_empty_array_entry(bt_value *value, const char *key,
        bt_value **entry_value);
 
extern bt_value_map_insert_entry_status
bt_value_map_insert_empty_map_entry(bt_value *value, const char *key,
        bt_value **entry_value);
 
extern bt_value *bt_value_map_borrow_entry_value(
        bt_value *value, const char *key);
 
extern const bt_value *bt_value_map_borrow_entry_value_const(
        const bt_value *value, const char *key);
 
typedef enum bt_value_map_foreach_entry_func_status {
    BT_VALUE_MAP_FOREACH_ENTRY_FUNC_STATUS_OK       = __BT_FUNC_STATUS_OK,
 
    BT_VALUE_MAP_FOREACH_ENTRY_FUNC_STATUS_INTERRUPT    = __BT_FUNC_STATUS_INTERRUPTED,
 
    BT_VALUE_MAP_FOREACH_ENTRY_FUNC_STATUS_MEMORY_ERROR = __BT_FUNC_STATUS_MEMORY_ERROR,
 
    BT_VALUE_MAP_FOREACH_ENTRY_FUNC_STATUS_ERROR        = __BT_FUNC_STATUS_ERROR,
} bt_value_map_foreach_entry_func_status;
 
typedef bt_value_map_foreach_entry_func_status
        (* bt_value_map_foreach_entry_func)(const char *key,
            bt_value *value, void *user_data);
 
typedef enum bt_value_map_foreach_entry_status {
    BT_VALUE_MAP_FOREACH_ENTRY_STATUS_OK        = __BT_FUNC_STATUS_OK,
 
    BT_VALUE_MAP_FOREACH_ENTRY_STATUS_INTERRUPTED   = __BT_FUNC_STATUS_INTERRUPTED,
 
    BT_VALUE_MAP_FOREACH_ENTRY_STATUS_USER_ERROR    = __BT_FUNC_STATUS_USER_ERROR,
 
    BT_VALUE_MAP_FOREACH_ENTRY_STATUS_MEMORY_ERROR  = __BT_FUNC_STATUS_MEMORY_ERROR,
 
    BT_VALUE_MAP_FOREACH_ENTRY_STATUS_ERROR     = __BT_FUNC_STATUS_ERROR,
} bt_value_map_foreach_entry_status;
 
extern bt_value_map_foreach_entry_status bt_value_map_foreach_entry(
        bt_value *value, bt_value_map_foreach_entry_func user_func,
        void *user_data);
 
typedef enum bt_value_map_foreach_entry_const_func_status {
    BT_VALUE_MAP_FOREACH_ENTRY_CONST_FUNC_STATUS_OK         = __BT_FUNC_STATUS_OK,
 
    BT_VALUE_MAP_FOREACH_ENTRY_CONST_FUNC_STATUS_INTERRUPT      = __BT_FUNC_STATUS_INTERRUPTED,
 
    BT_VALUE_MAP_FOREACH_ENTRY_CONST_FUNC_STATUS_MEMORY_ERROR   = __BT_FUNC_STATUS_MEMORY_ERROR,
 
    BT_VALUE_MAP_FOREACH_ENTRY_CONST_FUNC_STATUS_ERROR      = __BT_FUNC_STATUS_ERROR,
} bt_value_map_foreach_entry_const_func_status;
 
typedef bt_value_map_foreach_entry_const_func_status
        (* bt_value_map_foreach_entry_const_func)(const char *key,
            const bt_value *value, void *user_data);
 
typedef enum bt_value_map_foreach_entry_const_status {
    BT_VALUE_MAP_FOREACH_ENTRY_CONST_STATUS_OK      = __BT_FUNC_STATUS_OK,
 
    BT_VALUE_MAP_FOREACH_ENTRY_CONST_STATUS_INTERRUPTED = __BT_FUNC_STATUS_INTERRUPTED,
 
    BT_VALUE_MAP_FOREACH_ENTRY_CONST_STATUS_USER_ERROR  = __BT_FUNC_STATUS_USER_ERROR,
 
    BT_VALUE_MAP_FOREACH_ENTRY_CONST_STATUS_MEMORY_ERROR    = __BT_FUNC_STATUS_MEMORY_ERROR,
 
    BT_VALUE_MAP_FOREACH_ENTRY_CONST_STATUS_ERROR       = __BT_FUNC_STATUS_ERROR,
} bt_value_map_foreach_entry_const_status;
 
extern bt_value_map_foreach_entry_const_status bt_value_map_foreach_entry_const(
        const bt_value *value,
        bt_value_map_foreach_entry_const_func user_func,
        void *user_data);
 
extern uint64_t bt_value_map_get_size(const bt_value *value);
 
static inline
bt_bool bt_value_map_is_empty(const bt_value *value)
{
    return bt_value_map_get_size(value) == 0;
}
 
extern bt_bool bt_value_map_has_entry(const bt_value *value,
        const char *key);
 
typedef enum bt_value_map_extend_status {
    BT_VALUE_MAP_EXTEND_STATUS_OK       = __BT_FUNC_STATUS_OK,
 
    BT_VALUE_MAP_EXTEND_STATUS_MEMORY_ERROR = __BT_FUNC_STATUS_MEMORY_ERROR,
} bt_value_map_extend_status;
 
extern bt_value_map_extend_status bt_value_map_extend(
        bt_value *value, const bt_value *extension_value);
 
typedef enum bt_value_copy_status {
    BT_VALUE_COPY_STATUS_OK     = __BT_FUNC_STATUS_OK,
 
    BT_VALUE_COPY_STATUS_MEMORY_ERROR = __BT_FUNC_STATUS_MEMORY_ERROR,
} bt_value_copy_status;
 
extern bt_value_copy_status bt_value_copy(const bt_value *value,
        bt_value **copy_value);
 
extern bt_bool bt_value_is_equal(const bt_value *a_value,
        const bt_value *b_value);
 
extern void bt_value_get_ref(const bt_value *value);
 
extern void bt_value_put_ref(const bt_value *value);
 
#define BT_VALUE_PUT_REF_AND_RESET(_value)  \
    do {                    \
        bt_value_put_ref(_value);   \
        (_value) = NULL;        \
    } while (0)
 
#define BT_VALUE_MOVE_REF(_dst, _src)   \
    do {                \
        bt_value_put_ref(_dst); \
        (_dst) = (_src);    \
        (_src) = NULL;      \
    } while (0)
 
#ifdef __cplusplus
}
#endif
 
#endif /* BABELTRACE2_VALUE_H */