Inheritance diagram for NestingContext::Private:

Public Member Functions
	Private (const NestingNodeContext *parent, int level)

void	addNamespaces (const NamespaceSDict &nsDict, bool rootOnly, bool addClasses)

void	addClasses (const ClassSDict &clDict, bool rootOnly)

void	addDirs (const DirSDict &dirDict)

void	addDirs (const DirList &dirList)

void	addFiles (const FileNameList &fnList)

void	addFiles (const FileList &fList)

void	addPages (const PageSDict &pages, bool rootOnly)

void	addModules (const GroupSDict &groups)

void	addModules (const GroupList &list)

void	addDerivedClasses (const BaseClassList *bcl, bool hideSuper)

void	addClassHierarchy (const ClassSDict &classSDict, bool)

Public Member Functions inherited from GenericNodeListContext
	GenericNodeListContext ()

int	count () const

TemplateVariant	at (int index) const

TemplateListIntf::ConstIterator *	createIterator () const

void	append (const TemplateVariant &ctn)

bool	isEmpty () const

int	addRef ()

int	release ()

Public Member Functions inherited from TemplateListIntf
virtual	~TemplateListIntf ()

Private Attributes
const NestingNodeContext *	m_parent

int	m_level

int	m_index

Additional Inherited Members
Static Public Member Functions inherited from GenericNodeListContext
static GenericNodeListContext *	alloc ()

Detailed Description

Definition at line 6403 of file context.cpp.

Constructor & Destructor Documentation

NestingContext::Private::Private	(	const NestingNodeContext *	parent,
		int	level
	)

inline

Definition at line 6406 of file context.cpp.

: m_parent(parent), m_level(level), m_index(0) {}

Member Function Documentation

void NestingContext::Private::addClasses	(	const ClassSDict &	clDict,
		bool	rootOnly
	)

inline

Definition at line 6429 of file context.cpp.

References NestingNodeContext::alloc(), GenericNodeListContext::append(), classVisibleInIndex(), Definition::getLanguage(), Definition::getOuterScope(), Doxygen::globalScope, SDict< ClassDef >::Iterator, m_index, m_level, m_parent, VhdlDocGen::PACKAGECLASS, VhdlDocGen::PACKBODYCLASS, ClassDef::protection(), SrcLangExt_VHDL, and ClassDef::templateMaster().

Referenced by NestingContext::addClasses().

    {
      ClassSDict::Iterator cli(clDict);
      ClassDef *cd;
      for (;(cd=cli.current());++cli)
      {
        if (cd->getLanguage()==SrcLangExt_VHDL)
        {
          if ((VhdlDocGen::VhdlClasses)cd->protection()==VhdlDocGen::PACKAGECLASS ||
              (VhdlDocGen::VhdlClasses)cd->protection()==VhdlDocGen::PACKBODYCLASS
             )// no architecture
          {
            continue;
          }
        }
        if (!rootOnly ||
            cd->getOuterScope()==0 ||
            cd->getOuterScope()==Doxygen::globalScope
           )
        {
          if (classVisibleInIndex(cd) && cd->templateMaster()==0)
          {
            NestingNodeContext *nnc = NestingNodeContext::alloc(m_parent,cd,m_index,m_level,TRUE,FALSE,FALSE);
            append(nnc);
            m_index++;
          }
        }
      }
    }

void NestingContext::Private::addClassHierarchy	(	const ClassSDict &	classSDict,
		bool
	)

inline

Definition at line 6584 of file context.cpp.

References NestingNodeContext::alloc(), GenericNodeListContext::append(), ClassDef::baseClasses(), VhdlDocGen::ENTITYCLASS, Definition::getLanguage(), hasVisibleRoot(), ClassDef::isVisibleInHierarchy(), SDict< ClassDef >::Iterator, m_index, m_level, m_parent, ClassDef::protection(), SrcLangExt_VHDL, ClassDef::subClasses(), and ClassDef::visited.

Referenced by NestingContext::addClassHierarchy().

    {
      ClassSDict::Iterator cli(classSDict);
      ClassDef *cd;
      for (cli.toFirst();(cd=cli.current());++cli)
      {
        bool b;
        if (cd->getLanguage()==SrcLangExt_VHDL)
        {
          if ((VhdlDocGen::VhdlClasses)cd->protection()!=VhdlDocGen::ENTITYCLASS)
          {
            continue;
          }
          b=!hasVisibleRoot(cd->subClasses());
        }
        else
        {
          b=!hasVisibleRoot(cd->baseClasses());
        }
        if (b)
        {
          if (cd->isVisibleInHierarchy()) // should it be visible
          {
            // new root level class
            NestingNodeContext *nnc = NestingNodeContext::alloc(m_parent,cd,m_index,m_level,TRUE,TRUE,cd->visited);
            append(nnc);
            m_index++;
          }
        }
      }
    }

void NestingContext::Private::addDerivedClasses	(	const BaseClassList *	bcl,
		bool	hideSuper
	)

inline

Definition at line 6553 of file context.cpp.

References NestingNodeContext::alloc(), GenericNodeListContext::append(), ClassDef::baseClasses(), BaseClassDef::classDef, VhdlDocGen::ENTITYCLASS, Definition::getLanguage(), hasVisibleRoot(), ClassDef::isVisibleInHierarchy(), m_index, m_level, m_parent, ClassDef::protection(), SrcLangExt_VHDL, and ClassDef::subClasses().

Referenced by NestingContext::addDerivedClasses().

    {
      if (bcl==0) return;
      BaseClassListIterator bcli(*bcl);
      BaseClassDef *bcd;
      for (bcli.toFirst() ; (bcd=bcli.current()) ; ++bcli)
      {
        ClassDef *cd=bcd->classDef;
        if (cd->getLanguage()==SrcLangExt_VHDL && (VhdlDocGen::VhdlClasses)cd->protection()!=VhdlDocGen::ENTITYCLASS)
        {
          continue;
        }
        bool b;
        if (cd->getLanguage()==SrcLangExt_VHDL)
        {
          b=hasVisibleRoot(cd->subClasses());
        }
        else
        {
          b=hasVisibleRoot(cd->baseClasses());
        }
        if (cd->isVisibleInHierarchy() && b)
        {
          NestingNodeContext *tnc = NestingNodeContext::alloc(m_parent,cd,m_index,m_level,TRUE,TRUE,hideSuper);
          append(tnc);
          m_index++;
        }
      }
    }

void NestingContext::Private::addDirs ( const DirSDict & dirDict )

inline

Definition at line 6458 of file context.cpp.

References NestingNodeContext::alloc(), GenericNodeListContext::append(), Definition::getOuterScope(), Doxygen::globalScope, m_index, m_level, and m_parent.

Referenced by NestingContext::addDirs().

    {
      SDict<DirDef>::Iterator dli(dirDict);
      DirDef *dd;
      for (dli.toFirst();(dd=dli.current());++dli)
      {
        if (dd->getOuterScope()==Doxygen::globalScope)
        {
          append(NestingNodeContext::alloc(m_parent,dd,m_index,m_level,FALSE,FALSE,FALSE));
          m_index++;
        }
      }
    }

void NestingContext::Private::addDirs ( const DirList & dirList )

inline

Definition at line 6471 of file context.cpp.

References NestingNodeContext::alloc(), GenericNodeListContext::append(), m_index, m_level, and m_parent.

    {
      QListIterator<DirDef> li(dirList);
      DirDef *dd;
      for (li.toFirst();(dd=li.current());++li)
      {
        append(NestingNodeContext::alloc(m_parent,dd,m_index,m_level,FALSE,FALSE,FALSE));
        m_index++;
      }
    }

void NestingContext::Private::addFiles ( const FileNameList & fnList )

inline

Definition at line 6481 of file context.cpp.

References NestingNodeContext::alloc(), GenericNodeListContext::append(), FileDef::getDirDef(), m_index, m_level, and m_parent.

Referenced by NestingContext::addFiles().

    {
      FileNameListIterator fnli(fnList);
      FileName *fn;
      for (fnli.toFirst();(fn=fnli.current());++fnli)
      {
        FileNameIterator fni(*fn);
        FileDef *fd;
        for (;(fd=fni.current());++fni)
        {
          if (fd->getDirDef()==0) // top level file
          {
            append(NestingNodeContext::alloc(m_parent,fd,m_index,m_level,FALSE,FALSE,FALSE));
            m_index++;
          }
        }
      }
    }

void NestingContext::Private::addFiles ( const FileList & fList )

inline

Definition at line 6499 of file context.cpp.

References NestingNodeContext::alloc(), GenericNodeListContext::append(), m_index, m_level, and m_parent.

    {
      QListIterator<FileDef> li(fList);
      FileDef *fd;
      for (li.toFirst();(fd=li.current());++li)
      {
        append(NestingNodeContext::alloc(m_parent,fd,m_index,m_level,FALSE,FALSE,FALSE));
        m_index++;
      }
    }

void NestingContext::Private::addModules ( const GroupSDict & groups )

inline

Definition at line 6524 of file context.cpp.

References NestingNodeContext::alloc(), GenericNodeListContext::append(), Config_getBool, GroupDef::isASubGroup(), Definition::isReference(), Definition::isVisible(), SDict< GroupDef >::Iterator, m_index, m_level, and m_parent.

Referenced by NestingContext::addModules().

    {
      GroupSDict::Iterator gli(groups);
      GroupDef *gd;
      for (gli.toFirst();(gd=gli.current());++gli)
      {
        static bool externalGroups = Config_getBool(EXTERNAL_GROUPS);
        if (!gd->isASubGroup() && gd->isVisible() &&
             (!gd->isReference() || externalGroups)
           )
        {
          append(NestingNodeContext::alloc(m_parent,gd,m_index,m_level,FALSE,FALSE,FALSE));
          m_index++;
        }
      }
    }

void NestingContext::Private::addModules ( const GroupList & list )

inline

Definition at line 6540 of file context.cpp.

References NestingNodeContext::alloc(), GenericNodeListContext::append(), Definition::isVisible(), m_index, m_level, and m_parent.

    {
      GroupListIterator gli(list);
      GroupDef *gd;
      for (gli.toFirst();(gd=gli.current());++gli)
      {
        if (gd->isVisible())
        {
          append(NestingNodeContext::alloc(m_parent,gd,m_index,m_level,FALSE,FALSE,FALSE));
          m_index++;
        }
      }
    }

void NestingContext::Private::addNamespaces	(	const NamespaceSDict &	nsDict,
		bool	rootOnly,
		bool	addClasses
	)

inline

Definition at line 6409 of file context.cpp.

References NestingNodeContext::alloc(), GenericNodeListContext::append(), Definition::getOuterScope(), Doxygen::globalScope, NamespaceDef::isLinkableInProject(), SDict< NamespaceDef >::Iterator, NamespaceDef::localName(), m_index, m_level, m_parent, and namespaceHasVisibleChild().

Referenced by NestingContext::addNamespaces().

    {
      NamespaceSDict::Iterator nli(nsDict);
      NamespaceDef *nd;
      for (nli.toFirst();(nd=nli.current());++nli)
      {
        if (nd->localName().find('@')==-1 &&
            (!rootOnly || nd->getOuterScope()==Doxygen::globalScope))
        {
          bool hasChildren = namespaceHasVisibleChild(nd,addClasses);
          bool isLinkable  = nd->isLinkableInProject();
          if (isLinkable || hasChildren)
          {
            NestingNodeContext *nnc = NestingNodeContext::alloc(m_parent,nd,m_index,m_level,addClasses,FALSE,FALSE);
            append(nnc);
            m_index++;
          }
        }
      }
    }

void NestingContext::Private::addPages	(	const PageSDict &	pages,
		bool	rootOnly
	)

inline

Definition at line 6509 of file context.cpp.

References NestingNodeContext::alloc(), GenericNodeListContext::append(), DefinitionIntf::definitionType(), Definition::getOuterScope(), m_index, m_level, m_parent, and DefinitionIntf::TypePage.

Referenced by NestingContext::addPages().

    {
      SDict<PageDef>::Iterator pli(pages);
      PageDef *pd;
      for (pli.toFirst();(pd=pli.current());++pli)
      {
        if (!rootOnly ||
            pd->getOuterScope()==0 ||
            pd->getOuterScope()->definitionType()!=Definition::TypePage)
        {
          append(NestingNodeContext::alloc(m_parent,pd,m_index,m_level,FALSE,FALSE,FALSE));
          m_index++;
        }
      }
    }