MessageUtils.h

Go to the documentation of this file.

// This file is part of CoreLibrary containing useful reusable utility
// classes.
//
// Copyright (C) 2014 to present, Duncan Crutchley
// Contact <dac1976github@outlook.com>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published
// by the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License and GNU Lesser General Public License
// for more details.
//
// You should have received a copy of the GNU General Public License
// and GNU Lesser General Public License along with this program. If
// not, see <http://www.gnu.org/licenses/>.

#ifndef MESSAGEUTILS
#define MESSAGEUTILS

#include <iterator>
#include <algorithm>
#include <cstring>
#include <cassert>
#include "AsioDefines.h"
#include "Serialization/SerializeToVector.h"

namespace core_lib
{
namespace asio
{
namespace messages
{

class CORE_LIBRARY_DLL_SHARED_API MessageHandler final
{
public:
#ifdef USE_DEFAULT_CONSTRUCTOR_

    MessageHandler();
#else

    MessageHandler() = default;
#endif

    MessageHandler(const defs::default_message_dispatcher_t& messageDispatcher,
                   const std::string&                        magicString, 
                   size_t memPoolMsgCount = 0,
                   size_t defaultMsgSize = udp::DEFAULT_UDP_BUF_SIZE);
    ~MessageHandler() = default;
    MessageHandler(const MessageHandler&) = default;
    MessageHandler& operator=(const MessageHandler&) = default;

#ifdef USE_EXPLICIT_MOVE_

    MessageHandler(MessageHandler&& mh);
    MessageHandler& operator=(MessageHandler&& mh);
#else

    MessageHandler(MessageHandler&&) = default;
    MessageHandler& operator=(MessageHandler&&) = default;
#endif

    size_t CheckBytesLeftToRead(const defs::char_buffer_t& message) const;
    void MessageReceivedHandler(const defs::char_buffer_t& message) const;
    
private:
    static bool CheckMessage(const defs::char_buffer_t& message);
    void InitialiseMsgPool(size_t memPoolMsgCount, size_t defaultMsgSize);
    defs::default_received_message_ptr_t GetNewMessgeObject() const;

private:
    defs::default_message_dispatcher_t m_messageDispatcher;
#ifdef USE_DEFAULT_CONSTRUCTOR_

    std::string m_magicString;
#else

    std::string m_magicString{static_cast<char const*>(defs::DEFAULT_MAGIC_STRING)};
#endif
    mutable size_t                                    m_msgPoolIndex{0};
    std::vector<defs::default_received_message_ptr_t> m_msgPool;
};

void CORE_LIBRARY_DLL_SHARED_API FillHeader(const std::string& magicString,
                                            defs::eArchiveType archiveType, int32_t messageId,
                                            const defs::connection_t& responseAddress,
                                            uint32_t messageLength, defs::MessageHeader& header);

template <typename A> struct ArchiveTypeToEnum
{
    static defs::eArchiveType Enumerate()
    {
        BOOST_THROW_EXCEPTION(std::invalid_argument("unknown archive type"));
        return defs::eArchiveType::raw;
    }
};

template <> struct ArchiveTypeToEnum<serialize::archives::out_bin_t>
{
    static defs::eArchiveType Enumerate()
    {
        return defs::eArchiveType::binary;
    }
};

template <> struct ArchiveTypeToEnum<serialize::archives::out_port_bin_t>
{
    static defs::eArchiveType Enumerate()
    {
        return defs::eArchiveType::portableBinary;
    }
};

template <> struct ArchiveTypeToEnum<serialize::archives::out_raw_t>
{
    static defs::eArchiveType Enumerate()
    {
        return defs::eArchiveType::raw;
    }
};

template <> struct ArchiveTypeToEnum<serialize::archives::out_protobuf_t>
{
    static defs::eArchiveType Enumerate()
    {
        return defs::eArchiveType::protobuf;
    }
};

template <> struct ArchiveTypeToEnum<serialize::archives::out_json_t>
{
    static defs::eArchiveType Enumerate()
    {
        return defs::eArchiveType::json;
    }
};

template <> struct ArchiveTypeToEnum<serialize::archives::out_xml_t>
{
    static defs::eArchiveType Enumerate()
    {
        return defs::eArchiveType::xml;
    }
};

class CORE_LIBRARY_DLL_SHARED_API MessageBuilder final
{
public:
#ifdef USE_DEFAULT_CONSTRUCTOR_

    MessageBuilder();
#else

    MessageBuilder() = default;
#endif

    explicit MessageBuilder(const std::string& magicString);
    ~MessageBuilder() = default;
    MessageBuilder(const MessageBuilder&) = default;
    MessageBuilder& operator=(const MessageBuilder&) = default;
#ifdef USE_EXPLICIT_MOVE_

    MessageBuilder(MessageBuilder&& mb);
    MessageBuilder& operator=(MessageBuilder&& mb);
#else

    MessageBuilder(MessageBuilder&&) = default;
    MessageBuilder& operator=(MessageBuilder&&) = default;
#endif

    defs::char_buffer_t const& Build(int32_t                   messageId,
                                     const defs::connection_t& responseAddress) const;
    defs::char_buffer_t const&
    Build(const defs::char_buffer_t& message, int32_t messageId,
          const defs::connection_t& responseAddress,
          defs::eArchiveType        archiveType = defs::eArchiveType::raw) const;
    defs::char_buffer_t const&
    Build(const void* message, size_t messageLength, int32_t messageId,
          const defs::connection_t& responseAddress,
          defs::eArchiveType        archiveType = defs::eArchiveType::raw) const;
    template <typename T, typename A>
    defs::char_buffer_t const& Build(const T& message, int32_t messageId,
                                     const defs::connection_t& responseAddress) const
    {
        // Serialise message.
        serialize::ToCharVector<T, A>(message, m_serialisationBuffer);

        if (m_serialisationBuffer.empty())
        {
            BOOST_THROW_EXCEPTION(std::runtime_error("cannot serialize message"));
        }

        // Resize message buffer.
        auto totalLength = sizeof(defs::MessageHeader) + m_serialisationBuffer.size();
        m_messageBuffer.resize(totalLength);

        // Fill header.
        const defs::eArchiveType archiveType = ArchiveTypeToEnum<A>().Enumerate();
        defs::MessageHeader*     header =
            reinterpret_cast<defs::MessageHeader*>(m_messageBuffer.data());
        FillHeader(m_magicString,
                   archiveType,
                   messageId,
                   responseAddress,
                   static_cast<uint32_t>(m_serialisationBuffer.size()),
                   *header);

        auto writePosIter = std::next(m_messageBuffer.begin(), sizeof(defs::MessageHeader));
        std::copy(m_serialisationBuffer.begin(), m_serialisationBuffer.end(), writePosIter);

        return m_messageBuffer;
    }

private:
#ifdef USE_DEFAULT_CONSTRUCTOR_

    std::string m_magicString;
#else

    std::string m_magicString{static_cast<char const*>(defs::DEFAULT_MAGIC_STRING)};
#endif
    mutable defs::char_buffer_t m_messageBuffer;
    mutable defs::char_buffer_t m_serialisationBuffer;
};

template <typename MsgBldr>
defs::char_buffer_t const&
BuildMessage(int32_t messageId, const defs::connection_t& responseAddress,
             const defs::connection_t& fallbackResponseAddress, const MsgBldr& messageBuilder)
{
    auto responseConn =
        (responseAddress == defs::NULL_CONNECTION) ? fallbackResponseAddress : responseAddress;
    return messageBuilder.Build(messageId, responseConn);
}
template <typename MsgBldr>
defs::char_buffer_t const& BuildMessage(defs::char_buffer_t const& message, int32_t messageId,
                                        const defs::connection_t& responseAddress,
                                        const defs::connection_t& fallbackResponseAddress,
                                        const MsgBldr&            messageBuilder)
{
    auto responseConn =
        (responseAddress == defs::NULL_CONNECTION) ? fallbackResponseAddress : responseAddress;
    return messageBuilder.Build(message, messageId, responseConn);
}
template <typename T, typename A, typename MsgBldr>
defs::char_buffer_t const&
BuildMessage(const T& message, int32_t messageId, const defs::connection_t& responseAddress,
             const defs::connection_t& fallbackResponseAddress, const MsgBldr& messageBuilder)
{
    auto responseConn =
        (responseAddress == defs::NULL_CONNECTION) ? fallbackResponseAddress : responseAddress;
    return messageBuilder.template Build<T, A>(message, messageId, responseConn);
}

template <typename T>
T DeserializeMessage(const defs::char_buffer_t& messageBuffer, defs::eArchiveType archiveType)
{
    assert((archiveType != defs::eArchiveType::raw) &&
           (archiveType != defs::eArchiveType::protobuf));

    switch (archiveType)
    {
    case defs::eArchiveType::binary:
        return serialize::ToObject<T, serialize::archives::in_bin_t>(messageBuffer);
    case defs::eArchiveType::portableBinary:
        return serialize::ToObject<T, serialize::archives::in_port_bin_t>(messageBuffer);
    case defs::eArchiveType::raw:
        // Do nothing.
        break;
    case defs::eArchiveType::json:
        return serialize::ToObject<T, serialize::archives::in_json_t>(messageBuffer);
    case defs::eArchiveType::xml:
        return serialize::ToObject<T, serialize::archives::in_xml_t>(messageBuffer);
    case defs::eArchiveType::protobuf:
        // Do nothing;
        break;
    }

    return T();
}

template <typename T> T DeserializeMessage(const defs::char_buffer_t& messageBuffer)
{
    return serialize::ToObject<T, serialize::archives::in_raw_t>(messageBuffer);
}

template <typename T> T DeserializeProtobuf(const defs::char_buffer_t& messageBuffer)
{
    return serialize::ToObject<T, serialize::archives::in_protobuf_t>(messageBuffer);
}

} // namespace messages
} // namespace asio
} // namespace core_lib

#endif // MESSAGEUTILS