DinoXmlParser.h

Go to the documentation of this file.

/*
 * $Revision: 2299 $
 * 
 * last checkin:
 *   $Author: gutwenger $ 
 *   $Date: 2012-05-07 15:57:08 +0200 (Mon, 07 May 2012) $ 
 ***************************************************************/
 
#ifdef _MSC_VER
#pragma once
#endif

#ifndef OGDF_DINO_XML_PARSER_H
#define OGDF_DINO_XML_PARSER_H

#include <ogdf/basic/Stack.h>
#include <ogdf/basic/String.h>
#include <ogdf/basic/Hashing.h>
#include <ogdf/basic/GraphAttributes.h>
#include <ogdf/fileformats/DinoXmlScanner.h>



namespace ogdf {

    //---------------------------------------------------------
    // H a s h e d S t r i n g
    //---------------------------------------------------------

    typedef HashElement<String,int> HashedString;

    //---------------------------------------------------------
    // X m l A t t r i b u t e O b j e c t
    //---------------------------------------------------------
    struct OGDF_EXPORT XmlAttributeObject {
        
        HashedString *m_pAttributeName;
        
        HashedString *m_pAttributeValue;

        XmlAttributeObject *m_pNextAttribute;

        XmlAttributeObject(HashedString *name, HashedString *value) :
            m_pAttributeName(name),
            m_pAttributeValue(value),
            m_pNextAttribute(0)
            {};

        ~XmlAttributeObject(){};

        bool m_valid;

        const String& getName() const {
            return m_pAttributeName->key(); 
        }

        const String& getValue() const {
            return m_pAttributeValue->key();    
        }

        const bool& valid() const {
            return m_valid;
        }

        void setValid() {
            m_valid = true;
        }

        void setInvalid() {
            m_valid = false;    
        }

        // Overloaded new and delete operators
        OGDF_NEW_DELETE

    }; // struct XmlAttributeObject

    //---------------------------------------------------------
    // X m l T a g O b j e c t
    //---------------------------------------------------------
    struct OGDF_EXPORT XmlTagObject {

        HashedString *m_pTagName;

        XmlAttributeObject *m_pFirstAttribute;

        HashedString *m_pTagValue;

        XmlTagObject *m_pFirstSon;
            
        XmlTagObject *m_pBrother;

        XmlTagObject(HashedString *name) :
            m_pTagName(name),
            m_pFirstAttribute(0),
            m_pTagValue(0),
            m_pFirstSon(0),
            m_pBrother(0),
            m_valid(0)
            {};

        ~XmlTagObject(){};

        mutable bool m_valid;
        
        int m_depth;
        
         int m_line;
        
        public:

        bool isLeaf() const;

        bool findSonXmlTagObjectByName( const String sonsName,
                                        XmlTagObject *&son) const;

        bool findSonXmlTagObjectByName( const String sonsName,
                                        List<XmlTagObject*> &sons) const;

        bool hasMoreSonXmlTagObject(const List<String> &sonNamesToIgnore) const;

        bool findXmlAttributeObjectByName(const String attName,
                                           XmlAttributeObject*& attribute) const;
        
        bool isAttributeLess() const;

        const bool& valid() const {
            return m_valid; 
        }

        const String& getName() const {
            return m_pTagName->key();   
        }

        const String& getValue() const {
            return m_pTagValue->key();  
        }

        void setValid() const {
            m_valid = true;
        }

        void setInvalid() {
            m_valid = false;
        }
        
        /* get for depth of xml-tag-object */
        const int& getDepth() const {
            return m_depth; 
        }
        
        /* setter for new depth */
        void setDepth(int newDepth){
            m_depth = newDepth;
        }


        /* get for line of xml-tag-object */
        const int& getLine() const {
            return m_line;  
        }
        
        /* setter for line */
        void setLine(int line) {
            m_line = line;
        }

        // Overloaded new and delete operators
        OGDF_NEW_DELETE

    }; // struct XmlTagObject

    //---------------------------------------------------------
    // D i n o X m l P a r s e r 
    //---------------------------------------------------------
  class OGDF_EXPORT DinoXmlParser {

      friend ostream &operator<<(ostream&, const DinoXmlParser &);

    private:

        XmlTagObject *m_pRootTag;

        DinoXmlScanner *m_pScanner;

        Hashing<String,int> m_hashTable; 

        int m_hashTableInfoIndex;

        int m_recursionDepth;
        Stack<String> m_tagObserver;


    public:
        
        DinoXmlParser(const char *fileName);

        ~DinoXmlParser();

        void addNewHashElement(const String &key, int info){
            OGDF_ASSERT(info >= m_hashTableInfoIndex)
            m_hashTable.fastInsert(key, info);
            m_hashTableInfoIndex = info + 1;
        }

        void createParseTree();

        const XmlTagObject &getRootTag() const {
            return *m_pRootTag;
        }

        bool traversePath(const XmlTagObject &startTag, 
                          const Array<int> &infoIndexPath,
                          const XmlTagObject *&targetTag) const;

        bool findSonXmlTagObject(const XmlTagObject &father, 
                                 int sonInfoIndex,
                                 const XmlTagObject *&son) const;

        bool findBrotherXmlTagObject(const XmlTagObject &currentTag, 
                                     int brotherInfoIndex,
                                     const XmlTagObject *&brother) const;

        bool findXmlAttributeObject(const XmlTagObject &currentTag, 
                                    int attributeInfoIndex,
                                    const XmlAttributeObject *&attribute) const;
        
        inline int getInputFileLineCounter() const {
            return m_pScanner->getInputFileLineCounter();
        }

        void printHashTable(ostream &os);

    private:

        void destroyParseTree(XmlTagObject *root);

        XmlTagObject* parse();

        void appendAttributeObject(XmlTagObject *tagObject,
                                   XmlAttributeObject *attributeObject);
        
        void appendSonTagObject(XmlTagObject *currentTagObject, 
                                XmlTagObject *sonTagObject);

        HashedString *hashString(const String &str);

        void printXmlTagObjectTree(ostream &os, const XmlTagObject &rootObject, 
                                   int indent = 0) const;

        void printSpaces(ostream &os, int nOfSpaces) const;

    }; // class DinoXmlParser

    ostream &operator<<(ostream &os, const DinoXmlParser &parser);

} // end namespace ogdf

#endif