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 1273 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 1343 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 1355 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 1603 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 1308 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 1324 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 1658 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 1674 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 1367 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 1666 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 1379 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 1299 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 1533 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 1525 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 1564 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 1277 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 1682 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 1690 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 1642 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 1267 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 1598 of file moduledef.cpp.

{
  return p->moduleFileMap;
}

References p.

modules() [2/2]

const ModuleLinkedMap & ModuleManager::modules

(

)

const

Definition at line 1593 of file moduledef.cpp.

{
  return p->moduleFileMap;
}

References p.

numDocumentedModules()

int ModuleManager::numDocumentedModules

(

)

const

Definition at line 1583 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 1466 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 1433 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 1391 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 1698 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 1572 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