afw_interface.h

Go to the documentation of this file.

// See the 'COPYING' file in the project root for licensing information.
/*
 * Interface afw_interface Header
 *
 * Copyright (c) 2010-2023 Clemson University
 *
 */
 
/*  ----------------------------- N O T E -------------------------------------
 *
 * This file is generated by "afwdev generate afw".
 *
 * Do not change this file directly or the changes will be lost the next time
 * this file is regenerated.
 *
 * -------------------------------------------------------------------------*/
 
 
#ifndef __AFW_INTERFACE_H__
#define __AFW_INTERFACE_H__
 
 
#include "afw_interface_common.h"
#include "afw_interface_opaques.h"
#include "afw_common_opaques.h"
 
AFW_BEGIN_DECLARES
 
struct afw_extension_s {
    const afw_extension_inf_t *inf;
    afw_utf8_t extension_id;
    afw_utf8_t extension_version;
    afw_utf8_t afw_compiled_version;
    unsigned int afw_compiled_version_hex;
};
 
#define AFW_EXTENSION_INTERFACE_NAME \
"afw_extension"
 
typedef const afw_extension_t *
(*afw_extension_initialize_t)(
    const afw_extension_t * instance,
    const afw_object_t * properties,
    const afw_pool_t * p,
    afw_xctx_t * xctx);
 
typedef void
(*afw_extension_release_t)(
    const afw_extension_t * instance,
    afw_xctx_t * xctx);
 
struct afw_extension_inf_s {
    afw_interface_implementation_rti_t rti;
    afw_extension_initialize_t initialize;
    afw_extension_release_t release;
};
 
#define afw_extension_initialize( \
    instance, \
    properties, \
    p, \
    xctx \
) \
(instance)->inf->initialize( \
    (instance), \
    (properties), \
    (p), \
    (xctx) \
)
 
#define afw_extension_release( \
    instance, \
    xctx \
) \
(instance)->inf->release( \
    (instance), \
    (xctx) \
)
 
struct afw_adaptor_factory_s {
    const afw_adaptor_factory_inf_t *inf;
    afw_utf8_t adaptor_type;
    const afw_utf8_t * description;
};
 
#define AFW_ADAPTOR_FACTORY_INTERFACE_NAME \
"afw_adaptor_factory"
 
typedef const afw_adaptor_t *
(*afw_adaptor_factory_create_adaptor_cede_p_t)(
    const afw_adaptor_factory_t * instance,
    const afw_object_t * properties,
    const afw_pool_t * p,
    afw_xctx_t * xctx);
 
struct afw_adaptor_factory_inf_s {
    afw_interface_implementation_rti_t rti;
    afw_adaptor_factory_create_adaptor_cede_p_t create_adaptor_cede_p;
};
 
#define afw_adaptor_factory_create_adaptor_cede_p( \
    instance, \
    properties, \
    p, \
    xctx \
) \
(instance)->inf->create_adaptor_cede_p( \
    (instance), \
    (properties), \
    (p), \
    (xctx) \
)
 
struct afw_adaptor_s {
    const afw_adaptor_inf_t *inf;
    const afw_pool_t * p;
    afw_utf8_t adaptor_id;
    const afw_utf8_t * adaptor_type_id;
    const afw_utf8_t * service_id;
    const afw_object_t * properties;
    const afw_utf8_t * source_location;
    const afw_utf8_t * trace_flag_id;
    afw_size_t trace_flag_index;
    const afw_utf8_t * detail_flag_id;
    afw_size_t detail_flag_index;
    const afw_adaptor_impl_t * impl;
};
 
#define AFW_ADAPTOR_INTERFACE_NAME \
"afw_adaptor"
 
typedef void
(*afw_adaptor_destroy_t)(
    const afw_adaptor_t * instance,
    afw_xctx_t * xctx);
 
typedef const afw_adaptor_session_t *
(*afw_adaptor_create_adaptor_session_t)(
    const afw_adaptor_t * instance,
    afw_xctx_t * xctx);
 
typedef const afw_object_t *
(*afw_adaptor_get_additional_metrics_t)(
    const afw_adaptor_t * instance,
    const afw_pool_t * p,
    afw_xctx_t * xctx);
 
struct afw_adaptor_inf_s {
    afw_interface_implementation_rti_t rti;
    afw_adaptor_destroy_t destroy;
    afw_adaptor_create_adaptor_session_t create_adaptor_session;
    afw_adaptor_get_additional_metrics_t get_additional_metrics;
};
 
#define afw_adaptor_destroy( \
    instance, \
    xctx \
) \
(instance)->inf->destroy( \
    (instance), \
    (xctx) \
)
 
#define afw_adaptor_create_adaptor_session( \
    instance, \
    xctx \
) \
(instance)->inf->create_adaptor_session( \
    (instance), \
    (xctx) \
)
 
#define afw_adaptor_get_additional_metrics( \
    instance, \
    p, \
    xctx \
) \
(instance)->inf->get_additional_metrics( \
    (instance), \
    (p), \
    (xctx) \
)
 
struct afw_adaptor_object_type_cache_s {
    const afw_adaptor_object_type_cache_inf_t *inf;
    const afw_adaptor_session_t * session;
    afw_boolean_t all_object_types_immutable;
};
 
#define AFW_ADAPTOR_OBJECT_TYPE_CACHE_INTERFACE_NAME \
"afw_adaptor_object_type_cache"
 
typedef const afw_object_type_t *
(*afw_adaptor_object_type_cache_get_t)(
    const afw_adaptor_object_type_cache_t * instance,
    const afw_utf8_t * object_type_id,
    afw_boolean_t * final_result,
    afw_xctx_t * xctx);
 
typedef void
(*afw_adaptor_object_type_cache_set_t)(
    const afw_adaptor_object_type_cache_t * instance,
    const afw_object_type_t * object_type,
    afw_xctx_t * xctx);
 
struct afw_adaptor_object_type_cache_inf_s {
    afw_interface_implementation_rti_t rti;
    afw_adaptor_object_type_cache_get_t get;
    afw_adaptor_object_type_cache_set_t set;
};
 
#define afw_adaptor_object_type_cache_get( \
    instance, \
    object_type_id, \
    final_result, \
    xctx \
) \
(instance)->inf->get( \
    (instance), \
    (object_type_id), \
    (final_result), \
    (xctx) \
)
 
#define afw_adaptor_object_type_cache_set( \
    instance, \
    object_type, \
    xctx \
) \
(instance)->inf->set( \
    (instance), \
    (object_type), \
    (xctx) \
)
 
struct afw_adaptor_session_s {
    const afw_adaptor_session_inf_t *inf;
    const afw_adaptor_t * adaptor;
    const afw_pool_t * p;
};
 
#define AFW_ADAPTOR_SESSION_INTERFACE_NAME \
"afw_adaptor_session"
 
typedef void
(*afw_adaptor_session_destroy_t)(
    const afw_adaptor_session_t * instance,
    afw_xctx_t * xctx);
 
typedef void
(*afw_adaptor_session_retrieve_objects_t)(
    const afw_adaptor_session_t * instance,
    const afw_adaptor_impl_request_t * impl_request,
    const afw_utf8_t * object_type_id,
    const afw_query_criteria_t * criteria,
    void * context,
    afw_object_cb_t callback,
    const afw_object_t * adaptor_type_specific,
    const afw_pool_t * p,
    afw_xctx_t * xctx);
 
typedef void
(*afw_adaptor_session_get_object_t)(
    const afw_adaptor_session_t * instance,
    const afw_adaptor_impl_request_t * impl_request,
    const afw_utf8_t * object_type_id,
    const afw_utf8_t * object_id,
    void * context,
    afw_object_cb_t callback,
    const afw_object_t * adaptor_type_specific,
    const afw_pool_t * p,
    afw_xctx_t * xctx);
 
typedef const afw_utf8_t *
(*afw_adaptor_session_add_object_t)(
    const afw_adaptor_session_t * instance,
    const afw_adaptor_impl_request_t * impl_request,
    const afw_utf8_t * object_type_id,
    const afw_utf8_t * suggested_object_id,
    const afw_object_t * object,
    const afw_object_t * adaptor_type_specific,
    afw_xctx_t * xctx);
 
typedef void
(*afw_adaptor_session_modify_object_t)(
    const afw_adaptor_session_t * instance,
    const afw_adaptor_impl_request_t * impl_request,
    const afw_utf8_t * object_type_id,
    const afw_utf8_t * object_id,
    const afw_adaptor_modify_entry_t * const * entry,
    const afw_object_t * adaptor_type_specific,
    afw_xctx_t * xctx);
 
typedef void
(*afw_adaptor_session_replace_object_t)(
    const afw_adaptor_session_t * instance,
    const afw_adaptor_impl_request_t * impl_request,
    const afw_utf8_t * object_type_id,
    const afw_utf8_t * object_id,
    const afw_object_t * replacement_object,
    const afw_object_t * adaptor_type_specific,
    afw_xctx_t * xctx);
 
typedef void
(*afw_adaptor_session_delete_object_t)(
    const afw_adaptor_session_t * instance,
    const afw_adaptor_impl_request_t * impl_request,
    const afw_utf8_t * object_type_id,
    const afw_utf8_t * object_id,
    const afw_object_t * adaptor_type_specific,
    afw_xctx_t * xctx);
 
typedef const afw_adaptor_transaction_t *
(*afw_adaptor_session_begin_transaction_t)(
    const afw_adaptor_session_t * instance,
    afw_xctx_t * xctx);
 
typedef const afw_adaptor_journal_t *
(*afw_adaptor_session_get_journal_interface_t)(
    const afw_adaptor_session_t * instance,
    afw_xctx_t * xctx);
 
typedef const afw_adaptor_key_value_t *
(*afw_adaptor_session_get_key_value_interface_t)(
    const afw_adaptor_session_t * instance,
    afw_xctx_t * xctx);
 
typedef const afw_adaptor_impl_index_t *
(*afw_adaptor_session_get_index_interface_t)(
    const afw_adaptor_session_t * instance,
    afw_xctx_t * xctx);
 
typedef const afw_adaptor_object_type_cache_t *
(*afw_adaptor_session_get_object_type_cache_interface_t)(
    const afw_adaptor_session_t * instance,
    afw_xctx_t * xctx);
 
struct afw_adaptor_session_inf_s {
    afw_interface_implementation_rti_t rti;
    afw_adaptor_session_destroy_t destroy;
    afw_adaptor_session_retrieve_objects_t retrieve_objects;
    afw_adaptor_session_get_object_t get_object;
    afw_adaptor_session_add_object_t add_object;
    afw_adaptor_session_modify_object_t modify_object;
    afw_adaptor_session_replace_object_t replace_object;
    afw_adaptor_session_delete_object_t delete_object;
    afw_adaptor_session_begin_transaction_t begin_transaction;
    afw_adaptor_session_get_journal_interface_t get_journal_interface;
    afw_adaptor_session_get_key_value_interface_t get_key_value_interface;
    afw_adaptor_session_get_index_interface_t get_index_interface;
    afw_adaptor_session_get_object_type_cache_interface_t get_object_type_cache_interface;
};
 
#define afw_adaptor_session_destroy( \
    instance, \
    xctx \
) \
(instance)->inf->destroy( \
    (instance), \
    (xctx) \
)
 
#define afw_adaptor_session_retrieve_objects( \
    instance, \
    impl_request, \
    object_type_id, \
    criteria, \
    context, \
    callback, \
    adaptor_type_specific, \
    p, \
    xctx \
) \
(instance)->inf->retrieve_objects( \
    (instance), \
    (impl_request), \
    (object_type_id), \
    (criteria), \
    (context), \
    (callback), \
    (adaptor_type_specific), \
    (p), \
    (xctx) \
)
 
#define afw_adaptor_session_get_object( \
    instance, \
    impl_request, \
    object_type_id, \
    object_id, \
    context, \
    callback, \
    adaptor_type_specific, \
    p, \
    xctx \
) \
(instance)->inf->get_object( \
    (instance), \
    (impl_request), \
    (object_type_id), \
    (object_id), \
    (context), \
    (callback), \
    (adaptor_type_specific), \
    (p), \
    (xctx) \
)
 
#define afw_adaptor_session_add_object( \
    instance, \
    impl_request, \
    object_type_id, \
    suggested_object_id, \
    object, \
    adaptor_type_specific, \
    xctx \
) \
(instance)->inf->add_object( \
    (instance), \
    (impl_request), \
    (object_type_id), \
    (suggested_object_id), \
    (object), \
    (adaptor_type_specific), \
    (xctx) \
)
 
#define afw_adaptor_session_modify_object( \
    instance, \
    impl_request, \
    object_type_id, \
    object_id, \
    entry, \
    adaptor_type_specific, \
    xctx \
) \
(instance)->inf->modify_object( \
    (instance), \
    (impl_request), \
    (object_type_id), \
    (object_id), \
    (entry), \
    (adaptor_type_specific), \
    (xctx) \
)
 
#define afw_adaptor_session_replace_object( \
    instance, \
    impl_request, \
    object_type_id, \
    object_id, \
    replacement_object, \
    adaptor_type_specific, \
    xctx \
) \
(instance)->inf->replace_object( \
    (instance), \
    (impl_request), \
    (object_type_id), \
    (object_id), \
    (replacement_object), \
    (adaptor_type_specific), \
    (xctx) \
)
 
#define afw_adaptor_session_delete_object( \
    instance, \
    impl_request, \
    object_type_id, \
    object_id, \
    adaptor_type_specific, \
    xctx \
) \
(instance)->inf->delete_object( \
    (instance), \
    (impl_request), \
    (object_type_id), \
    (object_id), \
    (adaptor_type_specific), \
    (xctx) \
)
 
#define afw_adaptor_session_begin_transaction( \
    instance, \
    xctx \
) \
(instance)->inf->begin_transaction( \
    (instance), \
    (xctx) \
)
 
#define afw_adaptor_session_get_journal_interface( \
    instance, \
    xctx \
) \
(instance)->inf->get_journal_interface( \
    (instance), \
    (xctx) \
)
 
#define afw_adaptor_session_get_key_value_interface( \
    instance, \
    xctx \
) \
(instance)->inf->get_key_value_interface( \
    (instance), \
    (xctx) \
)
 
#define afw_adaptor_session_get_index_interface( \
    instance, \
    xctx \
) \
(instance)->inf->get_index_interface( \
    (instance), \
    (xctx) \
)
 
#define afw_adaptor_session_get_object_type_cache_interface( \
    instance, \
    xctx \
) \
(instance)->inf->get_object_type_cache_interface( \
    (instance), \
    (xctx) \
)
 
struct afw_adaptor_transaction_s {
    const afw_adaptor_transaction_inf_t *inf;
};
 
#define AFW_ADAPTOR_TRANSACTION_INTERFACE_NAME \
"afw_adaptor_transaction"
 
typedef void
(*afw_adaptor_transaction_release_t)(
    const afw_adaptor_transaction_t * instance,
    afw_xctx_t * xctx);
 
typedef void
(*afw_adaptor_transaction_commit_t)(
    const afw_adaptor_transaction_t * instance,
    afw_xctx_t * xctx);
 
struct afw_adaptor_transaction_inf_s {
    afw_interface_implementation_rti_t rti;
    afw_adaptor_transaction_release_t release;
    afw_adaptor_transaction_commit_t commit;
};
 
#define afw_adaptor_transaction_release( \
    instance, \
    xctx \
) \
(instance)->inf->release( \
    (instance), \
    (xctx) \
)
 
#define afw_adaptor_transaction_commit( \
    instance, \
    xctx \
) \
(instance)->inf->commit( \
    (instance), \
    (xctx) \
)
 
struct afw_adaptor_impl_index_cursor_s {
    const afw_adaptor_impl_index_cursor_inf_t *inf;
    const afw_query_criteria_filter_entry_t * filter_entry;
    afw_boolean_t inner_join;
};
 
#define AFW_ADAPTOR_IMPL_INDEX_CURSOR_INTERFACE_NAME \
"afw_adaptor_impl_index_cursor"
 
typedef void
(*afw_adaptor_impl_index_cursor_release_t)(
    const afw_adaptor_impl_index_cursor_t * instance,
    afw_xctx_t * xctx);
 
typedef const afw_object_t *
(*afw_adaptor_impl_index_cursor_get_next_object_t)(
    const afw_adaptor_impl_index_cursor_t * instance,
    const afw_pool_t * pool,
    afw_xctx_t * xctx);
 
typedef afw_boolean_t
(*afw_adaptor_impl_index_cursor_contains_object_t)(
    const afw_adaptor_impl_index_cursor_t * instance,
    const afw_object_t * object,
    afw_xctx_t * xctx);
 
typedef const afw_adaptor_impl_index_cursor_t *
(*afw_adaptor_impl_index_cursor_inner_join_t)(
    const afw_adaptor_impl_index_cursor_t * instance,
    const afw_adaptor_impl_index_cursor_t * cursor,
    afw_xctx_t * xctx);
 
typedef afw_boolean_t
(*afw_adaptor_impl_index_cursor_get_count_t)(
    const afw_adaptor_impl_index_cursor_t * instance,
    size_t * count,
    afw_xctx_t * xctx);
 
struct afw_adaptor_impl_index_cursor_inf_s {
    afw_interface_implementation_rti_t rti;
    afw_adaptor_impl_index_cursor_release_t release;
    afw_adaptor_impl_index_cursor_get_next_object_t get_next_object;
    afw_adaptor_impl_index_cursor_contains_object_t contains_object;
    afw_adaptor_impl_index_cursor_inner_join_t inner_join;
    afw_adaptor_impl_index_cursor_get_count_t get_count;
};
 
#define afw_adaptor_impl_index_cursor_release( \
    instance, \
    xctx \
) \
(instance)->inf->release( \
    (instance), \
    (xctx) \
)
 
#define afw_adaptor_impl_index_cursor_get_next_object( \
    instance, \
    pool, \
    xctx \
) \
(instance)->inf->get_next_object( \
    (instance), \
    (pool), \
    (xctx) \
)
 
#define afw_adaptor_impl_index_cursor_contains_object( \
    instance, \
    object, \
    xctx \
) \
(instance)->inf->contains_object( \
    (instance), \
    (object), \
    (xctx) \
)
 
#define afw_adaptor_impl_index_cursor_inner_join( \
    instance, \
    cursor, \
    xctx \
) \
(instance)->inf->inner_join( \
    (instance), \
    (cursor), \
    (xctx) \
)
 
#define afw_adaptor_impl_index_cursor_get_count( \
    instance, \
    count, \
    xctx \
) \
(instance)->inf->get_count( \
    (instance), \
    (count), \
    (xctx) \
)
 
struct afw_adaptor_key_value_s {
    const afw_adaptor_key_value_inf_t *inf;
};
 
#define AFW_ADAPTOR_KEY_VALUE_INTERFACE_NAME \
"afw_adaptor_key_value"
 
typedef void
(*afw_adaptor_key_value_add_t)(
    const afw_adaptor_key_value_t * instance,
    const afw_utf8_t * namespace,
    const afw_memory_t * key,
    const afw_memory_t * value,
    afw_xctx_t * xctx);
 
typedef void
(*afw_adaptor_key_value_delete_t)(
    const afw_adaptor_key_value_t * instance,
    const afw_utf8_t * namespace,
    const afw_memory_t * key,
    const afw_memory_t * value,
    afw_boolean_t must_exist,
    afw_xctx_t * xctx);
 
typedef void
(*afw_adaptor_key_value_replace_t)(
    const afw_adaptor_key_value_t * instance,
    const afw_utf8_t * namespace,
    const afw_memory_t * key,
    const afw_memory_t * value,
    afw_boolean_t must_exist,
    afw_xctx_t * xctx);
 
typedef const afw_memory_t *
(*afw_adaptor_key_value_get_t)(
    const afw_adaptor_key_value_t * instance,
    const afw_utf8_t * namespace,
    const afw_memory_t * key,
    afw_xctx_t * xctx);
 
struct afw_adaptor_key_value_inf_s {
    afw_interface_implementation_rti_t rti;
    afw_adaptor_key_value_add_t add;
    afw_adaptor_key_value_delete_t delete;
    afw_adaptor_key_value_replace_t replace;
    afw_adaptor_key_value_get_t get;
};
 
#define afw_adaptor_key_value_add( \
    instance, \
    namespace, \
    key, \
    value, \
    xctx \
) \
(instance)->inf->add( \
    (instance), \
    (namespace), \
    (key), \
    (value), \
    (xctx) \
)
 
#define afw_adaptor_key_value_delete( \
    instance, \
    namespace, \
    key, \
    value, \
    must_exist, \
    xctx \
) \
(instance)->inf->delete( \
    (instance), \
    (namespace), \
    (key), \
    (value), \
    (must_exist), \
    (xctx) \
)
 
#define afw_adaptor_key_value_replace( \
    instance, \
    namespace, \
    key, \
    value, \
    must_exist, \
    xctx \
) \
(instance)->inf->replace( \
    (instance), \
    (namespace), \
    (key), \
    (value), \
    (must_exist), \
    (xctx) \
)
 
#define afw_adaptor_key_value_get( \
    instance, \
    namespace, \
    key, \
    xctx \
) \
(instance)->inf->get( \
    (instance), \
    (namespace), \
    (key), \
    (xctx) \
)
 
struct afw_adaptor_impl_index_s {
    const afw_adaptor_impl_index_inf_t *inf;
    const afw_object_t * indexDefinitions;
};
 
#define AFW_ADAPTOR_IMPL_INDEX_INTERFACE_NAME \
"afw_adaptor_impl_index"
 
typedef void
(*afw_adaptor_impl_index_open_t)(
    const afw_adaptor_impl_index_t * instance,
    const afw_utf8_t * object_type_id,
    const afw_utf8_t * key,
    afw_boolean_t integer,
    afw_boolean_t unique,
    afw_boolean_t reverse,
    const afw_pool_t * pool,
    afw_xctx_t * xctx);
 
typedef void
(*afw_adaptor_impl_index_release_t)(
    const afw_adaptor_impl_index_t * instance,
    afw_xctx_t * xctx);
 
typedef const afw_object_t *
(*afw_adaptor_impl_index_get_index_definitions_t)(
    const afw_adaptor_impl_index_t * instance,
    afw_xctx_t * xctx);
 
typedef void
(*afw_adaptor_impl_index_update_index_definitions_t)(
    const afw_adaptor_impl_index_t * instance,
    const afw_object_t * indexDefinitions,
    afw_xctx_t * xctx);
 
typedef afw_rc_t
(*afw_adaptor_impl_index_add_t)(
    const afw_adaptor_impl_index_t * instance,
    const afw_utf8_t * object_type_id,
    const afw_utf8_t * object_id,
    const afw_utf8_t * key,
    const afw_utf8_t* value,
    afw_boolean_t unique,
    const afw_pool_t * pool,
    afw_xctx_t * xctx);
 
typedef afw_rc_t
(*afw_adaptor_impl_index_delete_t)(
    const afw_adaptor_impl_index_t * instance,
    const afw_utf8_t * object_type_id,
    const afw_utf8_t * object_id,
    const afw_utf8_t * key,
    const afw_utf8_t* value,
    const afw_pool_t * pool,
    afw_xctx_t * xctx);
 
typedef afw_rc_t
(*afw_adaptor_impl_index_replace_t)(
    const afw_adaptor_impl_index_t * instance,
    const afw_utf8_t * object_type_id,
    const afw_utf8_t * object_id,
    const afw_utf8_t * key,
    const afw_utf8_t* old_value,
    const afw_utf8_t* new_value,
    const afw_pool_t * pool,
    afw_xctx_t * xctx);
 
typedef afw_rc_t
(*afw_adaptor_impl_index_drop_t)(
    const afw_adaptor_impl_index_t * instance,
    const afw_utf8_t * object_type_id,
    const afw_utf8_t * key,
    const afw_pool_t * pool,
    afw_xctx_t * xctx);
 
typedef afw_adaptor_impl_index_cursor_t *
(*afw_adaptor_impl_index_open_cursor_t)(
    const afw_adaptor_impl_index_t * instance,
    const afw_utf8_t * object_type_id,
    const afw_utf8_t * index_key,
    int operator,
    const afw_utf8_t * value,
    afw_boolean_t unique,
    const afw_pool_t * pool,
    afw_xctx_t * xctx);
 
typedef const afw_adaptor_session_t *
(*afw_adaptor_impl_index_get_session_t)(
    const afw_adaptor_impl_index_t * instance,
    afw_xctx_t * xctx);
 
struct afw_adaptor_impl_index_inf_s {
    afw_interface_implementation_rti_t rti;
    afw_adaptor_impl_index_open_t open;
    afw_adaptor_impl_index_release_t release;
    afw_adaptor_impl_index_get_index_definitions_t get_index_definitions;
    afw_adaptor_impl_index_update_index_definitions_t update_index_definitions;
    afw_adaptor_impl_index_add_t add;
    afw_adaptor_impl_index_delete_t delete;
    afw_adaptor_impl_index_replace_t replace;
    afw_adaptor_impl_index_drop_t drop;
    afw_adaptor_impl_index_open_cursor_t open_cursor;
    afw_adaptor_impl_index_get_session_t get_session;
};
 
#define afw_adaptor_impl_index_open( \
    instance, \
    object_type_id, \
    key, \
    integer, \
    unique, \
    reverse, \
    pool, \
    xctx \
) \
(instance)->inf->open( \
    (instance), \
    (object_type_id), \
    (key), \
    (integer), \
    (unique), \
    (reverse), \
    (pool), \
    (xctx) \
)
 
#define afw_adaptor_impl_index_release( \
    instance, \
    xctx \
) \
(instance)->inf->release( \
    (instance), \
    (xctx) \
)
 
#define afw_adaptor_impl_index_get_index_definitions( \
    instance, \
    xctx \
) \
(instance)->inf->get_index_definitions( \
    (instance), \
    (xctx) \
)
 
#define afw_adaptor_impl_index_update_index_definitions( \
    instance, \
    indexDefinitions, \
    xctx \
) \
(instance)->inf->update_index_definitions( \
    (instance), \
    (indexDefinitions), \
    (xctx) \
)
 
#define afw_adaptor_impl_index_add( \
    instance, \
    object_type_id, \
    object_id, \
    key, \
    value, \
    unique, \
    pool, \
    xctx \
) \
(instance)->inf->add( \
    (instance), \
    (object_type_id), \
    (object_id), \
    (key), \
    (value), \
    (unique), \
    (pool), \
    (xctx) \
)
 
#define afw_adaptor_impl_index_delete( \
    instance, \
    object_type_id, \
    object_id, \
    key, \
    value, \
    pool, \
    xctx \
) \
(instance)->inf->delete( \
    (instance), \
    (object_type_id), \
    (object_id), \
    (key), \
    (value), \
    (pool), \
    (xctx) \
)
 
#define afw_adaptor_impl_index_replace( \
    instance, \
    object_type_id, \
    object_id, \
    key, \
    old_value, \
    new_value, \
    pool, \
    xctx \
) \
(instance)->inf->replace( \
    (instance), \
    (object_type_id), \
    (object_id), \
    (key), \
    (old_value), \
    (new_value), \
    (pool), \
    (xctx) \
)
 
#define afw_adaptor_impl_index_drop( \
    instance, \
    object_type_id, \
    key, \
    pool, \
    xctx \
) \
(instance)->inf->drop( \
    (instance), \
    (object_type_id), \
    (key), \
    (pool), \
    (xctx) \
)
 
#define afw_adaptor_impl_index_open_cursor( \
    instance, \
    object_type_id, \
    index_key, \
    operator, \
    value, \
    unique, \
    pool, \
    xctx \
) \
(instance)->inf->open_cursor( \
    (instance), \
    (object_type_id), \
    (index_key), \
    (operator), \
    (value), \
    (unique), \
    (pool), \
    (xctx) \
)
 
#define afw_adaptor_impl_index_get_session( \
    instance, \
    xctx \
) \
(instance)->inf->get_session( \
    (instance), \
    (xctx) \
)
 
struct afw_authorization_handler_factory_s {
    const afw_authorization_handler_factory_inf_t *inf;
    afw_utf8_t authorization_handler_type;
    const afw_utf8_t * description;
};
 
#define AFW_AUTHORIZATION_HANDLER_FACTORY_INTERFACE_NAME \
"afw_authorization_handler_factory"
 
typedef const afw_authorization_handler_t *
(*afw_authorization_handler_factory_create_authorization_handler_cede_p_t)(
    const afw_authorization_handler_factory_t * instance,
    const afw_object_t * properties,
    const afw_pool_t * p,
    afw_xctx_t * xctx);
 
struct afw_authorization_handler_factory_inf_s {
    afw_interface_implementation_rti_t rti;
    afw_authorization_handler_factory_create_authorization_handler_cede_p_t create_authorization_handler_cede_p;
};
 
#define afw_authorization_handler_factory_create_authorization_handler_cede_p( \
    instance, \
    properties, \
    p, \
    xctx \
) \
(instance)->inf->create_authorization_handler_cede_p( \
    (instance), \
    (properties), \
    (p), \
    (xctx) \
)
 
struct afw_authorization_handler_s {
    const afw_authorization_handler_inf_t *inf;
    const afw_pool_t * p;
    afw_utf8_t authorization_handler_id;
    const afw_utf8_t * authorization_handler_type_id;
    const afw_utf8_t * service_id;
    const afw_object_t * properties;
    const afw_utf8_t * source_location;
    const afw_utf8_t * trace_flag_id;
    afw_size_t trace_flag_index;
    const afw_utf8_t * detail_flag_id;
    afw_size_t detail_flag_index;
    const afw_lock_rw_t * authorization_handler_lock_rw;
    afw_integer_t priority;
    afw_boolean_t allow_deny_override;
    afw_boolean_t allow_permit_override;
    afw_boolean_t required;
    const afw_authorization_handler_impl_t * impl;
};
 
#define AFW_AUTHORIZATION_HANDLER_INTERFACE_NAME \
"afw_authorization_handler"
 
typedef void
(*afw_authorization_handler_destroy_t)(
    const afw_authorization_handler_t * instance,
    afw_xctx_t * xctx);
 
typedef const afw_value_t *
(*afw_authorization_handler_check_t)(
    const afw_authorization_handler_t * instance,
    const afw_value_t * resource_id,
    const afw_value_t * object,
    const afw_value_t * action_id,
    const afw_pool_t * p,
    afw_xctx_t * xctx);
 
struct afw_authorization_handler_inf_s {
    afw_interface_implementation_rti_t rti;
    afw_authorization_handler_destroy_t destroy;
    afw_authorization_handler_check_t check;
};
 
#define afw_authorization_handler_destroy( \
    instance, \
    xctx \
) \
(instance)->inf->destroy( \
    (instance), \
    (xctx) \
)
 
#define afw_authorization_handler_check( \
    instance, \
    resource_id, \
    object, \
    action_id, \
    p, \
    xctx \
) \
(instance)->inf->check( \
    (instance), \
    (resource_id), \
    (object), \
    (action_id), \
    (p), \
    (xctx) \
)
 
struct afw_content_type_s {
    const afw_content_type_inf_t *inf;
    afw_utf8_t content_type_id;
    afw_size_t media_type_count;
    const afw_utf8_t * media_types;
};
 
#define AFW_CONTENT_TYPE_INTERFACE_NAME \
"afw_content_type"
 
typedef const afw_value_t *
(*afw_content_type_raw_to_value_t)(
    const afw_content_type_t * instance,
    const afw_memory_t * raw,
    const afw_utf8_t * source_location,
    const afw_pool_t * p,
    afw_xctx_t * xctx);
 
typedef const afw_object_t *
(*afw_content_type_raw_to_object_t)(
    const afw_content_type_t * instance,
    const afw_memory_t * raw,
    const afw_utf8_t * source_location,
    const afw_utf8_t * adaptor_id,
    const afw_utf8_t * object_type_id,
    const afw_utf8_t * object_id,
    afw_boolean_t cede_p,
    const afw_pool_t * p,
    afw_xctx_t * xctx);
 
typedef void
(*afw_content_type_write_value_t)(
    const afw_content_type_t * instance,
    const afw_value_t * value,
    const afw_object_options_t * options,
    void * context,
    afw_write_cb_t callback,
    const afw_pool_t * p,
    afw_xctx_t * xctx);
 
typedef const afw_content_type_object_list_writer_t *
(*afw_content_type_create_object_list_writer_t)(
    const afw_content_type_t * instance,
    const afw_object_options_t * options,
    void * context,
    afw_write_cb_t callback,
    const afw_pool_t * p,
    afw_xctx_t * xctx);
 
struct afw_content_type_inf_s {
    afw_interface_implementation_rti_t rti;
    afw_content_type_raw_to_value_t raw_to_value;
    afw_content_type_raw_to_object_t raw_to_object;
    afw_content_type_write_value_t write_value;
    afw_content_type_create_object_list_writer_t create_object_list_writer;
};
 
#define afw_content_type_raw_to_value( \
    instance, \
    raw, \
    source_location, \
    p, \
    xctx \
) \
(instance)->inf->raw_to_value( \
    (instance), \
    (raw), \
    (source_location), \
    (p), \
    (xctx) \
)
 
#define afw_content_type_raw_to_object( \
    instance, \
    raw, \
    source_location, \
    adaptor_id, \
    object_type_id, \
    object_id, \
    cede_p, \
    p, \
    xctx \
) \
(instance)->inf->raw_to_object( \
    (instance), \
    (raw), \
    (source_location), \
    (adaptor_id), \
    (object_type_id), \
    (object_id), \
    (cede_p), \
    (p), \
    (xctx) \
)
 
#define afw_content_type_write_value( \
    instance, \
    value, \
    options, \
    context, \
    callback, \
    p, \
    xctx \
) \
(instance)->inf->write_value( \
    (instance), \
    (value), \
    (options), \
    (context), \
    (callback), \
    (p), \
    (xctx) \
)
 
#define afw_content_type_create_object_list_writer( \
    instance, \
    options, \
    context, \
    callback, \
    p, \
    xctx \
) \
(instance)->inf->create_object_list_writer( \
    (instance), \
    (options), \
    (context), \
    (callback), \
    (p), \
    (xctx) \
)
 
struct afw_content_type_object_list_writer_s {
    const afw_content_type_object_list_writer_inf_t *inf;
};
 
#define AFW_CONTENT_TYPE_OBJECT_LIST_WRITER_INTERFACE_NAME \
"afw_content_type_object_list_writer"
 
typedef void
(*afw_content_type_object_list_writer_release_t)(
    const afw_content_type_object_list_writer_t * instance,
    afw_xctx_t * xctx);
 
typedef void
(*afw_content_type_object_list_writer_write_object_t)(
    const afw_content_type_object_list_writer_t * instance,
    const afw_object_t * object,
    const afw_pool_t * p,
    afw_xctx_t * xctx);
 
struct afw_content_type_object_list_writer_inf_s {
    afw_interface_implementation_rti_t rti;
    afw_content_type_object_list_writer_release_t release;
    afw_content_type_object_list_writer_write_object_t write_object;
};
 
#define afw_content_type_object_list_writer_release( \
    instance, \
    xctx \
) \
(instance)->inf->release( \
    (instance), \
    (xctx) \
)
 
#define afw_content_type_object_list_writer_write_object( \
    instance, \
    object, \
    p, \
    xctx \
) \
(instance)->inf->write_object( \
    (instance), \
    (object), \
    (p), \
    (xctx) \
)
 
struct afw_data_type_s {
    const afw_data_type_inf_t *inf;
    const afw_object_t * object;
    afw_utf8_t data_type_id;
    afw_utf8_t brief;
    afw_utf8_t description;
    afw_utf8_t data_type_parameter_type;
    int data_type_number;
    afw_utf8_t ldapOid;
    afw_utf8_t jsonPrimitive;
    afw_utf8_t jsonSchemaStringFormat;
    afw_utf8_t cType;
    afw_size_t c_type_size;
    const afw_list_t * empty_list;
    const afw_value_t * empty_list_value;
    const afw_value_inf_t * evaluated_value_inf;
    afw_compile_type_t compile_type;
    afw_boolean_t json_implies_data_type;
    afw_boolean_t evaluated;
    afw_boolean_t directReturn;
    afw_boolean_t relationalCompares;
    afw_boolean_t scalar;
};
 
#define AFW_DATA_TYPE_INTERFACE_NAME \
"afw_data_type"
 
typedef const afw_utf8_t *
(*afw_data_type_internal_to_utf8_t)(
    const afw_data_type_t * instance,
    const void * from_internal,
    const afw_pool_t * p,
    afw_xctx_t * xctx);
 
typedef void
(*afw_data_type_utf8_to_internal_t)(
    const afw_data_type_t * instance,
    void * to_internal,
    const afw_utf8_t * from_utf8,
    const afw_pool_t * p,
    afw_xctx_t * xctx);
 
typedef int
(*afw_data_type_compare_internal_t)(
    const afw_data_type_t * instance,
    const void * internal1,
    const void * internal2,
    afw_xctx_t * xctx);
 
typedef void
(*afw_data_type_convert_internal_t)(
    const afw_data_type_t * instance,
    void * to_internal,
    const void * from_internal,
    const afw_data_type_t * to_data_type,
    const afw_pool_t * p,
    afw_xctx_t * xctx);
 
typedef void
(*afw_data_type_clone_internal_t)(
    const afw_data_type_t * instance,
    void * to_internal,
    const void * from_internal,
    const afw_pool_t * p,
    afw_xctx_t * xctx);
 
typedef void
(*afw_data_type_value_compiler_listing_t)(
    const afw_data_type_t * instance,
    const afw_writer_t * writer,
    const afw_value_t * value,
    afw_xctx_t * xctx);
 
typedef void
(*afw_data_type_write_as_expression_t)(
    const afw_data_type_t * instance,
    const afw_writer_t * writer,
    const void * from_internal,
    afw_xctx_t * xctx);
 
struct afw_data_type_inf_s {
    afw_interface_implementation_rti_t rti;
    afw_data_type_internal_to_utf8_t internal_to_utf8;
    afw_data_type_utf8_to_internal_t utf8_to_internal;
    afw_data_type_compare_internal_t compare_internal;
    afw_data_type_convert_internal_t convert_internal;
    afw_data_type_clone_internal_t clone_internal;
    afw_data_type_value_compiler_listing_t value_compiler_listing;
    afw_data_type_write_as_expression_t write_as_expression;
};
 
#define afw_data_type_internal_to_utf8( \
    instance, \
    from_internal, \
    p, \
    xctx \
) \
(instance)->inf->internal_to_utf8( \
    (instance), \
    (from_internal), \
    (p), \
    (xctx) \
)
 
#define afw_data_type_utf8_to_internal( \
    instance, \
    to_internal, \
    from_utf8, \
    p, \
    xctx \
) \
(instance)->inf->utf8_to_internal( \
    (instance), \
    (to_internal), \
    (from_utf8), \
    (p), \
    (xctx) \
)
 
#define afw_data_type_compare_internal( \
    instance, \
    internal1, \
    internal2, \
    xctx \
) \
(instance)->inf->compare_internal( \
    (instance), \
    (internal1), \
    (internal2), \
    (xctx) \
)
 
#define afw_data_type_convert_internal( \
    instance, \
    to_internal, \
    from_internal, \
    to_data_type, \
    p, \
    xctx \
) \
(instance)->inf->convert_internal( \
    (instance), \
    (to_internal), \
    (from_internal), \
    (to_data_type), \
    (p), \
    (xctx) \
)
 
#define afw_data_type_clone_internal( \
    instance, \
    to_internal, \
    from_internal, \
    p, \
    xctx \
) \
(instance)->inf->clone_internal( \
    (instance), \
    (to_internal), \
    (from_internal), \
    (p), \
    (xctx) \
)
 
#define afw_data_type_value_compiler_listing( \
    instance, \
    writer, \
    value, \
    xctx \
) \
(instance)->inf->value_compiler_listing( \
    (instance), \
    (writer), \
    (value), \
    (xctx) \
)
 
#define afw_data_type_write_as_expression( \
    instance, \
    writer, \
    from_internal, \
    xctx \
) \
(instance)->inf->write_as_expression( \
    (instance), \
    (writer), \
    (from_internal), \
    (xctx) \
)
 
struct afw_list_setter_s {
    const afw_list_setter_inf_t *inf;
    const afw_list_t * list;
};
 
#define AFW_LIST_SETTER_INTERFACE_NAME \
"afw_list_setter"
 
typedef void
(*afw_list_setter_set_immutable_t)(
    const afw_list_setter_t * instance,
    afw_xctx_t * xctx);
 
typedef const afw_data_type_t *
(*afw_list_setter_determine_data_type_and_set_immutable_t)(
    const afw_list_setter_t * instance,
    afw_xctx_t * xctx);
 
typedef void
(*afw_list_setter_add_internal_t)(
    const afw_list_setter_t * instance,
    const afw_data_type_t * data_type,
    const void * internal,
    afw_xctx_t * xctx);
 
typedef void
(*afw_list_setter_add_value_t)(
    const afw_list_setter_t * instance,
    const afw_value_t * value,
    afw_xctx_t * xctx);
 
typedef void
(*afw_list_setter_insert_internal_t)(
    const afw_list_setter_t * instance,
    const afw_data_type_t * data_type,
    const void * internal,
    afw_size_t index,
    afw_xctx_t * xctx);
 
typedef void
(*afw_list_setter_insert_value_t)(
    const afw_list_setter_t * instance,
    const afw_value_t * value,
    afw_size_t index,
    afw_xctx_t * xctx);
 
typedef void
(*afw_list_setter_remove_all_values_t)(
    const afw_list_setter_t * instance,
    afw_xctx_t * xctx);
 
typedef void
(*afw_list_setter_remove_internal_t)(
    const afw_list_setter_t * instance,
    const afw_data_type_t * data_type,
    const void * internal,
    afw_xctx_t * xctx);
 
typedef void
(*afw_list_setter_remove_value_t)(
    const afw_list_setter_t * instance,
    const afw_value_t * value,
    afw_xctx_t * xctx);
 
typedef void
(*afw_list_setter_set_value_by_index_t)(
    const afw_list_setter_t * instance,
    afw_size_t index,
    const afw_value_t * value,
    afw_xctx_t * xctx);
 
struct afw_list_setter_inf_s {
    afw_interface_implementation_rti_t rti;
    afw_list_setter_set_immutable_t set_immutable;
    afw_list_setter_determine_data_type_and_set_immutable_t determine_data_type_and_set_immutable;
    afw_list_setter_add_internal_t add_internal;
    afw_list_setter_add_value_t add_value;
    afw_list_setter_insert_internal_t insert_internal;
    afw_list_setter_insert_value_t insert_value;
    afw_list_setter_remove_all_values_t remove_all_values;
    afw_list_setter_remove_internal_t remove_internal;
    afw_list_setter_remove_value_t remove_value;
    afw_list_setter_set_value_by_index_t set_value_by_index;
};
 
#define afw_list_setter_set_immutable( \
    instance, \
    xctx \
) \
(instance)->inf->set_immutable( \
    (instance), \
    (xctx) \
)
 
#define afw_list_setter_determine_data_type_and_set_immutable( \
    instance, \
    xctx \
) \
(instance)->inf->determine_data_type_and_set_immutable( \
    (instance), \
    (xctx) \
)
 
#define afw_list_setter_add_internal( \
    instance, \
    data_type, \
    internal, \
    xctx \
) \
(instance)->inf->add_internal( \
    (instance), \
    (data_type), \
    (internal), \
    (xctx) \
)
 
#define afw_list_setter_add_value( \
    instance, \
    value, \
    xctx \
) \
(instance)->inf->add_value( \
    (instance), \
    (value), \
    (xctx) \
)
 
#define afw_list_setter_insert_internal( \
    instance, \
    data_type, \
    internal, \
    index, \
    xctx \
) \
(instance)->inf->insert_internal( \
    (instance), \
    (data_type), \
    (internal), \
    (index), \
    (xctx) \
)
 
#define afw_list_setter_insert_value( \
    instance, \
    value, \
    index, \
    xctx \
) \
(instance)->inf->insert_value( \
    (instance), \
    (value), \
    (index), \
    (xctx) \
)
 
#define afw_list_setter_remove_all_values( \
    instance, \
    xctx \
) \
(instance)->inf->remove_all_values( \
    (instance), \
    (xctx) \
)
 
#define afw_list_setter_remove_internal( \
    instance, \
    data_type, \
    internal, \
    xctx \
) \
(instance)->inf->remove_internal( \
    (instance), \
    (data_type), \
    (internal), \
    (xctx) \
)
 
#define afw_list_setter_remove_value( \
    instance, \
    value, \
    xctx \
) \
(instance)->inf->remove_value( \
    (instance), \
    (value), \
    (xctx) \
)
 
#define afw_list_setter_set_value_by_index( \
    instance, \
    index, \
    value, \
    xctx \
) \
(instance)->inf->set_value_by_index( \
    (instance), \
    (index), \
    (value), \
    (xctx) \
)
 
struct afw_list_s {
    const afw_list_inf_t *inf;
};
 
#define AFW_LIST_INTERFACE_NAME \
"afw_list"
 
typedef void
(*afw_list_release_t)(
    const afw_list_t * instance,
    afw_xctx_t * xctx);
 
typedef afw_size_t
(*afw_list_get_count_t)(
    const afw_list_t * instance,
    afw_xctx_t * xctx);
 
typedef const afw_data_type_t *
(*afw_list_get_data_type_t)(
    const afw_list_t * instance,
    afw_xctx_t * xctx);
 
typedef const afw_value_t *
(*afw_list_get_entry_meta_t)(
    const afw_list_t * instance,
    afw_integer_t index,
    const afw_pool_t * p,
    afw_xctx_t * xctx);
 
typedef afw_boolean_t
(*afw_list_get_entry_internal_t)(
    const afw_list_t * instance,
    afw_integer_t index,
    const afw_data_type_t * * data_type,
    const void * * internal,
    afw_xctx_t * xctx);
 
typedef const afw_value_t *
(*afw_list_get_entry_value_t)(
    const afw_list_t * instance,
    afw_integer_t index,
    const afw_pool_t * p,
    afw_xctx_t * xctx);
 
typedef const afw_value_t *
(*afw_list_get_next_entry_meta_t)(
    const afw_list_t * instance,
    const afw_iterator_t * * iterator,
    const afw_pool_t * p,
    afw_xctx_t * xctx);
 
typedef afw_boolean_t
(*afw_list_get_next_internal_t)(
    const afw_list_t * instance,
    const afw_iterator_t * * iterator,
    const afw_data_type_t * * data_type,
    const void * * internal,
    afw_xctx_t * xctx);
 
typedef const afw_value_t *
(*afw_list_get_next_value_t)(
    const afw_list_t * instance,
    const afw_iterator_t * * iterator,
    const afw_pool_t * p,
    afw_xctx_t * xctx);
 
typedef const afw_list_setter_t *
(*afw_list_get_setter_t)(
    const afw_list_t * instance,
    afw_xctx_t * xctx);
 
struct afw_list_inf_s {
    afw_interface_implementation_rti_t rti;
    afw_list_release_t release;
    afw_list_get_count_t get_count;
    afw_list_get_data_type_t get_data_type;
    afw_list_get_entry_meta_t get_entry_meta;
    afw_list_get_entry_internal_t get_entry_internal;
    afw_list_get_entry_value_t get_entry_value;
    afw_list_get_next_entry_meta_t get_next_entry_meta;
    afw_list_get_next_internal_t get_next_internal;
    afw_list_get_next_value_t get_next_value;
    afw_list_get_setter_t get_setter;
};
 
#define afw_list_release( \
    instance, \
    xctx \
) \
(instance)->inf->release( \
    (instance), \
    (xctx) \
)
 
#define afw_list_get_count( \
    instance, \
    xctx \
) \
(instance)->inf->get_count( \
    (instance), \
    (xctx) \
)
 
#define afw_list_get_data_type( \
    instance, \
    xctx \
) \
(instance)->inf->get_data_type( \
    (instance), \
    (xctx) \
)
 
#define afw_list_get_entry_meta( \
    instance, \
    index, \
    p, \
    xctx \
) \
(instance)->inf->get_entry_meta( \
    (instance), \
    (index), \
    (p), \
    (xctx) \
)
 
#define afw_list_get_entry_internal( \
    instance, \
    index, \
    data_type, \
    internal, \
    xctx \
) \
(instance)->inf->get_entry_internal( \
    (instance), \
    (index), \
    (data_type), \
    (internal), \
    (xctx) \
)
 
#define afw_list_get_entry_value( \
    instance, \
    index, \
    p, \
    xctx \
) \
(instance)->inf->get_entry_value( \
    (instance), \
    (index), \
    (p), \
    (xctx) \
)
 
#define afw_list_get_next_entry_meta( \
    instance, \
    iterator, \
    p, \
    xctx \
) \
(instance)->inf->get_next_entry_meta( \
    (instance), \
    (iterator), \
    (p), \
    (xctx) \
)
 
#define afw_list_get_next_internal( \
    instance, \
    iterator, \
    data_type, \
    internal, \
    xctx \
) \
(instance)->inf->get_next_internal( \
    (instance), \
    (iterator), \
    (data_type), \
    (internal), \
    (xctx) \
)
 
#define afw_list_get_next_value( \
    instance, \
    iterator, \
    p, \
    xctx \
) \
(instance)->inf->get_next_value( \
    (instance), \
    (iterator), \
    (p), \
    (xctx) \
)
 
#define afw_list_get_setter( \
    instance, \
    xctx \
) \
(instance)->inf->get_setter( \
    (instance), \
    (xctx) \
)
 
struct afw_log_factory_s {
    const afw_log_factory_inf_t *inf;
    afw_utf8_t log_type;
    const afw_utf8_t * description;
};
 
#define AFW_LOG_FACTORY_INTERFACE_NAME \
"afw_log_factory"
 
typedef const afw_log_t *
(*afw_log_factory_create_log_cede_p_t)(
    const afw_log_factory_t * instance,
    const afw_object_t * properties,
    const afw_pool_t * p,
    afw_xctx_t * xctx);
 
struct afw_log_factory_inf_s {
    afw_interface_implementation_rti_t rti;
    afw_log_factory_create_log_cede_p_t create_log_cede_p;
};
 
#define afw_log_factory_create_log_cede_p( \
    instance, \
    properties, \
    p, \
    xctx \
) \
(instance)->inf->create_log_cede_p( \
    (instance), \
    (properties), \
    (p), \
    (xctx) \
)
 
struct afw_log_s {
    const afw_log_inf_t *inf;
    const afw_pool_t * p;
    afw_utf8_t log_id;
    const afw_utf8_t * service_id;
    const afw_object_t * properties;
    const afw_utf8_t * source_location;
    const afw_log_impl_t * impl;
};
 
#define AFW_LOG_INTERFACE_NAME \
"afw_log"
 
typedef void
(*afw_log_destroy_t)(
    const afw_log_t * instance,
    afw_xctx_t * xctx);
 
typedef void
(*afw_log_set_own_mask_t)(
    const afw_log_t * instance,
    afw_log_priority_mask_t mask,
    afw_xctx_t * xctx);
 
typedef void
(*afw_log_write_t)(
    const afw_log_t * instance,
    afw_log_priority_t priority,
    const afw_utf8_z_t * source_z,
    const afw_utf8_t * message,
    afw_xctx_t * xctx);
 
struct afw_log_inf_s {
    afw_interface_implementation_rti_t rti;
    afw_log_destroy_t destroy;
    afw_log_set_own_mask_t set_own_mask;
    afw_log_write_t write;
};
 
#define afw_log_destroy( \
    instance, \
    xctx \
) \
(instance)->inf->destroy( \
    (instance), \
    (xctx) \
)
 
#define afw_log_set_own_mask( \
    instance, \
    mask, \
    xctx \
) \
(instance)->inf->set_own_mask( \
    (instance), \
    (mask), \
    (xctx) \
)
 
#define afw_log_write( \
    instance, \
    priority, \
    source_z, \
    message, \
    xctx \
) \
(instance)->inf->write( \
    (instance), \
    (priority), \
    (source_z), \
    (message), \
    (xctx) \
)
 
struct afw_object_setter_s {
    const afw_object_setter_inf_t *inf;
    const afw_object_t * object;
};
 
#define AFW_OBJECT_SETTER_INTERFACE_NAME \
"afw_object_setter"
 
typedef void
(*afw_object_setter_set_immutable_t)(
    const afw_object_setter_t * instance,
    afw_xctx_t * xctx);
 
typedef void
(*afw_object_setter_set_property_t)(
    const afw_object_setter_t * instance,
    const afw_utf8_t * property_name,
    const afw_value_t * value,
    afw_xctx_t * xctx);
 
struct afw_object_setter_inf_s {
    afw_interface_implementation_rti_t rti;
    afw_object_setter_set_immutable_t set_immutable;
    afw_object_setter_set_property_t set_property;
};
 
#define afw_object_setter_set_immutable( \
    instance, \
    xctx \
) \
(instance)->inf->set_immutable( \
    (instance), \
    (xctx) \
)
 
#define afw_object_setter_set_property( \
    instance, \
    property_name, \
    value, \
    xctx \
) \
(instance)->inf->set_property( \
    (instance), \
    (property_name), \
    (value), \
    (xctx) \
)
 
struct afw_object_s {
    const afw_object_inf_t *inf;
    const afw_pool_t * p;
    afw_object_meta_t meta;
};
 
#define AFW_OBJECT_INTERFACE_NAME \
"afw_object"
 
typedef void
(*afw_object_release_t)(
    const afw_object_t * instance,
    afw_xctx_t * xctx);
 
typedef void
(*afw_object_add_reference_t)(
    const afw_object_t * instance,
    afw_xctx_t * xctx);
 
typedef afw_size_t
(*afw_object_get_count_t)(
    const afw_object_t * instance,
    afw_xctx_t * xctx);
 
typedef const afw_value_t *
(*afw_object_get_meta_t)(
    const afw_object_t * instance,
    const afw_pool_t * p,
    afw_xctx_t * xctx);
 
typedef const afw_value_t *
(*afw_object_get_property_t)(
    const afw_object_t * instance,
    const afw_utf8_t * property_name,
    afw_xctx_t * xctx);
 
typedef const afw_value_t *
(*afw_object_get_property_meta_t)(
    const afw_object_t * instance,
    const afw_utf8_t * property_name,
    const afw_pool_t * p,
    afw_xctx_t * xctx);
 
typedef const afw_value_t *
(*afw_object_get_next_property_t)(
    const afw_object_t * instance,
    const afw_iterator_t * * iterator,
    const afw_utf8_t * * property_name,
    afw_xctx_t * xctx);
 
typedef const afw_value_t *
(*afw_object_get_next_property_meta_t)(
    const afw_object_t * instance,
    const afw_iterator_t * * iterator,
    const afw_utf8_t * * property_name,
    const afw_pool_t * p,
    afw_xctx_t * xctx);
 
typedef afw_boolean_t
(*afw_object_has_property_t)(
    const afw_object_t * instance,
    const afw_utf8_t * property_name,
    afw_xctx_t * xctx);
 
typedef const afw_object_setter_t *
(*afw_object_get_setter_t)(
    const afw_object_t * instance,
    afw_xctx_t * xctx);
 
struct afw_object_inf_s {
    afw_interface_implementation_rti_t rti;
    afw_object_release_t release;
    afw_object_add_reference_t add_reference;
    afw_object_get_count_t get_count;
    afw_object_get_meta_t get_meta;
    afw_object_get_property_t get_property;
    afw_object_get_property_meta_t get_property_meta;
    afw_object_get_next_property_t get_next_property;
    afw_object_get_next_property_meta_t get_next_property_meta;
    afw_object_has_property_t has_property;
    afw_object_get_setter_t get_setter;
};
 
#define afw_object_release( \
    instance, \
    xctx \
) \
(instance)->inf->release( \
    (instance), \
    (xctx) \
)
 
#define afw_object_add_reference( \
    instance, \
    xctx \
) \
(instance)->inf->add_reference( \
    (instance), \
    (xctx) \
)
 
#define afw_object_get_count( \
    instance, \
    xctx \
) \
(instance)->inf->get_count( \
    (instance), \
    (xctx) \
)
 
#define afw_object_get_meta( \
    instance, \
    p, \
    xctx \
) \
(instance)->inf->get_meta( \
    (instance), \
    (p), \
    (xctx) \
)
 
#define afw_object_get_property( \
    instance, \
    property_name, \
    xctx \
) \
(instance)->inf->get_property( \
    (instance), \
    (property_name), \
    (xctx) \
)
 
#define afw_object_get_property_meta( \
    instance, \
    property_name, \
    p, \
    xctx \
) \
(instance)->inf->get_property_meta( \
    (instance), \
    (property_name), \
    (p), \
    (xctx) \
)
 
#define afw_object_get_next_property( \
    instance, \
    iterator, \
    property_name, \
    xctx \
) \
(instance)->inf->get_next_property( \
    (instance), \
    (iterator), \
    (property_name), \
    (xctx) \
)
 
#define afw_object_get_next_property_meta( \
    instance, \
    iterator, \
    property_name, \
    p, \
    xctx \
) \
(instance)->inf->get_next_property_meta( \
    (instance), \
    (iterator), \
    (property_name), \
    (p), \
    (xctx) \
)
 
#define afw_object_has_property( \
    instance, \
    property_name, \
    xctx \
) \
(instance)->inf->has_property( \
    (instance), \
    (property_name), \
    (xctx) \
)
 
#define afw_object_get_setter( \
    instance, \
    xctx \
) \
(instance)->inf->get_setter( \
    (instance), \
    (xctx) \
)
 
struct afw_server_s {
    const afw_server_inf_t *inf;
    afw_xctx_t * xctx;
    const afw_object_t * properties;
    const afw_utf8_t * afw_compiled_version;
    const afw_utf8_t * afw_version;
    AFW_ATOMIC afw_integer_t concurrent;
    AFW_ATOMIC afw_integer_t max_concurrent;
    AFW_ATOMIC afw_integer_t request_count;
    const afw_utf8_t * server_type;
    const afw_utf8_t * server_version;
    const afw_dateTime_t * start_time;
    AFW_ATOMIC afw_integer_t thread_count;
    AFW_ATOMIC afw_integer_t unhandled_errors;
};
 
#define AFW_SERVER_INTERFACE_NAME \
"afw_server"
 
typedef void
(*afw_server_release_t)(
    const afw_server_t * instance,
    afw_xctx_t * xctx);
 
typedef void
(*afw_server_run_t)(
    const afw_server_t * instance,
    const afw_request_handler_t * handler,
    afw_xctx_t * xctx);
 
struct afw_server_inf_s {
    afw_interface_implementation_rti_t rti;
    afw_server_release_t release;
    afw_server_run_t run;
};
 
#define afw_server_release( \
    instance, \
    xctx \
) \
(instance)->inf->release( \
    (instance), \
    (xctx) \
)
 
#define afw_server_run( \
    instance, \
    handler, \
    xctx \
) \
(instance)->inf->run( \
    (instance), \
    (handler), \
    (xctx) \
)
 
struct afw_service_type_s {
    const afw_service_type_inf_t *inf;
    afw_utf8_t service_type_id;
    const afw_utf8_t * title;
    const afw_utf8_t * description;
    const afw_environment_conf_type_t * conf_type;
    const afw_object_t * conf_type_object;
};
 
#define AFW_SERVICE_TYPE_INTERFACE_NAME \
"afw_service_type"
 
typedef afw_integer_t
(*afw_service_type_related_instance_count_t)(
    const afw_service_type_t * instance,
    const afw_utf8_t * id,
    afw_xctx_t * xctx);
 
typedef void
(*afw_service_type_start_cede_p_t)(
    const afw_service_type_t * instance,
    const afw_object_t * properties,
    const afw_pool_t * p,
    afw_xctx_t * xctx);
 
typedef void
(*afw_service_type_stop_t)(
    const afw_service_type_t * instance,
    const afw_utf8_t * id,
    afw_xctx_t * xctx);
 
typedef void
(*afw_service_type_restart_cede_p_t)(
    const afw_service_type_t * instance,
    const afw_object_t * properties,
    const afw_pool_t * p,
    afw_xctx_t * xctx);
 
struct afw_service_type_inf_s {
    afw_interface_implementation_rti_t rti;
    afw_service_type_related_instance_count_t related_instance_count;
    afw_service_type_start_cede_p_t start_cede_p;
    afw_service_type_stop_t stop;
    afw_service_type_restart_cede_p_t restart_cede_p;
};
 
#define afw_service_type_related_instance_count( \
    instance, \
    id, \
    xctx \
) \
(instance)->inf->related_instance_count( \
    (instance), \
    (id), \
    (xctx) \
)
 
#define afw_service_type_start_cede_p( \
    instance, \
    properties, \
    p, \
    xctx \
) \
(instance)->inf->start_cede_p( \
    (instance), \
    (properties), \
    (p), \
    (xctx) \
)
 
#define afw_service_type_stop( \
    instance, \
    id, \
    xctx \
) \
(instance)->inf->stop( \
    (instance), \
    (id), \
    (xctx) \
)
 
#define afw_service_type_restart_cede_p( \
    instance, \
    properties, \
    p, \
    xctx \
) \
(instance)->inf->restart_cede_p( \
    (instance), \
    (properties), \
    (p), \
    (xctx) \
)
 
struct afw_object_associative_array_s {
    const afw_object_associative_array_inf_t *inf;
    const afw_pool_t * p;
};
 
#define AFW_OBJECT_ASSOCIATIVE_ARRAY_INTERFACE_NAME \
"afw_object_associative_array"
 
typedef void
(*afw_object_associative_array_release_t)(
    const afw_object_associative_array_t * instance,
    afw_xctx_t * xctx);
 
typedef void
(*afw_object_associative_array_add_reference_t)(
    const afw_object_associative_array_t * instance,
    afw_xctx_t * xctx);
 
typedef const afw_object_t *
(*afw_object_associative_array_get_t)(
    const afw_object_associative_array_t * instance,
    const afw_utf8_t * key,
    afw_xctx_t * xctx);
 
typedef const afw_object_t *
(*afw_object_associative_array_get_reference_t)(
    const afw_object_associative_array_t * instance,
    const afw_utf8_t * key,
    afw_xctx_t * xctx);
 
typedef void
(*afw_object_associative_array_for_each_t)(
    const afw_object_associative_array_t * instance,
    void * context,
    afw_object_cb_t cb,
    afw_xctx_t * xctx);
 
typedef void
(*afw_object_associative_array_set_t)(
    const afw_object_associative_array_t * instance,
    const afw_utf8_t * key,
    const afw_object_t * object,
    afw_xctx_t * xctx);
 
struct afw_object_associative_array_inf_s {
    afw_interface_implementation_rti_t rti;
    afw_object_associative_array_release_t release;
    afw_object_associative_array_add_reference_t add_reference;
    afw_object_associative_array_get_t get;
    afw_object_associative_array_get_reference_t get_reference;
    afw_object_associative_array_for_each_t for_each;
    afw_object_associative_array_set_t set;
};
 
#define afw_object_associative_array_release( \
    instance, \
    xctx \
) \
(instance)->inf->release( \
    (instance), \
    (xctx) \
)
 
#define afw_object_associative_array_add_reference( \
    instance, \
    xctx \
) \
(instance)->inf->add_reference( \
    (instance), \
    (xctx) \
)
 
#define afw_object_associative_array_get( \
    instance, \
    key, \
    xctx \
) \
(instance)->inf->get( \
    (instance), \
    (key), \
    (xctx) \
)
 
#define afw_object_associative_array_get_reference( \
    instance, \
    key, \
    xctx \
) \
(instance)->inf->get_reference( \
    (instance), \
    (key), \
    (xctx) \
)
 
#define afw_object_associative_array_for_each( \
    instance, \
    context, \
    cb, \
    xctx \
) \
(instance)->inf->for_each( \
    (instance), \
    (context), \
    (cb), \
    (xctx) \
)
 
#define afw_object_associative_array_set( \
    instance, \
    key, \
    object, \
    xctx \
) \
(instance)->inf->set( \
    (instance), \
    (key), \
    (object), \
    (xctx) \
)
 
struct afw_request_handler_factory_s {
    const afw_request_handler_factory_inf_t *inf;
    afw_utf8_t request_handler_type;
    const afw_utf8_t * description;
};
 
#define AFW_REQUEST_HANDLER_FACTORY_INTERFACE_NAME \
"afw_request_handler_factory"
 
typedef const afw_request_handler_t *
(*afw_request_handler_factory_create_request_handler_cede_p_t)(
    const afw_request_handler_factory_t * instance,
    const afw_object_t * properties,
    const afw_pool_t * p,
    afw_xctx_t * xctx);
 
struct afw_request_handler_factory_inf_s {
    afw_interface_implementation_rti_t rti;
    afw_request_handler_factory_create_request_handler_cede_p_t create_request_handler_cede_p;
};
 
#define afw_request_handler_factory_create_request_handler_cede_p( \
    instance, \
    properties, \
    p, \
    xctx \
) \
(instance)->inf->create_request_handler_cede_p( \
    (instance), \
    (properties), \
    (p), \
    (xctx) \
)
 
struct afw_request_handler_s {
    const afw_request_handler_inf_t *inf;
};
 
#define AFW_REQUEST_HANDLER_INTERFACE_NAME \
"afw_request_handler"
 
typedef void
(*afw_request_handler_release_t)(
    const afw_request_handler_t * instance,
    afw_xctx_t * xctx);
 
typedef void
(*afw_request_handler_process_t)(
    const afw_request_handler_t * instance,
    const afw_request_t * request,
    afw_xctx_t * xctx);
 
struct afw_request_handler_inf_s {
    afw_interface_implementation_rti_t rti;
    afw_request_handler_release_t release;
    afw_request_handler_process_t process;
};
 
#define afw_request_handler_release( \
    instance, \
    xctx \
) \
(instance)->inf->release( \
    (instance), \
    (xctx) \
)
 
#define afw_request_handler_process( \
    instance, \
    request, \
    xctx \
) \
(instance)->inf->process( \
    (instance), \
    (request), \
    (xctx) \
)
 
struct afw_connection_s {
    const afw_connection_inf_t *inf;
};
 
#define AFW_CONNECTION_INTERFACE_NAME \
"afw_connection"
 
typedef void
(*afw_connection_release_t)(
    const afw_connection_t * instance,
    afw_xctx_t * xctx);
 
struct afw_connection_inf_s {
    afw_interface_implementation_rti_t rti;
    afw_connection_release_t release;
};
 
#define afw_connection_release( \
    instance, \
    xctx \
) \
(instance)->inf->release( \
    (instance), \
    (xctx) \
)
 
struct afw_request_s {
    const afw_request_inf_t *inf;
    afw_xctx_t * xctx;
    afw_read_cb_t read_content_cb;
    afw_write_cb_t write_content_cb;
    const afw_object_t * properties;
    const afw_utf8_t * method;
    const afw_utf8_t * uri;
    const afw_utf8_t * query_string;
    const afw_utf8_t * content_type;
    afw_size_t content_length;
    const afw_utf8_t * const * accept;
    const afw_object_t * error_info;
    const afw_content_type_t * response_content_type;
    afw_boolean_t is_closed;
};
 
#define AFW_REQUEST_INTERFACE_NAME \
"afw_request"
 
typedef void
(*afw_request_release_t)(
    const afw_request_t * instance,
    afw_xctx_t * xctx);
 
typedef void
(*afw_request_set_error_info_t)(
    const afw_request_t * instance,
    const afw_object_t * error_info,
    afw_xctx_t * xctx);
 
typedef void
(*afw_request_read_raw_request_body_t)(
    const afw_request_t * instance,
    afw_size_t buffer_size,
    void * buffer,
    afw_size_t * size,
    afw_boolean_t * more_to_read,
    afw_xctx_t * xctx);
 
typedef void
(*afw_request_set_response_status_code_t)(
    const afw_request_t * instance,
    const afw_utf8_t * code,
    const afw_utf8_t * reason,
    afw_xctx_t * xctx);
 
typedef void
(*afw_request_write_response_header_t)(
    const afw_request_t * instance,
    const afw_utf8_t * name,
    const afw_utf8_t * value,
    afw_xctx_t * xctx);
 
typedef void
(*afw_request_write_raw_response_body_t)(
    const afw_request_t * instance,
    afw_size_t size,
    const void * buffer,
    afw_xctx_t * xctx);
 
typedef void
(*afw_request_flush_response_t)(
    const afw_request_t * instance,
    afw_xctx_t * xctx);
 
typedef void
(*afw_request_finish_response_t)(
    const afw_request_t * instance,
    afw_xctx_t * xctx);
 
struct afw_request_inf_s {
    afw_interface_implementation_rti_t rti;
    afw_request_release_t release;
    afw_request_set_error_info_t set_error_info;
    afw_request_read_raw_request_body_t read_raw_request_body;
    afw_request_set_response_status_code_t set_response_status_code;
    afw_request_write_response_header_t write_response_header;
    afw_request_write_raw_response_body_t write_raw_response_body;
    afw_request_flush_response_t flush_response;
    afw_request_finish_response_t finish_response;
};
 
#define afw_request_release( \
    instance, \
    xctx \
) \
(instance)->inf->release( \
    (instance), \
    (xctx) \
)
 
#define afw_request_set_error_info( \
    instance, \
    error_info, \
    xctx \
) \
(instance)->inf->set_error_info( \
    (instance), \
    (error_info), \
    (xctx) \
)
 
#define afw_request_read_raw_request_body( \
    instance, \
    buffer_size, \
    buffer, \
    size, \
    more_to_read, \
    xctx \
) \
(instance)->inf->read_raw_request_body( \
    (instance), \
    (buffer_size), \
    (buffer), \
    (size), \
    (more_to_read), \
    (xctx) \
)
 
#define afw_request_set_response_status_code( \
    instance, \
    code, \
    reason, \
    xctx \
) \
(instance)->inf->set_response_status_code( \
    (instance), \
    (code), \
    (reason), \
    (xctx) \
)
 
#define afw_request_write_response_header( \
    instance, \
    name, \
    value, \
    xctx \
) \
(instance)->inf->write_response_header( \
    (instance), \
    (name), \
    (value), \
    (xctx) \
)
 
#define afw_request_write_raw_response_body( \
    instance, \
    size, \
    buffer, \
    xctx \
) \
(instance)->inf->write_raw_response_body( \
    (instance), \
    (size), \
    (buffer), \
    (xctx) \
)
 
#define afw_request_flush_response( \
    instance, \
    xctx \
) \
(instance)->inf->flush_response( \
    (instance), \
    (xctx) \
)
 
#define afw_request_finish_response( \
    instance, \
    xctx \
) \
(instance)->inf->finish_response( \
    (instance), \
    (xctx) \
)
 
struct afw_xctx_s {
    const afw_xctx_inf_t *inf;
    const afw_pool_t * p;
    const afw_utf8_t * name;
    afw_xctx_t * parent;
    const afw_environment_t * env;
    const afw_thread_t * thread;
    const afw_request_t * request;
    const afw_utf8_t * uuid;
    const afw_object_t * properties;
    const afw_value_t * mode;
    const afw_stream_anchor_t * stream_anchor;
    afw_integer_t write_sequence;
    void * priv;
    afw_error_t * error;
    afw_try_t * current_try;
    const afw_runtime_objects_t * runtime_objects;
    afw_xctx_evaluation_stack_t * evaluation_stack;
    apr_array_header_t * stack;
    const afw_xctx_qualifier_stack_t * qualifier_stack;
    int current_frame_index;
    afw_adaptor_xctx_internal_t * adaptor_xctx_internal;
    afw_adaptor_internal_cache_t * cache;
    afw_dateTime_t local_dateTime_when_created;
    afw_dateTime_t utc_dateTime_when_created;
    afw_size_t flags_count;
    const afw_boolean_t * flags;
    afw_boolean_t flags_is_mutable_copy;
    void * libxml2_error_func;
    afw_boolean_t secure;
};
 
#define AFW_XCTX_INTERFACE_NAME \
"afw_xctx"
 
typedef void
(*afw_xctx_release_t)(
    afw_xctx_t * instance,
    afw_xctx_t * xctx);
 
struct afw_xctx_inf_s {
    afw_interface_implementation_rti_t rti;
    afw_xctx_release_t release;
};
 
#define afw_xctx_release( \
    instance, \
    xctx \
) \
(instance)->inf->release( \
    (instance), \
    (xctx) \
)
 
struct afw_stream_s {
    const afw_stream_inf_t *inf;
    const afw_pool_t * p;
    const afw_utf8_t * streamId;
    afw_read_cb_t read_cb;
    afw_write_cb_t write_cb;
    const afw_boolean_t is_standard;
};
 
#define AFW_STREAM_INTERFACE_NAME \
"afw_stream"
 
typedef void
(*afw_stream_release_t)(
    const afw_stream_t * instance,
    afw_xctx_t * xctx);
 
typedef void
(*afw_stream_flush_t)(
    const afw_stream_t * instance,
    afw_xctx_t * xctx);
 
typedef void
(*afw_stream_read_t)(
    const afw_stream_t * instance,
    const void * buffer,
    afw_size_t size,
    afw_xctx_t * xctx);
 
typedef void
(*afw_stream_write_t)(
    const afw_stream_t * instance,
    const void * buffer,
    afw_size_t size,
    afw_xctx_t * xctx);
 
struct afw_stream_inf_s {
    afw_interface_implementation_rti_t rti;
    afw_stream_release_t release;
    afw_stream_flush_t flush;
    afw_stream_read_t read;
    afw_stream_write_t write;
};
 
#define afw_stream_release( \
    instance, \
    xctx \
) \
(instance)->inf->release( \
    (instance), \
    (xctx) \
)
 
#define afw_stream_flush( \
    instance, \
    xctx \
) \
(instance)->inf->flush( \
    (instance), \
    (xctx) \
)
 
#define afw_stream_read( \
    instance, \
    buffer, \
    size, \
    xctx \
) \
(instance)->inf->read( \
    (instance), \
    (buffer), \
    (size), \
    (xctx) \
)
 
#define afw_stream_write( \
    instance, \
    buffer, \
    size, \
    xctx \
) \
(instance)->inf->write( \
    (instance), \
    (buffer), \
    (size), \
    (xctx) \
)
 
struct afw_pool_s {
    const afw_pool_inf_t *inf;
};
 
#define AFW_POOL_INTERFACE_NAME \
"afw_pool"
 
typedef void
(*afw_pool_release_t)(
    const afw_pool_t * instance,
    afw_xctx_t * xctx);
 
typedef void
(*afw_pool_add_reference_t)(
    const afw_pool_t * instance,
    afw_xctx_t * xctx);
 
typedef void
(*afw_pool_destroy_t)(
    const afw_pool_t * instance,
    afw_xctx_t * xctx);
 
typedef apr_pool_t *
(*afw_pool_get_apr_pool_t)(
    const afw_pool_t * instance);
 
typedef void *
(*afw_pool_calloc_t)(
    const afw_pool_t * instance,
    afw_size_t size,
    afw_xctx_t * xctx);
 
typedef void *
(*afw_pool_malloc_t)(
    const afw_pool_t * instance,
    afw_size_t size,
    afw_xctx_t * xctx);
 
typedef void
(*afw_pool_free_t)(
    const afw_pool_t * instance,
    void * address,
    afw_size_t size,
    afw_xctx_t * xctx);
 
typedef void
(*afw_pool_register_cleanup_before_t)(
    const afw_pool_t * instance,
    void * data,
    void * data2,
    afw_pool_cleanup_function_p_t cleanup,
    afw_xctx_t * xctx);
 
typedef void
(*afw_pool_deregister_cleanup_t)(
    const afw_pool_t * instance,
    void * data,
    void * data2,
    afw_pool_cleanup_function_p_t cleanup,
    afw_xctx_t * xctx);
 
typedef void
(*afw_pool_release_debug_t)(
    const afw_pool_t * instance,
    afw_xctx_t * xctx,
    const afw_utf8_z_t * source_z);
 
typedef void
(*afw_pool_add_reference_debug_t)(
    const afw_pool_t * instance,
    afw_xctx_t * xctx,
    const afw_utf8_z_t * source_z);
 
typedef void
(*afw_pool_destroy_debug_t)(
    const afw_pool_t * instance,
    afw_xctx_t * xctx,
    const afw_utf8_z_t * source_z);
 
typedef void *
(*afw_pool_calloc_debug_t)(
    const afw_pool_t * instance,
    afw_size_t size,
    afw_xctx_t * xctx,
    const afw_utf8_z_t * source_z);
 
typedef void *
(*afw_pool_malloc_debug_t)(
    const afw_pool_t * instance,
    afw_size_t size,
    afw_xctx_t * xctx,
    const afw_utf8_z_t * source_z);
 
typedef void
(*afw_pool_free_debug_t)(
    const afw_pool_t * instance,
    void * address,
    afw_size_t size,
    afw_xctx_t * xctx,
    const afw_utf8_z_t * source_z);
 
typedef void
(*afw_pool_register_cleanup_before_debug_t)(
    const afw_pool_t * instance,
    void * data,
    void * data2,
    afw_pool_cleanup_function_p_t cleanup,
    afw_xctx_t * xctx,
    const afw_utf8_z_t * source_z);
 
typedef void
(*afw_pool_deregister_cleanup_debug_t)(
    const afw_pool_t * instance,
    void * data,
    void * data2,
    afw_pool_cleanup_function_p_t cleanup,
    afw_xctx_t * xctx,
    const afw_utf8_z_t * source_z);
 
struct afw_pool_inf_s {
    afw_interface_implementation_rti_t rti;
    afw_pool_release_t release;
    afw_pool_add_reference_t add_reference;
    afw_pool_destroy_t destroy;
    afw_pool_get_apr_pool_t get_apr_pool;
    afw_pool_calloc_t calloc;
    afw_pool_malloc_t malloc;
    afw_pool_free_t free;
    afw_pool_register_cleanup_before_t register_cleanup_before;
    afw_pool_deregister_cleanup_t deregister_cleanup;
    afw_pool_release_debug_t release_debug;
    afw_pool_add_reference_debug_t add_reference_debug;
    afw_pool_destroy_debug_t destroy_debug;
    afw_pool_calloc_debug_t calloc_debug;
    afw_pool_malloc_debug_t malloc_debug;
    afw_pool_free_debug_t free_debug;
    afw_pool_register_cleanup_before_debug_t register_cleanup_before_debug;
    afw_pool_deregister_cleanup_debug_t deregister_cleanup_debug;
};
 
#define afw_pool_release( \
    instance, \
    xctx \
) \
(instance)->inf->release( \
    (instance), \
    (xctx) \
)
 
#define afw_pool_add_reference( \
    instance, \
    xctx \
) \
(instance)->inf->add_reference( \
    (instance), \
    (xctx) \
)
 
#define afw_pool_destroy( \
    instance, \
    xctx \
) \
(instance)->inf->destroy( \
    (instance), \
    (xctx) \
)
 
#define afw_pool_get_apr_pool( \
    instance \
) \
(instance)->inf->get_apr_pool( \
    (instance) \
)
 
#define afw_pool_calloc( \
    instance, \
    size, \
    xctx \
) \
(instance)->inf->calloc( \
    (instance), \
    (size), \
    (xctx) \
)
 
#define afw_pool_malloc( \
    instance, \
    size, \
    xctx \
) \
(instance)->inf->malloc( \
    (instance), \
    (size), \
    (xctx) \
)
 
#define afw_pool_free( \
    instance, \
    address, \
    size, \
    xctx \
) \
(instance)->inf->free( \
    (instance), \
    (address), \
    (size), \
    (xctx) \
)
 
#define afw_pool_register_cleanup_before( \
    instance, \
    data, \
    data2, \
    cleanup, \
    xctx \
) \
(instance)->inf->register_cleanup_before( \
    (instance), \
    (data), \
    (data2), \
    (cleanup), \
    (xctx) \
)
 
#define afw_pool_deregister_cleanup( \
    instance, \
    data, \
    data2, \
    cleanup, \
    xctx \
) \
(instance)->inf->deregister_cleanup( \
    (instance), \
    (data), \
    (data2), \
    (cleanup), \
    (xctx) \
)
 
#define afw_pool_release_debug( \
    instance, \
    xctx, \
    source_z \
) \
(instance)->inf->release_debug( \
    (instance), \
    (xctx), \
    (source_z) \
)
 
#define afw_pool_add_reference_debug( \
    instance, \
    xctx, \
    source_z \
) \
(instance)->inf->add_reference_debug( \
    (instance), \
    (xctx), \
    (source_z) \
)
 
#define afw_pool_destroy_debug( \
    instance, \
    xctx, \
    source_z \
) \
(instance)->inf->destroy_debug( \
    (instance), \
    (xctx), \
    (source_z) \
)
 
#define afw_pool_calloc_debug( \
    instance, \
    size, \
    xctx, \
    source_z \
) \
(instance)->inf->calloc_debug( \
    (instance), \
    (size), \
    (xctx), \
    (source_z) \
)
 
#define afw_pool_malloc_debug( \
    instance, \
    size, \
    xctx, \
    source_z \
) \
(instance)->inf->malloc_debug( \
    (instance), \
    (size), \
    (xctx), \
    (source_z) \
)
 
#define afw_pool_free_debug( \
    instance, \
    address, \
    size, \
    xctx, \
    source_z \
) \
(instance)->inf->free_debug( \
    (instance), \
    (address), \
    (size), \
    (xctx), \
    (source_z) \
)
 
#define afw_pool_register_cleanup_before_debug( \
    instance, \
    data, \
    data2, \
    cleanup, \
    xctx, \
    source_z \
) \
(instance)->inf->register_cleanup_before_debug( \
    (instance), \
    (data), \
    (data2), \
    (cleanup), \
    (xctx), \
    (source_z) \
)
 
#define afw_pool_deregister_cleanup_debug( \
    instance, \
    data, \
    data2, \
    cleanup, \
    xctx, \
    source_z \
) \
(instance)->inf->deregister_cleanup_debug( \
    (instance), \
    (data), \
    (data2), \
    (cleanup), \
    (xctx), \
    (source_z) \
)
 
struct afw_adaptor_journal_s {
    const afw_adaptor_journal_inf_t *inf;
    const afw_adaptor_session_t * session;
};
 
#define AFW_ADAPTOR_JOURNAL_INTERFACE_NAME \
"afw_adaptor_journal"
 
typedef const afw_utf8_t *
(*afw_adaptor_journal_add_entry_t)(
    const afw_adaptor_journal_t * instance,
    const afw_adaptor_impl_request_t * impl_request,
    const afw_object_t * entry,
    afw_xctx_t * xctx);
 
typedef void
(*afw_adaptor_journal_get_entry_t)(
    const afw_adaptor_journal_t * instance,
    const afw_adaptor_impl_request_t * impl_request,
    afw_adaptor_journal_option_t option,
    const afw_utf8_t * consumer_id,
    const afw_utf8_t * entry_cursor,
    afw_size_t limit,
    const afw_object_t * response,
    afw_xctx_t * xctx);
 
typedef void
(*afw_adaptor_journal_mark_entry_consumed_t)(
    const afw_adaptor_journal_t * instance,
    const afw_adaptor_impl_request_t * impl_request,
    const afw_utf8_t * consumer_id,
    const afw_utf8_t * entry_cursor,
    afw_xctx_t * xctx);
 
struct afw_adaptor_journal_inf_s {
    afw_interface_implementation_rti_t rti;
    afw_adaptor_journal_add_entry_t add_entry;
    afw_adaptor_journal_get_entry_t get_entry;
    afw_adaptor_journal_mark_entry_consumed_t mark_entry_consumed;
};
 
#define afw_adaptor_journal_add_entry( \
    instance, \
    impl_request, \
    entry, \
    xctx \
) \
(instance)->inf->add_entry( \
    (instance), \
    (impl_request), \
    (entry), \
    (xctx) \
)
 
#define afw_adaptor_journal_get_entry( \
    instance, \
    impl_request, \
    option, \
    consumer_id, \
    entry_cursor, \
    limit, \
    response, \
    xctx \
) \
(instance)->inf->get_entry( \
    (instance), \
    (impl_request), \
    (option), \
    (consumer_id), \
    (entry_cursor), \
    (limit), \
    (response), \
    (xctx) \
)
 
#define afw_adaptor_journal_mark_entry_consumed( \
    instance, \
    impl_request, \
    consumer_id, \
    entry_cursor, \
    xctx \
) \
(instance)->inf->mark_entry_consumed( \
    (instance), \
    (impl_request), \
    (consumer_id), \
    (entry_cursor), \
    (xctx) \
)
 
struct afw_value_s {
    const afw_value_inf_t *inf;
};
 
#define AFW_VALUE_INTERFACE_NAME \
"afw_value"
 
typedef void
(*afw_value_optional_release_t)(
    const afw_value_t * instance,
    afw_xctx_t * xctx);
 
typedef const afw_value_t *
(*afw_value_get_reference_t)(
    const afw_value_t * instance,
    const afw_pool_t * p,
    afw_xctx_t * xctx);
 
typedef const afw_value_t *
(*afw_value_optional_evaluate_t)(
    const afw_value_t * instance,
    const afw_pool_t * p,
    afw_xctx_t * xctx);
 
typedef const afw_data_type_t *
(*afw_value_get_data_type_t)(
    const afw_value_t * instance,
    afw_xctx_t * xctx);
 
typedef const afw_data_type_t *
(*afw_value_get_evaluated_data_type_t)(
    const afw_value_t * instance,
    afw_xctx_t * xctx);
 
typedef const afw_utf8_t *
(*afw_value_get_evaluated_data_type_parameter_t)(
    const afw_value_t * instance,
    afw_xctx_t * xctx);
 
typedef const afw_value_t *
(*afw_value_get_evaluated_meta_t)(
    const afw_value_t * instance,
    const afw_pool_t * p,
    afw_xctx_t * xctx);
 
typedef const afw_value_t *
(*afw_value_get_evaluated_metas_t)(
    const afw_value_t * instance,
    const afw_pool_t * p,
    afw_xctx_t * xctx);
 
typedef void
(*afw_value_produce_compiler_listing_t)(
    const afw_value_t * instance,
    const afw_writer_t * writer,
    afw_xctx_t * xctx);
 
typedef void
(*afw_value_decompile_t)(
    const afw_value_t * instance,
    const afw_writer_t * writer,
    afw_xctx_t * xctx);
 
typedef void
(*afw_value_get_info_t)(
    const afw_value_t * instance,
    afw_value_info_t * info,
    const afw_pool_t * p,
    afw_xctx_t * xctx);
 
struct afw_value_inf_s {
    afw_interface_implementation_rti_t rti;
    afw_value_optional_release_t optional_release;
    afw_value_get_reference_t get_reference;
    afw_value_optional_evaluate_t optional_evaluate;
    afw_value_get_data_type_t get_data_type;
    afw_value_get_evaluated_data_type_t get_evaluated_data_type;
    afw_value_get_evaluated_data_type_parameter_t get_evaluated_data_type_parameter;
    afw_value_get_evaluated_meta_t get_evaluated_meta;
    afw_value_get_evaluated_metas_t get_evaluated_metas;
    afw_value_produce_compiler_listing_t produce_compiler_listing;
    afw_value_decompile_t decompile;
    afw_value_get_info_t get_info;
    const afw_data_type_t * data_type;
    const afw_data_type_t * fully_evaluated_data_type;
};
 
#define afw_value_optional_release( \
    instance, \
    xctx \
) \
(instance)->inf->optional_release( \
    (instance), \
    (xctx) \
)
 
#define afw_value_get_reference( \
    instance, \
    p, \
    xctx \
) \
(instance)->inf->get_reference( \
    (instance), \
    (p), \
    (xctx) \
)
 
#define afw_value_optional_evaluate( \
    instance, \
    p, \
    xctx \
) \
(instance)->inf->optional_evaluate( \
    (instance), \
    (p), \
    (xctx) \
)
 
#define afw_value_get_data_type( \
    instance, \
    xctx \
) \
(instance)->inf->get_data_type( \
    (instance), \
    (xctx) \
)
 
#define afw_value_get_evaluated_data_type( \
    instance, \
    xctx \
) \
(instance)->inf->get_evaluated_data_type( \
    (instance), \
    (xctx) \
)
 
#define afw_value_get_evaluated_data_type_parameter( \
    instance, \
    xctx \
) \
(instance)->inf->get_evaluated_data_type_parameter( \
    (instance), \
    (xctx) \
)
 
#define afw_value_get_evaluated_meta( \
    instance, \
    p, \
    xctx \
) \
(instance)->inf->get_evaluated_meta( \
    (instance), \
    (p), \
    (xctx) \
)
 
#define afw_value_get_evaluated_metas( \
    instance, \
    p, \
    xctx \
) \
(instance)->inf->get_evaluated_metas( \
    (instance), \
    (p), \
    (xctx) \
)
 
#define afw_value_produce_compiler_listing( \
    instance, \
    writer, \
    xctx \
) \
(instance)->inf->produce_compiler_listing( \
    (instance), \
    (writer), \
    (xctx) \
)
 
#define afw_value_decompile( \
    instance, \
    writer, \
    xctx \
) \
(instance)->inf->decompile( \
    (instance), \
    (writer), \
    (xctx) \
)
 
#define afw_value_get_info( \
    instance, \
    info, \
    p, \
    xctx \
) \
(instance)->inf->get_info( \
    (instance), \
    (info), \
    (p), \
    (xctx) \
)
 
struct afw_variable_handler_s {
    const afw_variable_handler_inf_t *inf;
};
 
#define AFW_VARIABLE_HANDLER_INTERFACE_NAME \
"afw_variable_handler"
 
typedef const afw_value_t *
(*afw_variable_handler_get_variable_t)(
    const afw_variable_handler_t * instance,
    const afw_utf8_t * qualifier,
    const afw_utf8_t * name,
    afw_xctx_t * xctx);
 
typedef afw_boolean_t
(*afw_variable_handler_set_variable_t)(
    const afw_variable_handler_t * instance,
    const afw_utf8_t * qualifier,
    const afw_utf8_t * name,
    const afw_value_t * value,
    afw_xctx_t * xctx);
 
struct afw_variable_handler_inf_s {
    afw_interface_implementation_rti_t rti;
    afw_variable_handler_get_variable_t get_variable;
    afw_variable_handler_set_variable_t set_variable;
};
 
#define afw_variable_handler_get_variable( \
    instance, \
    qualifier, \
    name, \
    xctx \
) \
(instance)->inf->get_variable( \
    (instance), \
    (qualifier), \
    (name), \
    (xctx) \
)
 
#define afw_variable_handler_set_variable( \
    instance, \
    qualifier, \
    name, \
    value, \
    xctx \
) \
(instance)->inf->set_variable( \
    (instance), \
    (qualifier), \
    (name), \
    (value), \
    (xctx) \
)
 
struct afw_writer_s {
    const afw_writer_inf_t *inf;
    const afw_pool_t * p;
    afw_write_cb_t write_raw_cb;
    afw_size_t indent;
    const afw_utf8_t * tab;
};
 
#define AFW_WRITER_INTERFACE_NAME \
"afw_writer"
 
typedef void
(*afw_writer_release_t)(
    const afw_writer_t * instance,
    afw_xctx_t * xctx);
 
typedef void
(*afw_writer_flush_t)(
    const afw_writer_t * instance,
    afw_xctx_t * xctx);
 
typedef void
(*afw_writer_write_t)(
    const afw_writer_t * instance,
    const void * buffer,
    afw_size_t size,
    afw_xctx_t * xctx);
 
typedef void
(*afw_writer_write_eol_t)(
    const afw_writer_t * instance,
    afw_xctx_t * xctx);
 
typedef void
(*afw_writer_increment_indent_t)(
    const afw_writer_t * instance,
    afw_xctx_t * xctx);
 
typedef void
(*afw_writer_decrement_indent_t)(
    const afw_writer_t * instance,
    afw_xctx_t * xctx);
 
struct afw_writer_inf_s {
    afw_interface_implementation_rti_t rti;
    afw_writer_release_t release;
    afw_writer_flush_t flush;
    afw_writer_write_t write;
    afw_writer_write_eol_t write_eol;
    afw_writer_increment_indent_t increment_indent;
    afw_writer_decrement_indent_t decrement_indent;
};
 
#define afw_writer_release( \
    instance, \
    xctx \
) \
(instance)->inf->release( \
    (instance), \
    (xctx) \
)
 
#define afw_writer_flush( \
    instance, \
    xctx \
) \
(instance)->inf->flush( \
    (instance), \
    (xctx) \
)
 
#define afw_writer_write( \
    instance, \
    buffer, \
    size, \
    xctx \
) \
(instance)->inf->write( \
    (instance), \
    (buffer), \
    (size), \
    (xctx) \
)
 
#define afw_writer_write_eol( \
    instance, \
    xctx \
) \
(instance)->inf->write_eol( \
    (instance), \
    (xctx) \
)
 
#define afw_writer_increment_indent( \
    instance, \
    xctx \
) \
(instance)->inf->increment_indent( \
    (instance), \
    (xctx) \
)
 
#define afw_writer_decrement_indent( \
    instance, \
    xctx \
) \
(instance)->inf->decrement_indent( \
    (instance), \
    (xctx) \
)
 
AFW_END_DECLARES
 
 
 
#endif /* __AFW_INTERFACE_H__ */