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

/*
** libutil++
** $Id: Port.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__Port_H__
#define __libutilxx__sella__net__Port_H__

#include "../../common.h"
#include "PortException.h"

#include <sys/socket.h>
#include <stdint.h>

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

namespace sella {
        namespace net {
                class Port;
        }
}

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

                typedef struct {
                        size_t operator()(const Port &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<Port> list;
                typedef std::list<ptr> ptr_list;
                typedef std::list<shared> shared_list;
                typedef std::forward_list<Port> flist;
                typedef std::forward_list<ptr> ptr_flist;
                typedef std::forward_list<shared> shared_flist;
                typedef std::vector<Port> vector;
                typedef std::vector<ptr> ptr_vector;
                typedef std::vector<shared> shared_vector;
                typedef std::unordered_set<Port, hash> uset;
                typedef std::unordered_set<ptr, hash> ptr_uset;
                typedef std::unordered_set<shared, hash> shared_uset;
                typedef std::unordered_multiset<Port, hash> umset;
                typedef std::unordered_multiset<ptr, hash> ptr_umset;
                typedef std::unordered_multiset<shared, hash> shared_umset;

        public:
                static const int        UDPPreferred = 0x01;
                static const int        UDPRequired  = 0x03;

                static const int        TCPPreferred = 0x04;
                static const int        TCPRequired  = 0x12;

                static const int        UDPProtocol  = SOCK_DGRAM;
                static const int        TCPProtocol  = SOCK_STREAM;

        public:
                Port(const std::string &service, int protocol = TCPPreferred) throw (PortException);
                Port(uint16_t port = 0, int protocol = TCPPreferred) throw (PortException);
                Port(const struct sockaddr_storage *ss, int protocol = TCPPreferred) throw (PortException);
                Port(const struct sockaddr *sa, int protocol = TCPPreferred) throw (PortException);

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

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

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

        public:
                uint16_t get(void) const throw ();
                uint16_t getPort(void) const throw ();
                int getProtocol(void) const throw ();
                const std::string& str(void) const throw ();
                const char* c_str(void) const throw ();
                uint32_t getU32(void) const throw ();
                uint32_t getHash(void) const throw ();

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

                static const Port::shared shared_ptr(const std::string &service, int protocol = TCPPreferred) throw (PortException);
                static const Port::shared shared_ptr(uint16_t port = 0, int protocol = TCPPreferred) throw (PortException);
                static const Port::shared shared_ptr(const struct sockaddr_storage *ss, int protocol = TCPPreferred) throw (PortException);
                static const Port::shared shared_ptr(const struct sockaddr *sa, int protocol = TCPPreferred) throw (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); }

        protected:
                bool parseUDPPreferred(uint16_t &port, int &protocol, const std::string &service) throw ();
                bool parseTCPPreferred(uint16_t &port, int &protocol, const std::string &service) throw ();
                bool parseUDPRequired(uint16_t &port, int &protocol, const std::string &service) throw ();
                bool parseTCPRequired(uint16_t &port, int &protocol, const std::string &service) throw ();

        private:
                uint16_t                                        port;
                int                                             protocol;

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

#endif

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

---