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

/*
** libutil++
** $Id: IPAddressPort.h 1197 2014-10-14 22:26:11Z 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__IPAddressPort_H__
#define __libutilxx__sella__net__IPAddressPort_H__

#include "../../common.h"
#include "IPAddress.h"
#include "TCPPort.h"
#include "UDPPort.h"

#include <netinet/in.h>

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

namespace sella {
        namespace net {
                class IPAddressPort;
        }
}

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

                typedef struct {
                        size_t operator()(const IPAddressPort &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 IPAddressPort *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 {
#ifdef KEYEQUAL_METHOD
                                const std::unordered_set<std::string> s;
                                const std::unordered_set<std::string>::key_equal &eqfn = s.key_eq();

                                return eqfn(a->str(), b->str());
#else
                                return (*a == *b);
#endif
                        }
                } shared_eq;

                typedef std::list<IPAddressPort> list;
                typedef std::list<ptr> ptr_list;
                typedef std::list<shared> shared_list;
                typedef std::forward_list<IPAddressPort> flist;
                typedef std::forward_list<ptr> ptr_flist;
                typedef std::forward_list<shared> shared_flist;
                typedef std::vector<IPAddressPort> vector;
                typedef std::vector<ptr> ptr_vector;
                typedef std::vector<shared> shared_vector;
                typedef std::unordered_set<IPAddressPort, 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<IPAddressPort, 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:
                IPAddressPort(const IPAddress &address, const Port &port) throw ();
                IPAddressPort(const IPAddress &address, const TCPPort &port) throw ();
                IPAddressPort(const IPAddress &address, const UDPPort &port) throw ();
                IPAddressPort(const IPAddress &address, uint16_t port) throw (PortException);
                IPAddressPort(const std::string &address = std::string("0.0.0.0"), uint16_t port = 0) throw (AddressException, PortException);
                IPAddressPort(const struct sockaddr_storage *ss) throw (AddressException, PortException);
                IPAddressPort(const struct sockaddr *sa) throw (AddressException, PortException);
                IPAddressPort(const IPAddressPort &other) throw ();
                IPAddressPort(const IPAddressPort &&other) throw ();
                virtual ~IPAddressPort() throw ();

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

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

        public:
                int getFamily(void) const throw ();
                const IPAddress& getIPAddress(void) const throw ();
                const Port& getPort(void) const throw ();
                const struct sockaddr_storage& getSockaddrStorage(void) const throw ();
                const struct sockaddr& getSockaddr(void) const throw ();
                const struct sockaddr_in& getSockaddrIn(void) const throw ();
                const struct sockaddr_in6& getSockaddrIn6(void) const throw ();

                bool hasIPAddress(void) const throw ();
                bool hasPort(void) const throw ();

                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 ();

                static const IPAddressPort::shared shared_ptr(const IPAddress &address, const Port &port) throw ();
                static const IPAddressPort::shared shared_ptr(const IPAddress &address, const TCPPort &port) throw ();
                static const IPAddressPort::shared shared_ptr(const IPAddress &address, const UDPPort &port) throw ();
                static const IPAddressPort::shared shared_ptr(const IPAddress &address, uint16_t port) throw (PortException);
                static const IPAddressPort::shared shared_ptr(const std::string &address = std::string("0.0.0.0"), uint16_t port = 0) throw (AddressException, PortException);
                static const IPAddressPort::shared shared_ptr(const struct sockaddr_storage *ss) throw (AddressException, PortException);
                static const IPAddressPort::shared shared_ptr(const struct sockaddr *sa) throw (AddressException, PortException);

        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); }

        private:
                IPAddress                               address;
                Port                                            port;

                union __sockaddr_union {
                        struct sockaddr_storage ss;
                        struct sockaddr sa;
                        struct sockaddr_in sa_in;
                        struct sockaddr_in6 sa_in6;
                } u;

                mutable std::string     scache;
                mutable uint32_t                hcache;

                void init(const IPAddress &address, const Port &port) throw ();
};

#endif

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

---