#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:

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< NamespaceDef >	createNamespaceDef (const DString &defFileName, int defLine, int defColumn, const DString &name, const DString &ref=DString(), const DString &refFile=DString(), const DString &type=DString(), bool isPublished=false)
	Factory method to create new NamespaceDef instance.
std::unique_ptr< NamespaceDef >	createNamespaceDefAlias (const Definition newScope, const NamespaceDef nd)
	Factory method to create an alias of an existing namespace.
NamespaceDef *	toNamespaceDef (Definition *d)
NamespaceDef *	toNamespaceDef (DefinitionMutable *d)
const NamespaceDef *	toNamespaceDef (const Definition *d)
NamespaceDefMutable *	toNamespaceDefMutable (Definition *d)
void	replaceNamespaceAliases (DString &name)
NamespaceDef *	getResolvedNamespace (const DString &key)
NamespaceDefMutable *	getResolvedNamespaceMutable (const DString &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 DString &	defFileName,
		int	defLine,
		int	defColumn,
		const DString &	name,
		const DString &	ref = DString(),
		const DString &	refFile = DString(),
		const DString &	type = DString(),
		bool	isPublished = false )

Factory method to create new NamespaceDef instance.

Definition at line 173 of file namespacedef.cpp.

{
  //printf("createNamespaceDef(%s)\n",qPrint(name));
  return std::make_unique<NamespaceDefImpl>(defFileName,defLine,defColumn,name,ref,refFile,type,isPublished);
}

References createNamespaceDef().

Referenced by adjustConfiguration(), buildNamespaceList(), buildScopeFromQualifiedName(), createNamespaceDef(), 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 261 of file namespacedef.cpp.

{
  auto alnd = std::make_unique<NamespaceDefAliasImpl>(newScope,nd);
  //printf("alnd name=%s localName=%s qualifiedName=%s displayName()=%s\n",
  //    qPrint(alnd->name()),qPrint(alnd->localName()),qPrint(alnd->qualifiedName()),
  //    qPrint(alnd->displayName()));
  return alnd;
}

References createNamespaceDefAlias().

Referenced by buildNamespaceList(), createNamespaceDefAlias(), and NamespaceDefMutable::setInline().

◆ getResolvedNamespace()

NamespaceDef * getResolvedNamespace ( const DString & key )

Definition at line 1841 of file namespacedef.cpp.

{
  //printf("> getResolvedNamespace(%s)\n",qPrint(name));
  if (name.empty()) return nullptr;
  StringSet namespacesTried;
  auto ns = getResolvedNamespaceRec(namespacesTried,NamespaceAliasInfo(name.str()));
  //printf("< getResolvedNamespace(%s)=%s\n",qPrint(name),ns?qPrint(ns->qualifiedName()):"nullptr");
  return ns;
}

References DString::empty(), getResolvedNamespace(), getResolvedNamespaceRec(), NamespaceAliasInfo::NamespaceAliasInfo(), and DString::str().

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

◆ getResolvedNamespaceMutable()

NamespaceDefMutable * getResolvedNamespaceMutable ( const DString & key )

inline

Definition at line 151 of file namespacedef.h.

{
  return toNamespaceDefMutable(getResolvedNamespace(key));
}

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 1889 of file namespacedef.cpp.

{
  //printf(">namespaceHasNestedClass(%s,filterClasses=%d)\n",qPrint(nd->name()),filterClasses);
  for (const auto &cnd : nd->getNamespaces())
  {
    if (namespaceHasNestedClass(cnd,filterClasses,ct))
    {
      //printf("<namespaceHasNestedClass(%s,filterClasses=%d): case1\n",qPrint(nd->name()),filterClasses);
      return true;
    }
  }
 
  ClassLinkedRefMap list = nd->getClasses();
  if (filterClasses)
  {
    switch (ct)
    {
      case ClassDef::Interface:
        list = nd->getInterfaces();
        break;
      case ClassDef::Struct:
        list = nd->getStructs();
        break;
      case ClassDef::Exception:
        list = nd->getExceptions();
        break;
      default:
        break;
    }
  }
 
  for (const auto &cd : list)
  {
    //printf("candidate %s isLinkableInProject()=%d\n",qPrint(cd->name()),cd->isLinkableInProject());
    if (cd->isLinkableInProject())
    {
      //printf("<namespaceHasNestedClass(%s,filterClasses=%d): case2\n",qPrint(nd->name()),filterClasses);
      return true;
    }
  }
  //printf("<namespaceHasNestedClass(%s,filterClasses=%d): case3\n",qPrint(nd->name()),filterClasses);
  return false;
}

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 1865 of file namespacedef.cpp.

{
  //printf(">namespaceHasNestedConcept(%s)\n",qPrint(nd->name()));
  for (const auto &cnd : nd->getNamespaces())
  {
    if (namespaceHasNestedConcept(cnd))
    {
      //printf("<namespaceHasNestedConcept(%s): case1\n",qPrint(nd->name()));
      return true;
    }
  }
  for (const auto &cnd : nd->getConcepts())
  {
    //printf("candidate %s isLinkableInProject()=%d\n",qPrint(cnd->name()),cnd->isLinkableInProject());
    if (cnd->isLinkableInProject())
    {
      //printf("<namespaceHasNestedConcept(%s): case2\n",qPrint(nd->name()));
      return true;
    }
  }
  //printf("<namespaceHasNestedConcept(%s): case3\n",qPrint(nd->name()));
  return false;
}

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

Referenced by namespaceHasNestedConcept(), and writeNamespaceTreeElement().

◆ namespaceHasNestedNamespace()

bool namespaceHasNestedNamespace ( const NamespaceDef * nd )

Definition at line 1853 of file namespacedef.cpp.

{
  for (const auto &cnd : nd->getNamespaces())
  {
    if (cnd->isLinkableInProject() && !cnd->isAnonymous())
    {
      return true;
    }
  }
  return false;
}

References NamespaceDef::getNamespaces(), and namespaceHasNestedNamespace().

Referenced by namespaceHasNestedNamespace(), and writeNamespaceTreeElement().

◆ replaceNamespaceAliases()

void replaceNamespaceAliases ( DString & name )

Definition at line 1833 of file namespacedef.cpp.

{
  //printf("> replaceNamespaceAliases(%s)\n",qPrint(name));
  StringSet namespacesTried;
  name = replaceNamespaceAliasesRec(namespacesTried,name);
  //printf("< replaceNamespaceAliases: result=%s\n",qPrint(name));
}

References replaceNamespaceAliases(), and replaceNamespaceAliasesRec().

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

◆ toNamespaceDef() [1/3]

const NamespaceDef * toNamespaceDef ( const Definition * d )

Definition at line 1718 of file namespacedef.cpp.

{
  if (d && (typeid(*d)==typeid(NamespaceDefImpl) || typeid(*d)==typeid(NamespaceDefAliasImpl)))
  {
    return static_cast<const NamespaceDef*>(d);
  }
  else
  {
    return nullptr;
  }
}

References toNamespaceDef().

◆ toNamespaceDef() [2/3]

NamespaceDef * toNamespaceDef ( Definition * d )

Definition at line 1692 of file namespacedef.cpp.

{
  if (d && (typeid(*d)==typeid(NamespaceDefImpl) || typeid(*d)==typeid(NamespaceDefAliasImpl)))
  {
    return static_cast<NamespaceDef*>(d);
  }
  else
  {
    return nullptr;
  }
}

References toNamespaceDef().

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

◆ toNamespaceDef() [3/3]

NamespaceDef * toNamespaceDef ( DefinitionMutable * d )

Definition at line 1704 of file namespacedef.cpp.

{
  Definition *d = toDefinition(md);
  if (d && typeid(*d)==typeid(NamespaceDefImpl))
  {
    return static_cast<NamespaceDef*>(d);
  }
  else
  {
    return nullptr;
  }
}

References toDefinition(), and toNamespaceDef().

◆ toNamespaceDefMutable()

NamespaceDefMutable * toNamespaceDefMutable ( Definition * d )

Definition at line 1730 of file namespacedef.cpp.

{
  if (d && typeid(*d)==typeid(NamespaceDefImpl))
  {
    return static_cast<NamespaceDefMutable*>(d);
  }
  else
  {
    return nullptr;
  }
}

References toNamespaceDefMutable().

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

Classes

Typedefs

Functions