net.hpp

Go to the documentation of this file.

#ifndef CORAL_NET_HPP
#define CORAL_NET_HPP

#ifdef _WIN32
#   include <winsock2.h>
#else
#   include <netinet/in.h>
#endif

#include <chrono>
#include <cstdint>
#include <string>

#include <coral/config.h>


namespace coral
{
namespace net
{


class Endpoint
{
public:
    Endpoint() CORAL_NOEXCEPT;

    explicit Endpoint(const std::string& url);

    Endpoint(const std::string& transport, const std::string& address);

    std::string Transport() const CORAL_NOEXCEPT;

    std::string Address() const CORAL_NOEXCEPT;

    std::string URL() const CORAL_NOEXCEPT;

private:
    std::string m_transport;
    std::string m_address;
};


namespace ip
{

    class Address
    {
    public:
        Address() CORAL_NOEXCEPT;

        /* implicit */ Address(const std::string& address);

        // C-style version of the above.
        /* implicit */ Address(const char* address);

        /* implicit */ Address(in_addr address) CORAL_NOEXCEPT;

        bool IsAnyAddress() const CORAL_NOEXCEPT;

        bool IsName() const CORAL_NOEXCEPT;

        std::string ToString() const CORAL_NOEXCEPT;

        in_addr ToInAddr() const;

    private:
        friend bool operator==(const Address&, const Address&);
        std::string m_strAddr;
        in_addr m_inAddr;
    };

    bool operator==(const Address& a1, const Address& a2);

    inline bool operator!=(const Address& a1, const Address& a2)
    {
        return !operator==(a1, a2);
    }


    class Port
    {
    public:
        /* implicit */ Port(std::uint16_t port = 0u) CORAL_NOEXCEPT;

        /* implicit */ Port(const std::string& port);

        // C-style version of the above.
        /* implicit */ Port(const char* port);

        bool IsNumber() const CORAL_NOEXCEPT;

        bool IsAnyPort() const CORAL_NOEXCEPT;

        std::uint16_t ToNumber() const;

        std::string ToString() const CORAL_NOEXCEPT;

        std::uint16_t ToNetworkByteOrder() const;

        static Port FromNetworkByteOrder(std::uint16_t nPort) CORAL_NOEXCEPT;

    private:
        std::int32_t m_port;
    };


    class Endpoint
    {
    public:
        Endpoint() CORAL_NOEXCEPT;

        Endpoint(
            const ip::Address& address,
            const ip::Port& port)
            CORAL_NOEXCEPT;

        explicit Endpoint(const std::string& specification);

        explicit Endpoint(const sockaddr_in& sin);

        explicit Endpoint(const sockaddr& sa);

        const ip::Address& Address() const CORAL_NOEXCEPT;

        void SetAddress(const ip::Address& value) CORAL_NOEXCEPT;

        const ip::Port& Port() const CORAL_NOEXCEPT;

        void SetPort_(const ip::Port& value) CORAL_NOEXCEPT;

        std::string ToString() const CORAL_NOEXCEPT;

        coral::net::Endpoint ToEndpoint(const std::string& transport) const;

        sockaddr_in ToSockaddrIn() const;

    private:
        ip::Address m_address;
        ip::Port m_port;
    };

} // namespace ip


class SlaveLocator
{
public:
    explicit SlaveLocator(
        const Endpoint& controlEndpoint = Endpoint{},
        const Endpoint& dataPubEndpoint = Endpoint{}) CORAL_NOEXCEPT;

    const Endpoint& ControlEndpoint() const CORAL_NOEXCEPT;
    const Endpoint& DataPubEndpoint() const CORAL_NOEXCEPT;

private:
    Endpoint m_controlEndpoint;
    Endpoint m_dataPubEndpoint;
};


}}      // namespace
#endif  // header guard