afw_environment.h

Go to the documentation of this file.

// See the 'COPYING' file in the project root for licensing information.
/*
 * Adaptive Framework Environment Header
 *
 * Copyright (c) 2010-2023 Clemson University
 *
 */
 
#ifndef __AFW_ENVIRONMENT_H__
#define __AFW_ENVIRONMENT_H__
 
#include "afw_interface.h"
 
AFW_BEGIN_DECLARES
 
#define AFW_ENVIRONMENT_REGISTRY_TYPE_MAP(XX)                                   \
                                                                                \
    XX(registry_type,                                                           \
        NULL,                                                                   \
        false,                                                                  \
        "registryType",                                                         \
        "_AdaptiveEnvironmentRegistryType_",                                    \
        "The afw_environment_registry_type_t associated with this property "    \
            "name .")                                                           \
                                                                                \
    XX(singleton,                                                               \
        impl_internal_additional_register_key_only,                             \
        false,                                                                  \
        "singleton",                                                            \
        "_AdaptiveSingleton_",                                                  \
        "The void pointer for a singleton key.")                                \
                                                                                \
    XX(adaptor_id,                                                              \
        impl_internal_additional_register_default,                              \
        false,                                                                  \
        "adaptorId",                                                            \
        "_AdaptiveAdaptor_",                                                    \
        "The afw_adaptor_id_t struct for this adaptor id.")                     \
                                                                                \
    XX(adaptor_type,                                                            \
        impl_internal_additional_register_default,                              \
        false,                                                                  \
        "adaptorType",                                                          \
        "_AdaptiveAdaptorType_",                                                \
        "The afw_adaptor_factory_t instance for an adaptor type.")              \
                                                                                \
    XX(authorization_handler_id,                                                \
        impl_internal_additional_register_default,                              \
        false,                                                                  \
        "authorizationHandlerId",                                               \
        "_AdaptiveAuthorizationHandler_",                                       \
        "The afw_authorization_handler_id_t struct for an "                     \
        "authorization handler id.")                                            \
                                                                                \
    XX(authorization_handler_type,                                              \
        impl_internal_additional_register_default,                              \
        false,                                                                  \
        "authorizationHandlerType",                                             \
        "_AdaptiveAuthorizationHandlerType_",                                   \
        "The afw_authorization_handler_factory_t instance for an "              \
        "authorization handler type.")                                          \
                                                                                \
    XX(conf_type,                                                               \
        impl_internal_additional_register_default,                              \
        false,                                                                  \
        "confType",                                                             \
        "_AdaptiveConfType_",                                                   \
        "The afw_environment_conf_type_t for a configuration type.")            \
                                                                                \
    XX(content_type,                                                            \
        impl_internal_additional_register_key_only,                             \
        false,                                                                  \
        "contentType",                                                          \
        "_AdaptiveContentType_",                                                \
        "The afw_content_type_t instance for a content type.")                  \
                                                                                \
    XX(context_type,                                                            \
        impl_internal_additional_register_object,                               \
        true,                                                                   \
        "contextType",                                                          \
        "_AdaptiveContextType_",                                                \
        "The context type object.  "                                            \
        "`/afw/_AdaptiveContextType_/<context_type_id>`"                        \
        " runtime object will be set to this object as well.")                  \
                                                                                \
    XX(data_type,                                                               \
        NULL,                                                                   \
        false,                                                                  \
        "dataType",                                                             \
        "_AdaptiveDataType_",                                                   \
        "The afw_data_type_t struct for a data type id.")                       \
                                                                                \
    XX(error_rv_decoder,                                                        \
        impl_internal_additional_register_key_only,                             \
        false,                                                                  \
        "errorRVDecoder",                                                       \
        "_AdaptiveErrorRVDecoder_",                                             \
        "The afw_environment_error_rv_decoder_z_t function for a rv source id.")\
                                                                                \
    XX(extension,                                                               \
        impl_internal_additional_register_default,                              \
        false,                                                                  \
        "extension",                                                            \
        "_AdaptiveExtension_",                                                  \
        "The afw_extension_t for a loaded extension.")                          \
                                                                                \
    XX(flag,                                                                    \
        NULL,                                                                   \
        false,                                                                  \
        "flagType",                                                             \
        "_AdaptiveFlag_",                                                       \
        "The afw_flag_t for a flag_id.")                                        \
                                                                                \
    XX(function,                                                                \
        NULL,                                                                   \
        false,                                                                  \
        "function",                                                             \
        "_AdaptiveFunction_",                                                   \
        "The afw_value_function_definition_t struct for a function id.")        \
                                                                                \
    XX(lock,                                                                    \
        impl_internal_additional_register_default,                              \
        true,                                                                   \
        "lockId",                                                               \
        "_AdaptiveLock_",                                                       \
        "The afw_lock_t instance for a log id.")                                \
                                                                                \
    XX(log,                                                                     \
        impl_internal_additional_register_default,                              \
        true,                                                                   \
        "logId",                                                                \
        "_AdaptiveLog_",                                                        \
        "The afw_log_t instance for a log id.")                                 \
                                                                                \
    XX(log_type,                                                                \
        impl_internal_additional_register_log_type,                             \
        false,                                                                  \
        "logType",                                                              \
        "_AdaptiveLogType_",                                                    \
        "The afw_log_factory_t instance for a log type.")                       \
                                                                                \
    XX(policy_combining_algorithm,                                              \
        impl_internal_additional_register_default,                              \
        false,                                                                  \
        "policyCombiningAlgorithmId",                                           \
        "_AdaptivePolicyCombiningAlgorithm_",                                   \
        "The afw_value_function_definition_t struct for a policy combining algorithm.")    \
                                                                                \
    XX(request_handler,                                                         \
        impl_internal_additional_register_key_only,                             \
        false,                                                                  \
        "requestHandler",                                                       \
        "_AdaptiveRequestHandler_",                                             \
        "The afw_request_handler_t instance for a request handler entry.")      \
                                                                                \
    XX(request_handler_type,                                                    \
        impl_internal_additional_register_default,                              \
        false,                                                                  \
        "requestHandlerType",                                                   \
        "_AdaptiveRequestHandlerType_",                                         \
        "The afw_request_handler_factory_t instance for a handler type.")       \
                                                                                \
    XX(rule_combining_algorithm,                                                \
        impl_internal_additional_register_default,                              \
        false,                                                                  \
        "ruleCombiningAlgorithmId",                                             \
        "_AdaptiveRuleCombiningAlgorithm_",                                     \
        "The afw_value_function_definition_t struct for a rule combining algorithm.")      \
                                                                                \
    XX(runtime_custom,                                                          \
        impl_internal_additional_register_key_only,                             \
        false,                                                                  \
        "runtimeCustom",                                                        \
        "_AdaptiveRuntimeCustom_",                                              \
        "The afw_runtime_custom_t for custom afw object type handling.")        \
                                                                                \
    XX(runtime_object_map_inf,                                                  \
        NULL,                                                                   \
        false,                                                                  \
        "runtimeObjectMapInf",                                                  \
        "_AdaptiveRuntimeObjectMapInf_",                                        \
        "The runtime object map interface for an object type id.")              \
                                                                                \
    XX(runtime_value_accessor,                                                  \
        impl_internal_additional_register_key_only,                             \
        false,                                                                  \
        "runtimeValueAccessor",                                                 \
        "_AdaptiveRuntimeValueAccessor_",                                       \
        "The afw_runtime_value_accessor_t for an accessor name.")               \
                                                                                \
    XX(service,                                                                 \
        NULL,                                                                   \
        true,                                                                   \
        "serviceId",                                                            \
        "_AdaptiveService_",                                                    \
        "The afw_service_t for a service_id.")                                  \
                                                                                \
    XX(service_type,                                                            \
        impl_internal_additional_register_default,                              \
        false,                                                                  \
        "serviceType",                                                          \
        "_AdaptiveServiceType_",                                                \
        "The afw_service_type_t for a service_type_id.")                        \
                                                                                \
    XX(value_inf,                                                               \
        impl_internal_additional_register_key_only,                             \
        false,                                                                  \
        "valueInf",                                                             \
        "_AdaptiveValueInf_",                                                   \
        "The afw_value_inf_t struct for a value interface implementation.")     \
 
 
typedef enum {
#define XX(id, register_additional, allow_reregister, property_name,          \
    object_type_id, description)                                              \
    afw_environemnt_registry_type_ ## id,
    AFW_ENVIRONMENT_REGISTRY_TYPE_MAP(XX)
#undef XX
    afw_environemnt_registry_type_max_core_type
} afw_environment_registry_type_enum_t;
 
 
 
typedef struct afw_environment_default_register_additional_s {
    const afw_utf8_t *key;
} afw_environment_default_register_additional_t;
 
 
 
#define AFW_ENVIRONMENT_Q_EXTENSION_INSTANCE \
    "afw_environment_extension_instance"
 
 
#define AFW_ENVIRONMENT_DEFINE_EXTENSION_IMPL() \
static const afw_extension_t \
impl_extension = \
{ \
    &impl_afw_extension_inf, \
    AFW_UTF8_LITERAL(AFW_IMPLEMENTATION_ID), \
    AFW_UTF8_LITERAL(AFW_IMPLEMENTATION_VERSION), \
    AFW_UTF8_LITERAL(AFW_VERSION_STRING), \
    AFW_VERSION_HEX \
}; \
\
AFW_DEFINE_DSO(const afw_extension_t *) \
afw_environment_extension_instance = &impl_extension
 
 
 
typedef void(*afw_environment_conf_type_create_cede_p_t)(
    const afw_utf8_t *type, const afw_object_t *conf,
    const afw_utf8_t *source_location,
    const afw_pool_t *p, afw_xctx_t *xctx);
 
 
 
typedef void * (*afw_environment_auto_register_cb_t)(
    const afw_utf8_t *registry_type_id,
    const afw_utf8_t *key,
    afw_xctx_t *xctx);
 
 
 
typedef void (*afw_environment_register_additional_cb_t)(
    const afw_utf8_t *registry_type_id,
    int type_number,
    const afw_utf8_t *key,
    const void *value,
    const void *register_additional_param,
    const void **register_additional_use,
    afw_xctx_t *xctx);
 
 
 
/* @brief Entries in environemnt->registry_types[] */
struct afw_environment_registry_type_s {
 
    /* Registry type id */
    const afw_utf8_t *registry_type_id;
 
    /* Type number */
    int number;
 
    /* Object type id */
    const afw_utf8_t *object_type_id;
 
    /* Description */
    const afw_utf8_t *description;
 
    /* Key Name */
    const afw_utf8_t *property_name;
 
    /* Indicates reregister of a key is allowed. */
    afw_boolean_t allow_reregister;
 
    /* Set and used by _AdaptiveEnvironmentRegistryType_. */
    afw_boolean_t auto_register_specified;
 
    /* Hash table used to hold keyed values for this type. */
    apr_hash_t *ht;
 
    /* Function to call for auto register or NULL. */
    afw_environment_auto_register_cb_t auto_register;
 
    /* Function to call after normal registration or NULL. */
    afw_environment_register_additional_cb_t register_additional;
 
    /* Parameter for register_additional function. */
    void *register_additional_param;
 
    /* &register_additional_use passed to register_additional for it's use. */
    const void *register_additional_use;
 
};
 
 
struct afw_environment_conf_type_s {
 
    afw_utf8_t conf_type_id;
 
    const afw_utf8_t *title;
 
    const afw_utf8_t *description;
 
    const afw_utf8_t *id_property_name;
 
    const afw_utf8_t *id_registry_type_id;
 
    const afw_utf8_t *id_runtime_object_type_id;
 
    const afw_utf8_t *subtype_property_name;
 
    const afw_utf8_t *subtype_registry_type_id;
 
    const afw_utf8_t *subtype_runtime_object_type_id;
 
    afw_environment_conf_type_create_cede_p_t create;
 
    afw_boolean_t is_unique;
};
 
 
 
typedef const afw_utf8_z_t * (*afw_environment_error_rv_decoder_z_t) (
    int rv, afw_utf8_z_t *wa, afw_size_t wa_size);
 
 
AFW_DECLARE(afw_xctx_t *)
afw_environment_create(
    unsigned int version,
    int argc, const char * const *argv,
    const afw_error_t **environment_create_error);
 
#define AFW_ENVIRONMENT_CREATE(xctx, argc, argv, environment_create_error) \
    AFW_VERSION_ABORT_IF_NOT_COMPATIBLE("AFW_ENVIRONMENT_CREATE()"); \
    xctx = afw_environment_create(AFW_VERSION_HEX, argc, argv, \
        environment_create_error)
 
 
AFW_DECLARE(void)
afw_environment_release(afw_xctx_t *xctx);
 
 
 
AFW_DEFINE(const afw_object_t *)
afw_environment_registry_object_get_current(afw_xctx_t *xctx);
 
 
 
AFW_DECLARE(void)
afw_environment_configure_with_object(
    const afw_object_t *conf,
    const afw_utf8_t *source_location,
    afw_xctx_t *xctx);
 
 
AFW_DECLARE(void)
afw_environment_configure_with_object_list(
    const afw_list_t *entry_list,
    const afw_utf8_t *source_location,
    afw_xctx_t *xctx);
 
 
 
AFW_DECLARE(const afw_object_t *)
afw_environment_create_environment_variables_object(
    afw_boolean_t preload_variables,
    afw_xctx_t *xctx);
 
 
 
AFW_DECLARE(const afw_extension_t *)
afw_environment_load_extension(
    const afw_utf8_t *extension_id,
    const afw_utf8_t *module_path,
    const afw_object_t *properties,
    afw_xctx_t *xctx);
 
 
 
typedef afw_boolean_t (*afw_environment_foreach_cb_t) (
    int type_number,
    void *data,
    const afw_utf8_octet_t *key_s,
    afw_size_t key_len,
    void *value,
    const afw_pool_t *p,
    afw_xctx_t *xctx);
 
 
AFW_DECLARE(void)
afw_environment_foreach(
    int type_number,
    afw_environment_foreach_cb_t callback,
    void *data,
    const afw_pool_t *p,
    afw_xctx_t *xctx);
 
 
AFW_DECLARE(int)
afw_environment_create_registry_type(
    const afw_utf8_t *registry_type_id,
    const afw_utf8_t *property_name,
    const afw_utf8_t *object_type_id,
    const afw_utf8_t *description,
    afw_boolean_t allow_reregister,
    afw_environment_auto_register_cb_t auto_register,
    afw_environment_register_additional_cb_t register_additional,
    void * register_additional_param,
    afw_xctx_t *xctx);
 
 
AFW_DECLARE(const afw_environment_registry_type_t *)
afw_environment_get_registry_type_by_id(
    const afw_utf8_t *registry_type_id,
    afw_boolean_t load_extension,
    afw_xctx_t *xctx);
 
 
AFW_DECLARE(const afw_environment_registry_type_t *)
afw_environment_get_registry_type_by_number(
    int registry_type_number,
    afw_xctx_t *xctx);
 
 
 
AFW_DECLARE(void)
afw_environment_registry_register(
    int type_number,
    const afw_utf8_t *key,
    const void *value,
    afw_xctx_t *xctx);
 
 
AFW_DECLARE(afw_boolean_t)
afw_environment_registry_key_exists(
    int type_number,
    const afw_utf8_t *key,
    afw_xctx_t *xctx);
 
 
AFW_DECLARE(void *)
afw_environment_registry_get(
    int type_number,
    const afw_utf8_t *key,
    afw_xctx_t *xctx);
 
 
AFW_DECLARE(void *)
afw_environment_registry_get_without_xctx(
    const afw_environment_t *env,
    int type_number,
    const afw_utf8_t *key);
 
 
 
AFW_DEFINE_STATIC_INLINE(const afw_environment_registry_type_t *)
afw_environment_get_registry_type(
    const afw_utf8_t *property_name,
    afw_xctx_t *xctx)
{
    return afw_environment_registry_get(
        afw_environemnt_registry_type_registry_type,
        property_name,
        xctx);
}
 
 
 
AFW_DEFINE_STATIC_INLINE(void)
afw_environment_register_singleton(
    const afw_utf8_t *singleton_key,
    const void *void_ptr,
    afw_xctx_t *xctx)
{
    afw_environment_registry_register(
        afw_environemnt_registry_type_singleton,
        singleton_key,
        void_ptr,
        xctx);
}
 
 
AFW_DEFINE_STATIC_INLINE(void *)
afw_environment_get_singleton(
    const afw_utf8_t *singleton_key, afw_xctx_t *xctx)
{
    return afw_environment_registry_get(
        afw_environemnt_registry_type_singleton,
        singleton_key,
        xctx);
}
 
 
AFW_DEFINE(void)
afw_environment_register_adaptor_type(
    const afw_utf8_t *adaptor_type,
    const afw_adaptor_factory_t *adaptor_factory,
    afw_xctx_t *xctx);
 
 
AFW_DEFINE_STATIC_INLINE(const afw_adaptor_factory_t *)
afw_environment_get_adaptor_type(
    const afw_utf8_t *adaptor_type,
    afw_xctx_t *xctx)
{
    return (const afw_adaptor_factory_t *) afw_environment_registry_get(
        afw_environemnt_registry_type_adaptor_type,
        adaptor_type,
        xctx);
}
 
 
AFW_DEFINE_STATIC_INLINE(void)
afw_environment_register_adaptor_id(
    const afw_utf8_t *adaptor_id,
    const afw_adaptor_id_anchor_t *anchor,
    afw_xctx_t *xctx)
{
    afw_environment_registry_register(
        afw_environemnt_registry_type_adaptor_id,
        adaptor_id,
        anchor,
        xctx);
}
 
 
AFW_DEFINE_STATIC_INLINE(const afw_adaptor_id_anchor_t *)
afw_environment_get_adaptor_id(
    const afw_utf8_t *adaptor_id,
    afw_xctx_t *xctx)
{
    return (const afw_adaptor_id_anchor_t *)afw_environment_registry_get(
        afw_environemnt_registry_type_adaptor_id,
        adaptor_id,
        xctx);
}
 
 
AFW_DEFINE(void)
afw_environment_register_authorization_handler_type(
    const afw_utf8_t *authorization_handler_type,
    const afw_authorization_handler_factory_t *authorization_handler_factory,
    afw_xctx_t *xctx);
 
 
 
AFW_DEFINE_STATIC_INLINE(const afw_authorization_handler_factory_t *)
afw_environment_get_authorization_handler_type(
    const afw_utf8_t *authorization_handler_type,
    afw_xctx_t *xctx)
{
    return (const afw_authorization_handler_factory_t *)
        afw_environment_registry_get(
            afw_environemnt_registry_type_authorization_handler_type,
            authorization_handler_type,
            xctx);
}
 
 
 
AFW_DEFINE_STATIC_INLINE(void)
afw_environment_register_authorization_handler_id(
    const afw_utf8_t *authorization_handler_id,
    const afw_authorization_handler_id_anchor_t *anchor,
    afw_xctx_t *xctx)
{
    afw_environment_registry_register(
        afw_environemnt_registry_type_authorization_handler_id,
        authorization_handler_id,
        anchor,
        xctx);
}
 
 
 
AFW_DEFINE_STATIC_INLINE(const afw_authorization_handler_id_anchor_t *)
afw_environment_get_authorization_handler_id(
    const afw_utf8_t *authorization_handler_id,
    afw_xctx_t *xctx)
{
    return (const afw_authorization_handler_id_anchor_t *)
        afw_environment_registry_get(
            afw_environemnt_registry_type_authorization_handler_id,
            authorization_handler_id,
            xctx);
}
 
 
 
AFW_DECLARE(void)
afw_environment_create_and_register_conf_type(
    const afw_utf8_t *conf_type_id,
    afw_environment_conf_type_create_cede_p_t create,
    const afw_utf8_t *title,
    const afw_utf8_t *description,
    const afw_utf8_t *id_property_name,
    const afw_utf8_t *id_registry_type_id,
    const afw_utf8_t *id_runtime_object_type_id,
    const afw_utf8_t *subtype_property_name,
    const afw_utf8_t *subtype_registry_type_id,
    const afw_utf8_t *subtype_runtime_object_type_id,
    afw_boolean_t is_unique,
    afw_xctx_t *xctx);
 
 
AFW_DEFINE_STATIC_INLINE(const afw_environment_conf_type_t *)
afw_environment_get_conf_type(
const afw_utf8_t *type,
    afw_xctx_t *xctx)
{
    return (const afw_environment_conf_type_t *)afw_environment_registry_get(
        afw_environemnt_registry_type_conf_type,
        type, xctx);
}
 
 
 
AFW_DECLARE(const afw_object_t *)
afw_environment_prepare_conf_type_properties(
    const afw_object_t *properties,
    afw_xctx_t *xctx);
 
 
 
AFW_DEFINE_STATIC_INLINE(void)
afw_environment_register_content_type(
    const afw_utf8_t *type,
    const afw_content_type_t *content_type,
    afw_xctx_t *xctx)
{
    afw_environment_registry_register(
        afw_environemnt_registry_type_content_type,
        type,
        content_type,
        xctx);
}
 
 
 
AFW_DEFINE_STATIC_INLINE(const afw_content_type_t *)
afw_environment_get_content_type(
    const afw_utf8_t *type,
    afw_xctx_t *xctx)
{
    return (afw_content_type_t *)afw_environment_registry_get(
        afw_environemnt_registry_type_content_type,
        type, xctx);
}
 
 
 
AFW_DEFINE_STATIC_INLINE(void)
afw_environment_register_context_type(
    const afw_utf8_t *context_type_id,
    const afw_object_t *context_type_object,
    afw_xctx_t *xctx)
{
    afw_environment_registry_register(
        afw_environemnt_registry_type_context_type,
        context_type_id,
        context_type_object,
        xctx);
}
 
 
 
AFW_DEFINE_STATIC_INLINE(const afw_object_t *)
afw_environment_get_context_type(
    const afw_utf8_t *context_type_id,
    afw_xctx_t *xctx)
{
    return (const afw_object_t *)afw_environment_registry_get(
        afw_environemnt_registry_type_context_type,
        context_type_id, xctx);
}
 
 
 
AFW_DECLARE(void)
afw_environment_register_data_type(
    const afw_utf8_t *data_type_id,
    const afw_data_type_t *data_type,
    afw_xctx_t *xctx);
 
 
 
AFW_DECLARE(void)
afw_environment_register_data_types(
    const afw_data_type_t * const *data_types,
    afw_xctx_t *xctx);
 
 
 
AFW_DEFINE_STATIC_INLINE(const afw_data_type_t *)
afw_environment_get_data_type(
    const afw_utf8_t *type,
    afw_xctx_t *xctx)
{
    return (const afw_data_type_t *)afw_environment_registry_get(
        afw_environemnt_registry_type_data_type,
        type, xctx);
}
 
 
 
AFW_DEFINE_STATIC_INLINE(void)
afw_environment_register_error_rv_decoder(
    const afw_utf8_t *rv_source_id,
    afw_environment_error_rv_decoder_z_t rv_decoder,
    afw_xctx_t *xctx)
{
    afw_environment_registry_register(
        afw_environemnt_registry_type_error_rv_decoder,
        rv_source_id,
        rv_decoder,
        xctx);
}
 
 
 
AFW_DEFINE_STATIC_INLINE(afw_environment_error_rv_decoder_z_t)
afw_environment_get_error_rv_decoder(
    const afw_utf8_t *rv_source_id,
    afw_xctx_t *xctx)
{
    return (afw_environment_error_rv_decoder_z_t)afw_environment_registry_get(
        afw_environemnt_registry_type_error_rv_decoder,
        rv_source_id, xctx);
}
 
 
 
#define afw_environment_register_flag( \
    flag_id, brief, description, included_by_flag_id, xctx) \
afw_flag_environment_register_flag( \
    flag_id, brief, description, included_by_flag_id, xctx)
 
 
 
AFW_DEFINE_STATIC_INLINE(const  afw_flag_t *)
afw_environment_get_flag(
    const afw_utf8_t *flag_id,
    afw_xctx_t *xctx)
{
    return ( afw_flag_t *)afw_environment_registry_get(
        afw_environemnt_registry_type_flag,
        flag_id,
        xctx);
}
 
 
 
AFW_DECLARE(void)
afw_environment_register_function(
    const afw_utf8_t *function_id,
    const afw_value_function_definition_t *function,
    afw_xctx_t *xctx);
 
 
 
AFW_DECLARE(void)
afw_environment_register_functions(
    const afw_value_function_definition_t **functions,
    afw_xctx_t *xctx);
 
 
AFW_DEFINE_STATIC_INLINE(const afw_value_function_definition_t *)
afw_environment_get_function(
    const afw_utf8_t *function_id,
    afw_xctx_t *xctx)
{
    return (const afw_value_function_definition_t *)afw_environment_registry_get(
        afw_environemnt_registry_type_function,
        function_id,
        xctx);
}
 
 
AFW_DECLARE(const afw_value_function_definition_t *)
afw_environment_get_qualified_function(
    const afw_utf8_t *qualifier,
    const afw_utf8_t *name,
    afw_xctx_t *xctx);
 
 
AFW_DECLARE(const afw_value_function_definition_t *)
afw_environment_registry_get_data_type_method(
    const afw_data_type_t * data_type,
    afw_integer_t dataTypeMethodNumber,
    afw_xctx_t *xctx);
 
 
AFW_DEFINE_STATIC_INLINE(void)
afw_environment_register_lock(
    const afw_utf8_t *lock_id,
    const afw_lock_t *lock,
    afw_xctx_t *xctx)
{
    afw_environment_registry_register(
        afw_environemnt_registry_type_lock,
        lock_id,
        lock,
        xctx);
}
 
 
AFW_DEFINE_STATIC_INLINE(const afw_lock_t *)
afw_environment_get_lock(
    const afw_utf8_t *log_type,
    afw_xctx_t *xctx)
{
    return (const afw_lock_t *)afw_environment_registry_get(
        afw_environemnt_registry_type_log_type,
        log_type,
        xctx);
}
 
 
AFW_DEFINE_STATIC_INLINE(void)
afw_environment_register_log_type(
    const afw_utf8_t *log_type,
    const afw_log_factory_t *log_factory,
    afw_xctx_t *xctx)
{
    afw_environment_registry_register(
        afw_environemnt_registry_type_log_type,
        log_type,
        log_factory,
        xctx);
}
 
 
 
AFW_DEFINE_STATIC_INLINE(const afw_log_factory_t *)
afw_environment_get_log_type(
    const afw_utf8_t *log_type,
    afw_xctx_t *xctx)
{
    return (const afw_log_factory_t *)afw_environment_registry_get(
        afw_environemnt_registry_type_log_type,
        log_type,
        xctx);
}
 
 
AFW_DEFINE_STATIC_INLINE(void)
afw_environment_register_log(
    const afw_utf8_t *log_id,
    const afw_log_t *log,
    afw_xctx_t *xctx)
{
    afw_environment_registry_register(
        afw_environemnt_registry_type_log,
        log_id,
        log,
        xctx);
}
 
 
 
AFW_DEFINE_STATIC_INLINE(const afw_log_t *)
afw_environment_get_log(
    const afw_utf8_t *log_id,
    afw_xctx_t *xctx)
{
    return (const afw_log_t *)afw_environment_registry_get(
        afw_environemnt_registry_type_log,
        log_id,
        xctx);
}
 
 
 
AFW_DEFINE_STATIC_INLINE(void)
afw_environment_register_policy_combining_algorithm(
    const afw_utf8_t *policy_combining_algorithm_id,
    const afw_value_function_definition_t *function,
    afw_xctx_t *xctx)
{
    afw_environment_registry_register(
        afw_environemnt_registry_type_policy_combining_algorithm,
        policy_combining_algorithm_id,
        function,
        xctx);
}
 
 
 
AFW_DEFINE_STATIC_INLINE(const afw_value_function_definition_t *)
afw_environment_get_policy_combining_algorithm(
    const afw_utf8_t *policy_combining_algorithm_id,
    afw_xctx_t *xctx)
{
    return (const afw_value_function_definition_t *)afw_environment_registry_get(
        afw_environemnt_registry_type_policy_combining_algorithm,
        policy_combining_algorithm_id,
        xctx);
}
 
 
 
AFW_DEFINE_STATIC_INLINE(void)
afw_environment_register_request_handler_type(
    const afw_utf8_t *handler_type,
    const afw_request_handler_factory_t *request_handler_factory,
    afw_xctx_t *xctx)
{
    afw_environment_registry_register(
        afw_environemnt_registry_type_request_handler_type,
        handler_type,
        request_handler_factory,
        xctx);
}
 
 
 
AFW_DEFINE_STATIC_INLINE(const afw_request_handler_factory_t *)
afw_environment_get_request_handler_type(
    const afw_utf8_t *handler_type,
    afw_xctx_t *xctx)
 
{
    return (const afw_request_handler_factory_t *)
        afw_environment_registry_get(
        afw_environemnt_registry_type_request_handler_type,
        handler_type,
        xctx);
}
 
 
AFW_DEFINE_STATIC_INLINE(void)
afw_environment_register_rule_combining_algorithm(
    const afw_utf8_t *rule_combining_algorithm_id,
    const afw_value_function_definition_t *function,
    afw_xctx_t *xctx)
{
    afw_environment_registry_register(
        afw_environemnt_registry_type_rule_combining_algorithm,
        rule_combining_algorithm_id,
        function,
        xctx);
}
 
 
 
AFW_DEFINE_STATIC_INLINE(const afw_value_function_definition_t *)
afw_environment_get_rule_combining_algorithm(
    const afw_utf8_t *rule_combining_algorithm_id,
    afw_xctx_t *xctx)
{
    return (const afw_value_function_definition_t *)afw_environment_registry_get(
        afw_environemnt_registry_type_rule_combining_algorithm,
        rule_combining_algorithm_id,
        xctx);
}
 
 
 
AFW_DEFINE_STATIC_INLINE(void)
afw_environment_register_runtime_custom(
    const afw_utf8_t *object_type_id,
    const afw_runtime_custom_t *custom,
    afw_xctx_t *xctx)
{
    afw_environment_registry_register(
        afw_environemnt_registry_type_runtime_custom,
        object_type_id,
        custom,
        xctx);
}
 
 
AFW_DEFINE_STATIC_INLINE(const afw_runtime_custom_t *)
afw_environment_get_runtime_custom(
    const afw_utf8_t *object_type_id,
    afw_xctx_t *xctx)
 
{
    return (const afw_runtime_custom_t *)
        afw_environment_registry_get(
        afw_environemnt_registry_type_runtime_custom,
        object_type_id,
        xctx);
}
 
 
AFW_DEFINE_STATIC_INLINE(void)
afw_environment_register_runtime_object_map_inf(
    const afw_utf8_t *object_type_id,
    const afw_object_inf_t *inf,
    afw_xctx_t *xctx)
{
    afw_environment_registry_register(
        afw_environemnt_registry_type_runtime_object_map_inf,
        object_type_id,
        inf,
        xctx);
}
 
 
AFW_DEFINE_STATIC_INLINE(const afw_object_inf_t *)
afw_environment_get_runtime_object_map_inf(
    const afw_utf8_t *object_type_id,
    afw_xctx_t *xctx)
{
    return (const afw_object_inf_t *)afw_environment_registry_get(
        afw_environemnt_registry_type_runtime_object_map_inf,
        object_type_id,
        xctx);
}
 
 
AFW_DEFINE_STATIC_INLINE(void)
afw_environment_register_runtime_value_accessor(
    const afw_utf8_t *accessor_name,
    afw_runtime_value_accessor_t function,
    afw_xctx_t *xctx)
{
    afw_environment_registry_register(
        afw_environemnt_registry_type_runtime_value_accessor,
        accessor_name,
        function,
        xctx);
}
 
 
AFW_DEFINE_STATIC_INLINE(afw_runtime_value_accessor_t)
afw_environment_get_runtime_value_accessor(
    const afw_utf8_t *accessor_name,
    afw_xctx_t *xctx)
{
    return (afw_runtime_value_accessor_t)afw_environment_registry_get(
        afw_environemnt_registry_type_runtime_value_accessor,
        accessor_name,
        xctx);
}
 
 
 
AFW_DEFINE_STATIC_INLINE(void)
afw_environment_register_service(
    const afw_utf8_t *service_id,
    afw_service_t *service,
    afw_xctx_t *xctx)
{
    afw_environment_registry_register(
        afw_environemnt_registry_type_service,
        service_id,
        service,
        xctx);
}
 
 
AFW_DEFINE_STATIC_INLINE(afw_service_t *)
afw_environment_get_service(
    const afw_utf8_t *service_id,
    afw_xctx_t *xctx)
{
    return (afw_service_t *)afw_environment_registry_get(
        afw_environemnt_registry_type_service,
        service_id,
        xctx);
}
 
 
 
AFW_DEFINE_STATIC_INLINE(void)
afw_environment_register_service_type(
    const afw_utf8_t *service_type_id,
    const afw_service_type_t *service_type,
    afw_xctx_t *xctx)
{
    afw_environment_registry_register(
        afw_environemnt_registry_type_service_type,
        service_type_id,
        service_type,
        xctx);
}
 
 
 
 
AFW_DEFINE_STATIC_INLINE(const afw_service_type_t *)
afw_environment_get_service_type(
    const afw_utf8_t *service_type_id,
    afw_xctx_t *xctx)
{
    return (afw_service_type_t *)afw_environment_registry_get(
        afw_environemnt_registry_type_service_type,
        service_type_id,
        xctx);
}
 
 
 
AFW_DEFINE_STATIC_INLINE(void)
afw_environment_register_value_inf(
    const afw_utf8_t *value_inf_id,
    const afw_value_inf_t *value_inf,
    afw_xctx_t *xctx)
{
    afw_environment_registry_register(
        afw_environemnt_registry_type_value_inf,
        value_inf_id,
        value_inf,
        xctx);
}
 
 
AFW_DEFINE_STATIC_INLINE(const afw_value_inf_t *)
afw_environment_get_value_inf(
    const afw_utf8_t *value_inf_id,
    afw_xctx_t *xctx)
{
    return (const afw_value_inf_t *)afw_environment_registry_get(
        afw_environemnt_registry_type_value_inf,
        value_inf_id,
        xctx);
}
 
 
AFW_DECLARE(void)
afw_environment_set_debug_fd(FILE *fd, afw_xctx_t *xctx);
 
 
AFW_DECLARE(void)
afw_environment_set_stderr_fd(FILE *fd, afw_xctx_t *xctx);
 
 
AFW_DECLARE(void)
afw_environment_set_stdout_fd(FILE *fd, afw_xctx_t *xctx);
 
AFW_END_DECLARES
 
#endif /* __AFW_ENVIRONMENT_H__ */