networkaddress.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <variant>
#include <promeki/datatype.h>
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/result.h>
#include <promeki/platform.h>
#include <promeki/ipv4address.h>
#include <promeki/ipv6address.h>
 
#if defined(PROMEKI_PLATFORM_WINDOWS)
#include <winsock2.h>
#include <ws2tcpip.h>
#elif !defined(PROMEKI_PLATFORM_EMSCRIPTEN)
#include <sys/socket.h>
#include <netinet/in.h>
#endif
 
PROMEKI_NAMESPACE_BEGIN
 
class TextStream;
class DataStream;
 
class NetworkAddress {
        public:
                PROMEKI_DATATYPE(NetworkAddress, DataTypeNetworkAddress, 1)
 
                
                Error writeToStream(DataStream &s) const;
                template <uint32_t V> static Result<NetworkAddress> readFromStream(DataStream &s);
 
                enum Type {
                        None = 0, 
                        IPv4,     
                        IPv6,     
                        Hostname  
                };
 
                static Result<NetworkAddress> fromString(const String &str);
 
#if !defined(PROMEKI_PLATFORM_EMSCRIPTEN)
                static Result<NetworkAddress> fromSockAddr(const struct sockaddr *addr, size_t len);
#endif
 
                NetworkAddress() = default;
 
                NetworkAddress(const Ipv4Address &addr) : _data(addr) {}
 
                NetworkAddress(const Ipv6Address &addr) : _data(addr) {}
 
                explicit NetworkAddress(const String &hostname) : _data(hostname) {}
 
                Type type() const;
 
                bool isNull() const { return std::holds_alternative<std::monostate>(_data); }
 
                bool isIPv4() const { return std::holds_alternative<Ipv4Address>(_data); }
 
                bool isIPv6() const { return std::holds_alternative<Ipv6Address>(_data); }
 
                bool isHostname() const { return std::holds_alternative<String>(_data); }
 
                bool isResolved() const { return isIPv4() || isIPv6(); }
 
                Ipv4Address toIpv4() const;
 
                Ipv6Address toIpv6() const;
 
                String hostname() const;
 
                bool isLoopback() const;
 
                bool isMulticast() const;
 
                bool isLinkLocal() const;
 
                String toString() const;
 
#if !defined(PROMEKI_PLATFORM_EMSCRIPTEN)
                size_t toSockAddr(struct sockaddr_storage *storage) const;
 
                enum FamilyPreference {
                        PreferIPv4,   
                        PreferIPv6,   
                        AnyFamily     
                };
 
                Result<NetworkAddress> resolve(FamilyPreference prefer = PreferIPv4) const;
#endif
 
                bool operator==(const NetworkAddress &other) const { return _data == other._data; }
                bool operator!=(const NetworkAddress &other) const { return _data != other._data; }
 
        private:
                std::variant<std::monostate, Ipv4Address, Ipv6Address, String> _data;
};
 
TextStream &operator<<(TextStream &stream, const NetworkAddress &addr);
 
PROMEKI_NAMESPACE_END
 
PROMEKI_FORMAT_VIA_TOSTRING(promeki::NetworkAddress);
 
#endif // PROMEKI_ENABLE_CORE