msg_envelope.h

Go to the documentation of this file.

// Copyright (c) 2019 Intel Corporation.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM,OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
 
#ifndef _EII_MESSAGE_BUS_MSGENV_H
#define _EII_MESSAGE_BUS_MSGENV_H
 
#include <stdlib.h>
#include <stdbool.h>
#include <stdint.h>
#include "eii/msgbus/msgbusret.h"
#include "eii/msgbus/hashmap.h"
#include "eii/msgbus/linkedlist.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef enum {
    CT_JSON = 0,
 
    // For custom serialized data by the user (assumed done by the caller of
    // the `msgbus_recv()` prior to calling the method)
    CT_BLOB = 1,
 
    // TODO: ADD support for CBOR
    // CT_CBOR = 2,
} content_type_t;
 
typedef enum {
    MSG_ENV_DT_INT      = 0,
    MSG_ENV_DT_FLOATING = 1,
    MSG_ENV_DT_STRING   = 2,
    MSG_ENV_DT_BOOLEAN  = 3,
    MSG_ENV_DT_BLOB     = 4,
    MSG_ENV_DT_OBJECT   = 5,
    MSG_ENV_DT_ARRAY    = 6,
    MSG_ENV_DT_NONE     = 7,
} msg_envelope_data_type_t;
 
typedef struct {
    void* ptr;
    void (*free)(void*);
    bool owned;
 
    size_t len;
    const char* bytes;
} owned_blob_t;
 
typedef struct {
    owned_blob_t* shared;
 
    uint64_t len;
    const char*    data;
} msg_envelope_blob_t;
 
typedef struct {
    msg_envelope_data_type_t type;
 
    union {
        int64_t              integer;
        double               floating;
        char*                string;
        bool                 boolean;
        msg_envelope_blob_t* blob;
        hashmap_t*           object;
        linkedlist_t*        array;
    } body;
} msg_envelope_elem_body_t;
 
typedef struct {
    char* name;
    char* correlation_id;
    content_type_t content_type;
 
    // Internal tracking for (key, value) pairs
    hashmap_t* map;
 
    // Internal tracking for blob data
    msg_envelope_elem_body_t* blob;
} msg_envelope_t;
 
typedef struct {
    owned_blob_t* shared;
 
    // Convenience values
    size_t len;
    const char* bytes;
} msg_envelope_serialized_part_t;
 
msg_envelope_t* msgbus_msg_envelope_new(content_type_t ct);
 
msg_envelope_elem_body_t* msgbus_msg_envelope_new_none();
 
msg_envelope_elem_body_t* msgbus_msg_envelope_new_array();
 
msg_envelope_elem_body_t* msgbus_msg_envelope_new_object();
 
msg_envelope_elem_body_t* msgbus_msg_envelope_new_string(const char* string);
 
msgbus_ret_t msgbus_msg_envelope_put_string(
        msg_envelope_t* obj, const char* key,
        const char* value);
 
msg_envelope_elem_body_t* msgbus_msg_envelope_new_integer(int64_t integer);
 
msgbus_ret_t msgbus_msg_envelope_put_integer(
        msg_envelope_t* obj, const char* key,
        int64_t value);
 
msg_envelope_elem_body_t* msgbus_msg_envelope_new_floating(double floating);
 
msgbus_ret_t msgbus_msg_envelope_put_float(
        msg_envelope_t* obj, const char* key,
        double value);
 
msg_envelope_elem_body_t* msgbus_msg_envelope_new_bool(bool boolean);
 
msgbus_ret_t msgbus_msg_envelope_put_bool(
        msg_envelope_t* obj, const char* key,
        bool value);
 
msg_envelope_elem_body_t* msgbus_msg_envelope_new_blob(
        char* data, size_t len);
 
msgbus_ret_t msgbus_msg_envelope_elem_object_put(
        msg_envelope_elem_body_t* obj, const char* key,
        msg_envelope_elem_body_t* value);
 
msgbus_ret_t msgbus_msg_envelope_elem_object_put_integer(
        msg_envelope_elem_body_t* obj, const char* key,
        int64_t value);
 
msgbus_ret_t msgbus_msg_envelope_elem_object_put_string(
        msg_envelope_elem_body_t* obj, const char* key,
        const char* value);
 
msgbus_ret_t msgbus_msg_envelope_elem_object_put_float(
        msg_envelope_elem_body_t* obj, const char* key,
        double value);
 
msgbus_ret_t msgbus_msg_envelope_elem_object_put_bool(
        msg_envelope_elem_body_t* obj, const char* key,
        bool value);
 
msg_envelope_elem_body_t* msgbus_msg_envelope_elem_object_get(
        msg_envelope_elem_body_t* obj, const char* key);
 
msgbus_ret_t msgbus_msg_envelope_elem_object_remove(
        msg_envelope_elem_body_t* obj, const char* key);
 
msgbus_ret_t msgbus_msg_envelope_elem_array_add(
        msg_envelope_elem_body_t* arr,
        msg_envelope_elem_body_t* value);
 
msgbus_ret_t msgbus_msg_envelope_elem_array_add_integer(
        msg_envelope_elem_body_t* arr,
        int64_t value);
 
msgbus_ret_t msgbus_msg_envelope_elem_array_add_string(
        msg_envelope_elem_body_t* arr,
        const char* value);
 
msgbus_ret_t msgbus_msg_envelope_elem_array_add_float(
        msg_envelope_elem_body_t* arr,
        double value);
 
msgbus_ret_t msgbus_msg_envelope_elem_array_add_bool(
        msg_envelope_elem_body_t* arr,
        bool value);
 
msg_envelope_elem_body_t* msgbus_msg_envelope_elem_array_get_at(
        msg_envelope_elem_body_t* arr, int idx);
 
msgbus_ret_t msgbus_msg_envelope_elem_array_remove_at(
        msg_envelope_elem_body_t* arr, int idx);
 
void msgbus_msg_envelope_elem_destroy(msg_envelope_elem_body_t* elem);
 
msgbus_ret_t msgbus_msg_envelope_put(
        msg_envelope_t* env, const char* key, msg_envelope_elem_body_t* data);
 
msgbus_ret_t msgbus_msg_envelope_remove(msg_envelope_t* env, const char* key);
 
msgbus_ret_t msgbus_msg_envelope_get(
        msg_envelope_t* env, const char* key, msg_envelope_elem_body_t** data);
 
int msgbus_msg_envelope_serialize(
        msg_envelope_t* env, msg_envelope_serialized_part_t** parts);
 
msgbus_ret_t msgbus_msg_envelope_deserialize(
        content_type_t ct, msg_envelope_serialized_part_t* parts,
        int num_parts, const char* name, msg_envelope_t** env);
 
msgbus_ret_t msgbus_msg_envelope_serialize_parts_new(
        int num_parts, msg_envelope_serialized_part_t** parts);
 
void msgbus_msg_envelope_serialize_destroy(
        msg_envelope_serialized_part_t* parts, int num_parts);
 
void msgbus_msg_envelope_print(
        msg_envelope_t* msg, bool pretty_print, bool print_blobs);
 
void msgbus_msg_envelope_destroy(msg_envelope_t* msg);
 
owned_blob_t* owned_blob_new(
        void* ptr, void (*free_fn)(void*), const char* data, size_t len);
 
owned_blob_t* owned_blob_copy(owned_blob_t* to_copy);
 
void owned_blob_destroy(owned_blob_t* shared);
 
#ifdef __cplusplus
} // extern "C"
 
// If in C++, then add Serializable interface for objects which can be
// serialized into a msg_envelope_t* structure
namespace eii {
namespace msgbus {
 
class Serializable {
protected:
    msg_envelope_t* m_msg;
 
public:
    Serializable() : m_msg(NULL) {};
 
    Serializable(msg_envelope_t* msg) : m_msg(msg) {};
 
    virtual ~Serializable() {
        if(m_msg != NULL) {
            msgbus_msg_envelope_destroy(m_msg);
        }
    };
 
    virtual msg_envelope_t* serialize() = 0;
};
 
} // msgbus
} // eii
 
#endif // __cplusplus
 
#endif // _EII_MESSAGE_BUD_MSGENV_H