Doxygen
Loading...
Searching...
No Matches
namespacedef.h File Reference
#include <memory>
#include <unordered_set>
#include "definition.h"
#include "filedef.h"
#include "linkedmap.h"
#include "membergroup.h"
Include dependency graph for namespacedef.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

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

Typedefs

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

Functions

std::unique_ptr< NamespaceDefcreateNamespaceDef (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.
std::unique_ptr< NamespaceDefcreateNamespaceDefAlias (const Definition *newScope, const NamespaceDef *nd)
 Factory method to create an alias of an existing namespace.
NamespaceDeftoNamespaceDef (Definition *d)
NamespaceDeftoNamespaceDef (DefinitionMutable *d)
const NamespaceDeftoNamespaceDef (const Definition *d)
NamespaceDefMutabletoNamespaceDefMutable (Definition *d)
void replaceNamespaceAliases (QCString &name)
NamespaceDefgetResolvedNamespace (const QCString &key)
NamespaceDefMutablegetResolvedNamespaceMutable (const QCString &key)
bool namespaceHasNestedNamespace (const NamespaceDef *nd)
bool namespaceHasNestedConcept (const NamespaceDef *nd)
bool namespaceHasNestedClass (const NamespaceDef *nd, bool filterClasses, ClassDef::CompoundType ct)

Typedef Documentation

◆ NamespaceDefSet

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

Definition at line 39 of file namespacedef.h.

Function Documentation

◆ 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.

Definition at line 174 of file namespacedef.cpp.

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.

Definition at line 262 of file namespacedef.cpp.

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)

Definition at line 1799 of file namespacedef.cpp.

1800{
1801 //printf("> getResolvedNamespace(%s)\n",qPrint(name));
1802 if (name.isEmpty()) return nullptr;
1803 StringSet namespacesTried;
1804 auto ns = getResolvedNamespaceRec(namespacesTried,NamespaceAliasInfo(name.str()));
1805 //printf("< getResolvedNamespace(%s)=%s\n",qPrint(name),ns?qPrint(ns->qualifiedName()):"nullptr");
1806 return ns;
1807}
std::set< std::string > StringSet
Definition containers.h:31
static NamespaceDef * getResolvedNamespaceRec(StringSet &namespacesTried, const NamespaceAliasInfo &aliasInfo)

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.

151{
153}
NamespaceDef * getResolvedNamespace(const QCString &key)
NamespaceDefMutable * toNamespaceDefMutable(Definition *d)

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 )

Definition at line 1847 of file namespacedef.cpp.

1848{
1849 //printf(">namespaceHasNestedClass(%s,filterClasses=%d)\n",qPrint(nd->name()),filterClasses);
1850 for (const auto &cnd : nd->getNamespaces())
1851 {
1852 if (namespaceHasNestedClass(cnd,filterClasses,ct))
1853 {
1854 //printf("<namespaceHasNestedClass(%s,filterClasses=%d): case1\n",qPrint(nd->name()),filterClasses);
1855 return true;
1856 }
1857 }
1858
1859 ClassLinkedRefMap list = nd->getClasses();
1860 if (filterClasses)
1861 {
1862 switch (ct)
1863 {
1865 list = nd->getInterfaces();
1866 break;
1867 case ClassDef::Struct:
1868 list = nd->getStructs();
1869 break;
1871 list = nd->getExceptions();
1872 break;
1873 default:
1874 break;
1875 }
1876 }
1877
1878 for (const auto &cd : list)
1879 {
1880 //printf("candidate %s isLinkableInProject()=%d\n",qPrint(cd->name()),cd->isLinkableInProject());
1881 if (cd->isLinkableInProject())
1882 {
1883 //printf("<namespaceHasNestedClass(%s,filterClasses=%d): case2\n",qPrint(nd->name()),filterClasses);
1884 return true;
1885 }
1886 }
1887 //printf("<namespaceHasNestedClass(%s,filterClasses=%d): case3\n",qPrint(nd->name()),filterClasses);
1888 return false;
1889}
@ Interface
Definition classdef.h:112
@ Exception
Definition classdef.h:115
virtual ClassLinkedRefMap getStructs() const =0
virtual ClassLinkedRefMap getExceptions() const =0
virtual NamespaceLinkedRefMap getNamespaces() const =0
virtual ClassLinkedRefMap getClasses() const =0
virtual ClassLinkedRefMap getInterfaces() const =0
bool namespaceHasNestedClass(const NamespaceDef *nd, bool filterClasses, ClassDef::CompoundType ct)

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)

Definition at line 1823 of file namespacedef.cpp.

1824{
1825 //printf(">namespaceHasNestedConcept(%s)\n",qPrint(nd->name()));
1826 for (const auto &cnd : nd->getNamespaces())
1827 {
1829 {
1830 //printf("<namespaceHasNestedConcept(%s): case1\n",qPrint(nd->name()));
1831 return true;
1832 }
1833 }
1834 for (const auto &cnd : nd->getConcepts())
1835 {
1836 //printf("candidate %s isLinkableInProject()=%d\n",qPrint(cnd->name()),cnd->isLinkableInProject());
1837 if (cnd->isLinkableInProject())
1838 {
1839 //printf("<namespaceHasNestedConcept(%s): case2\n",qPrint(nd->name()));
1840 return true;
1841 }
1842 }
1843 //printf("<namespaceHasNestedConcept(%s): case3\n",qPrint(nd->name()));
1844 return false;
1845}
virtual ConceptLinkedRefMap getConcepts() const =0
bool namespaceHasNestedConcept(const NamespaceDef *nd)

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

Referenced by namespaceHasNestedConcept(), writeConceptTreeInsideNamespaceElement(), and writeNamespaceTreeElement().

◆ namespaceHasNestedNamespace()

bool namespaceHasNestedNamespace ( const NamespaceDef * nd)

Definition at line 1811 of file namespacedef.cpp.

1812{
1813 for (const auto &cnd : nd->getNamespaces())
1814 {
1815 if (cnd->isLinkableInProject() && !cnd->isAnonymous())
1816 {
1817 return true;
1818 }
1819 }
1820 return false;
1821}

References NamespaceDef::getNamespaces().

Referenced by writeNamespaceTreeElement().

◆ replaceNamespaceAliases()

void replaceNamespaceAliases ( QCString & name)

Definition at line 1791 of file namespacedef.cpp.

1792{
1793 //printf("> replaceNamespaceAliases(%s)\n",qPrint(name));
1794 StringSet namespacesTried;
1795 name = replaceNamespaceAliasesRec(namespacesTried,name);
1796 //printf("< replaceNamespaceAliases: result=%s\n",qPrint(name));
1797}
static QCString replaceNamespaceAliasesRec(StringSet &namespacesTried, const QCString &name)

References replaceNamespaceAliasesRec().

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

◆ toNamespaceDef() [1/3]

const NamespaceDef * toNamespaceDef ( const Definition * d)

Definition at line 1676 of file namespacedef.cpp.

1677{
1678 if (d && (typeid(*d)==typeid(NamespaceDefImpl) || typeid(*d)==typeid(NamespaceDefAliasImpl)))
1679 {
1680 return static_cast<const NamespaceDef*>(d);
1681 }
1682 else
1683 {
1684 return nullptr;
1685 }
1686}
An abstract interface of a namespace symbol.

◆ toNamespaceDef() [2/3]

◆ toNamespaceDef() [3/3]

NamespaceDef * toNamespaceDef ( DefinitionMutable * d)

Definition at line 1662 of file namespacedef.cpp.

1663{
1664 Definition *d = toDefinition(md);
1665 if (d && typeid(*d)==typeid(NamespaceDefImpl))
1666 {
1667 return static_cast<NamespaceDef*>(d);
1668 }
1669 else
1670 {
1671 return nullptr;
1672 }
1673}
The common base class of all entity definitions found in the sources.
Definition definition.h:76
Definition * toDefinition(DefinitionMutable *dm)

References toDefinition().

◆ toNamespaceDefMutable()