MacAddress.h

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <initializer_list>
#include <iterator>
#include <ostream>
#include <stdint.h>
#include <string.h>
#include <string>
 
 
namespace pcpp
{
 
    class MacAddress
    {
    public:
        MacAddress() = default;
 
        explicit MacAddress(const uint8_t* addr)
        {
            memcpy(m_Address, addr, sizeof(m_Address));
        }
 
        explicit MacAddress(const std::string& addr);
 
        template <typename T, typename = typename std::enable_if<std::is_convertible<T, std::string>::value>::type>
        MacAddress(const T& addr) : MacAddress(static_cast<std::string>(addr))
        {}
 
        inline MacAddress(uint8_t firstOctet, uint8_t secondOctet, uint8_t thirdOctet, uint8_t fourthOctet,
                          uint8_t fifthOctet, uint8_t sixthOctet)
        {
            m_Address[0] = firstOctet;
            m_Address[1] = secondOctet;
            m_Address[2] = thirdOctet;
            m_Address[3] = fourthOctet;
            m_Address[4] = fifthOctet;
            m_Address[5] = sixthOctet;
        }
 
        MacAddress(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(), std::begin(m_Address));
        }
 
        bool operator==(const MacAddress& other) const
        {
            return memcmp(m_Address, other.m_Address, sizeof(m_Address)) == 0;
        }
 
        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(), std::begin(m_Address));
            return *this;
        }
 
        const uint8_t* getRawData() const
        {
            return m_Address;
        }
 
        std::string toString() const;
 
        void copyTo(uint8_t** arr) const
        {
            *arr = new uint8_t[sizeof(m_Address)];
            memcpy(*arr, m_Address, sizeof(m_Address));
        }
 
        void copyTo(uint8_t* arr) const
        {
            memcpy(arr, m_Address, sizeof(m_Address));
        }
 
        static MacAddress Zero;
 
    private:
        uint8_t m_Address[6] = { 0 };
    };
 
    inline std::ostream& operator<<(std::ostream& os, const pcpp::MacAddress& macAddress)
    {
        os << macAddress.toString();
        return os;
    }
}  // namespace pcpp