/data3/calcul/jacquem/working_dir/Micromegas/micromegasFrameWork/src/xml/XMLTool.cpp

Go to the documentation of this file.

/* @version $Revision: 1703 $ * @modifiedby $Author: jacquem $ * @lastmodified $Date: 2012-05-03 10:11:12 +0200 (Thu, 03 May 2012) $ */
/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/*
 * $Id: XMLHandlers.cpp 676911 2008-07-15 13:27:32Z amassari $
 */



// ---------------------------------------------------------------------------
//  Includes
// ---------------------------------------------------------------------------
#include <xercesc/util/XMLUniDefs.hpp>
#include <xercesc/sax/AttributeList.hpp>

#include <xercesc/util/PlatformUtils.hpp>
#include <xercesc/util/TransService.hpp>
#include <xercesc/parsers/SAXParser.hpp>
#include <xercesc/util/OutOfMemoryException.hpp>

#include <iostream>
#include <cstring>
#include <string>

#include "tools/Log.hh"

#include "xml/XMLTool.hh"
// ---------------------------------------------------------------------------
//  Local const data
//
//  Note: This is the 'safe' way to do these strings. If you compiler supports
//        L"" style strings, and portability is not a concern, you can use
//        those types constants directly.
// ---------------------------------------------------------------------------
static const XMLCh  gEndElement[] = { chOpenAngle, chForwardSlash, chNull };
static const XMLCh  gEndPI[] = { chQuestion, chCloseAngle, chNull };
static const XMLCh  gStartPI[] = { chOpenAngle, chQuestion, chNull };
static const XMLCh  gXMLDecl1[] =
{
        chOpenAngle, chQuestion, chLatin_x, chLatin_m, chLatin_l
    ,   chSpace, chLatin_v, chLatin_e, chLatin_r, chLatin_s, chLatin_i
    ,   chLatin_o, chLatin_n, chEqual, chDoubleQuote, chDigit_1, chPeriod
    ,   chDigit_0, chDoubleQuote, chSpace, chLatin_e, chLatin_n, chLatin_c
    ,   chLatin_o, chLatin_d, chLatin_i, chLatin_n, chLatin_g, chEqual
    ,   chDoubleQuote, chNull
};

static const XMLCh  gXMLDecl2[] =
{
        chDoubleQuote, chQuestion, chCloseAngle
    ,   chLF, chNull
};




// ---------------------------------------------------------------------------
//  XMLHandlers: Constructors and Destructor
// ---------------------------------------------------------------------------
XMLHandlers::XMLHandlers( const XMLTool &aFather
        , const   char* const              encodingName
                          , const XMLFormatter::UnRepFlags unRepFlags) :

    fFormatter
    (
        encodingName
        , 0
        , this
        , XMLFormatter::NoEscapes
        , unRepFlags
    ),
    father(aFather)
{
    //
    //  Go ahead and output an XML Decl with our known encoding. This
    //  is not the best answer, but its the best we can do until we
    //  have SAX2 support.
    //
    fFormatter << gXMLDecl1 << fFormatter.getEncodingName() << gXMLDecl2;
}

XMLHandlers::~XMLHandlers()
{
}


// ---------------------------------------------------------------------------
//  XMLHandlers: Overrides of the output formatter target interface
// ---------------------------------------------------------------------------
void XMLHandlers::writeChars(const XMLByte* const /* toWrite */)
{
}

void XMLHandlers::writeChars(const XMLByte* const toWrite,
                                  const XMLSize_t      count,
                                  XMLFormatter* const /* formatter */)
{
    // For this one, just dump them to the standard output
    // Surprisingly, Solaris was the only platform on which
    // required the char* cast to print out the string correctly.
    // Without the cast, it was printing the pointer value in hex.
    // Quite annoying, considering every other platform printed
    // the string with the explicit cast to char* below.
    //XERCES_STD_QUALIFIER cout.write((char *) toWrite, (int) count);
  //XERCES_STD_QUALIFIER cout.flush();
  //std::cout <<toWrite;
}


// ---------------------------------------------------------------------------
//  XMLHandlers: Overrides of the SAX ErrorHandler interface
// ---------------------------------------------------------------------------
void XMLHandlers::error(const SAXParseException& e)
{
    XERCES_STD_QUALIFIER cerr << "\nError at file " << StrX(e.getSystemId())
     << ", line " << e.getLineNumber()
     << ", char " << e.getColumnNumber()
         << "\n  Message: " << StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl;
}

void XMLHandlers::fatalError(const SAXParseException& e)
{
    XERCES_STD_QUALIFIER cerr << "\nFatal Error at file " << StrX(e.getSystemId())
     << ", line " << e.getLineNumber()
     << ", char " << e.getColumnNumber()
         << "\n  Message: " << StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl;
}

void XMLHandlers::warning(const SAXParseException& e)
{
    XERCES_STD_QUALIFIER cerr << "\nWarning at file " << StrX(e.getSystemId())
     << ", line " << e.getLineNumber()
     << ", char " << e.getColumnNumber()
         << "\n  Message: " << StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl;
}


// ---------------------------------------------------------------------------
//  XMLHandlers: Overrides of the SAX DTDHandler interface
// ---------------------------------------------------------------------------
void XMLHandlers::unparsedEntityDecl(const     XMLCh* const /* name */
                                          , const   XMLCh* const /* publicId */
                                          , const   XMLCh* const /* systemId */
                                          , const   XMLCh* const /* notationName */)
{
    // Not used at this time
}


void XMLHandlers::notationDecl(const   XMLCh* const /* name */
                                    , const XMLCh* const /* publicId */
                                    , const XMLCh* const /* systemId */)
{
    // Not used at this time
}


// ---------------------------------------------------------------------------
//  XMLHandlers: Overrides of the SAX DocumentHandler interface
// ---------------------------------------------------------------------------
void XMLHandlers::characters(const     XMLCh* const    chars
                                  , const   XMLSize_t       length)
{
    fFormatter.formatBuf(chars, length, XMLFormatter::CharEscapes);
}


void XMLHandlers::endDocument()
{
}


void XMLHandlers::endElement(const XMLCh* const name)
{
    // No escapes are legal here
    //fFormatter << XMLFormatter::NoEscapes << gEndElement << name << chCloseAngle;
}


void XMLHandlers::ignorableWhitespace( const   XMLCh* const chars
                                            ,const  XMLSize_t    length)
{
    fFormatter.formatBuf(chars, length, XMLFormatter::NoEscapes);
}


void XMLHandlers::processingInstruction(const  XMLCh* const target
                                            , const XMLCh* const data)
{
    //fFormatter << XMLFormatter::NoEscapes << gStartPI  << target;
    //if (data)
     //   fFormatter << chSpace << data;
    //fFormatter << XMLFormatter::NoEscapes << gEndPI;
    }


void XMLHandlers::startDocument()
{
}


void XMLHandlers::startElement(const   XMLCh* const    name
                                   ,       AttributeList&  attributes)
{
    // The name has to be representable without any escapes
    //fFormatter  << XMLFormatter::NoEscapes
    //            << chOpenAngle << name;
    //string balise, string key, string value)

    // get the balise
    string balise = XMLCh_to_String(name);

    // get key and value
    XMLSize_t len = attributes.getLength();
    // For a balise -> 0 to n keys
      // map key <-> value
    map<string,string> key_value;
    for (XMLSize_t index = 0; index < len; index++)
    {
           string key =  XMLCh_to_String( attributes.getName(index));
           string value =  XMLCh_to_String( attributes.getValue(index));
     key_value[key]=value;
           //father.receiveEvent(balise,key,value);
    }
    father.receiveEvent(balise,key_value);
    //fFormatter << chCloseAngle;
}

string XMLHandlers::XMLCh_to_String( const XMLCh* toTranscode )
{
return string(XMLString::transcode(toTranscode));
}





using namespace std;

// ---------------------------------------------------------------------------
//  Local helper methods
// ---------------------------------------------------------------------------
XMLTool::XMLTool():steerDesc(NULL)

{
}

// ---------------------------------------------------------------------------
int XMLTool::parse(SteerDesc& aSteerDesc, string aXmlFileName)
{

steerDesc =  &aSteerDesc;

if ( steerDesc != NULL )
{
xmlFileName = aXmlFileName;


bool                     doNamespaces        = false;
bool                     doSchema            = false;
bool                     schemaFullChecking  = false;
const char*              encodingName    = "LATIN1";
XMLFormatter::UnRepFlags unRepFlags      = XMLFormatter::UnRep_CharRef;
const char*                    xmlFile         = 0;
SAXParser::ValSchemes    valScheme       = SAXParser::Val_Auto;


    // Initialize the XML4C2 system
    try
    {
         XMLPlatformUtils::Initialize();
    }

    catch (const XMLException& toCatch)
    {
         XERCES_STD_QUALIFIER cerr << "Error during initialization! :\n"
              << StrX(toCatch.getMessage()) << XERCES_STD_QUALIFIER endl;
         return 1;
    }

    xmlFile = xmlFileName.data() ;
    int errorCount = 0;

    //
    //  Create a SAX parser object. Then, according to what we were told on
    //  the command line, set it to validate or not.
    //
    SAXParser* parser = new SAXParser;
    parser->setValidationScheme(valScheme);
    parser->setDoNamespaces(doNamespaces);
    parser->setDoSchema(doSchema);
    parser->setValidationSchemaFullChecking(schemaFullChecking);

    //
    //  Create the handler object and install it as the document and error
    //  handler for the parser-> Then parse the file and catch any exceptions
    //  that propogate out
    //
    int errorCode = 0;
    try
    {
        XMLHandlers handler(*this, encodingName, unRepFlags);
        parser->setDocumentHandler(&handler);
        parser->setErrorHandler(&handler);
        parser->parse(xmlFile);
        errorCount = parser->getErrorCount();
    }
    catch (const OutOfMemoryException&)
    {
        XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl;
        errorCode = 5;
    }
    catch (const XMLException& toCatch)
    {
        XERCES_STD_QUALIFIER cerr << "\nAn error occurred\n  Error: "
             << StrX(toCatch.getMessage())
             << "\n" << XERCES_STD_QUALIFIER endl;
        errorCode = 4;
    }
    if(errorCode) {
        XMLPlatformUtils::Terminate();
        return errorCode;
    }

    //
    //  Delete the parser itself.  Must be done prior to calling Terminate, below.
    //
    delete parser;

    // And call the termination method
    XMLPlatformUtils::Terminate();

    if (errorCount > 0)
        return 4;
    else
  {
          return 0;
}
}
else { return 4; }
}


//void XMLTool::receiveEvent(string balise,string key, string value) const
void XMLTool::receiveEvent(string balise,const map<string,string> &key_value) const
{
  string key,value;
  map<string, string>::const_iterator iter;

//cout << "balise[" << balise <<"]" <<endl;

  for (iter=key_value.begin(); iter != key_value.end(); ++iter)
  {
    key = iter->first;
    value = iter->second;

//cout << "key[" << key <<"]" <<endl;
//cout << "value[" << value <<"]" <<endl;


    //Info
    if ( !balise.compare(INFOR) && !key.compare(DATE) )
    {
      steerDesc->date = value;
    }
    // uRun

// Monitoring dif 
    else if (  !balise.compare(MONDIF) && !key.compare(ID) )
    {
      int id = atoi(value.c_str());
      steerDesc->monitoringDif = atoi(value.c_str());
    }
    //slow control file
    else if (  !balise.compare(SLOWCONTROL) && !key.compare(PATH) )
    {
      steerDesc->slowControl = value;
    }

    //input file
    else if (  !balise.compare(INPUT) && !key.compare(PATH) )
    {
      steerDesc->inputInfo = new input_info_t();
      steerDesc->inputInfo->path = value;
    }
    else if (  !balise.compare(INPUT) && !key.compare(TYPE) )
    {
      if ( steerDesc->inputInfo != NULL )
      {
        steerDesc->inputInfo->type = value;
      }
    }

    else if (  !balise.compare(INPUT) && !key.compare(RUNID) )
    {
      if ( steerDesc->inputInfo != NULL )
      {
        steerDesc->inputInfo->runId = atoi(value.c_str());
      }
    }

    // output file
    else if (  !balise.compare(OUTPUT) && !key.compare(PATH) )
    {
      steerDesc->outputFile = value;
    }
    //detector name and description
    else if (  !balise.compare(DETECTOR) && !key.compare(NAME) )
    {
      steerDesc->detectorName = value;
    }
    else if (  !balise.compare(DETECTOR) && !key.compare(DESCRIPTION) )
    {
      steerDesc->detectorDescription = value;
    }

    // Chamber type and z position
    else if (  !balise.compare(CHAMBER) && !key.compare(TYPE) )
    {
      if ( steerDesc->chamberInfo == NULL )  
                        {
                                        steerDesc->chamberInfo = new chamber_info_t();
                                        steerDesc->chamberInfo->xRotation = false;
                                        steerDesc->chamberInfo->yRotation = false;
                                        steerDesc->chamberInfo->zRotation = 0;
                                        steerDesc->chamberInfo->stripHorizontal = false;
                                        steerDesc->chamberInfo->unit = "cm" ;
                        }
      steerDesc->chamberInfo->type = value;
    }
    else if (  !balise.compare(CHAMBER) && !key.compare(XPOS) )
    {
      if ( steerDesc->chamberInfo == NULL )
                        {
                                        steerDesc->chamberInfo = new chamber_info_t();
                                        steerDesc->chamberInfo->xRotation = false;
                                        steerDesc->chamberInfo->yRotation = false;
                                        steerDesc->chamberInfo->zRotation = 0;
                                        steerDesc->chamberInfo->stripHorizontal = false;
          steerDesc->chamberInfo->unit = "cm" ;
                        }
      steerDesc->chamberInfo->xPos = atof(value.c_str());
//                      cout << "XMLTool xPos[" << steerDesc->chamberInfo->xPos <<"]" << endl;
    }
    else if (  !balise.compare(CHAMBER) && !key.compare(YPOS) )
    {
      if ( steerDesc->chamberInfo == NULL )
                        {
                                        steerDesc->chamberInfo = new chamber_info_t();
                                        steerDesc->chamberInfo->xRotation = false;
                                        steerDesc->chamberInfo->yRotation = false;
                                        steerDesc->chamberInfo->zRotation = 0;
                                        steerDesc->chamberInfo->stripHorizontal = false;
          steerDesc->chamberInfo->unit = "cm" ;
                        }
      steerDesc->chamberInfo->yPos = atof(value.c_str());
        //              cout << "y  atof(value.c_str()[" <<  atof(value.c_str()) << "]" <<endl;
//                      cout << "XMLTool yPos[" << steerDesc->chamberInfo->yPos <<"]" << endl;
    }
    else if (  !balise.compare(CHAMBER) && !key.compare(ZPOS) )
    {
      if ( steerDesc->chamberInfo == NULL )
                        {
                                        steerDesc->chamberInfo = new chamber_info_t();
                                        steerDesc->chamberInfo->xRotation = false;
                                        steerDesc->chamberInfo->yRotation = false;
                                        steerDesc->chamberInfo->zRotation = 0;
                                        steerDesc->chamberInfo->stripHorizontal = false;
          steerDesc->chamberInfo->unit = "cm" ;
                        }
      steerDesc->chamberInfo->zPos = atof(value.c_str());
    }
    else if (  !balise.compare(CHAMBER) && !key.compare(XROTATION) )
    {
      if ( steerDesc->chamberInfo == NULL )
                        {
                                        steerDesc->chamberInfo = new chamber_info_t();
                                        steerDesc->chamberInfo->xRotation = false;
                                        steerDesc->chamberInfo->yRotation = false;
                                        steerDesc->chamberInfo->zRotation = 0;
                                        steerDesc->chamberInfo->stripHorizontal = false;
          steerDesc->chamberInfo->unit = "cm" ;
                        }
                        if ( !value.compare("true") || !value.compare("TRUE") )
                        {
          steerDesc->chamberInfo->xRotation = true;
                        }
    }
    else if (  !balise.compare(CHAMBER) && !key.compare(YROTATION) )
    {
      if ( steerDesc->chamberInfo == NULL )
                        {
                                        steerDesc->chamberInfo = new chamber_info_t();
                                        steerDesc->chamberInfo->xRotation = false;
                                        steerDesc->chamberInfo->yRotation = false;
                                        steerDesc->chamberInfo->zRotation = 0;
                                        steerDesc->chamberInfo->stripHorizontal = false;
          steerDesc->chamberInfo->unit = "cm" ;
                        }
                        if ( !value.compare("true") || !value.compare("TRUE") )
                        {
          steerDesc->chamberInfo->yRotation = true;
                        }
    }

  else if (  !balise.compare(CHAMBER) && !key.compare(ZROTATION) )
    {
      if ( steerDesc->chamberInfo == NULL )
      {
          steerDesc->chamberInfo = new chamber_info_t();
          steerDesc->chamberInfo->xRotation = false;
          steerDesc->chamberInfo->yRotation = false;
          steerDesc->chamberInfo->zRotation = 0;
          steerDesc->chamberInfo->stripHorizontal = false;
          steerDesc->chamberInfo->unit = "cm" ;
      }
      i16 rotation =  atoi(value.c_str());
      if (  rotation == 0  ||  rotation == -90 ||  rotation == 90 )
      {
        steerDesc->chamberInfo->zRotation = rotation;
      }
      else
      { 
        cout << "XML error. zRotation value choise is [-90,0,90]." << endl;
        exit(-1);
      }
      
    }


    else if (  !balise.compare(CHAMBER) && !key.compare(STRIPHORIZONTAL) )
    {
      if ( steerDesc->chamberInfo == NULL )
                        {
                                        steerDesc->chamberInfo = new chamber_info_t();
                                        steerDesc->chamberInfo->xRotation = false;
                                        steerDesc->chamberInfo->yRotation = false;
                                        steerDesc->chamberInfo->zRotation = 0;
                                        steerDesc->chamberInfo->stripHorizontal = false;
          steerDesc->chamberInfo->unit = "cm" ;
                        }
                        if ( !value.compare("true") || !value.compare("TRUE") )
                        {
          steerDesc->chamberInfo->stripHorizontal = true;
                        }
    }
    else if (  !balise.compare(CHAMBER) && !key.compare(UNIT) )
    {
      if ( steerDesc->chamberInfo == NULL )
      {
          steerDesc->chamberInfo = new chamber_info_t();
          steerDesc->chamberInfo->xRotation = false;
          steerDesc->chamberInfo->yRotation = false;
                                        steerDesc->chamberInfo->zRotation = 0;
          steerDesc->chamberInfo->stripHorizontal = false;
          steerDesc->chamberInfo->unit = "cm" ;
      }
      steerDesc->chamberInfo->unit = value;
    }

    else if (  !balise.compare(CHAMBER) && !key.compare(ID) )
    {
      if ( steerDesc->chamberInfo == NULL )
                        {
                                        steerDesc->chamberInfo = new chamber_info_t();
                                        steerDesc->chamberInfo->xRotation = false;
                                        steerDesc->chamberInfo->yRotation = false;
                                        steerDesc->chamberInfo->zRotation = 0;
                                        steerDesc->chamberInfo->stripHorizontal = false;
          steerDesc->chamberInfo->unit = "cm" ;
                        }
      steerDesc->chamberInfo->id = atoi(value.c_str());
    }

    // Boards
    else if (  !balise.compare(BOARD) && !key.compare(ID) )
    {
      if ( steerDesc->boardInfo == NULL ) steerDesc->boardInfo = new BoardInfo_t();
      steerDesc->boardInfo->id = atoi(value.c_str());
      steerDesc->boardInfo->chamberId = steerDesc->lastChamberId;
      steerDesc->boardInfo->difId = steerDesc->lastDifId;
    }

 
    // Difs
    else if (  !balise.compare(DIF) && !key.compare(ID) )
    {
      if ( steerDesc->difInfo == NULL ) steerDesc->difInfo = new DifInfo_t();
      steerDesc->difInfo->id = atoi(value.c_str());
      steerDesc->difInfo->chamberId = steerDesc->lastChamberId;
    }

    // Chips
    else if (  !balise.compare(CHIP) && !key.compare(ID) )
    {
      if ( steerDesc->chipInfo == NULL ) 
      {
        steerDesc->chipInfo = new ChipInfo_t();
        steerDesc->chipInfo->boardId = steerDesc->lastBoardId;
        steerDesc->chipInfo->difId = steerDesc->lastDifId;
        steerDesc->chipInfo->chamberId = steerDesc->lastChamberId;
      }
      steerDesc->chipInfo->id = atoi(value.c_str());
    }
    else if (  !balise.compare(CHIP) && !key.compare(SERIAL) )
    {
      if ( steerDesc->chipInfo == NULL ) 
      {
        steerDesc->chipInfo = new ChipInfo_t();
        steerDesc->chipInfo->boardId = steerDesc->lastBoardId;
        steerDesc->chipInfo->difId = steerDesc->lastDifId;
        steerDesc->chipInfo->chamberId = steerDesc->lastChamberId;
      }
      steerDesc->chipInfo->serial = atoi(value.c_str());
    }

    // Slow Control
    else if (!balise.compare(SCPARAM) && !key.compare(SCID) )
    {
      if ( steerDesc->slowControlInfo == NULL )
     {
       steerDesc->slowControlInfo = new SlowControl_t();
     }
      steerDesc->slowControlInfo->scId = atoi(value.c_str());
    }
    else if (!balise.compare(SCPARAM) && !key.compare(TYPE) )
    {
      if ( steerDesc->slowControlInfo == NULL ) steerDesc->slowControlInfo = new SlowControl_t();
      steerDesc->slowControlInfo->type = value;
    }
    else if (!balise.compare(SCPARAM) && !key.compare(CHAMBERID) )
    {
      if ( steerDesc->slowControlInfo == NULL ) steerDesc->slowControlInfo = new SlowControl_t();
      steerDesc->slowControlInfo->chamberId = atoi(value.c_str());
    }
    else if (!balise.compare(SCPARAM) && !key.compare(DIFID) )
    {
      if ( steerDesc->slowControlInfo == NULL ) steerDesc->slowControlInfo = new SlowControl_t();
      steerDesc->slowControlInfo->difId = atoi(value.c_str());
    }
    else if (!balise.compare(SCPARAM) && !key.compare(BOARDID) )
    {
      if ( steerDesc->slowControlInfo == NULL ) steerDesc->slowControlInfo = new SlowControl_t();
      steerDesc->slowControlInfo->boardId = atoi(value.c_str());
    }
    else if (!balise.compare(SCPARAM) && !key.compare(NAME) )
    {
      if ( steerDesc->slowControlInfo == NULL ) steerDesc->slowControlInfo = new SlowControl_t();
      steerDesc->slowControlInfo->name = value;
    }
    else if (!balise.compare(SCPARAM) && !key.compare(PMID) )
    {
      if ( steerDesc->slowControlInfo == NULL ) steerDesc->slowControlInfo = new SlowControl_t();
      steerDesc->slowControlInfo->pmId = atoi(value.c_str());
    }

  } // for

  if (  !balise.compare(CHAMBER) && ( steerDesc->chamberInfo != NULL ) )
  {
    steerDesc->chambers.push_back(*(steerDesc->chamberInfo));
    steerDesc->lastChamberId = steerDesc->chamberInfo->id;
    steerDesc->chamberInfo = NULL;
  }
  if (  !balise.compare(BOARD) && ( steerDesc->boardInfo != NULL ) )
  {
    steerDesc->boards.push_back(*(steerDesc->boardInfo));
    steerDesc->lastBoardId = steerDesc->boardInfo->id;
    steerDesc->boardInfo = NULL;
  }
  if (  !balise.compare(INPUT) && ( steerDesc->inputInfo != NULL ) )
  {
    steerDesc->inputFiles.push_back(*(steerDesc->inputInfo));
    steerDesc->inputInfo = NULL;
  }
  if (!balise.compare(DIF) && ( steerDesc->difInfo != NULL ) )
  {
    steerDesc->difs.push_back(*(steerDesc->difInfo));
    steerDesc->lastDifId = steerDesc->difInfo->id;
    steerDesc->difInfo = NULL;
  }
  if (!balise.compare(CHIP) && ( steerDesc->chipInfo != NULL ) )
  {
    steerDesc->chips.push_back(*(steerDesc->chipInfo));
    steerDesc->chipInfo = NULL;
  }
  if (!balise.compare(SCPARAM) && ( steerDesc->slowControlInfo != NULL ) )
  {
    steerDesc->slowControls.push_back(*(steerDesc->slowControlInfo));
    steerDesc->slowControlInfo = NULL;
  }

}

---