msg_envelope.hpp

Go to the documentation of this file.

// Copyright (c) 2021 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_MSGENVELOPE_HPP_
#define _EII_MSGENVELOPE_HPP_
 
#include <stdint.h>
#include <iostream>
#include <string>
#include <vector>
#include <typeinfo>
#include <exception>
#include "eii/msgbus/msg_envelope.h"
 
 
namespace eii {
namespace msgbus {
 
class MsgbusException : public std::exception {
 private:
    // EII Message Bus C return value
    msgbus_ret_t m_ret;
 
    // Extra message with the exception providing additional context
    std::string m_msg;
 
 public:
    MsgbusException(msgbus_ret_t ret, const char* msg);
 
    const char * what() const noexcept override {
        return m_msg.c_str();
    }
 
    msgbus_ret_t get_msgbus_ret();
};
 
// Forward declarations
class MsgEnvelopeObject;
class MsgEnvelopeList;
class MsgEnvelope;
 
class MsgEnvelopeElement {
 private:
    // msg_envelope_elem_body_t object
    msg_envelope_elem_body_t* m_elem;
 
    MsgEnvelopeElement(const MsgEnvelopeElement& src);
 
    MsgEnvelopeElement& operator=(const MsgEnvelopeElement& src);
 
    MsgEnvelopeElement(msg_envelope_elem_body_t* elem);
 
 public:
    // Declaring MsgEnvelope as friend so that it can access
    // private constructors
    friend MsgEnvelope;
    friend MsgEnvelopeList;
    friend MsgEnvelopeObject;
 
    int64_t to_int();
 
    double to_float();
 
    const char* to_string();
 
    bool to_bool();
 
    MsgEnvelopeList* to_array();
 
    MsgEnvelopeObject* to_object();
 
    bool is_none();
 
    msg_envelope_data_type_t get_type();
 
    const char* get_type_str();
 
    ~MsgEnvelopeElement();
};
 
class MsgEnvelope {
 private:
    // msg_envelope_t object
    msg_envelope_t* m_msgenv;
 
    MsgEnvelope(const MsgEnvelope& src);
 
    MsgEnvelope& operator=(const MsgEnvelope& src);
 
 public:
    MsgEnvelope(content_type_t ct);
 
    MsgEnvelope(msg_envelope_t* msgenv);
 
    void put_integer(const std::string key, int64_t value);
 
    void put_float(const std::string key, double value);
 
    void put_string(const std::string key, const std::string value);
 
    void put_bool(const std::string key, bool value);
 
    void put_array(const std::string key, MsgEnvelopeList* value);
 
    template<typename T>
    void put_vector(const std::string key,
                    std::vector<T> const& value) {
      if (m_msgenv == NULL) {
         throw MsgbusException(MSG_ERR_UNKNOWN,
                               "Message Envelope already consumed, "
                               "unable to add to message envelope");
      }
      msg_envelope_elem_body_t* arr = msgbus_msg_envelope_new_array();
      if (arr == NULL) {
         throw MsgbusException(MSG_ERR_NO_MEMORY,
                               "Failed to create underlying msg envelope array");
      }
      msgbus_ret_t ret;
      for (int i = 0; i < value.size(); i++) {
         try {
            if (typeid(value).name() == typeid(std::vector<int>).name()) {
               ret = msgbus_msg_envelope_elem_array_add_integer(arr, value[i]);
               if (ret != MSG_SUCCESS) {
                  throw MsgbusException(ret, "Failed to add integer "
                                             "into msg envelope array");
               }
            } else if (typeid(value).name() == typeid(std::vector<double>).name()) {
               ret = msgbus_msg_envelope_elem_array_add_float(arr, value[i]);
               if (ret != MSG_SUCCESS) {
                  throw MsgbusException(ret, "Failed to add integer "
                                             "into msg envelope array");
               }
            } else if (typeid(value).name() == typeid(std::vector<bool>).name()) {
               ret = msgbus_msg_envelope_elem_array_add_bool(arr, value[i]);
               if (ret != MSG_SUCCESS) {
                  throw MsgbusException(ret, "Failed to add integer "
                                             "into msg envelope array");
               }
            } else {
               throw MsgbusException(MSG_ERR_UNKNOWN, "Vector type not supported");
            }
         } catch (const std::exception& e) {
            throw MsgbusException(MSG_ERR_UNKNOWN, e.what());
         }
      }
 
      if (m_msgenv == NULL) {
         throw MsgbusException(MSG_ERR_UNKNOWN,
                              "Message Envelope already consumed, "
                              "unable to add to message envelope");
      }
      ret = msgbus_msg_envelope_put(m_msgenv, key.c_str(), arr);
      if (ret != MSG_SUCCESS) {
         throw MsgbusException(ret, "Failed to add array into message envelope");
      }
    }
 
    void put_object(const std::string key, MsgEnvelopeObject* value);
 
    void put_blob(char* value, size_t size);
 
    void remove(const std::string key);
 
    int64_t get_int(const std::string key);
 
    double get_float(const std::string key);
 
    const char* get_string(const std::string key);
 
    bool get_bool(const std::string key);
 
    char* get_blob(const std::string key);
 
    MsgEnvelopeObject* get_object(const std::string key);
 
    MsgEnvelopeList* get_array(const std::string key);
 
    MsgEnvelopeElement* get_msg_envelope_element(const std::string key);
 
    msg_envelope_t* get_msg_envelope();
 
    ~MsgEnvelope();
};
 
class MsgEnvelopeList {
 private:
    // msg_envelope_elem_body_t object
    msg_envelope_elem_body_t* m_arr;
 
    // bool whether the MsgEnvelopeList owns m_arr
    bool m_owns_array;
 
    MsgEnvelopeList(const MsgEnvelopeList& src);
 
    MsgEnvelopeList& operator=(const MsgEnvelopeList& src);
 
    MsgEnvelopeList(msg_envelope_elem_body_t* arr, bool owns_array);
 
 public:
    // Declaring MsgEnvelope as friend so that it can access
    // private constructors
    friend MsgEnvelope;
 
    MsgEnvelopeList();
 
    void put_integer(int64_t value);
 
    void put_float(double value);
 
    void put_string(const std::string value);
 
    void put_bool(bool value);
 
    void put_object(MsgEnvelopeObject* value);
 
    void remove_at(int64_t index);
 
    int64_t get_int(int64_t index);
 
    double get_float(int64_t index);
 
    const char* get_string(int64_t index);
 
    bool get_bool(int64_t index);
 
    MsgEnvelopeObject* get_msg_envelope_object(int64_t index);
 
    MsgEnvelopeElement* get_msg_envelope_element(int64_t index);
 
    msg_envelope_elem_body_t* get_msg_envelope_array();
 
    ~MsgEnvelopeList();
};
 
class MsgEnvelopeObject {
 private:
    // msg_envelope_elem_body_t object
    msg_envelope_elem_body_t* m_msgenvobj;
 
    // bool whether the MsgEnvelopeObject object owns m_msgenvobj
    bool m_owns_object;
 
    MsgEnvelopeObject(const MsgEnvelopeObject& src);
 
    MsgEnvelopeObject& operator=(const MsgEnvelopeObject& src);
 
    MsgEnvelopeObject(msg_envelope_elem_body_t* obj, bool owns_object);
 
 public:
    // Declaring MsgEnvelope as friend so that it can access
    // private constructors
    friend MsgEnvelope;
 
    MsgEnvelopeObject();
 
    void put_integer(const std::string key, int64_t value);
 
    void put_float(const std::string key, double value);
 
    void put_string(const std::string key, const std::string value);
 
    void put_bool(const std::string key, bool value);
 
    void remove(const std::string key);
 
    int64_t get_int(const std::string key);
 
    double get_float(const std::string key);
 
    const char* get_string(const std::string key);
 
    bool get_bool(const std::string key);
 
    MsgEnvelopeElement* get_msg_envelope_element(const std::string key);
 
    msg_envelope_elem_body_t* get_msg_envelope_object();
 
    ~MsgEnvelopeObject();
};
 
}  // namespace msgbus
}  // namespace eii
 
const char* msgbus_msg_envelope_elem_type_str(msg_envelope_data_type_t dt);
 
#endif  // _EII_MSGENVELOPE_HPP_