/Users/jacquem/NetBeansProjects/MicromegasFramework/trunk/include/XMLTool.hh

Go to the documentation of this file.

#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 "SteerDesc.hh"
#include "Run.hh"

// XML balises
#define RUN         "run"
#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 CHIP        "chip"

//XML key and value label
#define DATE        "date"
#define DESCRIPTION "description"
#define PATH        "path"
#define NAME        "name"
#define ID          "id"
#define TYPE        "type"
#define XPOS        "xPos"
#define YPOS        "yPos"
#define ZPOS        "zPos"
#define SCID        "scId"

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 ) ;



    // -----------------------------------------------------------------------
    //  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

---