MacAddress.h

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <initializer_list>
#include <iterator>
#include <ostream>
#include <cstdint>
#include <string>
#include <array>
#include <memory>
 
#include "DeprecationUtils.h"
 
 
namespace pcpp
{
 
    class MacAddress
    {
    public:
        MacAddress() = default;
 
        explicit MacAddress(const uint8_t addr[6]) : MacAddress(addr, 6)
        {}
 
        explicit MacAddress(const uint8_t* addr, size_t size);
 
        explicit MacAddress(const std::array<uint8_t, 6>& addr) : m_Address(addr)
        {}
 
        explicit MacAddress(const std::string& addr);
 
        template <typename T,
                  typename = std::enable_if_t<std::is_convertible<T, std::string>::value && !std::is_array<T>::value>>
        MacAddress(const T& addr) : MacAddress(static_cast<std::string>(addr))
        {}
 
        template <size_t N>
        MacAddress(const char (&addr)[N]) : MacAddress(std::string(addr, std::find(addr, addr + N, '\0')))
        {}
 
        MacAddress(uint8_t firstOctet, uint8_t secondOctet, uint8_t thirdOctet, uint8_t fourthOctet, uint8_t fifthOctet,
                   uint8_t sixthOctet)
            : m_Address{ firstOctet, secondOctet, thirdOctet, fourthOctet, fifthOctet, sixthOctet }
        {}
 
        MacAddress(std::initializer_list<uint8_t> octets)
        {
            if (octets.size() != m_Address.size())
            {
                throw std::invalid_argument("Invalid initializer list size, should be 6");
            }
            std::copy(octets.begin(), octets.end(), std::begin(m_Address));
        }
 
        bool operator==(const MacAddress& other) const
        {
            return m_Address == other.m_Address;
        }
 
        bool operator!=(const MacAddress& other) const
        {
            return !operator==(other);
        }
 
        MacAddress& operator=(std::initializer_list<uint8_t> octets)
        {
            if (octets.size() != sizeof(m_Address))
            {
                throw std::invalid_argument("Invalid initializer list size, should be 6");
            }
 
            std::copy(octets.begin(), octets.end(), m_Address.begin());
            return *this;
        }
 
        const uint8_t* getRawData() const
        {
            return m_Address.data();
        }
 
        std::string toString() const;
 
        std::array<uint8_t, 6> toByteArray() const
        {
            return m_Address;
        }
 
        PCPP_DEPRECATED("Use copyToNewBuffer instead.")
        void copyTo(uint8_t** arr) const
        {
            size_t unused = 0;
            copyToNewBuffer(arr, unused);
        }
 
        void copyTo(uint8_t arr[6]) const
        {
            copyTo(arr, 6);
        }
 
        size_t copyTo(uint8_t* buffer, size_t size) const;
 
        bool copyToNewBuffer(uint8_t** buffer, size_t& size) const;
 
        static const MacAddress Zero;
        static const MacAddress Broadcast;
 
    private:
        std::array<uint8_t, 6> m_Address{};
    };
 
    namespace literals
    {
        inline MacAddress operator""_mac(const char* addrString, size_t size)
        {
            return MacAddress(std::string(addrString, size));
        }
    }  // namespace literals
 
    inline std::ostream& operator<<(std::ostream& oss, const pcpp::MacAddress& macAddress)
    {
        oss << macAddress.toString();
        return oss;
    }
}  // namespace pcpp