FieldParser.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
 
#include <string.h>
#include "phoenix_varint.h"
 
#include "FieldParser.h"
 

FieldParser::FieldParser(){
        initialisationFieldParser();
}

FieldParser::~FieldParser(){
        clear();
}


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


FieldParser * FieldParser::addSubMessage(const FieldConfig & field){
        if(!checkInputType(FieldType::SUBMESSAGE, field)){return NULL;}
        return addSubMessage(field.getId(), field.getName());
}


FieldParser * FieldParser::addSubMessage(const FieldConfig & field, const PString & childName){
        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;
        }
}


FieldParser * FieldParser::addSubMessage(FieldConfig & childConfig, const FieldConfig & field, const PString & childName){
        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;
        }
}


void FieldParser::addParseFieldEnum(size_t* varPtr, size_t fieldId, const PString & fieldName){
        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);
}


bool FieldParser::addParseFieldEnum(size_t* varPtr, const FieldConfig & field){
        if(!checkInputType(FieldType::ENUM_TYPE, field)){return false;}
        addParseFieldEnum(varPtr, field.getId(), field.getName());
        return true;
}


bool FieldParser::addParseFieldEnum(size_t* varPtr, const FieldConfig & field, const PString & childName){
        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;
        }
}


bool FieldParser::load(const std::vector<char> & message, std::ostream & out){
        return load(message.data(), message.size(), out);
}


bool FieldParser::load(const char * message, size_t nbByte, std::ostream & out){
        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);
        }
}

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

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


void FieldParser::print(std::ostream & out, const PString & indentation) const{
        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;
        }
}

void FieldParser::initialisationFieldParser(){
        
}


FieldParser * FieldParser::createSubFieldParser(size_t fieldId, const PString & fieldName){
        FieldParser* parser = new FieldParser;
        parser->setBaseField(fieldId, fieldName);
        return parser;
}


void FieldParser::setBaseField(size_t fieldId, const PString & fieldName){
        p_field.setId(fieldId);
        p_field.setName(fieldName);
}


bool FieldParser::checkInputType(FieldType::FieldType type, const FieldConfig & field){
        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;
}


bool FieldParser::loadComputeOffset(char* & iter, const char* endMessage, const char * message, std::ostream & out){
        //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;
}


bool FieldParser::loadComputeFieldOffset(char* & iter, const char* endMessage, const char * message, size_t fieldId, size_t fieldType, std::ostream & out){
        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;
}


bool FieldParser::loadComputeFieldOffsetArray(char* & iter, const char* endMessage, const char * message, std::ostream & out){
        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;
}


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


bool FieldParser::loadFromOffset(char* & iter){
        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;
}


bool FieldParser::loadFieldFromOffset(char* & iter){
        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;
}