/home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/Calibration/xmlBase/xmlBase-00-00-03/xmlBase/Dom.h

Go to the documentation of this file.

// $Header: /bes/bes/BossCvs/Calibration/xmlBase/xmlBase/Dom.h,v 1.1.1.1 2005/10/17 06:10:27 maqm Exp $
// Author:  J. Bogart

#ifndef xmlBase_Dom_h
#define xmlBase_Dom_h
#include <xercesc/util/XercesDefs.hpp>

XERCES_CPP_NAMESPACE_BEGIN
class  DOMElement;
class  DOMNode;
class  XMLLCPTranscoder;
// class XERCES_CPP_NAMESPACE_QUALIFIER DOMNodeList;
class  DOMDocument;
XERCES_CPP_NAMESPACE_END
#include <string>
#include <iostream>
#include <vector>
#include <map>

// typedef DOM_Element DomElement;
// typedef XERCES_CPP_NAMESPACE_QUALIFIER DOMElement  DomElement
// typedef XERCES_CPP_NAMESPACE_QUALIFIER DOMNode     DomNode;
// typedef XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument DomDocuemnt;
// typedef DOMString   DomString;
// typedef DOMNodeList DomNodeList;
// typedef XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument DomDocument;
namespace xmlBase {
  class DomException : std::exception {
  public:
    DomException(const std::string& extraInfo = "") : std::exception(),
      m_name("DomException"), m_extra(extraInfo) {}
    virtual ~DomException() throw() {}
    virtual std::string getMsg() {
      std::string msg = m_name + ": " + m_extra;
      return msg;}
    virtual const char* what() {
      return m_extra.c_str();
    }
  protected: 
    std::string m_name;
  private:
    std::string m_extra;
  };

  class NullNode : public DomException {
  public:
    NullNode(const std::string& extraInfo = "") : DomException(extraInfo) 
    {m_name = "NullNode";}
    virtual ~NullNode() throw() {}
  };

  class WrongAttributeType : public DomException {
  public:
    WrongAttributeType(const std::string& extraInfo = "") : 
      DomException(extraInfo) 
    {
      m_name = "WrongAttributeType";
    }
    virtual ~WrongAttributeType() throw() {}
  };

  class WrongNodeType : public DomException {
  public:
    WrongNodeType(const std::string& extraInfo = "") : 
      DomException(extraInfo) 
    {
      m_name = "WrongNodeType";
    }
    virtual ~WrongNodeType() throw() {}
  };

  //  XERCES_CPP_NAMESPACE_USE
  using XERCES_CPP_NAMESPACE_QUALIFIER DOMElement;
  using XERCES_CPP_NAMESPACE_QUALIFIER DOMNode;
  using XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument;
  class Dom {

  public: 
    static DOMElement*  findFirstChildByName(const DOMElement* parent, 
                                             const char* const name);
    static DOMElement*  findFirstChildByName(const DOMElement* parent, 
                                             const std::string name);
    

    static DOMElement* getSiblingElement(const DOMNode* child);

    static DOMElement*  getFirstChildElement(const DOMNode* parent);

    static DOMElement* getElementById(const DOMDocument* doc,
                                     const std::string& id);

    static std::string  getNodeName(const DOMNode* elt); 

    static std::string  getTagName(const DOMElement* node);


    static bool checkTagName(const DOMElement* element, 
                             const std::string& tagName);
   
    static void getChildrenByTagName(const DOMElement* parent, 
                                     const std::string& tagName,
                                     std::vector<DOMElement*>& children,
                                     bool clear = true);

    static void getDescendantsByTagName(const DOMElement* parent, 
                                        const std::string& tagName,
                                        std::vector<DOMElement*>& children,
                                        bool clear = true);

    static void getAttributeNodeMap(const DOMNode* elt,
                                    std::map<std::string, DOMNode*>& atts,
                                    bool clear = true);

    static bool hasAttribute(const DOMNode* elt, const char* attName);

    static std::string  getAttribute(const DOMElement* elt, 
                                     const char* attName);
    static std::string  getAttribute(const DOMElement* elt, 
                                     std::string attName);

    static std::string  getAttribute(const DOMNode* elt, 
                                     const char* attName);
    static std::string  getAttribute(const DOMNode* elt, 
                                     std::string attName);

    static double getDoubleAttribute(const DOMNode* elt, std::string attName);

    static unsigned getDoublesAttribute(const DOMNode* elt, 
                                        std::string attName,
                                        std::vector<double>& values, 
                                        bool clear=true);

    static unsigned getFloatsAttribute(const DOMNode* elt, 
                                       std::string attName,
                                       std::vector<float>& values, 
                                       bool clear=true);

    static int getIntAttribute(const DOMNode* elt, std::string attName);

    static unsigned getIntsAttribute(const DOMNode* elt, 
                                     std::string attName,
                                     std::vector<int>& values, 
                                     bool clear=true);

    static std::string getText(const DOMNode* textNode);

    static std::string getTextContent(const DOMElement* elt);

    //    static void         addAttribute(DOMElement* elt, const DomString& name, 
    //                                     double value);

    static void         addAttribute(DOMElement* elt, std::string name, 
                                     double value);

    static void         addAttribute(DOMElement* elt, std::string name, 
                                     int value);

    static void         addAttribute(DOMElement* elt, std::string name, 
                                     unsigned int value);

    static void         addAttribute(DOMElement* elt, std::string name, 
                                     std::string value);

    static void         addAttribute(DOMElement* elt, std::string name, 
                                     const char * const value);

    

    // Could get rid of prefix argument for non-pretty print

    static void         printElement(DOMNode* elt, std::ostream& out);


    static void         prettyPrintElement(DOMNode* elt, std::ostream& out,
                                           std::string prefix);

    static void         prune(DOMElement* elt);

    // Make EResolver, XmlParser and XmlErrorHandler friends so they can 
    // use transcode methods
    // friend class EResolver;
    //    friend class XmlErrorHandler;
    //    friend class XmlParser;
  private:


    static char*        transToChar(const XMLCh* const str);
    static char*        transToChar(const XMLCh* const str, unsigned int len);



    static XMLCh*       transToXMLCh(const char* const src);


    static unsigned int transBufSize;
    static char*        transBuf; /*< output buffer for \b transToChar */
    static unsigned int xmlchBufSize;
    static XMLCh*       xmlchBuf; /*< output buffer for \b transToXMLCh */
    static XERCES_CPP_NAMESPACE_QUALIFIER XMLLCPTranscoder* transcoder;
    static int          initTrans(); /*< set up buffers, make transcoder */

    static XMLCh*    xmlchStar;


  };
} // end namespace
#endif

---