eui64.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <cstdint>
#include <cstring>
#include <format>
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/result.h>
#include <promeki/array.h>
#include <promeki/enums.h>
#include <promeki/datatype.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class MacAddress;
class TextStream;
class DataStream;
 
class EUI64 {
        public:
                PROMEKI_DATATYPE(EUI64, DataTypeEUI64, 1)
 
                
                Error writeToStream(DataStream &s) const;
                template <uint32_t V> static Result<EUI64> readFromStream(DataStream &s);
 
                using DataFormat = Array<uint8_t, 8>;
 
                static Result<EUI64> fromString(const String &str);
 
                static EUI64 fromMacAddress(const MacAddress &mac);
 
                EUI64() : _addr{} {}
 
                explicit EUI64(const DataFormat &bytes) : _addr(bytes) {}
 
                EUI64(uint8_t a, uint8_t b, uint8_t c, uint8_t d, uint8_t e, uint8_t f, uint8_t g, uint8_t h)
                    : _addr{DataFormat{a, b, c, d, e, f, g, h}} {}
 
                bool isNull() const { return _addr.isZero(); }
 
                const DataFormat &data() const { return _addr; }
 
                const uint8_t *raw() const { return _addr.data(); }
 
                uint8_t octet(int index) const {
                        if (index < 0 || index > 7) return 0;
                        return _addr[index];
                }
 
                bool hasMacAddress() const { return _addr[3] == 0xFF && _addr[4] == 0xFE; }
 
                MacAddress toMacAddress() const;
 
                String toString() const;
 
                String toString(const EUI64Format &fmt) const;
 
                bool operator==(const EUI64 &other) const { return _addr == other._addr; }
                bool operator!=(const EUI64 &other) const { return _addr != other._addr; }
                bool operator<(const EUI64 &other) const {
                        return std::memcmp(_addr.data(), other._addr.data(), 8) < 0;
                }
 
        private:
                DataFormat _addr;
};
 
TextStream &operator<<(TextStream &stream, const EUI64 &addr);
 
PROMEKI_NAMESPACE_END
 
template <> struct std::formatter<promeki::EUI64> {
                int _spec = 0; // 0=hyphen, 1=colon, 2=ipv6
 
                constexpr auto parse(std::format_parse_context &ctx) {
                        auto it = ctx.begin();
                        if (it != ctx.end() && *it != '}') {
                                if (*it == 'h') {
                                        _spec = 0;
                                        ++it;
                                } else if (*it == 'o') {
                                        _spec = 1;
                                        ++it;
                                } else if (*it == 'v') {
                                        _spec = 2;
                                        ++it;
                                }
                        }
                        return it;
                }
 
                template <typename FormatContext> auto format(const promeki::EUI64 &v, FormatContext &ctx) const {
                        promeki::EUI64Format fmt(_spec);
                        promeki::String      s = v.toString(fmt);
                        return std::format_to(ctx.out(), "{}", std::string_view(s.cstr(), s.byteCount()));
                }
};
 
#endif // PROMEKI_ENABLE_CORE