CastorChannel.h

Go to the documentation of this file.

#ifndef CASTOR_NET_CASTORCHANNEL_H
#define CASTOR_NET_CASTORCHANNEL_H 1

#include <ifaddrs.h>

#include <string>
#include <vector>
#include <set>

#include <boost/function.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/enable_shared_from_this.hpp>

#include "asio.hpp"

#include "Exception.h"
#include "Network.h"
#include "NetAddress.h"
#include "NetInterface.h"
#include "NetException.h"

namespace castor { namespace net {

        class CastorChannel;

        typedef boost::shared_ptr<CastorChannel> CastorChannelPtr;

        typedef boost::function<void (const char *, size_t, NetAddressPtr)> CastorChannelCallback;
        typedef boost::function<void (const char *, size_t, NetAddressPtr, CastorChannelPtr)> CastorChannelExtCallback;

        typedef boost::function<void (const NetAddress &)> Event;

        class CCallback {
                public:
                        virtual ~CCallback() { }
                        virtual void call(const char *data, size_t count, NetAddressPtr address) = 0;
        };

        typedef boost::shared_ptr<CCallback> CCallbackPtr;

        typedef asio::socket_base::reuse_address                ReuseAddress;
        typedef asio::ip::multicast::leave_group                LeaveGroup;
        typedef asio::ip::multicast::join_group                 JoinGroup;
        typedef asio::ip::multicast::enable_loopback    EnableLoopback;
        typedef asio::ip::multicast::hops                               MulticastHops;

        class CastorChannel : public boost::enable_shared_from_this<CastorChannel> {

                protected:

                        NetAddress address;

                        char buffer[8192];

                        typedef boost::shared_ptr<asio::thread> ThreadType;

                        asio::io_service *service;
                        asio::io_service::strand strand;

                        ThreadType thread;

                        CastorChannel(asio::io_service &service);

                        inline void signalReceive(const char *buffer, size_t count, NetAddressPtr address) {
                                if (this->callback) {
                                        this->callback(buffer, count, address);
                                }
                                if (this->callbackExt) {
                                        this->callbackExt(buffer, count, address, shared_from_this());
                                }
                        }


                        enum { mode_undefined, mode_accept, mode_connect } mode;

                        CCallbackPtr cb;

                        static CastorChannelPtr create(asio::io_service &service, const std::string spec) throw(NetException);
                        static CastorChannelPtr create(asio::io_service &service, const NetAddress &address) throw(NetException);

                        friend class Communication;

                        typedef std::map<std::string, NetInterfacePtr> InterfaceMap;
                        typedef std::set<NetAddress> AddressSet;

                        InterfaceMap interfaces;
                        AddressSet localAddresses;

                        bool closed;
                        bool async;

                        void getIfaddrs();

                public:

                        CastorChannelCallback callback;
                        CastorChannelExtCallback callbackExt;

                        Event peerAdded;
                        Event peerRemoved;

                        Event connectionLost;
                        Event connectionEstablished;

                        CastorChannel(const CastorChannel &other);

                        virtual ~CastorChannel();

                        void registerCallback(CCallbackPtr cb);

                        asio::mutable_buffers_1 getBuffer();

                        NetAddress &getAddress();

                        asio::io_service &getIoService();
                        void start();
                        void join();
                        void run();

                        virtual NetAddress getLocalAddress() = 0;

                        bool isAsync() { return this->async; }

                        virtual void setAsync(bool value) = 0;

                        virtual void open() = 0;
                        virtual void open(const NetAddress &a) = 0;
                        virtual void bind() = 0;

                        virtual void reuseAddress(bool on) = 0;
                        virtual bool reuseAddress() = 0;

                        virtual void enableLoopback(bool on) = 0;
                        virtual bool enableLoopback() = 0;

                        virtual void enableBroadcast(bool on) = 0;
                        virtual bool enableBroadcast() = 0;

                        virtual void multicastHops(int hops) = 0;
                        virtual int multicastHops() = 0;

                        virtual void joinGroup(const asio::ip::address &address) = 0;
                        virtual void leaveGroup(const asio::ip::address &address) = 0;

                        virtual void accept() throw(NetException) = 0;
                        virtual void connect() throw(NetException) = 0;

                        virtual void close() throw(NetException) = 0;
                        virtual void close(const NetAddress &address) throw(NetException) = 0;
                        virtual bool isOpen() = 0;

                        virtual size_t receive(char *data, size_t length) = 0;
                        virtual size_t receive(char *data, size_t length, NetAddress &remote) = 0;

                        virtual void send(const char *data, size_t length) = 0;
                        virtual void send(const char *data, size_t length, const NetAddress &remote) = 0;
        };

} }

#endif /* CASTOR_NET_CHANNEL_H */