Skip to main content

The ModuleDefImpl Class Reference

Declaration​

class ModuleDefImpl { ... }

Base class​

classDefinitionMixin<Base>

Public Constructors Index​

ModuleDefImpl (const QCString &fileName, int startLine, int startColom, const QCString &name, Type type, const QCString &partitionName)

Public Member Functions Index​

DefTypedefinitionType () const override
CodeSymbolTypecodeSymbolType () const override
QCStringdisplayName (bool=TRUE) const override
QCStringgetOutputFileBase () const override
QCStringanchor () const override
boolisLinkableInProject () const override
boolisLinkable () const override
QCStringqualifiedName () const override
voidwriteSummaryLinks (OutputList &ol) const override
voidwritePageNavigation (OutputList &ol) const override
TypemoduleType () const override
QCStringpartitionName () const override
voidwriteDocumentation (OutputList &ol) override
boolisPrimaryInterface () const override
MemberList *getMemberList (MemberListType lt) const override
const MemberLists &getMemberLists () const override
const MemberGroupList &getMemberGroups () const override
const ClassLinkedRefMap &getClasses () const override
const ConceptLinkedRefMap &getConcepts () const override
intcountVisibleMembers () const override
FileDef *getFileDef () const override
const ImportInfoMap &getImports () const override
const ImportInfoMap &getExports () const override
const ModuleMap &partitions () const override
voidwriteTagFile (TextStream &t) const override
FileListgetUsedFiles () const override
voidwriteExports (OutputList &ol, const QCString &title)
voidwriteClassDeclarations (OutputList &ol, const QCString &title)
voidwriteConcepts (OutputList &ol, const QCString &title)
voidwriteFiles (OutputList &ol, const QCString &title)
voidstartMemberDeclarations (OutputList &ol)
voidendMemberDeclarations (OutputList &ol)
voidstartMemberDocumentation (OutputList &ol)
voidendMemberDocumentation (OutputList &ol)
voidwriteDetailedDescription (OutputList &ol, const QCString &title)
voidwriteBriefDescription (OutputList &ol)
voidwriteMemberGroups (OutputList &ol)
voidwriteMemberDeclarations (OutputList &ol, MemberListType lt, const QCString &title)
voidwriteMemberDocumentation (OutputList &ol, MemberListType lt, const QCString &title)
voidwriteAuthorSection (OutputList &ol)
voidwriteDeclarationLink (OutputList &ol, bool &found, const QCString &header, bool localNames) const
voidaddHeader (int line, const QCString &headerName, bool isSystem)
voidaddImport (int line, const QCString &moduleName, const QCString &partitionName, bool isExported)
voidaddClassToModule (const Entry *root, ClassDef *cd)
voidaddConceptToModule (const Entry *root, ConceptDef *cd)
voidaddMemberToModule (const Entry *root, MemberDef *md)
voidaddPartition (ModuleDefImpl *mod)
voidaddContributingModule (ModuleDefImpl *mod)
voidsetPrimaryInterface (const ModuleDef *mod)
voidsetFileDef (FileDef *fd)
voidaddMemberToList (MemberListType lt, MemberDef *md)
voidaddExportedModule (const QCString &moduleName, const ImportInfo &info)
voidaddListReferences ()
voidaddMembersToMemberGroup ()
voiddistributeMemberGroupDocumentation ()
voidfindSectionsInDocumentation ()
voidsortMemberLists ()
voidmergeSymbolsFrom (ModuleDefImpl *other)
boolhasDetailedDescription () const
voidcountMembers ()

Private Member Attributes Index​

Typem_type
QCStringm_partitionName
ImportInfoMapm_imports
ImportInfoMapm_exportedModules
ClassLinkedRefMapm_classes
ConceptLinkedRefMapm_concepts
MemberListsm_memberLists
ModuleMapm_partitions
ModuleListm_contributing
MemberGroupListm_memberGroups
const ModuleDef *m_primaryInterface = nullptr
FileDef *m_fileDef = nullptr

Definition at line 48 of file moduledef.cpp.

Public Constructors​

ModuleDefImpl()​

ModuleDefImpl::ModuleDefImpl (const QCString & fileName, int startLine, int startColom, const QCString & name, Type type, const QCString & partitionName)
 inline

Definition at line 51 of file moduledef.cpp.

51 ModuleDefImpl(const QCString &fileName,int startLine,int startColom,
52 const QCString &name, Type type, const QCString &partitionName)
53 : DefinitionMixin<ModuleDef>(fileName,startLine,startColom,name,nullptr,nullptr,true),
54 m_type(type), m_partitionName(partitionName) {}

References DefinitionMixin< ModuleDef >::DefinitionMixin, m_partitionName, m_type, DefinitionMixin< ModuleDef >::name and partitionName.

Referenced by addContributingModule, addPartition and mergeSymbolsFrom.

Public Member Functions​

addClassToModule()​

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

Definition at line 108 of file moduledef.cpp.

202void ModuleDefImpl::addClassToModule(const Entry *root,ClassDef *cd)
203{
204 QCString className = cd->qualifiedName();
205 AUTO_TRACE("{}:{} class {} of module {} exported={}",
206 root->fileName,root->startLine, className, name(), root->exported);
207 bool isExported = m_classes.find(className)!=nullptr;
208 if (root->exported && !isExported)
209 {
210 m_classes.add(className,cd);
211 }
212 auto cdm = toClassDefMutable(cd);
213 if (cdm && root->exported && !cd->isExported())
214 {
215 cdm->setExported(true);
216 }
217}

References AUTO_TRACE, Entry::exported, Entry::fileName, Definition::isExported, DefinitionMixin< ModuleDef >::isExported, m_classes, DefinitionMixin< ModuleDef >::name, Definition::qualifiedName, Entry::startLine and toClassDefMutable.

Referenced by ModuleManager::addClassToModule.

addConceptToModule()​

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

Definition at line 109 of file moduledef.cpp.

219void ModuleDefImpl::addConceptToModule(const Entry *root,ConceptDef *cd)
220{
221 QCString conceptName = cd->qualifiedName();
222 AUTO_TRACE("{}:{} concept {} of module {} exported={}",
223 root->fileName,root->startLine,
224 cd->qualifiedName(),name(),
225 root->exported);
226 bool isExported = m_classes.find(conceptName)!=nullptr;
227 if (root->exported && !isExported)
228 {
229 m_concepts.add(conceptName,cd);
230 }
231 auto cdm = toConceptDefMutable(cd);
232 if (cdm && root->exported && !cd->isExported())
233 {
234 cdm->setExported(true);
235 }
236}

References AUTO_TRACE, Entry::exported, Entry::fileName, Definition::isExported, DefinitionMixin< ModuleDef >::isExported, m_classes, m_concepts, DefinitionMixin< ModuleDef >::name, Definition::qualifiedName, Entry::startLine and toConceptDefMutable.

Referenced by ModuleManager::addConceptToModule.

addContributingModule()​

void ModuleDefImpl::addContributingModule (ModuleDefImpl * mod)

Definition at line 112 of file moduledef.cpp.

167void ModuleDefImpl::addContributingModule(ModuleDefImpl *mod)
168{
169 if (std::find(m_contributing.begin(),m_contributing.end(),mod)==m_contributing.end())
170 {
171 m_contributing.push_back(mod);
172 }
173}

References m_contributing and ModuleDefImpl.

Referenced by ModuleManager::collectExportedSymbols.

addExportedModule()​

void ModuleDefImpl::addExportedModule (const QCString & moduleName, const ImportInfo & info)

Definition at line 116 of file moduledef.cpp.

196void ModuleDefImpl::addExportedModule(const QCString &moduleName,const ImportInfo &info)
197{
198 AUTO_TRACE("name={}:moduleName={},import={}",name(),moduleName,info.importName);
199 m_exportedModules[moduleName.str()].push_back(info);
200}

References AUTO_TRACE, ImportInfo::importName, m_exportedModules, DefinitionMixin< ModuleDef >::name and QCString::str.

Referenced by ModuleManager::resolvePartitions and ModuleManager::resolvePartitionsRecursively.

addHeader()​

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

Definition at line 106 of file moduledef.cpp.

185void ModuleDefImpl::addHeader(int line,const QCString &headerName,bool isSystem)
186{
187 AUTO_TRACE("name={}:line={},header={},isSystem={}",name(),line,headerName,isSystem);
188}

References AUTO_TRACE and DefinitionMixin< ModuleDef >::name.

Referenced by ModuleManager::addHeader.

addImport()​

void ModuleDefImpl::addImport (int line, const QCString & moduleName, const QCString & partitionName, bool isExported)

Definition at line 107 of file moduledef.cpp.

190void ModuleDefImpl::addImport(int line,const QCString &moduleName,const QCString &partitionName,bool isExported)
191{
192 AUTO_TRACE("name={}:line={},module={},partition={}",name(),line,moduleName,partitionName);
193 m_imports[getDefFileName().str()+":"+std::to_string(line)].push_back(ImportInfo(this,moduleName,line,partitionName,isExported));
194}

References AUTO_TRACE, DefinitionMixin< ModuleDef >::getDefFileName, DefinitionMixin< ModuleDef >::isExported, m_imports, DefinitionMixin< ModuleDef >::name, partitionName and QCString::str.

Referenced by ModuleManager::addImport.

addListReferences()​

void ModuleDefImpl::addListReferences ()

Definition at line 117 of file moduledef.cpp.

672void ModuleDefImpl::addListReferences()
673{
674 const RefItemVector &xrefItems = xrefListItems();
675 addRefItem(xrefItems,
676 qualifiedName(),
677 getLanguage()==SrcLangExt::Fortran ?
678 theTranslator->trModule(TRUE,TRUE) :
679 theTranslator->trNamespace(TRUE,TRUE),
680 getOutputFileBase(),displayName(),
681 QCString(),
682 this
683 );
684 for (const auto &mg : m_memberGroups)
685 {
686 mg->addListReferences(this);
687 }
688 for (auto &ml : m_memberLists)
689 {
690 if (ml->listType().isDocumentation())
691 {
692 ml->addListReferences(this);
693 }
694 }
695}

References addRefItem, displayName, DefinitionMixin< ModuleDef >::getLanguage, getOutputFileBase, m_memberGroups, m_memberLists, qualifiedName, theTranslator, TRUE and DefinitionMixin< ModuleDef >::xrefListItems.

Referenced by ModuleManager::addListReferences.

addMembersToMemberGroup()​

void ModuleDefImpl::addMembersToMemberGroup ()

Definition at line 118 of file moduledef.cpp.

697void ModuleDefImpl::addMembersToMemberGroup()
698{
699 for (auto &ml : m_memberLists)
700 {
701 if (ml->listType().isDeclaration())
702 {
703 ::addMembersToMemberGroup(ml.get(),&m_memberGroups,this);
704 }
705 }
706
707 // add members inside sections to their groups
708 for (const auto &mg : m_memberGroups)
709 {
710 if (mg->allMembersInSameSection() && Config_getBool(SUBGROUPING))
711 {
712 //printf("----> addToDeclarationSection(%s)\n",qPrint(mg->header()));
713 mg->addToDeclarationSection();
714 }
715 }
716}

References addMembersToMemberGroup, Config_getBool, m_memberGroups and m_memberLists.

Referenced by addMembersToMemberGroup and ModuleManager::addMembersToMemberGroup.

addMemberToList()​

void ModuleDefImpl::addMemberToList (MemberListType lt, MemberDef * md)

Definition at line 115 of file moduledef.cpp.

250void ModuleDefImpl::addMemberToList(MemberListType lt,MemberDef *md)
251{
252 bool sortBriefDocs = Config_getBool(SORT_BRIEF_DOCS);
253 bool sortMemberDocs = Config_getBool(SORT_MEMBER_DOCS);
254 auto &ml = m_memberLists.get(lt,MemberListContainer::Module);
255 ml->setNeedsSorting(
256 (ml->listType().isDeclaration() && sortBriefDocs) ||
257 (ml->listType().isDocumentation() && sortMemberDocs));
258 ml->push_back(md);
259 if (ml->listType().isDeclaration())
260 {
261 MemberDefMutable *mdm = toMemberDefMutable(md);
262 if (mdm)
263 {
264 mdm->setSectionList(this,ml.get());
265 }
266 }
267}

References Config_getBool, m_memberLists, Module, MemberDefMutable::setSectionList and toMemberDefMutable.

Referenced by addMemberToModule.

addMemberToModule()​

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

Definition at line 110 of file moduledef.cpp.

269void ModuleDefImpl::addMemberToModule(const Entry *root,MemberDef *md)
270{
271 AUTO_TRACE("{}:{} member {} of module {} exported={}",
272 qPrint(root->fileName),root->startLine,
273 qPrint(md->qualifiedName()),qPrint(name()),
274 root->exported);
275 MemberList *allMemberList = getMemberList(MemberListType::AllMembersList());
276 if (allMemberList==nullptr)
277 {
278 m_memberLists.emplace_back(std::make_unique<MemberList>(MemberListType::AllMembersList(),MemberListContainer::Module));
279 allMemberList = m_memberLists.back().get();
280 }
281 if (allMemberList->contains(md))
282 {
283 return;
284 }
285 allMemberList->push_back(md);
286 switch (md->memberType())
287 {
288 case MemberType::Variable:
289 addMemberToList(MemberListType::DecVarMembers(),md);
290 break;
291 case MemberType::Function:
292 addMemberToList(MemberListType::DecFuncMembers(),md);
293 break;
294 case MemberType::Typedef:
295 addMemberToList(MemberListType::DecTypedefMembers(),md);
296 break;
297 case MemberType::Enumeration:
298 addMemberToList(MemberListType::DecEnumMembers(),md);
299 break;
300 default:
301 break;
302 }
303 auto mdm = toMemberDefMutable(md);
304 if (mdm && root->exported && !md->isExported())
305 {
306 mdm->setExported(true);
307 }
308}

References addMemberToList, AUTO_TRACE, MemberVector::contains, Enumeration, Entry::exported, Entry::fileName, Function, getMemberList, Definition::isExported, m_memberLists, MemberDef::memberType, Module, DefinitionMixin< ModuleDef >::name, MemberVector::push_back, qPrint, Definition::qualifiedName, Entry::startLine, toMemberDefMutable, Typedef and Variable.

Referenced by ModuleManager::addMemberToModule.

addPartition()​

void ModuleDefImpl::addPartition (ModuleDefImpl * mod)

Definition at line 111 of file moduledef.cpp.

158void ModuleDefImpl::addPartition(ModuleDefImpl *mod)
159{
160 std::string qName = mod->qualifiedName().str();
161 if (m_partitions.find(qName)==m_partitions.end())
162 {
163 m_partitions.emplace(qName,mod);
164 }
165}

References m_partitions, ModuleDefImpl, qualifiedName and QCString::str.

Referenced by ModuleManager::resolvePartitionsRecursively.

anchor()​

QCString ModuleDefImpl::anchor ()
 inline virtual

Returns the anchor within a page where this item can be found

Definition at line 61 of file moduledef.cpp.

61 QCString anchor() const override { return ""; }

Referenced by writeDeclarationLink.

codeSymbolType()​

CodeSymbolType ModuleDefImpl::codeSymbolType ()
 inline virtual

Used for syntax highlighting symbol class

Definition at line 58 of file moduledef.cpp.

58 CodeSymbolType codeSymbolType() const override { return CodeSymbolType::Module; }

Reference Module.

countMembers()​

void ModuleDefImpl::countMembers ()

Definition at line 126 of file moduledef.cpp.

658void ModuleDefImpl::countMembers()
659{
660 for (auto &ml : m_memberLists)
661 {
662 ml->countDecMembers();
663 ml->countDocMembers();
664 }
665 for (const auto &mg : m_memberGroups)
666 {
667 mg->countDecMembers();
668 mg->countDocMembers();
669 }
670}

References m_memberGroups and m_memberLists.

Referenced by ModuleManager::countMembers.

countVisibleMembers()​

int ModuleDefImpl::countVisibleMembers ()
 virtual

Definition at line 82 of file moduledef.cpp.

1017int ModuleDefImpl::countVisibleMembers() const
1018{
1019 int count=0;
1020 for (const auto &lde : LayoutDocManager::instance().docEntries(LayoutDocManager::Module))
1021 {
1022 if (lde->kind()==LayoutDocEntry::MemberDecl)
1023 {
1024 const LayoutDocEntryMemberDecl *lmd = dynamic_cast<const LayoutDocEntryMemberDecl*>(lde.get());
1025 if (lmd)
1026 {
1027 MemberList *ml = getMemberList(lmd->type);
1028 if (ml)
1029 {
1030 for (const auto &md : *ml)
1031 {
1032 if (md->visibleInIndex())
1033 {
1034 count++;
1035 }
1036 }
1037 }
1038 }
1039 }
1040 else if (lde->kind()==LayoutDocEntry::ModuleClasses)
1041 {
1042 for (const auto &cd : getClasses())
1043 {
1044 if (cd->isLinkableInProject())
1045 {
1046 count++;
1047 }
1048 }
1049 }
1050 else if (lde->kind()==LayoutDocEntry::ModuleConcepts)
1051 {
1052 for (const auto &cd : getConcepts())
1053 {
1054 if (cd->isLinkableInProject())
1055 {
1056 count++;
1057 }
1058 }
1059 }
1060 }
1061 return count;
1062}

References getClasses, getConcepts, getMemberList, LayoutDocManager::instance and LayoutDocEntryMemberDecl::type.

definitionType()​

DefType ModuleDefImpl::definitionType ()
 inline virtual

Use this for dynamic inspection of the type of the derived class

Definition at line 57 of file moduledef.cpp.

57 DefType definitionType() const override { return TypeModule; }

Reference Definition::TypeModule.

displayName()​

QCString ModuleDefImpl::displayName (bool includeScope=TRUE)
 inline virtual

Returns the name of the definition as it appears in the output

Definition at line 59 of file moduledef.cpp.

59 QCString displayName(bool=TRUE) const override { return name(); }

References DefinitionMixin< ModuleDef >::name and TRUE.

Referenced by addListReferences, writeDeclarationLink and writeDocumentation.

distributeMemberGroupDocumentation()​

void ModuleDefImpl::distributeMemberGroupDocumentation ()

Definition at line 119 of file moduledef.cpp.

718void ModuleDefImpl::distributeMemberGroupDocumentation()
719{
720 for (const auto &mg : m_memberGroups)
721 {
722 mg->distributeMemberGroupDocumentation();
723 }
724}

Reference m_memberGroups.

Referenced by ModuleManager::distributeMemberGroupDocumentation.

endMemberDeclarations()​

void ModuleDefImpl::endMemberDeclarations (OutputList & ol)

Definition at line 95 of file moduledef.cpp.

518void ModuleDefImpl::endMemberDeclarations(OutputList &ol)
519{
520 ol.endMemberSections();
521}

Reference OutputList::endMemberSections.

Referenced by writeDocumentation.

endMemberDocumentation()​

void ModuleDefImpl::endMemberDocumentation (OutputList & ol)

Definition at line 97 of file moduledef.cpp.

532void ModuleDefImpl::endMemberDocumentation(OutputList &ol)
533{
534 if (Config_getBool(SEPARATE_MEMBER_PAGES))
535 {
536 ol.enable(OutputType::Html);
537 Doxygen::suppressDocWarnings = FALSE;
538 }
539}

References Config_getBool, OutputList::enable, FALSE, Html and Doxygen::suppressDocWarnings.

Referenced by writeDocumentation.

findSectionsInDocumentation()​

void ModuleDefImpl::findSectionsInDocumentation ()

Definition at line 120 of file moduledef.cpp.

726void ModuleDefImpl::findSectionsInDocumentation()
727{
728 docFindSections(briefDescription(),this,docFile());
729 docFindSections(documentation(),this,docFile());
730 docFindSections(inbodyDocumentation(),this,docFile());
731 for (const auto &mg : m_memberGroups)
732 {
733 mg->findSectionsInDocumentation(this);
734 }
735 for (auto &ml : m_memberLists)
736 {
737 if (ml->listType().isDeclaration())
738 {
739 ml->findSectionsInDocumentation(this);
740 }
741 }
742}

References DefinitionMixin< ModuleDef >::briefDescription, DefinitionMixin< ModuleDef >::docFile, docFindSections, DefinitionMixin< ModuleDef >::documentation, DefinitionMixin< ModuleDef >::inbodyDocumentation, m_memberGroups and m_memberLists.

Referenced by ModuleManager::findSectionsInDocumentation.

getClasses()​

const ClassLinkedRefMap & ModuleDefImpl::getClasses ()
 inline virtual

Definition at line 80 of file moduledef.cpp.

80 const ClassLinkedRefMap &getClasses() const override { return m_classes; }

Reference m_classes.

Referenced by countVisibleMembers and mergeSymbolsFrom.

getConcepts()​

const ConceptLinkedRefMap & ModuleDefImpl::getConcepts ()
 inline virtual

Definition at line 81 of file moduledef.cpp.

81 const ConceptLinkedRefMap &getConcepts() const override { return m_concepts; }

Reference m_concepts.

Referenced by countVisibleMembers and mergeSymbolsFrom.

getExports()​

const ImportInfoMap & ModuleDefImpl::getExports ()
 inline virtual

Definition at line 85 of file moduledef.cpp.

85 const ImportInfoMap &getExports() const override { return m_exportedModules; }

Reference m_exportedModules.

getFileDef()​

FileDef * ModuleDefImpl::getFileDef ()
 inline virtual

Definition at line 83 of file moduledef.cpp.

83 FileDef *getFileDef() const override { return m_fileDef; }

Reference m_fileDef.

Referenced by writeTagFile.

getImports()​

const ImportInfoMap & ModuleDefImpl::getImports ()
 inline virtual

Definition at line 84 of file moduledef.cpp.

84 const ImportInfoMap &getImports() const override { return m_imports; }

Reference m_imports.

getMemberGroups()​

const MemberGroupList & ModuleDefImpl::getMemberGroups ()
 inline virtual

Definition at line 79 of file moduledef.cpp.

79 const MemberGroupList &getMemberGroups() const override { return m_memberGroups; }

Reference m_memberGroups.

getMemberList()​

MemberList * ModuleDefImpl::getMemberList (MemberListType lt)
 virtual

Definition at line 77 of file moduledef.cpp.

238MemberList *ModuleDefImpl::getMemberList(MemberListType lt) const
239{
240 for (auto &ml : m_memberLists)
241 {
242 if (ml->listType()==lt)
243 {
244 return ml.get();
245 }
246 }
247 return nullptr;
248}

Reference m_memberLists.

Referenced by addMemberToModule, countVisibleMembers, mergeSymbolsFrom, writeMemberDeclarations, writeMemberDocumentation, writeSummaryLinks and writeTagFile.

getMemberLists()​

const MemberLists & ModuleDefImpl::getMemberLists ()
 inline virtual

Definition at line 78 of file moduledef.cpp.

78 const MemberLists &getMemberLists() const override { return m_memberLists; }

Reference m_memberLists.

getOutputFileBase()​

QCString ModuleDefImpl::getOutputFileBase ()
 virtual

Returns the base file name (without extension) of this definition. as it is referenced to/written to disk.

Definition at line 60 of file moduledef.cpp.

143QCString ModuleDefImpl::getOutputFileBase() const
144{
145 return convertNameToFile("module_" + name());
146}

References convertNameToFile and DefinitionMixin< ModuleDef >::name.

Referenced by addListReferences, writeDeclarationLink, writeDocumentation and writeTagFile.

getUsedFiles()​

FileList ModuleDefImpl::getUsedFiles ()
 virtual

Definition at line 88 of file moduledef.cpp.

1006FileList ModuleDefImpl::getUsedFiles() const
1007{
1008 FileList result;
1009 for (const auto &mod : m_contributing)
1010 {
1011 FileDef *fd = mod->getFileDef();
1012 if (fd) result.push_back(fd);
1013 }
1014 return result;
1015}

Reference m_contributing.

Referenced by writeTagFile.

hasDetailedDescription()​

bool ModuleDefImpl::hasDetailedDescription ()

Definition at line 125 of file moduledef.cpp.

652bool ModuleDefImpl::hasDetailedDescription() const
653{
654 bool repeatBrief = Config_getBool(REPEAT_BRIEF);
655 return (!briefDescription().isEmpty() && repeatBrief) || !documentation().isEmpty();
656}

References DefinitionMixin< ModuleDef >::briefDescription, Config_getBool, DefinitionMixin< ModuleDef >::documentation and QCString::isEmpty.

Referenced by writeBriefDescription and writeDetailedDescription.

isLinkable()​

bool ModuleDefImpl::isLinkable ()
 inline virtual

Returns TRUE iff it is possible to link to this item. This can be a link to another project imported via a tag file.

Definition at line 65 of file moduledef.cpp.

65 bool isLinkable() const override {
66 if (m_primaryInterface) return m_primaryInterface->isLinkable();
67 else return hasDocumentation(); }

References DefinitionMixin< ModuleDef >::hasDocumentation and m_primaryInterface.

Referenced by isLinkableInProject and writeDeclarationLink.

isLinkableInProject()​

bool ModuleDefImpl::isLinkableInProject ()
 inline virtual

Returns TRUE iff it is possible to link to this item within this project.

Definition at line 62 of file moduledef.cpp.

62 bool isLinkableInProject() const override {
63 if (m_primaryInterface) return m_primaryInterface->isLinkableInProject();
64 else return isLinkable() && !isHidden() && !isReference(); }

References DefinitionMixin< ModuleDef >::isHidden, isLinkable, DefinitionMixin< ModuleDef >::isReference and m_primaryInterface.

Referenced by writeTagFile.

isPrimaryInterface()​

bool ModuleDefImpl::isPrimaryInterface ()
 inline virtual

Definition at line 76 of file moduledef.cpp.

76 bool isPrimaryInterface() const override { return m_type==Type::Interface && m_partitionName.isEmpty(); }

References ModuleDef::Interface, m_partitionName and m_type.

Referenced by writeTagFile.

mergeSymbolsFrom()​

void ModuleDefImpl::mergeSymbolsFrom (ModuleDefImpl * other)

Definition at line 124 of file moduledef.cpp.

310void ModuleDefImpl::mergeSymbolsFrom(ModuleDefImpl *other)
311{
312 AUTO_TRACE("{} merging symbols of {} ({}:{})",
313 name(),other->qualifiedName(),other->getDefFileName(),other->getDefLine());
314 for (const auto &cd : other->getClasses())
315 {
316 m_classes.add(cd->qualifiedName(),cd);
317 }
318 for (const auto &cd : other->getConcepts())
319 {
320 m_concepts.add(cd->qualifiedName(),cd);
321 }
322 auto mergeMemberList = [this,other](MemberListType lt)
323 {
324 const auto srcMl = other->getMemberList(lt);
325 if (srcMl)
326 {
327 auto &dstMl = m_memberLists.get(lt,srcMl->container());
328 for (const auto &md : *srcMl)
329 {
330 dstMl->push_back(md);
331 }
332 }
333 };
334 mergeMemberList(MemberListType::DecVarMembers());
335 mergeMemberList(MemberListType::DecFuncMembers());
336 mergeMemberList(MemberListType::DecTypedefMembers());
337 mergeMemberList(MemberListType::DecEnumMembers());
338}

References AUTO_TRACE, getClasses, getConcepts, DefinitionMixin< Base >::getDefFileName, DefinitionMixin< Base >::getDefLine, getMemberList, m_classes, m_concepts, m_memberLists, ModuleDefImpl, DefinitionMixin< ModuleDef >::name and qualifiedName.

moduleType()​

Type ModuleDefImpl::moduleType ()
 inline virtual

Definition at line 73 of file moduledef.cpp.

73 Type moduleType() const override { return m_type; }

Reference m_type.

partitionName()​

QCString ModuleDefImpl::partitionName ()
 inline virtual

Definition at line 74 of file moduledef.cpp.

74 QCString partitionName() const override { return m_partitionName; }

Reference m_partitionName.

Referenced by addImport and ModuleDefImpl.

partitions()​

const ModuleMap & ModuleDefImpl::partitions ()
 inline virtual

Definition at line 86 of file moduledef.cpp.

86 const ModuleMap &partitions() const override { return m_partitions; }

Reference m_partitions.

qualifiedName()​

QCString ModuleDefImpl::qualifiedName ()
 virtual

Returns the fully qualified name of this definition

Definition at line 68 of file moduledef.cpp.

148QCString ModuleDefImpl::qualifiedName() const
149{
150 QCString result=name();
151 if (!m_partitionName.isEmpty())
152 {
153 result+=":"+m_partitionName;
154 }
155 return result;
156}

References m_partitionName and DefinitionMixin< ModuleDef >::name.

Referenced by addListReferences, addPartition and mergeSymbolsFrom.

setFileDef()​

void ModuleDefImpl::setFileDef (FileDef * fd)

Definition at line 114 of file moduledef.cpp.

180void ModuleDefImpl::setFileDef(FileDef *fd)
181{
182 m_fileDef = fd;
183}

Reference m_fileDef.

Referenced by ModuleManager::resolvePartitions.

setPrimaryInterface()​

void ModuleDefImpl::setPrimaryInterface (const ModuleDef * mod)

Definition at line 113 of file moduledef.cpp.

175void ModuleDefImpl::setPrimaryInterface(const ModuleDef *mod)
176{
177 m_primaryInterface = mod;
178}

Reference m_primaryInterface.

Referenced by ModuleManager::resolvePartitionsRecursively.

sortMemberLists()​

void ModuleDefImpl::sortMemberLists ()

Definition at line 121 of file moduledef.cpp.

744void ModuleDefImpl::sortMemberLists()
745{
746 for (auto &ml : m_memberLists)
747 {
748 if (ml->needsSorting()) { ml->sort(); ml->setNeedsSorting(FALSE); }
749 }
750
751 if (Config_getBool(SORT_BRIEF_DOCS))
752 {
753 auto classComp = [](const ClassLinkedRefMap::Ptr &c1,const ClassLinkedRefMap::Ptr &c2)
754 {
755 return Config_getBool(SORT_BY_SCOPE_NAME) ?
756 qstricmp_sort(c1->name(), c2->name())<0 :
757 qstricmp_sort(c1->className(), c2->className())<0;
758 };
759 std::stable_sort(m_classes.begin(), m_classes.end(), classComp);
760
761 auto conceptComp = [](const ConceptLinkedRefMap::Ptr &c1,const ConceptLinkedRefMap::Ptr &c2)
762 {
763 return Config_getBool(SORT_BY_SCOPE_NAME) ?
764 qstricmp_sort(c1->qualifiedName(), c2->qualifiedName())<0 :
765 qstricmp_sort(c1->name(), c2->name())<0;
766 };
767 std::stable_sort(m_concepts.begin(), m_concepts.end(), conceptComp);
768 }
769
770 static auto contrComp = [](const ModuleDef *m1, const ModuleDef *m2)
771 {
772 FileDef *f1 = m1->getFileDef();
773 FileDef *f2 = m2->getFileDef();
774 QCString fn1 = f1 ? f1->name() : m1->name();
775 QCString fn2 = f2 ? f2->name() : m2->name();
776 static auto typeRank = [](const ModuleDef *m) -> int
777 {
778 if (m->moduleType()==ModuleDef::Type::Interface)
779 {
780 if (m->partitionName().isEmpty()) return 0; // primary interface unit
781 return 1; // partition interface unit
782 }
783 else
784 {
785 if (!m->partitionName().isEmpty()) return 2; // partition implementation unit
786 return 3; // implementation unit
787 }
788 };
789 auto tr1 = typeRank(m1);
790 auto tr2 = typeRank(m2);
791 int diff = qstricmp_sort(fn1,fn2);
792 return tr1<tr2 || (tr1==tr2 && diff<0);
793 };
794
795 std::stable_sort(m_contributing.begin(), m_contributing.end(), contrComp);
796}

References ClassDef::className, Config_getBool, FALSE, ModuleDef::getFileDef, ModuleDef::Interface, m_classes, m_concepts, m_contributing, m_memberLists, Definition::name, qstricmp_sort and Definition::qualifiedName.

Referenced by ModuleManager::sortMemberLists.

startMemberDeclarations()​

void ModuleDefImpl::startMemberDeclarations (OutputList & ol)

Definition at line 94 of file moduledef.cpp.

513void ModuleDefImpl::startMemberDeclarations(OutputList &ol)
514{
515 ol.startMemberSections();
516}

Reference OutputList::startMemberSections.

Referenced by writeDocumentation.

startMemberDocumentation()​

void ModuleDefImpl::startMemberDocumentation (OutputList & ol)

Definition at line 96 of file moduledef.cpp.

523void ModuleDefImpl::startMemberDocumentation(OutputList &ol)
524{
525 if (Config_getBool(SEPARATE_MEMBER_PAGES))
526 {
527 ol.disable(OutputType::Html);
528 Doxygen::suppressDocWarnings = TRUE;
529 }
530}

References Config_getBool, OutputList::disable, Html, Doxygen::suppressDocWarnings and TRUE.

Referenced by writeDocumentation.

writeAuthorSection()​

void ModuleDefImpl::writeAuthorSection (OutputList & ol)

Definition at line 103 of file moduledef.cpp.

640void ModuleDefImpl::writeAuthorSection(OutputList &ol)
641{
642 // write Author section (Man only)
643 ol.pushGeneratorState();
644 ol.disableAllBut(OutputType::Man);
645 ol.startGroupHeader();
646 ol.parseText(theTranslator->trAuthor(TRUE,TRUE));
647 ol.endGroupHeader();
648 ol.parseText(theTranslator->trGeneratedAutomatically(Config_getString(PROJECT_NAME)));
649 ol.popGeneratorState();
650}

References Config_getString, OutputList::disableAllBut, OutputList::endGroupHeader, Man, OutputList::parseText, OutputList::popGeneratorState, OutputList::pushGeneratorState, OutputList::startGroupHeader, theTranslator and TRUE.

Referenced by writeDocumentation.

writeBriefDescription()​

void ModuleDefImpl::writeBriefDescription (OutputList & ol)

Definition at line 99 of file moduledef.cpp.

584void ModuleDefImpl::writeBriefDescription(OutputList &ol)
585{
586 if (hasBriefDescription())
587 {
588 auto parser { createDocParser() };
589 auto ast { validatingParseDoc(*parser.get(),
590 briefFile(),briefLine(),this,nullptr,
591 briefDescription(),TRUE,FALSE,
592 QCString(),TRUE,FALSE) };
593 if (!ast->isEmpty())
594 {
595 ol.startParagraph();
596 ol.pushGeneratorState();
597 ol.disableAllBut(OutputType::Man);
598 ol.writeString(" - ");
599 ol.popGeneratorState();
600 ol.writeDoc(ast.get(),this,nullptr);
601 ol.pushGeneratorState();
602 ol.disable(OutputType::RTF);
603 ol.writeString(" \n");
604 ol.enable(OutputType::RTF);
605
606 if (hasDetailedDescription())
607 {
608 ol.disableAllBut(OutputType::Html);
609 ol.startTextLink(QCString(),"details");
610 ol.parseText(theTranslator->trMore());
611 ol.endTextLink();
612 }
613 ol.popGeneratorState();
614 ol.endParagraph();
615 }
616 }
617 ol.writeSynopsis();
618}

References DefinitionMixin< ModuleDef >::briefDescription, DefinitionMixin< ModuleDef >::briefFile, DefinitionMixin< ModuleDef >::briefLine, createDocParser, OutputList::disable, OutputList::disableAllBut, OutputList::enable, OutputList::endParagraph, OutputList::endTextLink, FALSE, DefinitionMixin< ModuleDef >::hasBriefDescription, hasDetailedDescription, Html, Man, OutputList::parseText, OutputList::popGeneratorState, OutputList::pushGeneratorState, RTF, OutputList::startParagraph, OutputList::startTextLink, theTranslator, TRUE, validatingParseDoc, OutputList::writeDoc, OutputList::writeString and OutputList::writeSynopsis.

Referenced by writeDocumentation.

writeClassDeclarations()​

void ModuleDefImpl::writeClassDeclarations (OutputList & ol, const QCString & title)

Definition at line 91 of file moduledef.cpp.

503void ModuleDefImpl::writeClassDeclarations(OutputList &ol,const QCString &title)
504{
505 m_classes.writeDeclaration(ol,nullptr,title,FALSE);
506}

References FALSE and m_classes.

Referenced by writeDocumentation.

writeConcepts()​

void ModuleDefImpl::writeConcepts (OutputList & ol, const QCString & title)

Definition at line 92 of file moduledef.cpp.

508void ModuleDefImpl::writeConcepts(OutputList &ol,const QCString &title)
509{
510 m_concepts.writeDeclaration(ol,title,FALSE);
511}

References FALSE and m_concepts.

Referenced by writeDocumentation.

writeDeclarationLink()​

void ModuleDefImpl::writeDeclarationLink (OutputList & ol, bool & found, const QCString & header, bool localNames)

Definition at line 104 of file moduledef.cpp.

851void ModuleDefImpl::writeDeclarationLink(OutputList &ol,bool &found,const QCString &header,bool localNames) const
852{
853 if (isLinkable())
854 {
855 if (!found) // first module
856 {
857 ol.startMemberHeader("modules");
858 if (!header.isEmpty())
859 {
860 ol.parseText(header);
861 }
862 else
863 {
864 theTranslator->trModule(true,false);
865 }
866 ol.endMemberHeader();
867 ol.startMemberList();
868 found=TRUE;
869 }
870 ol.startMemberDeclaration();
871 QCString cname = displayName(!localNames);
872 QCString anc = anchor();
873 if (anc.isEmpty()) anc=cname; else anc.prepend(cname+"_");
874 ol.startMemberItem(anc,OutputGenerator::MemberItemType::Normal);
875 ol.writeString("module ");
876 ol.insertMemberAlign();
877 if (isLinkable())
878 {
879 ol.writeObjectLink(getReference(),
880 getOutputFileBase(),
881 anchor(),
882 cname
883 );
884 }
885 else
886 {
887 ol.startBold();
888 ol.docify(cname);
889 ol.endBold();
890 }
891 ol.endMemberItem(OutputGenerator::MemberItemType::Normal);
892 // add the brief description if available
893 if (!briefDescription().isEmpty() && Config_getBool(BRIEF_MEMBER_DESC))
894 {
895 auto parser { createDocParser() };
896 auto ast { validatingParseDoc(
897 *parser.get(),briefFile(),briefLine(),this,nullptr,
898 briefDescription(),FALSE,FALSE,
899 QCString(),TRUE,FALSE,Config_getBool(MARKDOWN_SUPPORT)) };
900 if (!ast->isEmpty())
901 {
902 ol.startMemberDescription(anchor());
903 ol.writeDoc(ast.get(),this,nullptr);
904 ol.endMemberDescription();
905 }
906 }
907 ol.endMemberDeclaration(anchor(),QCString());
908 }
909}

References anchor, DefinitionMixin< ModuleDef >::briefDescription, DefinitionMixin< ModuleDef >::briefFile, DefinitionMixin< ModuleDef >::briefLine, Config_getBool, createDocParser, displayName, OutputList::docify, OutputList::endBold, OutputList::endMemberDeclaration, OutputList::endMemberDescription, OutputList::endMemberHeader, OutputList::endMemberItem, FALSE, getOutputFileBase, DefinitionMixin< ModuleDef >::getReference, OutputList::insertMemberAlign, QCString::isEmpty, isLinkable, OutputGenerator::Normal, OutputList::parseText, QCString::prepend, OutputList::startBold, OutputList::startMemberDeclaration, OutputList::startMemberDescription, OutputList::startMemberHeader, OutputList::startMemberItem, OutputList::startMemberList, theTranslator, TRUE, validatingParseDoc, OutputList::writeDoc, OutputList::writeObjectLink and OutputList::writeString.

Referenced by ModuleLinkedRefMap::writeDeclaration.

writeDetailedDescription()​

void ModuleDefImpl::writeDetailedDescription (OutputList & ol, const QCString & title)

Definition at line 98 of file moduledef.cpp.

541void ModuleDefImpl::writeDetailedDescription(OutputList &ol,const QCString &title)
542{
543 if (hasDetailedDescription())
544 {
545 ol.pushGeneratorState();
546 ol.disable(OutputType::Html);
547 ol.writeRuler();
548 ol.popGeneratorState();
549 ol.pushGeneratorState();
550 ol.disableAllBut(OutputType::Html);
551 ol.writeAnchor(QCString(),"details");
552 ol.popGeneratorState();
553 ol.startGroupHeader("details");
554 ol.parseText(title);
555 ol.endGroupHeader();
556
557 ol.startTextBlock();
558 if (!briefDescription().isEmpty() && Config_getBool(REPEAT_BRIEF))
559 {
560 ol.generateDoc(briefFile(),briefLine(),this,nullptr,briefDescription(),FALSE,FALSE,
561 QCString(),FALSE,FALSE);
562 }
563 if (!briefDescription().isEmpty() && Config_getBool(REPEAT_BRIEF) &&
564 !documentation().isEmpty())
565 {
566 ol.pushGeneratorState();
567 ol.disable(OutputType::Man);
568 ol.disable(OutputType::RTF);
569 ol.enableAll();
570 ol.disableAllBut(OutputType::Man);
571 ol.enable(OutputType::Latex);
572 ol.writeString("\n\n");
573 ol.popGeneratorState();
574 }
575 if (!documentation().isEmpty())
576 {
577 ol.generateDoc(docFile(),docLine(),this,nullptr,documentation()+"\n",TRUE,FALSE,
578 QCString(),FALSE,FALSE);
579 }
580 ol.endTextBlock();
581 }
582}

References DefinitionMixin< ModuleDef >::briefDescription, DefinitionMixin< ModuleDef >::briefFile, DefinitionMixin< ModuleDef >::briefLine, Config_getBool, OutputList::disable, OutputList::disableAllBut, DefinitionMixin< ModuleDef >::docFile, DefinitionMixin< ModuleDef >::docLine, DefinitionMixin< ModuleDef >::documentation, OutputList::enable, OutputList::enableAll, OutputList::endGroupHeader, OutputList::endTextBlock, FALSE, OutputList::generateDoc, hasDetailedDescription, Html, Latex, Man, OutputList::parseText, OutputList::popGeneratorState, OutputList::pushGeneratorState, RTF, OutputList::startGroupHeader, OutputList::startTextBlock, TRUE, OutputList::writeAnchor, OutputList::writeRuler and OutputList::writeString.

Referenced by writeDocumentation.

writeDocumentation()​

void ModuleDefImpl::writeDocumentation (OutputList & ol)
 virtual

Definition at line 75 of file moduledef.cpp.

340void ModuleDefImpl::writeDocumentation(OutputList &ol)
341{
342 if (isReference()) return;
343 bool generateTreeView = Config_getBool(GENERATE_TREEVIEW);
344 ol.pushGeneratorState();
345 AUTO_TRACE("%s file=%s",name(),getDefFileName());
346 SrcLangExt lang = getLanguage();
347 QCString pageTitle;
348 if (Config_getBool(HIDE_COMPOUND_REFERENCE))
349 {
350 pageTitle = displayName();
351 }
352 else
353 {
354 pageTitle = theTranslator->trModuleReference(displayName());
355 }
356 startFile(ol,getOutputFileBase(),name(),pageTitle,HighlightedItem::ModuleVisible,false,QCString(),0);
357
358 // ---- title part
359 ol.startHeaderSection();
360 bool writeOutlinePanel = generateTreeView && Config_getBool(PAGE_OUTLINE_PANEL);
361 if (!writeOutlinePanel) writeSummaryLinks(ol);
362 ol.startTitleHead(getOutputFileBase());
363
364 ol.pushGeneratorState();
365 ol.disable(OutputType::Man);
366 ol.parseText(pageTitle);
367 ol.popGeneratorState();
368
369 addGroupListToTitle(ol,this);
370
371 ol.pushGeneratorState();
372 ol.disable(OutputType::Man);
373 ol.endTitleHead(getOutputFileBase(),pageTitle);
374 ol.popGeneratorState();
375
376 ol.pushGeneratorState();
377 ol.disableAllBut(OutputType::Man);
378 ol.endTitleHead(getOutputFileBase(),name());
379 ol.writeString(" - ");
380 ol.parseText(pageTitle);
381 ol.popGeneratorState();
382
383 ol.endHeaderSection();
384 ol.startContents();
385
386 //---------------------------------------- start flexible part -------------------------------
387 for (const auto &lde : LayoutDocManager::instance().docEntries(LayoutDocManager::Module))
388 {
389 const LayoutDocEntrySection *ls = dynamic_cast<const LayoutDocEntrySection*>(lde.get());
390 switch (lde->kind())
391 {
392 case LayoutDocEntry::BriefDesc:
393 writeBriefDescription(ol);
394 break;
395 case LayoutDocEntry::MemberDeclStart:
396 startMemberDeclarations(ol);
397 break;
398 case LayoutDocEntry::ModuleClasses:
399 if (ls) writeClassDeclarations(ol,ls->title(lang));
400 break;
401 case LayoutDocEntry::ModuleConcepts:
402 if (ls) writeConcepts(ol,ls->title(lang));
403 break;
404 case LayoutDocEntry::ModuleExports:
405 if (ls) writeExports(ol,ls->title(lang));
406 break;
407 case LayoutDocEntry::ModuleUsedFiles:
408 if (ls) writeFiles(ol,ls->title(lang));
409 break;
410 case LayoutDocEntry::MemberGroups:
411 writeMemberGroups(ol);
412 break;
413 case LayoutDocEntry::MemberDecl:
414 {
415 const LayoutDocEntryMemberDecl *lmd = dynamic_cast<const LayoutDocEntryMemberDecl*>(lde.get());
416 if (lmd) writeMemberDeclarations(ol,lmd->type,lmd->title(lang));
417 }
418 break;
419 case LayoutDocEntry::MemberDeclEnd:
420 endMemberDeclarations(ol);
421 break;
422 case LayoutDocEntry::DetailedDesc:
423 if (ls) writeDetailedDescription(ol,ls->title(lang));
424 break;
425 case LayoutDocEntry::MemberDefStart:
426 startMemberDocumentation(ol);
427 break;
428 case LayoutDocEntry::MemberDef:
429 {
430 const LayoutDocEntryMemberDef *lmd = dynamic_cast<const LayoutDocEntryMemberDef*>(lde.get());
431 if (lmd) writeMemberDocumentation(ol,lmd->type,lmd->title(lang));
432 }
433 break;
434 case LayoutDocEntry::MemberDefEnd:
435 endMemberDocumentation(ol);
436 break;
437 case LayoutDocEntry::AuthorSection:
438 writeAuthorSection(ol);
439 break;
440 case LayoutDocEntry::ClassIncludes:
441 case LayoutDocEntry::ClassInheritanceGraph:
442 case LayoutDocEntry::ClassNestedClasses:
443 case LayoutDocEntry::ClassCollaborationGraph:
444 case LayoutDocEntry::ClassAllMembersLink:
445 case LayoutDocEntry::ClassUsedFiles:
446 case LayoutDocEntry::ClassInlineClasses:
447 case LayoutDocEntry::FileClasses:
448 case LayoutDocEntry::FileConcepts:
449 case LayoutDocEntry::FileInterfaces:
450 case LayoutDocEntry::FileStructs:
451 case LayoutDocEntry::FileExceptions:
452 case LayoutDocEntry::FileNamespaces:
453 case LayoutDocEntry::FileConstantGroups:
454 case LayoutDocEntry::FileIncludes:
455 case LayoutDocEntry::FileIncludeGraph:
456 case LayoutDocEntry::FileIncludedByGraph:
457 case LayoutDocEntry::FileInlineClasses:
458 case LayoutDocEntry::FileSourceLink:
459 case LayoutDocEntry::NamespaceNestedNamespaces:
460 case LayoutDocEntry::NamespaceNestedConstantGroups:
461 case LayoutDocEntry::NamespaceClasses:
462 case LayoutDocEntry::NamespaceConcepts:
463 case LayoutDocEntry::NamespaceInterfaces:
464 case LayoutDocEntry::NamespaceStructs:
465 case LayoutDocEntry::NamespaceExceptions:
466 case LayoutDocEntry::NamespaceInlineClasses:
467 case LayoutDocEntry::ConceptDefinition:
468 case LayoutDocEntry::GroupClasses:
469 case LayoutDocEntry::GroupConcepts:
470 case LayoutDocEntry::GroupModules:
471 case LayoutDocEntry::GroupInlineClasses:
472 case LayoutDocEntry::GroupNamespaces:
473 case LayoutDocEntry::GroupDirs:
474 case LayoutDocEntry::GroupNestedGroups:
475 case LayoutDocEntry::GroupFiles:
476 case LayoutDocEntry::GroupGraph:
477 case LayoutDocEntry::GroupPageDocs:
478 case LayoutDocEntry::DirSubDirs:
479 case LayoutDocEntry::DirFiles:
480 case LayoutDocEntry::DirGraph:
481 err("Internal inconsistency: member '{}' should not be part of "
482 "LayoutDocManager::Module entry list\n",lde->entryToString());
483 break;
484 }
485 }
486
487 //---------------------------------------- end flexible part -------------------------------
488 if (generateTreeView)
489 {
490 ol.pushGeneratorState();
491 ol.disableAllBut(OutputType::Html);
492 ol.endContents();
493 ol.writeString("</div><!-- doc-content -->\n");
494 writePageNavigation(ol);
495 ol.writeString("</div><!-- container -->\n");
496 ol.popGeneratorState();
497 }
498 endFile(ol,generateTreeView,true);
499
500 ol.popGeneratorState();
501}

References addGroupListToTitle, AUTO_TRACE, Config_getBool, OutputList::disable, OutputList::disableAllBut, displayName, OutputList::endContents, endFile, OutputList::endHeaderSection, endMemberDeclarations, endMemberDocumentation, OutputList::endTitleHead, err, DefinitionMixin< ModuleDef >::getDefFileName, DefinitionMixin< ModuleDef >::getLanguage, getOutputFileBase, Html, LayoutDocManager::instance, DefinitionMixin< ModuleDef >::isReference, Man, ModuleVisible, DefinitionMixin< ModuleDef >::name, OutputList::parseText, OutputList::popGeneratorState, OutputList::pushGeneratorState, OutputList::startContents, startFile, OutputList::startHeaderSection, startMemberDeclarations, startMemberDocumentation, OutputList::startTitleHead, theTranslator, LayoutDocEntryMemberDecl::title, LayoutDocEntryMemberDef::title, LayoutDocEntrySection::title, LayoutDocEntryMemberDecl::type, LayoutDocEntryMemberDef::type, writeAuthorSection, writeBriefDescription, writeClassDeclarations, writeConcepts, writeDetailedDescription, writeExports, writeFiles, writeMemberDeclarations, writeMemberDocumentation, writeMemberGroups, writePageNavigation, OutputList::writeString and writeSummaryLinks.

writeExports()​

void ModuleDefImpl::writeExports (OutputList & ol, const QCString & title)

Definition at line 90 of file moduledef.cpp.

912void ModuleDefImpl::writeExports(OutputList &ol,const QCString &title)
913{
914 AUTO_TRACE("name={} count={}",name(),m_exportedModules.size());
915 if (!m_exportedModules.empty())
916 {
917 ol.startMemberHeader("exports");
918 ol.parseText(title);
919 ol.endMemberHeader();
920 ol.startMemberList();
921 for (const auto &[moduleName,importInfoList] : m_exportedModules)
922 {
923 for (const auto &importInfo : importInfoList)
924 {
925 ModuleDef *mod = ModuleManager::instance().getPrimaryInterface(importInfo.importName);
926 ol.startMemberDeclaration();
927 ol.startMemberItem(importInfo.importName,OutputGenerator::MemberItemType::Normal);
928 ol.docify(theTranslator->trModule(FALSE,TRUE)+" ");
929 ol.insertMemberAlign();
930 if (mod && mod->isLinkable())
931 {
932 ol.writeObjectLink(mod->getReference(),mod->getOutputFileBase(),QCString(),mod->displayName());
933 }
934 else
935 {
936 ol.startBold();
937 ol.docify(importInfo.importName);
938 ol.endBold();
939 }
940 ol.endMemberItem(OutputGenerator::MemberItemType::Normal);
941 if (mod && !mod->briefDescription().isEmpty() && Config_getBool(BRIEF_MEMBER_DESC))
942 {
943 ol.startMemberDescription(mod->getOutputFileBase());
944 ol.generateDoc(briefFile(),briefLine(),mod,nullptr,mod->briefDescription(),FALSE,FALSE,
945 QCString(),TRUE,FALSE);
946 ol.endMemberDescription();
947 }
948 ol.endMemberDeclaration(QCString(),QCString());
949 }
950 }
951 ol.endMemberList();
952 }
953}

References AUTO_TRACE, Definition::briefDescription, DefinitionMixin< ModuleDef >::briefFile, DefinitionMixin< ModuleDef >::briefLine, Config_getBool, Definition::displayName, OutputList::docify, OutputList::endBold, OutputList::endMemberDeclaration, OutputList::endMemberDescription, OutputList::endMemberHeader, OutputList::endMemberItem, OutputList::endMemberList, FALSE, OutputList::generateDoc, Definition::getOutputFileBase, ModuleManager::getPrimaryInterface, Definition::getReference, OutputList::insertMemberAlign, ModuleManager::instance, QCString::isEmpty, Definition::isLinkable, m_exportedModules, DefinitionMixin< ModuleDef >::name, OutputGenerator::Normal, OutputList::parseText, OutputList::startBold, OutputList::startMemberDeclaration, OutputList::startMemberDescription, OutputList::startMemberHeader, OutputList::startMemberItem, OutputList::startMemberList, theTranslator, TRUE and OutputList::writeObjectLink.

Referenced by writeDocumentation.

writeFiles()​

void ModuleDefImpl::writeFiles (OutputList & ol, const QCString & title)

Definition at line 93 of file moduledef.cpp.

955void ModuleDefImpl::writeFiles(OutputList &ol,const QCString &title)
956{
957 AUTO_TRACE("{} count={}",name(),m_contributing.size());
958 if (!m_contributing.empty())
959 {
960 ol.startMemberHeader("files");
961 ol.parseText(title);
962 ol.endMemberHeader();
963 ol.startMemberList();
964 for (const auto &mod : m_contributing)
965 {
966 FileDef *fd = mod->getFileDef();
967 if (fd)
968 {
969 ol.startMemberDeclaration();
970 QCString fname = fd->displayName();
971 QCString anc = fd->anchor();
972 if (anc.isEmpty()) anc=fname; else anc.prepend(fname+"_");
973 ol.startMemberItem(anc,OutputGenerator::MemberItemType::Normal);
974 ol.docify(theTranslator->trFile(FALSE,TRUE)+" ");
975 ol.insertMemberAlign();
976 QCString path=fd->getPath();
977 if (Config_getBool(FULL_PATH_NAMES))
978 {
979 ol.docify(stripFromPath(path));
980 }
981 if (fd->isLinkable())
982 {
983 ol.writeObjectLink(fd->getReference(),fd->getOutputFileBase(),QCString(),fname);
984 }
985 else
986 {
987 ol.startBold();
988 ol.docify(fd->displayName());
989 ol.endBold();
990 }
991 ol.endMemberItem(OutputGenerator::MemberItemType::Normal);
992 if (!fd->briefDescription().isEmpty() && Config_getBool(BRIEF_MEMBER_DESC))
993 {
994 ol.startMemberDescription(fd->getOutputFileBase());
995 ol.generateDoc(briefFile(),briefLine(),fd,nullptr,fd->briefDescription(),FALSE,FALSE,
996 QCString(),TRUE,FALSE);
997 ol.endMemberDescription();
998 }
999 ol.endMemberDeclaration(QCString(),QCString());
1000 }
1001 }
1002 ol.endMemberList();
1003 }
1004}

References Definition::anchor, AUTO_TRACE, Definition::briefDescription, DefinitionMixin< ModuleDef >::briefFile, DefinitionMixin< ModuleDef >::briefLine, Config_getBool, Definition::displayName, OutputList::docify, OutputList::endBold, OutputList::endMemberDeclaration, OutputList::endMemberDescription, OutputList::endMemberHeader, OutputList::endMemberItem, OutputList::endMemberList, FALSE, OutputList::generateDoc, Definition::getOutputFileBase, FileDef::getPath, Definition::getReference, OutputList::insertMemberAlign, QCString::isEmpty, Definition::isLinkable, m_contributing, DefinitionMixin< ModuleDef >::name, OutputGenerator::Normal, OutputList::parseText, QCString::prepend, OutputList::startBold, OutputList::startMemberDeclaration, OutputList::startMemberDescription, OutputList::startMemberHeader, OutputList::startMemberItem, OutputList::startMemberList, stripFromPath, theTranslator, TRUE and OutputList::writeObjectLink.

Referenced by writeDocumentation.

writeMemberDeclarations()​

void ModuleDefImpl::writeMemberDeclarations (OutputList & ol, MemberListType lt, const QCString & title)

Definition at line 101 of file moduledef.cpp.

628void ModuleDefImpl::writeMemberDeclarations(OutputList &ol,MemberListType lt,const QCString &title)
629{
630 MemberList * ml = getMemberList(lt);
631 if (ml) ml->writeDeclarations(ol,nullptr,nullptr,nullptr,nullptr,this,title,QCString());
632}

References getMemberList and MemberList::writeDeclarations.

Referenced by writeDocumentation.

writeMemberDocumentation()​

void ModuleDefImpl::writeMemberDocumentation (OutputList & ol, MemberListType lt, const QCString & title)

Definition at line 102 of file moduledef.cpp.

634void ModuleDefImpl::writeMemberDocumentation(OutputList &ol,MemberListType lt,const QCString &title)
635{
636 MemberList * ml = getMemberList(lt);
637 if (ml) ml->writeDocumentation(ol,name(),this,title,ml->listType().toLabel());
638}

References getMemberList, MemberList::listType, DefinitionMixin< ModuleDef >::name, MemberListType::toLabel and MemberList::writeDocumentation.

Referenced by writeDocumentation.

writeMemberGroups()​

void ModuleDefImpl::writeMemberGroups (OutputList & ol)

Definition at line 100 of file moduledef.cpp.

620void ModuleDefImpl::writeMemberGroups(OutputList &ol)
621{
622 for (const auto &mg : m_memberGroups)
623 {
624 mg->writeDeclarations(ol,nullptr,nullptr,nullptr,nullptr,this);
625 }
626}

Reference m_memberGroups.

Referenced by writeDocumentation.

writePageNavigation()​

void ModuleDefImpl::writePageNavigation (OutputList & ol)
 virtual

Definition at line 70 of file moduledef.cpp.

846void ModuleDefImpl::writePageNavigation(OutputList &ol) const
847{
848 ol.writePageOutline();
849}

Reference OutputList::writePageOutline.

Referenced by writeDocumentation.

writeSummaryLinks()​

void ModuleDefImpl::writeSummaryLinks (OutputList & ol)
 virtual

Definition at line 69 of file moduledef.cpp.

798void ModuleDefImpl::writeSummaryLinks(OutputList &ol) const
799{
800 ol.pushGeneratorState();
801 ol.disableAllBut(OutputType::Html);
802 bool first=TRUE;
803 SrcLangExt lang=getLanguage();
804 for (const auto &lde : LayoutDocManager::instance().docEntries(LayoutDocManager::Module))
805 {
806 const LayoutDocEntrySection *ls = dynamic_cast<const LayoutDocEntrySection*>(lde.get());
807 if (lde->kind()==LayoutDocEntry::ModuleClasses && m_classes.declVisible() && ls)
808 {
809 QCString label = "classes";
810 ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
811 first=FALSE;
812 }
813 else if (lde->kind()==LayoutDocEntry::ModuleConcepts && m_concepts.declVisible() && ls)
814 {
815 QCString label = "concepts";
816 ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
817 first=FALSE;
818 }
819 else if (lde->kind()==LayoutDocEntry::ModuleUsedFiles && ls)
820 {
821 QCString label = "files";
822 ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
823 first=FALSE;
824 }
825 else if (lde->kind()==LayoutDocEntry::MemberDecl)
826 {
827 const LayoutDocEntryMemberDecl *lmd = dynamic_cast<const LayoutDocEntryMemberDecl*>(lde.get());
828 if (lmd)
829 {
830 MemberList * ml = getMemberList(lmd->type);
831 if (ml && ml->declVisible())
832 {
833 ol.writeSummaryLink(QCString(),ml->listType().toLabel(),lmd->title(lang),first);
834 first=FALSE;
835 }
836 }
837 }
838 }
839 if (!first)
840 {
841 ol.writeString(" </div>\n");
842 }
843 ol.popGeneratorState();
844}

References MemberList::declVisible, OutputList::disableAllBut, FALSE, DefinitionMixin< ModuleDef >::getLanguage, getMemberList, Html, LayoutDocManager::instance, MemberList::listType, m_classes, m_concepts, OutputList::popGeneratorState, OutputList::pushGeneratorState, LayoutDocEntryMemberDecl::title, LayoutDocEntrySection::title, MemberListType::toLabel, TRUE, LayoutDocEntryMemberDecl::type, OutputList::writeString and OutputList::writeSummaryLink.

Referenced by writeDocumentation.

writeTagFile()​

void ModuleDefImpl::writeTagFile (TextStream & t)
 virtual

Definition at line 87 of file moduledef.cpp.

1064void ModuleDefImpl::writeTagFile(TextStream &tagFile) const
1065{
1066 if (!isPrimaryInterface() || !isLinkableInProject()) return;
1067 tagFile << " <compound kind=\"module\">\n";
1068 tagFile << " <name>" << convertToXML(name()) << "</name>\n";
1069 const FileDef *fd = getFileDef();
1070 QCString fn = fd ? fd->getOutputFileBase() : getOutputFileBase();
1071 addHtmlExtensionIfMissing(fn);
1072 tagFile << " <filename>" << convertToXML(fn) << "</filename>\n";
1073#if 0 // at the moment we do not export the members of a module to a tag file.
1074 // We let the project using a tag file directly link to the implementation of the
1075 // symbols (which have the same scope).
1076 //
1077 // When we support linking to a module's interface instead we need to
1078 // export the module's members as well. Then we probably need a way to
1079 // disambiguate/prioritize a link to a module over a link to the implementation,
1080 // for instance by hiding non-exported symbols from the tag file.
1081 for (const auto &lde : LayoutDocManager::instance().docEntries(LayoutDocManager::Group))
1082 {
1083 switch (lde->kind())
1084 {
1085 case LayoutDocEntry::ModuleExports:
1086 {
1087 for (const auto &[modName,importInfo] : m_exportedModules)
1088 {
1089 tagFile << " <export>" << convertToXML(importInfo.importName) << "</export>\n";
1090 }
1091 }
1092 break;
1093 case LayoutDocEntry::ModuleClasses:
1094 {
1095 for (const auto &cd : m_classes)
1096 {
1097 if (cd->isLinkableInProject())
1098 {
1099 tagFile << " <class kind=\"" << cd->compoundTypeString()
1100 << "\">" << convertToXML(cd->name()) << "</class>\n";
1101 }
1102 }
1103 }
1104 break;
1105 case LayoutDocEntry::ModuleConcepts:
1106 {
1107 for (const auto &cd : m_concepts)
1108 {
1109 if (cd->isLinkableInProject())
1110 {
1111 tagFile << " <concept>" << convertToXML(cd->name())
1112 << "</concept>\n";
1113 }
1114 }
1115 }
1116 break;
1117 case LayoutDocEntry::ModuleUsedFiles:
1118 {
1119 for (const auto &usedFd : getUsedFiles())
1120 {
1121 if (usedFd->isLinkableInProject())
1122 {
1123 tagFile << " <file>" << convertToXML(usedFd->name()) << "</file>\n";
1124 }
1125 }
1126 }
1127 break;
1128 case LayoutDocEntry::MemberDecl:
1129 {
1130 const LayoutDocEntryMemberDecl *lmd = dynamic_cast<const LayoutDocEntryMemberDecl*>(lde.get());
1131 if (lmd && lmd->visible())
1132 {
1133 MemberList * ml = getMemberList(lmd->type);
1134 if (ml)
1135 {
1136 ml->writeTagFile(tagFile,true);
1137 }
1138 }
1139 }
1140 break;
1141 default:
1142 break;
1143 }
1144 }
1145#endif
1146 QCString idStr = id();
1147 if (!idStr.isEmpty())
1148 {
1149 tagFile << " <clangid>" << convertToXML(idStr) << "</clangid>\n";
1150 }
1151 writeDocAnchorsToTagFile(tagFile);
1152 tagFile << " </compound>\n";
1153}

References addHtmlExtensionIfMissing, convertToXML, getFileDef, getMemberList, Definition::getOutputFileBase, getOutputFileBase, getUsedFiles, DefinitionMixin< ModuleDef >::id, LayoutDocManager::instance, QCString::isEmpty, isLinkableInProject, isPrimaryInterface, m_classes, m_concepts, m_exportedModules, DefinitionMixin< ModuleDef >::name, LayoutDocEntryMemberDecl::type, LayoutDocEntryMemberDecl::visible, DefinitionMixin< ModuleDef >::writeDocAnchorsToTagFile and MemberList::writeTagFile.

Private Member Attributes​

m_classes​

ClassLinkedRefMap ModuleDefImpl::m_classes

Definition at line 133 of file moduledef.cpp.

133 ClassLinkedRefMap m_classes;

Referenced by addClassToModule, addConceptToModule, getClasses, mergeSymbolsFrom, sortMemberLists, writeClassDeclarations, writeSummaryLinks and writeTagFile.

m_concepts​

ConceptLinkedRefMap ModuleDefImpl::m_concepts

Definition at line 134 of file moduledef.cpp.

134 ConceptLinkedRefMap m_concepts;

Referenced by addConceptToModule, getConcepts, mergeSymbolsFrom, sortMemberLists, writeConcepts, writeSummaryLinks and writeTagFile.

m_contributing​

ModuleList ModuleDefImpl::m_contributing

Definition at line 137 of file moduledef.cpp.

137 ModuleList m_contributing;

Referenced by addContributingModule, getUsedFiles, sortMemberLists and writeFiles.

m_exportedModules​

ImportInfoMap ModuleDefImpl::m_exportedModules

Definition at line 132 of file moduledef.cpp.

132 ImportInfoMap m_exportedModules;

Referenced by addExportedModule, getExports, writeExports and writeTagFile.

m_fileDef​

FileDef* ModuleDefImpl::m_fileDef = nullptr

Definition at line 140 of file moduledef.cpp.

140 FileDef *m_fileDef = nullptr; // file holding this module

Referenced by getFileDef and setFileDef.

m_imports​

ImportInfoMap ModuleDefImpl::m_imports

Definition at line 131 of file moduledef.cpp.

131 ImportInfoMap m_imports;

Referenced by addImport and getImports.

m_memberGroups​

MemberGroupList ModuleDefImpl::m_memberGroups

Definition at line 138 of file moduledef.cpp.

138 MemberGroupList m_memberGroups;

Referenced by addListReferences, addMembersToMemberGroup, countMembers, distributeMemberGroupDocumentation, findSectionsInDocumentation, getMemberGroups and writeMemberGroups.

m_memberLists​

MemberLists ModuleDefImpl::m_memberLists

Definition at line 135 of file moduledef.cpp.

135 MemberLists m_memberLists;

Referenced by addListReferences, addMembersToMemberGroup, addMemberToList, addMemberToModule, countMembers, findSectionsInDocumentation, getMemberList, getMemberLists, mergeSymbolsFrom and sortMemberLists.

m_partitionName​

QCString ModuleDefImpl::m_partitionName

Definition at line 130 of file moduledef.cpp.

130 QCString m_partitionName;

Referenced by isPrimaryInterface, ModuleDefImpl, partitionName and qualifiedName.

m_partitions​

ModuleMap ModuleDefImpl::m_partitions

Definition at line 136 of file moduledef.cpp.

136 ModuleMap m_partitions;

Referenced by addPartition and partitions.

m_primaryInterface​

const ModuleDef* ModuleDefImpl::m_primaryInterface = nullptr

Definition at line 139 of file moduledef.cpp.

139 const ModuleDef *m_primaryInterface = nullptr;

Referenced by isLinkable, isLinkableInProject and setPrimaryInterface.

m_type​

Type ModuleDefImpl::m_type

Definition at line 129 of file moduledef.cpp.

129 Type m_type;

Referenced by isPrimaryInterface, ModuleDefImpl and moduleType.

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

Generated via doxygen2docusaurus by Doxygen 1.14.0.