afw_common.h

Go to the documentation of this file.

// See the 'COPYING' file in the project root for licensing information.
/*
 * Adaptive Framework Common Header
 *
 * Copyright (c) 2010-2023 Clemson University
 *
 */
 
#ifndef __AFW_COMMON_H__
#define __AFW_COMMON_H__
 
/* Need to include doxygen groups. */
#include "afw_doxygen.h"
 
 
/* For pool debugging use  -D AFW_POOL_DEBUG */
/* For lock debugging use -D AFW_LOCK_DEBUG */
 
/* Adaptive Framework uses Apache Portable Runtime. */
#include <apr_general.h>
#include <apr_tables.h>
#include <apr_strings.h>
#include <apr_time.h>
#include <apr_hash.h>
#include <apr_buckets.h>
#include <apr_atomic.h>
#include <apr_thread_proc.h>
#include <apr_thread_rwlock.h>
 
 
/* Common standard headers. */
#include <assert.h>
#include <limits.h>
#include <setjmp.h>
#include <string.h>
#include <stdint.h>
#include <stdarg.h>
#include <ctype.h>
#include <math.h>
#include <stdbool.h>
#include <stdlib.h>
#include <inttypes.h>
 
 
/*
 * Adaptive Framework common opaque typedefs are contained in
 * afw_common_opaques.h.
 */
#include "afw_common_opaques.h"
 
/*
 * Adaptive Framework interface opaque typedefs are contained in
 * afw_interface_opaques.h.
 */
#include "afw_interface_opaques.h"
 
/*
 * Atomic.
 *
 * On Windows, volatile has atomic semantics; otherwise require C11 or higher
 * and atomic primitives and types.
 */
#if defined(_WIN32) || defined(WIN32)
#define AFW_ATOMIC volatile
#define AFW_WINDOWS 1
#else
#if __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_ATOMICS__)
#define AFW_HAS_ATOMIC
#include <stdatomic.h>
#define AFW_ATOMIC _Atomic
#else
#error C11 or higher with atomic primitives and types is required to compile Adaptive Framework
#endif
#endif
 
/* Include generated declare helpers. */
#include "afw_declare_helpers.h"
 
/* Include template headers. */
#include "afw_associative_array_template.h"
 
#ifdef __GNUC__
#define AFW_POSSIBLY_UNUSED_VARIABLE __attribute__((unused))
#else
#define AFW_POSSIBLY_UNUSED_VARIABLE
#endif
 
#define AFW_ASSERT(e) assert(e)
 
#ifndef offsetof
#define offsetof(type, member)  __builtin_offsetof (type, member)
#endif
 
AFW_BEGIN_DECLARES
 
#define AFW_ADAPTOR_ID "afw"
 
#define AFW_STRINGIFY(x) AFW_STRINGIFY_x(x)
#define AFW_STRINGIFY_x(x) #x
 
#define AFW__FILE_LINE__ __FILE__ ":" AFW_STRINGIFY(__LINE__)
 
typedef apr_size_t afw_size_t;
 
typedef apr_off_t afw_off_t;
 
typedef int8_t afw_int8_t;
 
typedef apr_int16_t afw_int16_t;
 
typedef apr_int32_t afw_int32_t;
 
#define AFW_INT32_MIN -2147483647 - 1
 
#define AFW_INT32_MAX 2147483647
 
typedef apr_int64_t afw_int64_t;
 
typedef uint8_t afw_uint8_t;
 
typedef apr_uint16_t afw_uint16_t;
 
#define AFW_UINT16_MAX 65536
 
typedef apr_uint32_t afw_uint32_t;
 
#define AFW_UINT32_MAX 4294967296
 
typedef apr_uint64_t afw_uint64_t;
 
typedef float afw_float32_t;
 
typedef double afw_float64_t;
 
typedef double afw_float_t;
 
typedef double afw_double_t;
 
typedef afw_int32_t afw_code_point_t;
 
typedef unsigned char afw_byte_t;
 
typedef unsigned char afw_octet_t;
 
typedef char afw_utf8_octet_t;
 
typedef afw_code_point_t (*afw_code_point_get_cb_t) (
    void *data, afw_xctx_t *xctx);
 
 
typedef int (*afw_utf8_octet_get_cb_t) (
    afw_utf8_octet_t *octet,
    void *data, afw_xctx_t *xctx);
 
 
#define AFW_UTF8_Z_LEN -1
 
 
#define AFW_INTEGER_MAX_BUFFER 21
 
 
#define AFW_INTEGER_MAX  APR_INT64_MAX
 
#define AFW_INTEGER_Q_MAX "9223372036854775807"
 
#define AFW_INTEGER_MIN APR_INT64_MIN
 
#define AFW_INTEGER_Q_MIN "-9223372036854775808"
 
#define AFW_INTEGER_MAX_SAFE_DOUBLE 9007199254740991
 
#define AFW_INTEGER_MIN_SAFE_DOUBLE -9007199254740991
 
#define AFW_INTEGER_IS_SAFE_DOUBLE(integer) \
    ((integer) <= AFW_INTEGER_MAX_SAFE_DOUBLE && \
    ((integer) >= AFW_INTEGER_MIN_SAFE_DOUBLE)
 
 
typedef apr_int64_t afw_integer_t;
 
#define AFW_INTEGER_FMT APR_INT64_T_FMT
 
#define AFW_INTEGER_MAX_DIGITS 19
 
#define AFW_Q_INTEGER_MAX_DIGITS "19"
 
#define AFW_SIZE_T_FMT APR_SIZE_T_FMT
 
#define AFW_SIZE_T_MAX APR_SIZE_MAX
 
#define AFW_SIZE_T_MAX_DIGITS 19
 
#define AFW_Q_SIZE_T_MAX_DIGITS "19"
 
#define AFW_SIZE_T_MAX_BUFFER AFW_SIZE_T_MAX_DIGITS + 1
 
 
 
typedef apr_uint64_t afw_unsigned_integer_t;
 
 
typedef _Bool afw_boolean_t;
 
 
#define AFW_TRUE true
 
 
#define AFW_FALSE false
 
 
#define AFW_CRLF "\x0d\x0a"
 
 
#define AFW_CRLF_STRLEN 2
 
 
#define AFW_COMPILE_TYPE_MAP(XX)                                                \
                                                                                \
    XX(error,                                                                   \
        string, NULL,                                                           \
        "This is an error")                                                     \
                                                                                \
    XX(expression,                                                              \
        expression,                                                             \
        &afw_function_definition_compile_expression,                            \
        "See production Expression in src/afw/doc/syntax/index.html or "        \
        "src/afw/generated/ebnf/syntax.ebnf for syntax.")                       \
                                                                                \
    XX(expression_tuple,                                                        \
        hybrid,                                                                 \
        &afw_function_definition_compile_expression_tuple,                      \
        "See production ExpressionTuple in src/afw/doc/syntax/index.html or "   \
        "src/afw/generated/ebnf/syntax.ebnf for syntax.")                       \
                                                                                \
    XX(hybrid,                                                                  \
        hybrid,                                                                 \
        &afw_function_definition_compile_hybrid,                                \
        "See production Hybrid in src/afw/doc/syntax/index.html or "            \
        "src/afw/generated/ebnf/syntax.ebnf for syntax.")                       \
                                                                                \
    XX(json,                                                                    \
        string,                                                                 \
        &afw_function_definition_compile_json,                                  \
        "Compile strict json")                                                  \
                                                                                \
    XX(parenthesized_expression,                                                \
        expression,                                                             \
        &afw_function_definition_compile_expression,                            \
        "See production ParenthesizedExpression in "                            \
        "src/afw/doc/syntax/index.html "                                        \
        "or src/afw/generated/ebnf/syntax.ebnf for syntax.")                    \
                                                                                \
    XX(regexp,                                                                  \
        regexp,                                                                 \
        &afw_function_definition_compile_regexp,                                \
        "Parses a regular expression conforming to XML Schemas Part 2 "         \
        "Datatype Appendix F and builds an automata suitable for testing "      \
        "strings against that regular expression ")                             \
                                                                                \
    XX(relaxed_json,                                                            \
        string,                                                                 \
        &afw_function_definition_compile_relaxed_json,                          \
        "1) Allows inline and block comments\n"                                 \
        "2) Allows property names to be unquoted if they start with '_',\n"     \
        "   '$', 'a-z', 'A-Z', or char > 127 followed by any of those or\n"     \
        "   '0' - '9'.\n"                                                       \
        "3) Allows Infinity, -Infinity, NaN, and -NaN for number values.\n"    \
        "4) Allows a trailing comma in Object and List.")                       \
                                                                                \
    XX(script,                                                                  \
        script,                                                                 \
        &afw_function_definition_compile_script,                                \
        "See production Script in src/afw/doc/syntax/index.html or "            \
        "src/afw/generated/ebnf/syntax.ebnf for syntax.")                       \
                                                                                \
    XX(template,                                                                \
        template,                                                               \
        &afw_function_definition_compile_template,                              \
        "See production Template in src/afw/doc/syntax/index.html or "          \
        "src/afw/generated/ebnf/syntax.ebnf for syntax.")                       \
                                                                                \
    XX(test_script,                                                             \
        script,                                                                 \
        &afw_function_definition_compile_script,                                \
        "See production TestScript in src/afw/doc/syntax/index.html or "        \
        "src/afw/generated/ebnf/syntax.ebnf for syntax.")                       \
                                                                                \
    XX(xpathExpression,                                                         \
        xpathExpression,                                                        \
        &afw_function_definition_compile_xpathExpression,                       \
        "XML Path Language (XPath) expression")
 
typedef enum afw_compile_type_e {
#define XX(name, data_type, compile_function, description) \
    afw_compile_type_ ## name,
    AFW_COMPILE_TYPE_MAP(XX)
#undef XX
    afw_compile_type_count
} afw_compile_type_t;
 
 
typedef struct afw_memory_s {
    const afw_byte_t *ptr;
    afw_size_t size;
} afw_memory_t;
 
 
typedef afw_utf8_octet_t afw_utf8_z_t;
 
 
typedef struct afw_utf8_s {
    const afw_utf8_octet_t *s;
    afw_size_t len;
} afw_utf8_t;
 
 
 
typedef union afw_utf8_utf8_z_s {
    afw_utf8_t s;
    const afw_utf8_z_t *s_z;
} afw_utf8_utf8_z_t;
 
 
 
typedef struct afw_utf8_array_s {
    afw_integer_t count;
    union {
        afw_utf8_t *first;
        afw_utf8_t (*array)[];
    };
} afw_utf8_array_t;
 
 
#define AFW_UTF8_LITERAL(A_STRING) {A_STRING, sizeof(A_STRING) - 1}
 
 
#define AFW_UTF8_FMT ".*s"
 
#define AFW_UTF8_CONTEXTUAL_LABEL_FMT_SEP "> "
 
 
#define AFW_UTF8_CONTEXTUAL_LABEL_FMT \
AFW_UTF8_FMT AFW_UTF8_CONTEXTUAL_LABEL_FMT_SEP
 
#define AFW_UTF8_FMT_ARG(A_STRING) \
    (int)(A_STRING)->len, (const char *)(A_STRING)->s
 
 
#define AFW_UTF8_FMT_OPTIONAL_ARG(A_STRING) \
    (A_STRING) ? (int)(A_STRING)->len : 0, \
    (A_STRING) ? (const char *)(A_STRING)->s : ""
 
 
#define AFW_UTF8_FMT_OPTIONAL_UNDEFINED_ARG(A_STRING) \
    (A_STRING) ? (int)(A_STRING)->len : 0, \
    (A_STRING) ? (const char *)(A_STRING)->s : "<undefined>"
 
 
#define AFW_MESSAGE_PREFIX __FILE__ ":" AFW_STRINGIFY(__LINE__) " "
 
 
#define AFW_UTF8_ENCODING "UTF-8"
 
 
typedef uint32_t afw_u_cp_t;
 
 
typedef char *afw_uri_t;
 
 
typedef int afw_log_priority_mask_t;
 
 
typedef int afw_rc_t;
 
 
struct afw_stack_s {
    const afw_pool_t *p;
    void *first;
    void *top;
    void *end;
};
 
 
typedef struct afw_name_value_s {
    const afw_utf8_t *name;
    const afw_value_t *value;
} afw_name_value_t;
 
 
typedef struct afw_key_string_s {
    const afw_utf8_t *key;
    const afw_utf8_t *string;
} afw_key_string_t;
 
 
typedef struct afw_key_z_string_z_s {
    union {
        afw_utf8_t key;
        const afw_utf8_z_t *key_z;
    };
    union {
        afw_utf8_t string;
        const afw_utf8_z_t *string_z;
    };
} afw_key_z_string_z_t;
 
 
#define AFW_STACK_STRUCT(struct_name, entry_type) \
struct struct_name { \
    union { \
        afw_stack_t pub; \
        struct { \
            const afw_pool_t *p; \
            entry_type *first; \
            entry_type *top; \
            entry_type *end; \
        }; \
    }; \
}
 
AFW_STACK_STRUCT(afw_utf8_stack_s, afw_utf8_t);
 
AFW_STACK_STRUCT(afw_const_utf8_a_stack_s, const afw_utf8_t *);
 
AFW_STACK_STRUCT(afw_name_value_stack_s, afw_name_value_t);
 
 
typedef struct afw_object_meta_s {
 
    const afw_object_t *meta_object;
 
    const afw_object_t *embedding_object;
 
    const afw_utf8_t *id;
 
    const afw_utf8_t *object_type_uri;
 
    const afw_utf8_t *object_uri;
 
} afw_object_meta_t;
 
 
 
#define AFW_ERROR_CODE_MAP(XX)                                                  \
    XX(none,                   true,  200, "OK"                                )\
    XX(general,                true,  500, "General Error"                     )\
    XX(bad_request,            true,  400, "Bad Request"                       )\
    XX(query_too_complex,      true,  400, "Query Too Complex"                 )\
    XX(request_syntax,         true,  400, "Request Syntax Error"              )\
    XX(objects_needed,         true,  400, "Objects Needed To Complete Request")\
    XX(authentication_required,true,  401, "Authentication Needed"             )\
    XX(denied,                 true,  403, "Forbidden - Access Denied"         )\
    XX(read_only,              true,  403, "Forbidden - Read Only"             )\
    XX(not_found,              true,  404, "Not Found"                         )\
    XX(method_not_allowed,     true,  405, "Method Not Allowed"                )\
    XX(unsupported_accept,     false, 406, "Unsupported Content Type Requested")\
    XX(client_time_out,        true,  408, "Request Timeout"                   )\
    XX(im_a_teapot,            true,  418, "I'm a Teapot"                      )\
    XX(conflict,               true,  409, "Conflict"                          )\
    XX(length_required,        true,  411, "Content Length Required"           )\
    XX(payload_too_large,      true,  413, "Payload too large"                 )\
    XX(unsupported_content,    true,  415, "Unsupported Content Type"          )\
    XX(memory,                 true,  500, "Memory Error"                      )\
    XX(syntax,                 true,  500, "Server Side Syntax Error"          )\
    XX(method_not_supported,   true,  501, "Method Not Supported"              )\
    XX(client_closed,          false, 000, "Client Closed Connection"          )\
    XX(assertion_failed,       true,  400, "Assertion failed"                  )\
    XX(cast_error,             true,  400, "Adaptive Type Cast Error"          )\
    XX(arg_error,              true,  400, "Adaptive Function Arg Error"       )\
    XX(evaluate,               true,  400, "Evaluation error"                  )\
    XX(undefined,              true,  400, "Undefined value"                   )\
    XX(code,                   true,  500, "Clearly an internal coding error"  )\
 
typedef enum afw_error_code_e {
    afw_error_code_is_not_specified = 0,
    
#define XX(id, error_allow_in_response, http_response_code,  description) \
    afw_error_code_ ## id,
    AFW_ERROR_CODE_MAP(XX)
#undef XX
 
    afw_error_code_highest_afw = 1000
 
} afw_error_code_t;
 
 
 
typedef void (*afw_pool_cleanup_function_p_t)(
    void *data, void *data2, const afw_pool_t *p, afw_xctx_t *xctx);
 
 
 
typedef const afw_value_t *
(*afw_xctx_get_variable_t)(
    const afw_xctx_qualifier_stack_entry_t *entry,
    const afw_utf8_t *name,
    afw_xctx_t *xctx);
 
 
typedef enum afw_log_priority_e {
 
    afw_log_priority_invalid   = -1,   
    /* These go to the configured log. */
    afw_log_priority_min       = 0,    
    afw_log_priority_emerg     = 0,    
    afw_log_priority_alert     = 1,    
    afw_log_priority_crit      = 2,    
    afw_log_priority_err       = 3,    
    afw_log_priority_warning   = 4,    
    afw_log_priority_notice    = 5,    
    afw_log_priority_info      = 6,    
    afw_log_priority_debug     = 7,    
    afw_log_priority_max       = 7,    
    /* These go to the configured trace destination. */
    afw_log_priority_trace_min = 8,    
    afw_log_priority_trace1    = 8,    
    afw_log_priority_trace2    = 9,    
    afw_log_priority_trace3    = 10,   
    afw_log_priority_trace4    = 11,   
    afw_log_priority_trace5    = 12,   
    afw_log_priority_trace6    = 13,   
    afw_log_priority_trace7    = 14,   
    afw_log_priority_trace8    = 15,   
    afw_log_priority_trace_max = 15    
} afw_log_priority_t;
 
 
typedef enum afw_adaptor_journal_option_e {
 
    afw_adaptor_journal_option_get_first,
 
    afw_adaptor_journal_option_get_by_cursor,
    
    afw_adaptor_journal_option_get_next_after_cursor,
    
    afw_adaptor_journal_option_get_next_for_consumer,
    
    afw_adaptor_journal_option_get_next_for_consumer_after_cursor,
 
    afw_adaptor_journal_option_advance_cursor_for_consumer
    
} afw_adaptor_journal_option_t;
 
 
typedef afw_boolean_t
(*afw_object_cb_t)(
    const afw_object_t *object,
    void *context,
    afw_xctx_t *xctx);
 
 
typedef afw_boolean_t
(*afw_value_cb_t)(
    const void *value,
    void *context,
    afw_xctx_t *xctx);
 
 
typedef afw_size_t
(*afw_read_cb_t)(
    void *context,
    const void * buffer,
    afw_size_t size,
    afw_boolean_t *more_to_read,
    const afw_pool_t *p,
    afw_xctx_t *xctx);
 
 
typedef afw_size_t
(*afw_write_cb_t)(
    void *context,
    const void * buffer,
    afw_size_t size,
    const afw_pool_t *p,
    afw_xctx_t *xctx);
    
/*
 * @brief Runtime value accessor function.
 * @param property is associated afw_runtime_object_map_property_t *.
 * @param internal value.
 * @param p pool to use.
 * @param xctx xctx of caller.
 */
typedef const afw_value_t *
(*afw_runtime_value_accessor_t) (
    const afw_runtime_object_map_property_t * property,
    const void *internal, const afw_pool_t *p, afw_xctx_t *xctx);
 
 
typedef const afw_value_t *
(*afw_function_execute_cb_t) (afw_function_execute_t *x);
 
 
 
typedef const afw_value_t *
(*afw_function_thunk_execute_t) (
    const afw_value_function_thunk_t *function,
    afw_size_t argc,
    const afw_value_t *const *argv,
    const afw_pool_t *p,
    afw_xctx_t *xctx);
 
 
 
typedef const afw_utf8_t *
(*afw_function_arg_check_t)(
    afw_function_execute_t *x,
    afw_size_t argc,
    const afw_value_t * argv[],
    const afw_pool_t *p,
    afw_xctx_t *xctx);
 
 
#define AFW_SERVICE_STARTUP_MAP(XX)                                             \
    XX(disabled,    "Service is disabled and cannot be started."               )\
    XX(permanent,   "Service is permanently started and can not be stopped."   )\
    XX(manual,      "Service is started and stopped manually."                 )\
    XX(immediate,   "Service is started immediately and can be stopped and "    \
                    "started manually."    )\
 
typedef enum afw_service_startup_e {
 
#define XX(id, desc) afw_service_startup_ ## id,
    AFW_SERVICE_STARTUP_MAP(XX)
#undef XX
 
    afw_service_startup_invalid
} afw_service_startup_t;
 
#define AFW_SERVICE_STATUS_MAP(XX)                                              \
    XX(error,    "Service is not running because of an error."                 )\
    XX(disabled, "Service is disabled."                                        )\
    XX(ready_to_start, "Service is ready to start."                            )\
    XX(starting, "Service is starting."                                        )\
    XX(running,  "Service is running."                                         )\
    XX(stopping, "Service is finishing active work and releasing resources."   )\
    XX(stopped,  "Service is stopped and can be started manually."             )\
    XX(restarting,"Service is restarting."                                     )\
 
typedef enum afw_service_status_e {
 
#define XX(id, desc) afw_service_status_ ## id,
    AFW_SERVICE_STATUS_MAP(XX)
#undef XX
 
    afw_service_status_invalid
} afw_service_status_t;
 
 
#define afw_thread_mutex_t apr_thread_mutex_t
 
#define afw_thread_mutex_create apr_thread_mutex_create
 
#define afw_thread_mutex_lock apr_thread_mutex_lock
 
#define afw_thread_mutex_trylock apr_thread_mutex_trylock
 
#define afw_thread_mutex_unlock apr_thread_mutex_unlock
 
#define afw_thread_mutex_destroy apr_thread_mutex_destroy
 
#define AFW_THREAD_FUNCTION APR_THREAD_FUNC
 
typedef void
*(AFW_THREAD_FUNCTION *afw_thread_function_t)
    (const afw_thread_t *thread, void *arg);
 
typedef struct afw_thread_attr_s afw_thread_attr_t;
 
#define AFW_ENVIRONMENT_DEFAULT_EVALUATION_STACK_INITIAL_COUNT 100
 
#define AFW_ENVIRONMENT_DEFAULT_EVALUATION_STACK_MAXIMUM_COUNT 200
 
struct afw_environment_s {
 
    const afw_pool_t *p;
 
    union {
        afw_utf8_t program_name;
        const afw_utf8_z_t * program_name_z;
    };
 
    const afw_object_t *initial_environment_variables;
 
    const afw_adaptor_t *afw_adaptor;
 
    const afw_adaptor_t *conf_adaptor;
 
    afw_utf8_t application_id;
 
    const afw_object_t *application_object;
 
    const afw_object_t *application_qualified_variables;
    
    const afw_object_t *root_file_paths;
 
    const afw_utf8_t *layout_adaptor_id;
 
    const afw_log_t *log;
 
    FILE *debug_fd;
 
    FILE *stderr_fd;
 
    FILE *stdout_fd;
 
    afw_double_t infinity;
 
    const afw_value_t *infinity_value;
 
    afw_double_t minus_infinity;
 
    const afw_value_t *minus_infinity_value;
 
    afw_double_t NaN;
 
    const afw_value_t *NaN_value;
 
    const afw_authorization_control_t *authorization_control;
 
    const afw_function_environment_t *function_environment;
 
    afw_size_t evaluation_stack_initial_count;
 
    afw_size_t evaluation_stack_maximum_count;
 
    afw_log_priority_mask_t log_mask;
 
    AFW_ATOMIC afw_integer_t pool_number;
 
    afw_boolean_t terminating;
 
 
    /*---------- LOCKS ----------*/
 
    const afw_lock_t *environment_lock;
    
    const afw_lock_t *multithreaded_pool_lock;
    
    const afw_lock_t *adaptor_id_anchor_lock;
    
    const afw_lock_rw_t *authorization_handler_id_anchor_rw_lock;
 
    const afw_lock_t *active_log_list_lock;
 
    const afw_lock_t *flags_lock;
 
 
    /*---------- FLAGS ----------*/
 
    AFW_ATOMIC afw_size_t flags_count_allocated;
 
    AFW_ATOMIC afw_size_t flags_count_registered;
 
    AFW_ATOMIC const afw_boolean_t *default_flags;
 
    const afw_flag_t * AFW_ATOMIC const *flag_by_index;
 
    afw_size_t flag_index_debug_function_active;
 
    afw_size_t flag_index_debug_function_active_detail;
 
    afw_size_t flag_index_debug_pool;
 
    afw_size_t flag_index_debug_pool_detail;
 
    afw_size_t flag_index_response_error_backtrace;
 
    afw_size_t flag_index_response_error_backtraceEvaluation;
 
    afw_size_t flag_index_response_error_contextual;
 
    afw_size_t flag_index_response_error_hasAdditionalDetail;
 
    afw_size_t flag_index_trace_authorization_check;
 
    afw_size_t flag_index_trace_authorization_check_bypass;
 
    afw_size_t flag_index_trace_authorization_check_detail;
 
    afw_size_t flag_index_trace_authorization_decision;
 
    afw_size_t flag_index_trace_authorization_decision_detail;
 
    afw_size_t flag_index_trace_evaluation_detail;
 
    afw_size_t flag_index_trace_request;
 
    afw_size_t flag_index_trace_request_detail;
 
};
 
typedef union afw_c_types_u {
 
    afw_integer_t   integer;
    afw_integer_t   integer_p;
 
    afw_int8_t      int8;
    afw_int8_t    * int8_p;
 
    afw_uint8_t     uint8;
    afw_uint8_t   * uint8_p;
 
    afw_int16_t     int16;
    afw_int16_t   * int16_p;
 
    afw_uint16_t    uint16;
    afw_uint16_t  * uint16_p;
 
    afw_int32_t     int32;
    afw_int32_t   * int32_p;
 
    afw_uint32_t    uint32;
    afw_uint32_t  * uint32_p;
 
    afw_int64_t     int64;
    afw_int64_t   * int64_p;
 
    afw_uint64_t    uint64;
    afw_uint64_t  * uint64_p;
 
    afw_list_t    * list_p;
 
    afw_float32_t   float32;
    afw_float32_t * float32_p;
 
    afw_float64_t   float64;
    afw_float64_t * float64_p;
 
    afw_float_t     floating;
    afw_float_t   * floating_p;
 
    afw_object_t  * object_p;
 
    afw_utf8_t    string;
    afw_utf8_t  * string_p;
 
} afw_c_types_t;
 
 
typedef struct afw_time_with_offset_s {
    apr_time_t time;
    apr_time_t offset;
} afw_time_with_offset_t;
 
 
typedef struct afw_yearMonthDuration_s {
    afw_int32_t  years;
    afw_int32_t  months;
} afw_yearMonthDuration_t;
 
 
typedef struct afw_dayTimeDuration_s {
    afw_int32_t days;
    afw_int32_t hours;
    afw_int32_t minutes;
    afw_int32_t seconds;
    afw_int32_t microseconds;
} afw_dayTimeDuration_t;
 
 
typedef struct afw_time_duration_s {
    afw_yearMonthDuration_t yearMonth;
    afw_dayTimeDuration_t dayTime;
} afw_time_duration_t;
 
 
typedef struct afw_time_zone_s {
    afw_int8_t hours;
 
    afw_int8_t minutes;
} afw_time_zone_t;
 
 
typedef struct afw_date_no_time_zone_s {
 
    afw_int32_t year;
 
    afw_uint8_t month;
 
    afw_uint8_t day;
 
} afw_date_no_time_zone_t;
 
 
typedef struct afw_date_s {
    
    afw_date_no_time_zone_t date;
 
    afw_time_zone_t time_zone;
 
} afw_date_t;
 
 
typedef struct afw_time_no_time_zone_s {
 
    afw_uint8_t hour;
 
    afw_uint8_t minute;
 
    afw_uint8_t second;
 
    afw_uint32_t microsecond;
 
} afw_time_no_time_zone_t;
 
 
typedef struct afw_time_s {
 
    afw_time_no_time_zone_t time;
 
    afw_time_zone_t time_zone;
 
} afw_time_t;
 
 
typedef struct afw_dateTime_s {
 
    afw_date_no_time_zone_t date;
 
    afw_time_no_time_zone_t time;
 
    afw_time_zone_t time_zone;
 
} afw_dateTime_t;
 
 
typedef void
(*afw_service_wrapper_start_cb)(
    void *data, afw_xctx_t *xctx);
 
 
typedef void
(*afw_service_wrapper_stop_cb)(
    void *data, afw_xctx_t *xctx);
 
 
AFW_END_DECLARES
 
#endif /* __AFW_COMMON_H__ */