sol-memdesc.h

Go to the documentation of this file.

/*
 * This file is part of the Soletta (TM) Project
 *
 * Copyright (C) 2016 Intel Corporation. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#pragma once

#include <errno.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>
#include <limits.h>
#include <sol-common-buildopts.h>
#include <sol-str-slice.h>
#include <sol-str-table.h>
#include <sol-macros.h>
#include <sol-buffer.h>

#ifdef __cplusplus
extern "C" {
#endif

struct sol_memdesc;

enum sol_memdesc_type {
    SOL_MEMDESC_TYPE_UNKNOWN = 0, 
    SOL_MEMDESC_TYPE_UINT8,
    SOL_MEMDESC_TYPE_UINT16,
    SOL_MEMDESC_TYPE_UINT32,
    SOL_MEMDESC_TYPE_UINT64,
    SOL_MEMDESC_TYPE_ULONG,
    SOL_MEMDESC_TYPE_SIZE,
    SOL_MEMDESC_TYPE_INT8,
    SOL_MEMDESC_TYPE_INT16,
    SOL_MEMDESC_TYPE_INT32,
    SOL_MEMDESC_TYPE_INT64,
    SOL_MEMDESC_TYPE_LONG,
    SOL_MEMDESC_TYPE_SSIZE,
    SOL_MEMDESC_TYPE_BOOL,
    SOL_MEMDESC_TYPE_DOUBLE,
    SOL_MEMDESC_TYPE_STRING,
    SOL_MEMDESC_TYPE_CONST_STRING,
    SOL_MEMDESC_TYPE_ENUMERATION,
    SOL_MEMDESC_TYPE_PTR,
    SOL_MEMDESC_TYPE_STRUCTURE,
    SOL_MEMDESC_TYPE_ARRAY
};

enum sol_memdesc_type sol_memdesc_type_from_str(const char *str)
#ifndef DOXYGEN_RUN
    SOL_ATTR_WARN_UNUSED_RESULT
#endif
    ;

const char *sol_memdesc_type_to_str(enum sol_memdesc_type type)
#ifndef DOXYGEN_RUN
    SOL_ATTR_WARN_UNUSED_RESULT
#endif
    ;

#ifndef SOL_MEMDESC_DESCRIPTION
/* keep doxygen happy */
#define SOL_MEMDESC_DESCRIPTION
#undef SOL_MEMDESC_DESCRIPTION
#endif

#ifdef SOL_MEMDESC_DESCRIPTION
#define SOL_MEMDESC_SET_DESCRIPTION(...) __VA_ARGS__
#else
#define SOL_MEMDESC_SET_DESCRIPTION(...)
#endif

#ifndef SOL_NO_API_VERSION

extern const uint16_t SOL_MEMDESC_API_VERSION_COMPILED;
#endif

typedef struct sol_memdesc_ops_array {
#ifndef SOL_NO_API_VERSION
#define SOL_MEMDESC_OPS_ARRAY_API_VERSION (1) 
    uint16_t api_version; 
#endif

    ssize_t (*get_length)(const struct sol_memdesc *desc, const void *memory);
    void *(*get_element)(const struct sol_memdesc *desc, const void *memory, size_t idx);
    int (*resize)(const struct sol_memdesc *desc, void *memory, size_t length);
} sol_memdesc_ops_array;

typedef struct sol_memdesc_ops_enumeration {
#ifndef SOL_NO_API_VERSION
#define SOL_MEMDESC_OPS_ENUMERATION_API_VERSION (1) 
    uint16_t api_version; 
#endif

    const char *(*to_str)(const struct sol_memdesc *desc, const void *memory);
    int (*from_str)(const struct sol_memdesc *desc, void *ptr_return, const struct sol_str_slice str);
} sol_memdesc_ops_enumeration;

typedef struct sol_memdesc_ops {
#ifndef SOL_NO_API_VERSION
#define SOL_MEMDESC_OPS_API_VERSION (1) 
    uint16_t api_version; 
#endif

    int (*init_defaults)(const struct sol_memdesc *desc, void *memory);
    int (*set_content)(const struct sol_memdesc *desc, void *memory, const void *ptr_content);
    int (*copy)(const struct sol_memdesc *desc, const void *src_memory, void *dst_memory);
    int (*compare)(const struct sol_memdesc *desc, const void *a_memory, const void *b_memory);
    int (*free_content)(const struct sol_memdesc *desc, void *memory);
    union {
        const struct sol_memdesc_ops_array *array;
        const struct sol_memdesc_ops_enumeration *enumeration;
    };
} sol_memdesc_ops;

typedef struct sol_memdesc {
#ifndef SOL_NO_API_VERSION
#define SOL_MEMDESC_API_VERSION (1) 
    uint16_t api_version; 
#endif

    uint16_t size;
    enum sol_memdesc_type type;
    union {
        uint8_t u8; 
        uint16_t u16; 
        uint32_t u32; 
        uint64_t u64; 
        unsigned long ul; 
        size_t sz; 
        int8_t i8; 
        int16_t i16; 
        int32_t i32; 
        int64_t i64; 
        long l; 
        ssize_t ssz; 
        bool b; 
        double d; 
        int64_t e; 
        const char *s; 
        const void *p; 
    } defcontent;
    union {
        const struct sol_memdesc *pointed_item;
        const struct sol_memdesc *array_item;
        const struct sol_memdesc_structure_member *structure_members;
        const struct sol_str_table_int64 *enumeration_mapping;
    };

    const struct sol_memdesc_ops *ops;
} sol_memdesc;

typedef struct sol_memdesc_structure_member {
    struct sol_memdesc base;
    const char *name;
#ifdef SOL_MEMDESC_DESCRIPTION

    const char *description;
#endif

    uint16_t offset;
    bool optional : 1;
    bool detail : 1;
} sol_memdesc_structure_member;

extern const struct sol_memdesc_ops SOL_MEMDESC_OPS_VECTOR;
extern const struct sol_memdesc_ops SOL_MEMDESC_OPS_PTR_VECTOR;

static inline uint16_t
sol_memdesc_get_size(const struct sol_memdesc *desc)
{
    errno = EINVAL;
    if (!desc)
        return 0;

#ifndef SOL_NO_API_VERSION
    if (desc->api_version != SOL_MEMDESC_API_VERSION_COMPILED)
        return 0;
#endif

    errno = 0;
    switch (desc->type) {
    case SOL_MEMDESC_TYPE_UINT8:
        return sizeof(uint8_t);
    case SOL_MEMDESC_TYPE_UINT16:
        return sizeof(uint16_t);
    case SOL_MEMDESC_TYPE_UINT32:
        return sizeof(uint32_t);
    case SOL_MEMDESC_TYPE_UINT64:
        return sizeof(uint64_t);
    case SOL_MEMDESC_TYPE_ULONG:
        return sizeof(unsigned long);
    case SOL_MEMDESC_TYPE_SIZE:
        return sizeof(size_t);
    case SOL_MEMDESC_TYPE_INT8:
        return sizeof(int8_t);
    case SOL_MEMDESC_TYPE_INT16:
        return sizeof(int16_t);
    case SOL_MEMDESC_TYPE_INT32:
        return sizeof(int32_t);
    case SOL_MEMDESC_TYPE_INT64:
        return sizeof(int64_t);
    case SOL_MEMDESC_TYPE_LONG:
        return sizeof(long);
    case SOL_MEMDESC_TYPE_SSIZE:
        return sizeof(ssize_t);
    case SOL_MEMDESC_TYPE_BOOL:
        return sizeof(bool);
    case SOL_MEMDESC_TYPE_DOUBLE:
        return sizeof(double);
    case SOL_MEMDESC_TYPE_STRING:
        return sizeof(char *);
    case SOL_MEMDESC_TYPE_CONST_STRING:
        return sizeof(const char *);
    case SOL_MEMDESC_TYPE_PTR:
        return sizeof(void *);
    case SOL_MEMDESC_TYPE_STRUCTURE:
    case SOL_MEMDESC_TYPE_ARRAY:
    case SOL_MEMDESC_TYPE_ENUMERATION:
        if (desc->size)
            return desc->size;

    /* must provide size */
    default:
        errno = EINVAL;
        return 0;
    }
}

int sol_memdesc_init_defaults(const struct sol_memdesc *desc, void *memory);

int sol_memdesc_copy(const struct sol_memdesc *desc, const void *src_memory, void *dst_memory);

int sol_memdesc_set_content(const struct sol_memdesc *desc, void *memory, const void *ptr_content);

int sol_memdesc_compare(const struct sol_memdesc *desc, const void *a_memory, const void *b_memory);

int sol_memdesc_free_content(const struct sol_memdesc *desc, void *memory);

static inline void
sol_memdesc_free(const struct sol_memdesc *desc, void *memory)
{
    sol_memdesc_free_content(desc, memory);
    free(memory);
}

static inline void *
sol_memdesc_new_with_defaults(const struct sol_memdesc *desc)
{
    void *mem;
    uint16_t size;
    int r;

    size = sol_memdesc_get_size(desc);
    if (!size)
        return NULL;

    mem = malloc(size);
    if (!mem)
        return NULL;

    r = sol_memdesc_init_defaults(desc, mem);
    if (r < 0) {
        sol_memdesc_free(desc, mem);
        errno = -r;
        return NULL;
    }

    errno = 0;
    return mem;
}

ssize_t sol_memdesc_get_array_length(const struct sol_memdesc *array_desc, const void *memory);

void *sol_memdesc_get_array_element(const struct sol_memdesc *array_desc, const void *memory, size_t idx);

int sol_memdesc_resize_array(const struct sol_memdesc *array_desc, void *memory, size_t length);

static inline int
sol_memdesc_append_array_element(const struct sol_memdesc *array_desc, void *memory, const void *ptr_content)
{
    void *element;
    ssize_t len;
    int r;

    len = sol_memdesc_get_array_length(array_desc, memory);
    if (len < 0)
        return len;

    if (!array_desc->array_item)
        return -EINVAL;

    r = sol_memdesc_resize_array(array_desc, memory, len + 1);
    if (r < 0)
        return r;

    element = sol_memdesc_get_array_element(array_desc, memory, len);
    if (!element)
        return -errno;

    r = sol_memdesc_set_content(array_desc->array_item, element, ptr_content);
    if (r < 0)
        sol_memdesc_resize_array(array_desc, memory, len);

    return r;
}

#define SOL_MEMDESC_FOREACH_ARRAY_ELEMENT_IN_RANGE(desc, memory, start_idx, end_idx, itr_idx, element) \
    for (itr_idx = start_idx, \
        element = (itr_idx < end_idx) ? sol_memdesc_get_array_element((desc), (memory), itr_idx) : NULL; \
        itr_idx < end_idx && element; \
        itr_idx++, \
        element = (itr_idx < end_idx) ? sol_memdesc_get_array_element((desc), (memory), itr_idx) : NULL)

#ifdef SOL_NO_API_VERSION
#define _SOL_MEMDESC_CHECK_API_VERSION(desc) 1
#else
#define _SOL_MEMDESC_CHECK_API_VERSION(desc) ((desc)->api_version == SOL_MEMDESC_API_VERSION_COMPILED)
#endif

#define _SOL_MEMDESC_CHECK(desc) \
    ((desc) &&  _SOL_MEMDESC_CHECK_API_VERSION(desc) && (desc)->type != SOL_MEMDESC_TYPE_UNKNOWN)

#define _SOL_MEMDESC_CHECK_STRUCTURE(structure_desc) \
    (_SOL_MEMDESC_CHECK(structure_desc) && (structure_desc)->structure_members && _SOL_MEMDESC_CHECK(&((structure_desc)->structure_members->base)))

#define _SOL_MEMDESC_CHECK_STRUCTURE_MEMBER(structure_desc, member_desc) \
    (_SOL_MEMDESC_CHECK(&(member_desc)->base) && \
    ((member_desc)->offset + sol_memdesc_get_size(&(member_desc)->base) <= sol_memdesc_get_size((structure_desc))))

#define SOL_MEMDESC_FOREACH_STRUCTURE_MEMBER(structure_desc, member_desc) \
    for (member_desc = (_SOL_MEMDESC_CHECK_STRUCTURE((structure_desc)) && _SOL_MEMDESC_CHECK_STRUCTURE_MEMBER((structure_desc), (structure_desc)->structure_members)) ? (structure_desc)->structure_members : NULL; \
        _SOL_MEMDESC_CHECK_STRUCTURE_MEMBER((structure_desc), member_desc); \
        member_desc = _SOL_MEMDESC_CHECK_STRUCTURE_MEMBER((structure_desc), member_desc + 1) ? member_desc + 1 : NULL)

#define SOL_MEMDESC_FOREACH_STRUCTURE_MEMBER_MEMORY(structure_desc, member_desc, structure_memory, member_memory) \
    for (member_desc = (_SOL_MEMDESC_CHECK_STRUCTURE((structure_desc)) && _SOL_MEMDESC_CHECK_STRUCTURE_MEMBER((structure_desc), (structure_desc)->structure_members)) ? (structure_desc)->structure_members : NULL, \
        member_memory = member_desc ? sol_memdesc_get_structure_member_memory((structure_desc), member_desc, (structure_memory)) : NULL; \
        _SOL_MEMDESC_CHECK_STRUCTURE_MEMBER((structure_desc), member_desc) && member_memory; \
        member_desc = _SOL_MEMDESC_CHECK_STRUCTURE_MEMBER((structure_desc), member_desc + 1) ? member_desc + 1 : NULL, \
        member_memory = member_desc ? sol_memdesc_get_structure_member_memory((structure_desc), member_desc, (structure_memory)) : NULL)

static inline const struct sol_memdesc_structure_member *
sol_memdesc_find_structure_member(const struct sol_memdesc *structure_desc, struct sol_str_slice name)
{
    const struct sol_memdesc_structure_member *itr;

    errno = EINVAL;
    if (!structure_desc || !name.len)
        return NULL;

    SOL_MEMDESC_FOREACH_STRUCTURE_MEMBER(structure_desc, itr) {
        if (sol_str_slice_str_eq(name, itr->name)) {
            errno = 0;
            return itr;
        }
    }

    errno = ENOENT;
    return NULL;
}

static inline void *
sol_memdesc_get_structure_member_memory(const struct sol_memdesc *structure_desc, const struct sol_memdesc_structure_member *member_desc, const void *structure_memory)
{
    errno = EINVAL;
    if (!structure_desc || !member_desc || !structure_memory)
        return NULL;

#ifndef SOL_NO_API_VERSION
    if (structure_desc->api_version != SOL_MEMDESC_API_VERSION_COMPILED)
        return NULL;
    if (member_desc->base.api_version != SOL_MEMDESC_API_VERSION_COMPILED)
        return NULL;
#endif

    if (member_desc->offset + sol_memdesc_get_size(&member_desc->base) > sol_memdesc_get_size(structure_desc)) {
        errno = EOVERFLOW;
        return NULL;
    }

    errno = 0;
    return ((uint8_t *)structure_memory) + member_desc->offset;
}

const char *sol_memdesc_enumeration_to_str(const struct sol_memdesc *enumeration, const void *memory);

int sol_memdesc_enumeration_from_str(const struct sol_memdesc *enumeration, void *ptr_return, const struct sol_str_slice str);

static inline uint64_t
sol_memdesc_get_as_uint64(const struct sol_memdesc *desc, const void *memory)
{
    int64_t i64;

    errno = EINVAL;
    if (!desc || !memory)
        return 0;

#ifndef SOL_NO_API_VERSION
    if (desc->api_version != SOL_MEMDESC_API_VERSION_COMPILED)
        return 0;
#endif

    errno = 0;
    switch (desc->type) {
    case SOL_MEMDESC_TYPE_UINT8:
        return *(const uint8_t *)memory;
    case SOL_MEMDESC_TYPE_UINT16:
        return *(const uint16_t *)memory;
    case SOL_MEMDESC_TYPE_UINT32:
        return *(const uint32_t *)memory;
    case SOL_MEMDESC_TYPE_UINT64:
        return *(const uint64_t *)memory;
    case SOL_MEMDESC_TYPE_ULONG:
        return *(const unsigned long *)memory;
    case SOL_MEMDESC_TYPE_SIZE:
        return *(const size_t *)memory;
    case SOL_MEMDESC_TYPE_INT8:
        i64 = *(const int8_t *)memory;
        goto check_signed;
    case SOL_MEMDESC_TYPE_INT16:
        i64 = *(const int16_t *)memory;
        goto check_signed;
    case SOL_MEMDESC_TYPE_INT32:
        i64 = *(const int32_t *)memory;
        goto check_signed;
    case SOL_MEMDESC_TYPE_INT64:
        i64 = *(const int64_t *)memory;
        goto check_signed;
    case SOL_MEMDESC_TYPE_LONG:
        i64 = *(const long *)memory;
        goto check_signed;
    case SOL_MEMDESC_TYPE_SSIZE:
        i64 = *(const ssize_t *)memory;
        goto check_signed;
    case SOL_MEMDESC_TYPE_BOOL:
        return *(const bool *)memory;
    case SOL_MEMDESC_TYPE_DOUBLE:
        i64 = *(const double *)memory;
        goto check_signed;
    case SOL_MEMDESC_TYPE_ENUMERATION: {
        uint8_t offset = 0;

        if (desc->size > sizeof(int64_t)) {
            errno = EINVAL;
            return 0;
        }
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
        else if (desc->size < sizeof(int64_t))
            offset = sizeof(desc->defcontent.e) - desc->size;
#endif
        i64 = 0;
        memcpy((uint8_t *)&i64 + offset, memory, desc->size);
        goto check_signed;
    }
    case SOL_MEMDESC_TYPE_STRING:
    case SOL_MEMDESC_TYPE_CONST_STRING:
    case SOL_MEMDESC_TYPE_PTR:
    case SOL_MEMDESC_TYPE_STRUCTURE:
    case SOL_MEMDESC_TYPE_ARRAY:
    default:
        errno = EINVAL;
        return 0;
    }

check_signed:
    if (i64 < 0) {
        errno = ERANGE;
        return 0;
    }
    return i64;
}

static inline int64_t
sol_memdesc_get_as_int64(const struct sol_memdesc *desc, const void *memory)
{
    uint64_t u64;

    errno = EINVAL;
    if (!desc || !memory)
        return 0;

#ifndef SOL_NO_API_VERSION
    if (desc->api_version != SOL_MEMDESC_API_VERSION_COMPILED)
        return 0;
#endif

    errno = 0;
    switch (desc->type) {
    case SOL_MEMDESC_TYPE_UINT8:
        return *(const uint8_t *)memory;
    case SOL_MEMDESC_TYPE_UINT16:
        return *(const uint16_t *)memory;
    case SOL_MEMDESC_TYPE_UINT32:
        return *(const uint32_t *)memory;
    case SOL_MEMDESC_TYPE_UINT64:
        u64 = *(const uint64_t *)memory;
        goto check_overflow;
    case SOL_MEMDESC_TYPE_ULONG:
        u64 = *(const unsigned long *)memory;
        goto check_overflow;
    case SOL_MEMDESC_TYPE_SIZE:
        u64 = *(const size_t *)memory;
        goto check_overflow;
    case SOL_MEMDESC_TYPE_INT8:
        return *(const int8_t *)memory;
    case SOL_MEMDESC_TYPE_INT16:
        return *(const int16_t *)memory;
    case SOL_MEMDESC_TYPE_INT32:
        return *(const int32_t *)memory;
    case SOL_MEMDESC_TYPE_INT64:
        return *(const int64_t *)memory;
    case SOL_MEMDESC_TYPE_LONG:
        return *(const long *)memory;
    case SOL_MEMDESC_TYPE_SSIZE:
        return *(const ssize_t *)memory;
    case SOL_MEMDESC_TYPE_BOOL:
        return *(const bool *)memory;
    case SOL_MEMDESC_TYPE_DOUBLE:
        return *(const double *)memory;
    case SOL_MEMDESC_TYPE_ENUMERATION: {
        int64_t i64 = 0;
        uint8_t offset = 0;

        if (desc->size > sizeof(int64_t)) {
            errno = EINVAL;
            return 0;
        }
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
        else if (desc->size < sizeof(int64_t))
            offset = sizeof(desc->defcontent.e) - desc->size;
#endif
        memcpy((uint8_t *)&i64 + offset, memory, desc->size);
        return i64;
    }
    case SOL_MEMDESC_TYPE_STRING:
    case SOL_MEMDESC_TYPE_CONST_STRING:
    case SOL_MEMDESC_TYPE_PTR:
    case SOL_MEMDESC_TYPE_STRUCTURE:
    case SOL_MEMDESC_TYPE_ARRAY:
    default:
        errno = EINVAL;
        return 0;
    }

check_overflow:
    if (u64 > INT64_MAX) {
        errno = ERANGE;
        return 0;
    }
    return u64;
}

static inline int
sol_memdesc_set_as_uint64(const struct sol_memdesc *desc, void *memory, uint64_t value)
{
    if (!desc || !memory)
        return -EINVAL;

#ifndef SOL_NO_API_VERSION
    if (desc->api_version != SOL_MEMDESC_API_VERSION_COMPILED)
        return -EINVAL;
#endif

    switch (desc->type) {
    case SOL_MEMDESC_TYPE_UINT8:
        if (value > UINT8_MAX)
            return -EOVERFLOW;
        *(uint8_t *)memory = value;
        return 0;
    case SOL_MEMDESC_TYPE_UINT16:
        if (value > UINT16_MAX)
            return -EOVERFLOW;
        *(uint16_t *)memory = value;
        return 0;
    case SOL_MEMDESC_TYPE_UINT32:
        if (value > UINT32_MAX)
            return -EOVERFLOW;
        *(uint32_t *)memory = value;
        return 0;
    case SOL_MEMDESC_TYPE_UINT64:
        *(uint64_t *)memory = value;
        return 0;
    case SOL_MEMDESC_TYPE_ULONG:
        if (value > ULONG_MAX)
            return -EOVERFLOW;
        *(unsigned long *)memory = value;
        return 0;
    case SOL_MEMDESC_TYPE_SIZE:
        if (value > SIZE_MAX)
            return -EOVERFLOW;
        *(size_t *)memory = value;
        return 0;
    case SOL_MEMDESC_TYPE_INT8:
        if (value > INT8_MAX)
            return -EOVERFLOW;
        *(int8_t *)memory = value;
        return 0;
    case SOL_MEMDESC_TYPE_INT16:
        if (value > INT16_MAX)
            return -EOVERFLOW;
        *(int16_t *)memory = value;
        return 0;
    case SOL_MEMDESC_TYPE_INT32:
        if (value > INT32_MAX)
            return -EOVERFLOW;
        *(int32_t *)memory = value;
        return 0;
    case SOL_MEMDESC_TYPE_INT64:
        if (value > INT64_MAX)
            return -EOVERFLOW;
        *(int64_t *)memory = value;
        return 0;
    case SOL_MEMDESC_TYPE_LONG:
        if (value > LONG_MAX)
            return -EOVERFLOW;
        *(long *)memory = value;
        return 0;
    case SOL_MEMDESC_TYPE_SSIZE:
        if (value > SSIZE_MAX)
            return -EOVERFLOW;
        *(ssize_t *)memory = value;
        return 0;
    case SOL_MEMDESC_TYPE_BOOL:
        *(bool *)memory = !!value;
        return 0;
    case SOL_MEMDESC_TYPE_DOUBLE:
        *(double *)memory = value;
        return 0;
    case SOL_MEMDESC_TYPE_ENUMERATION: {
        uint8_t offset = 0;

        if (desc->size > sizeof(int64_t))
            return -EINVAL;
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
        else if (desc->size < sizeof(int64_t))
            offset = sizeof(desc->defcontent.e) - desc->size;
#endif

        if (value > (((uint64_t)1 << (desc->size * 8 - 1)) - 1))
            return -EOVERFLOW;

        memcpy(memory, (uint8_t *)&value + offset, desc->size);
        return 0;
    }
    case SOL_MEMDESC_TYPE_STRING:
    case SOL_MEMDESC_TYPE_CONST_STRING:
    case SOL_MEMDESC_TYPE_PTR:
    case SOL_MEMDESC_TYPE_STRUCTURE:
    case SOL_MEMDESC_TYPE_ARRAY:
    default:
        return -EINVAL;
    }
}

static inline int64_t
sol_memdesc_set_as_int64(const struct sol_memdesc *desc, void *memory, int64_t value)
{
    if (!desc || !memory)
        return -EINVAL;

#ifndef SOL_NO_API_VERSION
    if (desc->api_version != SOL_MEMDESC_API_VERSION_COMPILED)
        return -EINVAL;
#endif

    switch (desc->type) {
    case SOL_MEMDESC_TYPE_UINT8:
        if (value < 0 || value > UINT8_MAX)
            return -EOVERFLOW;
        *(uint8_t *)memory = value;
        return 0;
    case SOL_MEMDESC_TYPE_UINT16:
        if (value < 0 || value > UINT16_MAX)
            return -EOVERFLOW;
        *(uint16_t *)memory = value;
        return 0;
    case SOL_MEMDESC_TYPE_UINT32:
        if (value < 0 || value > UINT32_MAX)
            return -EOVERFLOW;
        *(uint32_t *)memory = value;
        return 0;
    case SOL_MEMDESC_TYPE_UINT64:
        if (value < 0)
            return -EOVERFLOW;
        *(uint64_t *)memory = value;
        return 0;
    case SOL_MEMDESC_TYPE_ULONG:
        if (value < 0 || (uint64_t)value > ULONG_MAX)
            return -EOVERFLOW;
        *(unsigned long *)memory = value;
        return 0;
    case SOL_MEMDESC_TYPE_SIZE:
        if (value < 0 || (uint64_t)value > SIZE_MAX)
            return -EOVERFLOW;
        *(size_t *)memory = value;
        return 0;
    case SOL_MEMDESC_TYPE_INT8:
        if (value < INT8_MIN || value > INT8_MAX)
            return -EOVERFLOW;
        *(int8_t *)memory = value;
        return 0;
    case SOL_MEMDESC_TYPE_INT16:
        if (value < INT16_MIN || value > INT16_MAX)
            return -EOVERFLOW;
        *(int16_t *)memory = value;
        return 0;
    case SOL_MEMDESC_TYPE_INT32:
        if (value < INT32_MIN || value > INT32_MAX)
            return -EOVERFLOW;
        *(int32_t *)memory = value;
        return 0;
    case SOL_MEMDESC_TYPE_INT64:
        *(int64_t *)memory = value;
        return 0;
    case SOL_MEMDESC_TYPE_LONG:
        if (value < LONG_MIN || value > LONG_MAX)
            return -EOVERFLOW;
        *(long *)memory = value;
        return 0;
    case SOL_MEMDESC_TYPE_SSIZE:
        if (value < SSIZE_MIN || value > SSIZE_MAX)
            return -EOVERFLOW;
        *(ssize_t *)memory = value;
        return 0;
    case SOL_MEMDESC_TYPE_BOOL:
        *(bool *)memory = !!value;
        return 0;
    case SOL_MEMDESC_TYPE_DOUBLE:
        *(double *)memory = value;
        return 0;
    case SOL_MEMDESC_TYPE_ENUMERATION: {
        uint8_t offset = 0;

        if (desc->size > sizeof(int64_t))
            return -EINVAL;
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
        else if (desc->size < sizeof(int64_t))
            offset = sizeof(desc->defcontent.e) - desc->size;
#endif

        if (desc->size < sizeof(int64_t)) {
            if (value > (((int64_t)1 << (desc->size * 8 - 1)) - 1))
                return -EOVERFLOW;
            if (value < -((int64_t)1 << (desc->size * 8 - 1)))
                return -EOVERFLOW;
        }

        memcpy(memory, (uint8_t *)&value + offset, desc->size);
        return 0;
    }
    case SOL_MEMDESC_TYPE_STRING:
    case SOL_MEMDESC_TYPE_CONST_STRING:
    case SOL_MEMDESC_TYPE_PTR:
    case SOL_MEMDESC_TYPE_STRUCTURE:
    case SOL_MEMDESC_TYPE_ARRAY:
    default:
        return -EINVAL;
    }
}

static inline bool
sol_memdesc_is_unsigned_integer(const struct sol_memdesc *desc)
{
    errno = EINVAL;
    if (!desc)
        return false;

#ifndef SOL_NO_API_VERSION
    if (desc->api_version != SOL_MEMDESC_API_VERSION_COMPILED)
        return false;
#endif

    errno = 0;
    switch (desc->type) {
    case SOL_MEMDESC_TYPE_UINT8:
    case SOL_MEMDESC_TYPE_UINT16:
    case SOL_MEMDESC_TYPE_UINT32:
    case SOL_MEMDESC_TYPE_UINT64:
    case SOL_MEMDESC_TYPE_ULONG:
    case SOL_MEMDESC_TYPE_SIZE:
        return true;
    case SOL_MEMDESC_TYPE_INT8:
    case SOL_MEMDESC_TYPE_INT16:
    case SOL_MEMDESC_TYPE_INT32:
    case SOL_MEMDESC_TYPE_INT64:
    case SOL_MEMDESC_TYPE_LONG:
    case SOL_MEMDESC_TYPE_SSIZE:
    case SOL_MEMDESC_TYPE_BOOL:
    case SOL_MEMDESC_TYPE_DOUBLE:
    case SOL_MEMDESC_TYPE_STRING:
    case SOL_MEMDESC_TYPE_CONST_STRING:
    case SOL_MEMDESC_TYPE_PTR:
    case SOL_MEMDESC_TYPE_STRUCTURE:
    case SOL_MEMDESC_TYPE_ARRAY:
    case SOL_MEMDESC_TYPE_ENUMERATION:
    default:
        return false;
    }
}

static inline bool
sol_memdesc_is_signed_integer(const struct sol_memdesc *desc)
{
    errno = EINVAL;
    if (!desc)
        return false;

#ifndef SOL_NO_API_VERSION
    if (desc->api_version != SOL_MEMDESC_API_VERSION_COMPILED)
        return false;
#endif

    errno = 0;
    switch (desc->type) {
    case SOL_MEMDESC_TYPE_UINT8:
    case SOL_MEMDESC_TYPE_UINT16:
    case SOL_MEMDESC_TYPE_UINT32:
    case SOL_MEMDESC_TYPE_UINT64:
    case SOL_MEMDESC_TYPE_ULONG:
    case SOL_MEMDESC_TYPE_SIZE:
        return false;
    case SOL_MEMDESC_TYPE_INT8:
    case SOL_MEMDESC_TYPE_INT16:
    case SOL_MEMDESC_TYPE_INT32:
    case SOL_MEMDESC_TYPE_INT64:
    case SOL_MEMDESC_TYPE_LONG:
    case SOL_MEMDESC_TYPE_SSIZE:
    case SOL_MEMDESC_TYPE_ENUMERATION:
        return true;
    case SOL_MEMDESC_TYPE_BOOL:
    case SOL_MEMDESC_TYPE_DOUBLE:
    case SOL_MEMDESC_TYPE_STRING:
    case SOL_MEMDESC_TYPE_CONST_STRING:
    case SOL_MEMDESC_TYPE_PTR:
    case SOL_MEMDESC_TYPE_STRUCTURE:
    case SOL_MEMDESC_TYPE_ARRAY:
    default:
        return false;
    }
}

typedef struct sol_memdesc_serialize_options {
#ifndef SOL_NO_API_VERSION
#define SOL_MEMDESC_SERIALIZE_OPTIONS_API_VERSION (1) 
    uint16_t api_version; 
#endif

    int (*serialize_int64)(const struct sol_memdesc *desc, int64_t value, struct sol_buffer *buffer);
    int (*serialize_uint64)(const struct sol_memdesc *desc, uint64_t value, struct sol_buffer *buffer);
    int (*serialize_double)(const struct sol_memdesc *desc, double value, struct sol_buffer *buffer);
    int (*serialize_bool)(const struct sol_memdesc *desc, bool value, struct sol_buffer *buffer);
    int (*serialize_pointer)(const struct sol_memdesc *desc, const void *value, struct sol_buffer *buffer);
    int (*serialize_string)(const struct sol_memdesc *desc, const char *value, struct sol_buffer *buffer);
    int (*serialize_enumeration)(const struct sol_memdesc *desc, const void *memory, struct sol_buffer *buffer);
    int (*serialize_structure_member)(const struct sol_memdesc *structure, const struct sol_memdesc_structure_member *member, const void *memory, struct sol_buffer *buffer, const struct sol_memdesc_serialize_options *opts, struct sol_buffer *prefix, bool is_first);
    int (*serialize_array_item)(const struct sol_memdesc *desc, size_t idx, const void *memory, struct sol_buffer *buffer, const struct sol_memdesc_serialize_options *opts, struct sol_buffer *prefix);
    struct {
        struct {
            const struct sol_str_slice start;
            const struct sol_str_slice end;
            const struct sol_str_slice indent;
        } container;
        struct {
            const struct sol_str_slice start;
            const struct sol_str_slice end;
            const struct sol_str_slice indent;
        } key;
        struct {
            const struct sol_str_slice start;
            const struct sol_str_slice end;
            const struct sol_str_slice indent;
        } value;
#ifdef SOL_MEMDESC_DESCRIPTION
        struct {
            const struct sol_str_slice start;
            const struct sol_str_slice end;
            const struct sol_str_slice indent;
        } description;
#endif

        struct sol_str_slice separator;
        bool show_key;
        bool detailed;
#ifdef SOL_MEMDESC_DESCRIPTION

        bool show_description;
#endif
    } structure;
    struct {
        struct {
            const struct sol_str_slice start;
            const struct sol_str_slice end;
            const struct sol_str_slice indent;
        } container;
        struct {
            const struct sol_str_slice start;
            const struct sol_str_slice end;
            const struct sol_str_slice indent;
        } index;
        struct {
            const struct sol_str_slice start;
            const struct sol_str_slice end;
            const struct sol_str_slice indent;
        } value;
        struct sol_str_slice separator;
        bool show_index;
    } array;
} sol_memdesc_serialize_options;

extern const struct sol_memdesc_serialize_options SOL_MEMDESC_SERIALIZE_OPTIONS_DEFAULT;

int sol_memdesc_serialize(const struct sol_memdesc *desc, const void *memory, struct sol_buffer *buffer, const struct sol_memdesc_serialize_options *opts, struct sol_buffer *prefix);

#ifdef __cplusplus
}
#endif