NetworkTypes.hpp

Go to the documentation of this file.

// @formatter:off
//
// Balau core C++ library
//
// Copyright (C) 2017 Bora Software (contact@borasoftware.com)
//
// Licensed under the Boost Software License - Version 1.0 - August 17th, 2003.
// See the LICENSE file for the full license text.
//

#ifndef COM_BORA_SOFTWARE__BALAU_NETWORK_HTTP_SERVER__NETWORK_TYPES
#define COM_BORA_SOFTWARE__BALAU_NETWORK_HTTP_SERVER__NETWORK_TYPES


#include <Balau/Type/ToString.hpp>
#include <Balau/Type/FromString.hpp>
#include <Balau/Util/Enums.hpp>

#include <Balau/ThirdParty/Boost/Beast/Http/BasicFileBody.hpp>

#include <boost/asio/bind_executor.hpp>
#include <boost/asio/connect.hpp>
#include <boost/asio/io_context.hpp>
#include <boost/asio/ip/tcp.hpp>
#include <boost/asio/ssl/error.hpp>
#include <boost/asio/ssl/stream.hpp>
#include <boost/asio/strand.hpp>
#include <boost/beast/core.hpp>
#include <boost/beast/http.hpp>
#include <boost/beast/version.hpp>
#include <boost/beast/websocket.hpp>
#include <boost/config.hpp>

namespace boost {

namespace asio::ip {

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(const address & a) {
    // Currently not possible to avoid std::allocator.
    return ::toString<AllocatorT>(a.to_string());
}

inline std::string toString(const address & a) {
    return a.to_string();
}

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(const tcp::endpoint & endpoint) {
    // Currently not possible to avoid std::allocator.
    return ::toString<AllocatorT>(endpoint.address().to_string(), ":", endpoint.port());
}

inline std::string toString(const tcp::endpoint & endpoint) {
    return ::toString(endpoint.address().to_string(), ":", endpoint.port());
}

inline void fromString(tcp::endpoint & endpoint, std::string_view value) {
    // TODO improve implementation (ipv4 / ipv6).

    const auto v = std::string(value);
    static const std::regex numeric("[0-9]+");

    const bool isPortOnly = std::regex_match(v, numeric);

    if (isPortOnly) {
        unsigned short port;
        ::fromString(port, value);
        endpoint = tcp::endpoint(make_address("127.0.0.1"), port);
        return;
    }

    auto lastColon = Balau::Util::Strings::lastIndexOf(value, ":");

    if (lastColon == std::string::npos) {
        // No port.
        endpoint = tcp::endpoint(make_address(v), 8080);
    } else {
        auto portStr = value.substr(lastColon + 1);

        if (Balau::Util::Strings::contains(portStr, "]")) {
            // No port.
            endpoint = tcp::endpoint(make_address(v), 8080);
        } else {
            auto ip = value.substr(0, lastColon);;
            unsigned short port;
            ::fromString(port, portStr);
            endpoint = tcp::endpoint(make_address(std::string(ip)), port);
        }
    }
}

} // namespace asio::ip

namespace system {

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(const error_code & errorCode) {
    // Currently not possible to avoid std::allocator.
    return Balau::U8String<AllocatorT>(errorCode.message());
}

inline std::string toString(const error_code & errorCode) {
    return errorCode.message();
}

} // namespace system

namespace beast::http {

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(const status & s) {
    #ifdef BOOST_BEAST_NEW_API
        return Balau::U8String<AllocatorT>(obsolete_reason(s));
    #else
        auto u = Balau::Util::Enums::toUnderlying(s);
        return Balau::U8String<AllocatorT>(detail::status_to_string<>((unsigned int) u));
    #endif
}

inline std::string toString(const status & s) {
    #ifdef BOOST_BEAST_NEW_API
        return std::string(obsolete_reason(s));
    #else
        auto u = Balau::Util::Enums::toUnderlying(s);
        return std::string(detail::status_to_string<>((unsigned int) u));
    #endif
}

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(const verb & method) {
    return Balau::U8String<AllocatorT>(to_string(method));
}

inline std::string toString(const verb & method) {
    return std::string(to_string(method));
}

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(const field & f) {
    return Balau::U8String<AllocatorT>(to_string(f));
}

inline std::string toString(const field & f) {
    return std::string(to_string(f));
}

} // namespace beast::http

} // namespace boost

namespace Balau::Network {

using Address = boost::asio::ip::address;

using Endpoint = boost::asio::ip::tcp::endpoint;

using CharVectorBody = boost::beast::http::vector_body<char>;

using StringBody = boost::beast::http::basic_string_body<char>;

using FileBody = Balau::Boost::Beast::Http::basic_file_body<boost::beast::file>;
//using FileBody = boost::beast::http::file_body;

using FileBodyValue = FileBody::value_type;

using EmptyBody = boost::beast::http::empty_body;

template<class Body, class Fields = boost::beast::http::fields>
using Request = boost::beast::http::request<Body, Fields>;

using StringRequest = Request<StringBody>;

using CharVectorRequest = Request<CharVectorBody>;

template<class Body, class Fields = boost::beast::http::fields>
using Response = boost::beast::http::response<Body, Fields>;

using StringResponse = Response<StringBody>;

using CharVectorResponse = Response<CharVectorBody>;

using EmptyResponse = Response<EmptyBody>;

using Method = boost::beast::http::verb;

using Field = boost::beast::http::field;

using Buffer = boost::beast::flat_buffer;

using Error = boost::beast::http::error;

using BoostSystemError = boost::system::system_error;

using BoostSystemErrorCode = boost::system::error_code;

using FileMode = boost::beast::file_mode;

using Status = boost::beast::http::status;

namespace SSL = boost::asio::ssl;

using TCP = boost::asio::ip::tcp;

namespace HTTP = boost::beast::http;

namespace WS = boost::beast::websocket;

using WsFrame = WS::frame_type;

inline Endpoint makeEndpoint(const std::string & address, unsigned short port) {
    return Endpoint(boost::asio::ip::make_address(address), port);
}

inline Endpoint makeEndpoint(const char * address, unsigned short port) {
    return Endpoint(boost::asio::ip::make_address(address), port);
}

inline std::shared_ptr<Endpoint> newEndpoint(const std::string & address, unsigned short port) {
    return std::shared_ptr<Endpoint>(new Endpoint(boost::asio::ip::make_address(address), port));
}

inline std::shared_ptr<Endpoint> newEndpoint(const char * address, unsigned short port) {
    return std::make_shared<Endpoint>(boost::asio::ip::make_address(address), port);
}

} // namespace Balau::Network

#endif // COM_BORA_SOFTWARE__BALAU_NETWORK_HTTP_SERVER__NETWORK_TYPES