mn_basic_ip4_address.hpp

Go to the documentation of this file.

/*
* This file is part of the Mini Thread Library (https://github.com/RoseLeBlood/MiniThread ).
* Copyright (c) 2018 Amber-Sophia Schroeck
*
* The Mini Thread Library 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, version 3, or (at your option) any later version.
*
* The Mini Thread Library 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
* General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with the Mini Thread  Library; if not, see
* <https://www.gnu.org/licenses/>.
*/
#ifndef __MINLIB_BASIC_IP4_ADDRESS_H__
#define __MINLIB_BASIC_IP4_ADDRESS_H__
 
#include "../mn_config.hpp"
 
#define MNNET_IPV4_ADDRESS_BYTES        4
 
#define MNNET_IPV4_ADDRESS_ANY          mn::net::basic_ip4_address( IPADDR_ANY )
#define MNNET_IPV4_ADDRESS_LOOPBACK     mn::net::basic_ip4_address( IPADDR_LOOPBACK )
#define MNNET_IPV4_ADDRESS_BROADCAST    mn::net::basic_ip4_address( IPADDR_BROADCAST )
#define MNNET_IPV4_ADDRESS_NONE         mn::net::basic_ip4_address( IPADDR_NONE )
 
#include "mn_basic_ip_address.hpp"
 
namespace mn {
    namespace net {
        class basic_ip4_address : public basic_ip_address {
        protected:
            union {
                uint8_t  as_array[MNNET_IPV4_ADDRESS_BYTES]; 
                uint32_t as_int32; 
            };
        public:
            basic_ip4_address();
            explicit basic_ip4_address(uint32_t newAddress) noexcept;
 
            basic_ip4_address(uint8_t adress[MNNET_IPV4_ADDRESS_BYTES]) noexcept;
            basic_ip4_address(uint8_t a, uint8_t b, uint8_t c, uint8_t d ) noexcept;
            basic_ip4_address(const char* str_ip) noexcept;
            basic_ip4_address(const basic_ip4_address& other) noexcept;
 
            uint8_t*            get_bytes();
 
            int length() const;
            inline void         set_zero()      { as_int32 = 0; }
            inline void         set_any()       { as_int32 = IPADDR_ANY; }
            inline void         set_broadcast() { as_int32 = IPADDR_BROADCAST; }
            inline void         set_loop()      { as_int32 = IPADDR_LOOPBACK; }
 
            virtual bool        is_equel(const basic_ip4_address& ipOther);
            inline bool             is_loopback()  { return (*this == MNNET_IPV4_ADDRESS_LOOPBACK); }
            inline bool             is_broadcast() { return (*this == MNNET_IPV4_ADDRESS_BROADCAST); }
            inline bool             is_multicast() { return ( as_int32 & PP_HTONL(0xf0000000UL) ) == PP_HTONL(0xe0000000UL); }
            inline bool             is_linklocal() { return ( as_int32 & PP_HTONL(0xf0000000UL) ) == PP_HTONL(0xa9fe0000UL); }
 
            virtual const char* to_string();
            basic_ip4_address   calc_broadcast(const basic_ip4_address& subnet);
            basic_ip4_address   calc_network_id(const basic_ip4_address& subnet);
            static uint8_t      get_subnet_cidr(const basic_ip4_address& subnet);
 
            uint8_t             operator[](int index) const { return as_array[index]; }
            uint8_t&            operator[](int index) { return as_array[index]; }
            bool                operator == (const basic_ip4_address& ipOther){ return  is_equel(ipOther); }
            bool                operator != (const basic_ip4_address& ipOther){ return !is_equel(ipOther); }
            bool                operator == (const uint8_t* addr);
 
            basic_ip4_address&  operator=(const uint32_t& address);
            basic_ip4_address&  operator=(const basic_ip4_address& address);
            basic_ip4_address   operator&(const basic_ip4_address& other)const;
            basic_ip4_address   operator|(const basic_ip4_address& other)const;
            basic_ip4_address   operator^(const basic_ip4_address& other)const;
            basic_ip4_address   operator~() const;
            operator uint32_t() const { return as_int32; }
 
            virtual void swap(basic_ip4_address& rhs) noexcept {
                basic_ip_address::swap(rhs);
                mn::swap<uint32_t>(as_int32, rhs.as_int32);
            }
        };
    }
}
 
#endif // __MINLIB_BASIC_IP4_ADDRESS_H__