ModuleManager Class Reference

#include <src/moduledef.h>

Classes
struct	Private

Public Member Functions
void	createModuleDef (const QCString &fileName, int line, int column, bool exported, const QCString &moduleName, const QCString &partitionName=QCString())
void	clear ()
void	addHeader (const QCString &moduleFile, int line, const QCString &headerName, bool isSystem)
void	addImport (const QCString &moduleFile, int line, const QCString &importName, bool isExported, const QCString &partitionName=QCString())
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 QCString &moduleFile, const QCString &tagName, const QCString &clangId)
void	addListReferences ()
void	addMembersToMemberGroup ()
void	distributeMemberGroupDocumentation ()
void	findSectionsInDocumentation ()
void	sortMemberLists ()
void	resolvePartitions ()
void	resolveImports ()
void	collectExportedSymbols ()
void	countMembers ()
void	writeDocumentation (OutputList &ol)
int	numDocumentedModules () const
const ModuleLinkedMap &	modules () const
ModuleDef *	getPrimaryInterface (const QCString &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 1186 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 1256 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 1268 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 1511 of file moduledef.cpp.

{
  AUTO_TRACE("file={} module={}",root->fileName,root->name);
  if (root->doc.isEmpty() && root->brief.isEmpty()) return;
  if (root->name.find(':')!=-1)
  {
    warn(root->fileName,root->startLine,"Ignoring documentation for module partition %s. Please place documentation at the primary module name",
        qPrint(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->addSectionsToDefinition(root->anchors);
        addModuleToGroups(root,mod);
      }
      else
      {
        warn(root->fileName,root->startLine,"Found documentation for module %s but it has no primary interface unit.",qPrint(root->name));
      }
    }
    else
    {
      warn(root->fileName,root->startLine,"Found documentation for unknown module %s.",qPrint(root->name));
    }
  }
}

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

Referenced by findModuleDocumentation().

addHeader()

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

Definition at line 1221 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 QCString &	moduleFile,
		int	line,
		const QCString &	importName,
		bool	isExported,
		const QCString &	partitionName = QCString() )

Definition at line 1237 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.isEmpty()?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, QCString::isEmpty(), p, QCString::str(), and toModuleDefImpl().

addListReferences()

void ModuleManager::addListReferences

(

)

Definition at line 1565 of file moduledef.cpp.

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

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

Referenced by addListReferences().

addMembersToMemberGroup()

void ModuleManager::addMembersToMemberGroup

(

)

Definition at line 1573 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 1280 of file moduledef.cpp.

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

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

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

addTagInfo()

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

Definition at line 1292 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 1212 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 1446 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 1438 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 1477 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 QCString &	fileName,
		int	line,
		int	column,
		bool	exported,
		const QCString &	moduleName,
		const QCString &	partitionName = QCString() )

Definition at line 1190 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 QCString::str().

distributeMemberGroupDocumentation()

void ModuleManager::distributeMemberGroupDocumentation

(

)

Definition at line 1581 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 1589 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 QCString &

moduleName

)

const

Definition at line 1549 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 QCString::str().

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

instance()

ModuleManager & ModuleManager::instance ( )

static

Definition at line 1180 of file moduledef.cpp.

{
  static ModuleManager m;
  return m;
}

References ModuleManager().

Referenced by addClassToContext(), addConceptToContext(), addDefineDoc(), addEnumDocs(), addGlobalFunction(), addInterfaceOrServiceToServiceOrSingleton(), addListReferences(), addMemberDocs(), addMembersToMemberGroup(), addMethodToClass(), addVariableToClass(), addVariableToFile(), 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(), parseInput(), sortMemberLists(), LatexGenerator::startIndexSection(), RTFGenerator::startIndexSection(), ModuleDefImpl::writeExports(), writeExports(), FileDefImpl::writeIncludeFiles(), writeModuleIndex(), writeModuleList(), and writeTagFile().

modules()

const ModuleLinkedMap & ModuleManager::modules

(

)

const

Definition at line 1506 of file moduledef.cpp.

{
  return p->moduleFileMap;
}

References p.

numDocumentedModules()

int ModuleManager::numDocumentedModules

(

)

const

Definition at line 1496 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 1379 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 = findFileDef(Doxygen::inputNameLinkedMap,QCString(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(QCString(fileName)),IncludeKind::ImportModule);
        }
      }
    }
  }
  for (const auto &headerInfo : p->headers)
  {
    bool ambig = false;
    FileDef *fd = findFileDef(Doxygen::inputNameLinkedMap,headerInfo.fileName,ambig);
    AUTO_TRACE_ADD("header name={} fd={}",headerInfo.fileName,(void*)fd);
    if (fd)
    {
      QCString resolvedHeader = determineAbsoluteIncludeName(headerInfo.fileName,headerInfo.headerName);
      FileDef *importFd = findFileDef(Doxygen::inputNameLinkedMap,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(), findFileDef(), ModuleDef::getFileDef(), getPrimaryInterface(), ImportLocal, ImportModule, ImportSystem, Doxygen::inputNameLinkedMap, p, Definition::qualifiedName(), and stripFromPath().

resolvePartitions()

void ModuleManager::resolvePartitions

(

)

Definition at line 1346 of file moduledef.cpp.

{
  AUTO_TRACE();
  for (auto &mod : p->moduleFileMap) // foreach module
  {
    if (mod->moduleType()==ModuleDef::Type::Interface && mod->partitionName().isEmpty())
    { // 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 = findFileDef(Doxygen::inputNameLinkedMap,mod->getDefFileName(),ambig);
    if (fd)
    {
      fd->setModuleDef(mod.get());
      toModuleDefImpl(mod)->setFileDef(fd);
    }
  }
}

References ModuleDefImpl::addExportedModule(), AUTO_TRACE, 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 1304 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.isEmpty() &&
          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, ModuleDef::getImports(), QCString::isEmpty(), Definition::name(), p, resolvePartitionsRecursively(), ModuleDefImpl::setPrimaryInterface(), and toModuleDefImpl().

Referenced by resolvePartitions(), and resolvePartitionsRecursively().

sortMemberLists()

void ModuleManager::sortMemberLists

(

)

Definition at line 1597 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 1485 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 146 of file moduledef.h.

Referenced by addClassToModule(), addConceptToModule(), addDocs(), addHeader(), addImport(), addListReferences(), addMembersToMemberGroup(), addMemberToModule(), addTagInfo(), clear(), collectExportedSymbols(), countMembers(), createModuleDef(), distributeMemberGroupDocumentation(), findSectionsInDocumentation(), getPrimaryInterface(), ModuleManager(), 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