compoundhandler.cpp

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

  m_protection = attrib.value("prot");
  debug(2,"startCompound(id=`%s' type=`%s')\n",m_id.data(),m_kindString.data());
}

void CompoundHandler::endCompound()
{
   debug(2,"endCompound()\n");
}

void CompoundHandler::startLocation(const QXmlAttributes& attrib)
{
  m_defFile      = attrib.value("file");
  m_defLine      = attrib.value("line").toInt();
  m_defBodyFile  = attrib.value("bodyfile");
  m_defBodyStart = attrib.value("bodystart").toInt();
  m_defBodyEnd   = attrib.value("bodyend").toInt();
}

void CompoundHandler::endCompoundName()
{
  m_name = m_curString.stripWhiteSpace();
  debug(2,"Compound name `%s'\n",m_name.data());
}

void CompoundHandler::startInnerClass(const QXmlAttributes& attrib)
{
  m_innerCompounds.append(new QString(attrib.value("refid")));
}

void CompoundHandler::startInnerNamespace(const QXmlAttributes& attrib)
{
  m_innerCompounds.append(new QString(attrib.value("refid")));
}

void CompoundHandler::startInnerFile(const QXmlAttributes& attrib)
{
  m_innerCompounds.append(new QString(attrib.value("refid")));
}

void CompoundHandler::startInnerGroup(const QXmlAttributes& attrib)
{
  m_innerCompounds.append(new QString(attrib.value("refid")));
}

void CompoundHandler::startInnerPage(const QXmlAttributes& attrib)
{
  m_innerCompounds.append(new QString(attrib.value("refid")));
}

void CompoundHandler::startInnerDir(const QXmlAttributes& attrib)
{
  m_innerCompounds.append(new QString(attrib.value("refid")));
}

void CompoundHandler::startTemplateParamList(const QXmlAttributes& attrib)
{
  m_templateParamList = new TemplateParamListHandler(this);
  m_templateParamList->startTemplateParamList(attrib);
}

void CompoundHandler::startListOfAllMembers(const QXmlAttributes& attrib)
{
  m_members = new ListOfAllMembersHandler(this);
  m_members->startListOfAllMembers(attrib);
}

void CompoundHandler::startSuperClass(const QXmlAttributes& attrib)
{
  IRelatedCompound::Protection prot = IRelatedCompound::Public;
  QString protString = attrib.value("prot");
  if (protString=="protected") 
  {
    prot = IRelatedCompound::Protected;
  }
  else if (protString=="private") 
  {
    prot = IRelatedCompound::Private;
  }
  IRelatedCompound::Kind kind = IRelatedCompound::Normal;
  QString kindString = attrib.value("virt");
  if (kindString=="virtual") kind = IRelatedCompound::Virtual;
  
  RelatedCompound *sc=new RelatedCompound(
          this,
          attrib.value("refid"),
          prot,
          kind
         );
  debug(2,"super class id=`%s' prot=`%s' virt=`%s'\n",
      attrib.value("refid").data(),
      protString.data(),
      kindString.data());
  m_superClasses.append(sc);
  m_curString = "";
}

void CompoundHandler::endSuperClass()
{
  m_superClasses.getLast()->setName(m_curString);
}

void CompoundHandler::startSubClass(const QXmlAttributes& attrib)
{
  IRelatedCompound::Protection prot = IRelatedCompound::Public;
  QString protString = attrib.value("prot");
  if (protString=="protected") prot = IRelatedCompound::Protected;
  else if (protString=="private") prot = IRelatedCompound::Private;

  IRelatedCompound::Kind kind = IRelatedCompound::Normal;
  QString kindString = attrib.value("virt");
  if (kindString=="virtual") kind = IRelatedCompound::Virtual;
  
  RelatedCompound *sc = new RelatedCompound(
          this,
          attrib.value("refid"),
          prot,
          kind
         );
  debug(2,"sub class id=`%s' prot=`%s' virt=`%s'\n",
      attrib.value("refid").data(),
      protString.data(),
      kindString.data());
  m_subClasses.append(sc);
  m_curString = "";
}

void CompoundHandler::endSubClass()
{
  m_subClasses.getLast()->setName(m_curString);
}

void CompoundHandler::startTitle(const QXmlAttributes& attrib)
{
  ASSERT(m_titleHandler==0);
  m_titleHandler = new TitleHandler(this);
  m_titleHandler->startTitle(attrib);
}

bool CompoundHandler::parseXML(const char *compId)
{
  QFile xmlFile(m_xmlDir+"/"+compId+".xml");
  if (!xmlFile.exists()) return FALSE;
  CompoundErrorHandler errorHandler;
  QXmlInputSource source( xmlFile );
  QXmlSimpleReader reader;
  reader.setContentHandler( this );
  reader.setErrorHandler( &errorHandler );
  reader.parse( source );
  return TRUE;
}

void CompoundHandler::initialize(MainHandler *mh)
{
  m_mainHandler = mh;
  QListIterator<SectionHandler> msi(m_sections);
  SectionHandler *sec;
  for (;(sec=msi.current());++msi)
  {
    sec->initialize(this);
  }
  if (m_members)
  {
    m_members->initialize(mh);
  }
}

void CompoundHandler::insertMember(MemberHandler *mh)
{
  m_memberDict.insert(mh->id()->latin1(),mh);
  mh->initialize(m_mainHandler);
  QList<MemberHandler> *mhl = m_memberNameDict.find(mh->id()->latin1());
  if (mhl==0)
  {
    mhl = new QList<MemberHandler>;
    m_memberNameDict.insert(mh->name()->latin1(),mhl);
  }
  mhl->append(mh);
}

ICompound *CompoundHandler::toICompound() const
{
  switch (m_kind)
  {
    case IClass::Class:         return (IClass *)this;
    case IStruct::Struct:       return (IStruct *)this;
    case IUnion::Union:         return (IUnion *)this;
    case IException::Exception: return (IException *)this;
    case IInterface::Interface: return (IInterface *)this;
    case INamespace::Namespace: return (INamespace *)this;
    case IFile::File:           return (IFile *)this;
    case IGroup::Group:         return (IGroup *)this;
    case IPage::Page:           return (IPage *)this;
    default:   return 0;
  }
  return 0;
}

void CompoundHandler::release()
{ 
  debug(2,"CompoundHandler::release() %d->%d\n",m_refCount,m_refCount-1);
  if (--m_refCount<=0)
  {
    m_mainHandler->unloadCompound(this);
    delete this; 
  }
}

ISectionIterator *CompoundHandler::sections() const 
{ 
  return new SectionIterator(m_sections); 
}
    
IMemberIterator *CompoundHandler::memberByName(const char *name) const
{ 
  QList<MemberHandler> *ml = m_memberNameDict[name]; 
  if (ml==0) return 0;
  return new MemberIterator(*ml);
}

void CompoundHandler::startInheritanceGraph(const QXmlAttributes &attrib)
{
  m_inheritanceGraph = new GraphHandler(this,"inheritancegraph");
  m_inheritanceGraph->startGraph(attrib);
}

void CompoundHandler::startCollaborationGraph(const QXmlAttributes &attrib)
{
  m_collaborationGraph = new GraphHandler(this,"collaborationgraph");
  m_collaborationGraph->startGraph(attrib);
}

void CompoundHandler::startIncludeDependencyGraph(const QXmlAttributes &attrib)
{
  m_includeDependencyGraph = new GraphHandler(this,"incdepgraph");
  m_includeDependencyGraph->startGraph(attrib);
}

void CompoundHandler::startIncludedByDependencyGraph(const QXmlAttributes &attrib)
{
  m_includedByDependencyGraph = new GraphHandler(this,"invincdepgraph");
  m_includedByDependencyGraph->startGraph(attrib);
}

IDocRoot *CompoundHandler::briefDescription() const 
{ 
  return m_brief; 
}

IDocRoot *CompoundHandler::detailedDescription() const 
{ 
  return m_detailed; 
}

IMember *CompoundHandler::memberById(const char *id) const 
{ 
  return (IFunction*)m_memberDict[id]; 
}

IGraph *CompoundHandler::inheritanceGraph() const 
{ 
  return m_inheritanceGraph; 
}

IGraph *CompoundHandler::collaborationGraph() const 
{ 
  return m_collaborationGraph; 
}

IGraph *CompoundHandler::includeDependencyGraph() const
{
  return m_includeDependencyGraph;
}

IGraph *CompoundHandler::includedByDependencyGraph() const
{
  return m_includedByDependencyGraph;
}

IRelatedCompoundIterator *CompoundHandler::baseCompounds() const
{
  return new RelatedCompoundIterator(m_superClasses);
}

IRelatedCompoundIterator *CompoundHandler::derivedCompounds() const
{
  return new RelatedCompoundIterator(m_subClasses);
}

ICompoundIterator *CompoundHandler::nestedCompounds() const
{
  return new CompoundIdIterator(m_mainHandler,m_innerCompounds);
}

IDocProgramListing *CompoundHandler::source() const
{
  return m_programListing;
}

IIncludeIterator *CompoundHandler::includes() const
{
  return new IncludeIterator(m_includes);
}

IIncludeIterator *CompoundHandler::includedBy() const
{
  return new IncludeIterator(m_includedBy);
}

IParamIterator *CompoundHandler::templateParameters() const
{
  return m_templateParamList ? m_templateParamList->templateParams() : 0;
}

const IDocTitle *CompoundHandler::title() const
{
  return m_titleHandler;
}

IMemberReferenceIterator *CompoundHandler::members() const
{
  return m_members ? m_members->members() : 0;
}