/data3/calcul/jacquem/working_dir/Micromegas/micromegasFrameWork/include/xml/XMLTool.hh

Go to the documentation of this file.

/* @version $Revision: 1700 $ * @modifiedby $Author: lcdet $ * @lastmodified $Date: 2012-05-02 16:38:35 +0200 (Wed, 02 May 2012) $ */
#ifndef XMLHANDLERSHH
#define  XMLHANDLERSHH


#include  <xercesc/sax/HandlerBase.hpp>
#include  <xercesc/framework/XMLFormatter.hpp>
#include <string>
#include <iostream>
#include <stdlib.h>
#include <string>
#include <iostream>
#include <map>

#include "tools/SteerDesc.hh"

// XML balises
#define INFOR       "info"
#define INPUT       "input"
#define SLOWCONTROL "slowcontrol"
#define SCPARAM     "scParam"
#define OUTPUT      "output"
#define DETECTOR    "detector"
#define CHAMBER     "chamber"
#define BOARD       "board"
#define DIF         "dif"
#define MONDIF      "mondif"
#define CHIP        "chip"

//XML key and value label
#define DATE              "date"
#define DESCRIPTION       "description"
#define PATH              "path"
#define NAME              "name"
#define SERIAL            "serial"
#define ID                "id"
#define TYPE              "type"
#define RUNID             "runId"
#define XPOS              "xPos"
#define YPOS              "yPos"
#define ZPOS              "zPos"
#define XROTATION         "xRotation"
#define YROTATION         "yRotation"
#define ZROTATION         "zRotation"
#define STRIPHORIZONTAL   "stripHorizontal"
#define UNIT              "unit"
#define SCID              "scId"
#define BOARDID           "boardId"
#define DIFID             "difId"
#define CHAMBERID         "chamberId"
#define PMID              "pmId"

XERCES_CPP_NAMESPACE_USE

using namespace std;

class XMLTool;

class XMLHandlers : public HandlerBase, private XMLFormatTarget {
public:
    // -----------------------------------------------------------------------
    //  Constructors
    // -----------------------------------------------------------------------
    XMLHandlers
    (
      const XMLTool& father ,
        const   char* const                 encodingName
        , const XMLFormatter::UnRepFlags    unRepFlags
    );
    ~XMLHandlers();


private:
    //string XMLHandlers::XMLCh_to_String( const XMLCh* toTranscode ) ;
    string XMLCh_to_String( const XMLCh* toTranscode ) ;



    // -----------------------------------------------------------------------
    //  Implementations of the format target interface
    // -----------------------------------------------------------------------
    void writeChars
    (
        const   XMLByte* const  toWrite
    );

    virtual void writeChars
    (
        const   XMLByte* const  toWrite
        , const XMLSize_t       count
        , XMLFormatter* const   formatter
    );


    // -----------------------------------------------------------------------
    //  Implementations of the SAX DocumentHandler interface
    // -----------------------------------------------------------------------
    void endDocument();

    void endElement(const XMLCh* const name);

    void characters(const XMLCh* const chars, const XMLSize_t length);

    void ignorableWhitespace
    (
        const   XMLCh* const    chars
        , const XMLSize_t       length
    );

    void processingInstruction
    (
        const   XMLCh* const    target
        , const XMLCh* const    data
    );

    void startDocument();

    void startElement(const XMLCh* const name, AttributeList& attributes);



    // -----------------------------------------------------------------------
    //  Implementations of the SAX ErrorHandler interface
    // -----------------------------------------------------------------------
    void warning(const SAXParseException& exc);
    void error(const SAXParseException& exc);
    void fatalError(const SAXParseException& exc);



    // -----------------------------------------------------------------------
    //  Implementation of the SAX DTDHandler interface
    // -----------------------------------------------------------------------
    void notationDecl
    (
        const   XMLCh* const    name
        , const XMLCh* const    publicId
        , const XMLCh* const    systemId
    );

    void unparsedEntityDecl
    (
        const   XMLCh* const    name
        , const XMLCh* const    publicId
        , const XMLCh* const    systemId
        , const XMLCh* const    notationName
    );


private :
    // -----------------------------------------------------------------------
    //  Private data members
    //
    //  fFormatter
    //      This is the formatter object that is used to output the data
    //      to the target. It is set up to format to the standard output
    //      stream.
    // -----------------------------------------------------------------------
    XMLFormatter    fFormatter;
    const XMLTool       &father;
};




class XMLTool {

public:
    XMLTool() ;
    ~XMLTool(){};
    int parse(SteerDesc& _steerDesc, string _xmlFileName);
    void receiveEvent(string balise, const map<string,string> &key_value) const;


private:
    string xmlFileName;
    SteerDesc *steerDesc;

};

// ---------------------------------------------------------------------------
//  Includes for all the program files to see
// ---------------------------------------------------------------------------


// ---------------------------------------------------------------------------
//  This is a simple class that lets us do easy (though not terribly efficient)
//  trancoding of XMLCh data to local code page for display.
// ---------------------------------------------------------------------------
class StrX {
public :
    // -----------------------------------------------------------------------
    //  Constructors and Destructor
    // -----------------------------------------------------------------------
    StrX(const XMLCh* const toTranscode)
    {
        // Call the private transcoding method
        fLocalForm = XMLString::transcode(toTranscode);
    }

    ~StrX()
    {
        XMLString::release(&fLocalForm);
    }

    // -----------------------------------------------------------------------
    //  Getter methods
    // -----------------------------------------------------------------------
    const char* localForm() const
    {
        return fLocalForm;
    }

private :
    // -----------------------------------------------------------------------
    //  Private data members
    //
    //  fLocalForm
    //      This is the local code page form of the string.
    // -----------------------------------------------------------------------
    char*   fLocalForm;
};

inline XERCES_STD_QUALIFIER ostream& operator<<(XERCES_STD_QUALIFIER ostream& target, const StrX& toDump)
{
    target << toDump.localForm();
    return target;
}



#endif

---