FountainMessage.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/FountainMessage.h,v 1.27 2006/03/05 22:05:16 samm Exp $ */
#ifndef FOUNTAIN_MESSAGE_H__
#define FOUNTAIN_MESSAGE_H__

//forward class declarations
class FountainParseMessage;
class NodeID;

#include "define.h"
#include "Enforce.h"
#include "LokiInclude.h"
#include <bamboo/BaseMsg.h>
#include <bamboo/XML.h>
#include <cstdlib>
#include <vector>
#include <string>
#include <sys/time.h>

//forward declaration
class FountainParseMessage;
class FountainMessage;

typedef Loki::SmartPtr<const FountainParseMessage> ConstParseMsgPtr;

typedef Loki::SmartPtr<FountainMessage> FountainMessagePtr;

typedef Loki::SmartPtr<BambooLib::XMLElementList, Loki::RefCounted, Loki::DisallowConversion, Loki::RejectNullStrict> XMLElementListPtr;

class FountainMessage : public BambooLib::BuildMsg {
    public:
                enum MessageAction {
                        invalidAction=0,
                        join,
                        newParent,
                        syncMsg,
                        pulse,
                        admin,
                        pingPong,
                        trace,
                        bomb,
                        joinAsServer,
                        Query,
                        lostParent,
                        lostChild,
                        wakeup,
                        Number_Message_Actions
                };
        
        virtual ~FountainMessage() = 0;

        void buildStandardError(bool status=true, FountainErrorCode code=generalSuccess, const char* msg=NULL);
                
                void buildStandardError(bool status, FountainErrorCode code, const std::string& msg) { buildStandardError(status, code, msg.c_str()); };
                
                void buildStandardSuccess(const std::string& msg = std::string()) { return buildStandardError(true, generalSuccess, msg); }

                BambooLib::XMLElement* getDataElement() const { return dataElement; }
                
                static const char* fountain_convert(FountainMessage::MessageAction m);
                
                static bool fountain_convert(const char* s, FountainMessage::MessageAction& a);
                
    protected:
                FountainMessage(Loki::Int2Type<BambooLib::requestElement>, MessageAction a) : BambooLib::BuildMsg(sss_convert(BambooLib::envelopeElement)), action_(a) { create(BambooLib::requestElement); }
                
                FountainMessage(Loki::Int2Type<BambooLib::responseElement>, MessageAction a) : BambooLib::BuildMsg(sss_convert(BambooLib::envelopeElement)), action_(a) { create(BambooLib::responseElement); }
                
        MessageAction action_;
        
    private:
                void create(BambooLib::SSS_Element_type type);
                
                FountainMessage(const FountainMessage& rhs);
                
        const FountainMessage& operator=(const FountainMessage& rhs);
};

class FountainParseMessage {
        private:
                typedef Loki::SmartPtr<const BambooLib::ParseMsg, Loki::NoCopy, Loki::AllowConversion, Loki::RejectNullStrict> BambooParseMsg;
                
                BambooParseMsg msg_;
        
        public:
                FountainParseMessage(const BambooLib::ParseMsg* msg) : msg_(msg) {}
        
                ~FountainParseMessage() {}
                
                //operator BambooParseMsg::PointerType() const { return msg_; }
                
                BambooParseMsg::PointerType getParseMsg() const { return msg_; }
        
                FountainMessage::MessageAction getAction() const;
        
                bool getStatus() const { return msg_->getStatus(); }
                
                BambooLib::SSS_Element_type getMessageType() const { return msg_->getMessageType(); }
                
                BambooLib::XMLElement* getRoot() const { return msg_->getRoot(); }
                
                const char* getActor() const { return msg_->getActor(); }
                
                BambooLib::XMLElement* getDataElement() const { return msg_->getDataElement(); }
                
                const char* getDataElementValue(const char* value) const { return msg_->getDataElementValue(value); }
                
                const char* getResponseMessage() const { return msg_->getResponseMessage(); }
                
                const char* getSource() const;
                
                const char* getDestination() const;
                
                FountainErrorCode getErrorCode() const;
                
                friend std::ostream& operator<<(std::ostream& output, const FountainParseMessage& rhs);
                
        private:
                FountainParseMessage(const FountainParseMessage& rhs);
                
                FountainParseMessage& operator=(const FountainParseMessage& rhs);
};


#endif

---