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

/*
** libutil++
** $Id: IPPrefix.h 1243 2014-11-21 01:01:24Z 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__IPPrefix_H__
#define __libutilxx__sella__net__IPPrefix_H__

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

#include <netinet/in.h>

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

namespace sella {
        namespace net {
                class IPPrefix;
        }
}

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

                typedef struct {
                        size_t operator()(const IPPrefix &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 {
#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<IPPrefix> list;
                typedef std::list<ptr> ptr_list;
                typedef std::list<shared> shared_list;
                typedef std::forward_list<IPPrefix> flist;
                typedef std::forward_list<ptr> ptr_flist;
                typedef std::forward_list<shared> shared_flist;
                typedef std::vector<IPPrefix> vector;
                typedef std::vector<ptr> ptr_vector;
                typedef std::vector<shared> shared_vector;
                typedef std::unordered_set<IPPrefix, 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<IPPrefix, 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:
                IPPrefix(const IPAddress &address, uint8_t cidr) throw (AddressException);
                IPPrefix(const std::string &address, uint8_t cidr) throw (AddressException);
                IPPrefix(const std::string &prefix = std::string("0.0.0.0/32")) throw (AddressException);
                IPPrefix(const IPPrefix &other) throw ();
                IPPrefix(const IPPrefix &&other) throw ();
                virtual ~IPPrefix() throw ();

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

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

                /* Based off of PostgreSQL Network Address Operators: http://www.postgresql.org/docs/8.2/static/functions-net.html */
                bool operator<<(const IPPrefix &other) const throw (); /* contained within */
                bool operator<<=(const IPPrefix &other) const throw (); /* containd within or equals */
                bool operator>>(const IPPrefix &other) const throw (); /* contains */
                bool operator>>=(const IPPrefix &other) const throw (); /* contains or equals */

                bool operator<<(const IPAddress &other) const throw (); /* contained within */
                bool operator<<=(const IPAddress &other) const throw (); /* containd within or equals */
                bool operator>>(const IPAddress &other) const throw (); /* contains */
                bool operator>>=(const IPAddress &other) const throw (); /* contains or equals */

                bool contains(const IPPrefix &other, bool orEquals = false) const throw ();
                bool contains(const IPAddress &other, bool orEquals = false) const throw ();

        public:
                int getFamily(void) const throw ();
                const IPAddress& getIPAddress(void) const throw ();
                uint8_t getCIDR(void) const throw ();
                IPAddress getNetmask(void) const throw ();
                IPAddress getInverseMask(void) const throw ();
                IPAddress getNetwork(void) const throw ();
                //IPAddress getBroadcast(void) const throw ();
                IPAddress::vector getIPAddresses(bool usable = true) const throw (); /* Large prefix ranges will produce very large vectors. */
                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 IPPrefix::shared shared_ptr(const IPAddress &address, uint8_t cidr) throw (AddressException);
                static const IPPrefix::shared shared_ptr(const std::string &address, uint8_t cidr) throw (AddressException);
                static const IPPrefix::shared shared_ptr(const std::string &prefix = std::string("0.0.0.0/32")) 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); }

        private:
                IPAddress                               address;
                uint8_t                                 cidr;
                uint32_t                                        mask[4];

                mutable std::string     scache;
                mutable uint32_t                hcache;

                void generateMask(void) throw ();
};

#endif

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

---