sol-flow.h

Go to the documentation of this file.

/*
 * This file is part of the Soletta (TM) Project
 *
 * Copyright (C) 2015 Intel Corporation. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#pragma once

#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <time.h>

#include "sol-flow-packet.h"

#ifdef __cplusplus
extern "C" {
#endif

struct sol_flow_node_options;

struct sol_flow_node_type;

struct sol_flow_packet;

struct sol_flow_packet_type;

struct sol_flow_node;
typedef struct sol_flow_node sol_flow_node;

struct sol_flow_node *sol_flow_node_new(struct sol_flow_node *parent, const char *id, const struct sol_flow_node_type *type, const struct sol_flow_node_options *options);

void sol_flow_node_del(struct sol_flow_node *node);

void *sol_flow_node_get_private_data(const struct sol_flow_node *node);

const char *sol_flow_node_get_id(const struct sol_flow_node *node);

const struct sol_flow_node *sol_flow_node_get_parent(const struct sol_flow_node *node);

int sol_flow_send_packet(struct sol_flow_node *src, uint16_t src_port, struct sol_flow_packet *packet);

/*
 * Helper functions to create and send packets of specific types.
 *
 * They work like sol_flow_send_packet(), but besides creating,
 * sending and freeing the packet, they'll also set their value.
 */

int sol_flow_send_error_packet(struct sol_flow_node *src, int code, const char *msg_fmt, ...) SOL_ATTR_PRINTF(3, 4);

int sol_flow_send_error_packet_errno(struct sol_flow_node *src, int code);

int sol_flow_send_error_packet_str(struct sol_flow_node *src, int code, const char *str);

int sol_flow_send_bool_packet(struct sol_flow_node *src, uint16_t src_port, unsigned char value);

int sol_flow_send_blob_packet(struct sol_flow_node *src, uint16_t src_port, const struct sol_blob *value);

int sol_flow_send_json_object_packet(struct sol_flow_node *src, uint16_t src_port, const struct sol_blob *value);

int sol_flow_send_json_array_packet(struct sol_flow_node *src, uint16_t src_port, const struct sol_blob *value);

int sol_flow_send_byte_packet(struct sol_flow_node *src, uint16_t src_port, unsigned char value);

int sol_flow_send_drange_packet(struct sol_flow_node *src, uint16_t src_port, const struct sol_drange *value);

int sol_flow_send_drange_value_packet(struct sol_flow_node *src, uint16_t src_port, double value);

int sol_flow_send_rgb_packet(struct sol_flow_node *src, uint16_t src_port, const struct sol_rgb *value);

int sol_flow_send_rgb_components_packet(struct sol_flow_node *src, uint16_t src_port, uint32_t red, uint32_t green, uint32_t blue);

int sol_flow_send_direction_vector_packet(struct sol_flow_node *src, uint16_t src_port, const struct sol_direction_vector *value);

int sol_flow_send_direction_vector_components_packet(struct sol_flow_node *src, uint16_t src_port, double x, double y, double z);

int sol_flow_send_location_packet(struct sol_flow_node *src, uint16_t src_port, const struct sol_location *value);

int sol_flow_send_location_components_packet(struct sol_flow_node *src, uint16_t src_port, double lat, double lon, double alt);

int sol_flow_send_timestamp_packet(struct sol_flow_node *src, uint16_t src_port, const struct timespec *value);

int sol_flow_send_empty_packet(struct sol_flow_node *src, uint16_t src_port);

int sol_flow_send_irange_packet(struct sol_flow_node *src, uint16_t src_port, const struct sol_irange *value);

int sol_flow_send_irange_value_packet(struct sol_flow_node *src, uint16_t src_port, int32_t value);

int sol_flow_send_string_packet(struct sol_flow_node *src, uint16_t src_port, const char *value);

int sol_flow_send_string_slice_packet(struct sol_flow_node *src, uint16_t src_port, const struct sol_str_slice value);

int sol_flow_send_string_take_packet(struct sol_flow_node *src, uint16_t src_port, char *value);

int sol_flow_send_composed_packet(struct sol_flow_node *src, uint16_t src_port, const struct sol_flow_packet_type *composed_type, struct sol_flow_packet **children);

int sol_flow_send_http_response_packet(struct sol_flow_node *src, uint16_t src_port, int response_code, const char *url, const char *content_type, const struct sol_blob *content, const struct sol_vector *cookies, const struct sol_vector *headers);

const struct sol_flow_node_type *sol_flow_node_get_type(const struct sol_flow_node *node);

typedef struct sol_flow_node_options {
#ifndef SOL_NO_API_VERSION
#define SOL_FLOW_NODE_OPTIONS_API_VERSION (1) 
    uint16_t api_version; 
    uint16_t sub_api; 
#endif
} sol_flow_node_options;

enum sol_flow_node_options_member_type {
    SOL_FLOW_NODE_OPTIONS_MEMBER_UNKNOWN,
    SOL_FLOW_NODE_OPTIONS_MEMBER_BOOL,
    SOL_FLOW_NODE_OPTIONS_MEMBER_BYTE,
    SOL_FLOW_NODE_OPTIONS_MEMBER_DIRECTION_VECTOR,
    SOL_FLOW_NODE_OPTIONS_MEMBER_DRANGE_SPEC,
    SOL_FLOW_NODE_OPTIONS_MEMBER_FLOAT,
    SOL_FLOW_NODE_OPTIONS_MEMBER_INT,
    SOL_FLOW_NODE_OPTIONS_MEMBER_IRANGE_SPEC,
    SOL_FLOW_NODE_OPTIONS_MEMBER_RGB,
    SOL_FLOW_NODE_OPTIONS_MEMBER_STRING,
};

const char *sol_flow_node_options_member_type_to_str(enum sol_flow_node_options_member_type type);

enum sol_flow_node_options_member_type sol_flow_node_options_member_type_from_string(const char *data_type);

typedef struct sol_flow_node_named_options_member {
    const char *name; 
    enum sol_flow_node_options_member_type type; 
    union {
        bool boolean; 
        unsigned char byte; 
        int32_t i; 
        struct sol_irange_spec irange_spec; 
        struct sol_drange_spec drange_spec; 
        struct sol_rgb rgb; 
        struct sol_direction_vector direction_vector; 
        const char *string; 
        double f; 
    };
} sol_flow_node_named_options_member;

typedef struct sol_flow_node_named_options {
    struct sol_flow_node_named_options_member *members; 
    uint16_t count; 
} sol_flow_node_named_options;

int sol_flow_node_options_new(
    const struct sol_flow_node_type *type,
    const struct sol_flow_node_named_options *named_opts,
    struct sol_flow_node_options **out_opts);

int sol_flow_node_named_options_init_from_strv(
    struct sol_flow_node_named_options *named_opts,
    const struct sol_flow_node_type *type,
    const char *const *strv);

void sol_flow_node_options_del(const struct sol_flow_node_type *type, struct sol_flow_node_options *options);

void sol_flow_node_options_strv_del(char **opts_strv);

void sol_flow_node_named_options_fini(struct sol_flow_node_named_options *named_opts);

#include "sol-flow-buildopts.h"

#define SOL_FLOW_NODE_PORT_ERROR_NAME ("ERROR")

#ifdef SOL_FLOW_NODE_TYPE_DESCRIPTION_ENABLED

typedef struct sol_flow_port_description {
    const char *name; 
    const char *description; 
    const char *data_type; 
    uint16_t array_size; 
    uint16_t base_port_idx; 
    bool required;
} sol_flow_port_description;

typedef struct sol_flow_node_options_member_description {
    const char *name; 
    const char *description; 
    const char *data_type; 
    union {
        bool b; 
        unsigned char byte; 
        int32_t i; 
        struct sol_irange_spec irange_spec; 
        struct sol_drange_spec drange_spec; 
        struct sol_direction_vector direction_vector; 
        struct sol_rgb rgb; 
        const char *s; 
        const void *ptr; 
        double f; 
    } defvalue; 
    uint16_t offset; 
    uint16_t size; 
    bool required; 
} sol_flow_node_options_member_description;

typedef struct sol_flow_node_options_description {
    const struct sol_flow_node_options_member_description *members; 
    uint16_t data_size; 
#ifndef SOL_NO_API_VERSION
    uint16_t sub_api; 
#endif
    bool required; 
} sol_flow_node_options_description;

typedef struct sol_flow_node_type_description {
#ifndef SOL_NO_API_VERSION

#define SOL_FLOW_NODE_TYPE_DESCRIPTION_API_VERSION (1)
    uint16_t api_version; 
#endif
    const char *name; 
    const char *category;
    const char *symbol; 
    const char *options_symbol; 
    const char *description; 
    const char *author; 
    const char *url; 
    const char *license; 
    const char *version; 
    const struct sol_flow_port_description *const *ports_in; 
    const struct sol_flow_port_description *const *ports_out; 
    const struct sol_flow_node_options_description *options; 
} sol_flow_node_type_description;
#endif

enum sol_flow_node_type_flags {
    SOL_FLOW_NODE_TYPE_FLAGS_CONTAINER = (1 << 0), 
};

typedef struct sol_flow_node_type {
#define SOL_FLOW_NODE_PORT_ERROR (UINT16_MAX - 1) 
#ifndef SOL_NO_API_VERSION
#define SOL_FLOW_NODE_TYPE_API_VERSION (1) 
    uint16_t api_version; 
#endif
    uint16_t data_size; 
    uint16_t options_size; 
    uint16_t flags; 
    const void *type_data; 
    const void *default_options; 
    uint16_t ports_in_count; 
    uint16_t ports_out_count; 
    const struct sol_flow_port_type_in *(*get_port_in)(const struct sol_flow_node_type *type, uint16_t port);

    const struct sol_flow_port_type_out *(*get_port_out)(const struct sol_flow_node_type *type, uint16_t port);

    int (*open)(struct sol_flow_node *node, void *data, const struct sol_flow_node_options *options);

    void (*close)(struct sol_flow_node *node, void *data);

    void (*init_type)(void);

    void (*dispose_type)(struct sol_flow_node_type *type);

#ifdef SOL_FLOW_NODE_TYPE_DESCRIPTION_ENABLED
    const struct sol_flow_node_type_description *description; 
#endif
} sol_flow_node_type;

#ifdef SOL_FLOW_NODE_TYPE_DESCRIPTION_ENABLED

int sol_flow_node_named_options_parse_member(
    struct sol_flow_node_named_options_member *m,
    const char *value,
    const struct sol_flow_node_options_member_description *mdesc);
#endif

const struct sol_flow_port_type_in *sol_flow_node_type_get_port_in(const struct sol_flow_node_type *type, uint16_t port);

const struct sol_flow_port_type_out *sol_flow_node_type_get_port_out(const struct sol_flow_node_type *type, uint16_t port);

void sol_flow_node_type_del(struct sol_flow_node_type *type);

#ifdef SOL_FLOW_NODE_TYPE_DESCRIPTION_ENABLED

void sol_flow_foreach_builtin_node_type(bool (*cb)(void *data, const struct sol_flow_node_type *type), const void *data);

const struct sol_flow_port_description *sol_flow_node_get_description_port_in(const struct sol_flow_node_type *type, uint16_t port);

const struct sol_flow_port_description *sol_flow_node_get_description_port_out(const struct sol_flow_node_type *type, uint16_t port);

uint16_t sol_flow_node_find_port_in(const struct sol_flow_node_type *type, const char *name);

uint16_t sol_flow_node_find_port_out(const struct sol_flow_node_type *type, const char *name);
#endif

typedef struct sol_flow_node_container_type {
    struct sol_flow_node_type base; 
    int (*send)(struct sol_flow_node *container, struct sol_flow_node *source_node, uint16_t source_out_port_idx, struct sol_flow_packet *packet);

    int (*process)(struct sol_flow_node *container, uint16_t source_in_port_idx, struct sol_flow_packet *packet);

    void (*add)(struct sol_flow_node *container, struct sol_flow_node *node);

    void (*remove)(struct sol_flow_node *container, struct sol_flow_node *node);
} sol_flow_node_container_type;

typedef struct sol_flow_port_type_out {
#ifndef SOL_NO_API_VERSION
#define SOL_FLOW_PORT_TYPE_OUT_API_VERSION (1) 
    uint16_t api_version; 
#endif
    const struct sol_flow_packet_type *packet_type; 
    int (*connect)(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id);

    int (*disconnect)(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id);
} sol_flow_port_type_out;

typedef struct sol_flow_port_type_in {
#ifndef SOL_NO_API_VERSION
#define SOL_FLOW_PORT_TYPE_IN_API_VERSION (1) 
    uint16_t api_version; 
#endif
    const struct sol_flow_packet_type *packet_type; 
    int (*process)(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet);
    int (*connect)(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id); 
    int (*disconnect)(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id); 
} sol_flow_port_type_in;

#ifdef SOL_DYNAMIC_MODULES

#define sol_flow_get_node_type(_mod, _type, _var) sol_flow_internal_get_node_type(_mod, #_type, _var)

int sol_flow_internal_get_node_type(const char *modname, const char *symbol, const struct sol_flow_node_type ***type);

#define sol_flow_get_packet_type(_mod, _type, _var) sol_flow_internal_get_packet_type(_mod, #_type, _var)

int sol_flow_internal_get_packet_type(const char *module, const char *symbol, const struct sol_flow_packet_type **type);

#else
#define sol_flow_get_node_type(_mod, _type, _var) ({ (*(_var)) = &_type; 0; })
#define sol_flow_get_packet_type(_mod, _type, _var) ({ (*(_var)) = _type; 0; })
#endif /* SOL_DYNAMIC_MODULES */

#ifdef __cplusplus
}
#endif