The namespacedef.h File Reference

Included Headers

#include <memory> #include <unordered_set> #include "definition.h" #include "filedef.h" #include "linkedmap.h" #include "membergroup.h"

Classes Index

class	NamespaceLinkedMap
class	NamespaceLinkedRefMap
class	NamespaceDef
	An abstract interface of a namespace symbol. More...
class	NamespaceDefMutable

Typedefs Index

using	NamespaceDefSet = std::unordered_set< const NamespaceDef * >

Functions Index

std::unique_ptr< NamespaceDef >	createNamespaceDef (const QCString &defFileName, int defLine, int defColumn, const QCString &name, const QCString &ref=QCString(), const QCString &refFile=QCString(), const QCString &type=QCString(), bool isPublished=false)
	Factory method to create new NamespaceDef instance. More...
std::unique_ptr< NamespaceDef >	createNamespaceDefAlias (const Definition *newScope, const NamespaceDef *nd)
	Factory method to create an alias of an existing namespace. More...
NamespaceDef *	toNamespaceDef (Definition *d)
NamespaceDef *	toNamespaceDef (DefinitionMutable *d)
const NamespaceDef *	toNamespaceDef (const Definition *d)
NamespaceDefMutable *	toNamespaceDefMutable (Definition *d)
void	replaceNamespaceAliases (QCString &name)
NamespaceDef *	getResolvedNamespace (const QCString &key)
NamespaceDefMutable *	getResolvedNamespaceMutable (const QCString &key)
bool	namespaceHasNestedNamespace (const NamespaceDef *nd)
bool	namespaceHasNestedConcept (const NamespaceDef *nd)
bool	namespaceHasNestedClass (const NamespaceDef *nd, bool filterClasses, ClassDef::CompoundType ct)

Typedefs

NamespaceDefSet

using NamespaceDefSet = std::unordered_set<const NamespaceDef*>

Definition at line 39 of file namespacedef.h.

39using NamespaceDefSet = std::unordered_set<const NamespaceDef*>;

Functions

createNamespaceDef()

std::unique_ptr< NamespaceDef > createNamespaceDef (const QCString & defFileName, int defLine, int defColumn, const QCString & name, const QCString & ref=QCString(), const QCString & refFile=QCString(), const QCString & type=QCString(), bool isPublished=false)

Factory method to create new NamespaceDef instance.

Declaration at line 130 of file namespacedef.h, definition at line 174 of file namespacedef.cpp.

174std::unique_ptr<NamespaceDef> createNamespaceDef(const QCString &defFileName,int defLine,int defColumn,

175 const QCString &name,const QCString &ref,

176 const QCString &refFile,const QCString &type,

177 bool isPublished)

178{

179 //printf("createNamespaceDef(%s)\n",qPrint(name));

180 return std::make_unique<NamespaceDefImpl>(defFileName,defLine,defColumn,name,ref,refFile,type,isPublished);

181}

Referenced by adjustConfiguration, buildNamespaceList, buildScopeFromQualifiedName, findUsingDirectives and NamespaceDefMutable::setInline.

createNamespaceDefAlias()

std::unique_ptr< NamespaceDef > createNamespaceDefAlias (const Definition * newScope, const NamespaceDef * nd)

Factory method to create an alias of an existing namespace.

Used for inline namespaces.

Declaration at line 136 of file namespacedef.h, definition at line 262 of file namespacedef.cpp.

262std::unique_ptr<NamespaceDef> createNamespaceDefAlias(const Definition *newScope,const NamespaceDef *nd)

263{

264 auto alnd = std::make_unique<NamespaceDefAliasImpl>(newScope,nd);

265 //printf("alnd name=%s localName=%s qualifiedName=%s displayName()=%s\n",

266 // qPrint(alnd->name()),qPrint(alnd->localName()),qPrint(alnd->qualifiedName()),

267 // qPrint(alnd->displayName()));

268 return alnd;

269}

Referenced by buildNamespaceList and NamespaceDefMutable::setInline.

getResolvedNamespace()

NamespaceDef * getResolvedNamespace (const QCString & key)

Declaration at line 149 of file namespacedef.h, definition at line 1789 of file namespacedef.cpp.

1789NamespaceDef *getResolvedNamespace(const QCString &name)

1790{

1791 //printf("> getResolvedNamespace(%s)\n",qPrint(name));

1792 if (name.isEmpty()) return nullptr;

1793 StringSet namespacesTried;

1794 auto ns = getResolvedNamespaceRec(namespacesTried,NamespaceAliasInfo(name.str()));

1795 //printf("< getResolvedNamespace(%s)=%s\n",qPrint(name),ns?qPrint(ns->qualifiedName()):"nullptr");

1796 return ns;

1797}

References getResolvedNamespaceRec, QCString::isEmpty and QCString::str.

Referenced by addMemberFunction, buildFunctionList, buildTypedefList, extractNamespaceName, findUsedNamespace, findUsingDeclImports, findUsingDirectives, generateClassOrGlobalLink, generateClassOrGlobalLink, getResolvedNamespaceMutable, CCodeParser::parseCode, setCallContextForVar, NamespaceDefMutable::setInline and writeAlphabeticalClassList.

getResolvedNamespaceMutable()

NamespaceDefMutable * getResolvedNamespaceMutable (const QCString & key)

inline

Definition at line 150 of file namespacedef.h.

150inline NamespaceDefMutable *getResolvedNamespaceMutable(const QCString &key)

151{

152 return toNamespaceDefMutable(getResolvedNamespace(key));

153}

References getResolvedNamespace, getResolvedNamespaceMutable and toNamespaceDefMutable.

Referenced by addEnumValuesToEnums, addGlobalFunction, addVariableToFile, findEnums, findUsingDeclarations, findUsingDirectives and getResolvedNamespaceMutable.

namespaceHasNestedClass()

bool namespaceHasNestedClass (const NamespaceDef * nd, bool filterClasses, ClassDef::CompoundType ct)

Declaration at line 156 of file namespacedef.h, definition at line 1837 of file namespacedef.cpp.

1837bool namespaceHasNestedClass(const NamespaceDef *nd,bool filterClasses,ClassDef::CompoundType ct)

1838{

1839 //printf(">namespaceHasNestedClass(%s,filterClasses=%d)\n",qPrint(nd->name()),filterClasses);

1840 for (const auto &cnd : nd->getNamespaces())

1841 {

1842 if (namespaceHasNestedClass(cnd,filterClasses,ct))

1843 {

1844 //printf("<namespaceHasNestedClass(%s,filterClasses=%d): case1\n",qPrint(nd->name()),filterClasses);

1845 return true;

1846 }

1847 }

1848

1849 ClassLinkedRefMap list = nd->getClasses();

1850 if (filterClasses)

1851 {

1852 switch (ct)

1853 {

1854 case ClassDef::Interface:

1855 list = nd->getInterfaces();

1856 break;

1857 case ClassDef::Struct:

1858 list = nd->getStructs();

1859 break;

1860 case ClassDef::Exception:

1861 list = nd->getExceptions();

1862 break;

1863 default:

1864 break;

1865 }

1866 }

1867

1868 for (const auto &cd : list)

1869 {

1870 //printf("candidate %s isLinkableInProject()=%d\n",qPrint(cd->name()),cd->isLinkableInProject());

1871 if (cd->isLinkableInProject())

1872 {

1873 //printf("<namespaceHasNestedClass(%s,filterClasses=%d): case2\n",qPrint(nd->name()),filterClasses);

1874 return true;

1875 }

1876 }

1877 //printf("<namespaceHasNestedClass(%s,filterClasses=%d): case3\n",qPrint(nd->name()),filterClasses);

1878 return false;

1879}

References ClassDef::Exception, NamespaceDef::getClasses, NamespaceDef::getExceptions, NamespaceDef::getInterfaces, NamespaceDef::getNamespaces, NamespaceDef::getStructs, ClassDef::Interface, namespaceHasNestedClass and ClassDef::Struct.

Referenced by namespaceHasNestedClass, writeClassTreeInsideNamespaceElement and writeNamespaceTreeElement.

namespaceHasNestedConcept()

bool namespaceHasNestedConcept (const NamespaceDef * nd)

Declaration at line 155 of file namespacedef.h, definition at line 1813 of file namespacedef.cpp.

1813bool namespaceHasNestedConcept(const NamespaceDef *nd)

1814{

1815 //printf(">namespaceHasNestedConcept(%s)\n",qPrint(nd->name()));

1816 for (const auto &cnd : nd->getNamespaces())

1817 {

1818 if (namespaceHasNestedConcept(cnd))

1819 {

1820 //printf("<namespaceHasNestedConcept(%s): case1\n",qPrint(nd->name()));

1821 return true;

1822 }

1823 }

1824 for (const auto &cnd : nd->getConcepts())

1825 {

1826 //printf("candidate %s isLinkableInProject()=%d\n",qPrint(cnd->name()),cnd->isLinkableInProject());

1827 if (cnd->isLinkableInProject())

1828 {

1829 //printf("<namespaceHasNestedConcept(%s): case2\n",qPrint(nd->name()));

1830 return true;

1831 }

1832 }

1833 //printf("<namespaceHasNestedConcept(%s): case3\n",qPrint(nd->name()));

1834 return false;

1835}

References NamespaceDef::getConcepts, NamespaceDef::getNamespaces and namespaceHasNestedConcept.

Referenced by namespaceHasNestedConcept, writeConceptTreeInsideNamespaceElement and writeNamespaceTreeElement.

namespaceHasNestedNamespace()

bool namespaceHasNestedNamespace (const NamespaceDef * nd)

Declaration at line 154 of file namespacedef.h, definition at line 1801 of file namespacedef.cpp.

1801bool namespaceHasNestedNamespace(const NamespaceDef *nd)

1802{

1803 for (const auto &cnd : nd->getNamespaces())

1804 {

1805 if (cnd->isLinkableInProject() && !cnd->isAnonymous())

1806 {

1807 return true;

1808 }

1809 }

1810 return false;

1811}

Reference NamespaceDef::getNamespaces.

Referenced by writeNamespaceTreeElement.

replaceNamespaceAliases()

void replaceNamespaceAliases (QCString & name)

Declaration at line 148 of file namespacedef.h, definition at line 1781 of file namespacedef.cpp.

1781void replaceNamespaceAliases(QCString &name)

1782{

1783 //printf("> replaceNamespaceAliases(%s)\n",qPrint(name));

1784 StringSet namespacesTried;

1785 name = replaceNamespaceAliasesRec(namespacesTried,name);

1786 //printf("< replaceNamespaceAliases: result=%s\n",qPrint(name));

1787}

Reference replaceNamespaceAliasesRec.

Referenced by findClassRelation, findUsedClassesForClass, getMemberFromSymbol, SymbolResolver::Private::getResolvedSymbolRec, SymbolResolver::Private::getResolvedTypeRec and NamespaceDefMutable::setInline.

toNamespaceDef()

NamespaceDef * toNamespaceDef (Definition * d)

Declaration at line 141 of file namespacedef.h, definition at line 1640 of file namespacedef.cpp.

1640NamespaceDef *toNamespaceDef(Definition *d)

1641{

1642 if (d && (typeid(*d)==typeid(NamespaceDefImpl) || typeid(*d)==typeid(NamespaceDefAliasImpl)))

1643 {

1644 return static_cast<NamespaceDef*>(d);

1645 }

1646 else

1647 {

1648 return nullptr;

1649 }

1650}

Referenced by DocSets::addIndexItem, NamespaceDefImpl::addInnerCompound, buildNamespaceList, findGlobalMember, findUsingDirectives, SymbolResolver::Private::followPath, generateClassMemberLink, getDefsNew, NamespaceDefAliasImpl::getNSAlias, SymbolResolver::Private::isAccessibleFrom, SymbolResolver::Private::isAccessibleFromWithExpScope, MemberDefImpl::moveTo, resolveClassNestingRelations, NamespaceDefMutable::setInline and writeJavasScriptSearchDataPage.

toNamespaceDef()

NamespaceDef * toNamespaceDef (DefinitionMutable * d)

Declaration at line 142 of file namespacedef.h, definition at line 1652 of file namespacedef.cpp.

1652NamespaceDef *toNamespaceDef(DefinitionMutable *md)

1653{

1654 Definition *d = toDefinition(md);

1655 if (d && typeid(*d)==typeid(NamespaceDefImpl))

1656 {

1657 return static_cast<NamespaceDef*>(d);

1658 }

1659 else

1660 {

1661 return nullptr;

1662 }

1663}

Reference toDefinition.

toNamespaceDef()

const NamespaceDef * toNamespaceDef (const Definition * d)

Declaration at line 143 of file namespacedef.h, definition at line 1666 of file namespacedef.cpp.

1666const NamespaceDef *toNamespaceDef(const Definition *d)

1667{

1668 if (d && (typeid(*d)==typeid(NamespaceDefImpl) || typeid(*d)==typeid(NamespaceDefAliasImpl)))

1669 {

1670 return static_cast<const NamespaceDef*>(d);

1671 }

1672 else

1673 {

1674 return nullptr;

1675 }

1676}

toNamespaceDefMutable()

NamespaceDefMutable * toNamespaceDefMutable (Definition * d)

Declaration at line 144 of file namespacedef.h, definition at line 1678 of file namespacedef.cpp.

1678NamespaceDefMutable *toNamespaceDefMutable(Definition *d)

1679{

1680 if (d && typeid(*d)==typeid(NamespaceDefImpl))

1681 {

1682 return static_cast<NamespaceDefMutable*>(d);

1683 }

1684 else

1685 {

1686 return nullptr;

1687 }

1688}

Referenced by addEnumValuesToEnums, addListReferences, addMembersToMemberGroup, addNamespaceToGroups, adjustConfiguration, buildNamespaceList, buildScopeFromQualifiedName, combineUsingRelations, FileDefImpl::combineUsingRelations, NamespaceDefImpl::combineUsingRelations, computeMemberReferences, countMembers, distributeMemberGroupDocumentation, findEnums, findScopeFromQualifiedName, findSectionsInDocumentation, findUsingDeclImports, findUsingDirectives, generateNamespaceDocs, getResolvedNamespaceMutable, NamespaceDefImpl::insertMember, insertMemberAlias, NamespaceDefMutable::setInline, sortMemberLists and writeTagFile.

---

Generated via doxygen2docusaurus by Doxygen 1.14.0.