static int
two_ports_process(struct sol_flow_node *node, void *data, uint16_t port_in, uint16_t port_out,
const struct sol_flow_packet *packet, bool (*func) (bool in0, bool in1))
{
int r;
bool b;
struct boolean_data *mdata = data;
r = sol_flow_packet_get_boolean(packet, &b);
SOL_INT_CHECK(r, < 0, r);
if (port_in) {
mdata->init_in1 = true;
mdata->in1 = b;
} else {
mdata->init_in0 = true;
mdata->in0 = b;
}
if (mdata->init_in0 && mdata->init_in1) {
b = func(mdata->in0, mdata->in1);
return sol_flow_send_boolean_packet(node, port_out, b);
}
return 0;
}
int
sequence_process(
struct sol_flow_node *node,
void *data,
uint16_t port,
uint16_t conn_id,
const struct sol_flow_packet *packet)
{
struct boolean_validator_data *mdata = data;
char input;
bool val, match;
int r;
if (mdata->done) {
sol_flow_send_error_packet(node, ECANCELED,
"Input stream already deviated from expected data, ignoring packets.");
return 0;
}
r = sol_flow_packet_get_boolean(packet, &val);
SOL_INT_CHECK(r, < 0, r);
input = val ? 'T' : 'F';
match = input == *mdata->it;
mdata->it++;
if (*mdata->it == '\0' || !match) {
sol_flow_send_boolean_packet(node, SOL_FLOW_NODE_TYPE_TEST_BOOLEAN_VALIDATOR__OUT__OUT,
match);
mdata->done = true;
}
return 0;
}
static int
engine_state_process(struct sol_flow_node *node, void *data,
uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet)
{
int r;
bool engine_is_on;
struct sml_garden_data *sdata = data;
time_t now = time(NULL);
r = sol_flow_packet_get_boolean(packet, &engine_is_on);
SOL_INT_CHECK(r, < 0, r);
if (engine_is_on)
sdata->btn_pressed_timestamp = now;
else if (sdata->btn_pressed_timestamp) {
now -= sdata->btn_pressed_timestamp;
SOL_DBG("Pressed for:%ld seconds", now);
if (sdata->last_engine_on_duration + now > ENGINE_DURATION_MAX_VAL)
sdata->last_engine_on_duration = ENGINE_DURATION_MAX_VAL;
else
sdata->last_engine_on_duration += now;
sdata->btn_pressed_timestamp = 0;
r = send_packet_if_needed(node, sdata);
SOL_INT_CHECK(r, < 0, r);
}
static int
boolean_writer_process(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet)
{
struct unix_socket_data *mdata = data;
bool val;
int r;
r = sol_flow_packet_get_boolean(packet, &val);
SOL_INT_CHECK(r, < 0, r);
return unix_socket_write(mdata->un_socket, &val, sizeof(val));
}
/* NOT ********************************************************************/
static int
not_process(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id,
const struct sol_flow_packet *packet)
{
int r;
bool in;
r = sol_flow_packet_get_boolean(packet, &in);
SOL_INT_CHECK(r, < 0, r);
return sol_flow_send_boolean_packet(node, SOL_FLOW_NODE_TYPE_BOOLEAN_NOT__OUT__OUT, !in);
}
int
gtk_pwm_viewer_enable_process(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id,
const struct sol_flow_packet *packet)
{
struct gtk_pwm_viewer_data *mdata = data;
if (sol_flow_packet_get_type(packet) == SOL_FLOW_PACKET_TYPE_BOOLEAN) {
bool value;
int r = sol_flow_packet_get_boolean(packet, &value);
SOL_INT_CHECK(r, < 0, r);
mdata->enabled = value;
gtk_widget_queue_draw(mdata->base.widget);
} else {
static int
filter_process(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet)
{
bool packet_val;
uint16_t out_port;
int r;
r = sol_flow_packet_get_boolean(packet, &packet_val);
SOL_INT_CHECK(r, < 0, r);
if (packet_val)
out_port = SOL_FLOW_NODE_TYPE_BOOLEAN_FILTER__OUT__TRUE;
else
out_port = SOL_FLOW_NODE_TYPE_BOOLEAN_FILTER__OUT__FALSE;
return sol_flow_send_boolean_packet(node, out_port, packet_val);
}
static int
writer_in_process(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet)
{
struct writer_data *mdata = data;
int r;
bool in_value;
r = sol_flow_packet_get_boolean(packet, &in_value);
SOL_INT_CHECK(r, < 0, r);
printf("%s=%s\n",
mdata->prefix ? mdata->prefix : "writer",
in_value ? "true" : "false");
return 0;
}
static int
boolean_buffer_process(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id,
const struct sol_flow_packet *packet)
{
int r;
struct boolean_buffer_data *mdata = data;
r = sol_flow_packet_get_boolean(packet, &mdata->input_queue[mdata->cur_len]);
SOL_INT_CHECK(r, < 0, r);
if (mdata->n_samples <= ++mdata->cur_len) {
r = _boolean_buffer_do(mdata);
_reset(data);
}
return r;
}
static int
timer_enabled_process(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet)
{
struct timer_data *mdata = data;
int r;
bool val;
r = sol_flow_packet_get_boolean(packet, &val);
SOL_INT_CHECK(r, < 0, r);
if (!val)
return timer_stop(mdata);
else if (!mdata->timer)
return timer_start(mdata);
return 0;
}
static int
boolean_writer_process(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet)
{
struct ipm_data *mdata = data;
struct sol_blob *blob;
bool in_value;
int r;
r = sol_flow_packet_get_boolean(packet, &in_value);
SOL_INT_CHECK(r, < 0, r);
blob = SOL_BLOB_NEW_DUP(in_value);
SOL_NULL_CHECK(blob, -ENOMEM);
SEND_BLOB(blob, mdata->id, node);
return 0;
}
int
test_result_process(
struct sol_flow_node *node,
void *data,
uint16_t port,
uint16_t conn_id,
const struct sol_flow_packet *packet)
{
bool passed = false;
int r = sol_flow_packet_get_boolean(packet, &passed);
SOL_INT_CHECK(r, < 0, r);
if (passed)
pass(node);
else
fail(node);
return 0;
}
static int
enabled_set(struct sol_flow_node *node,
void *data,
uint16_t port,
uint16_t conn_id,
const struct sol_flow_packet *packet)
{
struct piezo_speaker_data *mdata = data;
bool in_value;
int r;
r = sol_flow_packet_get_boolean(packet, &in_value);
SOL_INT_CHECK(r, < 0, r);
if (!in_value)
return tune_stop(mdata);
if (in_value && mdata->periods_us && !mdata->timer) {
r = tune_start(mdata);
SOL_INT_CHECK(r, < 0, r);
}
static int
counter_process(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id,
const struct sol_flow_packet *packet)
{
struct sol_irange val = { 0, 0, INT32_MAX, 1 };
struct counter_data *mdata = data;
enum state *s;
bool packet_val;
int r;
r = sol_flow_packet_get_boolean(packet, &packet_val);
SOL_INT_CHECK(r, < 0, r);
s = sol_vector_get(&mdata->map, conn_id);
if (*s == packet_val)
return 0;
if (packet_val) {
mdata->true_count++;
if (*s != NA)
mdata->false_count--;
} else {
mdata->false_count++;
if (*s != NA)
mdata->true_count--;
}
*s = packet_val;
val.val = mdata->true_count;
sol_flow_send_irange_packet(node, SOL_FLOW_NODE_TYPE_BOOLEAN_COUNTER__OUT__TRUE, &val);
val.val = mdata->false_count;
sol_flow_send_irange_packet(node, SOL_FLOW_NODE_TYPE_BOOLEAN_COUNTER__OUT__FALSE, &val);
return 0;
}
static void
inspector_show_packet_value(const struct sol_flow_packet *packet)
{
const struct sol_flow_packet_type *type = sol_flow_packet_get_type(packet);
if (type == SOL_FLOW_PACKET_TYPE_EMPTY) {
fputs("<empty>", stdout);
return;
} else if (type == SOL_FLOW_PACKET_TYPE_ANY) {
fputs("<any>", stdout);
return;
} else if (type == SOL_FLOW_PACKET_TYPE_ERROR) {
int code;
const char *msg;
if (sol_flow_packet_get_error(packet, &code, &msg) == 0) {
fprintf(stdout, "<error:%d \"%s\">", code, msg ? msg : "");
return;
}
} else if (type == SOL_FLOW_PACKET_TYPE_BOOLEAN) {
bool v;
if (sol_flow_packet_get_boolean(packet, &v) == 0) {
fprintf(stdout, "<%s>", v ? "true" : "false");
return;
}
} else if (type == SOL_FLOW_PACKET_TYPE_BYTE) {
unsigned char v;
if (sol_flow_packet_get_byte(packet, &v) == 0) {
fprintf(stdout, "<%#x>", v);
return;
}
} else if (type == SOL_FLOW_PACKET_TYPE_IRANGE) {
struct sol_irange v;
if (sol_flow_packet_get_irange(packet, &v) == 0) {
fprintf(stdout, "<val:%d|min:%d|max:%d|step:%d>",
v.val, v.min, v.max, v.step);
return;
}
} else if (type == SOL_FLOW_PACKET_TYPE_DRANGE) {
struct sol_drange v;
if (sol_flow_packet_get_drange(packet, &v) == 0) {
fprintf(stdout, "<val:%g|min:%g|max:%g|step:%g>",
v.val, v.min, v.max, v.step);
return;
}
} else if (type == SOL_FLOW_PACKET_TYPE_STRING) {
const char *v;
if (sol_flow_packet_get_string(packet, &v) == 0) {
fprintf(stdout, "<\"%s\">", v);
return;
}
} else if (type == SOL_FLOW_PACKET_TYPE_BLOB) {
struct sol_blob *v;
if (sol_flow_packet_get_blob(packet, &v) == 0) {
fprintf(stdout, "<mem=%p|size=%zd|refcnt=%hu|type=%p|parent=%p>",
v->mem, v->size, v->refcnt, v->type, v->parent);
return;
}
} else if (type == SOL_FLOW_PACKET_TYPE_JSON_OBJECT) {
struct sol_blob *v;
if (sol_flow_packet_get_json_object(packet, &v) == 0) {
fprintf(stdout, "<%.*s>",
SOL_STR_SLICE_PRINT(sol_str_slice_from_blob(v)));
return;
}
} else if (type == SOL_FLOW_PACKET_TYPE_JSON_ARRAY) {
struct sol_blob *v;
if (sol_flow_packet_get_json_array(packet, &v) == 0) {
fprintf(stdout, "<%.*s>",
SOL_STR_SLICE_PRINT(sol_str_slice_from_blob(v)));
return;
}
} else if (type == SOL_FLOW_PACKET_TYPE_RGB) {
struct sol_rgb v;
if (sol_flow_packet_get_rgb(packet, &v) == 0) {
fprintf(stdout,
"<red=%u|green=%u|blue=%u"
"|red_max=%u|green_max=%u|blue_max=%u>",
v.red, v.green, v.blue,
v.red_max, v.green_max, v.blue_max);
return;
}
} else if (type == SOL_FLOW_PACKET_TYPE_DIRECTION_VECTOR) {
struct sol_direction_vector v;
if (sol_flow_packet_get_direction_vector(packet, &v) == 0) {
fprintf(stdout,
"<x=%g|y=%g|z=%g|min=%g|max=%g>",
v.x, v.y, v.z, v.min, v.max);
return;
}
} else if (type == SOL_FLOW_PACKET_TYPE_LOCATION) {
struct sol_location v;
if (sol_flow_packet_get_location(packet, &v) == 0) {
fprintf(stdout, "<lat=%g|lon=%g|alt=%g>", v.lat, v.lon, v.alt);
return;
}
} else if (type == SOL_FLOW_PACKET_TYPE_TIMESTAMP) {
struct timespec v;
if (sol_flow_packet_get_timestamp(packet, &v) == 0) {
struct tm cur_time;
char buf[32];
tzset();
if (gmtime_r(&v.tv_sec, &cur_time)) {
if (strftime(buf, sizeof(buf), "%Y-%m-%dT%H:%M:%SZ",
&cur_time) > 0) {
fprintf(stdout, "<%s>", buf);
return;
}
}
}
} else if (type == SOL_FLOW_PACKET_TYPE_HTTP_RESPONSE) {
int code;
const char *url, *content_type;
const struct sol_blob *content;
struct sol_vector headers, cookies;
if (sol_flow_packet_get_http_response(packet, &code, &url,
&content_type, &content, &cookies, &headers) == 0) {
fprintf(stdout, "<response_code:%d|content type:%s|url:%s|",
code, content_type, url);
fprintf(stdout, "|cookies: {");
inpector_print_key_value_array(&cookies);
fprintf(stdout, "}|headers:{");
inpector_print_key_value_array(&headers);
fprintf(stdout,
"}|content:{mem=%p|size=%zd|refcnt=%hu|type=%p|parent=%p}>",
content->mem, content->size, content->refcnt,
content->type, content->parent);
}
return;
}
fputs("<?>", stdout);
}
uint16_t port,
uint16_t conn_id,
const struct sol_flow_packet *packet)
{
struct gtk_common_data *mdata = data;
if (sol_flow_packet_get_type(packet) == SOL_FLOW_PACKET_TYPE_EMPTY) {
gtk_label_set_text(GTK_LABEL(mdata->widget), "[empty]");
} else if (sol_flow_packet_get_type(packet) == SOL_FLOW_PACKET_TYPE_STRING) {
const char *in_value;
int r = sol_flow_packet_get_string(packet, &in_value);
SOL_INT_CHECK(r, < 0, r);
gtk_label_set_text(GTK_LABEL(mdata->widget), in_value);
} else if (sol_flow_packet_get_type(packet) == SOL_FLOW_PACKET_TYPE_BOOLEAN) {
bool value;
int r = sol_flow_packet_get_boolean(packet, &value);
SOL_INT_CHECK(r, < 0, r);
gtk_label_set_text(GTK_LABEL(mdata->widget), value ? "ON" : "OFF");
} else if (sol_flow_packet_get_type(packet) == SOL_FLOW_PACKET_TYPE_BYTE) {
char buf[9];
unsigned char value;
int r = sol_flow_packet_get_byte(packet, &value), i;
SOL_INT_CHECK(r, < 0, r);
for (i = 7; i >= 0; i--) {
buf[i] = (value & 0x1) + '0';
value >>= 1;
}
buf[8] = '\0';
gtk_label_set_text(GTK_LABEL(mdata->widget), buf);
} else if (sol_flow_packet_get_type(packet) == SOL_FLOW_PACKET_TYPE_IRANGE) {
static int
mytype_func(struct sol_flow_node *node, const struct sol_flow_simplectype_event *ev, void *data)
{
struct mytype_context *ctx = data;
switch (ev->type) {
case SOL_FLOW_SIMPLECTYPE_EVENT_TYPE_OPEN: {
if (ev->options
#ifndef SOL_NO_API_VERSION
&& ev->options->sub_api == MYTYPE_OPTIONS_SUB_API
#endif
) {
struct mytype_options *opt = (struct mytype_options *)ev->options;
ctx->someint = opt->someint;
ctx->somebool = opt->somebool;
}
/* every 500ms send out a string representing our someint + somebool */
ctx->timer = sol_timeout_add(500, on_timeout, node);
if (!ctx->timer)
return -ENOMEM;
printf("simplectype opened ctx=%p, someint=%d, somebool=%d\n",
ctx, ctx->someint, ctx->somebool);
return 0;
}
case SOL_FLOW_SIMPLECTYPE_EVENT_TYPE_CLOSE: {
printf("simplectype closed ctx=%p\n", ctx);
sol_timeout_del(ctx->timer);
return 0;
}
case SOL_FLOW_SIMPLECTYPE_EVENT_TYPE_PORT_IN_PROCESS: {
/* this is to show the port names, ideally one would keep the
* indexes and use them here, doing integer comparisons
* instead of strcmp()
*/
if (strcmp(ev->port_name, "IRANGE") == 0) {
int32_t val;
if (sol_flow_packet_get_irange_value(ev->packet, &val) == 0) {
printf("simplectype updated integer from %d to %d\n",
ctx->someint, val);
ctx->someint = val;
return 0;
}
} else if (strcmp(ev->port_name, "BOOLEAN") == 0) {
bool val;
if (sol_flow_packet_get_boolean(ev->packet, &val) == 0) {
printf("simplectype updated boolean from %d to %d\n",
ctx->somebool, val);
ctx->somebool = val;
return 0;
}
}
printf("simplectype port '%s' got unexpected data!\n", ev->port_name);
return -EINVAL;
}
case SOL_FLOW_SIMPLECTYPE_EVENT_TYPE_PORT_IN_CONNECT:
printf("simplectype port IN '%s' id=%d conn=%d connected ctx=%p\n",
ev->port_name, ev->port, ev->conn_id, ctx);
return 0;
case SOL_FLOW_SIMPLECTYPE_EVENT_TYPE_PORT_IN_DISCONNECT:
printf("simplectype port IN '%s' id=%d conn=%d disconnected ctx=%p\n",
ev->port_name, ev->port, ev->conn_id, ctx);
return 0;
case SOL_FLOW_SIMPLECTYPE_EVENT_TYPE_PORT_OUT_CONNECT:
printf("simplectype port OUT '%s' id=%d conn=%d connected ctx=%p\n",
ev->port_name, ev->port, ev->conn_id, ctx);
return 0;
case SOL_FLOW_SIMPLECTYPE_EVENT_TYPE_PORT_OUT_DISCONNECT:
printf("simplectype port OUT '%s' id=%d conn=%d disconnected ctx=%p\n",
ev->port_name, ev->port, ev->conn_id, ctx);
return 0;
}
return -EINVAL;
}
