MessageManager Class Reference

#include <MessageManager.h>

Inheritance diagram for MessageManager:

Collaboration diagram for MessageManager:

Public Member Functions
void	AddGetModuleParamsNode (const char *module_,...)
void	AddGetPathParamsNode (const char *lib_, const char *path_,...)
void	AddMarksNode (int brick_, int plate_, const char *mapext_)
void	AddSetModuleParamsNode (const char *module_,...)
void	AddSetPathParamsNode (const char *lib_, const char *path_,...)
void	AddStartNode (const char *lib_, const char *path_, const char *comment_)
void	AddStopNode ()
void	Clean ()
void	CreateMessage ()
void	FillBuff ()
void	FillBuffOuter (uint8 *buf_, uint32 size_)
uint8 *	GetBuf ()
uint32	GetBufSize ()
	MessageManager ()

Private Attributes
std::vector< uint8 >	m_messBuf
uint32	m_messId
std::string	m_xml
TiXmlDocument	m_xmlDoc
TiXmlElement *	m_xmlDocAddPtr
Private Attributes inherited from PAVProtocol
uint32	m_headerSize

Additional Inherited Members
Private Member Functions inherited from PAVProtocol
uint32	Crc32 (uint32 len_, const uint8 *buf_)
	PAVProtocol ()
virtual bool	ReadMessage (uint8 *buf_, uint32 size_, std::vector< uint8 > &dstbuf_)
virtual bool	ReadMessageRaw (uint8 *buf_, uint32 size_, std::vector< uint8 > &dstbuf_)
virtual bool	WriteMessage (std::vector< uint8 > &buf_, const void *srcbuf_, uint32 srcsize_)
virtual bool	WriteMessageRaw (std::vector< uint8 > &buf_, const void *srcbuf_, uint32 srcsize_)
virtual	~PAVProtocol ()

Constructor & Destructor Documentation

MessageManager()

MessageManager::MessageManager ( )

inline

                    :m_messId(0), m_xmlDoc("mess")
    {};

Member Function Documentation

AddGetModuleParamsNode()

void MessageManager::AddGetModuleParamsNode	(	const char *	module_,
			...
	)

                                                                   {//ToDo: unix-compatible?
    TiXmlElement gmp(PAVPROT_NODE_GMP);
    gmp.SetAttribute("module", module_);
 
    char* var;
    va_list args;
    va_start(args, module_);
    while((var = va_arg(args, char *)) != NULL){
        TiXmlElement vare(var);
        gmp.InsertEndChild(vare);
    }
    va_end(args);
 
    m_xmlDocAddPtr->InsertEndChild(gmp);
};

AddGetPathParamsNode()

void MessageManager::AddGetPathParamsNode	(	const char *	lib_,
		const char *	path_,
			...
	)

                                                                                 {//ToDo: unix-compatible?
    TiXmlElement gpp(PAVPROT_NODE_GPP);
    gpp.SetAttribute("lib", lib_);
    gpp.SetAttribute("path", path_);
 
    char* var;
    va_list args;
    va_start(args, path_);
    var = va_arg(args, char *);
    while(var){
        TiXmlElement vare(var);
        gpp.InsertEndChild(vare);
        var = va_arg(args, char *);
    }
    va_end(args);
 
    m_xmlDocAddPtr->InsertEndChild(gpp);
};

AddMarksNode()

void MessageManager::AddMarksNode	(	int	brick_,
		int	plate_,
		const char *	mapext_
	)

                                                                            {
    TiXmlElement marks(PAVPROT_NODE_MARKS);
    marks.SetAttribute("brick", brick_);
    marks.SetAttribute("plate", plate_);
    marks.SetAttribute("mapext", mapext_);
    m_xmlDocAddPtr->InsertEndChild(marks);
};

AddSetModuleParamsNode()

void MessageManager::AddSetModuleParamsNode	(	const char *	module_,
			...
	)

                                                                   {//ToDo: unix-compatible?
    TiXmlElement smp(PAVPROT_NODE_SMP);
    smp.SetAttribute("module", module_);
 
    char* var, *val;
    va_list args;
    va_start(args, module_);
    while((var = va_arg(args, char *)) != NULL){
        val = va_arg(args, char *);
        if(val != NULL){
            TiXmlElement vare(var);
            vare.SetAttribute("val", val);
            smp.InsertEndChild(vare);
        }else{
            printf("Value is not provided for parameter <%s> in module <%s>\n", var, module_);
            break;
        };
    }
    va_end(args);
 
    m_xmlDocAddPtr->InsertEndChild(smp);
};

AddSetPathParamsNode()

void MessageManager::AddSetPathParamsNode	(	const char *	lib_,
		const char *	path_,
			...
	)

                                                                                 {//ToDo: unix-compatible?
    TiXmlElement spp(PAVPROT_NODE_SPP);
    spp.SetAttribute("lib", lib_);
    spp.SetAttribute("path", path_);
 
    char* var, *val;
    va_list args;
    va_start(args, path_);
    while((var = va_arg(args, char *)) != NULL){
        val = va_arg(args, char *);
        if(val != NULL){
            TiXmlElement vare(var);
            vare.SetAttribute("val", val);
            spp.InsertEndChild(vare);
        }else{
            printf("Value is not provided for parameter <%s> in lib <%s>, path <%s>\n", var, lib_, path_);
            break;
        };
    }
    va_end(args);
 
    m_xmlDocAddPtr->InsertEndChild(spp);
};

AddStartNode()

void MessageManager::AddStartNode	(	const char *	lib_,
		const char *	path_,
		const char *	comment_
	)

                                                                                          {
    TiXmlElement start(PAVPROT_NODE_START);
    start.SetAttribute("lib", lib_);
    start.SetAttribute("path", path_);
    TiXmlText comment(comment_);
    start.InsertEndChild(comment);
    m_xmlDocAddPtr->InsertEndChild(start);
};

AddStopNode()

void MessageManager::AddStopNode

(

)

                                {
    TiXmlElement stop(PAVPROT_NODE_STOP);
    m_xmlDocAddPtr->InsertEndChild(stop);
};

Clean()

void MessageManager::Clean

(

)

                          {
    m_messId++;
    m_xml = "";
    m_xmlDoc.Clear();
};

CreateMessage()

void MessageManager::CreateMessage

(

)

                                  {
    Clean();
    TiXmlElement main(PAVPROT_NODE_ROOT);
    TiXmlElement mess(PAVPROT_NODE_MESS);
    main.SetAttribute("version", PAVCLIENTVERSION);
    mess.SetAttribute("id", m_messId);
    m_xmlDocAddPtr = m_xmlDoc.InsertEndChild(main)->ToElement();
    m_xmlDocAddPtr->InsertEndChild(mess);
};

FillBuff()

void MessageManager::FillBuff

(

)

                             {
    TiXmlPrinter printer;
    m_xmlDoc.Accept( &printer );
    printf("%s\n", printer.CStr());//ToDo: verbisity
    std::string str;
    str << m_xmlDoc;
    WriteMessage(m_messBuf, str.c_str(), str.length());
};

FillBuffOuter()

void MessageManager::FillBuffOuter ( uint8 *  buf_, uint32  size_  )

inline

                                                 {
        printf("%s\n", buf_);//ToDo: verbisity
        WriteMessage(m_messBuf, buf_, size_);
    };

GetBuf()

uint8* MessageManager::GetBuf ( )

inline

{return &m_messBuf[0];};

GetBufSize()

uint32 MessageManager::GetBufSize ( )

inline

{return m_messBuf.size();};

Member Data Documentation

m_messBuf

std::vector<uint8> MessageManager::m_messBuf

private

m_messId

uint32 MessageManager::m_messId

private

m_xml

std::string MessageManager::m_xml

private

m_xmlDoc

TiXmlDocument MessageManager::m_xmlDoc

private

m_xmlDocAddPtr

TiXmlElement* MessageManager::m_xmlDocAddPtr

private

---

The documentation for this class was generated from the following files:

• src/libScan/MessageManager.h
• src/libScan/MessageManager.cpp