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        */
/*                                                             */
/* $Id: FountainWireProt.h 290 2006-04-18 22:03:15Z samm $ */
#ifndef FOUNTAIN_WIRE_PROT_H_
#define FOUNTAIN_WIRE_PROT_H_

//forward declarataion
class NodeID;

#include "define.h"
#include "FountainMessage.h"
#include "Enforce.h"
#include "Asserter.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:
        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) {
            ASSERT(GetImpl(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) {
            //we'll rely on the implicit conversion from the underlying pointee type to whatever
            //the BambooLib::SSSWireProt::forwardMessage accepts as a parameter
            //I am not sure if there's a way to get this implicit conversion without using the indirection operator...
            return connection_->forwardMessage(*GetImpl(msg));
        }
        
    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();
        }
        
        SSSWireProtConnectionPolicy::type::PointerType getConnection() { return Loki::GetImpl(connection_); }
        
        ~FountainWireProt();
        
    private:
        FountainWireProt(BambooLib::SSS_Protocols protocol) : FountainWireProtImpl<SSSWireProtConnectionPolicy>(BambooLib::SSSWireProt::CreateNewConnection(protocol)) {}
        
        FountainWireProt(const FountainWireProt& rhs);
        
        FountainWireProt& operator=(const FountainWireProt& rhs);
};

#endif

---