phoenix_field.cpp File Reference

#include "dico_replace_var.h"
#include "phoenix_varint.h"
#include "phoenix_field.h"

Include dependency graph for phoenix_field.cpp:

Go to the source code of this file.

Functions
FieldConfig	phoenix_createField (FieldType::FieldType type, size_t id, const PString &name, bool isArray)
	Create a FieldConfig.
void	phoenix_field (size_t &fieldId, size_t &fieldType, char *&iter)
	Reads a Field header.
void	phoenix_fieldPrint (char *&iter, size_t fieldType, const char *message)
	Print the current field.
void	phoenix_fieldPrintArray (char *&iter, const char *message)
	Print the current ByteArray.
void	phoenix_fieldSkip (char *&iter, size_t fieldType)
	Skip the current field.
bool	phoenix_parseFieldConfig (FieldConfig &field, const DicoValue &dico)
	Load a fieldConfig with a DicoValue (parsed yml file)
bool	phoenix_parseFieldConfig (FieldConfig &field, const DicoValue &dico, const PString &fieldConfigKey)
	Load a fieldConfig with a DicoValue (parsed yml file)
bool	phoenix_parseFieldConfig (FieldConfig &field, const PPath &fileName, const PString &fieldConfigKey)
	Parse a yml file and search for a field_config key.
void	phoenix_printFieldMessage (const char *message, size_t nbByte)
	Print the Fields in a message.
void	phoenix_printFieldMessage (const char *message, size_t nbByte, size_t offset)
	Print the Fields in a message.

Function Documentation

phoenix_createField()

FieldConfig phoenix_createField	(	FieldType::FieldType	type,
		size_t	id,
		const PString &	name,
		bool	isArray )

Create a FieldConfig.

Parameters

type	: type of the field
id	: id of the field
name	: name of the field
isArray	: true if the field is an array

Returns

corresponding FieldConfig

Definition at line 89 of file phoenix_field.cpp.

                                                                                                       {
        FieldConfig field;
        field.setType(type);
        field.setId(id);
        field.setName(name);
        field.setIsArray(isArray);
        return field;
}

References FieldConfig::setId(), FieldConfig::setIsArray(), FieldConfig::setName(), and FieldConfig::setType().

Referenced by phoenix_parseFieldConfig().

Here is the call graph for this function:

Here is the caller graph for this function:

phoenix_field()

void phoenix_field	(	size_t &	fieldId,
		size_t &	fieldType,
		char *&	iter )

Reads a Field header.

Parameters

[out]	fieldId	: id of the current field
[out]	fieldType	: type of the current field
[out]	iter	: iterator ofer the message to be read

Definition at line 16 of file phoenix_field.cpp.

                                                                     {
        char value = *iter;
        fieldType = value & 7;  //Get 3 first bits
        fieldId = value >> 3;   //Shifted of 3 bits on the left
        iter += 1lu;
}

Referenced by FieldParser::loadComputeOffset(), and phoenix_printFieldMessage().

Here is the caller graph for this function:

phoenix_fieldPrint()

void phoenix_fieldPrint	(	char *&	iter,
		size_t	fieldType,
		const char *	message )

Print the current field.

Parameters

[out]	iter	: iterator of the current message to be read
	fieldType	: type of the field to be skipped
	message	: message to be used

Definition at line 62 of file phoenix_field.cpp.

                                                                            {
        switch(fieldType){
                case 0lu:               //This is an enum
                        std::cout << "Enum = " << phoenix_readVarInt(iter) << std::endl;
                        break;
                case 1lu:               //This is a uint64_t
                        std::cout << "uint64_t = " << phoenix_readValue<uint64_t>(iter) << std::endl;
                        break;
                case 2lu:               //This is a binary array, which starts by a varint
                        phoenix_fieldPrintArray(iter, message);
                        break;
                case 5lu:               //This is a uint64_t
                        std::cout << "uint32_t = " << phoenix_readValue<uint32_t>(iter) << std::endl;
                        break;
                default:
                        std::cout << "Unknown Type" << std::endl;
                        break;
        }
}

References phoenix_fieldPrintArray(), phoenix_readValue(), and phoenix_readVarInt().

Referenced by phoenix_printFieldMessage().

Here is the call graph for this function:

Here is the caller graph for this function:

phoenix_fieldPrintArray()

void phoenix_fieldPrintArray	(	char *&	iter,
		const char *	message )

Print the current ByteArray.

Parameters

[out]	iter	: iterator of the current message to be read
	message	: message to be used

Definition at line 50 of file phoenix_field.cpp.

                                                               {
        size_t nbByte = phoenix_readVarInt(iter);
        size_t dataOffset = iter - (char*)message;
        std::cout << "ByteArray/SubMessage(data_offset = " << dataOffset << ", size = " << nbByte << ")" << std::endl;
        iter += nbByte;
}

References phoenix_readVarInt().

Referenced by phoenix_fieldPrint().

Here is the call graph for this function:

Here is the caller graph for this function:

phoenix_fieldSkip()

void phoenix_fieldSkip	(	char *&	iter,
		size_t	fieldType )

Skip the current field.

Parameters

[out]	iter	: iterator of the current message to be read
	fieldType	: type of the field to be skipped

Definition at line 27 of file phoenix_field.cpp.

                                                     {
        switch(fieldType){
                case 0lu:               //This is an enum
                        phoenix_skipVarInt(iter);
                        break;
                case 1lu:               //This is a uint64_t
                        iter += sizeof(uint64_t);
                        break;
                case 2lu:               //This is a binary array, which starts by a varint
                        iter += phoenix_readVarInt(iter);
                        break;
                case 5lu:               //This is a uint64_t
                        iter += sizeof(uint32_t);
                        break;
                default:
                        break;
        }
}

References phoenix_readVarInt(), and phoenix_skipVarInt().

Referenced by FieldParser::loadComputeOffset().

Here is the call graph for this function:

Here is the caller graph for this function:

phoenix_parseFieldConfig() [1/3]

bool phoenix_parseFieldConfig	(	FieldConfig &	field,
		const DicoValue &	dico )

Load a fieldConfig with a DicoValue (parsed yml file)

Parameters

[out]	field	: fieldConfig to be initialised
	dico	: DicoValue which contains the FieldConfig definition

Returns

true on success, false otherwise

Definition at line 140 of file phoenix_field.cpp.

                                                                          {
        const MapDicoValue & mapChildren = dico.getMapChild();
        for(MapDicoValue::const_iterator it(mapChildren.begin()); it != mapChildren.end(); ++it){
                PString name(it->first);
                size_t id(phoenix_load_value_from_config<size_t>(it->second, "id", 0lu));
                PString typeStr(phoenix_get_string(it->second, "type", "uint64"));
                bool isArray(phoenix_load_value_from_config<bool>(it->second, "is_array", false));
                FieldType::FieldType type(phoenix_fieldTypeFromStr(typeStr));
                if(type != FieldType::NONE){
                        FieldConfig subField = phoenix_createField(type, id, name, isArray);
                        if(type == FieldType::SUBMESSAGE){ //We check only the submessage definition with the type is FieldType::SUBMESSAGE
                                if(!phoenix_parseFieldConfig(subField, it->second, "sub_message")){
                                        std::cerr << "phoenix_parseFieldConfig : cannot parse 'sub_message' of Field '"<<name<<"'" << std::endl;
                                        return false;
                                }
                        }
                        field.getVecChildren()[name] = subField;
                }else{
                        std::cerr << "phoenix_parseFieldConfig : type '"<<typeStr<<"' does not exist for Field '"<<name<<"'. Please use one of :" << std::endl;
                        std::cerr << "\t- enum" << std::endl;
                        std::cerr << "\t- submessage" << std::endl;
                        std::cerr << "\t- uint64" << std::endl;
                        std::cerr << "\t- uint32" << std::endl;
                        std::cerr << "\t- uint16" << std::endl;
                        std::cerr << "\t- uint8" << std::endl;
                        std::cerr << "\t- int64" << std::endl;
                        std::cerr << "\t- int32" << std::endl;
                        std::cerr << "\t- int16" << std::endl;
                        std::cerr << "\t- int8" << std::endl;
                        return false;
                }
        }
        return true;
}

References FieldConfig::getVecChildren(), FieldType::NONE, phoenix_createField(), phoenix_fieldTypeFromStr(), phoenix_parseFieldConfig(), and FieldType::SUBMESSAGE.

Here is the call graph for this function:

phoenix_parseFieldConfig() [2/3]

bool phoenix_parseFieldConfig	(	FieldConfig &	field,
		const DicoValue &	dico,
		const PString &	fieldConfigKey )

Load a fieldConfig with a DicoValue (parsed yml file)

Parameters

[out]	field	: fieldConfig to be initialised
	dico	: DicoValue which contains the FieldConfig definition
	fieldConfigKey	: name of the key to be searched in the yml file to initialise the FieldConfig

Returns

true on success, false otherwise

Definition at line 125 of file phoenix_field.cpp.

                                                                                                          {
        const DicoValue * ymlField = dico.getMap(fieldConfigKey);
        if(ymlField != NULL){
                return phoenix_parseFieldConfig(field, *ymlField);
        }else{
                std::cerr << "phoenix_parseFieldConfig : FieldConfig definition '"<<fieldConfigKey<<"' does not exist in yml file" << std::endl;
                return false;
        }
}

References phoenix_parseFieldConfig().

Here is the call graph for this function:

phoenix_parseFieldConfig() [3/3]

bool phoenix_parseFieldConfig	(	FieldConfig &	field,
		const PPath &	fileName,
		const PString &	fieldConfigKey )

Parse a yml file and search for a field_config key.

Parameters

[out]	field	: fieldConfig to be initialised
	fileName	: name of the yml file to be loaded
	fieldConfigKey	: name of the key to be searched in the yml file to initialise the FieldConfig

Returns

true on success, false otherwise

Definition at line 104 of file phoenix_field.cpp.

                                                                                                          {
        DicoValue dico;
        if(!parser_yml(dico, fileName)){
                std::cerr << "phoenix_parseFieldConfig : cannot open yml file '"<<fileName<<"'" << std::endl;
                return false;
        }
        dico_replace_var(dico);
        if(!phoenix_parseFieldConfig(field, dico, fieldConfigKey)){
                std::cerr << "phoenix_parseFieldConfig : cannot parse yml file '"<<fileName<<"'" << std::endl;
                return false;
        }else{
                return true;
        }
}

References phoenix_parseFieldConfig().

Referenced by phoenix_parseFieldConfig(), phoenix_parseFieldConfig(), and phoenix_parseFieldConfig().

Here is the call graph for this function:

Here is the caller graph for this function:

phoenix_printFieldMessage() [1/2]

void phoenix_printFieldMessage	(	const char *	message,
		size_t	nbByte )

Print the Fields in a message.

Parameters

message	: message to be used
nbByte	: number of bytes of the message

Definition at line 198 of file phoenix_field.cpp.

                                                                   {
        phoenix_printFieldMessage(message, nbByte, 0lu);
}

References phoenix_printFieldMessage().

Here is the call graph for this function:

phoenix_printFieldMessage() [2/2]

void phoenix_printFieldMessage	(	const char *	message,
		size_t	nbByte,
		size_t	offset )

Print the Fields in a message.

Parameters

message	: message to be used
nbByte	: number of bytes of the message
offset	: offset to start reading the message

Definition at line 180 of file phoenix_field.cpp.

                                                                                  {
        char* iter = (char*)message + offset;
        size_t messageSize = nbByte - offset;
        std::cout << "Field{" << std::endl;
        while(iter < message + messageSize){
                size_t fieldId(0lu), fieldType(0lu);
                phoenix_field(fieldId, fieldType, iter);
                size_t fieldOffset = iter - (char*)message;
                std::cout << "\t- Field " << fieldId << " : field_offset = " << fieldOffset << ", ";
                phoenix_fieldPrint(iter, fieldType, message);
        }
        std::cout << "}" << std::endl;
}

References phoenix_field(), and phoenix_fieldPrint().

Referenced by phoenix_printFieldMessage(), and printProtocolBufferMessage().

Here is the call graph for this function:

Here is the caller graph for this function: