address.hpp

Go to the documentation of this file.

 
/*******************************************************************************
* Copyright (C) 2018 Eddie Carle [eddie@isatec.ca]                             *
*                                                                              *
* This file is part of fastcgi++.                                              *
*                                                                              *
* fastcgi++ is free software: you can redistribute it and/or modify it under   *
* the terms of the GNU Lesser General Public License as  published by the Free *
* Software Foundation, either version 3 of the License, or (at your option)    *
* any later version.                                                           *
*                                                                              *
* fastcgi++ is distributed in the hope that it will be useful, but WITHOUT ANY *
* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS    *
* FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for     *
* more details.                                                                *
*                                                                              *
* You should have received a copy of the GNU Lesser General Public License     *
* along with fastcgi++.  If not, see <http://www.gnu.org/licenses/>.           *
*******************************************************************************/
 
#ifndef FASTCGIPP_ADDRESS_HPP
#define FASTCGIPP_ADDRESS_HPP
 
#include <array>
#include <algorithm>
#include <cstring>
 
namespace Fastcgipp
{
 
    struct Address
    {
        static constexpr size_t size=16;
 
        std::array<unsigned char, size> m_data;
 
 
        Address operator=(const unsigned char* data)
        {
            std::copy(data, data+m_data.size(), m_data.begin());
            return *this;
        }
 
        Address operator=(const Address& address)
        {
            std::copy(
                    address.m_data.begin(),
                    address.m_data.end(),
                    m_data.begin());
            return *this;
        }
 
        Address(const Address& address)
        {
            std::copy(
                    address.m_data.begin(),
                    address.m_data.end(),
                    m_data.begin());
        }
 
        Address()
        {
            zero();
        }
 
 
        explicit Address(const unsigned char* data)
        {
            std::copy(data, data+m_data.size(), m_data.begin());
        }
 
 
        template<class charT> void assign(
                const charT* start,
                const charT* end);
 
        Address(const char* string)
        {
            assign(string, string+std::strlen(string));
        }
 
        bool operator==(const Address& x) const
        {
            return std::equal(
                    m_data.cbegin(),
                    m_data.cend(),
                    x.m_data.cbegin());
        }
 
        bool operator<(const Address& x) const
        {
            return std::memcmp(m_data.data(), x.m_data.data(), size)<0;
        }
 
        operator bool() const;
 
        Address& operator&=(const Address& x);
 
        Address operator&(const Address& x) const
        {
            Address address(*this);
            address &= x;
 
            return address;
        }
 
        void zero()
        {
            m_data.fill(0);
        }
    };
 
 
    template<class charT, class Traits>
    std::basic_ostream<charT, Traits>& operator<<(
            std::basic_ostream<charT, Traits>& os,
            const Address& address);
 
 
    template<class charT, class Traits>
    std::basic_istream<charT, Traits>& operator>>(
            std::basic_istream<charT, Traits>& is,
            Address& address);
}
 
#endif