macaddress.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <cstdint>
#include <cstring>
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/result.h>
#include <promeki/array.h>
#include <promeki/list.h>
#include <promeki/datatype.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class Ipv4Address;
class Ipv6Address;
class MacAddress;
class TextStream;
class DataStream;
 
class MacAddress {
        public:
                PROMEKI_DATATYPE(MacAddress, DataTypeMacAddress, 1)
 
                
                Error writeToStream(DataStream &s) const;
                template <uint32_t V> static Result<MacAddress> readFromStream(DataStream &s);
 
                using DataFormat = Array<uint8_t, 6>;
 
                using List = ::promeki::List<MacAddress>;
 
                static Result<MacAddress> fromString(const String &str);
 
                static MacAddress broadcast();
 
                static MacAddress fromIpv4Multicast(const Ipv4Address &addr);
 
                static MacAddress fromIpv6Multicast(const Ipv6Address &addr);
 
                MacAddress() : _addr{} {}
 
                explicit MacAddress(const DataFormat &bytes) : _addr(bytes) {}
 
                MacAddress(uint8_t a, uint8_t b, uint8_t c, uint8_t d, uint8_t e, uint8_t f)
                    : _addr{DataFormat{a, b, c, d, e, f}} {}
 
                bool isNull() const { return _addr.isZero(); }
 
                bool isBroadcast() const {
                        for (size_t i = 0; i < 6; ++i) {
                                if (_addr[i] != 0xFF) return false;
                        }
                        return true;
                }
 
                bool isMulticast() const { return (_addr[0] & 0x01) != 0; }
 
                bool isGroupMulticast() const { return isMulticast() && !isBroadcast(); }
 
                bool isIpv4Multicast() const {
                        return _addr[0] == 0x01 && _addr[1] == 0x00 && _addr[2] == 0x5E && (_addr[3] & 0x80) == 0;
                }
 
                bool isIpv6Multicast() const { return _addr[0] == 0x33 && _addr[1] == 0x33; }
 
                bool isUnicast() const { return !isMulticast(); }
 
                bool isLocallyAdministered() const { return (_addr[0] & 0x02) != 0; }
 
                const DataFormat &data() const { return _addr; }
 
                const uint8_t *raw() const { return _addr.data(); }
 
                uint8_t octet(int index) const {
                        if (index < 0 || index > 5) return 0;
                        return _addr[index];
                }
 
                String toString() const;
 
                String toString(char separator) const;
 
                bool operator==(const MacAddress &other) const { return _addr == other._addr; }
                bool operator!=(const MacAddress &other) const { return _addr != other._addr; }
                bool operator<(const MacAddress &other) const {
                        return std::memcmp(_addr.data(), other._addr.data(), 6) < 0;
                }
 
        private:
                DataFormat _addr; 
};
 
TextStream &operator<<(TextStream &stream, const MacAddress &addr);
 
PROMEKI_NAMESPACE_END
 
PROMEKI_FORMAT_VIA_TOSTRING(promeki::MacAddress);
 
#endif // PROMEKI_ENABLE_CORE