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
ModuleLinkedMap &	modules ()
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 1198 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 1268 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 1280 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 1528 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 {}. 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->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, Entry::endBodyLine, Entry::fileName, QCString::find(), getPrimaryInterface(), Entry::hidden, Entry::id, QCString::isEmpty(), Entry::name, p, 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 1233 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 1249 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 1582 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 1590 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 1292 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 1304 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 1224 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 1458 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 1450 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 1489 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 1202 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 1598 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 1606 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 1566 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 1192 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(), getScopeDefs(), parseInput(), resolveLink(), resolveRef(), sortMemberLists(), LatexGenerator::startIndexSection(), RTFGenerator::startIndexSection(), ModuleDefImpl::writeExports(), writeExports(), FileDefImpl::writeIncludeFiles(), writeModuleIndex(), writeModuleList(), and writeTagFile().

modules() [1/2]

ModuleLinkedMap & ModuleManager::modules

(

)

Definition at line 1523 of file moduledef.cpp.

{
  return p->moduleFileMap;
}

References p.

modules() [2/2]

const ModuleLinkedMap & ModuleManager::modules

(

)

const

Definition at line 1518 of file moduledef.cpp.

{
  return p->moduleFileMap;
}

References p.

numDocumentedModules()

int ModuleManager::numDocumentedModules

(

)

const

Definition at line 1508 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 1391 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 1358 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 1316 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 1614 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 1497 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 147 of file moduledef.h.

Referenced by addClassToModule(), addConceptToModule(), addDocs(), addHeader(), addImport(), addListReferences(), addMembersToMemberGroup(), addMemberToModule(), 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