base.h

Go to the documentation of this file.

#ifndef _CCS_BASE_H
#define _CCS_BASE_H
#include <limits.h>
#include <math.h>
#include <string.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef double   ccs_float_t;
typedef int64_t  ccs_int_t;
typedef int32_t  ccs_bool_t;
typedef uint32_t ccs_hash_t;
 
typedef struct {
    uint16_t revision;
    uint16_t patch;
    uint16_t minor;
    uint16_t major;
} ccs_version_t;
 
extern const ccs_version_t ccs_version;
 
#define CCS_TRUE     ((ccs_bool_t)(1))
#define CCS_FALSE    ((ccs_bool_t)(0))
 
#define CCS_INT_MAX  INT64_MAX
#define CCS_INT_MIN  INT64_MIN
#define CCS_INFINITY INFINITY
 
typedef struct _ccs_rng_s                  *ccs_rng_t;
typedef struct _ccs_distribution_s         *ccs_distribution_t;
typedef struct _ccs_parameter_s            *ccs_parameter_t;
typedef struct _ccs_expression_s           *ccs_expression_t;
typedef struct _ccs_context_s              *ccs_context_t;
typedef struct _ccs_distribution_space_s   *ccs_distribution_space_t;
typedef struct _ccs_search_space_s         *ccs_search_space_t;
typedef struct _ccs_configuration_space_s  *ccs_configuration_space_t;
typedef struct _ccs_binding_s              *ccs_binding_t;
typedef struct _ccs_search_configuration_s *ccs_search_configuration_t;
typedef struct _ccs_configuration_s        *ccs_configuration_t;
typedef struct _ccs_feature_space_s        *ccs_feature_space_t;
typedef struct _ccs_features_s             *ccs_features_t;
typedef struct _ccs_objective_space_s      *ccs_objective_space_t;
typedef struct _ccs_evaluation_s           *ccs_evaluation_t;
typedef struct _ccs_tuner_s                *ccs_tuner_t;
typedef struct _ccs_map_s                  *ccs_map_t;
typedef struct _ccs_error_stack_s          *ccs_error_stack_t;
typedef struct _ccs_tree_s                 *ccs_tree_t;
typedef struct _ccs_tree_space_s           *ccs_tree_space_t;
typedef struct _ccs_tree_configuration_s   *ccs_tree_configuration_t;
 
enum ccs_result_e {
    CCS_RESULT_MAX                              = 2,
    CCS_RESULT_AGAIN                            = 1,
    CCS_RESULT_SUCCESS                          = 0,
    CCS_RESULT_ERROR_INVALID_OBJECT             = -1,
    CCS_RESULT_ERROR_INVALID_VALUE              = -2,
    CCS_RESULT_ERROR_INVALID_TYPE               = -3,
    CCS_RESULT_ERROR_INVALID_SCALE              = -4,
    CCS_RESULT_ERROR_INVALID_DISTRIBUTION       = -5,
    CCS_RESULT_ERROR_INVALID_EXPRESSION         = -6,
    CCS_RESULT_ERROR_INVALID_PARAMETER          = -7,
    CCS_RESULT_ERROR_INVALID_CONFIGURATION      = -8,
    CCS_RESULT_ERROR_INVALID_NAME               = -9,
    CCS_RESULT_ERROR_INVALID_CONDITION          = -10,
    CCS_RESULT_ERROR_INVALID_TUNER              = -11,
    CCS_RESULT_ERROR_INVALID_GRAPH              = -12,
    CCS_RESULT_ERROR_TYPE_NOT_COMPARABLE        = -13,
    CCS_RESULT_ERROR_INVALID_BOUNDS             = -14,
    CCS_RESULT_ERROR_OUT_OF_BOUNDS              = -15,
    CCS_RESULT_ERROR_SAMPLING_UNSUCCESSFUL      = -16,
    CCS_RESULT_ERROR_OUT_OF_MEMORY              = -17,
    CCS_RESULT_ERROR_UNSUPPORTED_OPERATION      = -18,
    CCS_RESULT_ERROR_INVALID_EVALUATION         = -19,
    CCS_RESULT_ERROR_INVALID_FEATURES           = -20,
    CCS_RESULT_ERROR_INVALID_FILE_PATH          = -21,
    CCS_RESULT_ERROR_NOT_ENOUGH_DATA            = -22,
    CCS_RESULT_ERROR_DUPLICATE_HANDLE           = -23,
    CCS_RESULT_ERROR_INVALID_HANDLE             = -24,
    CCS_RESULT_ERROR_SYSTEM                     = -25,
    CCS_RESULT_ERROR_EXTERNAL                   = -26,
    CCS_RESULT_ERROR_INVALID_TREE               = -27,
    CCS_RESULT_ERROR_INVALID_TREE_SPACE         = -28,
    CCS_RESULT_ERROR_INVALID_DISTRIBUTION_SPACE = -29,
    CCS_RESULT_MIN                              = -30,
    CCS_RESULT_FORCE_32BIT                      = INT32_MAX
};
 
typedef enum ccs_result_e ccs_result_t;
 
typedef int32_t           ccs_evaluation_result_t;
 
enum ccs_object_type_e {
    CCS_OBJECT_TYPE_RNG,
    CCS_OBJECT_TYPE_DISTRIBUTION,
    CCS_OBJECT_TYPE_PARAMETER,
    CCS_OBJECT_TYPE_EXPRESSION,
    CCS_OBJECT_TYPE_CONFIGURATION_SPACE,
    CCS_OBJECT_TYPE_CONFIGURATION,
    CCS_OBJECT_TYPE_OBJECTIVE_SPACE,
    CCS_OBJECT_TYPE_EVALUATION,
    CCS_OBJECT_TYPE_TUNER,
    CCS_OBJECT_TYPE_FEATURE_SPACE,
    CCS_OBJECT_TYPE_FEATURES,
    CCS_OBJECT_TYPE_MAP,
    CCS_OBJECT_TYPE_ERROR_STACK,
    CCS_OBJECT_TYPE_TREE,
    CCS_OBJECT_TYPE_TREE_SPACE,
    CCS_OBJECT_TYPE_TREE_CONFIGURATION,
    CCS_OBJECT_TYPE_DISTRIBUTION_SPACE,
    CCS_OBJECT_TYPE_MAX,
    CCS_OBJECT_TYPE_FORCE_32BIT = INT32_MAX
};
 
typedef enum ccs_object_type_e ccs_object_type_t;
 
enum ccs_data_type_e {
    CCS_DATA_TYPE_NONE,
    CCS_DATA_TYPE_INT,
    CCS_DATA_TYPE_FLOAT,
    CCS_DATA_TYPE_BOOL,
    CCS_DATA_TYPE_STRING,
    CCS_DATA_TYPE_INACTIVE,
    CCS_DATA_TYPE_OBJECT,
    CCS_DATA_TYPE_MAX,
    CCS_DATA_TYPE_FORCE_32BIT = INT32_MAX
};
 
typedef enum ccs_data_type_e ccs_data_type_t;
 
enum ccs_datum_flag_e {
    CCS_DATUM_FLAG_DEFAULT     = 0,
    CCS_DATUM_FLAG_TRANSIENT   = (1 << 0),
    CCS_DATUM_FLAG_UNPOOLED    = (1 << 1),
    CCS_DATUM_FLAG_ID          = (1 << 2),
    CCS_DATUM_FLAG_FORCE_32BIT = INT32_MAX
};
 
typedef enum ccs_datum_flag_e ccs_datum_flag_t;
 
typedef uint32_t              ccs_datum_flags_t;
 
enum ccs_numeric_type_e {
    CCS_NUMERIC_TYPE_INT   = CCS_DATA_TYPE_INT,
    CCS_NUMERIC_TYPE_FLOAT = CCS_DATA_TYPE_FLOAT,
    CCS_NUMERIC_TYPE_MAX,
    CCS_NUMERIC_TYPE_FORCE_32BIT = INT32_MAX
};
 
typedef enum ccs_numeric_type_e ccs_numeric_type_t;
 
typedef void                   *ccs_object_t;
 
union ccs_numeric_u {
    ccs_float_t f;
    ccs_int_t   i;
#ifdef __cplusplus
    ccs_numeric_u(void)
        : i(0L)
    {
    }
    ccs_numeric_u(float v)
        : f((ccs_float_t)v)
    {
    }
    ccs_numeric_u(int v)
        : i((ccs_int_t)v)
    {
    }
    ccs_numeric_u(ccs_int_t v)
        : i(v)
    {
    }
    ccs_numeric_u(ccs_float_t v)
        : f(v)
    {
    }
#endif
};
 
typedef union ccs_numeric_u ccs_numeric_t;
 
#ifdef __cplusplus
#define CCSF(v) v
#define CCSI(v) v
#else
#define CCSF(v) ((ccs_numeric_t){.f = v})
#define CCSI(v) ((ccs_numeric_t){.i = v})
#endif
 
union ccs_value_u {
    ccs_float_t  f;
    ccs_int_t    i;
    const char  *s;
    ccs_object_t o;
#ifdef __cplusplus
    ccs_value_u(void)
        : i(0L)
    {
    }
    ccs_value_u(float v)
        : f((ccs_float_t)v)
    {
    }
    ccs_value_u(int v)
        : i((ccs_int_t)v)
    {
    }
    ccs_value_u(ccs_float_t v)
        : f(v)
    {
    }
    ccs_value_u(ccs_int_t v)
        : i(v)
    {
    }
    ccs_value_u(char *v)
        : s(v)
    {
    }
    ccs_value_u(ccs_object_t v)
        : o(v)
    {
    }
#endif
};
 
typedef union ccs_value_u ccs_value_t;
 
struct ccs_datum_s {
    ccs_value_t       value;
    ccs_data_type_t   type;
    ccs_datum_flags_t flags;
};
 
typedef struct ccs_datum_s ccs_datum_t;
 
static inline ccs_datum_t
ccs_bool(ccs_bool_t v)
{
    ccs_datum_t d;
    d.type    = CCS_DATA_TYPE_BOOL;
    d.value.i = v;
    d.flags   = CCS_DATUM_FLAG_DEFAULT;
    return d;
}
 
static inline ccs_datum_t
ccs_float(ccs_float_t v)
{
    ccs_datum_t d;
    d.type    = CCS_DATA_TYPE_FLOAT;
    d.value.f = v;
    d.flags   = CCS_DATUM_FLAG_DEFAULT;
    return d;
}
 
static inline ccs_datum_t
ccs_int(ccs_int_t v)
{
    ccs_datum_t d;
    d.type    = CCS_DATA_TYPE_INT;
    d.value.i = v;
    d.flags   = CCS_DATUM_FLAG_DEFAULT;
    return d;
}
 
static inline ccs_datum_t
ccs_object(ccs_object_t v)
{
    ccs_datum_t d;
    d.type    = CCS_DATA_TYPE_OBJECT;
    d.value.o = v;
    d.flags   = CCS_DATUM_FLAG_DEFAULT;
    return d;
}
 
static inline ccs_datum_t
ccs_string(const char *v)
{
    ccs_datum_t d;
    d.type    = CCS_DATA_TYPE_STRING;
    d.value.s = v;
    d.flags   = CCS_DATUM_FLAG_DEFAULT;
    return d;
}
 
static inline int
ccs_datum_cmp(const ccs_datum_t a, const ccs_datum_t b)
{
    if (a.type < b.type) {
        return -1;
    } else if (a.type > b.type) {
        return 1;
    } else {
        switch (a.type) {
        case CCS_DATA_TYPE_STRING:
            if (a.value.s == b.value.s)
                return 0;
            else if (!a.value.s)
                return -1;
            else if (!b.value.s)
                return 1;
            else
                return strcmp(a.value.s, b.value.s);
            break;
        case CCS_DATA_TYPE_INT:
            return a.value.i < b.value.i ? -1 :
                   a.value.i > b.value.i ? 1 :
                               0;
            break;
        case CCS_DATA_TYPE_FLOAT:
            return a.value.f < b.value.f ? -1 :
                   a.value.f > b.value.f ? 1 :
                               0;
            break;
        case CCS_DATA_TYPE_NONE:
        case CCS_DATA_TYPE_INACTIVE:
            return 0;
            break;
        default:
            return memcmp(
                &(a.value), &(b.value), sizeof(ccs_value_t));
        }
    }
}
 
extern const ccs_datum_t ccs_none;
extern const ccs_datum_t ccs_inactive;
extern const ccs_datum_t ccs_true;
extern const ccs_datum_t ccs_false;
 
#define CCS_NONE_VAL                                                           \
    {                                                                      \
        {0}, CCS_DATA_TYPE_NONE, CCS_DATUM_FLAG_DEFAULT                \
    }
#define CCS_INACTIVE_VAL                                                       \
    {                                                                      \
        {0}, CCS_DATA_TYPE_INACTIVE, CCS_DATUM_FLAG_DEFAULT            \
    }
#ifdef __cplusplus
#define CCS_TRUE_VAL                                                           \
    {                                                                      \
        {(ccs_int_t)CCS_TRUE}, CCS_DATA_TYPE_BOOL,                     \
            CCS_DATUM_FLAG_DEFAULT                                 \
    }
#define CCS_FALSE_VAL                                                          \
    {                                                                      \
        {(ccs_int_t)CCS_FALSE}, CCS_DATA_TYPE_BOOL,                    \
            CCS_DATUM_FLAG_DEFAULT                                 \
    }
#else
#define CCS_TRUE_VAL                                                           \
    {                                                                      \
        {.i = CCS_TRUE}, CCS_DATA_TYPE_BOOL, CCS_DATUM_FLAG_DEFAULT    \
    }
#define CCS_FALSE_VAL                                                          \
    {                                                                      \
        {.i = CCS_FALSE}, CCS_DATA_TYPE_BOOL, CCS_DATUM_FLAG_DEFAULT   \
    }
#endif
 
extern ccs_result_t
ccs_init(void);
 
extern ccs_result_t
ccs_fini(void);
 
extern ccs_result_t
ccs_get_result_name(ccs_result_t result, const char **name);
 
extern ccs_version_t
ccs_get_version(void);
 
extern const char *
ccs_get_version_string(void);
 
extern ccs_result_t
ccs_retain_object(ccs_object_t object);
 
extern ccs_result_t
ccs_release_object(ccs_object_t object);
 
extern ccs_result_t
ccs_object_get_type(ccs_object_t object, ccs_object_type_t *type_ret);
 
extern ccs_result_t
ccs_object_get_refcount(ccs_object_t object, int32_t *refcount_ret);
 
typedef void (
    *ccs_object_destroy_callback_t)(ccs_object_t object, void *user_data);
 
extern ccs_result_t
ccs_object_set_destroy_callback(
    ccs_object_t                  object,
    ccs_object_destroy_callback_t callback,
    void                         *user_data);
 
extern ccs_result_t
ccs_object_set_user_data(ccs_object_t object, void *user_data);
 
extern ccs_result_t
ccs_object_get_user_data(ccs_object_t object, void **user_data_ret);
 
typedef ccs_result_t (*ccs_object_serialize_callback_t)(
    ccs_object_t object,
    size_t       serialize_data_size,
    void        *serialize_data,
    size_t      *serialize_data_size_ret,
    void        *callback_user_data);
 
extern ccs_result_t
ccs_object_set_serialize_callback(
    ccs_object_t                    object,
    ccs_object_serialize_callback_t callback,
    void                           *user_data);
 
enum ccs_serialize_format_e {
    CCS_SERIALIZE_FORMAT_BINARY,
    CCS_SERIALIZE_FORMAT_MAX,
    CCS_SERIALIZE_FORMAT_FORCE_32BIT = INT32_MAX
};
typedef enum ccs_serialize_format_e ccs_serialize_format_t;
 
enum ccs_serialize_operation_e {
    CCS_SERIALIZE_OPERATION_SIZE,
    CCS_SERIALIZE_OPERATION_MEMORY,
    CCS_SERIALIZE_OPERATION_FILE,
    CCS_SERIALIZE_OPERATION_FILE_DESCRIPTOR,
    CCS_SERIALIZE_OPERATION_MAX,
    CCS_SERIALIZE_OPERATION_FORCE_32BIT = INT32_MAX
};
typedef enum ccs_serialize_operation_e ccs_serialize_operation_t;
 
enum ccs_deserialize_operation_e {
    CCS_DESERIALIZE_OPERATION_MEMORY,
    CCS_DESERIALIZE_OPERATION_FILE,
    CCS_DESERIALIZE_OPERATION_FILE_DESCRIPTOR,
    CCS_DESERIALIZE_OPERATION_MAX,
    CCS_DESERIALIZE_OPERATION_FORCE_32BIT = INT32_MAX
};
typedef enum ccs_deserialize_operation_e ccs_deserialize_operation_t;
 
enum ccs_serialize_option_e {
    CCS_SERIALIZE_OPTION_END = 0,
    CCS_SERIALIZE_OPTION_NON_BLOCKING,
    CCS_SERIALIZE_OPTION_CALLBACK,
    CCS_SERIALIZE_OPTION_MAX,
    CCS_SERIALIZE_OPTION_FORCE_32BIT = INT32_MAX
};
typedef enum ccs_serialize_option_e ccs_serialize_option_t;
 
typedef ccs_result_t (*ccs_object_deserialize_data_callback_t)(
    ccs_object_t object,
    size_t       serialize_data_size,
    const char  *serialize_data,
    void        *callback_user_data);
 
typedef ccs_result_t (*ccs_object_deserialize_vector_callback_t)(
    ccs_object_type_t type,
    const char       *name,
    void             *callback_user_data,
    void            **vector_ret,
    void            **data_ret);
 
enum ccs_deserialize_option_e {
    CCS_DESERIALIZE_OPTION_END = 0,
    CCS_DESERIALIZE_OPTION_HANDLE_MAP,
    CCS_DESERIALIZE_OPTION_MAP_HANDLES,
    CCS_DESERIALIZE_OPTION_VECTOR_CALLBACK,
    CCS_DESERIALIZE_OPTION_NON_BLOCKING,
    CCS_DESERIALIZE_OPTION_DATA_CALLBACK,
    CCS_DESERIALIZE_OPTION_MAX,
    CCS_DESERIALIZE_OPTION_FORCE_32BIT = INT32_MAX
};
typedef enum ccs_deserialize_option_e ccs_deserialize_option_t;
 
extern ccs_result_t
ccs_object_serialize(
    ccs_object_t              object,
    ccs_serialize_format_t    format,
    ccs_serialize_operation_t operation,
    ...);
 
extern ccs_result_t
ccs_object_deserialize(
    ccs_object_t               *object_ret,
    ccs_serialize_format_t      format,
    ccs_deserialize_operation_t operation,
    ...);
 
#ifdef __cplusplus
}
#endif
 
#endif //_CCS_BASE_H