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 6388 of file context.cpp.

Constructor & Destructor Documentation

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

inline

Definition at line 6391 of file context.cpp.

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

NestingContext::Private::m_index

int m_index

Definition: context.cpp:6604

NestingContext::Private::m_level

int m_level

Definition: context.cpp:6603

generate_datataset.level

level

Definition: generate_datataset.py:30

NestingContext::Private::m_parent

const NestingNodeContext * m_parent

Definition: context.cpp:6602

Member Function Documentation

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

inline

Definition at line 6414 of file context.cpp.

     {
       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 6569 of file context.cpp.

     {
       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 6538 of file context.cpp.

     {
       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 6443 of file context.cpp.

     {
       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 6456 of file context.cpp.

     {
       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 6466 of file context.cpp.

     {
       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 6484 of file context.cpp.

     {
       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 6509 of file context.cpp.

     {
       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 6525 of file context.cpp.

     {
       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 6394 of file context.cpp.

     {
       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 6494 of file context.cpp.

     {
       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++;
         }
       }
     }

Member Data Documentation

int NestingContext::Private::m_index

private

Definition at line 6604 of file context.cpp.

int NestingContext::Private::m_level

private

Definition at line 6603 of file context.cpp.

const NestingNodeContext* NestingContext::Private::m_parent

private

Definition at line 6602 of file context.cpp.

The documentation for this class was generated from the following file:

doxygen-1.8.11/src/context.cpp

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation