mn_basic_endpoint.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_ENDPOINT_HPP_
#define _MINLIB_BASIC_ENDPOINT_HPP_
 
#include "../mn_config.hpp"
#include "../mn_def.hpp"
 
 
#include "mn_basic_ip_address.hpp"
#include "mn_basic_ip4_address.hpp"
#include "mn_basic_ip6_address.hpp"
#include "mn_net_types.hpp"
 
 
namespace mn {
    namespace net {
        class basic_endpoint {
        public:
            virtual basic_endpoint* get_copy() = 0;
        };
 
        template <class TIPCLASS, address_family TAF>
        class basic_ip_endpoint : public basic_endpoint {
        public:
            using ip_type = TIPCLASS;
            using self_type = basic_ip_endpoint<TIPCLASS, TAF>;
 
            basic_ip_endpoint(const ip_type& ip, const uint16_t& port) noexcept
                : m_ipAdress(ip), m_iPort(port) { }
 
            basic_ip_endpoint(const self_type& pOther) noexcept
                : m_ipAdress(pOther.m_ipAdress), m_iPort(pOther.m_iPort) { }
 
            uint16_t            get_port() { return m_iPort; }
            ip_type             get_host()   { return m_ipAdress; }
            address_family      get_famile()   { return TAF; }
            void                set_port(const uint16_t& port) { if(port < 9999) m_iPort = port; }
            void                set_host(const ip_type& ip) { m_ipAdress = ip; }
            bool                is_multicast() { return m_ipAdress.is_multicast(); }
            bool                is_loopback()  { return m_ipAdress.is_loopback(); }
 
 
 
            self_type& operator = (const self_type& pOther) {
                if (this == &pOther) return *this;
                m_ipAdress = pOther.m_ipAdress; m_iPort = pOther.m_iPort; return *this;
            }
            bool operator == (const self_type& pOther) {
                if(m_iPort != pOther.m_iPort) return false;
                return m_ipAdress == pOther.m_ipAdress;
            }
            bool operator != (const self_type& pOther) {
                return !(*this == pOther);
            }
            bool operator < (const self_type& pOther) const {
                if(m_iPort >= pOther.m_iPort) return false;
                return m_ipAdress < pOther.m_ipAdress;
            }
 
            virtual void swap(self_type& rhs) noexcept {
                mn::swap<uint16_t>(m_iPort, rhs.m_iPort);
                m_ipAdress.swap(rhs.m_ipAdress);
            }
        protected:
            ip_type m_ipAdress;
            uint16_t m_iPort;
        };
    }
}
 
#endif // _MINLIB_BASIC_ENDPOINT_HPP_