compoundhandler.cpp

Doxygen的词根来源于Document（文档）和Oxygen（氧气）

/******************************************************************************
 *
 * $Id: compoundhandler.cpp,v 1.33 2002/10/13 21:01:58 dimitri Exp $
 *
 *
 * 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 "mainhandler.h"
#include "compoundhandler.h"
#include "dochandler.h"
#include "debug.h"
#include "graphhandler.h"
#include "sectionhandler.h"
#include "paramhandler.h"
#include "loamhandler.h"
#include "memberhandler.h"

//----------------------------------------------------------------------------

IncludeHandler::IncludeHandler(IBaseHandler *parent,const char *endtag) :
  m_parent(parent)
{
  addEndHandler(endtag,this,&IncludeHandler::endInclude);
}

IncludeHandler::~IncludeHandler()
{
}

void IncludeHandler::startInclude(const QXmlAttributes &attrib)
{
  m_curString = "";
  m_refId     = attrib.value("refid");
  m_isLocal   = attrib.value("local")=="yes";
  m_parent->setDelegate(this);
}

void IncludeHandler::endInclude()
{
  m_name = m_curString;
  m_parent->setDelegate(0);
  debug(2,"Found include %s\n",m_name.data());
}

//----------------------------------------------------------------------------

class CompoundIdIterator : public ICompoundIterator,
                           public QListIterator<QString>
{
  public:
    CompoundIdIterator(const MainHandler *m,const QList<QString> &list) :
      QListIterator<QString>(list), m_mainHandler(m) {}
    virtual ~CompoundIdIterator() {}

    virtual void toFirst()
    { 
      QListIterator<QString>::toFirst(); 
    }
    virtual void toLast()
    { 
      QListIterator<QString>::toLast(); 
    }
    virtual void toNext()
    { 
      QListIterator<QString>::operator++(); 
    }
    virtual void toPrev()
    { 
      QListIterator<QString>::operator--(); 
    }
    virtual ICompound *current() const
    { 
      QString *id = QListIterator<QString>::current(); 
      return id ? m_mainHandler->compoundById(*id) : 0;
    }
    virtual void release()
    { delete this; }

  private:
    const MainHandler *m_mainHandler;
};

//----------------------------------------------------------------------------

ICompound *RelatedCompound::compound() const 
{ 
  return m_parent->m_mainHandler->compoundById(m_id); 
}

//----------------------------------------------------------------------------

class CompoundErrorHandler : public QXmlErrorHandler
{
    public:
      virtual ~CompoundErrorHandler() {}
      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 CompoundTypeMap
{
  public:
    CompoundTypeMap()
    {
      m_map.setAutoDelete(TRUE);
      m_map.insert("class",    new int(ICompound::Class));
      m_map.insert("struct",   new int(ICompound::Struct));
      m_map.insert("union",    new int(ICompound::Union));
      m_map.insert("interface",new int(ICompound::Interface));
      m_map.insert("protocol", new int(ICompound::Protocol));
      m_map.insert("category", new int(ICompound::Category));
      m_map.insert("exception",new int(ICompound::Exception));
      m_map.insert("file",     new int(ICompound::File));
      m_map.insert("namespace",new int(ICompound::Namespace));
      m_map.insert("group",    new int(ICompound::Group));
      m_map.insert("page",     new int(ICompound::Page));
      m_map.insert("example",  new int(ICompound::Example));
      m_map.insert("dir",      new int(ICompound::Dir));
    }
    virtual ~CompoundTypeMap()
    {
    }
    ICompound::CompoundKind map(const QString &s)
    {
      int *val = m_map.find(s);
      if (val==0) 
      {
        debug(1,"Warning: `%s' is an invalid compound type\n",s.data());
        return ICompound::Invalid;
      }
      else return (ICompound::CompoundKind)*val;
    }
  private: 
    QDict<int> m_map;
};

static CompoundTypeMap *s_typeMap;

void compoundhandler_init()
{
  s_typeMap = new CompoundTypeMap;
}

void compoundhandler_exit()
{
  delete s_typeMap;
}

//----------------------------------------------------------------------------

CompoundHandler::CompoundHandler(const QString &xmlDir) 
  : m_titleHandler(0), 
    m_includeDependencyGraph(0), 
    m_includedByDependencyGraph(0), 
    m_templateParamList(0),
    m_brief(0), 
    m_detailed(0), 
    m_inheritanceGraph(0), 
    m_collaborationGraph(0),
    m_programListing(0),
    m_members(0),
    m_xmlDir(xmlDir), 
    m_refCount(1), 
    m_memberDict(257), 
    m_memberNameDict(257),
    m_mainHandler(0)
{
  m_superClasses.setAutoDelete(TRUE);
  m_subClasses.setAutoDelete(TRUE);
  m_sections.setAutoDelete(TRUE);
  m_memberNameDict.setAutoDelete(TRUE);
  m_innerCompounds.setAutoDelete(TRUE);
  m_includes.setAutoDelete(TRUE);
  m_includedBy.setAutoDelete(TRUE);

  addStartHandler("doxygen");
  addEndHandler("doxygen");
  
  addStartHandler("compounddef",this,&CompoundHandler::startCompound);
  addEndHandler("compounddef",this,&CompoundHandler::endCompound);

  addStartHandler("compoundname");
  addEndHandler("compoundname",this,&CompoundHandler::endCompoundName);

  addStartHandler("title",this,&CompoundHandler::startTitle);

  addStartHandler("basecompoundref",this,&CompoundHandler::startSuperClass);
  addEndHandler("basecompoundref",this,&CompoundHandler::endSuperClass);

  addStartHandler("derivedcompoundref",this,&CompoundHandler::startSubClass);
  addEndHandler("derivedcompoundref",this,&CompoundHandler::endSubClass);

  addStartHandler("includes",this,&CompoundHandler::startIncludes);
  addStartHandler("includedby",this,&CompoundHandler::startIncludedBy);

  addStartHandler("incdepgraph",this,&CompoundHandler::startIncludeDependencyGraph);

  addStartHandler("invincdepgraph",this,&CompoundHandler::startIncludedByDependencyGraph);

  addStartHandler("innerdir",this,&CompoundHandler::startInnerDir);
  addEndHandler("innerdir");

  addStartHandler("innerfile",this,&CompoundHandler::startInnerFile);
  addEndHandler("innerfile");

  addStartHandler("innerclass",this,&CompoundHandler::startInnerClass);
  addEndHandler("innerclass");

  addStartHandler("innernamespace",this,&CompoundHandler::startInnerNamespace);
  addEndHandler("innernamespace");

  addStartHandler("innerpage",this,&CompoundHandler::startInnerPage);
  addEndHandler("innerpage");
  
  addStartHandler("innergroup",this,&CompoundHandler::startInnerGroup);
  addEndHandler("innergroup");

  addStartHandler("templateparamlist",this,&CompoundHandler::startTemplateParamList);

  addStartHandler("sectiondef",this,&CompoundHandler::startSection);

  addStartHandler("briefdescription",this,&CompoundHandler::startBriefDesc);

  addStartHandler("detaileddescription",this,&CompoundHandler::startDetailedDesc);
  
  addStartHandler("inheritancegraph",this,&CompoundHandler::startInheritanceGraph);
  
  addStartHandler("collaborationgraph",this,&CompoundHandler::startCollaborationGraph);

  addStartHandler("programlisting",this,&CompoundHandler::startProgramListing);

  addStartHandler("location",this,&CompoundHandler::startLocation);
  addEndHandler("location");

  addStartHandler("listofallmembers",this,&CompoundHandler::startListOfAllMembers);
}

CompoundHandler::~CompoundHandler()
{
  debug(2,"CompoundHandler::~CompoundHandler()\n");
  delete m_titleHandler;
  delete m_brief;
  delete m_detailed;
  delete m_programListing;
  delete m_inheritanceGraph;
  delete m_collaborationGraph;
  delete m_includeDependencyGraph;
  delete m_includedByDependencyGraph;
  delete m_templateParamList;
  delete m_members;
}

void CompoundHandler::startSection(const QXmlAttributes& attrib)
{
  SectionHandler *sectHandler = new SectionHandler(this);
  sectHandler->startSection(attrib);
  m_sections.append(sectHandler);
}

void CompoundHandler::startBriefDesc(const QXmlAttributes& attrib)
{
  DocHandler *docHandler = new DocHandler(this);
  docHandler->startDoc(attrib);
  m_brief = docHandler;
}

void CompoundHandler::startDetailedDesc(const QXmlAttributes& attrib)
{
  DocHandler *docHandler = new DocHandler(this);
  docHandler->startDoc(attrib);
  m_detailed = docHandler;
}

void CompoundHandler::startProgramListing(const QXmlAttributes& attrib)
{
  ProgramListingHandler *plHandler = new ProgramListingHandler(this);
  plHandler->startProgramListing(attrib);
  m_programListing = plHandler;
}

void CompoundHandler::startIncludes(const QXmlAttributes& attrib)
{
  IncludeHandler *inc = new IncludeHandler(this,"includes");
  m_includes.append(inc);
  inc->startInclude(attrib);
}

void CompoundHandler::startIncludedBy(const QXmlAttributes& attrib)
{
  IncludeHandler *inc = new IncludeHandler(this,"includedby");
  m_includedBy.append(inc);
  inc->startInclude(attrib);
}

void CompoundHandler::startCompound(const QXmlAttributes& attrib)
{
  m_id         = attrib.value("id");
  m_kindString = attrib.value("kind");
  m_kind       = s_typeMap->map(m_kindString);