ModuleManager Class Reference

#include <src/moduledef.h>

Classes
struct	Private

Public Member Functions
void	createModuleDef (const DString &fileName, int line, size_t column, bool exported, const DString &moduleName, const DString &partitionName=DString())
void	clear ()
void	addHeader (const DString &moduleFile, int line, const DString &headerName, bool isSystem)
void	addImport (const DString &moduleFile, int line, const DString &importName, bool isExported, const DString &partitionName=DString())
void	addClassToModule (const Entry *root, ClassDef *cd)
void	addConceptToModule (const Entry *root, ConceptDef *cd)
void	addMemberToModule (const Entry *root, MemberDef *md)
void	addDocs (const Entry *root)
void	addTagInfo (const DString &moduleFile, const DString &tagName, const DString &clangId)
void	addListReferences ()
void	addRequirementReferences ()
void	addMembersToMemberGroup ()
void	distributeMemberGroupDocumentation ()
void	findSectionsInDocumentation ()
void	sortMemberLists ()
void	resolvePartitions ()
void	resolveImports ()
void	collectExportedSymbols ()
void	countMembers ()
void	writeDocumentation (OutputList &ol)
int	numDocumentedModules () const
ModuleLinkedMap &	modules ()
const ModuleLinkedMap &	modules () const
ModuleDef *	getPrimaryInterface (const DString &moduleName) const

Static Public Member Functions
static ModuleManager &	instance ()

Private Member Functions
	ModuleManager ()
	~ModuleManager ()=default
void	resolvePartitionsRecursively (ModuleDef *intfMod, ModuleDef *mod)
void	collectExportedSymbolsRecursively (ModuleDef *intfMod, ModuleDef *mod)

Private Attributes
std::unique_ptr< Private >	p

Detailed Description

Definition at line 110 of file moduledef.h.

Constructor & Destructor Documentation

ModuleManager()

ModuleManager::ModuleManager ( )

private

Definition at line 1272 of file moduledef.cpp.

                             : p(std::make_unique<Private>())
{
}

References p.

Referenced by instance(), and ~ModuleManager().

~ModuleManager()

ModuleManager::~ModuleManager ( )

privatedefault

References ModuleManager().

Member Function Documentation

addClassToModule()

void ModuleManager::addClassToModule	(	const Entry *	root,
		ClassDef *	cd )

Definition at line 1342 of file moduledef.cpp.

{
  std::lock_guard lock(p->mutex);
  auto mod = p->moduleFileMap.find(root->fileName);
  if (mod)
  {
    toModuleDefImpl(mod)->addClassToModule(root,cd);
    auto cdm = toClassDefMutable(cd);
    if (cdm) cdm->setModuleDef(mod);
  }
}

References ModuleDefImpl::addClassToModule(), Entry::fileName, p, toClassDefMutable(), and toModuleDefImpl().

Referenced by addClassToContext().

addConceptToModule()

void ModuleManager::addConceptToModule	(	const Entry *	root,
		ConceptDef *	cd )

Definition at line 1354 of file moduledef.cpp.

{
  std::lock_guard lock(p->mutex);
  auto mod = p->moduleFileMap.find(root->fileName);
  if (mod)
  {
    toModuleDefImpl(mod)->addConceptToModule(root,cd);
    auto cdm = toConceptDefMutable(cd);
    if (cdm) cdm->setModuleDef(mod);
  }
}

References ModuleDefImpl::addConceptToModule(), Entry::fileName, p, toConceptDefMutable(), and toModuleDefImpl().

Referenced by addConceptToContext().

addDocs()

void ModuleManager::addDocs

(

const Entry *

root

)

Definition at line 1602 of file moduledef.cpp.

{
  AUTO_TRACE("file={} module={}",root->fileName,root->name);
  if (root->doc.empty() && root->brief.empty()) return;
  if (root->name.find(':')!=DString::npos)
  {
    warn(root->fileName,root->startLine,"Ignoring documentation for module partition {}. Please place documentation at the primary module name",
        root->name);
  }
  else
  {
    auto it = p->moduleNameMap.find(root->name.str());
    if (it != p->moduleNameMap.end())
    {
      ModuleDef *mod = getPrimaryInterface(root->name);
      if (mod)
      {
        mod->setDocumentation(root->doc,root->docFile,root->docLine);
        mod->setBriefDescription(root->brief,root->briefFile,root->briefLine);
        mod->setId(root->id);
        mod->setHidden(root->hidden);
        mod->setBodySegment(root->startLine,root->bodyLine,root->endBodyLine);
        mod->setRefItems(root->sli);
        mod->setRequirementReferences(root->rqli);
        //mod->addSectionsToDefinition(root->anchors);
        addModuleToGroups(root,mod);
      }
      else
      {
        warn(root->fileName,root->startLine,"Found documentation for module {} but it has no primary interface unit.",root->name);
      }
    }
    else
    {
      warn(root->fileName,root->startLine,"Found documentation for unknown module {}.",root->name);
    }
  }
}

References addModuleToGroups(), AUTO_TRACE, Entry::bodyLine, Entry::brief, Entry::briefFile, Entry::briefLine, Entry::doc, Entry::docFile, Entry::docLine, DString::empty(), Entry::endBodyLine, Entry::fileName, DString::find(), getPrimaryInterface(), Entry::hidden, Entry::id, Entry::name, DString::npos, p, Entry::rqli, DefinitionMutable::setBodySegment(), DefinitionMutable::setBriefDescription(), DefinitionMutable::setDocumentation(), DefinitionMutable::setHidden(), DefinitionMutable::setId(), DefinitionMutable::setRefItems(), DefinitionMutable::setRequirementReferences(), Entry::sli, Entry::startLine, DString::str(), and warn.

Referenced by findModuleDocumentation().

addHeader()

void ModuleManager::addHeader	(	const DString &	moduleFile,
		int	line,
		const DString &	headerName,
		bool	isSystem )

Definition at line 1307 of file moduledef.cpp.

{
  AUTO_TRACE("{}:{} headerName={} isSystem={}",moduleFile,line,headerName,isSystem);
  std::lock_guard lock(p->mutex);
  auto mod = p->moduleFileMap.find(moduleFile);
  if (mod)
  {
    toModuleDefImpl(mod)->addHeader(line,headerName,isSystem);
  }
  else
  {
    AUTO_TRACE_ADD("imported header '{}' found in file '{}' that is not a module",headerName,moduleFile);
  }
  p->headers.emplace_back(moduleFile,headerName,isSystem);
}

References ModuleDefImpl::addHeader(), AUTO_TRACE, AUTO_TRACE_ADD, p, and toModuleDefImpl().

addImport()

void ModuleManager::addImport	(	const DString &	moduleFile,
		int	line,
		const DString &	importName,
		bool	isExported,
		const DString &	partitionName = DString() )

Definition at line 1323 of file moduledef.cpp.

{
  AUTO_TRACE("{}:{} importName={},isExported={},partitionName={}",
      moduleFile,line,importName,isExported,partitionName);
  std::lock_guard lock(p->mutex);
  auto mod = p->moduleFileMap.find(moduleFile);
  if (mod) // import inside a module
  {
    AUTO_TRACE_ADD("in module");
    toModuleDefImpl(mod)->addImport(line,importName.empty()?mod->name():importName,partitionName,isExported);
  }
  else // import outside of a module
  {
    AUTO_TRACE_ADD("outside module");
    p->externalImports[moduleFile.str()].emplace_back(nullptr,importName,line,partitionName);
  }
}

References ModuleDefImpl::addImport(), AUTO_TRACE, AUTO_TRACE_ADD, DString::empty(), p, DString::str(), and toModuleDefImpl().

addListReferences()

void ModuleManager::addListReferences

(

)

Definition at line 1657 of file moduledef.cpp.

{
  for (const auto &mod : p->moduleFileMap) // foreach module
  {
    if (mod->isPrimaryInterface()) toModuleDefImpl(mod)->addListReferences();
  }
}

References ModuleDefImpl::addListReferences(), p, and toModuleDefImpl().

addMembersToMemberGroup()

void ModuleManager::addMembersToMemberGroup

(

)

Definition at line 1673 of file moduledef.cpp.

{
  for (const auto &mod : p->moduleFileMap) // foreach module
  {
    if (mod->isPrimaryInterface()) toModuleDefImpl(mod)->addMembersToMemberGroup();
  }
}

References ModuleDefImpl::addMembersToMemberGroup(), p, and toModuleDefImpl().

Referenced by addMembersToMemberGroup().

addMemberToModule()

void ModuleManager::addMemberToModule	(	const Entry *	root,
		MemberDef *	md )

Definition at line 1366 of file moduledef.cpp.

{
  std::lock_guard lock(p->mutex);
  auto mod = p->moduleFileMap.find(root->fileName);
  if (mod && root->exported && md->getClassDef()==nullptr)
  {
    toModuleDefImpl(mod)->addMemberToModule(root,md);
    auto mdm = toMemberDefMutable(md);
    if (mdm) mdm->setModuleDef(mod);
  }
}

References ModuleDefImpl::addMemberToModule(), Entry::exported, Entry::fileName, MemberDef::getClassDef(), p, toMemberDefMutable(), and toModuleDefImpl().

Referenced by addDefineDoc(), addEnumDocs(), addGlobalFunction(), addInterfaceOrServiceToServiceOrSingleton(), addMemberDocs(), addMethodToClass(), addVariableToClass(), addVariableToFile(), buildFunctionList(), findEnums(), and findMember().

addRequirementReferences()

void ModuleManager::addRequirementReferences

(

)

Definition at line 1665 of file moduledef.cpp.

{
  for (const auto &mod : p->moduleFileMap) // foreach module
  {
    if (mod->isPrimaryInterface()) toModuleDefImpl(mod)->addRequirementReferences();
  }
}

References ModuleDefImpl::addRequirementReferences(), p, and toModuleDefImpl().

addTagInfo()

void ModuleManager::addTagInfo	(	const DString &	moduleFile,
		const DString &	tagName,
		const DString &	clangId )

Definition at line 1378 of file moduledef.cpp.

{
  std::lock_guard lock(p->mutex);
  auto mod = p->moduleFileMap.find(fileName);
  if (mod)
  {
    ModuleDefImpl *modi = toModuleDefImpl(mod);
    modi->setReference(tagFile);
    modi->setId(clangId);
  }
}

References p, DefinitionMixin< Base >::setId(), DefinitionMixin< Base >::setReference(), and toModuleDefImpl().

clear()

void ModuleManager::clear

(

)

Definition at line 1298 of file moduledef.cpp.

{
  std::lock_guard lock(p->mutex);
  p->headers.clear();
  p->externalImports.clear();
  p->moduleNameMap.clear();
  p->moduleFileMap.clear();
}

References p.

Referenced by cleanUpDoxygen().

collectExportedSymbols()

void ModuleManager::collectExportedSymbols

(

)

Definition at line 1532 of file moduledef.cpp.

{
  AUTO_TRACE();
  for (auto &mod : p->moduleFileMap) // foreach module
  {
    if (mod->isPrimaryInterface()) // that is a primary interface
    {
      for (auto &[partitionName,partitionMod] : mod->partitions())
      {
        collectExportedSymbolsRecursively(mod.get(),partitionMod);
      }
 
      // collect all files that contribute to this module (e.g. implementation/partition modules)
      auto it = p->moduleNameMap.find(mod->name().str());
      if (it != p->moduleNameMap.end())
      {
        for (auto contributingMod : it->second)
        {
          AUTO_TRACE_ADD("  adding contributing module {} to interface module {} type={} partition={} isPrimaryIntf={}",
              contributingMod->qualifiedName(),
              mod->name(),
              contributingMod->moduleType()==ModuleDef::Type::Interface ? "Interface" : "Implementation",
              contributingMod->partitionName(),
              contributingMod->isPrimaryInterface());
          toModuleDefImpl(mod)->addContributingModule(toModuleDefImpl(contributingMod));
        }
      }
    }
  }
}

References ModuleDefImpl::addContributingModule(), AUTO_TRACE, AUTO_TRACE_ADD, collectExportedSymbolsRecursively(), ModuleDef::Interface, p, and toModuleDefImpl().

collectExportedSymbolsRecursively()

void ModuleManager::collectExportedSymbolsRecursively ( ModuleDef * intfMod, ModuleDef * mod )

private

Definition at line 1524 of file moduledef.cpp.

{
  AUTO_TRACE("{}: collecting symbols for partition {}",intfMod->qualifiedName(),partitionMod->qualifiedName());
  auto intfModImpl      = toModuleDefImpl(intfMod);
  auto partitionModImpl = toModuleDefImpl(partitionMod);
  intfModImpl->mergeSymbolsFrom(partitionModImpl);
}

References AUTO_TRACE, Definition::qualifiedName(), and toModuleDefImpl().

Referenced by collectExportedSymbols().

countMembers()

void ModuleManager::countMembers

(

)

Definition at line 1563 of file moduledef.cpp.

{
  for (auto &mod : p->moduleFileMap) // foreach module
  {
    toModuleDefImpl(mod)->countMembers();
  }
}

References ModuleDefImpl::countMembers(), p, and toModuleDefImpl().

createModuleDef()

void ModuleManager::createModuleDef	(	const DString &	fileName,
		int	line,
		size_t	column,
		bool	exported,
		const DString &	moduleName,
		const DString &	partitionName = DString() )

Definition at line 1276 of file moduledef.cpp.

{
  AUTO_TRACE("{}:{}: Found module name='{}' partition='{}' exported='{}'",
      fileName,line,moduleName,partitionName,exported);
  std::lock_guard lock(p->mutex);
  ModuleDef::Type mt = exported ? ModuleDef::Type::Interface : ModuleDef::Type::Implementation;
  std::unique_ptr<ModuleDef> modDef = std::make_unique<ModuleDefImpl>(fileName,line,column,moduleName,mt,partitionName);
  auto mod = p->moduleFileMap.add(fileName,std::move(modDef));
  auto it = p->moduleNameMap.find(moduleName.str());
  if (it == p->moduleNameMap.end())
  {
    ModuleList ml;
    ml.push_back(mod);
    p->moduleNameMap.emplace(moduleName.str(),ml);
  }
  else
  {
    it->second.push_back(mod);
  }
}

References AUTO_TRACE, ModuleDef::Implementation, ModuleDef::Interface, p, and DString::str().

distributeMemberGroupDocumentation()

void ModuleManager::distributeMemberGroupDocumentation

(

)

Definition at line 1681 of file moduledef.cpp.

{
  for (const auto &mod : p->moduleFileMap) // foreach module
  {
    if (mod->isPrimaryInterface()) toModuleDefImpl(mod)->distributeMemberGroupDocumentation();
  }
}

References ModuleDefImpl::distributeMemberGroupDocumentation(), p, and toModuleDefImpl().

Referenced by distributeMemberGroupDocumentation().

findSectionsInDocumentation()

void ModuleManager::findSectionsInDocumentation

(

)

Definition at line 1689 of file moduledef.cpp.

{
  for (auto &mod : p->moduleFileMap) // foreach module
  {
    if (mod->isPrimaryInterface()) toModuleDefImpl(mod)->findSectionsInDocumentation();
  }
}

References ModuleDefImpl::findSectionsInDocumentation(), p, and toModuleDefImpl().

Referenced by findSectionsInDocumentation().

getPrimaryInterface()

ModuleDef * ModuleManager::getPrimaryInterface

(

const DString &

moduleName

)

const

Definition at line 1641 of file moduledef.cpp.

{
  auto it = p->moduleNameMap.find(moduleName.str());
  if (it != p->moduleNameMap.end())
  {
    for (const auto &mod : it->second)
    {
      if (mod->isPrimaryInterface())
      {
        return mod;
      }
    }
  }
  return nullptr;
}

References p, and DString::str().

Referenced by addDocs(), resolveImports(), ModuleDefImpl::writeExports(), writeExports(), and FileDefImpl::writeIncludeFiles().

instance()

ModuleManager & ModuleManager::instance ( )

static

Definition at line 1266 of file moduledef.cpp.

{
  static ModuleManager m;
  return m;
}

References ModuleManager().

Referenced by addClassToContext(), addConceptToContext(), addDefineDoc(), addEnumDocs(), addGlobalFunction(), addInterfaceOrServiceToServiceOrSingleton(), addMemberDocs(), addMembersToMemberGroup(), addMethodToClass(), addVariableToClass(), addVariableToFile(), applyToAllDefinitions(), buildFunctionList(), anonymous_namespace{tagreader.cpp}::TagFileParser::buildLists(), cleanUpDoxygen(), Index::countDataStructures(), countMembers(), createJavaScriptSearchIndex(), distributeMemberGroupDocumentation(), DocbookGenerator::endIndexSection(), LatexGenerator::endIndexSection(), RTFGenerator::endIndexSection(), findEnums(), findMember(), findModuleDocumentation(), findSectionsInDocumentation(), generateOutput(), PerlModGenerator::generatePerlModOutput(), generateSqlite3(), generateXML(), getScopeDefs(), parseInput(), resolveLink(), resolveRef(), sortMemberLists(), LatexGenerator::startIndexSection(), RTFGenerator::startIndexSection(), ModuleDefImpl::writeExports(), writeExports(), FileDefImpl::writeIncludeFiles(), writeModuleIndex(), and writeTagFile().

modules() [1/2]

ModuleLinkedMap & ModuleManager::modules

(

)

Definition at line 1597 of file moduledef.cpp.

{
  return p->moduleFileMap;
}

References p.

modules() [2/2]

const ModuleLinkedMap & ModuleManager::modules

(

)

const

Definition at line 1592 of file moduledef.cpp.

{
  return p->moduleFileMap;
}

References p.

numDocumentedModules()

int ModuleManager::numDocumentedModules

(

)

const

Definition at line 1582 of file moduledef.cpp.

{
  int count=0;
  for (const auto &mod : p->moduleFileMap) // foreach module
  {
    if (mod->isPrimaryInterface()) count++;
  }
  return count;
}

References p.

Referenced by Index::countDataStructures().

resolveImports()

void ModuleManager::resolveImports

(

)

Definition at line 1465 of file moduledef.cpp.

{
  AUTO_TRACE();
  for (auto &mod : p->moduleFileMap)
  {
    FileDef *fd = mod->getFileDef();
    if (fd)
    {
      for (const auto &[fileName,importInfoList] : mod->getImports())
      {
        for (const auto &importInfo : importInfoList)
        {
          ModuleDef *importedModule = getPrimaryInterface(importInfo.importName);
          const FileDef *importedFd = importedModule ? importedModule->getFileDef() : nullptr;
          AUTO_TRACE_ADD("module: addIncludeDependency {}->{}:{} fd={}",
              mod->qualifiedName(), importInfo.qualifiedName(), importInfo.line, fd?fd->absFilePath():"");
          fd->addIncludeDependency(importedFd,importInfo.qualifiedName(),IncludeKind::ImportModule);
        }
      }
    }
  }
  for (const auto &[fileName,importInfoList] : p->externalImports)
  {
    for (const auto &importInfo : importInfoList)
    {
      bool ambig = false;
      FileDef *fd = Doxygen::inputNameLinkedMap->findFileDef(fileName,ambig);
      AUTO_TRACE_ADD("externalImport name={} fd={}",fileName,(void*)fd);
      if (fd)
      {
        ModuleDef *mod = getPrimaryInterface(importInfo.importName);
        FileDef *importedFd = mod ? mod->getFileDef() : nullptr;
        fd->addIncludeDependency(importedFd,importInfo.importName,IncludeKind::ImportModule);
        if (importedFd)
        {
          importedFd->addIncludedByDependency(fd,stripFromPath(fileName),IncludeKind::ImportModule);
        }
      }
    }
  }
  for (const auto &headerInfo : p->headers)
  {
    bool ambig = false;
    FileDef *fd = Doxygen::inputNameLinkedMap->findFileDef(headerInfo.fileName,ambig);
    AUTO_TRACE_ADD("header name={} fd={}",headerInfo.fileName,(void*)fd);
    if (fd)
    {
      DString resolvedHeader = determineAbsoluteIncludeName(headerInfo.fileName,headerInfo.headerName);
      FileDef *importFd = Doxygen::inputNameLinkedMap->findFileDef(resolvedHeader,ambig);
      fd->addIncludeDependency(importFd, headerInfo.headerName,
                               headerInfo.isSystem ? IncludeKind::ImportSystem : IncludeKind::ImportLocal);
      if (importFd)
      {
        importFd->addIncludedByDependency(fd,headerInfo.fileName,IncludeKind::ImportModule);
      }
    }
  }
}

References FileDef::absFilePath(), FileDef::addIncludedByDependency(), FileDef::addIncludeDependency(), AUTO_TRACE, AUTO_TRACE_ADD, determineAbsoluteIncludeName(), FileDef::fileName(), FileNameLinkedMap::findFileDef(), ModuleDef::getFileDef(), getPrimaryInterface(), ImportLocal, ImportModule, ImportSystem, Doxygen::inputNameLinkedMap, p, Definition::qualifiedName(), and stripFromPath().

resolvePartitions()

void ModuleManager::resolvePartitions

(

)

Definition at line 1432 of file moduledef.cpp.

{
  AUTO_TRACE();
  for (auto &mod : p->moduleFileMap) // foreach module
  {
    if (mod->moduleType()==ModuleDef::Type::Interface && mod->partitionName().empty())
    { // that is a primary interface
      resolvePartitionsRecursively(mod.get(),mod.get());
    }
 
    // copy exported imports to m_exportedModules
    for (const auto &[fileName,importInfoList] : mod->getImports())
    {
      for (const auto &importInfo : importInfoList)
      {
        if (importInfo.exported && mod->name()!=importInfo.importName)
        {
          toModuleDefImpl(mod)->addExportedModule(importInfo.importName,importInfo);
        }
      }
    }
 
    // also link the ModuleDef and FileDef together
    bool ambig = false;
    FileDef *fd = Doxygen::inputNameLinkedMap->findFileDef(mod->getDefFileName(),ambig);
    if (fd)
    {
      fd->setModuleDef(mod.get());
      toModuleDefImpl(mod)->setFileDef(fd);
    }
  }
}

References ModuleDefImpl::addExportedModule(), AUTO_TRACE, FileNameLinkedMap::findFileDef(), Doxygen::inputNameLinkedMap, ModuleDef::Interface, p, resolvePartitionsRecursively(), ModuleDefImpl::setFileDef(), FileDef::setModuleDef(), and toModuleDefImpl().

resolvePartitionsRecursively()

void ModuleManager::resolvePartitionsRecursively ( ModuleDef * intfMod, ModuleDef * mod )

private

Definition at line 1390 of file moduledef.cpp.

{
  AUTO_TRACE();
  for (auto &[partitionFileName,importInfoList] : mod->getImports()) // foreach import
  {
    for (auto &importInfo : importInfoList)
    {
      AUTO_TRACE_ADD("partitionFileName={} importName={} partitionName={}",
          partitionFileName,importInfo.importName,importInfo.partitionName);
      if (importInfo.importName==intfMod->name() && !importInfo.partitionName.empty() &&
          importInfo.exported) // that is an exported partition of this module
      {
        auto it = p->moduleNameMap.find(importInfo.importName.str());
        if (it != p->moduleNameMap.end())
        {
          for (auto importedMod : it->second)
          {
            if (importedMod->qualifiedName()==importInfo.importName+":"+importInfo.partitionName)
            {
              AUTO_TRACE_ADD("Interface module {} exports partition {}:{}",
                  mod->name(),importedMod->name(),importedMod->partitionName());
              toModuleDefImpl(intfMod)->addPartition(toModuleDefImpl(importedMod));
              toModuleDefImpl(importedMod)->setPrimaryInterface(intfMod);
              for (const auto &[partitionFileName_,partitionImportInfoList] : importedMod->getImports())
              {
                for (const auto &partitionImportInfo : partitionImportInfoList)
                {
                  if (partitionImportInfo.exported && intfMod->name()!=partitionImportInfo.importName)
                  {
                    toModuleDefImpl(intfMod)->addExportedModule(partitionImportInfo.importName,partitionImportInfo);
                  }
                }
              }
              resolvePartitionsRecursively(intfMod,importedMod);
            }
          }
        }
      }
    }
  }
}

References ModuleDefImpl::addExportedModule(), ModuleDefImpl::addPartition(), AUTO_TRACE, AUTO_TRACE_ADD, DString::empty(), ModuleDef::getImports(), Definition::name(), p, resolvePartitionsRecursively(), ModuleDefImpl::setPrimaryInterface(), and toModuleDefImpl().

Referenced by resolvePartitions(), and resolvePartitionsRecursively().

sortMemberLists()

void ModuleManager::sortMemberLists

(

)

Definition at line 1697 of file moduledef.cpp.

{
  for (auto &mod : p->moduleFileMap) // foreach module
  {
    if (mod->isPrimaryInterface()) toModuleDefImpl(mod)->sortMemberLists();
  }
}

References p, ModuleDefImpl::sortMemberLists(), and toModuleDefImpl().

Referenced by sortMemberLists().

writeDocumentation()

void ModuleManager::writeDocumentation

(

OutputList &

ol

)

Definition at line 1571 of file moduledef.cpp.

{
  for (auto &mod : p->moduleFileMap) // foreach module
  {
    if (mod->isPrimaryInterface())
    {
      mod->writeDocumentation(ol);
    }
  }
}

References p.

Referenced by generateOutput().

Member Data Documentation

p

std::unique_ptr<Private> ModuleManager::p

private

Definition at line 148 of file moduledef.h.

Referenced by addClassToModule(), addConceptToModule(), addDocs(), addHeader(), addImport(), addListReferences(), addMembersToMemberGroup(), addMemberToModule(), addRequirementReferences(), addTagInfo(), clear(), collectExportedSymbols(), countMembers(), createModuleDef(), distributeMemberGroupDocumentation(), findSectionsInDocumentation(), getPrimaryInterface(), ModuleManager(), modules(), modules(), numDocumentedModules(), resolveImports(), resolvePartitions(), resolvePartitionsRecursively(), sortMemberLists(), and writeDocumentation().

---

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

• src/moduledef.h
• src/moduledef.cpp