zxsd_bind.h

Go to the documentation of this file.

/*
 * Copyright (c) 2026 Sixtaupi
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZXSD_BIND_H
#define ZXSD_BIND_H
 
#include "zxsd.h"
 
#include <stddef.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define ZXSD_BIND_NO_OFFSET ((size_t)(-1))
 
typedef enum {
    ZXSD_BIND_STRING = 0, 
    ZXSD_BIND_BOOLEAN,    
    ZXSD_BIND_INT8,       
    ZXSD_BIND_UINT8,      
    ZXSD_BIND_INT16,      
    ZXSD_BIND_UINT16,     
    ZXSD_BIND_INT32,      
    ZXSD_BIND_UINT32,     
    ZXSD_BIND_INT64,      
    ZXSD_BIND_UINT64,     
    ZXSD_BIND_ENUM,       
    ZXSD_BIND_COMPLEX     
} zxsd_bind_kind_t;
 
typedef enum {
    ZXSD_BIND_ATTRIBUTE = 0, 
    ZXSD_BIND_ELEMENT,       
    ZXSD_BIND_CONTENT        
} zxsd_bind_role_t;
 
typedef enum {
    ZXSD_BIND_INLINE = 0,
    ZXSD_BIND_POINTER,
    ZXSD_BIND_ARRAY
} zxsd_bind_storage_t;
 
struct zxsd_bind_type;
 
typedef struct zxsd_bind_field {
    const char *name;                  
    const char *namespace_uri;         
    zxsd_bind_role_t role;             
    zxsd_bind_kind_t kind;             
    zxsd_bind_storage_t storage;       
    unsigned long min_occurs;          
    unsigned long max_occurs;          
    size_t offset;                     
    size_t presence_offset;            
    size_t count_offset;               
    size_t value_size;                 
    const struct zxsd_bind_type *type; 
    const char *const *enumeration;    
    size_t enumeration_count;          
    zxsd_whitespace_t whitespace;      
    const char *default_value;         
    const char *fixed_value;           
} zxsd_bind_field_t;
 
typedef struct zxsd_bind_type {
    const char *name;                
    const char *type_name;           
    const char *type_namespace;      
    size_t size;                     
    const zxsd_bind_field_t *fields; 
    size_t field_count;              
} zxsd_bind_type_t;
 
typedef struct {
    const char *prefix;        
    const char *namespace_uri; 
} zxsd_bind_namespace_t;
 
typedef const zxsd_schema_t *(*zxsd_bind_schema_fn)(void);
 
typedef struct {
    const char *name;                        
    const char *namespace_uri;               
    const zxsd_bind_type_t *type;            
    zxsd_bind_schema_fn schema;              
    const zxsd_bind_namespace_t *namespaces; 
    size_t namespace_count;                  
    const char *default_value;               
    const char *fixed_value;                 
} zxsd_bind_root_t;
 
typedef struct {
    unsigned char *data; 
    size_t capacity;     
    size_t used;         
} zxsd_bind_arena_t;
 
typedef int (*zxsd_bind_sink_fn)(void *context, const char *data, size_t length);
 
void zxsd_bind_arena_init(zxsd_bind_arena_t *arena, void *storage, size_t capacity);
 
typedef enum {
    ZXSD_BIND_CONTINUE = 0,  
    ZXSD_BIND_VALIDATE_ONLY, 
    ZXSD_BIND_CALLBACK_ERROR 
} zxsd_bind_action_t;
 
typedef struct {
    const char *name;          
    const char *namespace_uri; 
} zxsd_bind_path_step_t;
 
typedef struct {
    zxsd_bind_schema_fn schema; 
    const zxsd_bind_path_step_t *steps; 
    size_t step_count;                  
    const zxsd_bind_type_t
        *type; 
    const char *default_value; 
    const char *fixed_value;   
} zxsd_bind_selection_t;
 
typedef zxsd_bind_action_t (*zxsd_bind_item_fn)(void *user_data, const void *object);
 
typedef struct {
    const zxsd_bind_type_t *type;   
    const zxsd_bind_field_t *field; 
    void *object;                   
    unsigned char path_match; 
    unsigned char seen_attributes[ZXSD_MAX_ATTRIBUTES]; 
} zxsd_bind_stream_frame_t;
 
typedef struct {
    zxsd_xml_reader_t xml;                  
    const zxsd_bind_selection_t *selection; 
    zxsd_bind_arena_t *arena;               
    void *object;                           
    zxsd_bind_item_fn callback;             
    void *user_data;                        
    size_t arena_mark;   
    size_t active_depth; 
    int validate_only;   
    int finished;        
    zxsd_bind_stream_frame_t frames[ZXSD_MAX_DEPTH]; 
} zxsd_bind_stream_t;
 
typedef struct {
    zxsd_runtime_config_t runtime; 
    unsigned int binding_abi;      
    size_t layouts[6];             
} zxsd_bind_runtime_config_t;
 
#define ZXSD_BIND_RUNTIME_CONFIG_INIT                                                              \
    {                                                                                          \
        ZXSD_RUNTIME_CONFIG_INIT, ZXSD_BINDING_ABI_VERSION,                                \
        {                                                                                  \
            sizeof(zxsd_bind_field_t), sizeof(zxsd_bind_type_t),                       \
                sizeof(zxsd_bind_root_t), sizeof(zxsd_bind_arena_t),               \
                sizeof(zxsd_bind_stream_t), sizeof(zxsd_bind_stream_frame_t)       \
        }                                                                                  \
    }
 
void ZXSD_BINDING_ABI_GUARD(void);
 
zxsd_result_t zxsd_bind_check_runtime(const zxsd_bind_runtime_config_t *expected);
 
zxsd_result_t zxsd_bind_stream_init(zxsd_bind_stream_t *reader,
                    const zxsd_bind_selection_t *selection, void *object,
                    zxsd_bind_arena_t *arena, zxsd_bind_item_fn callback,
                    void *user_data, const zxsd_allocator_t *allocator);
 
zxsd_result_t zxsd_bind_stream_feed(zxsd_bind_stream_t *reader, const void *data, size_t length);
 
zxsd_result_t zxsd_bind_stream_finish(zxsd_bind_stream_t *reader);
 
void zxsd_bind_stream_dispose(zxsd_bind_stream_t *reader);
 
zxsd_result_t zxsd_bind_read(const zxsd_bind_root_t *root, const char *xml, void *object,
                 zxsd_bind_arena_t *arena);
 
zxsd_result_t zxsd_bind_read_with_allocator(const zxsd_bind_root_t *root, const char *xml,
                        void *object, zxsd_bind_arena_t *arena,
                        const zxsd_allocator_t *allocator);
 
zxsd_result_t zxsd_bind_write(const zxsd_bind_root_t *root, const void *object,
                  zxsd_bind_sink_fn sink, void *context, zxsd_stream_t *validator);
 
zxsd_result_t zxsd_bind_write_buffer(const zxsd_bind_root_t *root, const void *object, char *buffer,
                     size_t capacity, size_t *length);
 
zxsd_result_t zxsd_bind_write_buffer_with_allocator(const zxsd_bind_root_t *root,
                            const void *object, char *buffer,
                            size_t capacity, size_t *length,
                            const zxsd_allocator_t *allocator);
 
#ifdef __cplusplus
}
#endif
#endif