AsioDefines.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 ASIODEFINES
#define ASIODEFINES

#include <vector>
#include <functional>
#include <memory>
#include <utility>
#include <string>
#include <cstdint>
#include <boost/asio.hpp>
#include "CoreLibraryDllGlobal.h"
#include "Platform/PlatformDefines.h"

namespace boost_sys          = boost::system;
namespace boost_asio         = boost::asio;
namespace boost_placeholders = boost::asio::placeholders;
namespace boost_mcast        = boost::asio::ip::multicast;

using boost_iocontext_t = boost_asio::io_context;
using boost_tcp_t = boost_asio::ip::tcp;
using boost_tcp_acceptor_t = boost::asio::ip::tcp::acceptor;
using boost_udp_t = boost::asio::ip::udp;
using boost_address_t = boost::asio::ip::address;
using boost_address_v4_t = boost::asio::ip::address_v4;

namespace core_lib
{
namespace asio
{

namespace tcp
{

enum eDefReservedSize : size_t
{
    DEFAULT_RESERVED_SIZE = 512 * 1024
};

enum eDefUnsentAsyncCount : size_t
{
    MAX_UNSENT_ASYNC_MSG_COUNT = 1000
};

enum class eSendOption
{
    nagleOff,
    nagleOn
};

class TcpConnection;
} // namespace tcp

namespace udp
{

enum class eUdpOption
{
    broadcast,
    unicast
};

enum eUdpDatagramMaxSize : size_t
{
    UDP_DATAGRAM_MAX_SIZE = 65507
};

enum eDefaultUdpSize : size_t
{
    DEFAULT_UDP_BUF_SIZE = 8192
};

enum class eMulticastTTL
{
    sameHost = 0,
    sameSubnet = 1,
    sameSite = 32,
    sameRegion = 64,
    sameContinent = 128,
    unrestricted = 255
};

} // namespace udp

namespace defs
{

using connection_t = std::pair<std::string, uint16_t>;
extern const connection_t NULL_CONNECTION;
using tcp_conn_ptr_t = std::shared_ptr<tcp::TcpConnection>;
enum eRespAddressLen : uint32_t
{
    RESPONSE_ADDRESS_LEN = 16
};
enum eMagicStringLen : uint32_t
{
    MAGIC_STRING_LEN = 16
};
extern const char DEFAULT_MAGIC_STRING[];

enum class eArchiveType : uint8_t
{ 
  portableBinary,
  binary,
  json,
  xml,
  raw,
  protobuf
};

// Push single byte alignment for the MessageHeader strcuture for maximum portability.
#pragma pack(push, 1)

struct CORE_LIBRARY_DLL_SHARED_API MessageHeader
{
    char magicString[MAGIC_STRING_LEN]{};
    char responseAddress[RESPONSE_ADDRESS_LEN]{};
    uint16_t responsePort{0};
    int32_t messageId{0};
    eArchiveType archiveType{eArchiveType::portableBinary};
    uint32_t totalLength{sizeof(*this)};

    MessageHeader();
    ~MessageHeader() = default;
    MessageHeader(const MessageHeader&) = default;
    MessageHeader& operator=(const MessageHeader&) = default;
#ifdef USE_EXPLICIT_MOVE_

    MessageHeader(MessageHeader&& header);
    MessageHeader& operator=(MessageHeader&& header);
#else

    MessageHeader(MessageHeader&&) = default;
    MessageHeader& operator=(MessageHeader&&) = default;
#endif
};
// Pop single byte alignment.
#pragma pack(pop)

enum eMessageHeaderLen : size_t
{
    MESSAGE_HEADER_LEN = sizeof(MessageHeader)
};

using char_buffer_t = std::vector<char>;

template <typename Header> struct ReceivedMessage
{
    using header_t = Header;
    header_t header;
    char_buffer_t body;
    ReceivedMessage() = default;
    ~ReceivedMessage() = default;
    ReceivedMessage(const ReceivedMessage&) = default;
    ReceivedMessage& operator=(const ReceivedMessage&) = default;
#ifdef USE_EXPLICIT_MOVE_

    ReceivedMessage(ReceivedMessage&& message)
    {
        *this = std::move(message);
    }
    ReceivedMessage& operator=(ReceivedMessage&& message)
    {
        std::swap(header, message.header);
        body.swap(message.body);
        return *this;
    }
#else

    ReceivedMessage(ReceivedMessage&&) = default;
    ReceivedMessage& operator=(ReceivedMessage&&) = default;
#endif
};

using default_received_message_t = ReceivedMessage<MessageHeader>;
using default_received_message_ptr_t = std::shared_ptr<default_received_message_t>;
using default_message_dispatcher_t = std::function<void(default_received_message_ptr_t)>;
using check_bytes_left_to_read_t = std::function<size_t(const char_buffer_t&)>;
using message_received_handler_t = std::function<void(const char_buffer_t&)>;

} // namespace defs
} // namespace asio
} // namespace core_lib

#endif // ASIODEFINES