Message.hpp

Go to the documentation of this file.

//
// Created by cbihan on 28/09/2021.
//
 
#pragma once
 
#include "Exceptions/BabelException.hpp"
#include "Utilities/SwapEndian.hpp"
#include <cstring>
#include <cstdint>
#include <vector>
#include <algorithm>
#include <iostream>
#include <bit>
 
namespace Babel
{
 
    template<typename T>
    struct MessageHeader
    {
        T codeId;
        uint32_t bodySize = 0;
 
        void handleEndianness();
 
 
//      //! @brief The UNIX Timestamp of the creation of the message
//      uint32_t timeStamp;
    };
 
    template<typename T>
    void MessageHeader<T>::handleEndianness()
    {
        if constexpr(std::endian::native != std::endian::big) {
            this->codeId = swapEndian<T>(this->codeId);
            this->bodySize = swapEndian<uint32_t>(this->bodySize);
        }
    }
 
    template<typename T>
    struct Message
    {
        MessageHeader<T> header;
        std::vector<uint8_t> body;
 
        size_t size() const;
 
        template<typename DataType>
        static Message<T> &GetBytes(Message<T> &msg, DataType &data, uint64_t size);
 
        static Message<T> &GetBytes(Message<T> &msg, std::string &data, uint64_t size);
 
        void reset();
 
        explicit Message();
 
        Message(const Message<T> &m) = default;
 
        ~Message() = default;
 
        Message &operator=(const Message<T> &) = default;
    };
 
 
    template<typename T>
    size_t Message<T>::size() const
    {
        return this->body.size();
    }
 
    template<typename T>
    template<typename DataType>
    Message<T> &Message<T>::GetBytes(Message<T> &msg, DataType &data, uint64_t size)
    {
        static_assert(std::is_standard_layout<DataType>::value, "Data is too complex to be pulled from vector");
 
        if (size > msg.body.size()) {
            throw Exception::BabelException("GetBytes: the size was superior than the message size");
        }
 
        size_t i = msg.body.size() - size;
        std::memmove(&data, msg.body.data(), size);
        msg.body.assign(msg.body.begin() + size, msg.body.end());
        if constexpr(std::endian::native != std::endian::big) {
            data = swapEndian<DataType>(data);
        }
        msg.body.resize(i);
        msg.header.bodySize = msg.size();
 
        return msg;
    }
 
    template<typename T>
    Message<T> &Message<T>::GetBytes(Message<T> &msg, std::string &data, uint64_t size)
    {
        if (size > msg.body.size()) {
            throw Exception::BabelException("GetBytes: the size was superior than the message size");
        }
 
        size_t i = msg.body.size() - size;
 
        data.assign(reinterpret_cast<char *>(msg.body.data()), size);
        msg.body.assign(msg.body.begin() + size, msg.body.end());
        if constexpr(std::endian::native != std::endian::big) {
            std::reverse(data.begin(), data.end());
        }
        msg.body.resize(i);
        msg.header.bodySize = msg.body.size();
 
        return msg;
    }
 
    template<typename T>
    Message<T>::Message()
        : header({}),
          body({})
    {
    }
 
    template<typename T>
    void Message<T>::reset()
    {
        this->header.bodySize = 0;
        this->body.clear();
    }
 
    template<typename T>
    std::ostream &operator<<(std::ostream &os, const Message<T> &msg)
    {
        os << "ID:" << int(msg.header.codeId) << " Size:" << msg.header.bodySize;
        return os;
    }
 
    template<typename T, typename DataType>
    Message<T> &operator<<(Message<T> &msg, DataType data)
    {
        static_assert(std::is_standard_layout<DataType>::value, "Data is too complex to be pushed into vector");
 
        size_t i = msg.body.size();
 
        msg.body.resize(msg.body.size() + sizeof(DataType));
        if constexpr(std::endian::native != std::endian::big) {
            data = swapEndian<DataType>(data);
        }
 
        std::memmove(msg.body.data() + i, &data, sizeof(DataType));
        msg.header.bodySize = msg.size();
        return msg;
    }
 
    template<typename T>
    Message<T> &operator<<(Message<T> &msg, std::string data)
    {
 
        size_t i = msg.body.size();
 
        msg.body.resize(msg.body.size() + data.size());
        if constexpr(std::endian::native != std::endian::big) {
            std::reverse(data.begin(), data.end());
        }
 
        std::memmove(msg.body.data() + i, data.data(), data.size());
        msg.header.bodySize = msg.size();
        return msg;
    }
 
    template<typename T>
    Message<T> &operator<<(Message<T> &msg, const char data[])
    {
        return msg << std::string(data);
    }
 
    template<typename T, typename DataType>
    Message<T> &operator>>(Message<T> &msg, DataType &data)
    {
        return Message<T>::GetBytes(msg, data, sizeof(DataType));
    }
}