Inheritance diagram for NamespaceDefImpl:

Collaboration diagram for NamespaceDefImpl:

Public Member Functions
	NamespaceDefImpl (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)

	~NamespaceDefImpl () override

DefType	definitionType () const override

CodeSymbolType	codeSymbolType () const override

QCString	getOutputFileBase () const override

QCString	anchor () const override

void	insertUsedFile (FileDef *fd) override

void	writeDocumentation (OutputList &ol) override

void	writeMemberPages (OutputList &ol) override

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

void	writeTagFile (TextStream &) override

void	insertClass (ClassDef *cd) override

void	insertConcept (ConceptDef *cd) override

void	insertNamespace (NamespaceDef *nd) override

void	insertMember (MemberDef *md) override

void	computeAnchors () override

void	countMembers () override

int	numDocMembers () const override

void	addUsingDirective (NamespaceDef *nd) override

const LinkedRefMap< NamespaceDef > &	getUsedNamespaces () const override

void	addUsingDeclaration (const Definition *cd) override

const LinkedRefMap< const Definition > &	getUsedDefinitions () const override

void	combineUsingRelations (NamespaceDefSet &visitedNamespace) override

QCString	displayName (bool=TRUE) const override

void	setInline (bool isInline) override

bool	isConstantGroup () const override

bool	isModule () const override

bool	isLibrary () const override

bool	isInline () const override

bool	isLinkableInProject () const override

bool	isLinkable () const override

bool	isVisibleInHierarchy () const override

bool	hasDetailedDescription () const override

void	addMembersToMemberGroup () override

void	distributeMemberGroupDocumentation () override

void	findSectionsInDocumentation () override

void	sortMemberLists () override

const Definition *	findInnerCompound (const QCString &name) const override

void	addInnerCompound (Definition *d) override

void	addListReferences () override

void	setFileName (const QCString &fn) override

bool	subGrouping () const override

MemberList *	getMemberList (MemberListType lt) const override

const MemberLists &	getMemberLists () const override

const MemberDef *	getMemberByName (const QCString &) const override

const MemberGroupList &	getMemberGroups () const override

ClassLinkedRefMap	getClasses () const override

ClassLinkedRefMap	getInterfaces () const override

ClassLinkedRefMap	getStructs () const override

ClassLinkedRefMap	getExceptions () const override

NamespaceLinkedRefMap	getNamespaces () const override

ConceptLinkedRefMap	getConcepts () const override

void	setName (const QCString &name) override

QCString	title () const override

QCString	compoundTypeString () const override

void	setMetaData (const QCString &m) override

int	countVisibleMembers () const override

void	writeSummaryLinks (OutputList &ol) const override

Public Member Functions inherited from DefinitionMixin< NamespaceDefMutable >
	DefinitionMixin (const QCString &defFileName, int defLine, int defColumn, const QCString &name, const char b=nullptr, const char d=nullptr, bool isSymbol=TRUE)

	DefinitionMixin (const DefinitionMixin &other)

	DefinitionMixin (DefinitionMixin &&)=delete

DefinitionMixin &	operator= (const DefinitionMixin &other)

DefinitionMixin &	operator= (DefinitionMixin &&)=delete

	~DefinitionMixin () override=default

bool	isAlias () const override

const QCString &	name () const override

bool	isAnonymous () const override

const QCString &	localName () const override

QCString	qualifiedName () const override

QCString	symbolName () const override

QCString	getSourceFileBase () const override

QCString	getSourceAnchor () const override

QCString	documentation () const override

int	docLine () const override

QCString	docFile () const override

QCString	briefDescription (bool abbreviate=FALSE) const override

QCString	briefDescriptionAsTooltip () const override

int	briefLine () const override

QCString	inbodyDocumentation () const override

QCString	inbodyFile () const override

int	inbodyLine () const override

QCString	briefFile () const override

QCString	getDefFileName () const override

QCString	getDefFileExtension () const override

int	getDefLine () const override

int	getDefColumn () const override

bool	hasDocumentation () const override

bool	hasUserDocumentation () const override

bool	isVisibleInProject () const override

bool	isVisible () const override

bool	isHidden () const override

bool	isArtificial () const override

bool	isExported () const override

QCString	getReference () const override

bool	isReference () const override

QCString	externalReference (const QCString &relPath) const override

int	getStartDefLine () const override

int	getStartBodyLine () const override

int	getEndBodyLine () const override

const FileDef *	getBodyDef () const override

SrcLangExt	getLanguage () const override

const GroupList &	partOfGroups () const override

bool	isLinkableViaGroup () const override

const RefItemVector &	xrefListItems () const override

Definition *	getOuterScope () const override

const MemberVector &	getReferencesMembers () const override

const MemberVector &	getReferencedByMembers () const override

bool	hasSections () const override

bool	hasSources () const override

bool	hasBriefDescription () const override

QCString	id () const override

const SectionRefs &	getSectionRefs () const override

void	setId (const QCString &name) override

void	setDefFile (const QCString &df, int defLine, int defColumn) override

void	setDocumentation (const QCString &doc, const QCString &docFile, int docLine, bool stripWhiteSpace=TRUE) override

void	setBriefDescription (const QCString &brief, const QCString &briefFile, int briefLine) override

void	setInbodyDocumentation (const QCString &doc, const QCString &docFile, int docLine) override

void	setReference (const QCString &r) override

void	addSectionsToDefinition (const std::vector< const SectionInfo * > &anchorList) override

void	setBodySegment (int defLine, int bls, int ble) override

void	setBodyDef (const FileDef *fd) override

void	addSourceReferencedBy (MemberDef *md, const QCString &sourceRefName) override

void	addSourceReferences (MemberDef *md, const QCString &sourceRefName) override

void	setRefItems (const RefItemVector &sli) override

void	mergeRefItems (Definition *def) override

void	mergeReferences (const Definition *other) override

void	mergeReferencedBy (const Definition *other) override

void	setOuterScope (Definition *def) override

void	setHidden (bool b) override

void	setArtificial (bool b) override

void	setExported (bool b) override

void	setLanguage (SrcLangExt lang) override

void	writeSourceDef (OutputList &ol) const override

void	writeInlineCode (OutputList &ol, const QCString &scopeName) const override

bool	hasSourceRefs () const override

bool	hasSourceReffedBy () const override

void	writeSourceRefs (OutputList &ol, const QCString &scopeName) const override

void	writeSourceReffedBy (OutputList &ol, const QCString &scopeName) const override

void	makePartOfGroup (GroupDef *gd) override

void	writeNavigationPath (OutputList &ol) const override

QCString	navigationPathAsString () const override

QCString	pathFragment () const override

void	writeDocAnchorsToTagFile (TextStream &fs) const override

void	setLocalName (const QCString &name) override

void	writeToc (OutputList &ol, const LocalToc &lt) const override

void	computeTooltip () override

void	_setSymbolName (const QCString &name) override

QCString	_symbolName () const override

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

Private Member Functions
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, const ClassLinkedRefMap &d)

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

void	writeInlineClasses (OutputList &ol)

void	writeMemberGroups (OutputList &ol)

void	writeAuthorSection (OutputList &ol)

void	startMemberDocumentation (OutputList &ol)

void	endMemberDocumentation (OutputList &ol)

void	addNamespaceAttributes (OutputList &ol)

void	writeClassesToTagFile (TextStream &, const ClassLinkedRefMap &d)

void	writeConceptsToTagFile (TextStream &)

void	setFileNameLocal (const QCString &fn)

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

void	updateLocalName ()

Private Attributes
QCString	fileName

FileList	files

LinkedRefMap< NamespaceDef >	m_usingDirList

LinkedRefMap< const Definition >	m_usingDeclList

LinkedRefMap< const Definition >	m_innerCompounds

MemberLinkedRefMap	m_allMembers

MemberLists	m_memberLists

MemberGroupList	m_memberGroups

ClassLinkedRefMap	classes

ClassLinkedRefMap	interfaces

ClassLinkedRefMap	structs

ClassLinkedRefMap	exceptions

ConceptLinkedRefMap	m_concepts

NamespaceLinkedRefMap	namespaces

bool	m_subGrouping = false

enum NamespaceDefImpl:: { ... }	m_type

bool	m_isPublished = false

QCString	metaData

bool	m_inline = false

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

Detailed Description

Definition at line 56 of file namespacedef.cpp.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

private

Enumerator
NAMESPACE
MODULE
CONSTANT_GROUP
LIBRARY

Definition at line 167 of file namespacedef.cpp.

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

NamespaceDefImpl::m_type

enum NamespaceDefImpl::@152056333015234071026257214045103374127312105332 m_type

NamespaceDefImpl::CONSTANT_GROUP

@ CONSTANT_GROUP

Definition namespacedef.cpp:167

NamespaceDefImpl::LIBRARY

@ LIBRARY

Definition namespacedef.cpp:167

NamespaceDefImpl::NAMESPACE

@ NAMESPACE

Definition namespacedef.cpp:167

NamespaceDefImpl::MODULE

@ MODULE

Definition namespacedef.cpp:167

Constructor & Destructor Documentation

◆ NamespaceDefImpl()

NamespaceDefImpl::NamespaceDefImpl	(	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 )

Definition at line 272 of file namespacedef.cpp.

                                             :
   DefinitionMixin(df,dl,dc,name)
  ,m_isPublished(isPublished)
{
  if (!fName.isEmpty())
  {
    if (!lref.isEmpty())
    {
      fileName = stripExtension(fName);
    }
    else
    {
      fileName = convertNameToFile(stripExtension(fName));
    }
  }
  else
  {
    setFileNameLocal(name);
  }
  setReference(lref);
  m_inline=FALSE;
  m_subGrouping=Config_getBool(SUBGROUPING);
  if (type=="module")
  {
    m_type = MODULE;
  }
  else if (type=="constants")
  {
    m_type = CONSTANT_GROUP;
  }
  else if (type=="library")
  {
    m_type = LIBRARY;
  }
  else
  {
    m_type = NAMESPACE;
  }
 
  updateLocalName();
}

References DefinitionMixin< NamespaceDefMutable >::DefinitionMixin(), QCString::isEmpty(), m_isPublished, and DefinitionMixin< NamespaceDefMutable >::name().

◆ ~NamespaceDefImpl()

NamespaceDefImpl::~NamespaceDefImpl ( )

override

Definition at line 334 of file namespacedef.cpp.

335{

336}

Member Function Documentation

◆ addInnerCompound()

void NamespaceDefImpl::addInnerCompound ( Definition * d )

overridevirtual

Reimplemented from DefinitionMixin< NamespaceDefMutable >.

Definition at line 391 of file namespacedef.cpp.

{
  //printf("%s:NamespaceDefImpl::addInnerCompound(%s)\n",qPrint(name()),qPrint(d->name()));
  m_innerCompounds.add(d->localName(),d);
  if (d->definitionType()==Definition::TypeNamespace)
  {
    insertNamespace(toNamespaceDef(d));
  }
  else if (d->definitionType()==Definition::TypeClass)
  {
    insertClass(toClassDef(d));
  }
  else if (d->definitionType()==Definition::TypeConcept)
  {
    insertConcept(toConceptDef(d));
  }
}

References Definition::definitionType(), insertClass(), insertConcept(), insertNamespace(), Definition::localName(), m_innerCompounds, toClassDef(), toConceptDef(), toNamespaceDef(), Definition::TypeClass, Definition::TypeConcept, and Definition::TypeNamespace.

◆ addListReferences()

void NamespaceDefImpl::addListReferences ( )

overridevirtual

Implements NamespaceDefMutable.

Definition at line 1248 of file namespacedef.cpp.

{
  //bool fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
  {
    const RefItemVector &xrefItems = xrefListItems();
    addRefItem(xrefItems,
        qualifiedName(),
        getLanguage()==SrcLangExt::Fortran ?
          theTranslator->trModule(TRUE,TRUE) :
          theTranslator->trNamespace(TRUE,TRUE),
        getOutputFileBase(),displayName(),
        QCString(),
        this
        );
  }
  for (const auto &mg : m_memberGroups)
  {
    mg->addListReferences(this);
  }
  for (auto &ml : m_memberLists)
  {
    if (ml->listType().isDocumentation())
    {
      ml->addListReferences(this);
    }
  }
}

References addRefItem(), displayName(), Fortran, DefinitionMixin< NamespaceDefMutable >::getLanguage(), getOutputFileBase(), m_memberGroups, m_memberLists, DefinitionMixin< NamespaceDefMutable >::qualifiedName(), theTranslator, TRUE, and DefinitionMixin< NamespaceDefMutable >::xrefListItems().

◆ addMembersToMemberGroup()

void NamespaceDefImpl::addMembersToMemberGroup ( )

overridevirtual

Implements NamespaceDefMutable.

Definition at line 443 of file namespacedef.cpp.

{
  for (auto &ml : m_memberLists)
  {
    if (ml->listType().isDeclaration())
    {
      ::addMembersToMemberGroup(ml.get(),&m_memberGroups,this);
    }
  }
 
  // add members inside sections to their groups
  for (const auto &mg : m_memberGroups)
  {
    if (mg->allMembersInSameSection() && m_subGrouping)
    {
      //printf("----> addToDeclarationSection(%s)\n",qPrint(mg->header()));
      mg->addToDeclarationSection();
    }
  }
}

References addMembersToMemberGroup(), m_memberGroups, m_memberLists, and m_subGrouping.

Referenced by addMembersToMemberGroup().

◆ addMemberToList()

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

private

Definition at line 1429 of file namespacedef.cpp.

{
  bool sortBriefDocs = Config_getBool(SORT_BRIEF_DOCS);
  bool sortMemberDocs = Config_getBool(SORT_MEMBER_DOCS);
  const auto &ml = m_memberLists.get(lt,MemberListContainer::Namespace);
  ml->setNeedsSorting(
      (ml->listType().isDeclaration() && sortBriefDocs) ||
      (ml->listType().isDocumentation() && sortMemberDocs));
  ml->push_back(md);
 
  if (ml->listType().isDeclaration())
  {
    MemberDefMutable *mdm = toMemberDefMutable(md);
    if (mdm)
    {
      mdm->setSectionList(this,ml.get());
    }
  }
}

References Config_getBool, m_memberLists, Namespace, MemberDefMutable::setSectionList(), and toMemberDefMutable().

Referenced by insertMember().

◆ addNamespaceAttributes()

void NamespaceDefImpl::addNamespaceAttributes ( OutputList & ol )

private

Definition at line 924 of file namespacedef.cpp.

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

References OutputList::disableAllBut(), OutputList::endLabels(), DefinitionMixin< NamespaceDefMutable >::getLanguage(), Html, IDL, isConstantGroup(), DefinitionMixin< NamespaceDefMutable >::isExported(), m_isPublished, OutputList::popGeneratorState(), OutputList::pushGeneratorState(), OutputList::startLabels(), and OutputList::writeLabel().

Referenced by writeDocumentation().

◆ addUsingDeclaration()

void NamespaceDefImpl::addUsingDeclaration ( const Definition * cd )

overridevirtual

Implements NamespaceDefMutable.

Definition at line 1220 of file namespacedef.cpp.

{
  m_usingDeclList.add(d->qualifiedName(),d);
}

References m_usingDeclList, and Definition::qualifiedName().

Referenced by combineUsingRelations().

◆ addUsingDirective()

void NamespaceDefImpl::addUsingDirective ( NamespaceDef * nd )

overridevirtual

Implements NamespaceDefMutable.

Definition at line 1214 of file namespacedef.cpp.

{
  m_usingDirList.add(nd->qualifiedName(),nd);
  //printf("%s: NamespaceDefImpl::addUsingDirective: %s:%zu\n",qPrint(name()),qPrint(nd->qualifiedName()),m_usingDirList.size());
}

References m_usingDirList, and Definition::qualifiedName().

Referenced by combineUsingRelations().

◆ anchor()

QCString NamespaceDefImpl::anchor ( ) const

inlineoverridevirtual

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

Implements Definition.

Definition at line 70 of file namespacedef.cpp.

70{ return QCString(); }

◆ codeSymbolType()

CodeSymbolType NamespaceDefImpl::codeSymbolType ( ) const

inlineoverridevirtual

Used for syntax highlighting symbol class

Implements Definition.

Definition at line 67 of file namespacedef.cpp.

68 { return getLanguage()==SrcLangExt::Java ? CodeSymbolType::Package : CodeSymbolType::Namespace; }

CodeSymbolType::Package

@ Package

Definition types.h:334

CodeSymbolType::Namespace

@ Namespace

Definition types.h:333

SrcLangExt::Java

@ Java

Definition types.h:45

References DefinitionMixin< NamespaceDefMutable >::getLanguage(), Java, Namespace, and Package.

◆ combineUsingRelations()

void NamespaceDefImpl::combineUsingRelations ( NamespaceDefSet & visitedNamespace )

overridevirtual

Implements NamespaceDefMutable.

Definition at line 1281 of file namespacedef.cpp.

{
  if (visitedNamespaces.find(this)!=visitedNamespaces.end()) return; // already processed
  visitedNamespaces.insert(this);
 
  LinkedRefMap<NamespaceDef> usingDirList = m_usingDirList;
  for (auto &nd : usingDirList)
  {
    NamespaceDefMutable *ndm = toNamespaceDefMutable(nd);
    if (ndm)
    {
      ndm->combineUsingRelations(visitedNamespaces);
    }
  }
 
  for (auto &nd : usingDirList)
  {
    // add used namespaces of namespace nd to this namespace
    for (const auto &und : nd->getUsedNamespaces())
    {
      addUsingDirective(und);
    }
    // add used classes of namespace nd to this namespace
    for (const auto &ud : nd->getUsedDefinitions())
    {
      addUsingDeclaration(ud);
    }
  }
}

References addUsingDeclaration(), addUsingDirective(), NamespaceDefMutable::combineUsingRelations(), m_usingDirList, and toNamespaceDefMutable().

◆ compoundTypeString()

QCString NamespaceDefImpl::compoundTypeString ( ) const

overridevirtual

Implements NamespaceDef.

Definition at line 1584 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 "namespace";
}

References CSharp, err_full, Fortran, DefinitionMixin< NamespaceDefMutable >::getDefFileName(), DefinitionMixin< NamespaceDefMutable >::getDefLine(), DefinitionMixin< NamespaceDefMutable >::getLanguage(), IDL, isConstantGroup(), isLibrary(), isModule(), and Java.

◆ computeAnchors()

void NamespaceDefImpl::computeAnchors ( )

overridevirtual

Implements NamespaceDefMutable.

Definition at line 588 of file namespacedef.cpp.

{
  MemberList *allMemberList = getMemberList(MemberListType::AllMembersList());
  if (allMemberList) allMemberList->setAnchors();
}

References getMemberList(), and MemberList::setAnchors().

◆ countMembers()

void NamespaceDefImpl::countMembers ( )

overridevirtual

Implements NamespaceDefMutable.

Definition at line 1194 of file namespacedef.cpp.

{
  for (auto &ml : m_memberLists)
  {
    ml->countDecMembers();
    ml->countDocMembers();
  }
  for (const auto &mg : m_memberGroups)
  {
    mg->countDecMembers();
    mg->countDocMembers();
  }
}

References m_memberGroups, and m_memberLists.

◆ countVisibleMembers()

int NamespaceDefImpl::countVisibleMembers ( ) const

overridevirtual

Implements NamespaceDef.

Definition at line 1311 of file namespacedef.cpp.

{
  int count=0;
  for (const auto &lde : LayoutDocManager::instance().docEntries(LayoutDocManager::Namespace))
  {
    if (lde->kind()==LayoutDocEntry::MemberDef)
    {
      const LayoutDocEntryMemberDef *lmd = dynamic_cast<const LayoutDocEntryMemberDef*>(lde.get());
      if (lmd)
      {
        MemberList *ml = getMemberList(lmd->type);
        if (ml)
        {
          for (const auto &md : *ml)
          {
            if (md->visibleInIndex())
            {
              count++;
            }
          }
        }
      }
    }
  }
  return count;
}

References getMemberList(), LayoutDocManager::instance(), and LayoutDocEntryMemberDef::type.

◆ definitionType()

DefType NamespaceDefImpl::definitionType ( ) const

inlineoverridevirtual

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

Implements Definition.

Definition at line 66 of file namespacedef.cpp.

66{ return TypeNamespace; }

References definitionType(), and Definition::TypeNamespace.

Referenced by definitionType().

◆ displayName()

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

overridevirtual

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

Implements Definition.

Definition at line 1276 of file namespacedef.cpp.

{
  return makeDisplayName(this,includeScope);
}

References makeDisplayName().

Referenced by addListReferences(), title(), writeDocumentation(), writeMemberDocumentation(), and writeMemberPages().

◆ distributeMemberGroupDocumentation()

void NamespaceDefImpl::distributeMemberGroupDocumentation ( )

overridevirtual

Implements NamespaceDefMutable.

Definition at line 355 of file namespacedef.cpp.

{
  for (const auto &mg : m_memberGroups)
  {
    mg->distributeMemberGroupDocumentation();
  }
}

References m_memberGroups.

◆ endMemberDeclarations()

void NamespaceDefImpl::endMemberDeclarations ( OutputList & ol )

private

Definition at line 784 of file namespacedef.cpp.

{
  ol.endMemberSections();
}

References OutputList::endMemberSections().

Referenced by writeDocumentation().

◆ endMemberDocumentation()

void NamespaceDefImpl::endMemberDocumentation ( OutputList & ol )

private

Definition at line 798 of file namespacedef.cpp.

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

References Config_getBool, OutputList::enable(), FALSE, Html, and Doxygen::suppressDocWarnings.

Referenced by writeDocumentation().

◆ findInnerCompound()

const Definition * NamespaceDefImpl::findInnerCompound ( const QCString & name ) const

overridevirtual

Reimplemented from DefinitionMixin< NamespaceDefMutable >.

Definition at line 1230 of file namespacedef.cpp.

{
  if (n==nullptr) return nullptr;
  const Definition *d = m_innerCompounds.find(n);
  if (d==nullptr)
  {
    if (!m_usingDirList.empty())
    {
      d = m_usingDirList.find(n);
    }
    if (d==nullptr && !m_usingDeclList.empty())
    {
      d = m_usingDeclList.find(n);
    }
  }
  return d;
}

References m_innerCompounds, m_usingDeclList, and m_usingDirList.

◆ findSectionsInDocumentation()

void NamespaceDefImpl::findSectionsInDocumentation ( )

overridevirtual

Implements NamespaceDefMutable.

Definition at line 363 of file namespacedef.cpp.

{
  docFindSections(briefDescription(),this,docFile());
  docFindSections(documentation(),this,docFile());
  docFindSections(inbodyDocumentation(),this,docFile());
  for (const auto &mg : m_memberGroups)
  {
    mg->findSectionsInDocumentation(this);
  }
  for (auto &ml : m_memberLists)
  {
    if (ml->listType().isDeclaration())
    {
      ml->findSectionsInDocumentation(this);
    }
  }
}

References DefinitionMixin< NamespaceDefMutable >::briefDescription(), DefinitionMixin< NamespaceDefMutable >::docFile(), docFindSections(), DefinitionMixin< NamespaceDefMutable >::documentation(), DefinitionMixin< NamespaceDefMutable >::inbodyDocumentation(), m_memberGroups, and m_memberLists.

◆ getClasses()

ClassLinkedRefMap NamespaceDefImpl::getClasses ( ) const

inlineoverridevirtual

Returns the classes contained in this namespace

Implements NamespaceDef.

Definition at line 111 of file namespacedef.cpp.

111{ return classes; }

NamespaceDefImpl::classes

ClassLinkedRefMap classes

Definition namespacedef.cpp:160

References classes.

◆ getConcepts()

ConceptLinkedRefMap NamespaceDefImpl::getConcepts ( ) const

inlineoverridevirtual

Returns the concepts contained in this namespace

Implements NamespaceDef.

Definition at line 116 of file namespacedef.cpp.

116{ return m_concepts; }

NamespaceDefImpl::m_concepts

ConceptLinkedRefMap m_concepts

Definition namespacedef.cpp:164

References m_concepts.

◆ getExceptions()

ClassLinkedRefMap NamespaceDefImpl::getExceptions ( ) const

inlineoverridevirtual

Returns the Slice exceptions contained in this namespace

Implements NamespaceDef.

Definition at line 114 of file namespacedef.cpp.

114{ return exceptions; }

NamespaceDefImpl::exceptions

ClassLinkedRefMap exceptions

Definition namespacedef.cpp:163

References exceptions.

◆ getInterfaces()

ClassLinkedRefMap NamespaceDefImpl::getInterfaces ( ) const

inlineoverridevirtual

Returns the Slice interfaces contained in this namespace

Implements NamespaceDef.

Definition at line 112 of file namespacedef.cpp.

112{ return interfaces; }

NamespaceDefImpl::interfaces

ClassLinkedRefMap interfaces

Definition namespacedef.cpp:161

References interfaces.

◆ getMemberByName()

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

overridevirtual

Implements NamespaceDef.

Definition at line 1554 of file namespacedef.cpp.

{
  return m_allMembers.find(n);
}

References m_allMembers.

◆ getMemberGroups()

const MemberGroupList & NamespaceDefImpl::getMemberGroups ( ) const

inlineoverridevirtual

Returns the user defined member groups

Implements NamespaceDef.

Definition at line 110 of file namespacedef.cpp.

110{ return m_memberGroups; }

References m_memberGroups.

◆ getMemberList()

MemberList * NamespaceDefImpl::getMemberList ( MemberListType lt ) const

overridevirtual

Implements NamespaceDef.

Definition at line 1477 of file namespacedef.cpp.

{
  for (auto &ml : m_memberLists)
  {
    if (ml->listType()==lt)
    {
      return ml.get();
    }
  }
  return nullptr;
}

References m_memberLists.

Referenced by computeAnchors(), countVisibleMembers(), insertMember(), numDocMembers(), writeDocumentation(), writeMemberDeclarations(), writeMemberDocumentation(), writeQuickMemberLinks(), writeSummaryLinks(), and writeTagFile().

◆ getMemberLists()

const MemberLists & NamespaceDefImpl::getMemberLists ( ) const

inlineoverridevirtual

Implements NamespaceDef.

Definition at line 108 of file namespacedef.cpp.

108{ return m_memberLists; }

References m_memberLists.

◆ getNamespaces()

NamespaceLinkedRefMap NamespaceDefImpl::getNamespaces ( ) const

inlineoverridevirtual

Returns the namespaces contained in this namespace

Implements NamespaceDef.

Definition at line 115 of file namespacedef.cpp.

115{ return namespaces; }

NamespaceDefImpl::namespaces

NamespaceLinkedRefMap namespaces

Definition namespacedef.cpp:165

References namespaces.

◆ getOutputFileBase()

QCString NamespaceDefImpl::getOutputFileBase ( ) const

overridevirtual

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

Implements Definition.

Definition at line 1225 of file namespacedef.cpp.

{
  return fileName;
}

References fileName.

Referenced by addListReferences(), writeBriefDescription(), writeDocumentation(), and writeTagFile().

◆ getStructs()

ClassLinkedRefMap NamespaceDefImpl::getStructs ( ) const

inlineoverridevirtual

Returns the Slice structs contained in this namespace

Implements NamespaceDef.

Definition at line 113 of file namespacedef.cpp.

113{ return structs; }

NamespaceDefImpl::structs

ClassLinkedRefMap structs

Definition namespacedef.cpp:162

References structs.

◆ getUsedDefinitions()

const LinkedRefMap< const Definition > & NamespaceDefImpl::getUsedDefinitions ( ) const

inlineoverridevirtual

Implements NamespaceDef.

Definition at line 86 of file namespacedef.cpp.

86{ return m_usingDeclList; }

References m_usingDeclList.

◆ getUsedNamespaces()

const LinkedRefMap< NamespaceDef > & NamespaceDefImpl::getUsedNamespaces ( ) const

inlineoverridevirtual

Implements NamespaceDef.

Definition at line 84 of file namespacedef.cpp.

84{ return m_usingDirList; }

References m_usingDirList.

◆ hasDetailedDescription()

bool NamespaceDefImpl::hasDetailedDescription ( ) const

overridevirtual

Implements NamespaceDef.

Definition at line 594 of file namespacedef.cpp.

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

References DefinitionMixin< NamespaceDefMutable >::briefDescription(), Config_getBool, and DefinitionMixin< NamespaceDefMutable >::documentation().

Referenced by writeBriefDescription(), and writeDetailedDescription().

◆ insertClass()

void NamespaceDefImpl::insertClass ( ClassDef * cd )

overridevirtual

Implements NamespaceDefMutable.

Definition at line 409 of file namespacedef.cpp.

{
  ClassLinkedRefMap *d = &classes;
 
  if (Config_getBool(OPTIMIZE_OUTPUT_SLICE))
  {
    if (cd->compoundType()==ClassDef::Interface)
    {
      d = &interfaces;
    }
    else if (cd->compoundType()==ClassDef::Struct)
    {
      d = &structs;
    }
    else if (cd->compoundType()==ClassDef::Exception)
    {
      d = &exceptions;
    }
  }
 
  d->add(cd->name(),cd);
}

References LinkedRefMap< T, Hash, KeyEqual, Map >::add(), classes, ClassDef::compoundType(), Config_getBool, ClassDef::Exception, exceptions, ClassDef::Interface, interfaces, Definition::name(), ClassDef::Struct, and structs.

Referenced by addInnerCompound().

◆ insertConcept()

void NamespaceDefImpl::insertConcept ( ConceptDef * cd )

overridevirtual

Implements NamespaceDefMutable.

Definition at line 432 of file namespacedef.cpp.

{
  m_concepts.add(cd->name(),cd);
}

References m_concepts, and Definition::name().

Referenced by addInnerCompound().

◆ insertMember()

void NamespaceDefImpl::insertMember ( MemberDef * md )

overridevirtual

Implements NamespaceDefMutable.

Definition at line 464 of file namespacedef.cpp.

{
  //printf("%s::insertMember(%s) isInline=%d hasDocs=%d\n",qPrint(name()),qPrint(md->name()),
  //    isInline(),hasDocumentation());
  if (md->isHidden()) return;
  MemberDefMutable *mdm = toMemberDefMutable(md);
 
  // if this is an inline namespace that is not documented, then insert the
  // member in the parent scope instead
  if (isInline() && !hasDocumentation())
  {
    Definition *outerScope = getOuterScope();
    if (outerScope)
    {
      if (outerScope->definitionType()==Definition::TypeNamespace)
      {
        NamespaceDefMutable *nd = toNamespaceDefMutable(outerScope);
        if (nd && nd!=Doxygen::globalScope)
        {
          nd->insertMember(md);
          if (mdm)
          {
            mdm->setNamespace(nd);
          }
        }
      }
      else if (outerScope->definitionType()==Definition::TypeFile)
      {
        FileDef *fd = toFileDef(outerScope);
        fd->insertMember(md);
        if (mdm)
        {
          mdm->setFileDef(fd);
          mdm->setOuterScope(fd);
        }
      }
    }
  }
  else // member is a non-inline namespace or a documented inline namespace
  {
    MemberList *allMemberList = getMemberList(MemberListType::AllMembersList());
    if (allMemberList==nullptr)
    {
      m_memberLists.emplace_back(std::make_unique<MemberList>(MemberListType::AllMembersList(),MemberListContainer::Namespace));
      allMemberList = m_memberLists.back().get();
    }
    allMemberList->push_back(md);
    //printf("%s::m_allMembersDict->append(%s)\n",qPrint(name()),qPrint(md->localName()));
    m_allMembers.add(md->localName(),md);
    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::Sequence:
        addMemberToList(MemberListType::DecSequenceMembers(),md);
        addMemberToList(MemberListType::DocSequenceMembers(),md);
        break;
      case MemberType::Dictionary:
        addMemberToList(MemberListType::DecDictionaryMembers(),md);
        addMemberToList(MemberListType::DocDictionaryMembers(),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;
      case MemberType::Property:
        if (md->getLanguage() == SrcLangExt::Python)
        {
          addMemberToList(MemberListType::PropertyMembers(),md);
          addMemberToList(MemberListType::Properties(),md);
          break;
        }
        //  fallthrough, explicitly no break here
      default:
        err("NamespaceDefImpl::insertMembers(): "
            "member '{}' with unexpected type '{}' and class scope '{}' inserted in namespace scope '{}'!\n",
            md->name(), md->memberTypeName(), md->getClassDef() ? md->getClassDef()->name() : "", name());
    }
    // if this is an inline namespace, then insert an alias of this member in the outer scope.
    if (isInline())
    {
      Definition *outerScope = getOuterScope();
      if (outerScope)
      {
        std::unique_ptr<MemberDef> aliasMd = createMemberDefAlias(outerScope,md);
        if (outerScope->definitionType()==Definition::TypeNamespace)
        {
          NamespaceDefMutable *ndm = toNamespaceDefMutable(outerScope);
          if (ndm)
          {
            ndm->insertMember(aliasMd.get());
          }
        }
        else if (outerScope->definitionType()==Definition::TypeFile)
        {
          toFileDef(outerScope)->insertMember(aliasMd.get());
        }
        if (aliasMd)
        {
          QCString name = md->name();
          MemberName *mn = Doxygen::functionNameLinkedMap->add(name);
          mn->push_back(std::move(aliasMd));
        }
      }
    }
  }
}

References addMemberToList(), createMemberDefAlias(), Define, Definition::definitionType(), Dictionary, Enumeration, EnumValue, err, Function, Doxygen::functionNameLinkedMap, MemberDef::getClassDef(), Definition::getLanguage(), getMemberList(), DefinitionMixin< NamespaceDefMutable >::getOuterScope(), Doxygen::globalScope, DefinitionMixin< NamespaceDefMutable >::hasDocumentation(), FileDef::insertMember(), NamespaceDefMutable::insertMember(), Definition::isHidden(), isInline(), Definition::localName(), m_allMembers, m_memberLists, MemberDef::memberType(), MemberDef::memberTypeName(), Definition::name(), DefinitionMixin< NamespaceDefMutable >::name(), Namespace, Property, MemberName::push_back(), MemberVector::push_back(), Python, Sequence, MemberDefMutable::setFileDef(), MemberDefMutable::setNamespace(), DefinitionMutable::setOuterScope(), toFileDef(), toMemberDefMutable(), toNamespaceDefMutable(), Typedef, Definition::TypeFile, Definition::TypeNamespace, and Variable.

◆ insertNamespace()

void NamespaceDefImpl::insertNamespace ( NamespaceDef * nd )

overridevirtual

Implements NamespaceDefMutable.

Definition at line 437 of file namespacedef.cpp.

{
  namespaces.add(nd->name(),nd);
}

References Definition::name(), and namespaces.

Referenced by addInnerCompound().

◆ insertUsedFile()

void NamespaceDefImpl::insertUsedFile ( FileDef * fd )

overridevirtual

Implements NamespaceDefMutable.

Definition at line 381 of file namespacedef.cpp.

{
  if (fd==nullptr) return;
  auto it = std::find(files.begin(),files.end(),fd);
  if (it==files.end())
  {
    files.push_back(fd);
  }
}

References files.

◆ isConstantGroup()

bool NamespaceDefImpl::isConstantGroup ( ) const

inlineoverridevirtual

Implements NamespaceDef.

Definition at line 90 of file namespacedef.cpp.

90{ return CONSTANT_GROUP == m_type; }

References CONSTANT_GROUP, and m_type.

Referenced by addNamespaceAttributes(), compoundTypeString(), title(), and writeNamespaceDeclarations().

◆ isInline()

bool NamespaceDefImpl::isInline ( ) const

inlineoverridevirtual

Implements NamespaceDef.

Definition at line 93 of file namespacedef.cpp.

93{ return m_inline; }

References m_inline.

Referenced by insertMember(), and setInline().

◆ isLibrary()

bool NamespaceDefImpl::isLibrary ( ) const

inlineoverridevirtual

Implements NamespaceDef.

Definition at line 92 of file namespacedef.cpp.

92{ return LIBRARY == m_type; }

References LIBRARY, and m_type.

Referenced by compoundTypeString().

◆ isLinkable()

bool NamespaceDefImpl::isLinkable ( ) const

overridevirtual

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

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

References isLinkableInProject(), and DefinitionMixin< NamespaceDefMutable >::isReference().

Referenced by isVisibleInHierarchy().

◆ isLinkableInProject()

bool NamespaceDefImpl::isLinkableInProject ( ) const

overridevirtual

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

Implements Definition.

Definition at line 1530 of file namespacedef.cpp.

{
  int i = name().findRev("::");
  if (i==-1) i=0; else i+=2;
  bool extractAnonNs = Config_getBool(EXTRACT_ANON_NSPACES);
  bool hideUndoc     = Config_getBool(HIDE_UNDOC_NAMESPACES);
  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() || !hideUndoc || getLanguage()==SrcLangExt::CSharp) &&  // documented
    !isReference() &&      // not an external reference
    !isHidden() &&         // not hidden
    !isArtificial();       // or artificial
}

References QCString::at(), Config_getBool, CSharp, QCString::findRev(), DefinitionMixin< NamespaceDefMutable >::getLanguage(), DefinitionMixin< NamespaceDefMutable >::hasDocumentation(), DefinitionMixin< NamespaceDefMutable >::isArtificial(), QCString::isEmpty(), DefinitionMixin< NamespaceDefMutable >::isHidden(), DefinitionMixin< NamespaceDefMutable >::isReference(), DefinitionMixin< NamespaceDefMutable >::name(), and TRUE.

Referenced by isLinkable().

◆ isModule()

bool NamespaceDefImpl::isModule ( ) const

inlineoverridevirtual

Implements NamespaceDef.

Definition at line 91 of file namespacedef.cpp.

91{ return NAMESPACE == m_type || MODULE == m_type; }

References m_type, MODULE, and NAMESPACE.

Referenced by compoundTypeString().

◆ isVisibleInHierarchy()

bool NamespaceDefImpl::isVisibleInHierarchy ( ) const

overridevirtual

Implements NamespaceDef.

Definition at line 1524 of file namespacedef.cpp.

{
  bool allExternals = Config_getBool(ALLEXTERNALS);
  return allExternals || hasNonReferenceNestedNamespaceRec(this,0) || isLinkable();
}

References Config_getBool, hasNonReferenceNestedNamespaceRec(), and isLinkable().

◆ numDocMembers()

int NamespaceDefImpl::numDocMembers ( ) const

overridevirtual

Implements NamespaceDef.

Definition at line 1208 of file namespacedef.cpp.

{
  MemberList *allMemberList = getMemberList(MemberListType::AllMembersList());
  return (allMemberList ? allMemberList->numDocMembers() : 0) + static_cast<int>(m_innerCompounds.size());
}

References getMemberList(), m_innerCompounds, and MemberList::numDocMembers().

◆ setFileName()

void NamespaceDefImpl::setFileName ( const QCString & fn )

overridevirtual

Implements NamespaceDefMutable.

Definition at line 350 of file namespacedef.cpp.

{
  setFileNameLocal(fn);
}

References setFileNameLocal().

◆ setFileNameLocal()

void NamespaceDefImpl::setFileNameLocal ( const QCString & fn )

private

Definition at line 338 of file namespacedef.cpp.

{
  if (isReference())
  {
    fileName = "namespace"+fn;
  }
  else
  {
    fileName = convertNameToFile("namespace"+fn);
  }
}

References convertNameToFile(), fileName, and DefinitionMixin< NamespaceDefMutable >::isReference().

Referenced by setFileName().

◆ setInline()

void NamespaceDefImpl::setInline ( bool isInline )

inlineoverridevirtual

Implements NamespaceDefMutable.

Definition at line 89 of file namespacedef.cpp.

89{ m_inline = isInline; }

References isInline(), and m_inline.

◆ setMetaData()

void NamespaceDefImpl::setMetaData ( const QCString & m )

overridevirtual

Implements NamespaceDefMutable.

Definition at line 1621 of file namespacedef.cpp.

{
  metaData = m;
}

References metaData.

◆ setName()

void NamespaceDefImpl::setName ( const QCString & name )

overridevirtual

Sets a new name for the definition

Reimplemented from DefinitionMixin< NamespaceDefMutable >.

Definition at line 328 of file namespacedef.cpp.

{
  DefinitionMixin<NamespaceDefMutable>::setName(name);
  updateLocalName();
}

References DefinitionMixin< NamespaceDefMutable >::name(), DefinitionMixin< Base >::setName(), and updateLocalName().

◆ sortMemberLists()

void NamespaceDefImpl::sortMemberLists ( )

overridevirtual

Implements NamespaceDefMutable.

Definition at line 1449 of file namespacedef.cpp.

{
  for (auto &ml : m_memberLists)
  {
    if (ml->needsSorting()) { ml->sort(); ml->setNeedsSorting(FALSE); }
  }
 
  auto classComp = [](const ClassLinkedRefMap::Ptr &c1,const ClassLinkedRefMap::Ptr &c2)
  {
    return Config_getBool(SORT_BY_SCOPE_NAME)          ?
      qstricmp_sort(c1->name(), c2->name())<0          :
      qstricmp_sort(c1->className(), c2->className())<0;
  };
 
  std::stable_sort(classes.begin(),   classes.end(),   classComp);
  std::stable_sort(interfaces.begin(),interfaces.end(),classComp);
  std::stable_sort(structs.begin(),   structs.end(),   classComp);
  std::stable_sort(exceptions.begin(),exceptions.end(),classComp);
 
 
  auto namespaceComp = [](const NamespaceLinkedRefMap::Ptr &n1,const NamespaceLinkedRefMap::Ptr &n2)
  {
    return qstricmp_sort(n1->name(),n2->name())<0;
  };
 
  std::stable_sort(namespaces.begin(),namespaces.end(),namespaceComp);
}

References classes, ClassDef::className(), Config_getBool, exceptions, FALSE, interfaces, m_memberLists, Definition::name(), namespaces, qstricmp_sort(), and structs.

◆ startMemberDeclarations()

void NamespaceDefImpl::startMemberDeclarations ( OutputList & ol )

private

Definition at line 779 of file namespacedef.cpp.

{
  ol.startMemberSections();
}

References OutputList::startMemberSections().

Referenced by writeDocumentation().

◆ startMemberDocumentation()

void NamespaceDefImpl::startMemberDocumentation ( OutputList & ol )

private

Definition at line 789 of file namespacedef.cpp.

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

References Config_getBool, OutputList::disable(), Html, Doxygen::suppressDocWarnings, and TRUE.

Referenced by writeDocumentation().

◆ subGrouping()

bool NamespaceDefImpl::subGrouping ( ) const

inlineoverridevirtual

Implements NamespaceDef.

Definition at line 106 of file namespacedef.cpp.

106{ return m_subGrouping; }

References m_subGrouping.

◆ title()

QCString NamespaceDefImpl::title ( ) const

overridevirtual

Implements NamespaceDef.

Definition at line 1559 of file namespacedef.cpp.

{
  SrcLangExt lang = getLanguage();
  QCString pageTitle;
  if (lang==SrcLangExt::Java)
  {
    pageTitle = theTranslator->trPackage(displayName());
  }
  else if (lang==SrcLangExt::Fortran || lang==SrcLangExt::Slice)
  {
    pageTitle = theTranslator->trModuleReference(displayName());
  }
  else if (lang==SrcLangExt::IDL)
  {
    pageTitle = isConstantGroup()
        ? theTranslator->trConstantGroupReference(displayName())
        : theTranslator->trModuleReference(displayName());
  }
  else
  {
    pageTitle = theTranslator->trNamespaceReference(displayName());
  }
  return pageTitle;
}

References displayName(), Fortran, DefinitionMixin< NamespaceDefMutable >::getLanguage(), IDL, isConstantGroup(), Java, Slice, and theTranslator.

Referenced by writeClassDeclarations(), writeConcepts(), writeDetailedDescription(), writeDocumentation(), writeMemberDeclarations(), writeMemberDocumentation(), and writeNamespaceDeclarations().

◆ updateLocalName()

void NamespaceDefImpl::updateLocalName ( )

private

Definition at line 317 of file namespacedef.cpp.

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

References QCString::findRev(), QCString::mid(), DefinitionMixin< NamespaceDefMutable >::name(), and DefinitionMixin< NamespaceDefMutable >::setLocalName().

Referenced by setName().

◆ writeAuthorSection()

void NamespaceDefImpl::writeAuthorSection ( OutputList & ol )

private

Definition at line 840 of file namespacedef.cpp.

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

References Config_getString, OutputList::disableAllBut(), OutputList::endGroupHeader(), Man, OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), OutputList::startGroupHeader(), theTranslator, and TRUE.

Referenced by writeDocumentation().

◆ writeBriefDescription()

void NamespaceDefImpl::writeBriefDescription ( OutputList & ol )

private

Definition at line 725 of file namespacedef.cpp.

{
  if (hasBriefDescription())
  {
    auto parser { createDocParser() };
    auto ast    { validatingParseDoc(*parser.get(),
                                     briefFile(),briefLine(),this,nullptr,
                                     briefDescription(),TRUE,FALSE,
                                     QCString(),TRUE,FALSE,Config_getBool(MARKDOWN_SUPPORT)) };
    if (!ast->isEmpty())
    {
      ol.startParagraph();
      ol.pushGeneratorState();
      ol.disableAllBut(OutputType::Man);
      ol.writeString(" - ");
      ol.popGeneratorState();
      ol.writeDoc(ast.get(),this,nullptr);
      ol.pushGeneratorState();
      ol.disable(OutputType::RTF);
      ol.writeString(" \n");
      ol.enable(OutputType::RTF);
 
      if (hasDetailedDescription())
      {
        ol.disableAllBut(OutputType::Html);
        ol.startTextLink(getOutputFileBase(),"details");
        ol.parseText(theTranslator->trMore());
        ol.endTextLink();
      }
      ol.popGeneratorState();
      ol.endParagraph();
    }
  }
 
  // Write a summary of the Slice definition including metadata.
  if (getLanguage() == SrcLangExt::Slice)
  {
    ol.startParagraph();
    ol.startTypewriter();
    if (!metaData.isEmpty())
    {
      ol.docify(metaData);
      ol.lineBreak();
    }
    ol.docify("module ");
    ol.docify(stripScope(name()));
    ol.docify(" { ... }");
    ol.endTypewriter();
    ol.endParagraph();
  }
 
  ol.writeSynopsis();
}

References DefinitionMixin< NamespaceDefMutable >::briefDescription(), DefinitionMixin< NamespaceDefMutable >::briefFile(), DefinitionMixin< NamespaceDefMutable >::briefLine(), Config_getBool, createDocParser(), OutputList::disable(), OutputList::disableAllBut(), OutputList::docify(), OutputList::enable(), OutputList::endParagraph(), OutputList::endTextLink(), OutputList::endTypewriter(), FALSE, DefinitionMixin< NamespaceDefMutable >::getLanguage(), getOutputFileBase(), DefinitionMixin< NamespaceDefMutable >::hasBriefDescription(), hasDetailedDescription(), Html, OutputList::lineBreak(), Man, metaData, DefinitionMixin< NamespaceDefMutable >::name(), OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), RTF, Slice, OutputList::startParagraph(), OutputList::startTextLink(), OutputList::startTypewriter(), stripScope(), theTranslator, TRUE, validatingParseDoc(), OutputList::writeDoc(), OutputList::writeString(), and OutputList::writeSynopsis().

Referenced by writeDocumentation().

◆ writeClassDeclarations()

void NamespaceDefImpl::writeClassDeclarations	(	OutputList &	ol,
		const QCString &	title,
		const ClassLinkedRefMap &	d )

private

Definition at line 807 of file namespacedef.cpp.

{
  d.writeDeclaration(ol,nullptr,title,TRUE);
}

References title(), TRUE, and ClassLinkedRefMap::writeDeclaration().

Referenced by writeDocumentation().

◆ writeClassesToTagFile()

void NamespaceDefImpl::writeClassesToTagFile	(	TextStream &	tagFile,
		const ClassLinkedRefMap &	d )

private

Definition at line 947 of file namespacedef.cpp.

{
  for (const auto &cd : list)
  {
    if (cd->isLinkableInProject())
    {
      tagFile << "    <class kind=\"" << cd->compoundTypeString()
              << "\">" << convertToXML(cd->name()) << "</class>\n";
    }
  }
}

References convertToXML().

Referenced by writeTagFile().

◆ writeConcepts()

void NamespaceDefImpl::writeConcepts	(	OutputList &	ol,
		const QCString &	title )

private

Definition at line 812 of file namespacedef.cpp.

{
  m_concepts.writeDeclaration(ol,title,TRUE);
}

References m_concepts, title(), and TRUE.

Referenced by writeDocumentation().

◆ writeConceptsToTagFile()

void NamespaceDefImpl::writeConceptsToTagFile ( TextStream & tagFile )

private

Definition at line 959 of file namespacedef.cpp.

{
  for (const auto &cd : m_concepts)
  {
    if (cd->isLinkableInProject())
    {
      tagFile << "    <concept>" << convertToXML(cd->name()) << "</concept>\n";
    }
  }
}

References convertToXML(), and m_concepts.

Referenced by writeTagFile().

◆ writeDetailedDescription()

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

private

Definition at line 682 of file namespacedef.cpp.

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

References DefinitionMixin< NamespaceDefMutable >::briefDescription(), DefinitionMixin< NamespaceDefMutable >::briefFile(), DefinitionMixin< NamespaceDefMutable >::briefLine(), Config_getBool, OutputList::disable(), OutputList::disableAllBut(), DefinitionMixin< NamespaceDefMutable >::docFile(), DefinitionMixin< NamespaceDefMutable >::docLine(), DefinitionMixin< NamespaceDefMutable >::documentation(), OutputList::enable(), OutputList::enableAll(), OutputList::endGroupHeader(), OutputList::endTextBlock(), FALSE, OutputList::generateDoc(), hasDetailedDescription(), Html, Latex, Man, OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), RTF, OutputList::startGroupHeader(), OutputList::startTextBlock(), title(), TRUE, OutputList::writeAnchor(), OutputList::writeRuler(), and OutputList::writeString().

Referenced by writeDocumentation().

◆ writeDocumentation()

void NamespaceDefImpl::writeDocumentation ( OutputList & ol )

overridevirtual

Implements NamespaceDefMutable.

Definition at line 970 of file namespacedef.cpp.

{
  bool generateTreeView = Config_getBool(GENERATE_TREEVIEW);
  //bool outputJava = Config_getBool(OPTIMIZE_OUTPUT_JAVA);
  //bool fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
 
  QCString pageTitle = title();
  startFile(ol,getOutputFileBase(),name(),pageTitle,HighlightedItem::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();
 
  //---------------------------------------- start flexible part -------------------------------
 
  SrcLangExt lang = getLanguage();
  for (const auto &lde : LayoutDocManager::instance().docEntries(LayoutDocManager::Namespace))
  {
    const LayoutDocEntrySection *ls = dynamic_cast<const LayoutDocEntrySection*>(lde.get());
    switch (lde->kind())
    {
      case LayoutDocEntry::BriefDesc:
        writeBriefDescription(ol);
        break;
      case LayoutDocEntry::MemberDeclStart:
        startMemberDeclarations(ol);
        break;
      case LayoutDocEntry::NamespaceClasses:
        {
          if (ls) writeClassDeclarations(ol,ls->title(lang),classes);
        }
        break;
      case LayoutDocEntry::NamespaceInterfaces:
        {
          if (ls) writeClassDeclarations(ol,ls->title(lang),interfaces);
        }
        break;
      case LayoutDocEntry::NamespaceStructs:
        {
          if (ls) writeClassDeclarations(ol,ls->title(lang),structs);
        }
        break;
      case LayoutDocEntry::NamespaceExceptions:
        {
          if (ls) writeClassDeclarations(ol,ls->title(lang),exceptions);
        }
        break;
      case LayoutDocEntry::NamespaceConcepts:
        {
          if (ls) writeConcepts(ol,ls->title(lang));
        }
        break;
      case LayoutDocEntry::NamespaceNestedNamespaces:
        {
          if (ls) writeNamespaceDeclarations(ol,ls->title(lang),false);
        }
        break;
      case LayoutDocEntry::NamespaceNestedConstantGroups:
        {
          if (ls) writeNamespaceDeclarations(ol,ls->title(lang),true);
        }
        break;
      case LayoutDocEntry::MemberGroups:
        writeMemberGroups(ol);
        break;
      case LayoutDocEntry::MemberDecl:
        {
          const LayoutDocEntryMemberDecl *lmd = dynamic_cast<const LayoutDocEntryMemberDecl*>(lde.get());
          if (lmd) writeMemberDeclarations(ol,lmd->type,lmd->title(lang));
        }
        break;
      case LayoutDocEntry::MemberDeclEnd:
        endMemberDeclarations(ol);
        break;
      case LayoutDocEntry::DetailedDesc:
        {
          if (ls) writeDetailedDescription(ol,ls->title(lang));
        }
        break;
      case LayoutDocEntry::MemberDefStart:
        startMemberDocumentation(ol);
        break;
      case LayoutDocEntry::NamespaceInlineClasses:
        writeInlineClasses(ol);
        break;
      case LayoutDocEntry::MemberDef:
        {
          const LayoutDocEntryMemberDef *lmd = dynamic_cast<const LayoutDocEntryMemberDef*>(lde.get());
          if (lmd) 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::ConceptDefinition:
      case LayoutDocEntry::FileClasses:
      case LayoutDocEntry::FileConcepts:
      case LayoutDocEntry::FileInterfaces:
      case LayoutDocEntry::FileStructs:
      case LayoutDocEntry::FileExceptions:
      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::GroupConcepts:
      case LayoutDocEntry::GroupModules:
      case LayoutDocEntry::GroupInlineClasses:
      case LayoutDocEntry::GroupNamespaces:
      case LayoutDocEntry::GroupDirs:
      case LayoutDocEntry::GroupNestedGroups:
      case LayoutDocEntry::GroupFiles:
      case LayoutDocEntry::GroupGraph:
      case LayoutDocEntry::GroupPageDocs:
      case LayoutDocEntry::ModuleExports:
      case LayoutDocEntry::ModuleClasses:
      case LayoutDocEntry::ModuleConcepts:
      case LayoutDocEntry::ModuleUsedFiles:
      case LayoutDocEntry::DirSubDirs:
      case LayoutDocEntry::DirFiles:
      case LayoutDocEntry::DirGraph:
        err("Internal inconsistency: member '{}' should not be part of "
            "LayoutDocManager::Namespace entry list\n",lde->entryToString());
        break;
    }
  }
 
  //---------------------------------------- end flexible part -------------------------------
 
  ol.endContents();
 
  endFileWithNavPath(ol,this);
 
  if (Config_getBool(SEPARATE_MEMBER_PAGES))
  {
    MemberList *allMemberList = getMemberList(MemberListType::AllMembersList());
    if (allMemberList) allMemberList->sort();
    writeMemberPages(ol);
  }
}

References addGroupListToTitle(), addNamespaceAttributes(), classes, Config_getBool, displayName(), OutputList::endContents(), endFileWithNavPath(), endMemberDeclarations(), endMemberDocumentation(), OutputList::endQuickIndices(), endTitle(), err, exceptions, DefinitionMixin< NamespaceDefMutable >::getLanguage(), getMemberList(), DefinitionMixin< NamespaceDefMutable >::getOuterScope(), getOutputFileBase(), Doxygen::globalScope, LayoutDocManager::instance(), interfaces, DefinitionMixin< NamespaceDefMutable >::name(), NamespaceVisible, OutputList::parseText(), MemberVector::sort(), OutputList::startContents(), startFile(), startMemberDeclarations(), startMemberDocumentation(), startTitle(), structs, LayoutDocEntryMemberDecl::title(), LayoutDocEntryMemberDef::title(), LayoutDocEntrySection::title(), title(), LayoutDocEntryMemberDecl::type, LayoutDocEntryMemberDef::type, writeAuthorSection(), writeBriefDescription(), writeClassDeclarations(), writeConcepts(), writeDetailedDescription(), writeInlineClasses(), writeMemberDeclarations(), writeMemberDocumentation(), writeMemberGroups(), writeMemberPages(), writeNamespaceDeclarations(), and DefinitionMixin< NamespaceDefMutable >::writeNavigationPath().

◆ writeInlineClasses()

void NamespaceDefImpl::writeInlineClasses ( OutputList & ol )

private

Definition at line 817 of file namespacedef.cpp.

{
  classes.writeDocumentation(ol,this);
}

References classes.

Referenced by writeDocumentation().

◆ writeMemberDeclarations()

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

private

Definition at line 1489 of file namespacedef.cpp.

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

References getMemberList(), title(), and MemberList::writeDeclarations().

Referenced by writeDocumentation().

◆ writeMemberDocumentation()

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

private

Definition at line 1495 of file namespacedef.cpp.

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

References displayName(), getMemberList(), title(), and MemberList::writeDocumentation().

Referenced by writeDocumentation().

◆ writeMemberGroups()

void NamespaceDefImpl::writeMemberGroups ( OutputList & ol )

private

Definition at line 828 of file namespacedef.cpp.

{
  /* write user defined member groups */
  for (const auto &mg : m_memberGroups)
  {
    if (!mg->allMembersInSameSection() || !m_subGrouping)
    {
      mg->writeDeclarations(ol,nullptr,this,nullptr,nullptr,nullptr);
    }
  }
}

References m_memberGroups, and m_subGrouping.

Referenced by writeDocumentation().

◆ writeMemberPages()

void NamespaceDefImpl::writeMemberPages ( OutputList & ol )

overridevirtual

Implements NamespaceDefMutable.

Definition at line 1136 of file namespacedef.cpp.

{
  ol.pushGeneratorState();
  ol.disableAllBut(OutputType::Html);
 
  for (const auto &ml : m_memberLists)
  {
    if (ml->listType().isDocumentation())
    {
      ml->writeDocumentationPage(ol,displayName(),this);
    }
  }
  ol.popGeneratorState();
}

References OutputList::disableAllBut(), displayName(), Html, m_memberLists, OutputList::popGeneratorState(), and OutputList::pushGeneratorState().

Referenced by writeDocumentation().

◆ writeNamespaceDeclarations()

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

private

Definition at line 822 of file namespacedef.cpp.

{
  namespaces.writeDeclaration(ol,title,isConstantGroup,TRUE);
}

References isConstantGroup(), namespaces, title(), and TRUE.

Referenced by writeDocumentation().

◆ writeQuickMemberLinks()

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

overridevirtual

Reimplemented from DefinitionMixin< NamespaceDefMutable >.

Definition at line 1151 of file namespacedef.cpp.

{
  bool createSubDirs=Config_getBool(CREATE_SUBDIRS);
 
  ol.writeString("      <div class=\"navtab\">\n");
  ol.writeString("        <table>\n");
 
  MemberList *allMemberList = getMemberList(MemberListType::AllMembersList());
  if (allMemberList)
  {
    for (const auto &md : *allMemberList)
    {
      if (md->getNamespaceDef()==this && md->isLinkable() && !md->isEnumValue())
      {
        if (md->isLinkableInProject())
        {
          QCString fn = md->getOutputFileBase();
          addHtmlExtensionIfMissing(fn);
          if (md==currentMd) // selected item => highlight
          {
            ol.writeString("          <tr><td class=\"navtabHL\">");
          }
          else
          {
            ol.writeString("          <tr><td class=\"navtab\">");
          }
          ol.writeString("<a class=\"navtab\" ");
          ol.writeString("href=\"");
          if (createSubDirs) ol.writeString("../../");
          ol.writeString(fn+"#"+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");
}

References addHtmlExtensionIfMissing(), Config_getBool, convertToHtml(), createSubDirs(), getMemberList(), and OutputList::writeString().

◆ writeSummaryLinks()

void NamespaceDefImpl::writeSummaryLinks ( OutputList & ol ) const

overridevirtual

Reimplemented from DefinitionMixin< NamespaceDefMutable >.

Definition at line 852 of file namespacedef.cpp.

{
  ol.pushGeneratorState();
  ol.disableAllBut(OutputType::Html);
  bool first=TRUE;
  SrcLangExt lang = getLanguage();
  for (const auto &lde : LayoutDocManager::instance().docEntries(LayoutDocManager::Namespace))
  {
    const LayoutDocEntrySection *ls = dynamic_cast<const LayoutDocEntrySection*>(lde.get());
    if (lde->kind()==LayoutDocEntry::NamespaceClasses && classes.declVisible() && ls)
    {
      QCString label = "nested-classes";
      ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
      first=FALSE;
    }
    else if (lde->kind()==LayoutDocEntry::NamespaceInterfaces && interfaces.declVisible() && ls)
    {
      QCString label = "interfaces";
      ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
      first=FALSE;
    }
    else if (lde->kind()==LayoutDocEntry::NamespaceStructs && structs.declVisible() && ls)
    {
      QCString label = "structs";
      ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
      first=FALSE;
    }
    else if (lde->kind()==LayoutDocEntry::NamespaceExceptions && exceptions.declVisible() && ls)
    {
      QCString label = "exceptions";
      ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
      first=FALSE;
    }
    else if (lde->kind()==LayoutDocEntry::NamespaceNestedNamespaces && namespaces.declVisible(false) && ls)
    {
      QCString label = "namespaces";
      ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
      first=FALSE;
    }
    else if (lde->kind()==LayoutDocEntry::NamespaceNestedConstantGroups && namespaces.declVisible(true) && ls)
    {
      QCString label = "constantgroups";
      ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
      first=FALSE;
    }
    else if (lde->kind()==LayoutDocEntry::NamespaceConcepts && m_concepts.declVisible() && ls)
    {
      QCString label = "concepts";
      ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
      first=FALSE;
    }
    else if (lde->kind()== LayoutDocEntry::MemberDecl)
    {
      const LayoutDocEntryMemberDecl *lmd = dynamic_cast<const LayoutDocEntryMemberDecl*>(lde.get());
      if (lmd)
      {
        MemberList * ml = getMemberList(lmd->type);
        if (ml && ml->declVisible())
        {
          ol.writeSummaryLink(QCString(),ml->listType().toLabel(),lmd->title(lang),first);
          first=FALSE;
        }
      }
    }
  }
  if (!first)
  {
    ol.writeString("  </div>\n");
  }
  ol.popGeneratorState();
}

References classes, MemberList::declVisible(), OutputList::disableAllBut(), exceptions, FALSE, DefinitionMixin< NamespaceDefMutable >::getLanguage(), getMemberList(), Html, LayoutDocManager::instance(), interfaces, MemberList::listType(), m_concepts, namespaces, OutputList::popGeneratorState(), OutputList::pushGeneratorState(), structs, LayoutDocEntryMemberDecl::title(), LayoutDocEntrySection::title(), MemberListType::toLabel(), TRUE, LayoutDocEntryMemberDecl::type, OutputList::writeString(), and OutputList::writeSummaryLink().

◆ writeTagFile()

void NamespaceDefImpl::writeTagFile ( TextStream & tagFile )

overridevirtual

Implements NamespaceDefMutable.

Definition at line 601 of file namespacedef.cpp.

{
  QCString fn = getOutputFileBase();
  addHtmlExtensionIfMissing(fn);
  tagFile << "  <compound kind=\"namespace\">\n";
  tagFile << "    <name>" << convertToXML(name()) << "</name>\n";
  tagFile << "    <filename>" << fn << "</filename>\n";
  QCString idStr = id();
  if (!idStr.isEmpty())
  {
    tagFile << "    <clangid>" << convertToXML(idStr) << "</clangid>\n";
  }
  for (const auto &lde : LayoutDocManager::instance().docEntries(LayoutDocManager::Namespace))
  {
    switch (lde->kind())
    {
      case LayoutDocEntry::NamespaceNestedNamespaces:
        {
          for (const auto &nd : namespaces)
          {
            if (nd->isLinkableInProject())
            {
              tagFile << "    <namespace>" << convertToXML(nd->name()) << "</namespace>\n";
            }
          }
        }
        break;
      case LayoutDocEntry::NamespaceClasses:
        {
          writeClassesToTagFile(tagFile, classes);
        }
        break;
      case LayoutDocEntry::NamespaceInterfaces:
        {
          writeClassesToTagFile(tagFile, interfaces);
        }
        break;
      case LayoutDocEntry::NamespaceStructs:
        {
          writeClassesToTagFile(tagFile, structs);
        }
        break;
      case LayoutDocEntry::NamespaceExceptions:
        {
          writeClassesToTagFile(tagFile, exceptions);
        }
        break;
      case LayoutDocEntry::NamespaceConcepts:
        {
          writeConceptsToTagFile(tagFile);
        }
        break;
      case LayoutDocEntry::MemberDecl:
        {
          const LayoutDocEntryMemberDecl *lmd = dynamic_cast<const LayoutDocEntryMemberDecl*>(lde.get());
          if (lmd)
          {
            MemberList * ml = getMemberList(lmd->type);
            if (ml)
            {
              ml->writeTagFile(tagFile);
            }
          }
        }
        break;
      case LayoutDocEntry::MemberGroups:
        {
          for (const auto &mg : m_memberGroups)
          {
            mg->writeTagFile(tagFile);
          }
        }
        break;
      default:
        break;
    }
  }
  writeDocAnchorsToTagFile(tagFile);
  tagFile << "  </compound>\n";
}

References addHtmlExtensionIfMissing(), classes, convertToXML(), exceptions, getMemberList(), getOutputFileBase(), DefinitionMixin< NamespaceDefMutable >::id(), LayoutDocManager::instance(), interfaces, QCString::isEmpty(), m_memberGroups, DefinitionMixin< NamespaceDefMutable >::name(), namespaces, structs, LayoutDocEntryMemberDecl::type, writeClassesToTagFile(), writeConceptsToTagFile(), DefinitionMixin< NamespaceDefMutable >::writeDocAnchorsToTagFile(), and MemberList::writeTagFile().

Member Data Documentation

◆ classes

ClassLinkedRefMap NamespaceDefImpl::classes

private

Definition at line 160 of file namespacedef.cpp.

Referenced by getClasses(), insertClass(), sortMemberLists(), writeDocumentation(), writeInlineClasses(), writeSummaryLinks(), and writeTagFile().

◆ exceptions

ClassLinkedRefMap NamespaceDefImpl::exceptions

private

Definition at line 163 of file namespacedef.cpp.

Referenced by getExceptions(), insertClass(), sortMemberLists(), writeDocumentation(), writeSummaryLinks(), and writeTagFile().

◆ fileName

QCString NamespaceDefImpl::fileName

private

Definition at line 150 of file namespacedef.cpp.

Referenced by getOutputFileBase(), and setFileNameLocal().

◆ files

FileList NamespaceDefImpl::files

private

Definition at line 151 of file namespacedef.cpp.

Referenced by insertUsedFile().

◆ interfaces

ClassLinkedRefMap NamespaceDefImpl::interfaces

private

Definition at line 161 of file namespacedef.cpp.

Referenced by getInterfaces(), insertClass(), sortMemberLists(), writeDocumentation(), writeSummaryLinks(), and writeTagFile().

◆ m_allMembers

MemberLinkedRefMap NamespaceDefImpl::m_allMembers

private

Definition at line 157 of file namespacedef.cpp.

Referenced by getMemberByName(), and insertMember().

◆ m_concepts

ConceptLinkedRefMap NamespaceDefImpl::m_concepts

private

Definition at line 164 of file namespacedef.cpp.

Referenced by getConcepts(), insertConcept(), writeConcepts(), writeConceptsToTagFile(), and writeSummaryLinks().

◆ m_inline

bool NamespaceDefImpl::m_inline = false

private

Definition at line 170 of file namespacedef.cpp.

Referenced by isInline(), and setInline().

◆ m_innerCompounds

LinkedRefMap<const Definition> NamespaceDefImpl::m_innerCompounds

private

Definition at line 155 of file namespacedef.cpp.

Referenced by addInnerCompound(), findInnerCompound(), and numDocMembers().

◆ m_isPublished

bool NamespaceDefImpl::m_isPublished = false

private

Definition at line 168 of file namespacedef.cpp.

Referenced by addNamespaceAttributes(), and NamespaceDefImpl().

◆ m_memberGroups

MemberGroupList NamespaceDefImpl::m_memberGroups

private

Definition at line 159 of file namespacedef.cpp.

Referenced by addListReferences(), addMembersToMemberGroup(), countMembers(), distributeMemberGroupDocumentation(), findSectionsInDocumentation(), getMemberGroups(), writeMemberGroups(), and writeTagFile().

◆ m_memberLists

MemberLists NamespaceDefImpl::m_memberLists

private

Definition at line 158 of file namespacedef.cpp.

Referenced by addListReferences(), addMembersToMemberGroup(), addMemberToList(), countMembers(), findSectionsInDocumentation(), getMemberList(), getMemberLists(), insertMember(), sortMemberLists(), and writeMemberPages().

◆ m_subGrouping

bool NamespaceDefImpl::m_subGrouping = false

private

Definition at line 166 of file namespacedef.cpp.

Referenced by addMembersToMemberGroup(), subGrouping(), and writeMemberGroups().

◆ []

enum { ... } NamespaceDefImpl::m_type

Referenced by isConstantGroup(), isLibrary(), and isModule().

◆ m_usingDeclList

LinkedRefMap<const Definition> NamespaceDefImpl::m_usingDeclList

private

Definition at line 154 of file namespacedef.cpp.

Referenced by addUsingDeclaration(), findInnerCompound(), and getUsedDefinitions().

◆ m_usingDirList

LinkedRefMap<NamespaceDef> NamespaceDefImpl::m_usingDirList

private

Definition at line 153 of file namespacedef.cpp.

Referenced by addUsingDirective(), combineUsingRelations(), findInnerCompound(), and getUsedNamespaces().

◆ metaData

QCString NamespaceDefImpl::metaData

private

Definition at line 169 of file namespacedef.cpp.

Referenced by setMetaData(), and writeBriefDescription().

◆ namespaces

NamespaceLinkedRefMap NamespaceDefImpl::namespaces

private

Definition at line 165 of file namespacedef.cpp.

Referenced by getNamespaces(), insertNamespace(), sortMemberLists(), writeNamespaceDeclarations(), writeSummaryLinks(), and writeTagFile().

◆ structs

ClassLinkedRefMap NamespaceDefImpl::structs

private

Definition at line 162 of file namespacedef.cpp.

Referenced by getStructs(), insertClass(), sortMemberLists(), writeDocumentation(), writeSummaryLinks(), and writeTagFile().

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

src/namespacedef.cpp

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ anonymous enum

Constructor & Destructor Documentation

◆ NamespaceDefImpl()

◆ ~NamespaceDefImpl()

Member Function Documentation

◆ addInnerCompound()

◆ addListReferences()

◆ addMembersToMemberGroup()

◆ addMemberToList()

◆ addNamespaceAttributes()

◆ addUsingDeclaration()

◆ addUsingDirective()

◆ anchor()

◆ codeSymbolType()

◆ combineUsingRelations()

◆ compoundTypeString()

◆ computeAnchors()

◆ countMembers()

◆ countVisibleMembers()

◆ definitionType()

◆ displayName()

◆ distributeMemberGroupDocumentation()

◆ endMemberDeclarations()

◆ endMemberDocumentation()

◆ findInnerCompound()

◆ findSectionsInDocumentation()

◆ getClasses()

◆ getConcepts()

◆ getExceptions()

◆ getInterfaces()

◆ getMemberByName()

◆ getMemberGroups()

◆ getMemberList()

◆ getMemberLists()

◆ getNamespaces()

◆ getOutputFileBase()

◆ getStructs()

◆ getUsedDefinitions()

◆ getUsedNamespaces()

◆ hasDetailedDescription()

◆ insertClass()

◆ insertConcept()

◆ insertMember()

◆ insertNamespace()

◆ insertUsedFile()

◆ isConstantGroup()

◆ isInline()

◆ isLibrary()

◆ isLinkable()

◆ isLinkableInProject()

◆ isModule()

◆ isVisibleInHierarchy()

◆ numDocMembers()

◆ setFileName()

◆ setFileNameLocal()

◆ setInline()

◆ setMetaData()

◆ setName()

◆ sortMemberLists()

◆ startMemberDeclarations()

◆ startMemberDocumentation()

◆ subGrouping()

◆ title()

◆ updateLocalName()

◆ writeAuthorSection()

◆ writeBriefDescription()

◆ writeClassDeclarations()

◆ writeClassesToTagFile()

◆ writeConcepts()

◆ writeConceptsToTagFile()

◆ writeDetailedDescription()

◆ writeDocumentation()

◆ writeInlineClasses()