Parser of Field. More...

#include <FieldParser.h>

Collaboration diagram for FieldParser:

Public Member Functions
template<typename T>
bool	addParseFieldArray (T *tabPtr, size_t nbElement, const FieldConfig &field)
	Add a sub FieldParser for a Array type.

template<typename T>
bool	addParseFieldArray (T *tabPtr, size_t nbElement, const FieldConfig &field, const PString &childName)
	Add a sub FieldParser for a Array type.

template<typename T>
void	addParseFieldArray (T *tabPtr, size_t nbElement, size_t fieldId, const PString &fieldName="")
	Add a sub FieldParser for a Array type.

bool	addParseFieldEnum (size_t *varPtr, const FieldConfig &field)
	Add a sub FieldParser for a enum type.

bool	addParseFieldEnum (size_t *varPtr, const FieldConfig &field, const PString &childName)
	Add a sub FieldParser for a enum type.

void	addParseFieldEnum (size_t *varPtr, size_t fieldId, const PString &fieldName="")
	Add a sub FieldParser for a enum type.

template<typename T>
bool	addParseFieldValue (T *varPtr, const FieldConfig &field)
	Add a sub FieldParser for a Array type.

template<typename T>
bool	addParseFieldValue (T *varPtr, const FieldConfig &field, const PString &childName)
	Add a sub FieldParser for a enum type.

template<typename T>
void	addParseFieldValue (T *varPtr, size_t fieldId, const PString &fieldName="")
	Add a sub FieldParser for a scalar type.

FieldParser *	addSubMessage (const FieldConfig &field)
	Add a sub message into the FieldParser.

FieldParser *	addSubMessage (const FieldConfig &field, const PString &childName)
	Add a sub message into the FieldParser.

FieldParser *	addSubMessage (FieldConfig &childConfig, const FieldConfig &field, const PString &childName)
	Add a sub message into the FieldParser.

FieldParser *	addSubMessage (size_t fieldId, const PString &fieldName="")
	Add a sub message into the FieldParser.

void	clear ()
	Clear all the children of the FieldParser.

	FieldParser ()
	Default constructor of FieldParser.

bool	load (const char *message, size_t nbByte, std::ostream &out=std::cerr)
	Load the Fields of the FieldParser (without offset on the first time and with offsets after)

bool	load (const std::vector< char > &message, std::ostream &out=std::cerr)
	Load the Fields of the FieldParser (without offset on the first time and with offsets after)

void	print (std::ostream &out=std::cout, const PString &indentation="") const
	Print the FieldParser.

void	resetOffset ()
	Reset the offset of the FieldParser.

virtual	~FieldParser ()
	Destructor of FieldParser.

Private Member Functions
template<typename T>
bool	checkInputType (const FieldConfig &field)
	Check the template type with the FieldConfig.

bool	checkInputType (FieldType::FieldType type, const FieldConfig &field)
	Check if the type is compatible with the type in the FieldConfig.

void	createMapFieldParser (MapFieldParser &mapFieldParser)
	Create the map of Field parser.

FieldParser *	createSubFieldParser (size_t fieldId, const PString &fieldName)
	Add a sub FieldParser.

void	initialisationFieldParser ()
	Initialisation function of the class FieldParser.

bool	loadComputeFieldOffset (char &iter, const char endMessage, const char *message, size_t fieldId, size_t fieldType, std::ostream &out)
	Compute FIeld offset.

bool	loadComputeFieldOffsetArray (char &iter, const char endMessage, const char *message, std::ostream &out)
	Compute FIeld offset of an array.

bool	loadComputeOffset (char &iter, const char endMessage, const char *message, std::ostream &out)
	Load the Fields and compute the offset.

bool	loadFieldFromOffset (char *&iter)
	Load the Field directly from the offset.

bool	loadFromOffset (char *&iter)
	Load the Fields directly from the offset.

void	setBaseField (size_t fieldId, const PString &fieldName)
	Set the basis of a Field to be parsed.

Private Attributes
AbtractField	p_field
	Field to be parsed.

VecFieldParser	p_vecChildren
	Children used to parse other field and sub messages.

Detailed Description

Parser of Field.

Definition at line 19 of file FieldParser.h.

Constructor & Destructor Documentation

◆ FieldParser()

FieldParser::FieldParser ( )

Default constructor of FieldParser.

Definition at line 15 of file FieldParser.cpp.

                        {
        initialisationFieldParser();
}

References initialisationFieldParser().

Referenced by addParseFieldArray(), addParseFieldEnum(), addParseFieldValue(), addSubMessage(), addSubMessage(), addSubMessage(), addSubMessage(), and createSubFieldParser().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ~FieldParser()

FieldParser::~FieldParser ( )

virtual

Destructor of FieldParser.

Definition at line 20 of file FieldParser.cpp.

                         {
        clear();
}

References clear().

Here is the call graph for this function:

Member Function Documentation

◆ addParseFieldArray() [1/3]

template<typename T>

bool FieldParser::addParseFieldArray	(	T **	tabPtr,
		size_t *	nbElement,
		const FieldConfig &	field )

Add a sub FieldParser for a Array type.

Parameters

tabPtr	: pointer to the table to be updated on the parsing of the protocol buffer message
nbElement	: pointer to the variable which will contain the number of element of the parsed array
field	: description of the field to be used

Returns: true on success, false otherwise

Definition at line 87 of file FieldParser_impl.h.

                                                                                             {
        if(!checkInputType<T>(field) || !field.getIsArray()){std::cerr << "FieldParser::addParseFieldArray : Field '"<<field.getName()<<"' is not defined as an array of the proper type" << std::endl;return false;} //If the field is not an array we quit
        addParseFieldArray(tabPtr, nbElement, field.getId(), field.getName());
        return true;
}

References addParseFieldArray(), checkInputType(), FieldConfig::getId(), FieldConfig::getIsArray(), and FieldConfig::getName().

Here is the call graph for this function:

◆ addParseFieldArray() [2/3]

template<typename T>

bool FieldParser::addParseFieldArray	(	T **	tabPtr,
		size_t *	nbElement,
		const FieldConfig &	field,
		const PString &	childName )

Add a sub FieldParser for a Array type.

Parameters

tabPtr	: pointer to the table to be updated on the parsing of the protocol buffer message
nbElement	: pointer to the variable which will contain the number of element of the parsed array
field	: description of the field to be used
childName	: name of the child of the field to be used as description

Returns: true on success, false otherwise

Definition at line 101 of file FieldParser_impl.h.

                                                                                                                        {
        const std::map<PString, FieldConfig> & mapChildren = field.getVecChildren();
        std::map<PString, FieldConfig>::const_iterator itFind = mapChildren.find(childName);
        if(itFind != mapChildren.end()){
                return addParseFieldArray(tabPtr, nbElement, itFind->second);
        }else{
                std::cerr << "FieldParser::addParseFieldArray : FieldConfig has no child named '"<<childName<<"'" << std::endl;
                return false;
        }
}

References addParseFieldArray(), and FieldConfig::getVecChildren().

Here is the call graph for this function:

◆ addParseFieldArray() [3/3]

template<typename T>

void FieldParser::addParseFieldArray	(	T **	tabPtr,
		size_t *	nbElement,
		size_t	fieldId,
		const PString &	fieldName = "" )

Add a sub FieldParser for a Array type.

Parameters

tabPtr	: pointer to the table to be updated on the parsing of the protocol buffer message
nbElement	: pointer to the variable which will contain the number of element of the parsed array
fieldId	: id of the field that contain the sub message
fieldName	: name of the field

Definition at line 37 of file FieldParser_impl.h.

                                                                                                             {
        FieldParser* parser = createSubFieldParser(fieldId, fieldName);
        parser->p_field.setType(phoenix_fieldType<T>());
        parser->p_field.setNbElement(NULL);
        parser->p_field.setTypeSize(sizeof(T));
        parser->p_field.setArrayPtr((void**)tabPtr);
        parser->p_field.setNbElement(nbElement);
        parser->p_field.setIsArray(true);
        parser->p_field.setOffset(0lu);
        parser->p_field.setIsOffsetReady(false);
        p_vecChildren.push_back(parser);
}

References createSubFieldParser(), FieldParser(), p_field, p_vecChildren, phoenix_fieldType(), AbtractField::setArrayPtr(), AbtractField::setIsArray(), AbtractField::setIsOffsetReady(), AbtractField::setNbElement(), AbtractField::setOffset(), AbtractField::setType(), and AbtractField::setTypeSize().

Referenced by addParseFieldArray(), and addParseFieldArray().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addParseFieldEnum() [1/3]

bool FieldParser::addParseFieldEnum	(	size_t *	varPtr,
		const FieldConfig &	field )

Add a sub FieldParser for a enum type.

Parameters

varPtr	: pointer to the variable to be updated on the parsing of the protocol buffer message
field	: FieldConfig which describes the field

Returns: pointer to the parser which will be used to parse the sub message

Definition at line 102 of file FieldParser.cpp.

                                                                            {
        if(!checkInputType(FieldType::ENUM_TYPE, field)){return false;}
        addParseFieldEnum(varPtr, field.getId(), field.getName());
        return true;
}

References addParseFieldEnum(), checkInputType(), FieldType::ENUM_TYPE, FieldConfig::getId(), and FieldConfig::getName().

Here is the call graph for this function:

◆ addParseFieldEnum() [2/3]

bool FieldParser::addParseFieldEnum	(	size_t *	varPtr,
		const FieldConfig &	field,
		const PString &	childName )

Add a sub FieldParser for a enum type.

Parameters

varPtr	: pointer to the variable to be updated on the parsing of the protocol buffer message
field	: FieldConfig which describes the field
childName	: name of the child of the field to be used as description

Returns: pointer to the parser which will be used to parse the sub message

Definition at line 114 of file FieldParser.cpp.

                                                                                                       {
        const std::map<PString, FieldConfig> & mapChildren = field.getVecChildren();
        std::map<PString, FieldConfig>::const_iterator itFind = mapChildren.find(childName);
        if(itFind != mapChildren.end()){
                return addParseFieldEnum(varPtr, itFind->second);
        }else{
                std::cerr << "FieldParser::addParseFieldEnum : FieldConfig has no child named '"<<childName<<"'" << std::endl;
                return false;
        }
}

References addParseFieldEnum(), and FieldConfig::getVecChildren().

Here is the call graph for this function:

◆ addParseFieldEnum() [3/3]

void FieldParser::addParseFieldEnum	(	size_t *	varPtr,
		size_t	fieldId,
		const PString &	fieldName = "" )

Add a sub FieldParser for a enum type.

Parameters

varPtr	: pointer to the variable to be updated on the parsing of the protocol buffer message
fieldId	: id of the field that contain the sub message
fieldName	: name of the field

Returns: pointer to the parser which will be used to parse the sub message

Definition at line 85 of file FieldParser.cpp.

                                                                                            {
        FieldParser* parser = createSubFieldParser(fieldId, fieldName);
        parser->p_field.setType(FieldType::ENUM_TYPE);
        parser->p_field.setNbElement(0lu);
        parser->p_field.setTypeSize(sizeof(size_t));
        parser->p_field.setVarPtr(varPtr);
        parser->p_field.setIsArray(false);
        parser->p_field.setOffset(0lu);
        parser->p_field.setIsOffsetReady(false);
        p_vecChildren.push_back(parser);
}

References createSubFieldParser(), FieldType::ENUM_TYPE, FieldParser(), p_field, p_vecChildren, AbtractField::setIsArray(), AbtractField::setIsOffsetReady(), AbtractField::setNbElement(), AbtractField::setOffset(), AbtractField::setType(), AbtractField::setTypeSize(), and AbtractField::setVarPtr().

Referenced by addParseFieldEnum(), and addParseFieldEnum().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addParseFieldValue() [1/3]

template<typename T>

bool FieldParser::addParseFieldValue	(	T *	varPtr,
		const FieldConfig &	field )

Add a sub FieldParser for a Array type.

Parameters

varPtr	: pointer to the variable to be updated on the parsing of the protocol buffer message
field	: description of the field to be used

Returns: true on success, false otherwise

Definition at line 56 of file FieldParser_impl.h.

                                                                        {
        if(!checkInputType<T>(field)){return false;}
        addParseFieldValue(varPtr, field.getId(), field.getName());
        return true;
}

References addParseFieldValue(), checkInputType(), FieldConfig::getId(), and FieldConfig::getName().

Here is the call graph for this function:

◆ addParseFieldValue() [2/3]

template<typename T>

bool FieldParser::addParseFieldValue	(	T *	varPtr,
		const FieldConfig &	field,
		const PString &	childName )

Add a sub FieldParser for a enum type.

Parameters

varPtr	: pointer to the variable to be updated on the parsing of the protocol buffer message
field	: FieldConfig which describes the field
childName	: name of the child of the field to be used as description

Returns: pointer to the parser which will be used to parse the sub message

Definition at line 69 of file FieldParser_impl.h.

                                                                                                   {
        const std::map<PString, FieldConfig> & mapChildren = field.getVecChildren();
        std::map<PString, FieldConfig>::const_iterator itFind = mapChildren.find(childName);
        if(itFind != mapChildren.end()){
                return addParseFieldValue(varPtr, itFind->second);
        }else{
                std::cerr << "FieldParser::addParseFieldValue : FieldConfig has no child named '"<<childName<<"'" << std::endl;
                return false;
        }
}

References addParseFieldValue(), and FieldConfig::getVecChildren().

Here is the call graph for this function:

◆ addParseFieldValue() [3/3]

template<typename T>

void FieldParser::addParseFieldValue	(	T *	varPtr,
		size_t	fieldId,
		const PString &	fieldName = "" )

Add a sub FieldParser for a scalar type.

Parameters

varPtr	: pointer to the variable to be updated on the parsing of the protocol buffer message
fieldId	: id of the field that contain the sub message
fieldName	: name of the field

Definition at line 18 of file FieldParser_impl.h.

                                                                                        {
        FieldParser* parser = createSubFieldParser(fieldId, fieldName);
        parser->p_field.setType(phoenix_fieldType<T>());
        parser->p_field.setNbElement(NULL);
        parser->p_field.setTypeSize(sizeof(T));
        parser->p_field.setVarPtr(varPtr);
        parser->p_field.setIsArray(false);
        parser->p_field.setOffset(0lu);
        parser->p_field.setIsOffsetReady(false);
        p_vecChildren.push_back(parser);
}

References createSubFieldParser(), FieldParser(), p_field, p_vecChildren, phoenix_fieldType(), AbtractField::setIsArray(), AbtractField::setIsOffsetReady(), AbtractField::setNbElement(), AbtractField::setOffset(), AbtractField::setType(), AbtractField::setTypeSize(), and AbtractField::setVarPtr().

Referenced by addParseFieldValue(), and addParseFieldValue().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addSubMessage() [1/4]

FieldParser * FieldParser::addSubMessage ( const FieldConfig & field )

Add a sub message into the FieldParser.

Parameters

field : description of the field

Returns: pointer to the parser which will be used to parse the sub message, of NULL if the field is not coherent

Definition at line 40 of file FieldParser.cpp.

                                                                 {
        if(!checkInputType(FieldType::SUBMESSAGE, field)){return NULL;}
        return addSubMessage(field.getId(), field.getName());
}

References addSubMessage(), checkInputType(), FieldParser(), FieldConfig::getId(), FieldConfig::getName(), and FieldType::SUBMESSAGE.

Here is the call graph for this function:

◆ addSubMessage() [2/4]

FieldParser * FieldParser::addSubMessage	(	const FieldConfig &	field,
		const PString &	childName )

Add a sub message into the FieldParser.

Parameters

field	: main description of the field
childName	: name of the child of the field to be used as description

Returns: pointer to the parser which will be used to parse the sub message, of NULL if the field is not coherent

Definition at line 50 of file FieldParser.cpp.

                                                                                            {
        const std::map<PString, FieldConfig> & mapChildren = field.getVecChildren();
        std::map<PString, FieldConfig>::const_iterator itFind = mapChildren.find(childName);
        if(itFind != mapChildren.end()){
                return addSubMessage(itFind->second);
        }else{
                std::cerr << "FieldParser::addSubMessage : FieldConfig has no child named '"<<childName<<"'" << std::endl;
                return NULL;
        }
}

References addSubMessage(), FieldParser(), and FieldConfig::getVecChildren().

Here is the call graph for this function:

◆ addSubMessage() [3/4]

FieldParser * FieldParser::addSubMessage	(	FieldConfig &	childConfig,
		const FieldConfig &	field,
		const PString &	childName )

Add a sub message into the FieldParser.

Parameters

childConfig	: configuration of the child with name childName
field	: main description of the field
childName	: name of the child of the field to be used as description

Returns: pointer to the parser which will be used to parse the sub message, of NULL if the field is not coherent

Definition at line 67 of file FieldParser.cpp.

                                                                                                                       {
        const std::map<PString, FieldConfig> & mapChildren = field.getVecChildren();
        std::map<PString, FieldConfig>::const_iterator itFind = mapChildren.find(childName);
        if(itFind != mapChildren.end()){
                childConfig = itFind->second;
                return addSubMessage(itFind->second);
        }else{
                std::cerr << "FieldParser::addSubMessage : FieldConfig has no child named '"<<childName<<"'" << std::endl;
                return NULL;
        }
}

References addSubMessage(), FieldParser(), and FieldConfig::getVecChildren().

Here is the call graph for this function:

◆ addSubMessage() [4/4]

FieldParser * FieldParser::addSubMessage	(	size_t	fieldId,
		const PString &	fieldName = "" )

Add a sub message into the FieldParser.

Parameters

fieldId	: id of the field that contain the sub message
fieldName	: name of the field

Returns: pointer to the parser which will be used to parse the sub message

Definition at line 29 of file FieldParser.cpp.

                                                                                 {
        FieldParser* parser = createSubFieldParser(fieldId, fieldName);
        parser->p_field.setType(FieldType::SUBMESSAGE);
        p_vecChildren.push_back(parser);
        return parser;
}

References createSubFieldParser(), FieldParser(), p_field, p_vecChildren, AbtractField::setType(), and FieldType::SUBMESSAGE.

Referenced by addSubMessage(), addSubMessage(), and addSubMessage().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ checkInputType() [1/2]

template<typename T>

bool FieldParser::checkInputType ( const FieldConfig & field )

private

Check the template type with the FieldConfig.

Parameters

field : description of the field to be used

Returns: true on success, false otherwise

Definition at line 117 of file FieldParser_impl.h.

                                                         {
        FieldType::FieldType type(phoenix_fieldType<T>());
        return checkInputType(type, field);
}

References checkInputType(), and phoenix_fieldType().

Referenced by addParseFieldArray(), addParseFieldEnum(), addParseFieldValue(), addSubMessage(), and checkInputType().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ checkInputType() [2/2]

bool FieldParser::checkInputType	(	FieldType::FieldType	type,
		const FieldConfig &	field )

private

Check if the type is compatible with the type in the FieldConfig.

Parameters

type	: type to be checked
field	: configuration to be used

Returns: true if the type is compatible with the field, false otherwise

Definition at line 241 of file FieldParser.cpp.

                                                                                  {
        if(type != field.getType()){
                std::cerr << "checkInputType : cannot add field '"<<field.getName()<<"' wrong type " << phoenix_fieldTypeToStr(type) << " of variables, expected type " << phoenix_fieldTypeToStr(field.getType()) << std::endl;
                return false;
        }
        return true;
}

References FieldConfig::getName(), FieldConfig::getType(), and phoenix_fieldTypeToStr().

Here is the call graph for this function:

◆ clear()

void FieldParser::clear ( )

Clear all the children of the FieldParser.

Definition at line 160 of file FieldParser.cpp.

                       {
        for(VecFieldParser::iterator it(p_vecChildren.begin()); it != p_vecChildren.end(); ++it){
                delete (*it);
        }
        p_vecChildren.clear();
}

References p_vecChildren.

Referenced by ~FieldParser().

Here is the caller graph for this function:

◆ createMapFieldParser()

void FieldParser::createMapFieldParser ( MapFieldParser & mapFieldParser )

private

Create the map of Field parser.

Parameters

[out] mapFieldParser : Map of FieldParser to be created

Definition at line 360 of file FieldParser.cpp.

                                                                     {
        for(VecFieldParser::iterator it(p_vecChildren.begin()); it != p_vecChildren.end(); ++it){
                mapFieldParser[(*it)->p_field.getId()] = (*it);
        }
}

References p_vecChildren.

Referenced by loadComputeOffset().

Here is the caller graph for this function:

◆ createSubFieldParser()

FieldParser * FieldParser::createSubFieldParser	(	size_t	fieldId,
		const PString &	fieldName )

private

Add a sub FieldParser.

Parameters

fieldId	: id of the field that contain the sub message
fieldName	: name of the field

Returns: pointer to the parser which will be used to parse sub Fields

Definition at line 221 of file FieldParser.cpp.

                                                                                        {
        FieldParser* parser = new FieldParser;
        parser->setBaseField(fieldId, fieldName);
        return parser;
}

References FieldParser(), and setBaseField().

Referenced by addParseFieldArray(), addParseFieldEnum(), addParseFieldValue(), and addSubMessage().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ initialisationFieldParser()

void FieldParser::initialisationFieldParser ( )

private

Initialisation function of the class FieldParser.

Definition at line 212 of file FieldParser.cpp.

                                           {
        
}

Referenced by FieldParser().

Here is the caller graph for this function:

◆ load() [1/2]

bool FieldParser::load	(	const char *	message,
		size_t	nbByte,
		std::ostream &	out = std::cerr )

Load the Fields of the FieldParser (without offset on the first time and with offsets after)

Parameters

message	: message to be parsed
nbByte	: number of bytes of the message
out	: output stream to be used

Returns: true on success, false otherwise

Definition at line 140 of file FieldParser.cpp.

                                                                           {
        char* iter = (char*)message;
        const char* endMessage = message + nbByte;
        if(!p_field.getIsOffsetReady()){ //If we do not have the offsets, we commute them
                return loadComputeOffset(iter, endMessage, message, out);
        }else{                                  //If we have the offset, we use them directly
                return loadFromOffset(iter);
        }
}

References loadComputeOffset(), loadFromOffset(), and p_field.

Here is the call graph for this function:

◆ load() [2/2]

bool FieldParser::load	(	const std::vector< char > &	message,
		std::ostream &	out = std::cerr )

Load the Fields of the FieldParser (without offset on the first time and with offsets after)

Parameters

message	: message to be parsed
out	: output stream to be used

Returns: true on success, false otherwise

Definition at line 130 of file FieldParser.cpp.

                                                                       {
        return load(message.data(), message.size(), out);
}

References load().

Referenced by load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ loadComputeFieldOffset()

bool FieldParser::loadComputeFieldOffset	(	char *&	iter,
		const char *	endMessage,
		const char *	message,
		size_t	fieldId,
		size_t	fieldType,
		std::ostream &	out )

private

Compute FIeld offset.

Parameters

[out]	iter	: iterator on the message to be used
	endMessage	: end of the message
	message	: message to be read
	fieldId	: id of the current field
	fieldType	: type of the current field
	out	: ostream to be used

Returns: true on success, false otherwise

Definition at line 302 of file FieldParser.cpp.

                                                                                                                                                      {
        bool b(false);
        switch(fieldType){
                case 0lu:               //This is an enum, and its value is in a varint
                        p_field.setOffset((const char*)iter - message);
                        *((size_t*)p_field.getVarPtr()) = phoenix_readVarInt(iter);
                        b = true;
                        break;
                case 1lu:               //This is a uint64_t
                case 5lu:               //This is a uint32_t
                        p_field.setOffset((const char*)iter - message);
                        memcpy(p_field.getVarPtr(), iter, p_field.getTypeSize());
                        iter += p_field.getTypeSize();
                        b = true;
                        break;
                case 2lu:               //This is a binary array, which starts by a varint
                        //It can be a sub message
                        b = loadComputeFieldOffsetArray(iter, endMessage, message, out);
                        break;
                default:
                        b = false;
                        out << "FieldParser::loadComputeFieldOffset : unknown type of Field " << fieldId << std::endl;
                        break;
        }
        p_field.setIsOffsetReady(b);
        return b;
}

References loadComputeFieldOffsetArray(), p_field, and phoenix_readVarInt().

Here is the call graph for this function:

◆ loadComputeFieldOffsetArray()

bool FieldParser::loadComputeFieldOffsetArray	(	char *&	iter,
		const char *	endMessage,
		const char *	message,
		std::ostream &	out )

private

Compute FIeld offset of an array.

Parameters

[out]	iter	: iterator on the message to be used
	endMessage	: end of the message
	message	: message to be read
	out	: ostream to be used

Returns: true on success, false otherwise

Definition at line 337 of file FieldParser.cpp.

                                                                                                                         {
        size_t nbByte = phoenix_readVarInt(iter);
        if(nbByte == 0lu){return true;} //Whatever it is, this it empty
        bool b(true);
        if(p_field.getType() == FieldType::SUBMESSAGE){     //If this is a sub message, we parse it
                //We have to load the sub message
                b &= loadComputeOffset(iter, iter + nbByte, message, out);
                if(!b){
                        out << "FieldParser::loadComputeFieldOffsetArray : cannot parse submessage at offset " << ((const char*)iter - message) << std::endl;
                }
        }else{  //If it is not a sub message, we skip it
                *p_field.getNbElement() = nbByte/p_field.getTypeSize();   //Let's compute the number of element in the array
                p_field.setOffset((const char*)iter - message);
                *p_field.getArrayPtr() = (void*)iter;
                iter += nbByte;
                p_field.setIsOffsetReady(true);
        }
        return b;
}

References loadComputeOffset(), p_field, phoenix_readVarInt(), and FieldType::SUBMESSAGE.

Referenced by loadComputeFieldOffset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ loadComputeOffset()

bool FieldParser::loadComputeOffset	(	char *&	iter,
		const char *	endMessage,
		const char *	message,
		std::ostream &	out )

private

Load the Fields and compute the offset.

Parameters

[out]	iter	: iterator over the message to be parsed
	endMessage	: address of the end of the message
	message	: message to be read
	out	: ostream to be used

Returns: true on success, false otherwise

Definition at line 256 of file FieldParser.cpp.

                                                                                                               {
        //We have to read the message from begining to end and each time we find a Field, we have to check if we want to read this particular field
        MapFieldParser mapFieldParser;
        createMapFieldParser(mapFieldParser);
        
        //Then, we have to call the parseField to get the type and id of the current field
        do{
                size_t fieldId(0lu), fieldType(0lu);
                phoenix_field(fieldId, fieldType, iter);
                MapFieldParser::iterator itFind = mapFieldParser.find(fieldId);
                if(itFind != mapFieldParser.end()){     //The field has to be read
                        if((*itFind).second->loadComputeFieldOffset(iter, endMessage, message, fieldId, fieldType, out)){       
                                mapFieldParser.erase(itFind);   //The parsing it OK, so we can remove the FieldParser from the mapFieldParser
                        }else{  //Error when parsing the field
                                out << "FieldParser::loadComputeOffset : error when parsing field " << fieldId << " of type " << phoenix_fieldTypeToStr(phoenix_pbTypeToFieldType(fieldType)) << std::endl;
                                return false;
                        }
                }else{          //The field has to be skipped
                        if(iter < endMessage){
                                phoenix_fieldSkip(iter, fieldType);
                        }
                }
        }while(iter < endMessage && mapFieldParser.size() != 0lu);
        
        //When the field is parsed successfully, we can compute the offset and remove it from the mapFieldParser
        
        //Check if all fields were parsed successfully (we can just check if mapFieldParser.size() == 0lu)
        bool b(mapFieldParser.size() == 0lu);
        p_field.setIsOffsetReady(b);
        //Then we can print the unresolved Fields by iterating the mapFieldParser
        if(!b){
                out << "FieldParser::loadComputeOffset : there are "<<mapFieldParser.size()<<" unresolved Fields in '"<<p_field.getName()<<"', id = "<<p_field.getId()<<" (those without offset) :" << std::endl;
                print(out);
        }
        return b;
}

References createMapFieldParser(), p_field, phoenix_field(), phoenix_fieldSkip(), phoenix_fieldTypeToStr(), phoenix_pbTypeToFieldType(), and print().

Referenced by load(), and loadComputeFieldOffsetArray().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ loadFieldFromOffset()

bool FieldParser::loadFieldFromOffset ( char *& iter )

private

Load the Field directly from the offset.

Parameters

[out] iter : iterator over the message to be parsed

Returns: true on success, false otherwise

Definition at line 386 of file FieldParser.cpp.

                                                 {
        if(p_field.getIsArray()){
                (*p_field.getArrayPtr()) = (void*)(iter + p_field.getOffset());   //We just set the address of the array with respect to the offset
        }else{
                if(p_field.getType() == FieldType::ENUM_TYPE){
                        char * tmp = iter + p_field.getOffset();
                        *((size_t*)p_field.getVarPtr()) = phoenix_readVarInt(tmp);
                }else{
                        memcpy(p_field.getVarPtr(), iter + p_field.getOffset(), p_field.getTypeSize());    //We copy the Field value into the variable pointer
                }
        }
        return true;
}

References FieldType::ENUM_TYPE, p_field, and phoenix_readVarInt().

Referenced by loadFromOffset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ loadFromOffset()

bool FieldParser::loadFromOffset ( char *& iter )

private

Load the Fields directly from the offset.

Parameters

[out] iter : iterator over the message to be parsed

Returns: true on success, false otherwise

Definition at line 370 of file FieldParser.cpp.

                                            {
        bool b(true);
        if(p_vecChildren.size() != 0lu){
                for(VecFieldParser::iterator it(p_vecChildren.begin()); it != p_vecChildren.end(); ++it){
                        b &= (*it)->loadFromOffset(iter);
                }
        }else{
                b &= loadFieldFromOffset(iter);
        }
        return b;
}

References loadFieldFromOffset(), and p_vecChildren.

Referenced by load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ print()

void FieldParser::print	(	std::ostream &	out = std::cout,
		const PString &	indentation = "" ) const

Print the FieldParser.

Parameters

[out]	out	: output stream to be used to print FieldParser information
	indentation	: indentatio to be used for the print

Definition at line 171 of file FieldParser.cpp.

                                                                          {
        if(p_vecChildren.size() != 0lu){
                out << indentation << "Field";
                
                if(p_field.getId() != 0lu){
                        out << "(Id = " << p_field.getId();
                        if(p_field.getName() != ""){
                                out << ", '" << p_field.getName() << "'";
                        }
                        if(p_field.getIsOffsetReady()){
                                out << ", offset = " << p_field.getOffset();
                        }else{
                                out << ", NOT_RESOLVED";
                        }
                        out << ")";
                }
                out << "{" << std::endl;
                for(VecFieldParser::const_iterator it(p_vecChildren.begin()); it != p_vecChildren.end(); ++it){
                        (*it)->print(out, indentation + "\t");
                }
                out << indentation << "}" << std::endl;
        }else{
                out << indentation << "Field(Id = " << p_field.getId();
                if(p_field.getName() != ""){
                        out << ", '"<<p_field.getName()<<"'";
                }
                if(p_field.getIsOffsetReady()){
                        out << ", offset = " << p_field.getOffset();
                }else{
                        out << ", NOT_RESOLVED";
                }
                if(p_field.getIsArray()){
                        out << ", arrayPtr = " << p_field.getArrayPtr() << ", sizePtr = " << p_field.getNbElement();
                }else{
                        out << ", varPtr = " << p_field.getVarPtr();
                }
                out << ")" << std::endl;
        }
}

References p_field, and p_vecChildren.

Referenced by loadComputeOffset().

Here is the caller graph for this function:

◆ resetOffset()

void FieldParser::resetOffset ( )

Reset the offset of the FieldParser.

Definition at line 151 of file FieldParser.cpp.

                             {
        p_field.setOffset(0lu);
        p_field.setIsOffsetReady(false);
        for(VecFieldParser::iterator it(p_vecChildren.begin()); it != p_vecChildren.end(); ++it){
                (*it)->resetOffset();
        }
}

References p_field, and p_vecChildren.

◆ setBaseField()

void FieldParser::setBaseField	(	size_t	fieldId,
		const PString &	fieldName )

private

Set the basis of a Field to be parsed.

Parameters

fieldId	: id of the field that contain the sub message
fieldName	: name of the field

Definition at line 231 of file FieldParser.cpp.

                                                                       {
        p_field.setId(fieldId);
        p_field.setName(fieldName);
}

References p_field.

Referenced by createSubFieldParser().

Here is the caller graph for this function:

Member Data Documentation

◆ p_field

AbtractField FieldParser::p_field

private

Field to be parsed.

Definition at line 69 of file FieldParser.h.

Referenced by addParseFieldArray(), addParseFieldEnum(), addParseFieldValue(), addSubMessage(), load(), loadComputeFieldOffset(), loadComputeFieldOffsetArray(), loadComputeOffset(), loadFieldFromOffset(), print(), resetOffset(), and setBaseField().

◆ p_vecChildren

VecFieldParser FieldParser::p_vecChildren

private

Children used to parse other field and sub messages.

Definition at line 71 of file FieldParser.h.

Referenced by addParseFieldArray(), addParseFieldEnum(), addParseFieldValue(), addSubMessage(), clear(), createMapFieldParser(), loadFromOffset(), print(), and resetOffset().

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

/builds/CTA-LAPP/PHOENIX_LIBS2/network/PhoenixProtocolBuffer/src/FieldParser.h
/builds/CTA-LAPP/PHOENIX_LIBS2/network/PhoenixProtocolBuffer/src/FieldParser.cpp
/builds/CTA-LAPP/PHOENIX_LIBS2/network/PhoenixProtocolBuffer/src/FieldParser_impl.h

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ FieldParser()

◆ ~FieldParser()

Member Function Documentation

◆ addParseFieldArray() [1/3]

◆ addParseFieldArray() [2/3]

◆ addParseFieldArray() [3/3]

◆ addParseFieldEnum() [1/3]

◆ addParseFieldEnum() [2/3]

◆ addParseFieldEnum() [3/3]

◆ addParseFieldValue() [1/3]

◆ addParseFieldValue() [2/3]

◆ addParseFieldValue() [3/3]

◆ addSubMessage() [1/4]

◆ addSubMessage() [2/4]

◆ addSubMessage() [3/4]

◆ addSubMessage() [4/4]

◆ checkInputType() [1/2]

◆ checkInputType() [2/2]

◆ clear()

◆ createMapFieldParser()

◆ createSubFieldParser()

◆ initialisationFieldParser()

◆ load() [1/2]

◆ load() [2/2]

◆ loadComputeFieldOffset()

◆ loadComputeFieldOffsetArray()

◆ loadComputeOffset()

◆ loadFieldFromOffset()

◆ loadFromOffset()

◆ print()

◆ resetOffset()

◆ setBaseField()

Member Data Documentation

◆ p_field

◆ p_vecChildren