xmlparse.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */
 
#ifndef INCLUDED_L10NTOOLS_INC_XMLPARSE_HXX
#define INCLUDED_L10NTOOLS_INC_XMLPARSE_HXX
 
#include <sal/config.h>
 
#include <cstddef>
#include <memory>
#include <utility>
#include <vector>
 
#include <expat.h>
 
#include <rtl/string.hxx>
#include <rtl/strbuf.hxx>
#include <unordered_map>
 
class XMLParentNode;
class XMLElement;
 
enum class XMLNodeType{
    XFILE   = 0x001,
    ELEMENT = 0x002,
    DATA    = 0x003,
    COMMENT = 0x004,
    DEFAULT = 0x005
};
 
class XMLAttribute
{
private:
    OString m_sName;
    OString m_sValue;
 
public:
    XMLAttribute(
        OString _sName,    // attributes name
        OString _sValue    // attributes data
    )
    : m_sName( std::move(_sName) ), m_sValue( std::move(_sValue) ) {}
 
    const OString& GetName() const { return m_sName; }
    const OString& GetValue() const { return m_sValue; }
 
    void setValue( const OString &rValue ){ m_sValue = rValue; }
};
 
 
typedef std::vector< XMLAttribute* > XMLAttributeList;
 
class XMLNode
{
protected:
    XMLNode(){}
 
public:
    virtual XMLNodeType GetNodeType() const = 0;
    virtual ~XMLNode(){}
 
    XMLNode(XMLNode const &) = default;
    XMLNode(XMLNode &&) = default;
    XMLNode & operator =(XMLNode const &) = default;
    XMLNode & operator =(XMLNode &&) = default;
};
 
 
class XMLChildNode : public XMLNode
{
private:
    XMLParentNode *m_pParent;
 
protected:
    XMLChildNode( XMLParentNode *pPar );
    XMLChildNode( const XMLChildNode& rObj);
    XMLChildNode& operator=(const XMLChildNode& rObj);
public:
    XMLParentNode *GetParent() { return m_pParent; }
};
 
typedef std::vector< XMLChildNode* > XMLChildNodeList;
 
class XMLData;
 
class XMLParentNode : public XMLChildNode
{
private:
    std::unique_ptr<XMLChildNodeList> m_pChildList;
 
protected:
    XMLParentNode( XMLParentNode *pPar )
        : XMLChildNode( pPar ) {}
 
    XMLParentNode( const XMLParentNode& );
 
    XMLParentNode& operator=(const XMLParentNode& rObj);
    virtual ~XMLParentNode() override;
 
public:
    XMLChildNodeList *GetChildList() { return m_pChildList.get(); }
 
    void AddChild(
        XMLChildNode *pChild    
    );
 
    void RemoveAndDeleteAllChildren();
};
 
typedef std::unordered_map<OString, XMLElement*> LangHashMap;
 
typedef std::unordered_map<OString, LangHashMap*> XMLHashMap;
 
class XMLFile final : public XMLParentNode
{
public:
    XMLFile(
        OString sFileName // the file name, empty if created from memory stream
    );
    XMLFile( const XMLFile& rObj ) ;
    virtual ~XMLFile() override;
 
    void Print( XMLNode *pCur, sal_uInt16 nLevel = 0 );
    void SearchL10NElements( XMLChildNode *pCur );
    void Extract();
 
    XMLHashMap* GetStrings(){ return m_pXMLStrings.get(); }
    void Write( OString const &rFilename );
    void Write( std::ofstream &rStream, XMLNode *pCur = nullptr );
 
    bool CheckExportStatus( XMLChildNode *pCur = nullptr );
 
    XMLFile& operator=(const XMLFile& rObj);
 
    virtual XMLNodeType GetNodeType() const override { return XMLNodeType::XFILE; }
 
    const OString& GetName() const { return m_sFileName; }
    void SetName( const OString &rFilename ) { m_sFileName = rFilename; }
    const std::vector<OString>& getOrder() const { return m_vOrder; }
 
private:
 
    void InsertL10NElement( XMLElement* pElement);
 
    // DATA
    OString m_sFileName;
 
    std::unordered_map<OString, bool> m_aNodes_localize;
 
    std::unique_ptr<XMLHashMap> m_pXMLStrings;
 
    std::vector <OString> m_vOrder;
};
 
class XMLUtil
{
public:
    static OString QuotHTML( const OString& rString );
};
 
 
class XMLElement : public XMLParentNode
{
private:
    OString m_sElementName;
    std::unique_ptr<XMLAttributeList> m_pAttributes;
 
protected:
    void Print(XMLNode *pCur, OStringBuffer& rBuffer, bool bRootelement) const;
public:
    XMLElement(
        OString sName,    // the element name
        XMLParentNode *pParent   // parent node of this element
    );
 
    virtual ~XMLElement() override;
    XMLElement(const XMLElement&);
 
    XMLElement& operator=(const XMLElement& rObj);
    virtual XMLNodeType GetNodeType() const override { return XMLNodeType::ELEMENT; }
 
    const OString& GetName() const { return m_sElementName; }
 
    XMLAttributeList *GetAttributeList() { return m_pAttributes.get(); }
 
    void AddAttribute( const OString &rAttribute, const OString &rValue );
 
    void ChangeLanguageTag( const OString &rValue );
 
    OString ToOString();
};
 
class XMLData : public XMLChildNode
{
private:
    OString m_sData;
 
public:
    XMLData(
        OString _sData,    // the initial data
        XMLParentNode *pParent   // the parent node of this data, typically an element node
    ) : XMLChildNode( pParent ), m_sData( std::move(_sData) ) {}
 
    // Default copy constructor and copy operator work well.
 
    virtual XMLNodeType GetNodeType() const override { return XMLNodeType::DATA; }
 
    const OString& GetData() const { return m_sData; }
 
    void AddData( const OString &rData ) { m_sData += rData; }
};
 
class XMLComment final : public XMLChildNode
{
private:
    OString m_sComment;
 
public:
    XMLComment(
        OString _sComment, // the comment
        XMLParentNode *pParent   // the parent node of this comment, typically an element node
    )
        : XMLChildNode( pParent ), m_sComment( std::move(_sComment) ) {}
 
    // Default copy constructor and copy operator work well.
 
    virtual XMLNodeType GetNodeType() const override { return XMLNodeType::COMMENT; }
 
    const OString& GetComment() const { return m_sComment; }
};
 
class XMLDefault final : public XMLChildNode
{
private:
    OString m_sDefault;
 
public:
    XMLDefault(
        OString _sDefault, // the comment
        XMLParentNode *pParent   // the parent node of this comment, typically an element node
    )
        : XMLChildNode( pParent ), m_sDefault( std::move(_sDefault) ) {}
 
    // Default copy constructor and copy operator work well.
 
    virtual XMLNodeType GetNodeType() const override { return XMLNodeType::DEFAULT; }
 
    const OString& GetDefault() const { return m_sDefault; }
};
 
struct XMLError {
    XML_Error m_eCode;    
    std::size_t m_nLine; 
    std::size_t m_nColumn; 
    OString m_sMessage;    
};
 
class SimpleXMLParser
{
private:
    XML_Parser m_aParser;
    XMLError m_aErrorInformation;
 
    XMLParentNode *m_pCurNode;
    XMLData *m_pCurData;
 
 
    static void StartElementHandler( void *userData, const XML_Char *name, const XML_Char **atts );
    static void EndElementHandler( void *userData, const XML_Char *name );
    static void CharacterDataHandler( void *userData, const XML_Char *s, int len );
    static void CommentHandler( void *userData, const XML_Char *data );
    static void DefaultHandler( void *userData, const XML_Char *s, int len );
 
 
    void StartElement( const XML_Char *name, const XML_Char **atts );
    void EndElement();
    void CharacterData( const XML_Char *s, int len );
    void Comment( const XML_Char *data );
    void Default( const XML_Char *s, int len );
 
public:
    SimpleXMLParser();
    ~SimpleXMLParser();
 
    bool Execute(
        const OString &rFileName,    // the file name
        XMLFile* pXMLFile  // the XMLFile
    );
 
    const XMLError &GetError() const { return m_aErrorInformation; }
};
 
#endif // INCLUDED_L10NTOOLS_INC_XMLPARSE_HXX
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */