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

Aller à la documentation de ce fichier.

/* This file is part of the KDE project
   Copyright (C) 2004 David Faure <faure@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 XMLWRITER_H
#define XMLWRITER_H

#include <QString>
#include <QStack>
#include <QMap>
#include <QIODevice>
#include <koffice_export.h>


class KOSTORE_EXPORT KoXmlWriter
{
public:
    KoXmlWriter( QIODevice* dev, int indentLevel = 0 );

    ~KoXmlWriter();

    QIODevice *device() const { return m_dev; }

    void startDocument( const char* rootElemName, const char* publicId = 0, const char* systemId = 0 );

    void endDocument();

    void startElement( const char* tagName, bool indentInside = true );

    inline void addAttribute( const char* attrName, const QString& value ) {
        addAttribute( attrName, value.toUtf8() );
    }
    inline void addAttribute( const char* attrName, int value ) {
        addAttribute( attrName, QByteArray::number( value ) );
    }
    inline void addAttribute( const char* attrName, uint value ) {
        addAttribute( attrName, QByteArray::number( value ) );
    }
    void addAttribute( const char* attrName, double value );
    void addAttributePt( const char* attrName, double value );

    void addAttribute( const char* attrName, const QByteArray& value );

    void addAttribute( const char* attrName, const char* value );
    void endElement();
    inline void addTextNode( const QString& str ) {
        addTextNode( str.toUtf8() );
    }
    void addTextNode( const QByteArray& cstr );
    void addTextNode( const char* cstr );

    void addProcessingInstruction( const char* cstr );

    void addCompleteElement( const char* cstr );

    void addCompleteElement( QIODevice* dev );

    // #### Maybe we want to subclass KoXmlWriter for manifest files.
    void addManifestEntry( const QString& fullPath, const QString& mediaType );

    void addConfigItem( const QString & configName, const QString& value );
    void addConfigItem( const QString & configName, bool value );
    void addConfigItem( const QString & configName, int value );
    void addConfigItem( const QString & configName, double value );
    void addConfigItem( const QString & configName, long value );
    void addConfigItem( const QString & configName, short value );

    // TODO addConfigItem for datetime and base64Binary

    void addTextSpan( const QString& text );
    void addTextSpan( const QString& text, const QMap<int, int>& tabCache );

    int indentLevel() const { return m_tags.size() + m_baseIndentLevel; }

private:
    struct Tag {
        Tag( const char* t = 0, bool ind = true )
            : tagName( t ), hasChildren( false ), lastChildIsText( false ),
              openingTagClosed( false ), indentInside( ind ) {}
        const char* tagName;
        bool hasChildren; 
        bool lastChildIsText; 
        bool openingTagClosed; 
        bool indentInside; 
    };

    void writeIndent();

    // writeCString is much faster than writeString.
    // Try to use it as much as possible, especially with constants.
    void writeString( const QString& str );

    // unused and possibly incorrect if length != size
    //inline void writeCString( const QCString& cstr ) {
    //    m_dev->write( cstr.data(), cstr.size() - 1 );
    //}

    inline void writeCString( const char* cstr ) {
        m_dev->write( cstr, qstrlen( cstr ) );
    }
    inline void writeChar( char c ) {
        m_dev->putChar( c );
    }
    inline void closeStartElement( Tag& tag ) {
        if ( !tag.openingTagClosed ) {
            tag.openingTagClosed = true;
            writeChar( '>' );
        }
    }
    char* escapeForXML( const char* source, int length ) const;
    bool prepareForChild();
    void prepareForTextNode();
    void init();

    QIODevice* m_dev;
    QStack<Tag> m_tags;
    int m_baseIndentLevel;

    class Private;
    Private *d;

    char* m_indentBuffer; // maybe make it static, but then it needs a KStaticDeleter,
                          // and would eat 1K all the time... Maybe refcount it :)
    char* m_escapeBuffer; // can't really be static if we want to be thread-safe
    static const int s_escapeBufferLen = 10000;

    KoXmlWriter( const KoXmlWriter & ); // forbidden
    KoXmlWriter& operator=( const KoXmlWriter & ); // forbidden
};

#endif /* XMLWRITER_H */

---