/builddir/build/BUILD/libutil++-1.4.0/src/sella/net/IPAddress.h

/*
** libutil++
** $Id: IPAddress.h 1242 2014-11-21 00:52:29Z sella $
** Copyright (c) 2011-2014 Digital Genesis, LLC. All Rights Reserved.
** Released under the LGPL Version 2.1 License.
** http://www.digitalgenesis.com
*/

#ifndef __libutilxx__sella__net__IPAddress_H__
#define __libutilxx__sella__net__IPAddress_H__

#include "../../common.h"
#include "AddressException.h"

#include <arpa/inet.h>
#include <netinet/in.h>

#include <list>
#include <vector>
#include <string>
#include <memory>
#include <forward_list>
#include <unordered_set>

namespace sella {
        namespace net {
                class IPAddress;
        }
}

class sella::net::IPAddress {
        public:
                typedef std::shared_ptr<IPAddress> shared;
                typedef IPAddress *ptr;

                typedef struct {
                        size_t operator()(const IPAddress &a) const {
                                const std::unordered_set<uint32_t> s;
                                const std::unordered_set<uint32_t>::hasher &hfn = s.hash_function();

                                return hfn(a.getHash());
                        }
                } hash;

                typedef struct {
                        size_t operator()(const ptr a) const {
                                const std::unordered_set<uint32_t> s;
                                const std::unordered_set<uint32_t>::hasher &hfn = s.hash_function();

                                return hfn(a->getHash());
                        }
                } ptr_hash;

                typedef struct {
                        size_t operator()(const shared &a) const {
                                const std::unordered_set<uint32_t> s;
                                const std::unordered_set<uint32_t>::hasher &hfn = s.hash_function();

                                return hfn(a->getHash());
                        }
                } shared_hash;

                typedef struct {
                        bool operator()(const ptr a, const ptr b) const {
                                if (a == NULL || b == NULL) {
                                        return false;
                                }
                                return (*a == *b);
                        }
                } ptr_eq;

                typedef struct {
                        bool operator()(const shared &a, const shared &b) const {
                                return (*a == *b);
                        }
                } shared_eq;

                typedef std::list<IPAddress> list;
                typedef std::list<ptr> ptr_list;
                typedef std::list<shared> shared_list;
                typedef std::forward_list<IPAddress> flist;
                typedef std::forward_list<ptr> ptr_flist;
                typedef std::forward_list<shared> shared_flist;
                typedef std::vector<IPAddress> vector;
                typedef std::vector<ptr> ptr_vector;
                typedef std::vector<shared> shared_vector;
                typedef std::unordered_set<IPAddress, hash> uset;
                typedef std::unordered_set<ptr, ptr_hash, ptr_eq> ptr_uset;
                typedef std::unordered_set<shared, shared_hash, shared_eq> shared_uset;
                typedef std::unordered_multiset<IPAddress, hash> umset;
                typedef std::unordered_multiset<ptr, ptr_hash, ptr_eq> ptr_umset;
                typedef std::unordered_multiset<shared, shared_hash, shared_eq> shared_umset;

        public:
                static const int        IPv4Preferred = 0x01;
                static const int        IPv4Required  = 0x03;

                static const int        IPv6Preferred = 0x04;
                static const int        IPv6Required  = 0x12;

                static const int        IPv4Family    = AF_INET;
                static const int        IPv6Family    = AF_INET6;

        public:
                IPAddress(const std::string &text, int family = IPv4Preferred, uint8_t cidr = 255) throw (AddressException);
                IPAddress(int family = IPv4Preferred) throw (AddressException);
                IPAddress(const struct sockaddr_storage *ss, uint8_t cidr = 255) throw (AddressException);
                IPAddress(const struct sockaddr *sa, uint8_t cidr = 255) throw (AddressException);
                IPAddress(const struct in_addr *in, uint8_t cidr = 255) throw (AddressException);
                IPAddress(const struct in6_addr *in6, uint8_t cidr = 255) throw (AddressException);
                IPAddress(uint32_t address, uint8_t cidr = 255) throw (AddressException);
                IPAddress(unsigned char address[16], uint8_t cidr = 255) throw (AddressException);

                IPAddress(const IPAddress &other) throw ();
                IPAddress(const IPAddress &&other) throw ();
                virtual ~IPAddress() throw ();

        public:
                IPAddress& operator=(const IPAddress &other) throw ();
                IPAddress& operator=(const IPAddress &&other) throw ();

                bool operator==(const IPAddress &other) const throw ();
                bool operator!=(const IPAddress &other) const throw ();
                bool operator>=(const IPAddress &other) const throw ();
                bool operator<=(const IPAddress &other) const throw ();
                bool operator<(const IPAddress &other) const throw ();
                bool operator>(const IPAddress &other) const throw ();

                IPAddress operator&(const IPAddress &other) const throw (AddressException);
                IPAddress operator|(const IPAddress &other) const throw (AddressException);
                IPAddress operator^(const IPAddress &other) const throw (AddressException);
                IPAddress operator~() const throw ();

                IPAddress& operator+=(uint32_t increment) throw ();
                IPAddress operator+(uint32_t increment) const throw ();
                IPAddress operator++(int) throw ();
                IPAddress& operator++() throw ();

                IPAddress& operator-=(uint32_t increment) throw ();
                IPAddress operator-(uint32_t increment) const throw ();
                IPAddress operator--(int) throw ();
                IPAddress& operator--() throw ();

        public:
                void applyCIDR(uint8_t cidr) throw (AddressException);

                int getFamily(void) const throw ();
                size_t getAddressStructureSize(void) const throw ();

                const struct in_addr& getIPv4AddressStructure(void) const throw (AddressException);
                const struct in6_addr& getIPv6AddressStructure(void) const throw (AddressException);
                const std::string& str(void) const throw (AddressException);
                const char* c_str(void) const throw (AddressException);
                uint32_t getU32(void) const throw ();
                uint32_t getHash(void) const throw ();

                bool empty(void) const throw ();
                void clear(void) throw ();

                static const IPAddress::shared shared_ptr(const std::string &text, int family = IPv4Preferred, uint8_t cidr = 255) throw (AddressException);
                static const IPAddress::shared shared_ptr(int family = IPv4Preferred, uint8_t cidr = 255) throw (AddressException);
                static const IPAddress::shared shared_ptr(const struct sockaddr_storage *ss, uint8_t cidr = 255) throw (AddressException);
                static const IPAddress::shared shared_ptr(const struct sockaddr *sa, uint8_t cidr = 255) throw (AddressException);
                static const IPAddress::shared shared_ptr(const struct in_addr *in, uint8_t cidr = 255) throw (AddressException);
                static const IPAddress::shared shared_ptr(const struct in6_addr *in6, uint8_t cidr = 255) throw (AddressException);
                static const IPAddress::shared shared_ptr(uint32_t address, uint8_t cidr = 255) throw (AddressException);
                static const IPAddress::shared shared_ptr(unsigned char address[16], uint8_t cidr = 255) throw (AddressException);

        public:
                static bool shared_bi_cmp(shared &a, shared &b) { return (*a < *b); }
                static bool shared_bi_eq(shared &a, shared &b) { return (*a == *b); }

        protected:
                bool parse(int &family, struct in_addr &v4, struct in6_addr &v6, const std::string &addr) throw ();
                bool parse(int &family, struct in6_addr &v6, struct in_addr &v4, const std::string &addr) throw ();
                bool parse(int &family, struct in_addr &v4, const std::string &addr) throw ();
                bool parse(int &family, struct in6_addr &v6, const std::string &addr) throw ();

        private:
                int                                             family;

                union {
                        struct in_addr          v4;
                        struct in6_addr v6;
                }                                                       addr;

                mutable std::string     scache;
                mutable uint32_t                hcache;
};

#endif

/*
** vim: noet ts=3 sw=3
*/

---