#include <namespacedef.h>

Inheritance diagram for NamespaceDef:

Public Member Functions
	NamespaceDef (const char defFileName, int defLine, int defColumn, const char name, const char ref=0, const char refFile=0, const char *type=0, bool isPublished=false)

	~NamespaceDef ()

DefType	definitionType () const

QCString	getOutputFileBase () const

QCString	anchor () const

void	insertUsedFile (FileDef *fd)

void	writeDocumentation (OutputList &ol)

void	writeMemberPages (OutputList &ol)

void	writeQuickMemberLinks (OutputList &ol, MemberDef *currentMd) const

void	writeTagFile (FTextStream &)

void	insertClass (ClassDef *cd)

void	insertNamespace (NamespaceDef *nd)

void	insertMember (MemberDef *md)

void	computeAnchors ()

int	countMembers ()

void	addUsingDirective (NamespaceDef *nd)

NamespaceSDict *	getUsedNamespaces () const

void	addUsingDeclaration (Definition *def)

SDict< Definition > *	getUsedClasses () const

void	combineUsingRelations ()

QCString	displayName (bool=TRUE) const

QCString	localName () const

bool	isConstantGroup () const

bool	isModule () const

bool	isLibrary () const

bool	isLinkableInProject () const

bool	isLinkable () const

bool	hasDetailedDescription () const

void	addMembersToMemberGroup ()

void	distributeMemberGroupDocumentation ()

void	findSectionsInDocumentation ()

void	sortMemberLists ()

virtual Definition *	findInnerCompound (const char *name)

void	addInnerCompound (Definition *d)

void	addListReferences ()

void	setFileName (const QCString &fn)

bool	subGrouping () const

MemberList *	getMemberList (MemberListType lt) const

const QList< MemberList > &	getMemberLists () const

MemberDef *	getMemberByName (const QCString &) const

MemberGroupSDict *	getMemberGroupSDict () const

ClassSDict *	getClassSDict () const

NamespaceSDict *	getNamespaceSDict () const

QCString	title () const

QCString	compoundTypeString () const

Public Member Functions inherited from Definition
	Definition (const char defFileName, int defLine, int defColumn, const char name, const char b=0, const char d=0, bool isSymbol=TRUE)

virtual	~Definition ()

const QCString &	name () const

QCString	localName () const

virtual QCString	qualifiedName () const

QCString	symbolName () const

virtual QCString	getSourceFileBase () const

virtual QCString	getSourceAnchor () const

virtual QCString	documentation () const

int	docLine () const

QCString	docFile () const

virtual QCString	briefDescription (bool abbreviate=FALSE) const

QCString	briefDescriptionAsTooltip () const

int	briefLine () const

QCString	inbodyDocumentation () const

QCString	inbodyFile () const

int	inbodyLine () const

QCString	briefFile () const

QCString	getDefFileName () const

QCString	getDefFileExtension () const

int	getDefLine () const

int	getDefColumn () const

virtual bool	hasDocumentation () const

virtual bool	hasUserDocumentation () const

virtual bool	isVisibleInProject () const

virtual bool	isVisible () const

bool	isHidden () const

bool	isArtificial () const

virtual QCString	getReference () const

virtual bool	isReference () const

QCString	externalReference (const QCString &relPath) const

int	getStartBodyLine () const

int	getEndBodyLine () const

FileDef *	getBodyDef () const

SrcLangExt	getLanguage () const

GroupList *	partOfGroups () const

QList< ListItemInfo > *	xrefListItems () const

virtual Definition *	getOuterScope () const

MemberSDict *	getReferencesMembers () const

MemberSDict *	getReferencedByMembers () const

bool	hasSections () const

bool	hasSources () const

bool	hasBriefDescription () const

QCString	id () const

virtual void	setName (const char *name)

void	setId (const char *name)

virtual void	setDocumentation (const char d, const char docFile, int docLine, bool stripWhiteSpace=TRUE)

virtual void	setBriefDescription (const char b, const char briefFile, int briefLine)

virtual void	setInbodyDocumentation (const char d, const char docFile, int docLine)

void	setReference (const char *r)

void	addSectionsToDefinition (QList< SectionInfo > *anchorList)

void	setBodySegment (int bls, int ble)

void	setBodyDef (FileDef *fd)

void	addSourceReferencedBy (MemberDef *d)

void	addSourceReferences (MemberDef *d)

void	setRefItems (const QList< ListItemInfo > *sli)

void	mergeRefItems (Definition *d)

virtual void	setOuterScope (Definition *d)

virtual void	setHidden (bool b)

void	setArtificial (bool b)

void	setLanguage (SrcLangExt lang)

QCString	convertNameToFile (const char *name, bool allowDots=FALSE) const

void	writeSourceDef (OutputList &ol, const char *scopeName)

void	writeInlineCode (OutputList &ol, const char *scopeName)

void	writeSourceRefs (OutputList &ol, const char *scopeName)

void	writeSourceReffedBy (OutputList &ol, const char *scopeName)

void	makePartOfGroup (GroupDef *gd)

void	writeNavigationPath (OutputList &ol) const

QCString	navigationPathAsString () const

QCString	pathFragment () const

void	writeDocAnchorsToTagFile (FTextStream &)

void	setLocalName (const QCString name)

void	addSectionsToIndex ()

void	writeToc (OutputList &ol)

void	setCookie (Cookie *cookie)

Cookie *	cookie () const

Public Member Functions inherited from DefinitionIntf
	DefinitionIntf ()

virtual	~DefinitionIntf ()

Public Attributes
bool	visited

Private Types
enum	{ NAMESPACE, MODULE, CONSTANT_GROUP, LIBRARY }

Private Member Functions
MemberList *	createMemberList (MemberListType lt)

void	addMemberToList (MemberListType lt, MemberDef *md)

void	writeMemberDeclarations (OutputList &ol, MemberListType lt, const QCString &title)

void	writeMemberDocumentation (OutputList &ol, MemberListType lt, const QCString &title)

void	writeDetailedDescription (OutputList &ol, const QCString &title)

void	writeBriefDescription (OutputList &ol)

void	startMemberDeclarations (OutputList &ol)

void	endMemberDeclarations (OutputList &ol)

void	writeClassDeclarations (OutputList &ol, const QCString &title)

void	writeInlineClasses (OutputList &ol)

void	writeNamespaceDeclarations (OutputList &ol, const QCString &title, bool isConstantGroup=false)

void	writeMemberGroups (OutputList &ol)

void	writeAuthorSection (OutputList &ol)

void	startMemberDocumentation (OutputList &ol)

void	endMemberDocumentation (OutputList &ol)

void	writeSummaryLinks (OutputList &ol)

void	addNamespaceAttributes (OutputList &ol)

Private Attributes
QCString	fileName

FileList	files

NamespaceSDict *	usingDirList

SDict< Definition > *	usingDeclList

SDict< Definition > *	m_innerCompounds

MemberSDict *	m_allMembersDict

QList< MemberList >	m_memberLists

MemberGroupSDict *	memberGroupSDict

ClassSDict *	classSDict

NamespaceSDict *	namespaceSDict

bool	m_subGrouping

enum NamespaceDef:: { ... }	m_type

bool	m_isPublished

Additional Inherited Members
Public Types inherited from DefinitionIntf
enum	DefType { TypeClass = 0, TypeFile = 1, TypeNamespace = 2, TypeMember = 3, TypeGroup = 4, TypePackage = 5, TypePage = 6, TypeDir = 7, TypeSymbolList = 8 }

Protected Member Functions inherited from Definition
	Definition (const Definition &d)

Detailed Description

A model of a namespace symbol.

Definition at line 39 of file namespacedef.h.

Member Enumeration Documentation

anonymous enum

private

Enumerator
NAMESPACE
MODULE
CONSTANT_GROUP
LIBRARY

Definition at line 141 of file namespacedef.h.

141 { NAMESPACE, MODULE, CONSTANT_GROUP, LIBRARY } m_type;

NamespaceDef::MODULE

Definition: namespacedef.h:141

NamespaceDef::CONSTANT_GROUP

Definition: namespacedef.h:141

NamespaceDef::LIBRARY

Definition: namespacedef.h:141

NamespaceDef::m_type

enum NamespaceDef::@8 m_type

NamespaceDef::NAMESPACE

Definition: namespacedef.h:141

Constructor & Destructor Documentation

NamespaceDef::NamespaceDef	(	const char *	defFileName,
		int	defLine,
		int	defColumn,
		const char *	name,
		const char *	ref = `0`,
		const char *	refFile = `0`,
		const char *	type = `0`,
		bool	isPublished = `false`
	)

Definition at line 36 of file namespacedef.cpp.

                                              :
    Definition(df,dl,dc,name)
   ,m_isPublished(isPublished)
 {
   if (fName)
   {
     fileName = stripExtension(fName);
   }
   else
   {
     setFileName(name);
   }
   classSDict = new ClassSDict(17);
   namespaceSDict = new NamespaceSDict(17);
   m_innerCompounds = new SDict<Definition>(17);
   usingDirList = 0;
   usingDeclList = 0;
   m_allMembersDict = 0;
   setReference(lref);
   memberGroupSDict = new MemberGroupSDict;
   memberGroupSDict->setAutoDelete(TRUE);
   visited=FALSE;
   m_subGrouping=Config_getBool("SUBGROUPING");
   if (type && !strcmp("module", type))
   {
     m_type = MODULE;
   }
   else if (type && !strcmp("constants", type))
   {
     m_type = CONSTANT_GROUP;
   }
   else if (type && !strcmp("library", type))
   {
     m_type = LIBRARY;
   }
   else
   {
     m_type = NAMESPACE;
   }
 }

NamespaceDef::~NamespaceDef ( )

Definition at line 80 of file namespacedef.cpp.

 {
   delete classSDict;
   delete namespaceSDict;
   delete m_innerCompounds;
   delete usingDirList;
   delete usingDeclList;
   delete memberGroupSDict;
   delete m_allMembersDict;
 }

Member Function Documentation

void NamespaceDef::addInnerCompound ( Definition * d )

virtual

Reimplemented from Definition.

Definition at line 139 of file namespacedef.cpp.

 {
   m_innerCompounds->append(d->localName(),d);
   if (d->definitionType()==Definition::TypeNamespace)
   {
     insertNamespace((NamespaceDef *)d);
   }
   else if (d->definitionType()==Definition::TypeClass)
   {
     insertClass((ClassDef *)d);
   }
 }

void NamespaceDef::addListReferences ( )

Definition at line 829 of file namespacedef.cpp.

 {
   //bool fortranOpt = Config_getBool("OPTIMIZE_FOR_FORTRAN");
   {
     QList<ListItemInfo> *xrefItems = xrefListItems();
     addRefItem(xrefItems,
         qualifiedName(),
         getLanguage()==SrcLangExt_Fortran ? 
           theTranslator->trModule(TRUE,TRUE) : 
           theTranslator->trNamespace(TRUE,TRUE),
         getOutputFileBase(),displayName(),
         0,
         this
         );
   }
   MemberGroupSDict::Iterator mgli(*memberGroupSDict);
   MemberGroup *mg;
   for (;(mg=mgli.current());++mgli)
   {
     mg->addListReferences(this);
   }
   QListIterator<MemberList> mli(m_memberLists);
   MemberList *ml;
   for (mli.toFirst();(ml=mli.current());++mli)
   {
     if (ml->listType()&MemberListType_documentationLists)
     {
       ml->addListReferences(this);
     }
   }
 }

void NamespaceDef::addMembersToMemberGroup ( )

Definition at line 175 of file namespacedef.cpp.

 {
   QListIterator<MemberList> mli(m_memberLists);
   MemberList *ml;
   for (mli.toFirst();(ml=mli.current());++mli)
   {
     if (ml->listType()&MemberListType_declarationLists)
     {
       ::addMembersToMemberGroup(ml,&memberGroupSDict,this);
     }
   }
 
   // add members inside sections to their groups
   if (memberGroupSDict)
   {
     MemberGroupSDict::Iterator mgli(*memberGroupSDict);
     MemberGroup *mg;
     for (;(mg=mgli.current());++mgli)
     {
       if (mg->allMembersInSameSection() && m_subGrouping)
       {
         //printf("----> addToDeclarationSection(%s)\n",mg->header().data());
         mg->addToDeclarationSection();
       }
     }
   }
 }

void NamespaceDef::addMemberToList	(	MemberListType	lt,
		MemberDef *	md
	)

private

Definition at line 1039 of file namespacedef.cpp.

 {
   static bool sortBriefDocs = Config_getBool("SORT_BRIEF_DOCS");
   static bool sortMemberDocs = Config_getBool("SORT_MEMBER_DOCS");
   MemberList *ml = createMemberList(lt);
   ml->setNeedsSorting(
       ((ml->listType()&MemberListType_declarationLists) && sortBriefDocs) ||
       ((ml->listType()&MemberListType_documentationLists) && sortMemberDocs));
   ml->append(md);
 
 #if 0
   if (ml->needsSorting())
     ml->inSort(md);
   else
     ml->append(md);
 #endif
 
   if (ml->listType()&MemberListType_declarationLists) md->setSectionList(this,ml);
 }

void NamespaceDef::addNamespaceAttributes ( OutputList & ol )

private

Definition at line 538 of file namespacedef.cpp.

 {
   // UNO IDL constant groups may be published
   if (getLanguage()==SrcLangExt_IDL && isConstantGroup() && m_isPublished)
   {
     ol.pushGeneratorState();
     ol.disableAllBut(OutputGenerator::Html);
     ol.startLabels();
     ol.writeLabel("published",false);
     ol.endLabels();
     ol.popGeneratorState();
   }
 }

void NamespaceDef::addUsingDeclaration ( Definition * def )

Definition at line 787 of file namespacedef.cpp.

 {
   if (usingDeclList==0)
   {
     usingDeclList = new SDict<Definition>(17);
   }
   if (usingDeclList->find(d->qualifiedName())==0)
   {
     usingDeclList->append(d->qualifiedName(),d);
   }
 }

void NamespaceDef::addUsingDirective ( NamespaceDef * nd )

Definition at line 768 of file namespacedef.cpp.

 {
   if (usingDirList==0)
   {
     usingDirList = new NamespaceSDict;
   }
   if (usingDirList->find(nd->qualifiedName())==0)
   {
     usingDirList->append(nd->qualifiedName(),nd);
   }
   //printf("%p: NamespaceDef::addUsingDirective: %s:%d\n",this,name().data(),usingDirList->count());
 }

QCString NamespaceDef::anchor ( ) const

inlinevirtual

Returns the anchor within a page where this item can be found

Implements Definition.

Definition at line 49 of file namespacedef.h.

49 { return QCString(); }

QCString

Definition: qcstring.h:131

void NamespaceDef::combineUsingRelations ( )

Definition at line 885 of file namespacedef.cpp.

 {
   if (visited) return; // already done
   visited=TRUE;
   if (usingDirList)
   {
     NamespaceSDict::Iterator nli(*usingDirList);
     NamespaceDef *nd;
     for (nli.toFirst();(nd=nli.current());++nli)
     {
       nd->combineUsingRelations();
     }
     for (nli.toFirst();(nd=nli.current());++nli)
     {
       // add used namespaces of namespace nd to this namespace
       if (nd->getUsedNamespaces())
       {
         NamespaceSDict::Iterator unli(*nd->getUsedNamespaces());
         NamespaceDef *und;
         for (unli.toFirst();(und=unli.current());++unli)
         {
           //printf("Adding namespace %s to the using list of %s\n",und->qualifiedName().data(),qualifiedName().data());
           addUsingDirective(und);
         }
       }
       // add used classes of namespace nd to this namespace
       if (nd->getUsedClasses())
       {
         SDict<Definition>::Iterator cli(*nd->getUsedClasses());
         Definition *ucd;
         for (cli.toFirst();(ucd=cli.current());++cli)
         {
           //printf("Adding class %s to the using list of %s\n",cd->qualifiedName().data(),qualifiedName().data());
           addUsingDeclaration(ucd);
         }
       }
     }
   }
 }

QCString NamespaceDef::compoundTypeString ( ) const

Definition at line 1165 of file namespacedef.cpp.

 {
   SrcLangExt lang = getLanguage();
   if (lang==SrcLangExt_Java)
   {
     return "package";
   }
   else if(lang==SrcLangExt_CSharp)
   {
         return "namespace";
   }
   else if (lang==SrcLangExt_Fortran)
   {
     return "module";
   }
   else if (lang==SrcLangExt_IDL)
   {
     if (isModule())
     {
       return "module";
     }
     else if (isConstantGroup())
     {
       return "constants";
     }
     else if (isLibrary())
     {
       return "library";
     }
     else
     {
       err_full(getDefFileName(),getDefLine(),"Internal inconsistency: namespace in IDL not module, library or constant group");
     }
   }
   return "";
 }

void NamespaceDef::computeAnchors ( )

Definition at line 254 of file namespacedef.cpp.

 {
   MemberList *allMemberList = getMemberList(MemberListType_allMembersList);
   if (allMemberList) setAnchors(allMemberList);
 }

int NamespaceDef::countMembers ( )

Definition at line 761 of file namespacedef.cpp.

 {
   MemberList *allMemberList = getMemberList(MemberListType_allMembersList);
   if (allMemberList) allMemberList->countDocMembers();
   return (allMemberList ? allMemberList->numDocMembers() : 0)+classSDict->count();
 }

MemberList * NamespaceDef::createMemberList ( MemberListType lt )

private

Definition at line 1021 of file namespacedef.cpp.

 {
   m_memberLists.setAutoDelete(TRUE);
   QListIterator<MemberList> mli(m_memberLists);
   MemberList *ml;
   for (mli.toFirst();(ml=mli.current());++mli)
   {
     if (ml->listType()==lt)
     {
       return ml;
     }
   }
   // not found, create a new member list
   ml = new MemberList(lt);
   m_memberLists.append(ml);
   return ml;
 }

DefType NamespaceDef::definitionType ( ) const

inlinevirtual

Use this for dynamic inspection of the type of the derived class

Implements DefinitionIntf.

Definition at line 47 of file namespacedef.h.

47 { return TypeNamespace; }

DefinitionIntf::TypeNamespace

Definition: definition.h:75

QCString NamespaceDef::displayName ( bool includeScope = TRUE ) const

virtual

Returns the name of the definition as it appears in the output

Implements Definition.

Definition at line 861 of file namespacedef.cpp.

 {
   QCString result=includeScope ? name() : localName();
   SrcLangExt lang = getLanguage();
   QCString sep = getLanguageSpecificSeparator(lang);
   if (sep!="::")
   {
     result = substitute(result,"::",sep);
   }
   //printf("NamespaceDef::displayName() %s->%s lang=%d\n",name().data(),result.data(),lang);
   return result; 
 }

void NamespaceDef::distributeMemberGroupDocumentation ( )

Definition at line 97 of file namespacedef.cpp.

 {
   MemberGroupSDict::Iterator mgli(*memberGroupSDict);
   MemberGroup *mg;
   for (;(mg=mgli.current());++mgli)
   {
     mg->distributeMemberGroupDocumentation();
   }
 }

void NamespaceDef::endMemberDeclarations ( OutputList & ol )

private

Definition at line 430 of file namespacedef.cpp.

 {
   ol.endMemberSections();
 }

void NamespaceDef::endMemberDocumentation ( OutputList & ol )

private

Definition at line 444 of file namespacedef.cpp.

 {
   if (Config_getBool("SEPARATE_MEMBER_PAGES"))
   {
     ol.enable(OutputGenerator::Html);
     Doxygen::suppressDocWarnings = FALSE;
   }
 }

Definition * NamespaceDef::findInnerCompound ( const char * name )

virtual

Reimplemented from Definition.

Definition at line 811 of file namespacedef.cpp.

 {
   if (n==0) return 0;
   Definition *d = m_innerCompounds->find(n);
   if (d==0)
   {
     if (usingDirList)
     {
       d = usingDirList->find(n);
     }
     if (d==0 && usingDeclList)
     {
       d = usingDeclList->find(n);
     }
   }
   return d;
 }

void NamespaceDef::findSectionsInDocumentation ( )

Definition at line 107 of file namespacedef.cpp.

 {
   docFindSections(documentation(),this,0,docFile());
   MemberGroupSDict::Iterator mgli(*memberGroupSDict);
   MemberGroup *mg;
   for (;(mg=mgli.current());++mgli)
   {
     mg->findSectionsInDocumentation();
   }
   QListIterator<MemberList> mli(m_memberLists);
   MemberList *ml;
   for (mli.toFirst();(ml=mli.current());++mli)
   {
     if (ml->listType()&MemberListType_declarationLists)
     {
       ml->findSectionsInDocumentation();
     }
   }
 }

ClassSDict* NamespaceDef::getClassSDict ( ) const

inline

Returns the classes contained in this namespace

Definition at line 98 of file namespacedef.h.

98 { return classSDict; }

NamespaceDef::classSDict

ClassSDict * classSDict

Definition: namespacedef.h:138

MemberDef * NamespaceDef::getMemberByName ( const QCString & n ) const

Definition at line 1129 of file namespacedef.cpp.

 {
   MemberDef *md = 0;
   if (m_allMembersDict && !n.isEmpty())
   {
     md = m_allMembersDict->find(n);
     //printf("%s::m_allMembersDict->find(%s)=%p\n",name().data(),n.data(),md);
   }
   return md;
 }

MemberGroupSDict* NamespaceDef::getMemberGroupSDict ( ) const

inline

Returns the user defined member groups

Definition at line 95 of file namespacedef.h.

95 { return memberGroupSDict; }

NamespaceDef::memberGroupSDict

MemberGroupSDict * memberGroupSDict

Definition: namespacedef.h:137

MemberList * NamespaceDef::getMemberList ( MemberListType lt ) const

Definition at line 1079 of file namespacedef.cpp.

 {
   QListIterator<MemberList> mli(m_memberLists);
   MemberList *ml;
   for (mli.toFirst();(ml=mli.current());++mli)
   {
     if (ml->listType()==lt)
     {
       return ml;
     }
   }
   return 0;
 }

const QList<MemberList>& NamespaceDef::getMemberLists ( ) const

inline

Definition at line 91 of file namespacedef.h.

91 { return m_memberLists; }

NamespaceDef::m_memberLists

QList< MemberList > m_memberLists

Definition: namespacedef.h:136

NamespaceSDict* NamespaceDef::getNamespaceSDict ( ) const

inline

Returns the namespaces contained in this namespace

Definition at line 101 of file namespacedef.h.

101 { return namespaceSDict; }

NamespaceDef::namespaceSDict

NamespaceSDict * namespaceSDict

Definition: namespacedef.h:139

QCString NamespaceDef::getOutputFileBase ( ) const

virtual

Returns the base file name (without extension) of this definition. as it is referenced to/written to disk.

Implements Definition.

Definition at line 799 of file namespacedef.cpp.

 { 
   if (isReference())
   {
     return fileName;
   }
   else
   {
     return convertNameToFile(fileName); 
   }
 }

SDict<Definition>* NamespaceDef::getUsedClasses ( ) const

inline

Definition at line 66 of file namespacedef.h.

66 { return usingDeclList; }

NamespaceDef::usingDeclList

SDict< Definition > * usingDeclList

Definition: namespacedef.h:132

NamespaceSDict * NamespaceDef::getUsedNamespaces ( ) const

Definition at line 781 of file namespacedef.cpp.

 { 
   //printf("%p: NamespaceDef::getUsedNamespace: %s:%d\n",this,name().data(),usingDirList?usingDirList->count():0);
   return usingDirList; 
 }

bool NamespaceDef::hasDetailedDescription ( ) const

Definition at line 260 of file namespacedef.cpp.

 {
   static bool repeatBrief = Config_getBool("REPEAT_BRIEF");
   return ((!briefDescription().isEmpty() && repeatBrief) ||
           !documentation().isEmpty());
 }

void NamespaceDef::insertClass ( ClassDef * cd )

Definition at line 152 of file namespacedef.cpp.

 {
   if (classSDict->find(cd->name())==0)
   {
     if (Config_getBool("SORT_BRIEF_DOCS"))
       classSDict->inSort(cd->name(),cd);
     else
       classSDict->append(cd->name(),cd);
   }
 }

void NamespaceDef::insertMember ( MemberDef * md )

Definition at line 203 of file namespacedef.cpp.

 {
   if (md->isHidden()) return;
   MemberList *allMemberList = getMemberList(MemberListType_allMembersList);
   if (allMemberList==0)
   {
     allMemberList = new MemberList(MemberListType_allMembersList);
     m_memberLists.append(allMemberList);
   }
   allMemberList->append(md); 
   if (m_allMembersDict==0)
   {
     m_allMembersDict = new MemberSDict;
   }
   //printf("%s::m_allMembersDict->append(%s)\n",name().data(),md->localName().data());
   m_allMembersDict->append(md->localName(),md); 
   //::addNamespaceMemberNameToIndex(md);
   //static bool sortBriefDocs=Config_getBool("SORT_BRIEF_DOCS");
   switch(md->memberType())
   {
     case MemberType_Variable:     
       addMemberToList(MemberListType_decVarMembers,md);
       addMemberToList(MemberListType_docVarMembers,md);
       break;
     case MemberType_Function: 
       addMemberToList(MemberListType_decFuncMembers,md);
       addMemberToList(MemberListType_docFuncMembers,md);
       break;
     case MemberType_Typedef:      
       addMemberToList(MemberListType_decTypedefMembers,md);
       addMemberToList(MemberListType_docTypedefMembers,md);
       break;
     case MemberType_Enumeration:  
       addMemberToList(MemberListType_decEnumMembers,md);
       addMemberToList(MemberListType_docEnumMembers,md);
       break;
     case MemberType_EnumValue:    
       break;
     case MemberType_Define:       
       addMemberToList(MemberListType_decDefineMembers,md);
       addMemberToList(MemberListType_docDefineMembers,md);
       break;
     default:
       err("NamespaceDef::insertMembers(): "
            "member `%s' with class scope `%s' inserted in namespace scope `%s'!\n",
            md->name().data(),
            md->getClassDef() ? md->getClassDef()->name().data() : "",
            name().data());
   }
 }

void NamespaceDef::insertNamespace ( NamespaceDef * nd )

Definition at line 163 of file namespacedef.cpp.

 {
   if (namespaceSDict->find(nd->name())==0)
   {
     if (Config_getBool("SORT_MEMBER_DOCS"))
       namespaceSDict->inSort(nd->name(),nd);
     else
       namespaceSDict->append(nd->name(),nd);
   }
 }

void NamespaceDef::insertUsedFile ( FileDef * fd )

Definition at line 127 of file namespacedef.cpp.

 {
   if (fd==0) return;
   if (files.find(fd)==-1) 
   {
     if (Config_getBool("SORT_MEMBER_DOCS"))
       files.inSort(fd);
     else
       files.append(fd);
   }
 }

bool NamespaceDef::isConstantGroup ( ) const

inline

Definition at line 71 of file namespacedef.h.

71 { return CONSTANT_GROUP == m_type; }

NamespaceDef::CONSTANT_GROUP

Definition: namespacedef.h:141

NamespaceDef::m_type

enum NamespaceDef::@8 m_type

bool NamespaceDef::isLibrary ( ) const

inline

Definition at line 73 of file namespacedef.h.

73 { return LIBRARY == m_type; }

NamespaceDef::LIBRARY

Definition: namespacedef.h:141

NamespaceDef::m_type

enum NamespaceDef::@8 m_type

bool NamespaceDef::isLinkable ( ) const

virtual

Returns TRUE iff it is possible to link to this item. This can be a link to another project imported via a tag file.

Implements Definition.

Definition at line 1124 of file namespacedef.cpp.

 {
   return isLinkableInProject() || isReference();
 }

bool NamespaceDef::isLinkableInProject ( ) const

virtual

Returns TRUE iff it is possible to link to this item within this project.

Implements Definition.

Definition at line 1106 of file namespacedef.cpp.

 {
   int i = name().findRev("::");
   if (i==-1) i=0; else i+=2;
   static bool extractAnonNs = Config_getBool("EXTRACT_ANON_NSPACES");
   if (extractAnonNs &&                             // extract anonymous ns
       name().mid(i,20)=="anonymous_namespace{"     // correct prefix
      )                                             // not disabled by config
   {
     return TRUE;
   }
   return !name().isEmpty() && name().at(i)!='@' && // not anonymous
     (hasDocumentation() || getLanguage()==SrcLangExt_CSharp) &&  // documented
     !isReference() &&      // not an external reference
     !isHidden() &&         // not hidden
     !isArtificial();       // or artificial
 }

bool NamespaceDef::isModule ( ) const

inline

Definition at line 72 of file namespacedef.h.

72 { return MODULE == m_type; }

NamespaceDef::MODULE

Definition: namespacedef.h:141

NamespaceDef::m_type

enum NamespaceDef::@8 m_type

QCString NamespaceDef::localName ( ) const

Definition at line 874 of file namespacedef.cpp.

 {
   QCString result=name();
   int i=result.findRev("::");
   if (i!=-1)
   {
     result=result.mid(i+2);
   }
   return result;
 }

void NamespaceDef::setFileName ( const QCString & fn )

Definition at line 91 of file namespacedef.cpp.

 {
   fileName="namespace";
   fileName+=fn;
 }

void NamespaceDef::sortMemberLists ( )

Definition at line 1059 of file namespacedef.cpp.

 {
   QListIterator<MemberList> mli(m_memberLists);
   MemberList *ml;
   for (mli.toFirst();(ml=mli.current());++mli)
   {
     if (ml->needsSorting()) { ml->sort(); ml->setNeedsSorting(FALSE); }
   }
   if (classSDict)
   {
     classSDict->sort();
   }
   if (namespaceSDict)
   {
     namespaceSDict->sort();
   }
 }

void NamespaceDef::startMemberDeclarations ( OutputList & ol )

private

Definition at line 425 of file namespacedef.cpp.

 {
   ol.startMemberSections();
 }

void NamespaceDef::startMemberDocumentation ( OutputList & ol )

private

Definition at line 435 of file namespacedef.cpp.

 {
   if (Config_getBool("SEPARATE_MEMBER_PAGES"))
   {
     ol.disable(OutputGenerator::Html);
     Doxygen::suppressDocWarnings = TRUE;
   }
 }

bool NamespaceDef::subGrouping ( ) const

inline

Definition at line 88 of file namespacedef.h.

88 { return m_subGrouping; }

NamespaceDef::m_subGrouping

bool m_subGrouping

Definition: namespacedef.h:140

QCString NamespaceDef::title ( ) const

Definition at line 1140 of file namespacedef.cpp.

 {
   SrcLangExt lang = getLanguage();
   QCString pageTitle;
   if (lang==SrcLangExt_Java)
   {
     pageTitle = theTranslator->trPackage(displayName());
   }
   else if (lang==SrcLangExt_Fortran)
   {
     pageTitle = theTranslator->trModuleReference(displayName());
   }
   else if (lang==SrcLangExt_IDL)
   {
     pageTitle = isConstantGroup()
         ? theTranslator->trConstantGroupReference(displayName())
         : theTranslator->trModuleReference(displayName());
   }
   else
   {
     pageTitle = theTranslator->trNamespaceReference(displayName());
   }
   return pageTitle;
 }

void NamespaceDef::writeAuthorSection ( OutputList & ol )

private

Definition at line 488 of file namespacedef.cpp.

 {
   // write Author section (Man only)
   ol.pushGeneratorState();
   ol.disableAllBut(OutputGenerator::Man);
   ol.startGroupHeader();
   ol.parseText(theTranslator->trAuthor(TRUE,TRUE));
   ol.endGroupHeader();
   ol.parseText(theTranslator->trGeneratedAutomatically(Config_getString("PROJECT_NAME")));
   ol.popGeneratorState();
 }

void NamespaceDef::writeBriefDescription ( OutputList & ol )

private

Definition at line 389 of file namespacedef.cpp.

 {
   if (hasBriefDescription())
   {
     DocRoot *rootNode = validatingParseDoc(briefFile(),briefLine(),this,0,
                         briefDescription(),TRUE,FALSE,0,TRUE,FALSE);
     if (rootNode && !rootNode->isEmpty())
     {
       ol.startParagraph();
       ol.writeDoc(rootNode,this,0);
       ol.pushGeneratorState();
       ol.disable(OutputGenerator::RTF);
       ol.writeString(" \n");
       ol.enable(OutputGenerator::RTF);
 
       if (hasDetailedDescription())
       {
         ol.disableAllBut(OutputGenerator::Html);
         ol.startTextLink(0,"details");
         ol.parseText(theTranslator->trMore());
         ol.endTextLink();
       }
       ol.popGeneratorState();
       ol.endParagraph();
     }
     delete rootNode;
 
     // FIXME:PARA
     //ol.pushGeneratorState();
     //ol.disable(OutputGenerator::RTF);
     //ol.newParagraph();
     //ol.popGeneratorState();
   }
   ol.writeSynopsis();
 }

void NamespaceDef::writeClassDeclarations	(	OutputList &	ol,
		const QCString &	title
	)

private

Definition at line 453 of file namespacedef.cpp.

 {
   if (classSDict) classSDict->writeDeclaration(ol,0,title,TRUE);
 }

void NamespaceDef::writeDetailedDescription	(	OutputList &	ol,
		const QCString &	title
	)

private

Definition at line 347 of file namespacedef.cpp.

 {
   if (hasDetailedDescription())
   {
     ol.pushGeneratorState();
       ol.disable(OutputGenerator::Html);
       ol.writeRuler();
     ol.popGeneratorState();
     ol.pushGeneratorState();
       ol.disableAllBut(OutputGenerator::Html);
       ol.writeAnchor(0,"details"); 
     ol.popGeneratorState();
     ol.startGroupHeader();
     ol.parseText(title);
     ol.endGroupHeader();
 
     ol.startTextBlock();
     if (!briefDescription().isEmpty() && Config_getBool("REPEAT_BRIEF"))
     {
       ol.generateDoc(briefFile(),briefLine(),this,0,briefDescription(),FALSE,FALSE);
     }
     if (!briefDescription().isEmpty() && Config_getBool("REPEAT_BRIEF") &&
         !documentation().isEmpty())
     {
       ol.pushGeneratorState();
         ol.disable(OutputGenerator::Man);
         ol.disable(OutputGenerator::RTF);
         //ol.newParagraph(); // FIXME:PARA
         ol.enableAll();
         ol.disableAllBut(OutputGenerator::Man);
         ol.enable(OutputGenerator::Latex);
         ol.writeString("\n\n");
       ol.popGeneratorState();
     }
     if (!documentation().isEmpty())
     {
       ol.generateDoc(docFile(),docLine(),this,0,documentation()+"\n",TRUE,FALSE);
     }
     ol.endTextBlock();
   }
 }

void NamespaceDef::writeDocumentation ( OutputList & ol )

Definition at line 552 of file namespacedef.cpp.

 {
   static bool generateTreeView = Config_getBool("GENERATE_TREEVIEW");
   //static bool outputJava = Config_getBool("OPTIMIZE_OUTPUT_JAVA");
   //static bool fortranOpt = Config_getBool("OPTIMIZE_FOR_FORTRAN");
 
   QCString pageTitle = title();
   startFile(ol,getOutputFileBase(),name(),pageTitle,HLI_NamespaceVisible,!generateTreeView);
 
   if (!generateTreeView)
   {
     if (getOuterScope()!=Doxygen::globalScope)
     {
       writeNavigationPath(ol);
     }
     ol.endQuickIndices();
   }
 
   startTitle(ol,getOutputFileBase(),this);
   ol.parseText(pageTitle);
   addGroupListToTitle(ol,this);
   addNamespaceAttributes(ol);
   endTitle(ol,getOutputFileBase(),displayName());
   ol.startContents();
   
   if (Doxygen::searchIndex)
   {
     Doxygen::searchIndex->setCurrentDoc(this,anchor(),FALSE);
     Doxygen::searchIndex->addWord(localName(),TRUE);
   }
 
   Doxygen::indexList->addIndexItem(this,0);
 
   //---------------------------------------- start flexible part -------------------------------
 
   SrcLangExt lang = getLanguage();
   QListIterator<LayoutDocEntry> eli(
       LayoutDocManager::instance().docEntries(LayoutDocManager::Namespace));
   LayoutDocEntry *lde;
   for (eli.toFirst();(lde=eli.current());++eli)
   {
     switch (lde->kind())
     {
       case LayoutDocEntry::BriefDesc: 
         writeBriefDescription(ol);
         break; 
       case LayoutDocEntry::MemberDeclStart: 
         startMemberDeclarations(ol);
         break; 
       case LayoutDocEntry::NamespaceClasses: 
         {
           LayoutDocEntrySection *ls = (LayoutDocEntrySection*)lde;
           writeClassDeclarations(ol,ls->title(lang));
         }
         break; 
       case LayoutDocEntry::NamespaceNestedNamespaces: 
         {
           LayoutDocEntrySection *ls = (LayoutDocEntrySection*)lde;
           writeNamespaceDeclarations(ol,ls->title(lang),false);
         }
         break; 
       case LayoutDocEntry::NamespaceNestedConstantGroups:
         {
           LayoutDocEntrySection *ls = (LayoutDocEntrySection*)lde;
           writeNamespaceDeclarations(ol,ls->title(lang),true);
         }
         break;
       case LayoutDocEntry::MemberGroups: 
         writeMemberGroups(ol);
         break; 
       case LayoutDocEntry::MemberDecl: 
         {
           LayoutDocEntryMemberDecl *lmd = (LayoutDocEntryMemberDecl*)lde;
           writeMemberDeclarations(ol,lmd->type,lmd->title(lang));
         }
         break; 
       case LayoutDocEntry::MemberDeclEnd: 
         endMemberDeclarations(ol);
         break;
       case LayoutDocEntry::DetailedDesc: 
         {
           LayoutDocEntrySection *ls = (LayoutDocEntrySection*)lde;
           writeDetailedDescription(ol,ls->title(lang));
         }
         break;
       case LayoutDocEntry::MemberDefStart: 
         startMemberDocumentation(ol);
         break; 
       case LayoutDocEntry::NamespaceInlineClasses:
         writeInlineClasses(ol);
         break;
       case LayoutDocEntry::MemberDef: 
         {
           LayoutDocEntryMemberDef *lmd = (LayoutDocEntryMemberDef*)lde;
           writeMemberDocumentation(ol,lmd->type,lmd->title(lang));
         }
         break;
       case LayoutDocEntry::MemberDefEnd: 
         endMemberDocumentation(ol);
         break;
       case LayoutDocEntry::AuthorSection: 
         writeAuthorSection(ol);
         break;
       case LayoutDocEntry::ClassIncludes:
       case LayoutDocEntry::ClassInheritanceGraph:
       case LayoutDocEntry::ClassNestedClasses:
       case LayoutDocEntry::ClassCollaborationGraph:
       case LayoutDocEntry::ClassAllMembersLink:
       case LayoutDocEntry::ClassUsedFiles:
       case LayoutDocEntry::ClassInlineClasses:
       case LayoutDocEntry::FileClasses:
       case LayoutDocEntry::FileNamespaces:
       case LayoutDocEntry::FileConstantGroups:
       case LayoutDocEntry::FileIncludes:
       case LayoutDocEntry::FileIncludeGraph:
       case LayoutDocEntry::FileIncludedByGraph: 
       case LayoutDocEntry::FileSourceLink:
       case LayoutDocEntry::FileInlineClasses:
       case LayoutDocEntry::GroupClasses: 
       case LayoutDocEntry::GroupInlineClasses: 
       case LayoutDocEntry::GroupNamespaces:
       case LayoutDocEntry::GroupDirs: 
       case LayoutDocEntry::GroupNestedGroups: 
       case LayoutDocEntry::GroupFiles:
       case LayoutDocEntry::GroupGraph: 
       case LayoutDocEntry::GroupPageDocs:
       case LayoutDocEntry::DirSubDirs:
       case LayoutDocEntry::DirFiles:
       case LayoutDocEntry::DirGraph:
         err("Internal inconsistency: member %d should not be part of "
             "LayoutDocManager::Namespace entry list\n",lde->kind());
         break;
     }
   }
 
   //---------------------------------------- end flexible part -------------------------------
 
   ol.endContents();
 
   endFileWithNavPath(this,ol);
 
   if (Config_getBool("SEPARATE_MEMBER_PAGES"))
   {
     MemberList *allMemberList = getMemberList(MemberListType_allMembersList);
     if (allMemberList) allMemberList->sort();
     writeMemberPages(ol);
   }
 }

void NamespaceDef::writeInlineClasses ( OutputList & ol )

private

Definition at line 458 of file namespacedef.cpp.

 {
   if (classSDict) classSDict->writeDocumentation(ol,this);
 }

void NamespaceDef::writeMemberDeclarations	(	OutputList &	ol,
		MemberListType	lt,
		const QCString &	title
	)

private

Definition at line 1093 of file namespacedef.cpp.

 {
   MemberList * ml = getMemberList(lt);
   if (ml) ml->writeDeclarations(ol,0,this,0,0,title,0);
 }

void NamespaceDef::writeMemberDocumentation	(	OutputList &	ol,
		MemberListType	lt,
		const QCString &	title
	)

private

Definition at line 1099 of file namespacedef.cpp.

 {
   MemberList * ml = getMemberList(lt);
   if (ml) ml->writeDocumentation(ol,displayName(),this,title);
 }

void NamespaceDef::writeMemberGroups ( OutputList & ol )

private

Definition at line 469 of file namespacedef.cpp.

 {
   /* write user defined member groups */
   if (memberGroupSDict)
   {
     memberGroupSDict->sort();
     MemberGroupSDict::Iterator mgli(*memberGroupSDict);
     MemberGroup *mg;
     for (;(mg=mgli.current());++mgli)
     {
       if ((!mg->allMembersInSameSection() || !m_subGrouping) 
           && mg->header()!="[NOHEADER]")
       {
         mg->writeDeclarations(ol,0,this,0,0);
       }
     }
   }
 }

void NamespaceDef::writeMemberPages ( OutputList & ol )

Definition at line 701 of file namespacedef.cpp.

 {
   ol.pushGeneratorState();
   ol.disableAllBut(OutputGenerator::Html);
 
   QListIterator<MemberList> mli(m_memberLists);
   MemberList *ml;
   for (mli.toFirst();(ml=mli.current());++mli)
   {
     if (ml->listType()&MemberListType_documentationLists)
     {
       ml->writeDocumentationPage(ol,displayName(),this);
     }
   }
   ol.popGeneratorState();
 }

void NamespaceDef::writeNamespaceDeclarations	(	OutputList &	ol,
		const QCString &	title,
		bool	isConstantGroup = `false`
	)

private

Definition at line 463 of file namespacedef.cpp.

 {
   if (namespaceSDict) namespaceSDict->writeDeclaration(ol,title,isConstantGroup,TRUE);
 }

void NamespaceDef::writeQuickMemberLinks	(	OutputList &	ol,
		MemberDef *	currentMd
	)		const

virtual

Reimplemented from Definition.

Definition at line 718 of file namespacedef.cpp.

 {
   static bool createSubDirs=Config_getBool("CREATE_SUBDIRS");
 
   ol.writeString("      <div class=\"navtab\">\n");
   ol.writeString("        <table>\n");
 
   MemberList *allMemberList = getMemberList(MemberListType_allMembersList);
   if (allMemberList)
   {
     MemberListIterator mli(*allMemberList);
     MemberDef *md;
     for (mli.toFirst();(md=mli.current());++mli)
     {
       if (md->getNamespaceDef()==this && md->isLinkable() && !md->isEnumValue())
       {
         ol.writeString("          <tr><td class=\"navtab\">");
         if (md->isLinkableInProject())
         {
           if (md==currentMd) // selected item => highlight
           {
             ol.writeString("<a class=\"qindexHL\" ");
           }
           else
           {
             ol.writeString("<a class=\"qindex\" ");
           }
           ol.writeString("href=\"");
           if (createSubDirs) ol.writeString("../../");
           ol.writeString(md->getOutputFileBase()+Doxygen::htmlFileExtension+"#"+md->anchor());
           ol.writeString("\">");
           ol.writeString(convertToHtml(md->localName()));
           ol.writeString("</a>");
         }
         ol.writeString("</td></tr>\n");
       }
     }
   }
 
   ol.writeString("        </table>\n");
   ol.writeString("      </div>\n");
 }

void NamespaceDef::writeSummaryLinks ( OutputList & ol )

privatevirtual

Reimplemented from Definition.

Definition at line 500 of file namespacedef.cpp.

 {
   ol.pushGeneratorState();
   ol.disableAllBut(OutputGenerator::Html);
   QListIterator<LayoutDocEntry> eli(
       LayoutDocManager::instance().docEntries(LayoutDocManager::Namespace));
   LayoutDocEntry *lde;
   bool first=TRUE;
   SrcLangExt lang = getLanguage();
   for (eli.toFirst();(lde=eli.current());++eli)
   {
     if ((lde->kind()==LayoutDocEntry::NamespaceClasses && classSDict && classSDict->declVisible()) || 
         (lde->kind()==LayoutDocEntry::NamespaceNestedNamespaces && namespaceSDict && namespaceSDict->declVisible())
        )
     {
       LayoutDocEntrySection *ls = (LayoutDocEntrySection*)lde;
       QCString label = lde->kind()==LayoutDocEntry::NamespaceClasses ? "nested-classes" : "namespaces";
       ol.writeSummaryLink(0,label,ls->title(lang),first);
       first=FALSE;
     }
     else if (lde->kind()== LayoutDocEntry::MemberDecl)
     {
       LayoutDocEntryMemberDecl *lmd = (LayoutDocEntryMemberDecl*)lde;
       MemberList * ml = getMemberList(lmd->type);
       if (ml && ml->declVisible())
       {
         ol.writeSummaryLink(0,MemberList::listTypeAsString(ml->listType()),lmd->title(lang),first);
         first=FALSE;
       }
     }
   }
   if (!first)
   {
     ol.writeString("  </div>\n");
   }
   ol.popGeneratorState();
 }

void NamespaceDef::writeTagFile ( FTextStream & tagFile )

Definition at line 267 of file namespacedef.cpp.

 {
   tagFile << "  <compound kind=\"namespace\">" << endl;
   tagFile << "    <name>" << convertToXML(name()) << "</name>" << endl;
   tagFile << "    <filename>" << convertToXML(getOutputFileBase()) << Doxygen::htmlFileExtension << "</filename>" << endl;
   QCString idStr = id();
   if (!idStr.isEmpty())
   {
     tagFile << "    <clangid>" << convertToXML(idStr) << "</clangid>" << endl;
   }
   QListIterator<LayoutDocEntry> eli(
       LayoutDocManager::instance().docEntries(LayoutDocManager::Namespace));
   LayoutDocEntry *lde;
   for (eli.toFirst();(lde=eli.current());++eli)
   {
     switch (lde->kind())
     {
       case LayoutDocEntry::NamespaceNestedNamespaces:
         {
           if (namespaceSDict)
           {
             SDict<NamespaceDef>::Iterator ni(*namespaceSDict);
             NamespaceDef *nd;
             for (ni.toFirst();(nd=ni.current());++ni)
             {
               if (nd->isLinkableInProject())
               {
                 tagFile << "    <namespace>" << convertToXML(nd->name()) << "</namespace>" << endl;
               }
             }
           }
         }
         break;
       case LayoutDocEntry::NamespaceClasses:
         {
           if (classSDict)
           {
             SDict<ClassDef>::Iterator ci(*classSDict);
             ClassDef *cd;
             for (ci.toFirst();(cd=ci.current());++ci)
             {
               if (cd->isLinkableInProject())
               {
                 tagFile << "    <class kind=\"" << cd->compoundTypeString()
                         << "\">" << convertToXML(cd->name()) << "</class>" << endl;
               }
             }
           }
         }
       case LayoutDocEntry::MemberDecl:
         {
           LayoutDocEntryMemberDecl *lmd = (LayoutDocEntryMemberDecl*)lde;
           MemberList * ml = getMemberList(lmd->type);
           if (ml)
           {
             ml->writeTagFile(tagFile);
           }
         }
         break;
       case LayoutDocEntry::MemberGroups:
         {
           if (memberGroupSDict)
           {
             MemberGroupSDict::Iterator mgli(*memberGroupSDict);
             MemberGroup *mg;
             for (;(mg=mgli.current());++mgli)
             {
               mg->writeTagFile(tagFile);
             }
           }
         }
         break;
       default:
         break;
     }
   }
   writeDocAnchorsToTagFile(tagFile);
   tagFile << "  </compound>" << endl;
 }

Member Data Documentation

ClassSDict* NamespaceDef::classSDict

private

Definition at line 138 of file namespacedef.h.

QCString NamespaceDef::fileName

private

Definition at line 128 of file namespacedef.h.

FileList NamespaceDef::files

private

Definition at line 129 of file namespacedef.h.

MemberSDict* NamespaceDef::m_allMembersDict

private

Definition at line 135 of file namespacedef.h.

SDict<Definition>* NamespaceDef::m_innerCompounds

private

Definition at line 133 of file namespacedef.h.

bool NamespaceDef::m_isPublished

private

Definition at line 142 of file namespacedef.h.

QList<MemberList> NamespaceDef::m_memberLists

private

Definition at line 136 of file namespacedef.h.

bool NamespaceDef::m_subGrouping

private

Definition at line 140 of file namespacedef.h.

enum { ... } NamespaceDef::m_type

MemberGroupSDict* NamespaceDef::memberGroupSDict

private

Definition at line 137 of file namespacedef.h.

NamespaceSDict* NamespaceDef::namespaceSDict

private

Definition at line 139 of file namespacedef.h.

SDict<Definition>* NamespaceDef::usingDeclList

private

Definition at line 132 of file namespacedef.h.

NamespaceSDict* NamespaceDef::usingDirList

private

Definition at line 131 of file namespacedef.h.

bool NamespaceDef::visited

Definition at line 106 of file namespacedef.h.

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

doxygen-1.8.11/src/namespacedef.h
doxygen-1.8.11/src/namespacedef.cpp

Public Member Functions

Public Attributes

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation