NamespaceDefImpl Class Reference

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	addRequirementReferences () 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
void	writePageNavigation (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 &	operator= (const DefinitionMixin &other)
	~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
const RequirementRefs &	requirementReferences () 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	setRequirementReferences (const RequirementRefs &rqli) 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
bool	hasRequirementRefs () const override
void	writeRequirementRefs (OutputList &ol) 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	m_classes
ClassLinkedRefMap	m_interfaces
ClassLinkedRefMap	m_structs
ClassLinkedRefMap	m_exceptions
ConceptLinkedRefMap	m_concepts
NamespaceLinkedRefMap	m_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 54 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.

{ NAMESPACE, MODULE, CONSTANT_GROUP, LIBRARY } m_type;

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.

{
}

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

{
  addRefItem(xrefListItems(),
             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(), 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 1460 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 944 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, isConstantGroup(), DefinitionMixin< NamespaceDefMutable >::isExported(), m_isPublished, OutputList::popGeneratorState(), OutputList::pushGeneratorState(), OutputList::startLabels(), and OutputList::writeLabel().

Referenced by writeDocumentation().

addRequirementReferences()

void NamespaceDefImpl::addRequirementReferences ( )

overridevirtual

Implements NamespaceDefMutable.

Definition at line 1292 of file namespacedef.cpp.

{
  RequirementManager::instance().addRequirementRefsForSymbol(this);
  for (const auto &mg : m_memberGroups)
  {
    mg->addRequirementReferences(this);
  }
  for (auto &ml : m_memberLists)
  {
    if (ml->listType().isDocumentation())
    {
      ml->addRequirementReferences(this);
    }
  }
}

References RequirementManager::addRequirementRefsForSymbol(), RequirementManager::instance(), m_memberGroups, and m_memberLists.

addUsingDeclaration()

void NamespaceDefImpl::addUsingDeclaration ( const Definition * cd )

overridevirtual

Implements NamespaceDefMutable.

Definition at line 1240 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 1234 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 68 of file namespacedef.cpp.

{ return QCString(); }

codeSymbolType()

CodeSymbolType NamespaceDefImpl::codeSymbolType ( ) const

inlineoverridevirtual

Used for syntax highlighting symbol class

Implements Definition.

Definition at line 65 of file namespacedef.cpp.

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

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

combineUsingRelations()

void NamespaceDefImpl::combineUsingRelations ( NamespaceDefSet & visitedNamespace )

overridevirtual

Implements NamespaceDefMutable.

Definition at line 1313 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 1637 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 err_full, DefinitionMixin< NamespaceDefMutable >::getDefFileName(), DefinitionMixin< NamespaceDefMutable >::getDefLine(), DefinitionMixin< NamespaceDefMutable >::getLanguage(), isConstantGroup(), isLibrary(), and isModule().

computeAnchors()

void NamespaceDefImpl::computeAnchors ( )

overridevirtual

Implements NamespaceDefMutable.

Definition at line 587 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 1214 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 1343 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 64 of file namespacedef.cpp.

{ 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 1308 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 799 of file namespacedef.cpp.

{
  ol.endMemberSections();
}

References OutputList::endMemberSections().

Referenced by writeDocumentation().

endMemberDocumentation()

void NamespaceDefImpl::endMemberDocumentation ( OutputList & ol )

private

Definition at line 813 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 1250 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 110 of file namespacedef.cpp.

{ return m_classes; }

References m_classes.

getConcepts()

ConceptLinkedRefMap NamespaceDefImpl::getConcepts ( ) const

inlineoverridevirtual

Returns the concepts contained in this namespace

Implements NamespaceDef.

Definition at line 115 of file namespacedef.cpp.

{ return m_concepts; }

References m_concepts.

getExceptions()

ClassLinkedRefMap NamespaceDefImpl::getExceptions ( ) const

inlineoverridevirtual

Returns the Slice exceptions contained in this namespace

Implements NamespaceDef.

Definition at line 113 of file namespacedef.cpp.

{ return m_exceptions; }

References m_exceptions.

getInterfaces()

ClassLinkedRefMap NamespaceDefImpl::getInterfaces ( ) const

inlineoverridevirtual

Returns the Slice interfaces contained in this namespace

Implements NamespaceDef.

Definition at line 111 of file namespacedef.cpp.

{ return m_interfaces; }

References m_interfaces.

getMemberByName()

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

overridevirtual

Implements NamespaceDef.

Definition at line 1595 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 109 of file namespacedef.cpp.

{ return m_memberGroups; }

References m_memberGroups.

getMemberList()

MemberList * NamespaceDefImpl::getMemberList ( MemberListType lt ) const

overridevirtual

Implements NamespaceDef.

Definition at line 1518 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 107 of file namespacedef.cpp.

{ return m_memberLists; }

References m_memberLists.

getNamespaces()

NamespaceLinkedRefMap NamespaceDefImpl::getNamespaces ( ) const

inlineoverridevirtual

Returns the namespaces contained in this namespace

Implements NamespaceDef.

Definition at line 114 of file namespacedef.cpp.

{ return m_namespaces; }

References m_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 1245 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 112 of file namespacedef.cpp.

{ return m_structs; }

References m_structs.

getUsedDefinitions()

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

inlineoverridevirtual

Implements NamespaceDef.

Definition at line 84 of file namespacedef.cpp.

{ return m_usingDeclList; }

References m_usingDeclList.

getUsedNamespaces()

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

inlineoverridevirtual

Implements NamespaceDef.

Definition at line 82 of file namespacedef.cpp.

{ return m_usingDirList; }

References m_usingDirList.

hasDetailedDescription()

bool NamespaceDefImpl::hasDetailedDescription ( ) const

overridevirtual

Implements NamespaceDef.

Definition at line 593 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 = &m_classes;
 
  if (Config_getBool(OPTIMIZE_OUTPUT_SLICE))
  {
    if (cd->compoundType()==ClassDef::Interface)
    {
      d = &m_interfaces;
    }
    else if (cd->compoundType()==ClassDef::Struct)
    {
      d = &m_structs;
    }
    else if (cd->compoundType()==ClassDef::Exception)
    {
      d = &m_exceptions;
    }
  }
 
  d->add(cd->name(),cd);
}

References LinkedRefMap< T, Hash, KeyEqual, Map >::add(), ClassDef::compoundType(), Config_getBool, ClassDef::Exception, ClassDef::Interface, m_classes, m_exceptions, m_interfaces, m_structs, Definition::name(), and ClassDef::Struct.

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)
        {
          MemberName *mn = Doxygen::functionNameLinkedMap->add(md->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(), 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.

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

References m_namespaces, and Definition::name().

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

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

{ return m_inline; }

References m_inline.

Referenced by insertMember(), and setInline().

isLibrary()

bool NamespaceDefImpl::isLibrary ( ) const

inlineoverridevirtual

Implements NamespaceDef.

Definition at line 90 of file namespacedef.cpp.

{ 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 1590 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 1571 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, 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 89 of file namespacedef.cpp.

{ 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 1565 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 1228 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 87 of file namespacedef.cpp.

{ m_inline = isInline; }

References isInline(), and m_inline.

setMetaData()

void NamespaceDefImpl::setMetaData ( const QCString & m )

overridevirtual

Implements NamespaceDefMutable.

Definition at line 1674 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 1480 of file namespacedef.cpp.

{
  for (auto &ml : m_memberLists)
  {
    if (ml->needsSorting()) { ml->sort(); ml->setNeedsSorting(FALSE); }
  }
 
  if (Config_getBool(SORT_BRIEF_DOCS))
  {
    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(m_classes.begin(),   m_classes.end(),   classComp);
    std::stable_sort(m_interfaces.begin(),m_interfaces.end(),classComp);
    std::stable_sort(m_structs.begin(),   m_structs.end(),   classComp);
    std::stable_sort(m_exceptions.begin(),m_exceptions.end(),classComp);
 
    auto conceptComp = [](const ConceptLinkedRefMap::Ptr &c1,const ConceptLinkedRefMap::Ptr &c2)
    {
      return qstricmp_sort(c1->name(),c2->name())<0;
    };
 
    std::stable_sort(m_concepts.begin(), m_concepts.end(), conceptComp);
 
    auto namespaceComp = [](const NamespaceLinkedRefMap::Ptr &n1,const NamespaceLinkedRefMap::Ptr &n2)
    {
      return qstricmp_sort(n1->name(),n2->name())<0;
    };
 
    std::stable_sort(m_namespaces.begin(),m_namespaces.end(),namespaceComp);
  }
 
}

References ClassDef::className(), Config_getBool, FALSE, m_classes, m_concepts, m_exceptions, m_interfaces, m_memberLists, m_namespaces, m_structs, Definition::name(), and qstricmp_sort().

startMemberDeclarations()

void NamespaceDefImpl::startMemberDeclarations ( OutputList & ol )

private

Definition at line 794 of file namespacedef.cpp.

{
  ol.startMemberSections();
}

References OutputList::startMemberSections().

Referenced by writeDocumentation().

startMemberDocumentation()

void NamespaceDefImpl::startMemberDocumentation ( OutputList & ol )

private

Definition at line 804 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 105 of file namespacedef.cpp.

{ return m_subGrouping; }

References m_subGrouping.

title()

QCString NamespaceDefImpl::title ( ) const

overridevirtual

Implements NamespaceDef.

Definition at line 1600 of file namespacedef.cpp.

{
  QCString pageTitle;
  SrcLangExt lang = getLanguage();
 
  auto getReferenceTitle = [this](std::function<QCString()> translateFunc) -> QCString
  {
    return Config_getBool(HIDE_COMPOUND_REFERENCE) ? displayName() : translateFunc();
  };
 
  if (lang==SrcLangExt::Java)
  {
    pageTitle = theTranslator->trPackage(displayName());
  }
  else if (lang==SrcLangExt::Fortran || lang==SrcLangExt::Slice)
  {
    pageTitle = getReferenceTitle([this](){
        return theTranslator->trModuleReference(displayName());
    });
  }
  else if (lang==SrcLangExt::IDL)
  {
    pageTitle = getReferenceTitle([this](){
        return isConstantGroup()
        ? theTranslator->trConstantGroupReference(displayName())
        : theTranslator->trModuleReference(displayName());
    });
  }
  else
  {
    pageTitle = getReferenceTitle([this](){
      return theTranslator->trNamespaceReference(displayName());
    });
  }
  return pageTitle;
}

References Config_getBool, displayName(), DefinitionMixin< NamespaceDefMutable >::getLanguage(), isConstantGroup(), 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 855 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 734 of file namespacedef.cpp.

{
  if (hasBriefDescription())
  {
    auto parser { createDocParser() };
    auto ast    { validatingParseDoc(*parser.get(),
                                     briefFile(),
                                     briefLine(),
                                     this,
                                     nullptr,
                                     briefDescription(),
                                     DocOptions()
                                     .setIndexWords(true)
                                     .setSingleLine(true))
                 };
    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(), createDocParser(), OutputList::disable(), OutputList::disableAllBut(), OutputList::docify(), OutputList::enable(), OutputList::endParagraph(), OutputList::endTextLink(), OutputList::endTypewriter(), DefinitionMixin< NamespaceDefMutable >::getLanguage(), getOutputFileBase(), DefinitionMixin< NamespaceDefMutable >::hasBriefDescription(), hasDetailedDescription(), Html, OutputList::lineBreak(), Man, metaData, DefinitionMixin< NamespaceDefMutable >::name(), OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), RTF, OutputList::startParagraph(), OutputList::startTextLink(), OutputList::startTypewriter(), stripScope(), theTranslator, 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 822 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 967 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 827 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 979 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 681 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("details");
    ol.parseText(title);
    ol.endGroupHeader();
 
    ol.startTextBlock();
    if (!briefDescription().isEmpty() && Config_getBool(REPEAT_BRIEF))
    {
      ol.generateDoc(briefFile(),
                     briefLine(),
                     this,
                     nullptr,
                     briefDescription(),
                     DocOptions());
    }
    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",
                     DocOptions()
                     .setIndexWords(true));
    }
    if (hasRequirementRefs()) writeRequirementRefs(ol);
    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(), OutputList::generateDoc(), hasDetailedDescription(), DefinitionMixin< NamespaceDefMutable >::hasRequirementRefs(), Html, Latex, Man, OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), RTF, OutputList::startGroupHeader(), OutputList::startTextBlock(), title(), OutputList::writeAnchor(), DefinitionMixin< NamespaceDefMutable >::writeRequirementRefs(), OutputList::writeRuler(), and OutputList::writeString().

Referenced by writeDocumentation().

writeDocumentation()

void NamespaceDefImpl::writeDocumentation ( OutputList & ol )

overridevirtual

Implements NamespaceDefMutable.

Definition at line 990 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(),false,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),m_classes);
        }
        break;
      case LayoutDocEntry::NamespaceInterfaces:
        {
          if (ls) writeClassDeclarations(ol,ls->title(lang),m_interfaces);
        }
        break;
      case LayoutDocEntry::NamespaceStructs:
        {
          if (ls) writeClassDeclarations(ol,ls->title(lang),m_structs);
        }
        break;
      case LayoutDocEntry::NamespaceExceptions:
        {
          if (ls) writeClassDeclarations(ol,ls->title(lang),m_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(), Config_getBool, displayName(), OutputList::endContents(), endFileWithNavPath(), endMemberDeclarations(), endMemberDocumentation(), OutputList::endQuickIndices(), endTitle(), err, DefinitionMixin< NamespaceDefMutable >::getLanguage(), getMemberList(), DefinitionMixin< NamespaceDefMutable >::getOuterScope(), getOutputFileBase(), Doxygen::globalScope, LayoutDocManager::instance(), m_classes, m_exceptions, m_interfaces, m_structs, DefinitionMixin< NamespaceDefMutable >::name(), NamespaceVisible, OutputList::parseText(), MemberVector::sort(), OutputList::startContents(), startFile(), startMemberDeclarations(), startMemberDocumentation(), startTitle(), 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 832 of file namespacedef.cpp.

{
  m_classes.writeDocumentation(ol,this);
}

References m_classes.

Referenced by writeDocumentation().

writeMemberDeclarations()

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

private

Definition at line 1530 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 1536 of file namespacedef.cpp.

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

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

Referenced by writeDocumentation().

writeMemberGroups()

void NamespaceDefImpl::writeMemberGroups ( OutputList & ol )

private

Definition at line 843 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 1156 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 837 of file namespacedef.cpp.

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

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

Referenced by writeDocumentation().

writePageNavigation()

void NamespaceDefImpl::writePageNavigation ( OutputList & ol ) const

overridevirtual

Reimplemented from DefinitionMixin< NamespaceDefMutable >.

Definition at line 939 of file namespacedef.cpp.

{
  ol.writePageOutline();
}

References OutputList::writePageOutline().

writeQuickMemberLinks()

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

overridevirtual

Reimplemented from DefinitionMixin< NamespaceDefMutable >.

Definition at line 1171 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("<span class=\"label\"><a ");
          ol.writeString("href=\"");
          if (createSubDirs) ol.writeString("../../");
          ol.writeString(fn+"#"+md->anchor());
          ol.writeString("\">");
          ol.writeString(convertToHtml(md->localName()));
          ol.writeString("</a></span>");
          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 867 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 && m_classes.declVisible() && ls)
    {
      QCString label = "nested-classes";
      ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
      first=FALSE;
    }
    else if (lde->kind()==LayoutDocEntry::NamespaceInterfaces && m_interfaces.declVisible() && ls)
    {
      QCString label = "interfaces";
      ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
      first=FALSE;
    }
    else if (lde->kind()==LayoutDocEntry::NamespaceStructs && m_structs.declVisible() && ls)
    {
      QCString label = "structs";
      ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
      first=FALSE;
    }
    else if (lde->kind()==LayoutDocEntry::NamespaceExceptions && m_exceptions.declVisible() && ls)
    {
      QCString label = "exceptions";
      ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
      first=FALSE;
    }
    else if (lde->kind()==LayoutDocEntry::NamespaceNestedNamespaces && m_namespaces.declVisible(false) && ls)
    {
      QCString label = "namespaces";
      ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
      first=FALSE;
    }
    else if (lde->kind()==LayoutDocEntry::NamespaceNestedConstantGroups && m_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 MemberList::declVisible(), OutputList::disableAllBut(), FALSE, DefinitionMixin< NamespaceDefMutable >::getLanguage(), getMemberList(), Html, LayoutDocManager::instance(), MemberList::listType(), m_classes, m_concepts, m_exceptions, m_interfaces, m_namespaces, m_structs, OutputList::popGeneratorState(), OutputList::pushGeneratorState(), 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 600 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 : m_namespaces)
          {
            if (nd->isLinkableInProject())
            {
              tagFile << "    <namespace>" << convertToXML(nd->name()) << "</namespace>\n";
            }
          }
        }
        break;
      case LayoutDocEntry::NamespaceClasses:
        {
          writeClassesToTagFile(tagFile, m_classes);
        }
        break;
      case LayoutDocEntry::NamespaceInterfaces:
        {
          writeClassesToTagFile(tagFile, m_interfaces);
        }
        break;
      case LayoutDocEntry::NamespaceStructs:
        {
          writeClassesToTagFile(tagFile, m_structs);
        }
        break;
      case LayoutDocEntry::NamespaceExceptions:
        {
          writeClassesToTagFile(tagFile, m_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(), convertToXML(), getMemberList(), getOutputFileBase(), DefinitionMixin< NamespaceDefMutable >::id(), LayoutDocManager::instance(), QCString::isEmpty(), m_classes, m_exceptions, m_interfaces, m_memberGroups, m_namespaces, m_structs, DefinitionMixin< NamespaceDefMutable >::name(), LayoutDocEntryMemberDecl::type, writeClassesToTagFile(), writeConceptsToTagFile(), DefinitionMixin< NamespaceDefMutable >::writeDocAnchorsToTagFile(), and MemberList::writeTagFile().

Member Data Documentation

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().

m_allMembers

MemberLinkedRefMap NamespaceDefImpl::m_allMembers

private

Definition at line 157 of file namespacedef.cpp.

Referenced by getMemberByName(), and insertMember().

m_classes

ClassLinkedRefMap NamespaceDefImpl::m_classes

private

Definition at line 160 of file namespacedef.cpp.

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

m_concepts

ConceptLinkedRefMap NamespaceDefImpl::m_concepts

private

Definition at line 164 of file namespacedef.cpp.

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

m_exceptions

ClassLinkedRefMap NamespaceDefImpl::m_exceptions

private

Definition at line 163 of file namespacedef.cpp.

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

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_interfaces

ClassLinkedRefMap NamespaceDefImpl::m_interfaces

private

Definition at line 161 of file namespacedef.cpp.

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

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(), addRequirementReferences(), 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(), addRequirementReferences(), countMembers(), findSectionsInDocumentation(), getMemberList(), getMemberLists(), insertMember(), sortMemberLists(), and writeMemberPages().

m_namespaces

NamespaceLinkedRefMap NamespaceDefImpl::m_namespaces

private

Definition at line 165 of file namespacedef.cpp.

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

m_structs

ClassLinkedRefMap NamespaceDefImpl::m_structs

private

Definition at line 162 of file namespacedef.cpp.

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

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().

---

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

• src/namespacedef.cpp