ipv6address.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <cstdint>
#include <cstring>
#include <promeki/datatype.h>
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/result.h>
#include <promeki/array.h>
#include <promeki/platform.h>
#include <promeki/list.h>
 
#if defined(PROMEKI_PLATFORM_WINDOWS)
#include <winsock2.h>
#include <ws2tcpip.h>
#elif !defined(PROMEKI_PLATFORM_EMSCRIPTEN)
#include <netinet/in.h>
#endif
 
PROMEKI_NAMESPACE_BEGIN
 
class Ipv4Address;
class Ipv6Address;
class MacAddress;
class TextStream;
class DataStream;
 
class Ipv6Address {
        public:
                PROMEKI_DATATYPE(Ipv6Address, DataTypeIpv6Address, 1)
 
                
                Error writeToStream(DataStream &s) const;
                template <uint32_t V> static Result<Ipv6Address> readFromStream(DataStream &s);
 
                using DataFormat = Array<uint8_t, 16>;
 
                using List = ::promeki::List<Ipv6Address>;
 
                static Result<Ipv6Address> fromString(const String &str);
 
                static Ipv6Address any() { return Ipv6Address(); }
 
                static Ipv6Address loopback();
 
                Ipv6Address() : _addr{}, _scopeId(0) {}
 
                explicit Ipv6Address(const DataFormat &bytes) : _addr(bytes), _scopeId(0) {}
 
                explicit Ipv6Address(const uint8_t *bytes) : _scopeId(0) {
                        for (size_t i = 0; i < 16; ++i) _addr[i] = bytes[i];
                }
 
                bool isNull() const { return _addr.isZero() && _scopeId == 0; }
 
                bool isLoopback() const;
 
                bool isMulticast() const { return _addr[0] == 0xFF; }
 
                bool isLinkLocal() const { return _addr[0] == 0xFE && (_addr[1] & 0xC0) == 0x80; }
 
                bool isV4Mapped() const;
 
                bool isSiteLocal() const { return _addr[0] == 0xFE && (_addr[1] & 0xC0) == 0xC0; }
 
                uint32_t scopeId() const { return _scopeId; }
 
                void setScopeId(uint32_t id) { _scopeId = id; }
 
                const DataFormat &data() const { return _addr; }
 
                const uint8_t *raw() const { return _addr.data(); }
 
                String toString() const;
 
                Ipv4Address toIpv4() const;
 
                MacAddress multicastMac() const;
 
#if !defined(PROMEKI_PLATFORM_EMSCRIPTEN)
                static Result<Ipv6Address> fromSockAddr(const struct sockaddr_in6 *sa);
 
                Error toSockAddr(struct sockaddr_in6 *sa) const;
#endif
 
                bool operator==(const Ipv6Address &other) const {
                        return _addr == other._addr && _scopeId == other._scopeId;
                }
                bool operator!=(const Ipv6Address &other) const { return !(*this == other); }
                bool operator<(const Ipv6Address &other) const {
                        int cmp = std::memcmp(_addr.data(), other._addr.data(), 16);
                        if (cmp != 0) return cmp < 0;
                        return _scopeId < other._scopeId;
                }
 
        private:
                DataFormat _addr;    
                uint32_t   _scopeId; 
};
 
TextStream &operator<<(TextStream &stream, const Ipv6Address &addr);
 
PROMEKI_NAMESPACE_END
 
PROMEKI_FORMAT_VIA_TOSTRING(promeki::Ipv6Address);
 
#endif // PROMEKI_ENABLE_CORE