namespacedef.cpp File Reference

#include "namespacedef.h"
#include "outputlist.h"
#include "util.h"
#include "language.h"
#include "classdef.h"
#include "classlist.h"
#include "memberlist.h"
#include "doxygen.h"
#include "message.h"
#include "docparser.h"
#include "searchindex.h"
#include "vhdldocgen.h"
#include "layout.h"
#include "membergroup.h"
#include "config.h"
#include "definitionimpl.h"
#include "membername.h"
#include "conceptdef.h"

Include dependency graph for namespacedef.cpp:

Go to the source code of this file.

Classes
class	NamespaceDefImpl
class	NamespaceDefAliasImpl

Functions
static QCString	makeDisplayName (const NamespaceDef *nd, bool includeScope)
std::unique_ptr< NamespaceDef >	createNamespaceDef (const QCString &defFileName, int defLine, int defColumn, const QCString &name, const QCString &ref, const QCString &refFile, const QCString &type, bool isPublished)
	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.
static bool	hasNonReferenceNestedNamespaceRec (const NamespaceDef *nd, int level)
NamespaceDef *	toNamespaceDef (Definition *d)
NamespaceDef *	toNamespaceDef (DefinitionMutable *md)
const NamespaceDef *	toNamespaceDef (const Definition *d)
NamespaceDefMutable *	toNamespaceDefMutable (Definition *d)
static NamespaceDef *	getResolvedNamespaceRec (StringSet &namespacesTried, const NamespaceAliasInfo &aliasInfo)
static QCString	replaceNamespaceAliasesRec (StringSet &namespacesTried, const QCString &name)
void	replaceNamespaceAliases (QCString &name)
NamespaceDef *	getResolvedNamespace (const QCString &name)
bool	namespaceHasNestedNamespace (const NamespaceDef *nd)
bool	namespaceHasNestedConcept (const NamespaceDef *nd)
bool	namespaceHasNestedClass (const NamespaceDef *nd, bool filterClasses, ClassDef::CompoundType ct)

Function Documentation

createNamespaceDef()

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

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);
}

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 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;
}

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

getResolvedNamespace()

NamespaceDef * getResolvedNamespace

(

const QCString &

name

)

Definition at line 1830 of file namespacedef.cpp.

{
  //printf("> getResolvedNamespace(%s)\n",qPrint(name));
  if (name.isEmpty()) 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 getResolvedNamespaceRec(), QCString::isEmpty(), and QCString::str().

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

getResolvedNamespaceRec()

NamespaceDef * getResolvedNamespaceRec ( StringSet & namespacesTried, const NamespaceAliasInfo & aliasInfo )

static

Definition at line 1781 of file namespacedef.cpp.

{
  size_t j = aliasInfo.context.length();
  for (;;)
  {
    if (j>0)
    {
      //printf("candidate %s|::%s\n",qPrint(aliasInfo.context.substr(0,j)),qPrint(aliasInfo.alias));
      auto candidate = replaceNamespaceAliasesRec(namespacesTried,aliasInfo.context.substr(0,j)+"::"+aliasInfo.alias);
      auto nd = Doxygen::namespaceLinkedMap->find(candidate);
      if (nd)
      {
        return nd;
      }
    }
    if (j>0) // strip one level from context, i.e. given N1::N2::N3
             // j==10 -> j==6 (N1::N2::N3->N1::N2), and then
             // j==6  -> j==2 (N1::N2->N1), and then
             // j==2  -> j==std::string::npos (N1->"")
    {
      j = aliasInfo.context.rfind("::",j-1);
    }
    else
    {
      j = std::string::npos;
    }
    if (j==std::string::npos)
    {
      //printf("candidate %s\n",qPrint(aliasInfo.alias));
      auto candidate = replaceNamespaceAliasesRec(namespacesTried,aliasInfo.alias);
      auto nd = Doxygen::namespaceLinkedMap->find(candidate);
      if (nd)
      {
        return nd;
      }
      break;
    }
  }
  return nullptr;
}

References NamespaceAliasInfo::alias, NamespaceAliasInfo::context, Doxygen::namespaceLinkedMap, and replaceNamespaceAliasesRec().

Referenced by getResolvedNamespace(), and replaceNamespaceAliasesRec().

hasNonReferenceNestedNamespaceRec()

bool hasNonReferenceNestedNamespaceRec ( const NamespaceDef * nd, int level )

static

Definition at line 1542 of file namespacedef.cpp.

{
  if (level>30)
  {
    err("Possible recursive namespace relation while inside {}\n",nd->name());
    return false;
  }
  bool found=nd->isLinkableInProject();
  if (found)
  {
    return true;
  }
  else
  {
    for (const auto &ind : nd->getNamespaces())
    {
      found = found || hasNonReferenceNestedNamespaceRec(ind,level+1);
      if (found) break;
    }
  }
  return found;
}

References err, NamespaceDef::getNamespaces(), hasNonReferenceNestedNamespaceRec(), Definition::isLinkableInProject(), and Definition::name().

Referenced by hasNonReferenceNestedNamespaceRec(), and NamespaceDefImpl::isVisibleInHierarchy().

makeDisplayName()

QCString makeDisplayName ( const NamespaceDef * nd, bool includeScope )

static

Definition at line 36 of file namespacedef.cpp.

{
  QCString result=includeScope ? nd->name() : nd->localName();
  SrcLangExt lang = nd->getLanguage();
  QCString sep = getLanguageSpecificSeparator(lang);
  if (sep!="::")
  {
    result = substitute(result,"::",sep);
  }
  if (nd->isAnonymous())
  {
    result = removeAnonymousScopes(result);
  }
  //printf("makeDisplayName() %s->%s lang=%d\n",qPrint(name()),qPrint(result),lang);
  return result;
}

References Definition::getLanguage(), getLanguageSpecificSeparator(), Definition::isAnonymous(), Definition::localName(), Definition::name(), removeAnonymousScopes(), and substitute().

Referenced by NamespaceDefAliasImpl::displayName(), and NamespaceDefImpl::displayName().

namespaceHasNestedClass()

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

Definition at line 1878 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 1854 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(), writeConceptTreeInsideNamespaceElement(), and writeNamespaceTreeElement().

namespaceHasNestedNamespace()

bool namespaceHasNestedNamespace

(

const NamespaceDef *

nd

)

Definition at line 1842 of file namespacedef.cpp.

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

References NamespaceDef::getNamespaces().

Referenced by writeNamespaceTreeElement().

replaceNamespaceAliases()

void replaceNamespaceAliases

(

QCString &

name

)

Definition at line 1822 of file namespacedef.cpp.

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

References replaceNamespaceAliasesRec().

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

replaceNamespaceAliasesRec()

QCString replaceNamespaceAliasesRec ( StringSet & namespacesTried, const QCString & name )

static

Definition at line 1735 of file namespacedef.cpp.

{
  QCString result = name;
  //printf("> replaceNamespaceAliasesRec(%s)\n",qPrint(name));
  if (namespacesTried.find(name.str())==namespacesTried.end())
  {
    namespacesTried.insert(name.str());
    size_t p = 0;
    for (;;)
    {
      size_t i = name.str().find("::",p);
      if (i==std::string::npos)
      {
        auto it = Doxygen::namespaceAliasMap.find(name.str());
        if (it != Doxygen::namespaceAliasMap.end())
        {
          //printf("found map %s->%s\n",qPrint(name),qPrint(it->second.alias));
          auto ns = getResolvedNamespaceRec(namespacesTried,it->second);
          if (ns)
          {
            result = replaceNamespaceAliasesRec(namespacesTried,ns->qualifiedName());
          }
        }
        break;
      }
      else
      {
        auto it = Doxygen::namespaceAliasMap.find(name.left(i).str());
        if (it != Doxygen::namespaceAliasMap.end())
        {
          //printf("found map %s|%s->%s\n",qPrint(name.left(i)),qPrint(name.mid(i)),qPrint(it->second.alias));
          auto ns = getResolvedNamespaceRec(namespacesTried,it->second);
          if (ns)
          {
            result = replaceNamespaceAliasesRec(namespacesTried,ns->qualifiedName()+name.mid(i));
            break;
          }
        }
      }
      p = i+2;
    }
  }
  //printf("< replaceNamespaceAliasesRec(%s)=%s\n",qPrint(name),qPrint(result));
  return result;
}

References end(), getResolvedNamespaceRec(), QCString::left(), QCString::mid(), Doxygen::namespaceAliasMap, replaceNamespaceAliasesRec(), and QCString::str().

Referenced by getResolvedNamespaceRec(), replaceNamespaceAliases(), and replaceNamespaceAliasesRec().

toNamespaceDef() [1/3]

const NamespaceDef * toNamespaceDef

(

const Definition *

d

)

Definition at line 1707 of file namespacedef.cpp.

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

toNamespaceDef() [2/3]

NamespaceDef * toNamespaceDef

(

Definition *

d

)

Definition at line 1681 of file namespacedef.cpp.

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

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

toNamespaceDef() [3/3]

NamespaceDef * toNamespaceDef

(

DefinitionMutable *

md

)

Definition at line 1693 of file namespacedef.cpp.

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

References toDefinition().

toNamespaceDefMutable()

NamespaceDefMutable * toNamespaceDefMutable

(

Definition *

d

)

Definition at line 1719 of file namespacedef.cpp.

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

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(), and writeTagFile().