The ModuleManager Class Reference

Declaration

class ModuleManager { ... }

Included Headers

#include <src/moduledef.h>

Private Constructors Index

	ModuleManager ()

Private Destructor Index

	~ModuleManager ()=default

Public Member Functions Index

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

Private Member Functions Index

void	resolvePartitionsRecursively (ModuleDef *intfMod, ModuleDef *mod)
void	collectExportedSymbolsRecursively (ModuleDef *intfMod, ModuleDef *mod)

Private Member Attributes Index

std::unique_ptr< Private >	p

Public Static Functions Index

static ModuleManager &	instance ()

Definition at line 110 of file moduledef.h.

Private Constructors

ModuleManager()

ModuleManager::ModuleManager ()

Declaration at line 141 of file moduledef.h, definition at line 1221 of file moduledef.cpp.

1221ModuleManager::ModuleManager() : p(std::make_unique<Private>())

1222{

1223}

Reference p.

Referenced by instance and ~ModuleManager.

Private Destructor

~ModuleManager()

ModuleManager::~ModuleManager ()

default

Definition at line 142 of file moduledef.h.

Reference ModuleManager.

Public Member Functions

addClassToModule()

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

Declaration at line 119 of file moduledef.h, definition at line 1291 of file moduledef.cpp.

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

1292{

1293 std::lock_guard lock(p->mutex);

1294 auto mod = p->moduleFileMap.find(root->fileName);

1295 if (mod)

1296 {

1297 toModuleDefImpl(mod)->addClassToModule(root,cd);

1298 auto cdm = toClassDefMutable(cd);

1299 if (cdm) cdm->setModuleDef(mod);

1300 }

1301}

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

Referenced by addClassToContext.

addConceptToModule()

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

Declaration at line 120 of file moduledef.h, definition at line 1303 of file moduledef.cpp.

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

1304{

1305 std::lock_guard lock(p->mutex);

1306 auto mod = p->moduleFileMap.find(root->fileName);

1307 if (mod)

1308 {

1309 toModuleDefImpl(mod)->addConceptToModule(root,cd);

1310 auto cdm = toConceptDefMutable(cd);

1311 if (cdm) cdm->setModuleDef(mod);

1312 }

1313}

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

Referenced by addConceptToContext.

addDocs()

void ModuleManager::addDocs (const Entry * root)

Declaration at line 122 of file moduledef.h, definition at line 1551 of file moduledef.cpp.

1551void ModuleManager::addDocs(const Entry *root)

1552{

1553 AUTO_TRACE("file={} module={}",root->fileName,root->name);

1554 if (root->doc.isEmpty() && root->brief.isEmpty()) return;

1555 if (root->name.find(':')!=-1)

1556 {

1557 warn(root->fileName,root->startLine,"Ignoring documentation for module partition {}. Please place documentation at the primary module name",

1558 root->name);

1559 }

1560 else

1561 {

1562 auto it = p->moduleNameMap.find(root->name.str());

1563 if (it != p->moduleNameMap.end())

1564 {

1565 ModuleDef *mod = getPrimaryInterface(root->name);

1566 if (mod)

1567 {

1568 mod->setDocumentation(root->doc,root->docFile,root->docLine);

1569 mod->setBriefDescription(root->brief,root->briefFile,root->briefLine);

1570 mod->setId(root->id);

1571 mod->setHidden(root->hidden);

1572 mod->setBodySegment(root->startLine,root->bodyLine,root->endBodyLine);

1573 mod->setRefItems(root->sli);

1574 //mod->addSectionsToDefinition(root->anchors);

1575 addModuleToGroups(root,mod);

1576 }

1577 else

1578 {

1579 warn(root->fileName,root->startLine,"Found documentation for module {} but it has no primary interface unit.",root->name);

1580 }

1581 }

1582 else

1583 {

1584 warn(root->fileName,root->startLine,"Found documentation for unknown module {}.",root->name);

1585 }

1586 }

1587}

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)

Declaration at line 117 of file moduledef.h, definition at line 1256 of file moduledef.cpp.

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

1257{

1258 AUTO_TRACE("{}:{} headerName={} isSystem={}",moduleFile,line,headerName,isSystem);

1259 std::lock_guard lock(p->mutex);

1260 auto mod = p->moduleFileMap.find(moduleFile);

1261 if (mod)

1262 {

1263 toModuleDefImpl(mod)->addHeader(line,headerName,isSystem);

1264 }

1265 else

1266 {

1267 AUTO_TRACE_ADD("imported header '{}' found in file '{}' that is not a module",headerName,moduleFile);

1268 }

1269 p->headers.emplace_back(moduleFile,headerName,isSystem);

1270}

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

Declaration at line 118 of file moduledef.h, definition at line 1272 of file moduledef.cpp.

1272void ModuleManager::addImport(const QCString &moduleFile,int line,const QCString &importName,

1273 bool isExported,const QCString &partitionName)

1274{

1275 AUTO_TRACE("{}:{} importName={},isExported={},partitionName={}",

1276 moduleFile,line,importName,isExported,partitionName);

1277 std::lock_guard lock(p->mutex);

1278 auto mod = p->moduleFileMap.find(moduleFile);

1279 if (mod) // import inside a module

1280 {

1281 AUTO_TRACE_ADD("in module");

1282 toModuleDefImpl(mod)->addImport(line,importName.isEmpty()?mod->name():importName,partitionName,isExported);

1283 }

1284 else // import outside of a module

1285 {

1286 AUTO_TRACE_ADD("outside module");

1287 p->externalImports[moduleFile.str()].emplace_back(nullptr,importName,line,partitionName);

1288 }

1289}

References ModuleDefImpl::addImport, AUTO_TRACE, AUTO_TRACE_ADD, QCString::isEmpty, p, QCString::str and toModuleDefImpl.

addListReferences()

void ModuleManager::addListReferences ()

Declaration at line 124 of file moduledef.h, definition at line 1605 of file moduledef.cpp.

1605void ModuleManager::addListReferences()

1606{

1607 for (const auto &mod : p->moduleFileMap) // foreach module

1608 {

1609 if (mod->isPrimaryInterface()) toModuleDefImpl(mod)->addListReferences();

1610 }

1611}

References ModuleDefImpl::addListReferences, p and toModuleDefImpl.

Referenced by addListReferences.

addMembersToMemberGroup()

void ModuleManager::addMembersToMemberGroup ()

Declaration at line 125 of file moduledef.h, definition at line 1613 of file moduledef.cpp.

1613void ModuleManager::addMembersToMemberGroup()

1614{

1615 for (const auto &mod : p->moduleFileMap) // foreach module

1616 {

1617 if (mod->isPrimaryInterface()) toModuleDefImpl(mod)->addMembersToMemberGroup();

1618 }

1619}

References ModuleDefImpl::addMembersToMemberGroup, p and toModuleDefImpl.

Referenced by addMembersToMemberGroup.

addMemberToModule()

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

Declaration at line 121 of file moduledef.h, definition at line 1315 of file moduledef.cpp.

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

1316{

1317 std::lock_guard lock(p->mutex);

1318 auto mod = p->moduleFileMap.find(root->fileName);

1319 if (mod && root->exported)

1320 {

1321 toModuleDefImpl(mod)->addMemberToModule(root,md);

1322 auto mdm = toMemberDefMutable(md);

1323 if (mdm) mdm->setModuleDef(mod);

1324 }

1325}

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)

Declaration at line 123 of file moduledef.h, definition at line 1327 of file moduledef.cpp.

1327void ModuleManager::addTagInfo(const QCString &fileName,const QCString &tagFile,const QCString &clangId)

1328{

1329 std::lock_guard lock(p->mutex);

1330 auto mod = p->moduleFileMap.find(fileName);

1331 if (mod)

1332 {

1333 ModuleDefImpl *modi = toModuleDefImpl(mod);

1334 modi->setReference(tagFile);

1335 modi->setId(clangId);

1336 }

1337}

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

clear()

void ModuleManager::clear ()

Declaration at line 116 of file moduledef.h, definition at line 1247 of file moduledef.cpp.

1247void ModuleManager::clear()

1248{

1249 std::lock_guard lock(p->mutex);

1250 p->headers.clear();

1251 p->externalImports.clear();

1252 p->moduleNameMap.clear();

1253 p->moduleFileMap.clear();

1254}

Reference p.

Referenced by cleanUpDoxygen.

collectExportedSymbols()

void ModuleManager::collectExportedSymbols ()

Declaration at line 132 of file moduledef.h, definition at line 1481 of file moduledef.cpp.

1481void ModuleManager::collectExportedSymbols()

1482{

1483 AUTO_TRACE();

1484 for (auto &mod : p->moduleFileMap) // foreach module

1485 {

1486 if (mod->isPrimaryInterface()) // that is a primary interface

1487 {

1488 for (auto &[partitionName,partitionMod] : mod->partitions())

1489 {

1490 collectExportedSymbolsRecursively(mod.get(),partitionMod);

1491 }

1492

1493 // collect all files that contribute to this module (e.g. implementation/partition modules)

1494 auto it = p->moduleNameMap.find(mod->name().str());

1495 if (it != p->moduleNameMap.end())

1496 {

1497 for (auto contributingMod : it->second)

1498 {

1499 AUTO_TRACE_ADD(" adding contributing module {} to interface module {} type={} partition={} isPrimaryIntf={}",

1500 contributingMod->qualifiedName(),

1501 mod->name(),

1502 contributingMod->moduleType()==ModuleDef::Type::Interface ? "Interface" : "Implementation",

1503 contributingMod->partitionName(),

1504 contributingMod->isPrimaryInterface());

1505 toModuleDefImpl(mod)->addContributingModule(toModuleDefImpl(contributingMod));

1506 }

1507 }

1508 }

1509 }

1510}

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

countMembers()

void ModuleManager::countMembers ()

Declaration at line 133 of file moduledef.h, definition at line 1512 of file moduledef.cpp.

1512void ModuleManager::countMembers()

1513{

1514 for (auto &mod : p->moduleFileMap) // foreach module

1515 {

1516 toModuleDefImpl(mod)->countMembers();

1517 }

1518}

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

Declaration at line 114 of file moduledef.h, definition at line 1225 of file moduledef.cpp.

1225void ModuleManager::createModuleDef(const QCString &fileName,int line,int column,bool exported,

1226 const QCString &moduleName,const QCString &partitionName)

1227{

1228 AUTO_TRACE("{}:{}: Found module name='{}' partition='{}' exported='{}'",

1229 fileName,line,moduleName,partitionName,exported);

1230 std::lock_guard lock(p->mutex);

1231 ModuleDef::Type mt = exported ? ModuleDef::Type::Interface : ModuleDef::Type::Implementation;

1232 std::unique_ptr<ModuleDef> modDef = std::make_unique<ModuleDefImpl>(fileName,line,column,moduleName,mt,partitionName);

1233 auto mod = p->moduleFileMap.add(fileName,std::move(modDef));

1234 auto it = p->moduleNameMap.find(moduleName.str());

1235 if (it == p->moduleNameMap.end())

1236 {

1237 ModuleList ml;

1238 ml.push_back(mod);

1239 p->moduleNameMap.emplace(moduleName.str(),ml);

1240 }

1241 else

1242 {

1243 it->second.push_back(mod);

1244 }

1245}

References AUTO_TRACE, ModuleDef::Implementation, ModuleDef::Interface, p and QCString::str.

distributeMemberGroupDocumentation()

void ModuleManager::distributeMemberGroupDocumentation ()

Declaration at line 126 of file moduledef.h, definition at line 1621 of file moduledef.cpp.

1621void ModuleManager::distributeMemberGroupDocumentation()

1622{

1623 for (const auto &mod : p->moduleFileMap) // foreach module

1624 {

1625 if (mod->isPrimaryInterface()) toModuleDefImpl(mod)->distributeMemberGroupDocumentation();

1626 }

1627}

References ModuleDefImpl::distributeMemberGroupDocumentation, p and toModuleDefImpl.

Referenced by distributeMemberGroupDocumentation.

findSectionsInDocumentation()

void ModuleManager::findSectionsInDocumentation ()

Declaration at line 127 of file moduledef.h, definition at line 1629 of file moduledef.cpp.

1629void ModuleManager::findSectionsInDocumentation()

1630{

1631 for (auto &mod : p->moduleFileMap) // foreach module

1632 {

1633 if (mod->isPrimaryInterface()) toModuleDefImpl(mod)->findSectionsInDocumentation();

1634 }

1635}

References ModuleDefImpl::findSectionsInDocumentation, p and toModuleDefImpl.

Referenced by findSectionsInDocumentation.

getPrimaryInterface()

ModuleDef * ModuleManager::getPrimaryInterface (const QCString & moduleName)

Declaration at line 138 of file moduledef.h, definition at line 1589 of file moduledef.cpp.

1589ModuleDef *ModuleManager::getPrimaryInterface(const QCString &moduleName) const

1590{

1591 auto it = p->moduleNameMap.find(moduleName.str());

1592 if (it != p->moduleNameMap.end())

1593 {

1594 for (const auto &mod : it->second)

1595 {

1596 if (mod->isPrimaryInterface())

1597 {

1598 return mod;

1599 }

1600 }

1601 }

1602 return nullptr;

1603}

References p and QCString::str.

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

modules()

ModuleLinkedMap & ModuleManager::modules ()

Declaration at line 136 of file moduledef.h, definition at line 1546 of file moduledef.cpp.

1546ModuleLinkedMap &ModuleManager::modules()

1547{

1548 return p->moduleFileMap;

1549}

Reference p.

modules()

const ModuleLinkedMap & ModuleManager::modules ()

Declaration at line 137 of file moduledef.h, definition at line 1541 of file moduledef.cpp.

1541const ModuleLinkedMap &ModuleManager::modules() const

1542{

1543 return p->moduleFileMap;

1544}

Reference p.

numDocumentedModules()

int ModuleManager::numDocumentedModules ()

Declaration at line 135 of file moduledef.h, definition at line 1531 of file moduledef.cpp.

1531int ModuleManager::numDocumentedModules() const

1532{

1533 int count=0;

1534 for (const auto &mod : p->moduleFileMap) // foreach module

1535 {

1536 if (mod->isPrimaryInterface()) count++;

1537 }

1538 return count;

1539}

Reference p.

Referenced by Index::countDataStructures.

resolveImports()

void ModuleManager::resolveImports ()

Declaration at line 131 of file moduledef.h, definition at line 1414 of file moduledef.cpp.

1414void ModuleManager::resolveImports()

1415{

1416 AUTO_TRACE();

1417 for (auto &mod : p->moduleFileMap)

1418 {

1419 FileDef *fd = mod->getFileDef();

1420 if (fd)

1421 {

1422 for (const auto &[fileName,importInfoList] : mod->getImports())

1423 {

1424 for (const auto &importInfo : importInfoList)

1425 {

1426 ModuleDef *importedModule = getPrimaryInterface(importInfo.importName);

1427 const FileDef *importedFd = importedModule ? importedModule->getFileDef() : nullptr;

1428 AUTO_TRACE_ADD("module: addIncludeDependency {}->{}:{} fd={}",

1429 mod->qualifiedName(), importInfo.qualifiedName(), importInfo.line, fd?fd->absFilePath():"");

1430 fd->addIncludeDependency(importedFd,importInfo.qualifiedName(),IncludeKind::ImportModule);

1431 }

1432 }

1433 }

1434 }

1435 for (const auto &[fileName,importInfoList] : p->externalImports)

1436 {

1437 for (const auto &importInfo : importInfoList)

1438 {

1439 bool ambig = false;

1440 FileDef *fd = findFileDef(Doxygen::inputNameLinkedMap,QCString(fileName),ambig);

1441 AUTO_TRACE_ADD("externalImport name={} fd={}",fileName,(void*)fd);

1442 if (fd)

1443 {

1444 ModuleDef *mod = getPrimaryInterface(importInfo.importName);

1445 FileDef *importedFd = mod ? mod->getFileDef() : nullptr;

1446 fd->addIncludeDependency(importedFd,importInfo.importName,IncludeKind::ImportModule);

1447 if (importedFd)

1448 {

1449 importedFd->addIncludedByDependency(fd,stripFromPath(QCString(fileName)),IncludeKind::ImportModule);

1450 }

1451 }

1452 }

1453 }

1454 for (const auto &headerInfo : p->headers)

1455 {

1456 bool ambig = false;

1457 FileDef *fd = findFileDef(Doxygen::inputNameLinkedMap,headerInfo.fileName,ambig);

1458 AUTO_TRACE_ADD("header name={} fd={}",headerInfo.fileName,(void*)fd);

1459 if (fd)

1460 {

1461 QCString resolvedHeader = determineAbsoluteIncludeName(headerInfo.fileName,headerInfo.headerName);

1462 FileDef *importFd = findFileDef(Doxygen::inputNameLinkedMap,resolvedHeader,ambig);

1463 fd->addIncludeDependency(importFd, headerInfo.headerName,

1464 headerInfo.isSystem ? IncludeKind::ImportSystem : IncludeKind::ImportLocal);

1465 if (importFd)

1466 {

1467 importFd->addIncludedByDependency(fd,headerInfo.fileName,IncludeKind::ImportModule);

1468 }

1469 }

1470 }

1471}

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

Declaration at line 130 of file moduledef.h, definition at line 1381 of file moduledef.cpp.

1381void ModuleManager::resolvePartitions()

1382{

1383 AUTO_TRACE();

1384 for (auto &mod : p->moduleFileMap) // foreach module

1385 {

1386 if (mod->moduleType()==ModuleDef::Type::Interface && mod->partitionName().isEmpty())

1387 { // that is a primary interface

1388 resolvePartitionsRecursively(mod.get(),mod.get());

1389 }

1390

1391 // copy exported imports to m_exportedModules

1392 for (const auto &[fileName,importInfoList] : mod->getImports())

1393 {

1394 for (const auto &importInfo : importInfoList)

1395 {

1396 if (importInfo.exported && mod->name()!=importInfo.importName)

1397 {

1398 toModuleDefImpl(mod)->addExportedModule(importInfo.importName,importInfo);

1399 }

1400 }

1401 }

1402

1403 // also link the ModuleDef and FileDef together

1404 bool ambig = false;

1405 FileDef *fd = findFileDef(Doxygen::inputNameLinkedMap,mod->getDefFileName(),ambig);

1406 if (fd)

1407 {

1408 fd->setModuleDef(mod.get());

1409 toModuleDefImpl(mod)->setFileDef(fd);

1410 }

1411 }

1412}

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

sortMemberLists()

void ModuleManager::sortMemberLists ()

Declaration at line 128 of file moduledef.h, definition at line 1637 of file moduledef.cpp.

1637void ModuleManager::sortMemberLists()

1638{

1639 for (auto &mod : p->moduleFileMap) // foreach module

1640 {

1641 if (mod->isPrimaryInterface()) toModuleDefImpl(mod)->sortMemberLists();

1642 }

1643}

References p, ModuleDefImpl::sortMemberLists and toModuleDefImpl.

Referenced by sortMemberLists.

writeDocumentation()

void ModuleManager::writeDocumentation (OutputList & ol)

Declaration at line 134 of file moduledef.h, definition at line 1520 of file moduledef.cpp.

1520void ModuleManager::writeDocumentation(OutputList &ol)

1521{

1522 for (auto &mod : p->moduleFileMap) // foreach module

1523 {

1524 if (mod->isPrimaryInterface())

1525 {

1526 mod->writeDocumentation(ol);

1527 }

1528 }

1529}

Reference p.

Referenced by generateOutput.

Private Member Functions

collectExportedSymbolsRecursively()

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

Declaration at line 145 of file moduledef.h, definition at line 1473 of file moduledef.cpp.

1473void ModuleManager::collectExportedSymbolsRecursively(ModuleDef *intfMod, ModuleDef *partitionMod)

1474{

1475 AUTO_TRACE("{}: collecting symbols for partition {}",intfMod->qualifiedName(),partitionMod->qualifiedName());

1476 auto intfModImpl = toModuleDefImpl(intfMod);

1477 auto partitionModImpl = toModuleDefImpl(partitionMod);

1478 intfModImpl->mergeSymbolsFrom(partitionModImpl);

1479}

References AUTO_TRACE, Definition::qualifiedName and toModuleDefImpl.

Referenced by collectExportedSymbols.

resolvePartitionsRecursively()

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

Declaration at line 144 of file moduledef.h, definition at line 1339 of file moduledef.cpp.

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

1340{

1341 AUTO_TRACE();

1342 for (auto &[partitionFileName,importInfoList] : mod->getImports()) // foreach import

1343 {

1344 for (auto &importInfo : importInfoList)

1345 {

1346 AUTO_TRACE_ADD("partitionFileName={} importName={} partitionName={}",

1347 partitionFileName,importInfo.importName,importInfo.partitionName);

1348 if (importInfo.importName==intfMod->name() && !importInfo.partitionName.isEmpty() &&

1349 importInfo.exported) // that is an exported partition of this module

1350 {

1351 auto it = p->moduleNameMap.find(importInfo.importName.str());

1352 if (it != p->moduleNameMap.end())

1353 {

1354 for (auto importedMod : it->second)

1355 {

1356 if (importedMod->qualifiedName()==importInfo.importName+":"+importInfo.partitionName)

1357 {

1358 AUTO_TRACE_ADD("Interface module {} exports partition {}:{}",

1359 mod->name(),importedMod->name(),importedMod->partitionName());

1360 toModuleDefImpl(intfMod)->addPartition(toModuleDefImpl(importedMod));

1361 toModuleDefImpl(importedMod)->setPrimaryInterface(intfMod);

1362 for (const auto &[partitionFileName_,partitionImportInfoList] : importedMod->getImports())

1363 {

1364 for (const auto &partitionImportInfo : partitionImportInfoList)

1365 {

1366 if (partitionImportInfo.exported && intfMod->name()!=partitionImportInfo.importName)

1367 {

1368 toModuleDefImpl(intfMod)->addExportedModule(partitionImportInfo.importName,partitionImportInfo);

1369 }

1370 }

1371 }

1372 resolvePartitionsRecursively(intfMod,importedMod);

1373 }

1374 }

1375 }

1376 }

1377 }

1378 }

1379}

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.

Private Member Attributes

p

std::unique_ptr<Private> ModuleManager::p

Definition at line 147 of file moduledef.h.

147 std::unique_ptr<Private> p;

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.

Public Static Functions

instance()

ModuleManager & ModuleManager::instance ()

static

Declaration at line 113 of file moduledef.h, definition at line 1215 of file moduledef.cpp.

1215ModuleManager &ModuleManager::instance()

1216{

1217 static ModuleManager m;

1218 return m;

1219}

Reference ModuleManager.

Referenced by addClassToContext, addConceptToContext, addDefineDoc, addEnumDocs, addGlobalFunction, addInterfaceOrServiceToServiceOrSingleton, addListReferences, addMemberDocs, addMembersToMemberGroup, addMethodToClass, addVariableToClass, addVariableToFile, buildFunctionList, anonymous{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.

---

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

• moduledef.cpp
• moduledef.h

---

Generated via doxygen2docusaurus by Doxygen 1.14.0.