SOL_API void
sol_oic_resource_unref(struct sol_oic_resource *r)
{
SOL_NULL_CHECK(r);
OIC_RESOURCE_CHECK_API(r);
r->refcnt--;
if (!r->refcnt) {
struct sol_str_slice *slice;
uint16_t idx;
free((char *)r->href.data);
free((char *)r->device_id.data);
SOL_VECTOR_FOREACH_IDX (&r->types, slice, idx)
free((char *)slice->data);
sol_vector_clear(&r->types);
SOL_VECTOR_FOREACH_IDX (&r->interfaces, slice, idx)
free((char *)slice->data);
sol_vector_clear(&r->interfaces);
free(r);
}
}
static inline const void *
sol_mavlink_parse_addr_protocol(const char *str, struct sol_str_slice *addr, int *port)
{
struct sol_vector tokens;
struct sol_str_slice slice = sol_str_slice_from_str(str);
const void *init;
tokens = sol_str_slice_split(slice, ":", 0);
if (tokens.len <= 1) {
SOL_ERR("Invalid addr string, it must specify at least <prot>:<addr>");
return NULL;
}
init = sol_str_table_ptr_lookup_fallback
(protocol_table, STR_SLICE_VAL(sol_vector_get(&tokens, 0)),
sol_mavlink_init_tcp);
if (!init) {
SOL_ERR("Invalid protocol");
goto err;
}
*addr = STR_SLICE_VAL(sol_vector_get(&tokens, 1));
if (tokens.len >= 3)
sol_str_slice_to_int(STR_SLICE_VAL(sol_vector_get(&tokens, 2)), port);
sol_vector_clear(&tokens);
return init;
err:
sol_vector_clear(&tokens);
return NULL;
}
void
sml_fuzzy_destroy(struct sml_fuzzy *fuzzy)
{
delete (fl::Engine*) fuzzy->engine;
sol_vector_clear(&fuzzy->input_terms_width);
sol_vector_clear(&fuzzy->output_terms_width);
free(fuzzy);
}
bool
sml_fuzzy_load_file(struct sml_fuzzy *fuzzy, const char *filename)
{
fl::Engine *engine;
uint16_t i, len;
void *width;
try {
fl::FllImporter importer;
engine = importer.fromFile(filename);
} catch (fl::Exception e) {
sml_critical("%s", e.getWhat().c_str());
return false;
}
if (engine->numberOfInputVariables() == 0 ||
engine->numberOfOutputVariables() == 0) {
sml_critical("Input and output variables must be provided!");
goto error;
}
if (engine->numberOfRuleBlocks() == 0) {
sml_critical("Rule blocks must be provided!");
goto error;
}
if (fuzzy->engine)
delete (fl::Engine*) fuzzy->engine;
fuzzy->engine = engine;
fuzzy->input_list = (struct sml_variables_list*)&(engine->inputVariables());
fuzzy->output_list = (struct sml_variables_list*)&(engine->outputVariables());
fuzzy->input_terms_count = _calc_terms_count(engine->inputVariables());
fuzzy->output_terms_count = _calc_terms_count(engine->outputVariables());
_remove_rule_blocks(engine);
sol_vector_clear(&fuzzy->input_terms_width);
sol_vector_clear(&fuzzy->output_terms_width);
len = engine->inputVariables().size();
for (i = 0; i < len; i++) {
width = sol_vector_append(&fuzzy->input_terms_width);
ON_NULL_RETURN_VAL(width, false);
}
len = engine->outputVariables().size();
for (i = 0; i < len; i++) {
width = sol_vector_append(&fuzzy->output_terms_width);
ON_NULL_RETURN_VAL(width, false);
}
return true;
error:
delete engine;
return false;
}
void
sml_matrix_clear(struct sml_matrix *m)
{
uint16_t i;
struct sol_vector *line;
SOL_VECTOR_FOREACH_IDX (&m->data, line, i)
sol_vector_clear(line);
sol_vector_clear(&m->data);
}
static bool
_sml_ann_bridge_calculate_confidence_interval(struct sml_ann_bridge *iann,
struct sml_variables_list *inputs,
unsigned int observations)
{
unsigned int i, j, inputs_len;
float mean, sd, value;
struct sml_variable *var;
Confidence_Interval *ci;
char var_name[SML_VARIABLE_NAME_MAX_LEN + 1];
sml_debug("Calculating confidence interval");
inputs_len = sml_ann_variables_list_get_length(inputs);
for (i = 0; i < inputs_len; i++) {
mean = sd = 0.0;
var = sml_ann_variables_list_index(inputs, i);
ci = sol_vector_append(&iann->confidence_intervals);
if (!ci) {
sml_critical("Could not alloc the Confidence_Interval");
goto err_exit;
}
for (j = 0; j < observations; j++) {
value = sml_ann_variable_get_value_by_index(var, j);
if (isnan(value))
sml_ann_variable_get_range(var, &value, NULL);
mean += value;
}
mean /= observations;
//Now the standard deviation
for (j = 0; j < observations; j++) {
value = sml_ann_variable_get_value_by_index(var, j);
if (isnan(value))
sml_ann_variable_get_range(var, &value, NULL);
sd += pow(value - mean, 2.0);
}
sd /= observations;
sd = sqrt(sd);
//Confidence interval of 95%
ci->lower_limit = mean - (1.96 * (sd / sqrt(observations)));
ci->upper_limit = mean + (1.96 * (sd / sqrt(observations)));
iann->ci_length_sum += (ci->upper_limit - ci->lower_limit);
if (sml_ann_variable_get_name(var, var_name, sizeof(var_name))) {
sml_warning("Failed to get variable name for %p", var);
continue;
}
sml_debug("Variable:%s mean:%f sd:%f lower:%f upper:%f",
var_name, mean, sd, ci->lower_limit,
ci->upper_limit);
}
return true;
err_exit:
sol_vector_clear(&iann->confidence_intervals);
return false;
}
static bool
on_write(void *data, int fd, uint32_t active_flags)
{
struct subprocess_data *mdata = data;
int err = 0;
if (active_flags & SOL_FD_FLAGS_ERR)
err = -EBADF;
else
err = out_write(mdata);
if (err < 0) {
uint16_t i;
struct write_data *w;
SOL_VECTOR_FOREACH_IDX (&mdata->write_data, w, i)
sol_blob_unref(w->blob);
sol_vector_clear(&mdata->write_data);
}
if (mdata->write_data.len == 0) {
mdata->watches.out = NULL;
return false;
}
return true;
}
static void
counter_close(struct sol_flow_node *node, void *data)
{
struct counter_data *mdata = data;
sol_vector_clear(&mdata->map);
}
void
process_subprocess_close(struct sol_flow_node *node, void *data)
{
struct subprocess_data *mdata = data;
if (mdata->fork_run)
sol_platform_linux_fork_run_stop(mdata->fork_run);
if (mdata->watches.in)
sol_fd_del(mdata->watches.in);
if (mdata->watches.err)
sol_fd_del(mdata->watches.err);
if (mdata->watches.out) {
struct write_data *w;
uint16_t i;
sol_fd_del(mdata->watches.out);
SOL_VECTOR_FOREACH_IDX (&mdata->write_data, w, i)
sol_blob_unref(w->blob);
sol_vector_clear(&mdata->write_data);
}
close(mdata->pipes.in[0]);
close(mdata->pipes.in[1]);
close(mdata->pipes.err[0]);
close(mdata->pipes.err[1]);
close(mdata->pipes.out[0]);
close(mdata->pipes.out[1]);
free(mdata->command);
}
void
byte_validator_close(struct sol_flow_node *node, void *data)
{
struct byte_validator_data *mdata = data;
sol_vector_clear(&mdata->values);
}
static int
_populate_values(void *data, const char *sequence)
{
struct int_validator_data *mdata = data;
char *tail;
const char *it;
int32_t *val;
sol_vector_init(&mdata->values, sizeof(int32_t));
it = sequence;
do {
val = sol_vector_append(&mdata->values);
SOL_NULL_CHECK_GOTO(val, no_memory);
errno = 0;
*val = strtol(it, &tail, 10);
if (errno) {
SOL_WRN("Failed do convert option 'sequence' to int %s: %d", it, errno);
return -errno;
}
if (it == tail) {
SOL_WRN("Failed to convert option 'sequence' to int %s", it);
return -EINVAL;
}
it = tail;
} while (*tail != '\0');
return 0;
no_memory:
sol_vector_clear(&mdata->values);
return -ENOMEM;
}
void
int_generator_close(struct sol_flow_node *node, void *data)
{
struct int_generator_data *mdata = data;
if (mdata->values.len != mdata->next_index)
sol_timeout_del(mdata->timer);
sol_vector_clear(&mdata->values);
}
int
int_generator_open(
struct sol_flow_node *node,
void *data,
const struct sol_flow_node_options *options)
{
struct int_generator_data *mdata = data;
const struct sol_flow_node_type_test_int_generator_options *opts =
(const struct sol_flow_node_type_test_int_generator_options *)options;
const char *it;
char *tail;
int32_t *val;
if (opts->sequence == NULL || *opts->sequence == '\0') {
SOL_ERR("Option 'sequence' is either NULL or empty.");
return -EINVAL;
}
it = opts->sequence;
if (opts->interval.val < 0)
SOL_WRN("Option 'interval' < 0, setting it to 0.");
mdata->interval = opts->interval.val >= 0 ? opts->interval.val : 0;
mdata->next_index = 0;
sol_vector_init(&mdata->values, sizeof(int32_t));
do {
val = sol_vector_append(&mdata->values);
SOL_NULL_CHECK_GOTO(val, no_memory);
errno = 0;
*val = strtol(it, &tail, 10);
if (errno) {
SOL_WRN("Failed do convert option 'sequence' to int %s: %d", it, errno);
goto error;
}
if (it == tail) {
SOL_WRN("Failed to convert option 'sequence' to int %s", it);
errno = -EINVAL;
goto error;
}
it = tail;
} while (*tail != '\0');
mdata->timer = sol_timeout_add(mdata->interval, timer_tick, node);
SOL_NULL_CHECK_GOTO(mdata->timer, error);
return 0;
no_memory:
errno = -ENOMEM;
error:
sol_vector_clear(&mdata->values);
return errno;
}
SOL_API void
sol_oic_resource_unref(struct sol_oic_resource *r)
{
SOL_NULL_CHECK(r);
OIC_RESOURCE_CHECK_API(r);
r->refcnt--;
if (!r->refcnt) {
free((char *)r->href.data);
free((char *)r->device_id.data);
sol_vector_clear(&r->types);
free(r->types_data);
sol_vector_clear(&r->interfaces);
free(r->interfaces_data);
free(r);
}
}
void
sml_matrix_remove_line(struct sml_matrix *m, uint16_t line_num)
{
struct sol_vector *line;
line = sol_vector_get(&m->data, line_num);
if (!line)
return;
sol_vector_clear(line);
sol_vector_del(&m->data, line_num);
}
SOL_API struct sol_vector
sol_str_slice_split(const struct sol_str_slice slice,
const char *delim,
size_t maxsplit)
{
struct sol_vector v = SOL_VECTOR_INIT(struct sol_str_slice);
const char *str = slice.data;
ssize_t dlen;
size_t len;
if (!slice.len || !delim)
return v;
maxsplit = (maxsplit) ? : slice.len - 1;
if (maxsplit == SIZE_MAX) //once we compare to maxsplit + 1
maxsplit--;
dlen = strlen(delim);
len = slice.len;
#define CREATE_SLICE(_str, _len) \
do { \
s = sol_vector_append(&v); \
if (!s) \
goto err; \
s->data = _str; \
s->len = _len; \
} while (0)
while (str && (v.len < maxsplit + 1)) {
struct sol_str_slice *s;
char *token = memmem(str, len, delim, dlen);
if (!token) {
CREATE_SLICE(str, len);
break;
}
if (v.len == (uint16_t)maxsplit)
CREATE_SLICE(str, len);
else
CREATE_SLICE(str, (size_t)(token - str));
len -= (token - str) + dlen;
str = token + dlen;
}
#undef CREATE_SLICE
return v;
err:
sol_vector_clear(&v);
return v;
}
int
float_validator_open(
struct sol_flow_node *node,
void *data,
const struct sol_flow_node_options *options)
{
struct float_validator_data *mdata = data;
const struct sol_flow_node_type_test_float_validator_options *opts =
(const struct sol_flow_node_type_test_float_validator_options *)options;
const char *it;
char *tail;
double *val;
SOL_FLOW_NODE_OPTIONS_SUB_API_CHECK(options,
SOL_FLOW_NODE_TYPE_TEST_FLOAT_VALIDATOR_OPTIONS_API_VERSION,
-EINVAL);
mdata->done = false;
if (opts->sequence == NULL || *opts->sequence == '\0') {
SOL_ERR("Option 'sequence' is either NULL or empty.");
return -EINVAL;
}
sol_vector_init(&mdata->values, sizeof(double));
it = opts->sequence;
do {
val = sol_vector_append(&mdata->values);
SOL_NULL_CHECK_GOTO(val, no_memory);
*val = sol_util_strtod_n(it, &tail, -1, false);
if (errno) {
SOL_WRN("Failed do convert option 'sequence' to double %s: %d", it, errno);
goto error;
}
if (it == tail) {
SOL_WRN("Failed to convert option 'sequence' to double %s", it);
errno = EINVAL;
goto error;
}
it = tail;
} while (*tail != '\0');
return 0;
no_memory:
errno = ENOMEM;
error:
sol_vector_clear(&mdata->values);
return -errno;
}
static void
http_composed_client_type_dispose(struct sol_flow_node_type *type)
{
struct http_composed_client_type *self = (struct http_composed_client_type *)type;
struct http_composed_client_port_out *port_out;
struct http_composed_client_port_in *port_in;
uint16_t i;
#ifdef SOL_FLOW_NODE_TYPE_DESCRIPTION_ENABLED
struct sol_flow_node_type_description *desc;
desc = (struct sol_flow_node_type_description *)self->base.description;
if (desc) {
if (desc->ports_in) {
for (i = 0; i < self->ports_in.len; i++)
free((struct sol_flow_port_description *)desc->ports_in[i]);
free((struct sol_flow_port_description **)desc->ports_in);
}
if (desc->ports_out) {
for (i = 0; i < self->ports_out.len; i++)
free((struct sol_flow_port_description *)desc->ports_out[i]);
free((struct sol_flow_port_description **)desc->ports_out);
}
free(desc);
}
#endif
SOL_VECTOR_FOREACH_IDX (&self->ports_in, port_in, i)
free(port_in->name);
SOL_VECTOR_FOREACH_IDX (&self->ports_out, port_out, i)
free(port_out->name);
sol_vector_clear(&self->ports_in);
sol_vector_clear(&self->ports_out);
free(self);
}
static int
calculate_regexp_substrings(struct string_regexp_search_data *mdata,
struct sol_flow_node *node)
{
if (!(mdata->string && mdata->regexp))
return 0;
sol_vector_clear(&mdata->substrings);
mdata->substrings = string_regexp_search_and_split(mdata);
return sol_flow_send_irange_value_packet(node,
SOL_FLOW_NODE_TYPE_STRING_REGEXP_SEARCH__OUT__LENGTH,
mdata->substrings.len);
}
static bool
_sml_load_fll_file(struct sml_engine *engine, const char *filename)
{
struct sml_fuzzy_engine *fuzzy_engine = (struct sml_fuzzy_engine *)engine;
if (!sml_fuzzy_load_file(fuzzy_engine->fuzzy, filename))
return false;
sml_observation_controller_clear(fuzzy_engine->observation_controller);
sml_terms_manager_clear(&fuzzy_engine->terms_manager);
sol_ptr_vector_clear(&fuzzy_engine->inputs_to_be_removed);
sol_vector_clear(&fuzzy_engine->terms_to_be_removed);
sol_ptr_vector_clear(&fuzzy_engine->outputs_to_be_removed);
return true;
}
struct sol_vector
sol_util_str_split(const struct sol_str_slice slice, const char *delim, size_t maxsplit)
{
struct sol_vector v = SOL_VECTOR_INIT(struct sol_str_slice);
ssize_t dlen, len;
const char *str = slice.data;
if (!slice.len || !delim)
return v;
maxsplit = (maxsplit) ? : slice.len;
dlen = strlen(delim);
len = slice.len;
#define CREATE_SLICE(_str, _len) \
do { \
s = sol_vector_append(&v); \
if (!s) \
goto err; \
s->data = _str; \
s->len = _len; \
} while (0)
while (str && (v.len < maxsplit)) {
struct sol_str_slice *s;
char *token = memmem(str, len, delim, dlen);
if (!token) {
CREATE_SLICE(str, len);
break;
}
len -= (token - str) + dlen;
CREATE_SLICE(str, token - str);
str = token + dlen;
}
#undef CREATE_SLICE
return v;
err:
sol_vector_clear(&v);
return v;
}
int
string_generator_open(
struct sol_flow_node *node,
void *data,
const struct sol_flow_node_options *options)
{
struct string_generator_data *mdata = data;
const struct sol_flow_node_type_test_string_generator_options *opts =
(const struct sol_flow_node_type_test_string_generator_options *)options;
SOL_FLOW_NODE_OPTIONS_SUB_API_CHECK(options,
SOL_FLOW_NODE_TYPE_TEST_STRING_GENERATOR_OPTIONS_API_VERSION,
-EINVAL);
sol_vector_init(&mdata->values, sizeof(struct sol_str_slice));
if (opts->sequence == NULL || *opts->sequence == '\0') {
SOL_ERR("Option 'sequence' is either NULL or empty.");
return -EINVAL;
}
mdata->sequence = strdup(opts->sequence);
SOL_NULL_CHECK_GOTO(mdata->sequence, no_memory);
if (opts->interval < 0)
SOL_WRN("Option 'interval' < 0, setting it to 0.");
mdata->interval = opts->interval >= 0 ? opts->interval : 0;
mdata->next_index = 0;
mdata->values = sol_str_slice_split(sol_str_slice_from_str
(mdata->sequence), opts->separator, SIZE_MAX);
mdata->timer = sol_timeout_add(mdata->interval, timer_tick, node);
SOL_NULL_CHECK_GOTO(mdata->timer, error);
return 0;
no_memory:
errno = -ENOMEM;
error:
sol_vector_clear(&mdata->values);
return errno;
}
static void
on_fork_exit(void *data, uint64_t pid, int status)
{
struct subprocess_data *mdata = data;
mdata->fork_run = NULL;
if (mdata->watches.in)
sol_fd_del(mdata->watches.in);
if (mdata->watches.err)
sol_fd_del(mdata->watches.err);
if (mdata->watches.out) {
struct write_data *w;
uint16_t i;
sol_fd_del(mdata->watches.out);
SOL_VECTOR_FOREACH_IDX (&mdata->write_data, w, i)
sol_blob_unref(w->blob);
sol_vector_clear(&mdata->write_data);
}
mdata->watches.in = NULL;
mdata->watches.err = NULL;
mdata->watches.out = NULL;
sol_flow_send_irange_value_packet(mdata->node, SOL_FLOW_NODE_TYPE_PROCESS_SUBPROCESS__OUT__STATUS, status);
}
