Classes
struct	Cachable

Public Member Functions
	Private (const NestingNodeContext parent, const NestingNodeContext thisNode, Definition *d, int index, int level, bool addCls, bool inherit, bool hideSuper)

TemplateVariant	get (const char *n) const

TemplateVariant	isLeafNode () const

TemplateVariant	children () const

TemplateVariant	getClass () const

TemplateVariant	getNamespace () const

TemplateVariant	getDir () const

TemplateVariant	getFile () const

TemplateVariant	getPage () const

TemplateVariant	getModule () const

TemplateVariant	level () const

TemplateVariant	id () const

TemplateVariant	name () const

QCString	relPathAsString () const

TemplateVariant	brief () const

TemplateVariant	isLinkable () const

TemplateVariant	anchor () const

TemplateVariant	fileName () const

TemplateVariant	isReference () const

TemplateVariant	externalReference () const

void	addClasses (bool inherit, bool hideSuper)

void	addNamespaces (bool addClasses)

void	addDirFiles ()

void	addPages ()

void	addModules ()

Private Attributes
const NestingNodeContext *	m_parent

Definition *	m_def

SharedPtr< NestingContext >	m_children

int	m_level

int	m_index

Cachable	m_cache

Static Private Attributes
static PropertyMapper< NestingNodeContext::Private >	s_inst

Detailed Description

Definition at line 6061 of file context.cpp.

Constructor & Destructor Documentation

NestingNodeContext::Private::Private	(	const NestingNodeContext *	parent,
		const NestingNodeContext *	thisNode,
		Definition *	d,
		int	index,
		int	level,
		bool	addCls,
		bool	inherit,
		bool	hideSuper
	)

inline

Definition at line 6064 of file context.cpp.

       : m_parent(parent), m_def(d), m_level(level), m_index(index)
     {
       m_children.reset(NestingContext::alloc(thisNode,level+1));
       static bool init=FALSE;
       if (!init)
       {
         //%% bool is_leaf_node: true if this node does not have any children
         s_inst.addProperty("is_leaf_node",&Private::isLeafNode);
         //%% Nesting children: list of nested classes/namespaces
         s_inst.addProperty("children",&Private::children);
         //%% [optional] Class class: class info (if this node represents a class)
         s_inst.addProperty("class",&Private::getClass);
         //%% [optional] Namespace namespace: namespace info (if this node represents a namespace)
         s_inst.addProperty("namespace",&Private::getNamespace);
         //%% [optional] File file: file info (if this node represents a file)
         s_inst.addProperty("file",&Private::getFile);
         //%% [optional] Dir dir: directory info (if this node represents a directory)
         s_inst.addProperty("dir",&Private::getDir);
         //%% [optional] Page page: page info (if this node represents a page)
         s_inst.addProperty("page",&Private::getPage);
         //%% [optional] Module module: module info (if this node represents a module)
         s_inst.addProperty("module",&Private::getModule);
         //%% int id
         s_inst.addProperty("id",&Private::id);
         //%% string level
         s_inst.addProperty("level",&Private::level);
         //%% string name
         s_inst.addProperty("name",&Private::name);
         //%% string brief
         s_inst.addProperty("brief",&Private::brief);
         //%% bool isLinkable
         s_inst.addProperty("isLinkable",&Private::isLinkable);
         s_inst.addProperty("anchor",&Private::anchor);
         s_inst.addProperty("fileName",&Private::fileName);
         s_inst.addProperty("isReference",&Private::isReference);
         s_inst.addProperty("externalReference",&Private::externalReference);
         init=TRUE;
       }
 
       addNamespaces(addCls);
       addClasses(inherit,hideSuper);
       addDirFiles();
       addPages();
       addModules();
     }

Member Function Documentation

void NestingNodeContext::Private::addClasses	(	bool	inherit,
		bool	hideSuper
	)

inline

Definition at line 6272 of file context.cpp.

     {
       ClassDef *cd = m_def->definitionType()==Definition::TypeClass ? (ClassDef*)m_def : 0;
       if (cd && inherit)
       {
         bool hasChildren = !cd->visited && !hideSuper && classHasVisibleChildren(cd);
         if (hasChildren)
         {
           bool wasVisited=cd->visited;
           cd->visited=TRUE;
           if (cd->getLanguage()==SrcLangExt_VHDL)
           {
             m_children->addDerivedClasses(cd->baseClasses(),wasVisited);
           }
           else
           {
             m_children->addDerivedClasses(cd->subClasses(),wasVisited);
           }
         }
       }
       else
       {
         if (cd && cd->getClassSDict())
         {
           m_children->addClasses(*cd->getClassSDict(),FALSE);
         }
       }
     }

void NestingNodeContext::Private::addDirFiles ( )

inline

Definition at line 6312 of file context.cpp.

     {
       DirDef *dd = m_def->definitionType()==Definition::TypeDir ? (DirDef*)m_def : 0;
       if (dd)
       {
         m_children->addDirs(dd->subDirs());
         if (dd && dd->getFiles())
         {
           m_children->addFiles(*dd->getFiles());
         }
       }
     }

void NestingNodeContext::Private::addModules ( )

inline

Definition at line 6332 of file context.cpp.

     {
       GroupDef *gd = m_def->definitionType()==Definition::TypeGroup ? (GroupDef*)m_def : 0;
       if (gd && gd->getSubGroups())
       {
         m_children->addModules(*gd->getSubGroups());
       }
     }

void NestingNodeContext::Private::addNamespaces ( bool addClasses )

inline

Definition at line 6300 of file context.cpp.

     {
       NamespaceDef *nd = m_def->definitionType()==Definition::TypeNamespace ? (NamespaceDef*)m_def : 0;
       if (nd && nd->getNamespaceSDict())
       {
         m_children->addNamespaces(*nd->getNamespaceSDict(),FALSE,addClasses);
       }
       if (addClasses && nd && nd->getClassSDict())
       {
         m_children->addClasses(*nd->getClassSDict(),FALSE);
       }
     }

void NestingNodeContext::Private::addPages ( )

inline

Definition at line 6324 of file context.cpp.

     {
       PageDef *pd = m_def->definitionType()==Definition::TypePage ? (PageDef*)m_def : 0;
       if (pd && pd->getSubPages())
       {
         m_children->addPages(*pd->getSubPages(),FALSE);
       }
     }

TemplateVariant NestingNodeContext::Private::anchor ( ) const

inline

Definition at line 6253 of file context.cpp.

     {
       return m_def->anchor();
     }

TemplateVariant NestingNodeContext::Private::brief ( ) const

inline

Definition at line 6233 of file context.cpp.

     {
       if (!m_cache.brief)
       {
         if (m_def->hasBriefDescription())
         {
           m_cache.brief.reset(new TemplateVariant(parseDoc(m_def,m_def->briefFile(),m_def->briefLine(),
                               "",m_def->briefDescription(),TRUE)));
         }
         else
         {
           m_cache.brief.reset(new TemplateVariant(""));
         }
       }
       return *m_cache.brief;
     }

TemplateVariant NestingNodeContext::Private::children ( ) const

inline

Definition at line 6119 of file context.cpp.

     {
       return m_children.get();
     }

TemplateVariant NestingNodeContext::Private::externalReference ( ) const

inline

Definition at line 6265 of file context.cpp.

     {
       return m_def->externalReference(relPathAsString());
     }

TemplateVariant NestingNodeContext::Private::fileName ( ) const

inline

Definition at line 6257 of file context.cpp.

     {
       return m_def->getOutputFileBase();
     }

TemplateVariant NestingNodeContext::Private::get ( const char * n ) const

inline

Definition at line 6111 of file context.cpp.

     {
       return s_inst.get(this,n);
     }

TemplateVariant NestingNodeContext::Private::getClass ( ) const

inline

Definition at line 6123 of file context.cpp.

     {
       if (!m_cache.classContext && m_def->definitionType()==Definition::TypeClass)
       {
         m_cache.classContext.reset(ClassContext::alloc((ClassDef*)m_def));
       }
       if (m_cache.classContext)
       {
         return m_cache.classContext.get();
       }
       else
       {
         return TemplateVariant(FALSE);
       }
     }

TemplateVariant NestingNodeContext::Private::getDir ( ) const

inline

Definition at line 6153 of file context.cpp.

     {
       if (!m_cache.dirContext && m_def->definitionType()==Definition::TypeDir)
       {
         m_cache.dirContext.reset(DirContext::alloc((DirDef*)m_def));
       }
       if (m_cache.dirContext)
       {
         return m_cache.dirContext.get();
       }
       else
       {
         return TemplateVariant(FALSE);
       }
     }

TemplateVariant NestingNodeContext::Private::getFile ( ) const

inline

Definition at line 6168 of file context.cpp.

     {
       if (!m_cache.fileContext && m_def->definitionType()==Definition::TypeFile)
       {
         m_cache.fileContext.reset(FileContext::alloc((FileDef*)m_def));
       }
       if (m_cache.fileContext)
       {
         return m_cache.fileContext.get();
       }
       else
       {
         return TemplateVariant(FALSE);
       }
     }

TemplateVariant NestingNodeContext::Private::getModule ( ) const

inline

Definition at line 6198 of file context.cpp.

     {
       if (!m_cache.moduleContext && m_def->definitionType()==Definition::TypeGroup)
       {
         m_cache.moduleContext.reset(ModuleContext::alloc((GroupDef*)m_def));
       }
       if (m_cache.moduleContext)
       {
         return m_cache.moduleContext.get();
       }
       else
       {
         return TemplateVariant(FALSE);
       }
     }

TemplateVariant NestingNodeContext::Private::getNamespace ( ) const

inline

Definition at line 6138 of file context.cpp.

     {
       if (!m_cache.namespaceContext && m_def->definitionType()==Definition::TypeNamespace)
       {
         m_cache.namespaceContext.reset(NamespaceContext::alloc((NamespaceDef*)m_def));
       }
       if (m_cache.namespaceContext)
       {
         return m_cache.namespaceContext.get();
       }
       else
       {
         return TemplateVariant(FALSE);
       }
     }

TemplateVariant NestingNodeContext::Private::getPage ( ) const

inline

Definition at line 6183 of file context.cpp.

     {
       if (!m_cache.pageContext && m_def->definitionType()==Definition::TypePage)
       {
         m_cache.pageContext.reset(PageContext::alloc((PageDef*)m_def,FALSE,FALSE));
       }
       if (m_cache.pageContext)
       {
         return m_cache.pageContext.get();
       }
       else
       {
         return TemplateVariant(FALSE);
       }
     }

TemplateVariant NestingNodeContext::Private::id ( ) const

inline

Definition at line 6217 of file context.cpp.

     {
       QCString result;
       if (m_parent) result=m_parent->id();
       result+=QCString().setNum(m_index)+"_";
       return result;
     }

TemplateVariant NestingNodeContext::Private::isLeafNode ( ) const

inline

Definition at line 6115 of file context.cpp.

     {
       return m_children->count()==0;
     }

TemplateVariant NestingNodeContext::Private::isLinkable ( ) const

inline

Definition at line 6249 of file context.cpp.

     {
       return m_def->isLinkable();
     }

TemplateVariant NestingNodeContext::Private::isReference ( ) const

inline

Definition at line 6261 of file context.cpp.

     {
       return m_def->isReference();
     }

TemplateVariant NestingNodeContext::Private::level ( ) const

inline

Definition at line 6213 of file context.cpp.

     {
       return m_level;
     }

TemplateVariant NestingNodeContext::Private::name ( ) const

inline

Definition at line 6224 of file context.cpp.

     {
       return m_def->displayName(FALSE);
     }

QCString NestingNodeContext::Private::relPathAsString ( ) const

inline

Definition at line 6228 of file context.cpp.

     {
       static bool createSubdirs = Config_getBool("CREATE_SUBDIRS");
       return createSubdirs ? QCString("../../") : QCString("");
     }

Member Data Documentation

Cachable NestingNodeContext::Private::m_cache

mutableprivate

Definition at line 6356 of file context.cpp.

SharedPtr<NestingContext> NestingNodeContext::Private::m_children

private

Definition at line 6343 of file context.cpp.

Definition* NestingNodeContext::Private::m_def

private

Definition at line 6342 of file context.cpp.

int NestingNodeContext::Private::m_index

private

Definition at line 6345 of file context.cpp.

int NestingNodeContext::Private::m_level

private

Definition at line 6344 of file context.cpp.

const NestingNodeContext* NestingNodeContext::Private::m_parent

private

Definition at line 6341 of file context.cpp.

PropertyMapper< NestingNodeContext::Private > NestingNodeContext::Private::s_inst

staticprivate

Definition at line 6357 of file context.cpp.

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

doxygen-1.8.11/src/context.cpp

Classes

Public Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation