phoenix_field.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include "dico_replace_var.h"
#include "phoenix_varint.h"
#include "phoenix_field.h"


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


void phoenix_fieldSkip(char*& iter, size_t fieldType){
        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;
        }
}


void phoenix_fieldPrintArray(char*& iter, const char * message){
        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;
}


void phoenix_fieldPrint(char*& iter, size_t fieldType, const char * message){
        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;
        }
}


FieldConfig phoenix_createField(FieldType::FieldType type, size_t id, const PString & name, bool isArray){
        FieldConfig field;
        field.setType(type);
        field.setId(id);
        field.setName(name);
        field.setIsArray(isArray);
        return field;
}


bool phoenix_parseFieldConfig(FieldConfig & field, const PPath & fileName, const PString & fieldConfigKey){
        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;
        }
}


bool phoenix_parseFieldConfig(FieldConfig & field, const DicoValue & dico, const PString & fieldConfigKey){
        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;
        }
}


bool phoenix_parseFieldConfig(FieldConfig & field, const DicoValue & dico){
        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;
}


void phoenix_printFieldMessage(const char * message, size_t nbByte, size_t offset){
        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;
}


void phoenix_printFieldMessage(const char * message, size_t nbByte){
        phoenix_printFieldMessage(message, nbByte, 0lu);
}