--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/Orb/Doxygen/addon/doxmlparser/src/mainhandler.cpp Thu Jan 21 17:29:01 2010 +0000
@@ -0,0 +1,299 @@
+/******************************************************************************
+ *
+ * $Id: mainhandler.cpp 645 2008-08-19 13:23:22Z dimitri $
+ *
+ *
+ * Copyright (C) 1997-2006 by Dimitri van Heesch.
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation under the terms of the GNU General Public License is hereby
+ * granted. No representations are made about the suitability of this software
+ * for any purpose. It is provided "as is" without express or implied warranty.
+ * See the GNU General Public License for more details.
+ *
+ */
+
+#include <qxml.h>
+#include "mainhandler.h"
+#include "compoundhandler.h"
+#include "sectionhandler.h"
+#include "graphhandler.h"
+#include "dochandler.h"
+#include "memberhandler.h"
+#include "debug.h"
+
+
+class ErrorHandler : public QXmlErrorHandler
+{
+ public:
+ virtual ~ErrorHandler() {}
+ bool warning( const QXmlParseException & )
+ {
+ return FALSE;
+ }
+ bool error( const QXmlParseException & )
+ {
+ return FALSE;
+ }
+ bool fatalError( const QXmlParseException &exception )
+ {
+ debug(1,"Fatal error at line %d column %d: %s\n",
+ exception.lineNumber(),exception.columnNumber(),
+ exception.message().data());
+ return FALSE;
+ }
+ QString errorString() { return ""; }
+
+ private:
+ QString errorMsg;
+};
+
+//--------------------------------------------------------------------------
+
+class CompoundEntryIterator : public ICompoundIterator,
+ public QListIterator<CompoundEntry>
+{
+ public:
+ CompoundEntryIterator(const MainHandler *m,const QList<CompoundEntry> &list) :
+ QListIterator<CompoundEntry>(list), m_mainHandler(m) {}
+ virtual ~CompoundEntryIterator() {}
+
+ virtual void toFirst()
+ {
+ QListIterator<CompoundEntry>::toFirst();
+ }
+ virtual void toLast()
+ {
+ QListIterator<CompoundEntry>::toLast();
+ }
+ virtual void toNext()
+ {
+ QListIterator<CompoundEntry>::operator++();
+ }
+ virtual void toPrev()
+ {
+ QListIterator<CompoundEntry>::operator--();
+ }
+ virtual ICompound *current() const
+ {
+ CompoundEntry *ch = QListIterator<CompoundEntry>::current();
+ return ch ? m_mainHandler->compoundById(ch->id) : 0;
+ }
+ virtual void release()
+ { delete this; }
+
+ private:
+ const MainHandler *m_mainHandler;
+};
+
+//--------------------------------------------------------------------------
+
+MainHandler::MainHandler() : m_compoundDict(2999), m_compoundNameDict(2999),
+ m_memberDict(12251), m_memberNameDict(12251),
+ m_compoundsLoaded(1009)
+{
+ m_compounds.setAutoDelete(TRUE);
+ m_memberNameDict.setAutoDelete(TRUE);
+ addStartHandler("doxygenindex");
+ addEndHandler("doxygenindex");
+ addStartHandler("compound",this,&MainHandler::startCompound);
+ addEndHandler("compound");
+ addStartHandler("member",this,&MainHandler::startMember);
+ addEndHandler("member",this,&MainHandler::endMember);
+ addStartHandler("name",this,&MainHandler::startName);
+ addEndHandler("name",this,&MainHandler::endName);
+ m_curCompound = 0;
+ m_insideMember = FALSE;
+}
+
+MainHandler::~MainHandler()
+{
+ debug(2,"MainHandler::~MainHandler()\n");
+}
+
+void MainHandler::startCompound(const QXmlAttributes& attrib)
+{
+ m_curCompound = new CompoundEntry(257);
+ m_curCompound->id = attrib.value("refid");
+ m_compounds.append(m_curCompound);
+ m_compoundDict.insert(m_curCompound->id,m_curCompound);
+}
+
+void MainHandler::startName(const QXmlAttributes& /*attrib*/)
+{
+ m_curString = "";
+}
+
+void MainHandler::endName()
+{
+ if (m_insideMember)
+ {
+ m_curMember->name = m_curString;
+ }
+ else
+ {
+ m_curCompound->name = m_curString;
+ m_compoundNameDict.insert(m_curString,m_curCompound);
+ }
+}
+
+void MainHandler::startMember(const QXmlAttributes& attrib)
+{
+ m_insideMember = TRUE;
+ m_curMember = new MemberEntry;
+ m_curMember->id = attrib.value("refid");
+ m_curMember->compound = m_curCompound;
+ m_memberDict.insert(m_curMember->id,m_curMember);
+}
+
+void MainHandler::endMember()
+{
+ m_curCompound->memberDict.insert(m_curMember->name,m_curMember);
+ QList<CompoundEntry> *cel=0;
+ if ((cel=m_memberNameDict.find(m_curMember->name))==0)
+ {
+ cel = new QList<CompoundEntry>;
+ m_memberNameDict.insert(m_curMember->name,cel);
+ }
+ cel->append(m_curCompound);
+ m_insideMember = FALSE;
+}
+
+void MainHandler::setDebugLevel(int level)
+{
+ ::setDebugLevel(level);
+}
+
+void MainHandler::dump()
+{
+ QListIterator<CompoundEntry> cli(m_compounds);
+ CompoundEntry *ce;
+ for (cli.toFirst();(ce=cli.current());++cli)
+ {
+ debug(2,"compound id=`%s' name=`%s'\n",ce->id.data(),ce->name.data());
+ QDictIterator<MemberEntry> mdi(ce->memberDict);
+ MemberEntry *me;
+ for (mdi.toFirst();(me=mdi.current());++mdi)
+ {
+ debug(2," member id=`%s' name=`%s'\n",me->id.data(),me->name.data());
+ }
+ }
+}
+
+bool MainHandler::readXMLDir(const char * xmlDirName)
+{
+ m_xmlDirName = xmlDirName;
+ QString xmlFileName=m_xmlDirName+"/index.xml";
+ QFile xmlFile(xmlFileName);
+ //printf("Trying %s xmlFile.exists()=%d isReadable()=%d\n",
+ // xmlFileName.data(),xmlFile.exists(),xmlFile.isReadable());
+ if (xmlFile.exists())
+ {
+ ErrorHandler errorHandler;
+ QXmlInputSource source( xmlFile );
+ QXmlSimpleReader reader;
+ reader.setContentHandler( this );
+ reader.setErrorHandler( &errorHandler );
+ reader.parse( source );
+ dump();
+ return TRUE;
+ }
+ return FALSE;
+}
+
+ICompoundIterator *MainHandler::compounds() const
+{
+ return new CompoundEntryIterator(this,m_compounds);
+}
+
+ICompound *MainHandler::compoundById(const char *id) const
+{
+ QString ids = id;
+ if (ids.isEmpty()) return 0;
+ CompoundHandler *ch = m_compoundsLoaded[ids];
+ if (ch) // compound already in memory
+ {
+ ch->addref(); // returning alias -> increase reference counter
+ return ch->toICompound();
+ }
+ CompoundEntry *ce = m_compoundDict.find(ids);
+ if (ce==0) return 0; // id not found
+ // create and load a new compound
+ ch = new CompoundHandler(m_xmlDirName);
+ if (!ch->parseXML(id))
+ {
+ // compound could not be initialized.
+ delete ch;
+ return 0;
+ }
+
+ // we disregard the constness here, because the object stays conceptually
+ // unchanged.
+ MainHandler *that = (MainHandler *)this;
+ ch->initialize(that);
+ //printf("loading compound %s in memory\n",id);
+ that->m_compoundsLoaded.insert(id,ch);
+ return ch->toICompound();
+}
+
+void MainHandler::unloadCompound(CompoundHandler *ch)
+{
+ //printf("unloading compound %s from memory\n",ch->id()->latin1());
+ bool result = m_compoundsLoaded.remove(ch->id()->latin1());
+ if (!result) debug(1,"Failed to unload component!\n");
+}
+
+ICompound *MainHandler::compoundByName(const char *name) const
+{
+ QString nameStr = name;
+ if (nameStr.isEmpty()) return 0;
+ CompoundEntry *ce = m_compoundNameDict[name];
+ if (ce==0) return 0; // name not found
+ return compoundById(ce->id);
+}
+
+ICompound *MainHandler::memberById(const char *id) const
+{
+ QString ids = id;
+ if (ids.isEmpty()) return 0;
+ MemberEntry *me = m_memberDict[id];
+ if (me==0) return 0; // id not found
+ return compoundById(me->compound->id);
+}
+
+ICompoundIterator *MainHandler::memberByName(const char *name) const
+{
+ QString nameStr = name;
+ if (nameStr.isEmpty()) return 0;
+ QList<CompoundEntry> *cel = m_memberNameDict[name];
+ if (cel==0) return 0; // name not found
+ return new CompoundEntryIterator(this,*cel);
+}
+
+IDoxygen *createObjectModel()
+{
+ compoundhandler_init();
+ sectionhandler_init();
+ memberhandler_init();
+ dochandler_init();
+ graphhandler_init();
+ return new MainHandler;
+}
+
+void MainHandler::release()
+{
+ //printf("MainHandler::release()\n");
+ QDictIterator<CompoundHandler> chi(m_compoundsLoaded);
+ CompoundHandler *ch;
+ for (chi.toFirst();(ch=chi.current());++chi)
+ {
+ debug(1,"Compound %s not released\n",ch->name()->latin1());
+ }
+ graphhandler_exit();
+ dochandler_exit();
+ memberhandler_exit();
+ sectionhandler_exit();
+ compoundhandler_exit();
+ delete this;
+}
+