FountainWireProt.h

Go to the documentation of this file.

/* ex: set tabstop=4 expandtab: */
/*                                                                                                                      */
/*  (c) 2004-2006 Iowa State University                                         */
/*      see the LICENSE file in the top level directory         */
/*                                                                                                                      */
/* $Header: /afs/scl/project/cvsroot/fountain/source/common/FountainWireProt.h,v 1.32 2006/03/05 22:05:16 samm Exp $ */
#ifndef FOUNTAIN_WIRE_PROT_H__
#define FOUNTAIN_WIRE_PROT_H__

class NodeID;

#include "define.h"
#include "FountainMessage.h"
#include "Enforce.h"
#include "LokiInclude.h"
#include <bamboo/WireProt.h>
#include <bamboo/SSSXML.h>
#include <bamboo/qLog.h>
#include <cstddef> //for NULL
#include <vector>
#include <sstream> //for stringstream

struct SSSWireProtConnectionPolicy {
    typedef Loki::SmartPtr<BambooLib::SSSWireProt, Loki::NoCopy, Loki::DisallowConversion, Loki::NoCheck> type;
        typedef BambooLib::BuildMsg* SendType;
        typedef const BambooLib::ParseMsg* ReceiveType;
};

struct FountainMessagePtrSendPolicy {
    typedef FountainMessagePtr type;
};

struct ConstParseMsgPtrReceivePolicy {
    typedef ConstParseMsgPtr type;
};

template <class ConnectionPolicy>
class LookupHostname {
    public:
        LookupHostname() : hostname_() {}
        void lookup(typename ConnectionPolicy::type &connection);
        std::string getHostname() const { return hostname_; }
    protected:
        ~LookupHostname() {}
        
    private:
        std::string hostname_;

};

template <class ConnectionPolicy>
class NoLookupHostname {
    public:
        void lookup(typename ConnectionPolicy::type&) { }

    protected:
        ~NoLookupHostname() {}
};

template <
    class ConnectionPolicy = SSSWireProtConnectionPolicy,
    class SendPolicy = FountainMessagePtrSendPolicy,
    class ReceivePolicy = ConstParseMsgPtrReceivePolicy,
    template <class> class HostnamePolicy = LookupHostname
>
class FountainWireProtImpl : public HostnamePolicy<ConnectionPolicy> {
    private:
        //these typedefs are somewhat of a juxtaposition, a typedef typename... =D
        typedef typename ConnectionPolicy::type CT;
        
        typedef typename SendPolicy::type ST;
        
        typedef typename ReceivePolicy::type RT;
        
        typedef HostnamePolicy<ConnectionPolicy> HP;
    
    public:
        bool CheckForData(int sleepTime=0) {
            return connection_->CheckForData(sleepTime);
        }
        
        int sendMessage(ST msg) {
            return connection_->sendMessage(GetImpl(msg));
        }
        
        RT recvMessage() {
                        typename ConnectionPolicy::ReceiveType msg = connection_->recvMessage();
            if (!msg) {
                return NULL;
            } else {
                                return new FountainParseMessage(msg);
            }
        }
    
        int forwardMessage(RT msg) {
                        return connection_->forwardMessage(msg->getParseMsg());
        }
        
    protected:
                FountainWireProtImpl(typename CT::PointerType connection) : connection_(connection) {}
        
        ~FountainWireProtImpl() {}
                
        void lookupHostname() { HP::lookup(connection_); }
        
        CT connection_;
};

//forward declaration
class FountainWireProt;

typedef Loki::SmartPtr<FountainWireProt, Loki::RefCounted, Loki::DisallowConversion, Loki::RejectNull> FountainWireProtPtr;

class FountainWireProt : public FountainWireProtImpl<SSSWireProtConnectionPolicy> {
    public:
        static FountainWireProtPtr Connect(BambooLib::SSS_Protocols protocol, const NodeID& remoteNode);
        
                FountainWireProt(SSSWireProtConnectionPolicy::type::PointerType connection) : FountainWireProtImpl<SSSWireProtConnectionPolicy>(connection) {
            lookupHostname();
        }
                
        ~FountainWireProt();
        
    private:
                FountainWireProt(BambooLib::SSS_Protocols protocol) : FountainWireProtImpl<SSSWireProtConnectionPolicy>(BambooLib::SSSWireProt::CreateNewConnection(protocol)) {}
                
        FountainWireProt(const FountainWireProt& rhs);
                
        FountainWireProt& operator=(const FountainWireProt& rhs);
};

#endif

---