NetAddress.h

Go to the documentation of this file.

#ifndef CASTOR_NET_NETADDRESS_H
#define CASTOR_NET_NETADDRESS_H 1

#include <set>
#include <string>
#include <vector>
#include <asio.hpp>
#include <boost/algorithm/string.hpp>

#include "Exception.h"
#include "Types.h"

/*
 * Spica addressing scheme
 *
 * Generic:                                                                                     <spica-specific>
 *   <protocol>://<address>:<explicit port>                     (0x00)
 *
 * Spica-specific:                                                                      <spica-specific>
 *   spica+<protocol>://<address>                                       (0x01)
 *   spica+<protocol>://<address>[:<spica port>]        (0x02)
 *   spica+<protocol>://<address>[/cidr]                        (0x03)
 *
 *
 * Layout:
 *
 *   <uchar:spica-specific><uchar:protocol><ushort:port><uchar:address-length><uchar*:address>
 *
 *   0x00 <uchar:protocol> <ushort:port> <uchar:address-length> <uchar*:address>
 *   0x01 <uchar:protocol> <uchar:address-length> <uchar*:address>
 *   0x02 <uchar:protocol> <ushort:port> <uchar:address-length> <uchar*:address>
 *   0x03 <uchar:protocol> <uchar:cidr> <uchar:address-length> <uchar*:address>
 *
 */

namespace castor { namespace net {

        class NetAddress;

        typedef boost::shared_ptr<NetAddress> NetAddressPtr;

        enum SpicaSpecific {

                ss_none         = 0x00,
                ss_plain        = 0x01,
                ss_host         = 0x02,
                ss_network      = 0x03,
                ss_undecided = 0x04,
        };

        class NetAddress {

                private:

                        SpicaSpecific spicaSpecific;
                        unsigned char protocol;
                        unsigned short port;
                        unsigned char cidr;
                        asio::ip::address address;
                        bool empty;

                protected:

                        NetAddress(SpicaSpecific spicaSpecific, unsigned char protocol,
                                        const asio::ip::address &address, unsigned short port,
                                        unsigned char cidr);

                public:

                        NetAddress();
                        NetAddress(const std::string spec);

                        static NetAddressPtr create(const std::string spec) throw(Exception);
                        static NetAddressPtr create(SpicaSpecific ss, unsigned char protocol, const asio::ip::address &address, unsigned short port);
                        static NetAddressPtr create(unsigned char protocol, const asio::ip::address &address, unsigned short port);
                        static NetAddressPtr createPlain(unsigned char protocol, const asio::ip::address &address);
                        static NetAddressPtr createHost(unsigned char protocol, const asio::ip::address &address, unsigned short port);
                        static NetAddressPtr createNetwork(unsigned char protocol, const asio::ip::address &address, unsigned char cidr);
                        static NetAddressPtr create(SpicaSpecific ss, const asio::ip::tcp::endpoint &endpoint);
                        static NetAddressPtr create(SpicaSpecific ss, const asio::ip::udp::endpoint &endpoint);
                        static NetAddressPtr create(const BytesPtr bytes) throw();
                        static NetAddressPtr create(const char *data, size_t size) throw();

                        NetAddress(const NetAddress &other);
                        NetAddress(const BytesPtr bytes);
                        NetAddress(const asio::ip::address &address);
                        NetAddress(SpicaSpecific ss, const asio::ip::tcp::endpoint &endpoint);
                        NetAddress(SpicaSpecific ss, const asio::ip::udp::endpoint &endpoint);

                        void setSpicaSpecific(SpicaSpecific value);
                        SpicaSpecific getSpicaSpecific() const;
                        bool isSpicaSpecific() const;
                        bool isPlain() const;
                        bool isHost() const;
                        bool isNetwork() const;

                        bool isAny() const;

                        bool isEmpty() const;

                        bool isLoopback() const;
                        bool isMulticast() const;

                        void setProtocol(unsigned char value);
                        unsigned char getProtocol() const;

                        void setPort(unsigned short value);

                        unsigned short getPort() const;
                        unsigned char getCidr() const;

                        void setAddress(const asio::ip::address &address);
                        const asio::ip::address &getAddress() const;

                        BytesPtr getBytes() const;

                        std::string str() const;

                        static std::string protocol_to_string(int protocol);

                        static unsigned char string_to_protocol(const std::string protocol);

                        bool equals(const NetAddress &other) const;

                        NetAddress &operator=(const NetAddress &other);

                        friend bool operator==(const NetAddress &one, const NetAddress &other);
                        friend bool operator!=(const NetAddress &one, const NetAddress &other);
                        friend bool operator<(const NetAddress &one, const NetAddress &other);

                        bool similarLess(const NetAddress &y, bool checkProtocol = false) const;
                        bool sameScope(const NetAddress &y) const;

                protected:

                        void parse(const char *data, size_t size) throw();
        };

        struct NetAddressPtrLess { //: public std::binary_function<const NetAddressPtr &, const NetAddressPtr &, bool> {
                bool operator()(const NetAddressPtr &x, const NetAddressPtr &y) {
                        return (*x < *y);
                }
        };

        typedef std::set<NetAddressPtr, NetAddressPtrLess> NetAddressPtrSet;
        typedef std::multiset<NetAddressPtr, NetAddressPtrLess> NetAddressPtrMultiSet;
        typedef std::set<NetAddress> NetAddressSet;

        typedef std::vector<NetAddressPtr> NetAddressPtrList;

} }

std::ostream &operator<<(std::ostream &os, const castor::net::NetAddress &x);

#endif /* CASTOR_NET_NETADDRESS_H */