F:/KPlato/koffice/libs/store/KoXmlReader.h

Aller à la documentation de ce fichier.

/* This file is part of the KDE project
   Copyright (C) 2005-2006 Ariya Hidayat <ariya@kde.org>

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.

   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
*/

#ifndef KOFFICE_XMLREADER
#define KOFFICE_XMLREADER

// use standard QDom, useful to test KoXml classes against Qt's QDom
#define KOXML_USE_QDOM

#include <koffice_export.h>

#include <qxml.h>
#include <qdom.h>

class QIODevice;
class QTextDecoder;

#ifdef KOXML_USE_QDOM

typedef QDomNode KoXmlNode;
typedef QDomElement KoXmlElement;
typedef QDomText KoXmlText;
typedef QDomCDATASection KoXmlCDATASection;
typedef QDomDocument KoXmlDocument;

#else

class QString;
class QXmlReader;
class QXmlInputSource;

class KoXmlElement;
class KoXmlText;
class KoXmlCDATASection;
class KoXmlDocument;
class KoXmlNodeData;

class KOSTORE_EXPORT KoXmlNode
{
public:

  enum NodeType 
  {
    NullNode = 0,
    ElementNode,
    TextNode,
    CDATASectionNode,
    ProcessingInstructionNode,
    DocumentNode 
  };

  KoXmlNode();
  KoXmlNode( const KoXmlNode& node );
  KoXmlNode& operator=( const KoXmlNode& node );
  bool operator== ( const KoXmlNode& ) const;
  bool operator!= ( const KoXmlNode& ) const;
  virtual ~KoXmlNode();

  virtual KoXmlNode::NodeType nodeType() const;
  virtual bool isNull() const;
  virtual bool isElement() const;
  virtual bool isText() const;
  virtual bool isCDATASection() const;
  virtual bool isDocument() const;

  virtual void clear();
  KoXmlElement toElement() const;
  KoXmlText toText() const;
  KoXmlCDATASection toCDATASection() const;
  KoXmlDocument toDocument() const;

  virtual QString nodeName() const;
  virtual QString namespaceURI() const;
  virtual QString prefix() const;
  virtual QString localName() const;

  KoXmlDocument ownerDocument() const;
  KoXmlNode parentNode() const;

  bool hasChildNodes() const;
  KoXmlNode firstChild() const;
  KoXmlNode lastChild() const;
  KoXmlNode nextSibling() const;
  KoXmlNode previousSibling() const;
  
  // equivalen to node.childNodes().count() if node is a QDomNode instance
  int childNodesCount() const;

  KoXmlNode namedItem( const QString& name ) const;
  KoXmlNode namedItemNS( const QString& nsURI, const QString& name ) const;

  void load( int depth=1 );

  void unload();

  // compatibility
  QDomNode asQDomNode( QDomDocument ownerDoc ) const;

protected:
  KoXmlNodeData* d;
  KoXmlNode( KoXmlNodeData* );
};

class KOSTORE_EXPORT KoXmlElement: public KoXmlNode
{
public:
  KoXmlElement();
  KoXmlElement( const KoXmlElement& element );
  KoXmlElement& operator=( const KoXmlElement& element );
  virtual ~KoXmlElement();
  bool operator== ( const KoXmlElement& ) const;
  bool operator!= ( const KoXmlElement& ) const;

  QString tagName() const;
  QString text() const;

  QString attribute( const QString& name ) const;
  QString attribute( const QString& name, const QString& defaultValue ) const;
  QString attributeNS( const QString& namespaceURI, const QString& localName, 
    const QString& defaultValue ) const;
  bool hasAttribute( const QString& name ) const;
  bool hasAttributeNS( const QString& namespaceURI, const QString& localName ) const;

private:
  friend class KoXmlNode;
  friend class KoXmlDocument;
  KoXmlElement( KoXmlNodeData* );
};

class KOSTORE_EXPORT KoXmlText: public KoXmlNode
{
public:
  KoXmlText();
  KoXmlText( const KoXmlText& text );
  KoXmlText& operator=( const KoXmlText& text );
  virtual ~KoXmlText();

  QString data() const;
  void setData( const QString& data );
  virtual bool isText() const;

private:
  friend class KoXmlNode;
  friend class KoXmlCDATASection;
  friend class KoXmlDocument;
  KoXmlText( KoXmlNodeData* );
};

class KOSTORE_EXPORT KoXmlCDATASection: public KoXmlText
{
public:
  KoXmlCDATASection();
  KoXmlCDATASection( const KoXmlCDATASection& cdata );
  KoXmlCDATASection& operator=( const KoXmlCDATASection& cdata );
  virtual ~KoXmlCDATASection();

  virtual bool isCDATASection() const;

private:
  friend class KoXmlNode;
  friend class KoXmlDocument;
  KoXmlCDATASection( KoXmlNodeData* );
};

class KOSTORE_EXPORT KoXmlDocument: public KoXmlNode
{
public:
  KoXmlDocument();
  KoXmlDocument( const KoXmlDocument& node );
  KoXmlDocument& operator=( const KoXmlDocument& node );
  bool operator==( const KoXmlDocument& ) const;
  bool operator!=( const KoXmlDocument& ) const;
  virtual ~KoXmlDocument();

  KoXmlElement documentElement() const;

  virtual QString nodeName() const;
  virtual void clear();

  bool setContent( QIODevice* device, bool namespaceProcessing, 
    QString* errorMsg = 0, int* errorLine = 0, int* errorColumn = 0 );
  bool setContent( QIODevice* device, 
    QString* errorMsg = 0, int* errorLine = 0, int* errorColumn = 0 );
  bool setContent( QXmlInputSource *source, QXmlReader *reader, 
    QString* errorMsg = 0, int* errorLine = 0, int* errorColumn = 0 );
  bool setContent( const QByteArray& text, bool namespaceProcessing,
    QString *errorMsg=0, int *errorLine=0, int *errorColumn=0  );    
  bool setContent( const QString& text, bool namespaceProcessing, 
    QString *errorMsg=0, int *errorLine=0, int *errorColumn=0  );
    
  // no namespace processing
  bool setContent( const QString& text, 
    QString *errorMsg=0, int *errorLine=0, int *errorColumn=0  );

private:
  friend class KoXmlNode;
  KoXmlDocument( KoXmlNodeData* );
};

#endif // KOXML_USE_QDOM

class KOSTORE_EXPORT KoXmlInputSource: public QXmlInputSource
{
public:
  KoXmlInputSource(QIODevice *dev);
  ~KoXmlInputSource();

  virtual void setData(const QString& dat);
  virtual void setData(const QByteArray& dat);
  virtual void fetchData();
  virtual QString data() const;
  virtual QChar next();
  virtual void reset();

protected:
  virtual QString fromRawData(const QByteArray &data, bool beginning = false);
    
private:
  QIODevice* device;
  QTextDecoder* decoder;
  QString stringData;
  int stringLength;
  int stringIndex;
  char* buffer;
};

namespace KoXml {

    KOSTORE_EXPORT KoXmlElement namedItemNS( const KoXmlNode& node, 
        const char* nsURI, const char* localName );

    KOSTORE_EXPORT void load( KoXmlNode& node, int depth = 1 );

    KOSTORE_EXPORT void unload( KoXmlNode& node );
    
    KOSTORE_EXPORT int childNodesCount( const KoXmlNode& node );
    
        KOSTORE_EXPORT QDomNode asQDomNode( QDomDocument ownerDoc, const KoXmlNode& node );
        KOSTORE_EXPORT QDomElement asQDomElement( QDomDocument ownerDoc, const KoXmlElement& element );
        KOSTORE_EXPORT QDomDocument asQDomDocument( QDomDocument ownerDoc, const KoXmlDocument& document );

    /*
     * Load an XML document from specified device to a document. You can of 
     * course use it with QFile (which inherits QIODevice).     
     * This is much more memory efficient than standard QDomDocument::setContent
     * because the data from the device is buffered, unlike 
     * QDomDocument::setContent which just loads everything in memory.
     * 
     * Note: it is assumed that the XML uses UTF-8 encoding.          
     */     
    KOSTORE_EXPORT bool setDocument( KoXmlDocument& doc, QIODevice* device,
      bool namespaceProcessing, QString* errorMsg = 0, 
          int* errorLine = 0, int* errorColumn = 0 );

    KOSTORE_EXPORT bool setDocument( KoXmlDocument& doc, QIODevice* device,
      QXmlSimpleReader* reader, QString* errorMsg = 0, 
          int* errorLine = 0, int* errorColumn = 0 );
}

#define forEachElement( elem, parent ) \
      for ( KoXmlNode _node = parent.firstChild(); !_node.isNull(); _node = _node.nextSibling() ) \
        if ( !( elem = _node.toElement() ).isNull() )


#endif // KOFFICE_XMLREADER

---