lite3_context_api.h

Go to the documentation of this file.

/*
    Lite³: A JSON-Compatible Zero-Copy Serialization Format
 
    Copyright © 2025 Elias de Jong <elias@fastserial.com>
 
    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 LITE3_CONTEXT_API_H
#define LITE3_CONTEXT_API_H
 
#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>
#include <assert.h>
#include <string.h>
#include <errno.h>
 
#include "lite3.h"
 
 
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define LITE3_CONTEXT_BUF_SIZE_MIN 1024
static_assert(LITE3_CONTEXT_BUF_SIZE_MIN > (size_t)LITE3_NODE_ALIGNMENT_MASK, "LITE3_CONTEXT_BUF_SIZE_MIN must be greater than LITE3_NODE_ALIGNMENT_MASK");
 
typedef struct lite3_ctx {
        uint8_t __attribute__((aligned(LITE3_NODE_ALIGNMENT))) *buf;
        size_t buflen;
        size_t bufsz;
        void *underlying_buf;
} lite3_ctx;
 
 
 
lite3_ctx *lite3_ctx_create_with_size(size_t bufsz);
 
lite3_ctx *lite3_ctx_create_from_buf(
        const unsigned char *buf,       
        size_t buflen                   
);
 
lite3_ctx *lite3_ctx_create_take_ownership(
        unsigned char *buf,     
        size_t buflen,          
        size_t bufsz            
);
 
static inline lite3_ctx *lite3_ctx_create(void) {
        return lite3_ctx_create_with_size(LITE3_CONTEXT_BUF_SIZE_MIN);
}
 
int lite3_ctx_import_from_buf(
        lite3_ctx *ctx,                 
        const unsigned char *buf,       
        size_t buflen                   
);
 
void lite3_ctx_destroy(lite3_ctx *ctx);
 
#ifndef DOXYGEN_IGNORE
// Private function
int lite3_ctx_grow_impl(lite3_ctx *ctx);
#endif // DOXYGEN_IGNORE
 
 
 
static inline int lite3_ctx_init_obj(lite3_ctx *ctx)
{
        return lite3_init_obj(ctx->buf, &ctx->buflen, ctx->bufsz);
}
 
static inline int lite3_ctx_init_arr(lite3_ctx *ctx)
{
        return lite3_init_arr(ctx->buf, &ctx->buflen, ctx->bufsz);
}
 
 
 
#define lite3_ctx_set_null(ctx, ofs, key) ({ \
        const char *__lite3_key__ = (key); \
        lite3_ctx_set_null_impl(ctx, ofs, __lite3_key__, LITE3_KEY_DATA(key)); \
})
#ifndef DOXYGEN_IGNORE
static inline int lite3_ctx_set_null_impl(lite3_ctx *ctx, size_t ofs, const char *__restrict key, lite3_key_data key_data)
{
        int ret;
        if ((ret = _lite3_verify_obj_set(ctx->buf, &ctx->buflen, ofs, ctx->bufsz)) < 0)
                return ret;
        lite3_val *val;
        errno = 0;
        while ((ret = lite3_set_impl(ctx->buf, &ctx->buflen, ofs, ctx->bufsz, key, key_data, lite3_type_sizes[LITE3_TYPE_NULL], &val)) < 0) {
                if (errno == ENOBUFS && (lite3_ctx_grow_impl(ctx) == 0)) {
                        continue;
                } else {
                        return ret;
                }
        }
        val->type = (uint8_t)LITE3_TYPE_NULL;
        return ret;
}
#endif // DOXYGEN_IGNORE
 
#define lite3_ctx_set_bool(ctx, ofs, key, value) ({ \
        const char *__lite3_key__ = (key); \
        _lite3_ctx_set_bool_impl(ctx, ofs, __lite3_key__, LITE3_KEY_DATA(key), value); \
})
#ifndef DOXYGEN_IGNORE
static inline int _lite3_ctx_set_bool_impl(lite3_ctx *ctx, size_t ofs, const char *__restrict key, lite3_key_data key_data, bool value)
{
        int ret;
        if ((ret = _lite3_verify_obj_set(ctx->buf, &ctx->buflen, ofs, ctx->bufsz)) < 0)
                return ret;
        lite3_val *val;
        errno = 0;
        while ((ret = lite3_set_impl(ctx->buf, &ctx->buflen, ofs, ctx->bufsz, key, key_data, lite3_type_sizes[LITE3_TYPE_BOOL], &val)) < 0) {
                if (errno == ENOBUFS && (lite3_ctx_grow_impl(ctx) == 0)) {
                        continue;
                } else {
                        return ret;
                }
        }
        val->type = (uint8_t)LITE3_TYPE_BOOL;
        memcpy(val->val, &value, lite3_type_sizes[LITE3_TYPE_BOOL]);
        return ret;
}
#endif // DOXYGEN_IGNORE
 
#define lite3_ctx_set_i64(ctx, ofs, key, value) ({ \
        const char *__lite3_key__ = (key); \
        _lite3_ctx_set_i64_impl(ctx, ofs, __lite3_key__, LITE3_KEY_DATA(key), value); \
})
#ifndef DOXYGEN_IGNORE
static inline int _lite3_ctx_set_i64_impl(lite3_ctx *ctx, size_t ofs, const char *__restrict key, lite3_key_data key_data, int64_t value)
{
        int ret;
        if ((ret = _lite3_verify_obj_set(ctx->buf, &ctx->buflen, ofs, ctx->bufsz)) < 0)
                return ret;
        lite3_val *val;
        errno = 0;
        while ((ret = lite3_set_impl(ctx->buf, &ctx->buflen, ofs, ctx->bufsz, key, key_data, lite3_type_sizes[LITE3_TYPE_I64], &val)) < 0) {
                if (errno == ENOBUFS && (lite3_ctx_grow_impl(ctx) == 0)) {
                        continue;
                } else {
                        return ret;
                }
        }
        val->type = (uint8_t)LITE3_TYPE_I64;
        memcpy(val->val, &value, lite3_type_sizes[LITE3_TYPE_I64]);
        return ret;
}
#endif // DOXYGEN_IGNORE
 
#define lite3_ctx_set_f64(ctx, ofs, key, value) ({ \
        const char *__lite3_key__ = (key); \
        _lite3_ctx_set_f64_impl(ctx, ofs, __lite3_key__, LITE3_KEY_DATA(key), value); \
})
#ifndef DOXYGEN_IGNORE
static inline int _lite3_ctx_set_f64_impl(lite3_ctx *ctx, size_t ofs, const char *__restrict key, lite3_key_data key_data, double value)
{
        int ret;
        if ((ret = _lite3_verify_obj_set(ctx->buf, &ctx->buflen, ofs, ctx->bufsz)) < 0)
                return ret;
        lite3_val *val;
        errno = 0;
        while ((ret = lite3_set_impl(ctx->buf, &ctx->buflen, ofs, ctx->bufsz, key, key_data, lite3_type_sizes[LITE3_TYPE_F64], &val)) < 0) {
                if (errno == ENOBUFS && (lite3_ctx_grow_impl(ctx) == 0)) {
                        continue;
                } else {
                        return ret;
                }
        }
        val->type = (uint8_t)LITE3_TYPE_F64;
        memcpy(val->val, &value, lite3_type_sizes[LITE3_TYPE_F64]);
        return ret;
}
#endif // DOXYGEN_IGNORE
 
#define lite3_ctx_set_bytes(ctx, ofs, key, bytes, bytes_len) ({ \
        const char *__lite3_key__ = (key); \
        _lite3_ctx_set_bytes_impl(ctx, ofs, __lite3_key__, LITE3_KEY_DATA(key), bytes, bytes_len); \
})
#ifndef DOXYGEN_IGNORE
static inline int _lite3_ctx_set_bytes_impl(lite3_ctx *ctx, size_t ofs, const char *__restrict key, lite3_key_data key_data, const unsigned char *__restrict bytes, size_t bytes_len)
{
        int ret;
        if ((ret = _lite3_verify_obj_set(ctx->buf, &ctx->buflen, ofs, ctx->bufsz)) < 0)
                return ret;
        lite3_val *val;
        errno = 0;
        while ((ret = lite3_set_impl(ctx->buf, &ctx->buflen, ofs, ctx->bufsz, key, key_data, lite3_type_sizes[LITE3_TYPE_BYTES] + bytes_len, &val)) < 0) {
                if (errno == ENOBUFS && (lite3_ctx_grow_impl(ctx) == 0)) {
                        continue;
                } else {
                        return ret;
                }
        }
        val->type = (uint8_t)LITE3_TYPE_BYTES;
        memcpy(val->val, &bytes_len, lite3_type_sizes[LITE3_TYPE_BYTES]);
        memcpy(val->val + lite3_type_sizes[LITE3_TYPE_BYTES], bytes, bytes_len);
        return ret;
}
#endif // DOXYGEN_IGNORE
 
#define lite3_ctx_set_str(ctx, ofs, key, str) ({ \
        const char *__lite3_key__ = (key); \
        _lite3_ctx_set_str_impl(ctx, ofs, __lite3_key__, LITE3_KEY_DATA(key), str); \
})
#ifndef DOXYGEN_IGNORE
static inline int _lite3_ctx_set_str_impl(lite3_ctx *ctx, size_t ofs, const char *__restrict key, lite3_key_data key_data, const char *__restrict str)
{
        int ret;
        if ((ret = _lite3_verify_obj_set(ctx->buf, &ctx->buflen, ofs, ctx->bufsz)) < 0)
                return ret;
        lite3_val *val;
        size_t str_size = strlen(str) + 1;
        errno = 0;
        while ((ret = lite3_set_impl(ctx->buf, &ctx->buflen, ofs, ctx->bufsz, key, key_data, lite3_type_sizes[LITE3_TYPE_STRING] + str_size, &val)) < 0) {
                if (errno == ENOBUFS && (lite3_ctx_grow_impl(ctx) == 0)) {
                        continue;
                } else {
                        return ret;
                }
        }
        val->type = (uint8_t)LITE3_TYPE_STRING;
        memcpy(val->val, &str_size, lite3_type_sizes[LITE3_TYPE_STRING]);
        memcpy(val->val + lite3_type_sizes[LITE3_TYPE_STRING], str, str_size);
        return ret;
}
#endif // DOXYGEN_IGNORE
 
#define lite3_ctx_set_str_n(ctx, ofs, key, str, str_len) ({ \
        const char *__lite3_key__ = (key); \
        _lite3_ctx_set_str_n_impl(ctx, ofs, __lite3_key__, LITE3_KEY_DATA(key), str, str_len); \
})
#ifndef DOXYGEN_IGNORE
static inline int _lite3_ctx_set_str_n_impl(lite3_ctx *ctx, size_t ofs, const char *__restrict key, lite3_key_data key_data, const char *__restrict str, size_t str_len)
{
        int ret;
        if ((ret = _lite3_verify_obj_set(ctx->buf, &ctx->buflen, ofs, ctx->bufsz)) < 0)
                return ret;
        lite3_val *val;
        size_t str_size = str_len + 1;
        errno = 0;
        while ((ret = lite3_set_impl(ctx->buf, &ctx->buflen, ofs, ctx->bufsz, key, key_data, lite3_type_sizes[LITE3_TYPE_STRING] + str_size, &val)) < 0) {
                if (errno == ENOBUFS && (lite3_ctx_grow_impl(ctx) == 0)) {
                        continue;
                } else {
                        return ret;
                }
        }
        val->type = (uint8_t)LITE3_TYPE_STRING;
        memcpy(val->val, &str_size, lite3_type_sizes[LITE3_TYPE_STRING]);
        memcpy(val->val + lite3_type_sizes[LITE3_TYPE_STRING], str, str_len);
        *(val->val + lite3_type_sizes[LITE3_TYPE_STRING] + str_len) = 0x00; // Insert NULL-terminator
        return ret;
}
#endif // DOXYGEN_IGNORE
 
#define lite3_ctx_set_obj(ctx, ofs, key, out_ofs) ({ \
        lite3_ctx *__lite3_ctx__ = (ctx); \
        size_t __lite3_ofs__ = (ofs); \
        int __lite3_ret__; \
        if ((__lite3_ret__ = _lite3_verify_obj_set( \
                __lite3_ctx__->buf, \
                &__lite3_ctx__->buflen, \
                __lite3_ofs__, \
                __lite3_ctx__->bufsz)) < 0) \
                return __lite3_ret__; \
        \
        const char *__lite3_key__ = (key); \
        errno = 0; \
        while ((__lite3_ret__ = lite3_set_obj_impl( \
                __lite3_ctx__->buf, \
                &__lite3_ctx__->buflen, \
                __lite3_ofs__, \
                __lite3_ctx__->bufsz, \
                __lite3_key__, \
                LITE3_KEY_DATA(key), \
                out_ofs)) < 0) { \
                if (errno == ENOBUFS && (lite3_ctx_grow_impl(__lite3_ctx__) == 0)) { \
                        continue; \
                } else { \
                        return __lite3_ret__; \
                } \
        } \
        __lite3_ret__; \
})
 
#define lite3_ctx_set_arr(ctx, ofs, key, out_ofs) ({ \
        lite3_ctx *__lite3_ctx__ = (ctx); \
        size_t __lite3_ofs__ = (ofs); \
        int __lite3_ret__; \
        if ((__lite3_ret__ = _lite3_verify_obj_set( \
                __lite3_ctx__->buf, \
                &__lite3_ctx__->buflen, \
                __lite3_ofs__, \
                __lite3_ctx__->bufsz)) < 0) \
                return __lite3_ret__; \
        \
        const char *__lite3_key__ = (key); \
        errno = 0; \
        while ((__lite3_ret__ = lite3_set_arr_impl( \
                __lite3_ctx__->buf, \
                &__lite3_ctx__->buflen, \
                __lite3_ofs__, \
                __lite3_ctx__->bufsz, \
                __lite3_key__, \
                LITE3_KEY_DATA(key), \
                out_ofs)) < 0) { \
                if (errno == ENOBUFS && (lite3_ctx_grow_impl(__lite3_ctx__) == 0)) { \
                        continue; \
                } else { \
                        return __lite3_ret__; \
                } \
        } \
        __lite3_ret__; \
})
 
 
 
#ifndef DOXYGEN_IGNORE
static inline int _lite3_ctx_set_by_index(lite3_ctx *ctx, size_t ofs, uint32_t index, size_t val_len, lite3_val **out)
{
        int ret;
        if ((ret = _lite3_verify_arr_set(ctx->buf, &ctx->buflen, ofs, ctx->bufsz)) < 0)
                return ret;
        uint32_t size = (*(uint32_t *)(ctx->buf + ofs + LITE3_NODE_SIZE_KC_OFFSET)) >> LITE3_NODE_SIZE_SHIFT;
        if (LITE3_UNLIKELY(index > size)) {
                LITE3_PRINT_ERROR("INVALID ARGUMENT: ARRAY INDEX %u OUT OF BOUNDS (size == %u)\n", index, size);
                errno = EINVAL;
                return -1;
        }
        lite3_key_data key_data = {
                .hash = index,
                .size = 0,
        };
        errno = 0;
        while ((ret = lite3_set_impl(ctx->buf, &ctx->buflen, ofs, ctx->bufsz, NULL, key_data, val_len, out)) < 0) {
                if (errno == ENOBUFS && (lite3_ctx_grow_impl(ctx) == 0)) {
                        continue;
                } else {
                        return ret;
                }
        }
        return ret;
}
 
static inline int _lite3_ctx_set_by_append(lite3_ctx *ctx, size_t ofs, size_t val_len, lite3_val **out)
{
        int ret;
        if ((ret = _lite3_verify_arr_set(ctx->buf, &ctx->buflen, ofs, ctx->bufsz)) < 0)
                return ret;
        uint32_t size = (*(uint32_t *)(ctx->buf + ofs + LITE3_NODE_SIZE_KC_OFFSET)) >> LITE3_NODE_SIZE_SHIFT;
        lite3_key_data key_data = {
                .hash = size,
                .size = 0,
        };
        errno = 0;
        while ((ret = lite3_set_impl(ctx->buf, &ctx->buflen, ofs, ctx->bufsz, NULL, key_data, val_len, out)) < 0) {
                if (errno == ENOBUFS && (lite3_ctx_grow_impl(ctx) == 0)) {
                        continue;
                } else {
                        return ret;
                }
        }
        return ret;
}
#endif // DOXYGEN_IGNORE
 
static inline int lite3_ctx_arr_append_null(
        lite3_ctx *ctx,         
        size_t ofs)             
{
        lite3_val *val;
        int ret;
        if ((ret = _lite3_ctx_set_by_append(ctx, ofs, lite3_type_sizes[LITE3_TYPE_NULL], &val)) < 0)
                return ret;
        val->type = (uint8_t)LITE3_TYPE_NULL;
        return ret;
}
 
static inline int lite3_ctx_arr_append_bool(
        lite3_ctx *ctx,         
        size_t ofs,             
        bool value)             
{
        lite3_val *val;
        int ret;
        if ((ret = _lite3_ctx_set_by_append(ctx, ofs, lite3_type_sizes[LITE3_TYPE_BOOL], &val)) < 0)
                return ret;
        val->type = (uint8_t)LITE3_TYPE_BOOL;
        memcpy(val->val, &value, lite3_type_sizes[LITE3_TYPE_BOOL]);
        return ret;
}
 
static inline int lite3_ctx_arr_append_i64(
        lite3_ctx *ctx,         
        size_t ofs,             
        int64_t value)          
{
        lite3_val *val;
        int ret;
        if ((ret = _lite3_ctx_set_by_append(ctx, ofs, lite3_type_sizes[LITE3_TYPE_I64], &val)) < 0)
                return ret;
        val->type = (uint8_t)LITE3_TYPE_I64;
        memcpy(val->val, &value, lite3_type_sizes[LITE3_TYPE_I64]);
        return ret;
}
 
static inline int lite3_ctx_arr_append_f64(
        lite3_ctx *ctx,         
        size_t ofs,             
        double value)           
{
        lite3_val *val;
        int ret;
        if ((ret = _lite3_ctx_set_by_append(ctx, ofs, lite3_type_sizes[LITE3_TYPE_F64], &val)) < 0)
                return ret;
        val->type = (uint8_t)LITE3_TYPE_F64;
        memcpy(val->val, &value, lite3_type_sizes[LITE3_TYPE_F64]);
        return ret;
}
 
static inline int lite3_ctx_arr_append_bytes(
        lite3_ctx *ctx,                         
        size_t ofs,                             
        const unsigned char *__restrict bytes,  
        size_t bytes_len)                         
{
        lite3_val *val;
        int ret;
        if ((ret = _lite3_ctx_set_by_append(ctx, ofs, lite3_type_sizes[LITE3_TYPE_BYTES] + bytes_len, &val)) < 0)
                return ret;
        val->type = (uint8_t)LITE3_TYPE_BYTES;
        memcpy(val->val, &bytes_len, lite3_type_sizes[LITE3_TYPE_BYTES]);
        memcpy(val->val + lite3_type_sizes[LITE3_TYPE_BYTES], bytes, bytes_len);
        return ret;
}
 
static inline int lite3_ctx_arr_append_str(
        lite3_ctx *ctx,                 
        size_t ofs,                     
        const char *__restrict str)     
{
        lite3_val *val;
        size_t str_size = strlen(str) + 1;
        int ret;
        if ((ret = _lite3_ctx_set_by_append(ctx, ofs, lite3_type_sizes[LITE3_TYPE_STRING] + str_size, &val)) < 0)
                return ret;
        val->type = (uint8_t)LITE3_TYPE_STRING;
        memcpy(val->val, &str_size, lite3_type_sizes[LITE3_TYPE_STRING]);
        memcpy(val->val + lite3_type_sizes[LITE3_TYPE_STRING], str, str_size);
        return ret;
}
 
static inline int lite3_ctx_arr_append_str_n(
        lite3_ctx *ctx,                 
        size_t ofs,                     
        const char *__restrict str,     
        size_t str_len)                 
{
        lite3_val *val;
        size_t str_size = str_len + 1;
        int ret;
        if ((ret = _lite3_ctx_set_by_append(ctx, ofs, lite3_type_sizes[LITE3_TYPE_STRING] + str_size, &val)) < 0)
                return ret;
        val->type = (uint8_t)LITE3_TYPE_STRING;
        memcpy(val->val, &str_size, lite3_type_sizes[LITE3_TYPE_STRING]);
        memcpy(val->val + lite3_type_sizes[LITE3_TYPE_STRING], str, str_len);
        *(val->val + lite3_type_sizes[LITE3_TYPE_STRING] + str_len) = 0x00; // Insert NULL-terminator
        return ret;
}
 
static inline int lite3_ctx_arr_append_obj(
        lite3_ctx *ctx,                 
        size_t ofs,                     
        size_t *__restrict out_ofs)     
{
        int ret;
        if ((ret = _lite3_verify_arr_set(ctx->buf, &ctx->buflen, ofs, ctx->bufsz)) < 0)
                return ret;
        errno = 0;
        while ((ret = lite3_arr_append_obj_impl(ctx->buf, &ctx->buflen, ofs, ctx->bufsz, out_ofs)) < 0) {
                if (errno == ENOBUFS && (lite3_ctx_grow_impl(ctx) == 0)) {
                        continue;
                } else {
                        return ret;
                }
        }
        return ret;
}
 
static inline int lite3_ctx_arr_append_arr(
        lite3_ctx *ctx,                 
        size_t ofs,                     
        size_t *__restrict out_ofs)     
{
        int ret;
        if ((ret = _lite3_verify_arr_set(ctx->buf, &ctx->buflen, ofs, ctx->bufsz)) < 0)
                return ret;
        errno = 0;
        while ((ret = lite3_arr_append_arr_impl(ctx->buf, &ctx->buflen, ofs, ctx->bufsz, out_ofs)) < 0) {
                if (errno == ENOBUFS && (lite3_ctx_grow_impl(ctx) == 0)) {
                        continue;
                } else {
                        return ret;
                }
        }
        return ret;
}
 
 
static inline int lite3_ctx_arr_set_null(
        lite3_ctx *ctx,         
        size_t ofs,             
        uint32_t index)         
{
        lite3_val *val;
        int ret;
        if ((ret = _lite3_ctx_set_by_index(ctx, ofs, index, lite3_type_sizes[LITE3_TYPE_NULL], &val)) < 0)
                return ret;
        val->type = (uint8_t)LITE3_TYPE_NULL;
        return ret;
}
 
static inline int lite3_ctx_arr_set_bool(
        lite3_ctx *ctx,         
        size_t ofs,             
        uint32_t index,         
        bool value)             
{
        lite3_val *val;
        int ret;
        if ((ret = _lite3_ctx_set_by_index(ctx, ofs, index, lite3_type_sizes[LITE3_TYPE_BOOL], &val)) < 0)
                return ret;
        val->type = (uint8_t)LITE3_TYPE_BOOL;
        memcpy(val->val, &value, lite3_type_sizes[LITE3_TYPE_BOOL]);
        return ret;
}
 
static inline int lite3_ctx_arr_set_i64(
        lite3_ctx *ctx,         
        size_t ofs,             
        uint32_t index,         
        int64_t value)          
{
        lite3_val *val;
        int ret;
        if ((ret = _lite3_ctx_set_by_index(ctx, ofs, index, lite3_type_sizes[LITE3_TYPE_I64], &val)) < 0)
                return ret;
        val->type = (uint8_t)LITE3_TYPE_I64;
        memcpy(val->val, &value, lite3_type_sizes[LITE3_TYPE_I64]);
        return ret;
}
 
static inline int lite3_ctx_arr_set_f64(
        lite3_ctx *ctx,         
        size_t ofs,             
        uint32_t index,         
        double value)           
{
        lite3_val *val;
        int ret;
        if ((ret = _lite3_ctx_set_by_index(ctx, ofs, index, lite3_type_sizes[LITE3_TYPE_F64], &val)) < 0)
                return ret;
        val->type = (uint8_t)LITE3_TYPE_F64;
        memcpy(val->val, &value, lite3_type_sizes[LITE3_TYPE_F64]);
        return ret;
}
 
static inline int lite3_ctx_arr_set_bytes(
        lite3_ctx *ctx,                         
        size_t ofs,                             
        uint32_t index,                         
        const unsigned char *__restrict bytes,  
        size_t bytes_len)                         
{
        lite3_val *val;
        int ret;
        if ((ret = _lite3_ctx_set_by_index(ctx, ofs, index, lite3_type_sizes[LITE3_TYPE_BYTES] + bytes_len, &val)) < 0)
                return ret;
        val->type = (uint8_t)LITE3_TYPE_BYTES;
        memcpy(val->val, &bytes_len, lite3_type_sizes[LITE3_TYPE_BYTES]);
        memcpy(val->val + lite3_type_sizes[LITE3_TYPE_BYTES], bytes, bytes_len);
        return ret;
}
 
static inline int lite3_ctx_arr_set_str(
        lite3_ctx *ctx,                 
        size_t ofs,                     
        uint32_t index,                 
        const char *__restrict str)     
{
        lite3_val *val;
        size_t str_size = strlen(str) + 1;
        int ret;
        if ((ret = _lite3_ctx_set_by_index(ctx, ofs, index, lite3_type_sizes[LITE3_TYPE_STRING] + str_size, &val)) < 0)
                return ret;
        val->type = (uint8_t)LITE3_TYPE_STRING;
        memcpy(val->val, &str_size, lite3_type_sizes[LITE3_TYPE_STRING]);
        memcpy(val->val + lite3_type_sizes[LITE3_TYPE_STRING], str, str_size);
        return ret;
}
 
static inline int lite3_ctx_arr_set_str_n(
        lite3_ctx *ctx,                 
        size_t ofs,                     
        uint32_t index,                 
        const char *__restrict str,     
        size_t str_len)                 
{
        lite3_val *val;
        size_t str_size = str_len + 1;
        int ret;
        if ((ret = _lite3_ctx_set_by_index(ctx, ofs, index, lite3_type_sizes[LITE3_TYPE_STRING] + str_size, &val)) < 0)
                return ret;
        val->type = (uint8_t)LITE3_TYPE_STRING;
        memcpy(val->val, &str_size, lite3_type_sizes[LITE3_TYPE_STRING]);
        memcpy(val->val + lite3_type_sizes[LITE3_TYPE_STRING], str, str_len);
        *(val->val + lite3_type_sizes[LITE3_TYPE_STRING] + str_len) = 0x00; // Insert NULL-terminator
        return ret;
}
 
static inline int lite3_ctx_arr_set_obj(
        lite3_ctx *ctx,                 
        size_t ofs,                     
        uint32_t index,                 
        size_t *__restrict out_ofs)     
{
        int ret;
        if ((ret = _lite3_verify_arr_set(ctx->buf, &ctx->buflen, ofs, ctx->bufsz)) < 0)
                return ret;
        errno = 0;
        while ((ret = lite3_arr_set_obj_impl(ctx->buf, &ctx->buflen, ofs, ctx->bufsz, index, out_ofs)) < 0) {
                if (errno == ENOBUFS && (lite3_ctx_grow_impl(ctx) == 0)) {
                        continue;
                } else {
                        return ret;
                }
        }
        return ret;
}
 
static inline int lite3_ctx_arr_set_arr(
        lite3_ctx *ctx,                 
        size_t ofs,                     
        uint32_t index,                 
        size_t *__restrict out_ofs)     
{
        int ret;
        if ((ret = _lite3_verify_arr_set(ctx->buf, &ctx->buflen, ofs, ctx->bufsz)) < 0)
                return ret;
        errno = 0;
        while ((ret = lite3_arr_set_arr_impl(ctx->buf, &ctx->buflen, ofs, ctx->bufsz, index, out_ofs)) < 0) {
                if (errno == ENOBUFS && (lite3_ctx_grow_impl(ctx) == 0)) {
                        continue;
                } else {
                        return ret;
                }
        }
        return ret;
}
 
 
#ifdef LITE3_DEBUG
static inline void lite3_ctx_print(lite3_ctx *ctx) { lite3_print(ctx->buf, ctx->buflen); }
#else
static inline void lite3_ctx_print(lite3_ctx *ctx) { (void)ctx; }
#endif
 
#define lite3_ctx_get_type(ctx, ofs, key) ({ \
        const char *__lite3_key__ = (key); \
        _lite3_ctx_get_type_impl(ctx, ofs, __lite3_key__, LITE3_KEY_DATA(key)); \
})
#ifndef DOXYGEN_IGNORE
static inline enum lite3_type _lite3_ctx_get_type_impl(lite3_ctx *ctx, size_t ofs, const char *__restrict key, lite3_key_data key_data)
{
        if (_lite3_verify_obj_get(ctx->buf, ctx->buflen, ofs) < 0)
                return LITE3_TYPE_INVALID;
        lite3_val *val;
        if (lite3_get_impl(ctx->buf, ctx->buflen, ofs, key, key_data, &val) < 0)
                return LITE3_TYPE_INVALID;
        enum lite3_type type = (enum lite3_type)val->type;
        return type;
}
#endif // DOXYGEN_IGNORE
 
#define lite3_ctx_get_type_size(ctx, ofs, key, out) ({ \
        const char *__lite3_key__ = (key); \
        _lite3_ctx_get_type_size_impl(ctx, ofs, __lite3_key__, LITE3_KEY_DATA(key), out); \
})
#ifndef DOXYGEN_IGNORE
static inline int _lite3_ctx_get_type_size_impl(lite3_ctx *ctx, size_t ofs, const char *__restrict key, lite3_key_data key_data, size_t *__restrict out)
{
        int ret;
        if ((ret = _lite3_verify_obj_get(ctx->buf, ctx->buflen, ofs)) < 0)
                return ret;
        lite3_val *val;
        if ((ret = lite3_get_impl(ctx->buf, ctx->buflen, ofs, key, key_data, &val)) < 0)
                return ret;
        if (val->type == LITE3_TYPE_STRING || val->type == LITE3_TYPE_BYTES) {
                *out = 0;
                memcpy(out, &val->val, lite3_type_sizes[LITE3_TYPE_BYTES]);
                return ret;
        }
        *out = lite3_type_sizes[val->type];
        return ret;
}
#endif // DOXYGEN_IGNORE
 
#define lite3_ctx_exists(ctx, ofs, key) ({ \
        const char *__lite3_key__ = (key); \
        _lite3_ctx_exists_impl(ctx, ofs, __lite3_key__, LITE3_KEY_DATA(key)); \
})
#ifndef DOXYGEN_IGNORE
static inline bool _lite3_ctx_exists_impl(lite3_ctx *ctx, size_t ofs, const char *__restrict key, lite3_key_data key_data)
{
        if (_lite3_verify_obj_get(ctx->buf, ctx->buflen, ofs) < 0)
                return false;
        lite3_val *val;
        if (lite3_get_impl(ctx->buf, ctx->buflen, ofs, key, key_data, &val) < 0)
                return false;
        return true;
}
#endif // DOXYGEN_IGNORE
 
static inline int lite3_ctx_count(
        lite3_ctx *ctx,         
        size_t ofs,             
        uint32_t *out)          
{
        int ret;
        if ((ret = _lite3_verify_get(ctx->buf, ctx->buflen, ofs)) < 0)
                return ret;
        enum lite3_type type = (enum lite3_type)(*(ctx->buf + ofs));
        if (LITE3_UNLIKELY(!(type == LITE3_TYPE_OBJECT || type == LITE3_TYPE_ARRAY))) {
                LITE3_PRINT_ERROR("INVALID ARGUMENT: EXPECTING ARRAY OR OBJECT TYPE\n");
                errno = EINVAL;
                return -1;
        }
        *out = (*(uint32_t *)(ctx->buf + ofs + LITE3_NODE_SIZE_KC_OFFSET)) >> LITE3_NODE_SIZE_SHIFT;
        return ret;
}
 
#define lite3_ctx_is_null(ctx, ofs, key) ({ \
        const char *__lite3_key__ = (key); \
        _lite3_ctx_is_null_impl(ctx, ofs, __lite3_key__, LITE3_KEY_DATA(key)); \
})
#ifndef DOXYGEN_IGNORE
static inline bool _lite3_ctx_is_null_impl(lite3_ctx *ctx, size_t ofs, const char *__restrict key, lite3_key_data key_data)
{
        if (_lite3_verify_obj_get(ctx->buf, ctx->buflen, ofs) < 0)
                return false;
        lite3_val *val;
        if (lite3_get_impl(ctx->buf, ctx->buflen, ofs, key, key_data, &val) < 0)
                return false;
        return val->type == LITE3_TYPE_NULL;
}
#endif // DOXYGEN_IGNORE
 
#define lite3_ctx_is_bool(ctx, ofs, key) ({ \
        const char *__lite3_key__ = (key); \
        _lite3_ctx_is_bool_impl(ctx, ofs, __lite3_key__, LITE3_KEY_DATA(key)); \
})
#ifndef DOXYGEN_IGNORE
static inline bool _lite3_ctx_is_bool_impl(lite3_ctx *ctx, size_t ofs, const char *__restrict key, lite3_key_data key_data)
{
        if (_lite3_verify_obj_get(ctx->buf, ctx->buflen, ofs) < 0)
                return false;
        lite3_val *val;
        if (lite3_get_impl(ctx->buf, ctx->buflen, ofs, key, key_data, &val) < 0)
                return false;
        return val->type == LITE3_TYPE_BOOL;
}
#endif // DOXYGEN_IGNORE
 
#define lite3_ctx_is_i64(ctx, ofs, key) ({ \
        const char *__lite3_key__ = (key); \
        _lite3_ctx_is_i64_impl(ctx, ofs, __lite3_key__, LITE3_KEY_DATA(key)); \
})
#ifndef DOXYGEN_IGNORE
static inline bool _lite3_ctx_is_i64_impl(lite3_ctx *ctx, size_t ofs, const char *__restrict key, lite3_key_data key_data)
{
        if (_lite3_verify_obj_get(ctx->buf, ctx->buflen, ofs) < 0)
                return false;
        lite3_val *val;
        if (lite3_get_impl(ctx->buf, ctx->buflen, ofs, key, key_data, &val) < 0)
                return false;
        return val->type == LITE3_TYPE_I64;
}
#endif // DOXYGEN_IGNORE
 
#define lite3_ctx_is_f64(ctx, ofs, key) ({ \
        const char *__lite3_key__ = (key); \
        _lite3_ctx_is_f64_impl(ctx, ofs, __lite3_key__, LITE3_KEY_DATA(key)); \
})
#ifndef DOXYGEN_IGNORE
static inline bool _lite3_ctx_is_f64_impl(lite3_ctx *ctx, size_t ofs, const char *__restrict key, lite3_key_data key_data)
{
        if (_lite3_verify_obj_get(ctx->buf, ctx->buflen, ofs) < 0)
                return false;
        lite3_val *val;
        if (lite3_get_impl(ctx->buf, ctx->buflen, ofs, key, key_data, &val) < 0)
                return false;
        return val->type == LITE3_TYPE_F64;
}
#endif // DOXYGEN_IGNORE
 
#define lite3_ctx_is_bytes(ctx, ofs, key) ({ \
        const char *__lite3_key__ = (key); \
        _lite3_ctx_is_bytes_impl(ctx, ofs, __lite3_key__, LITE3_KEY_DATA(key)); \
})
#ifndef DOXYGEN_IGNORE
static inline bool _lite3_ctx_is_bytes_impl(lite3_ctx *ctx, size_t ofs, const char *__restrict key, lite3_key_data key_data)
{
        if (_lite3_verify_obj_get(ctx->buf, ctx->buflen, ofs) < 0)
                return false;
        lite3_val *val;
        if (lite3_get_impl(ctx->buf, ctx->buflen, ofs, key, key_data, &val) < 0)
                return false;
        return val->type == LITE3_TYPE_BYTES;
}
#endif // DOXYGEN_IGNORE
 
#define lite3_ctx_is_str(ctx, ofs, key) ({ \
        const char *__lite3_key__ = (key); \
        _lite3_ctx_is_str_impl(ctx, ofs, __lite3_key__, LITE3_KEY_DATA(key)); \
})
#ifndef DOXYGEN_IGNORE
static inline bool _lite3_ctx_is_str_impl(lite3_ctx *ctx, size_t ofs, const char *__restrict key, lite3_key_data key_data)
{
        if (_lite3_verify_obj_get(ctx->buf, ctx->buflen, ofs) < 0)
                return false;
        lite3_val *val;
        if (lite3_get_impl(ctx->buf, ctx->buflen, ofs, key, key_data, &val) < 0)
                return false;
        return val->type == LITE3_TYPE_STRING;
}
#endif // DOXYGEN_IGNORE
 
#define lite3_ctx_is_obj(ctx, ofs, key) ({ \
        const char *__lite3_key__ = (key); \
        _lite3_ctx_is_obj_impl(ctx, ofs, __lite3_key__, LITE3_KEY_DATA(key)); \
})
#ifndef DOXYGEN_IGNORE
static inline bool _lite3_ctx_is_obj_impl(lite3_ctx *ctx, size_t ofs, const char *__restrict key, lite3_key_data key_data)
{
        if (_lite3_verify_obj_get(ctx->buf, ctx->buflen, ofs) < 0)
                return false;
        lite3_val *val;
        if (lite3_get_impl(ctx->buf, ctx->buflen, ofs, key, key_data, &val) < 0)
                return false;
        return val->type == LITE3_TYPE_OBJECT;
}
#endif // DOXYGEN_IGNORE
 
#define lite3_ctx_is_arr(ctx, ofs, key) ({ \
        const char *__lite3_key__ = (key); \
        _lite3_ctx_is_arr_impl(ctx, ofs, __lite3_key__, LITE3_KEY_DATA(key)); \
})
#ifndef DOXYGEN_IGNORE
static inline bool _lite3_ctx_is_arr_impl(lite3_ctx *ctx, size_t ofs, const char *__restrict key, lite3_key_data key_data)
{
        if (_lite3_verify_obj_get(ctx->buf, ctx->buflen, ofs) < 0)
                return false;
        lite3_val *val;
        if (lite3_get_impl(ctx->buf, ctx->buflen, ofs, key, key_data, &val) < 0)
                return false;
        return val->type == LITE3_TYPE_ARRAY;
}
#endif // DOXYGEN_IGNORE
 
 
 
#define lite3_ctx_get(ctx, ofs, key, out) ({ \
        lite3_ctx *__lite3_ctx__ = (ctx); \
        size_t __lite3_ofs__ = (ofs); \
        int __lite3_ret__; \
        if ((__lite3_ret__ = _lite3_verify_get(__lite3_ctx__->buf, __lite3_ctx__->buflen, __lite3_ofs__)) < 0) \
                return __lite3_ret__; \
        const char *__lite3_key__ = (key); \
        lite3_get_impl(__lite3_ctx__->buf, __lite3_ctx__->buflen, __lite3_ofs__, __lite3_key__, LITE3_KEY_DATA(key), out); \
})
 
#define lite3_ctx_get_bool(ctx, ofs, key, out) ({ \
        const char *__lite3_key__ = (key); \
        _lite3_ctx_get_bool_impl(ctx, ofs, __lite3_key__, LITE3_KEY_DATA(key), out); \
})
#ifndef DOXYGEN_IGNORE
static inline int _lite3_ctx_get_bool_impl(lite3_ctx *ctx, size_t ofs, const char *__restrict key, lite3_key_data key_data, bool *out)
{
        int ret;
        if ((ret = _lite3_verify_obj_get(ctx->buf, ctx->buflen, ofs)) < 0)
                return ret;
        lite3_val *val;
        if ((ret = lite3_get_impl(ctx->buf, ctx->buflen, ofs, key, key_data, &val)) < 0)
                return ret;
        if (LITE3_UNLIKELY(val->type != LITE3_TYPE_BOOL)) {
                LITE3_PRINT_ERROR("VALUE TYPE != LITE3_TYPE_BOOL\n");
                errno = EINVAL;
                return -1;
        }
        *out = (bool)(*(val->val));
        return ret;
}
#endif // DOXYGEN_IGNORE
 
#define lite3_ctx_get_i64(ctx, ofs, key, out) ({ \
        const char *__lite3_key__ = (key); \
        _lite3_ctx_get_i64_impl(ctx, ofs, __lite3_key__, LITE3_KEY_DATA(key), out); \
})
#ifndef DOXYGEN_IGNORE
static inline int _lite3_ctx_get_i64_impl(lite3_ctx *ctx, size_t ofs, const char *__restrict key, lite3_key_data key_data, int64_t *out)
{
        int ret;
        if ((ret = _lite3_verify_obj_get(ctx->buf, ctx->buflen, ofs)) < 0)
                return ret;
        lite3_val *val;
        if ((ret = lite3_get_impl(ctx->buf, ctx->buflen, ofs, key, key_data, &val)) < 0)
                return ret;
        if (LITE3_UNLIKELY(val->type != LITE3_TYPE_I64)) {
                LITE3_PRINT_ERROR("VALUE TYPE != LITE3_TYPE_I64\n");
                errno = EINVAL;
                return -1;
        }
        memcpy(out, val->val, lite3_type_sizes[LITE3_TYPE_I64]);
        return ret;
}
#endif // DOXYGEN_IGNORE
 
#define lite3_ctx_get_f64(ctx, ofs, key, out) ({ \
        const char *__lite3_key__ = (key); \
        _lite3_ctx_get_f64_impl(ctx, ofs, __lite3_key__, LITE3_KEY_DATA(key), out); \
})
#ifndef DOXYGEN_IGNORE
static inline int _lite3_ctx_get_f64_impl(lite3_ctx *ctx, size_t ofs, const char *__restrict key, lite3_key_data key_data, double *out)
{
        int ret;
        if ((ret = _lite3_verify_obj_get(ctx->buf, ctx->buflen, ofs)) < 0)
                return ret;
        lite3_val *val;
        if ((ret = lite3_get_impl(ctx->buf, ctx->buflen, ofs, key, key_data, &val)) < 0)
                return ret;
        if (LITE3_UNLIKELY(val->type != LITE3_TYPE_F64)) {
                LITE3_PRINT_ERROR("VALUE TYPE != LITE3_TYPE_F64\n");
                errno = EINVAL;
                return -1;
        }
        memcpy(out, val->val, lite3_type_sizes[LITE3_TYPE_F64]);
        return ret;
}
#endif // DOXYGEN_IGNORE
 
#define lite3_ctx_get_bytes(ctx, ofs, key, out) ({ \
        const char *__lite3_key__ = (key); \
        _lite3_ctx_get_bytes_impl(ctx, ofs, __lite3_key__, LITE3_KEY_DATA(key), out); \
})
#ifndef DOXYGEN_IGNORE
static inline int _lite3_ctx_get_bytes_impl(lite3_ctx *ctx, size_t ofs, const char *__restrict key, lite3_key_data key_data, lite3_bytes *out)
{
        int ret;
        if ((ret = _lite3_verify_obj_get(ctx->buf, ctx->buflen, ofs)) < 0)
                return ret;
        lite3_val *val;
        if ((ret = lite3_get_impl(ctx->buf, ctx->buflen, ofs, key, key_data, &val)) < 0)
                return ret;
        if (LITE3_UNLIKELY(val->type != LITE3_TYPE_BYTES)) {
                LITE3_PRINT_ERROR("VALUE TYPE != LITE3_TYPE_BYTES\n");
                errno = EINVAL;
                return -1;
        }
        *out = (lite3_bytes){
                .gen = *(uint32_t *)(ctx->buf),
                .len = 0,
                .ptr = val->val + lite3_type_sizes[LITE3_TYPE_BYTES]
        };
        memcpy(&out->len, val->val, lite3_type_sizes[LITE3_TYPE_BYTES]);
        return ret;
}
#endif // DOXYGEN_IGNORE
 
#define lite3_ctx_get_str(ctx, ofs, key, out) ({ \
        const char *__lite3_key__ = (key); \
        _lite3_ctx_get_str_impl(ctx, ofs, __lite3_key__, LITE3_KEY_DATA(key), out); \
})
#ifndef DOXYGEN_IGNORE
static inline int _lite3_ctx_get_str_impl(lite3_ctx *ctx, size_t ofs, const char *__restrict key, lite3_key_data key_data, lite3_str *out)
{
        int ret;
        if ((ret = _lite3_verify_obj_get(ctx->buf, ctx->buflen, ofs)) < 0)
                return ret;
        lite3_val *val;
        if ((ret = lite3_get_impl(ctx->buf, ctx->buflen, ofs, key, key_data, &val)) < 0)
                return ret;
        if (LITE3_UNLIKELY(val->type != LITE3_TYPE_STRING)) {
                LITE3_PRINT_ERROR("VALUE TYPE != LITE3_TYPE_STRING\n");
                errno = EINVAL;
                return -1;
        }
        *out = (lite3_str){
                .gen = *(uint32_t *)(ctx->buf),
                .len = 0,
                .ptr = (char *)(val->val + lite3_type_sizes[LITE3_TYPE_STRING])
        };
        memcpy(&out->len, val->val, lite3_type_sizes[LITE3_TYPE_STRING]);
        --out->len; // Lite³ stores string size including NULL-terminator. Correction required for public API.
        return ret;
}
#endif // DOXYGEN_IGNORE
 
#define lite3_ctx_get_obj(ctx, ofs, key, out) ({ \
        const char *__lite3_key__ = (key); \
        _lite3_ctx_get_obj_impl(ctx, ofs, __lite3_key__, LITE3_KEY_DATA(key), out); \
})
#ifndef DOXYGEN_IGNORE
static inline int _lite3_ctx_get_obj_impl(lite3_ctx *ctx, size_t ofs, const char *__restrict key, lite3_key_data key_data, size_t *__restrict out_ofs)
{
        int ret;
        if ((ret = _lite3_verify_obj_get(ctx->buf, ctx->buflen, ofs)) < 0)
                return ret;
        lite3_val *val;
        if ((ret = lite3_get_impl(ctx->buf, ctx->buflen, ofs, key, key_data, &val)) < 0)
                return ret;
        if (LITE3_UNLIKELY(val->type != LITE3_TYPE_OBJECT)) {
                LITE3_PRINT_ERROR("VALUE TYPE != LITE3_TYPE_OBJECT\n");
                errno = EINVAL;
                return -1;
        }
        *out_ofs = (size_t)((uint8_t *)val - ctx->buf);
        return ret;
}
#endif // DOXYGEN_IGNORE
 
#define lite3_ctx_get_arr(ctx, ofs, key, out) ({ \
        const char *__lite3_key__ = (key); \
        _lite3_ctx_get_arr_impl(ctx, ofs, __lite3_key__, LITE3_KEY_DATA(key), out); \
})
#ifndef DOXYGEN_IGNORE
static inline int _lite3_ctx_get_arr_impl(lite3_ctx *ctx, size_t ofs, const char *__restrict key, lite3_key_data key_data, size_t *__restrict out_ofs)
{
        int ret;
        if ((ret = _lite3_verify_obj_get(ctx->buf, ctx->buflen, ofs)) < 0)
                return ret;
        lite3_val *val;
        if ((ret = lite3_get_impl(ctx->buf, ctx->buflen, ofs, key, key_data, &val)) < 0)
                return ret;
        if (LITE3_UNLIKELY(val->type != LITE3_TYPE_ARRAY)) {
                LITE3_PRINT_ERROR("VALUE TYPE != LITE3_TYPE_ARRAY\n");
                errno = EINVAL;
                return -1;
        }
        *out_ofs = (size_t)((uint8_t *)val - ctx->buf);
        return ret;
}
#endif // DOXYGEN_IGNORE
 
 
 
static inline int lite3_ctx_arr_get_bool(
        lite3_ctx *ctx,         
        size_t ofs,             
        uint32_t index,         
        bool *out)              
{
        lite3_val *val;
        int ret;
        if ((ret = _lite3_get_by_index(ctx->buf, ctx->buflen, ofs, index, &val)) < 0)
                return ret;
        if (LITE3_UNLIKELY(val->type != LITE3_TYPE_BOOL)) {
                LITE3_PRINT_ERROR("VALUE TYPE != LITE3_TYPE_BOOL\n");
                errno = EINVAL;
                return -1;
        }
        *out = (bool)(*(val->val));
        return ret;
}
 
static inline int lite3_ctx_arr_get_i64(
        lite3_ctx *ctx,         
        size_t ofs,             
        uint32_t index,         
        int64_t *out)           
{
        lite3_val *val;
        int ret;
        if ((ret = _lite3_get_by_index(ctx->buf, ctx->buflen, ofs, index, &val)) < 0)
                return ret;
        if (LITE3_UNLIKELY(val->type != LITE3_TYPE_I64)) {
                LITE3_PRINT_ERROR("VALUE TYPE != LITE3_TYPE_I64\n");
                errno = EINVAL;
                return -1;
        }
        memcpy(out, val->val, lite3_type_sizes[LITE3_TYPE_I64]);
        return ret;
}
 
static inline int lite3_ctx_arr_get_f64(
        lite3_ctx *ctx,         
        size_t ofs,             
        uint32_t index,         
        double *out)            
{
        lite3_val *val;
        int ret;
        if ((ret = _lite3_get_by_index(ctx->buf, ctx->buflen, ofs, index, &val)) < 0)
                return ret;
        if (LITE3_UNLIKELY(val->type != LITE3_TYPE_F64)) {
                LITE3_PRINT_ERROR("VALUE TYPE != LITE3_TYPE_F64\n");
                errno = EINVAL;
                return -1;
        }
        memcpy(out, val->val, lite3_type_sizes[LITE3_TYPE_F64]);
        return ret;
}
 
static inline int lite3_ctx_arr_get_bytes(
        lite3_ctx *ctx,         
        size_t ofs,             
        uint32_t index,         
        lite3_bytes *out)       
{
        lite3_val *val;
        int ret;
        if ((ret = _lite3_get_by_index(ctx->buf, ctx->buflen, ofs, index, &val)) < 0)
                return ret;
        if (LITE3_UNLIKELY(val->type != LITE3_TYPE_BYTES)) {
                LITE3_PRINT_ERROR("VALUE TYPE != LITE3_TYPE_BYTES\n");
                errno = EINVAL;
                return -1;
        }
        *out = (lite3_bytes){
                .gen = *(uint32_t *)(ctx->buf),
                .len = 0,
                .ptr = val->val + lite3_type_sizes[LITE3_TYPE_BYTES]
        };
        memcpy(&out->len, val->val, lite3_type_sizes[LITE3_TYPE_BYTES]);
        return ret;
}
 
static inline int lite3_ctx_arr_get_str(
        lite3_ctx *ctx,         
        size_t ofs,             
        uint32_t index,         
        lite3_str *out)         
{
        lite3_val *val;
        int ret;
        if ((ret = _lite3_get_by_index(ctx->buf, ctx->buflen, ofs, index, &val)) < 0)
                return ret;
        if (LITE3_UNLIKELY(val->type != LITE3_TYPE_STRING)) {
                LITE3_PRINT_ERROR("VALUE TYPE != LITE3_TYPE_STRING\n");
                errno = EINVAL;
                return -1;
        }
        *out = (lite3_str){
                .gen = *(uint32_t *)(ctx->buf),
                .len = 0,
                .ptr = (char *)(val->val + lite3_type_sizes[LITE3_TYPE_STRING])
        };
        memcpy(&out->len, val->val, lite3_type_sizes[LITE3_TYPE_STRING]);
        --out->len; // Lite³ stores string size including NULL-terminator. Correction required for public API.
        return ret;
}
 
static inline int lite3_ctx_arr_get_obj(
        lite3_ctx *ctx,                 
        size_t ofs,                     
        uint32_t index,                 
        size_t *__restrict out_ofs)     
{
        lite3_val *val;
        int ret;
        if ((ret = _lite3_get_by_index(ctx->buf, ctx->buflen, ofs, index, &val)) < 0)
                return ret;
        if (LITE3_UNLIKELY(val->type != LITE3_TYPE_OBJECT)) {
                LITE3_PRINT_ERROR("VALUE TYPE != LITE3_TYPE_OBJECT\n");
                errno = EINVAL;
                return -1;
        }
        *out_ofs = (size_t)((uint8_t *)val - (ctx->buf));
        return ret;
}
 
static inline int lite3_ctx_arr_get_arr(
        lite3_ctx *ctx,                 
        size_t ofs,                     
        uint32_t index,                 
        size_t *__restrict out_ofs)     
{
        lite3_val *val;
        int ret;
        if ((ret = _lite3_get_by_index(ctx->buf, ctx->buflen, ofs, index, &val)) < 0)
                return ret;
        if (LITE3_UNLIKELY(val->type != LITE3_TYPE_ARRAY)) {
                LITE3_PRINT_ERROR("VALUE TYPE != LITE3_TYPE_ARRAY\n");
                errno = EINVAL;
                return -1;
        }
        *out_ofs = (size_t)((uint8_t *)val - (ctx->buf));
        return ret;
}
 
 
 
#ifdef DOXYGEN_ONLY
#define LITE3_ITER_ITEM 1
#define LITE3_ITER_DONE 0
#endif
 
static inline int lite3_ctx_iter_create(
        lite3_ctx *ctx,         
        size_t ofs,             
        lite3_iter *out)        
{
        int ret;
        if ((ret = _lite3_verify_get(ctx->buf, ctx->buflen, ofs)) < 0)
                return ret;
        return lite3_iter_create_impl(ctx->buf, ctx->buflen, ofs, out);
}
 
static inline int lite3_ctx_iter_next(
        lite3_ctx *ctx,         
        lite3_iter *iter,       
        lite3_str *out_key,     
        size_t *out_val_ofs)    
{
        return lite3_iter_next(ctx->buf, ctx->buflen, iter, out_key, out_val_ofs);
}
 
 
#if defined(DOXYGEN_ONLY) && !defined(LITE3_JSON)
#define LITE3_JSON
#endif // DOXYGEN_ONLY
 
#ifdef LITE3_JSON
static inline int lite3_ctx_json_dec(
        lite3_ctx *ctx,                 
        const char *__restrict json_str,
        size_t json_len)                
{
        int ret;
        errno = 0;
        while ((ret = lite3_json_dec(ctx->buf, &ctx->buflen, ctx->bufsz, json_str, json_len)) < 0) {
                if (errno == ENOBUFS && (lite3_ctx_grow_impl(ctx) == 0)) {
                        continue;
                } else {
                        return ret;
                }
        }
        return ret;
}
 
static inline int lite3_ctx_json_dec_file(
        lite3_ctx *ctx,                 
        const char *__restrict path)    
{
        int ret;
        errno = 0;
        while ((ret = lite3_json_dec_file(ctx->buf, &ctx->buflen, ctx->bufsz, path)) < 0) {
                if (errno == ENOBUFS && (lite3_ctx_grow_impl(ctx) == 0)) {
                        continue;
                } else {
                        return ret;
                }
        }
        return ret;
}
 
static inline int lite3_ctx_json_dec_fp(
        lite3_ctx *ctx,         
        FILE *fp)               
{
        int ret;
        errno = 0;
        while ((ret = lite3_json_dec_fp(ctx->buf, &ctx->buflen, ctx->bufsz, fp)) < 0) {
                if (errno == ENOBUFS && (lite3_ctx_grow_impl(ctx) == 0)) {
                        continue;
                } else {
                        return ret;
                }
        }
        return ret;
}
 
static inline int lite3_ctx_json_print(
        lite3_ctx *ctx,         
        size_t ofs)             
{
        return lite3_json_print(ctx->buf, ctx->buflen, ofs);
}
 
static inline char *lite3_ctx_json_enc(
        lite3_ctx *ctx,                 
        size_t ofs,                     
        size_t *__restrict out_len)     
{
        return lite3_json_enc(ctx->buf, ctx->buflen, ofs, out_len);
}
 
static inline char *lite3_ctx_json_enc_pretty(
        lite3_ctx *ctx,                 
        size_t ofs,                     
        size_t *__restrict out_len)     
{
        return lite3_json_enc_pretty(ctx->buf, ctx->buflen, ofs, out_len);
}
 
static inline int64_t lite3_ctx_json_enc_buf(
        lite3_ctx *ctx,                 
        size_t ofs,                     
        char *__restrict json_buf,      
        size_t json_bufsz               
)
{
        return lite3_json_enc_buf(ctx->buf, ctx->buflen, ofs, json_buf, json_bufsz);
}
 
static inline int64_t lite3_ctx_json_enc_pretty_buf(
        lite3_ctx *ctx,                 
        size_t ofs,                     
        char *__restrict json_buf,      
        size_t json_bufsz)              
{
        return lite3_json_enc_pretty_buf(ctx->buf, ctx->buflen, ofs, json_buf, json_bufsz);
}
#else
static inline int lite3_ctx_json_dec(lite3_ctx *ctx, const char *__restrict json_str, size_t json_len)
{
        (void)ctx; (void)json_str; (void)json_len;
        return -1;
}
 
static inline int lite3_ctx_json_dec_file(lite3_ctx *ctx, const char *__restrict path)
{
        (void)ctx; (void)path;
        return -1;
}
 
static inline int lite3_ctx_json_dec_fp(lite3_ctx *ctx, FILE *fp)
{
        (void)ctx; (void)fp;
        return -1;
}
 
static inline int lite3_ctx_json_print(lite3_ctx *ctx, size_t ofs)
{
        (void)ctx; (void)ofs;
        return 0;
}
 
static inline char *lite3_ctx_json_enc(lite3_ctx *ctx, size_t ofs, size_t *out_len)
{
        (void)ctx; (void)ofs; (void)out_len;
        return NULL;
}
 
static inline char *lite3_ctx_json_enc_pretty(lite3_ctx *ctx, size_t ofs, size_t *out_len)
{
        (void)ctx; (void)ofs; (void)out_len;
        return NULL;
}
 
static inline int64_t lite3_ctx_json_enc_buf(lite3_ctx *ctx, size_t ofs, char *__restrict json_buf, size_t json_bufsz)
{
        (void)ctx; (void)ofs; (void)json_buf; (void)json_bufsz;
        return -1;
}
 
static inline int64_t lite3_ctx_json_enc_pretty_buf(lite3_ctx *ctx, size_t ofs, char *__restrict json_buf, size_t json_bufsz)
{
        (void)ctx; (void)ofs; (void)json_buf; (void)json_bufsz;
        return -1;
}
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif // LITE3_CONTEXT_API_H