Doxygen
Loading...
Searching...
No Matches
namespacedef.cpp
Go to the documentation of this file.
1/******************************************************************************
2 *
3 * Copyright (C) 1997-2015 by Dimitri van Heesch.
4 *
5 * Permission to use, copy, modify, and distribute this software and its
6 * documentation under the terms of the GNU General Public License is hereby
7 * granted. No representations are made about the suitability of this software
8 * for any purpose. It is provided "as is" without express or implied warranty.
9 * See the GNU General Public License for more details.
10 *
11 * Documents produced by Doxygen are derivative works derived from the
12 * input used in their production; they are not affected by this license.
13 *
14 */
15
16#include "namespacedef.h"
17#include "outputlist.h"
18#include "util.h"
19#include "language.h"
20#include "classdef.h"
21#include "classlist.h"
22#include "memberlist.h"
23#include "doxygen.h"
24#include "message.h"
25#include "docparser.h"
26#include "searchindex.h"
27#include "vhdldocgen.h"
28#include "layout.h"
29#include "membergroup.h"
30#include "config.h"
31#include "definitionimpl.h"
32#include "membername.h"
33#include "conceptdef.h"
34
35//------------------------------------------------------------------
36static QCString makeDisplayName(const NamespaceDef *nd,bool includeScope)
37{
38 QCString result=includeScope ? nd->name() : nd->localName();
39 SrcLangExt lang = nd->getLanguage();
41 if (sep!="::")
42 {
43 result = substitute(result,"::",sep);
44 }
45 if (nd->isAnonymous())
46 {
47 result = removeAnonymousScopes(result);
48 }
49 //printf("makeDisplayName() %s->%s lang=%d\n",qPrint(name()),qPrint(result),lang);
50 return result;
51}
52//------------------------------------------------------------------
53
54class NamespaceDefImpl : public DefinitionMixin<NamespaceDefMutable>
55{
56 public:
57 NamespaceDefImpl(const QCString &defFileName,int defLine,int defColumn,
58 const QCString &name,const QCString &ref=QCString(),
59 const QCString &refFile=QCString(),const QCString &type=QCString(),
60 bool isPublished=false);
61 ~NamespaceDefImpl() override;
63
64 DefType definitionType() const override { return TypeNamespace; }
66 { return getLanguage()==SrcLangExt::Java ? CodeSymbolType::Package : CodeSymbolType::Namespace; }
67 QCString getOutputFileBase() const override;
68 QCString anchor() const override { return QCString(); }
69 void insertUsedFile(FileDef *fd) override;
70 void writeDocumentation(OutputList &ol) override;
71 void writeMemberPages(OutputList &ol) override;
72 void writeQuickMemberLinks(OutputList &ol,const MemberDef *currentMd) const override;
73 void writeTagFile(TextStream &) override;
74 void insertClass(ClassDef *cd) override;
75 void insertConcept(ConceptDef *cd) override;
76 void insertNamespace(NamespaceDef *nd) override;
77 void insertMember(MemberDef *md) override;
78 void computeAnchors() override;
79 void countMembers() override;
80 int numDocMembers() const override;
81 void addUsingDirective(NamespaceDef *nd) override;
83 void addUsingDeclaration(const Definition *cd) override;
85 void combineUsingRelations(NamespaceDefSet &visitedNamespace) override;
86 QCString displayName(bool=TRUE) const override;
87 void setInline(bool isInline) override { m_inline = isInline; }
88 bool isConstantGroup() const override { return CONSTANT_GROUP == m_type; }
89 bool isModule() const override { return NAMESPACE == m_type || MODULE == m_type; }
90 bool isLibrary() const override { return LIBRARY == m_type; }
91 bool isInline() const override { return m_inline; }
92 bool isLinkableInProject() const override;
93 bool isLinkable() const override;
94 bool isVisibleInHierarchy() const override;
95 bool hasDetailedDescription() const override;
96 void addMembersToMemberGroup() override;
98 void findSectionsInDocumentation() override;
99 void sortMemberLists() override;
100 const Definition *findInnerCompound(const QCString &name) const override;
101 void addInnerCompound(Definition *d) override;
102 void addListReferences() override;
103 void setFileName(const QCString &fn) override;
104 bool subGrouping() const override { return m_subGrouping; }
105 MemberList *getMemberList(MemberListType lt) const override;
106 const MemberLists &getMemberLists() const override { return m_memberLists; }
107 const MemberDef *getMemberByName(const QCString &) const override;
108 const MemberGroupList &getMemberGroups() const override { return m_memberGroups; }
109 ClassLinkedRefMap getClasses() const override { return m_classes; }
110 ClassLinkedRefMap getInterfaces() const override { return m_interfaces; }
111 ClassLinkedRefMap getStructs() const override { return m_structs; }
112 ClassLinkedRefMap getExceptions() const override { return m_exceptions; }
114 ConceptLinkedRefMap getConcepts() const override { return m_concepts; }
115 void setName(const QCString &name) override;
116
117 QCString title() const override;
118 QCString compoundTypeString() const override;
119
120 void setMetaData(const QCString &m) override;
121 int countVisibleMembers() const override;
122 void writeSummaryLinks(OutputList &ol) const override;
123 void writePageNavigation(OutputList &ol) const override;
124
125 private:
134 void writeConcepts(OutputList &ol,const QCString &title);
143 void setFileNameLocal(const QCString &fn);
144
146 bool isConstantGroup=false);
147 void updateLocalName();
148
151
155
165 bool m_subGrouping = false;
167 bool m_isPublished = false;
169 bool m_inline = false;
170};
171
172std::unique_ptr<NamespaceDef> createNamespaceDef(const QCString &defFileName,int defLine,int defColumn,
173 const QCString &name,const QCString &ref,
174 const QCString &refFile,const QCString &type,
175 bool isPublished)
176{
177 //printf("createNamespaceDef(%s)\n",qPrint(name));
178 return std::make_unique<NamespaceDefImpl>(defFileName,defLine,defColumn,name,ref,refFile,type,isPublished);
179}
180
181//------------------------------------------------------------------
182
183class NamespaceDefAliasImpl : public DefinitionAliasMixin<NamespaceDef>
184{
185 public:
187 : DefinitionAliasMixin(newScope,nd) { init(); }
190
191 DefType definitionType() const override { return TypeNamespace; }
192
193 const NamespaceDef *getNSAlias() const { return toNamespaceDef(getAlias()); }
194
195 // ---- getters
197 { return getNSAlias()->codeSymbolType(); }
199 { return getNSAlias()->getOutputFileBase(); }
200 QCString anchor() const override
201 { return getNSAlias()->anchor(); }
202 int numDocMembers() const override
203 { return getNSAlias()->numDocMembers(); }
205 { return getNSAlias()->getUsedNamespaces(); }
208 QCString displayName(bool b=TRUE) const override
209 { return makeDisplayName(this,b); }
210 const QCString &localName() const override
211 { return getNSAlias()->localName(); }
212 bool isConstantGroup() const override
213 { return getNSAlias()->isConstantGroup(); }
214 bool isModule() const override
215 { return getNSAlias()->isModule(); }
216 bool isLibrary() const override
217 { return getNSAlias()->isLibrary(); }
218 bool isInline() const override
219 { return getNSAlias()->isInline(); }
220 bool isLinkableInProject() const override
221 { return getNSAlias()->isLinkableInProject(); }
222 bool isLinkable() const override
223 { return getNSAlias()->isLinkable(); }
224 bool isVisibleInHierarchy() const override
225 { return getNSAlias()->isVisibleInHierarchy(); }
226 bool hasDetailedDescription() const override
227 { return getNSAlias()->hasDetailedDescription(); }
228 const Definition *findInnerCompound(const QCString &name) const override
229 { return getNSAlias()->findInnerCompound(name); }
230 bool subGrouping() const override
231 { return getNSAlias()->subGrouping(); }
233 { return getNSAlias()->getMemberList(lt); }
234 const MemberLists &getMemberLists() const override
235 { return getNSAlias()->getMemberLists(); }
236 const MemberDef *getMemberByName(const QCString &name) const override
237 { return getNSAlias()->getMemberByName(name); }
238 const MemberGroupList &getMemberGroups() const override
239 { return getNSAlias()->getMemberGroups(); }
241 { return getNSAlias()->getClasses(); }
243 { return getNSAlias()->getInterfaces(); }
245 { return getNSAlias()->getStructs(); }
247 { return getNSAlias()->getExceptions(); }
249 { return getNSAlias()->getNamespaces(); }
251 { return getNSAlias()->getConcepts(); }
252 QCString title() const override
253 { return getNSAlias()->title(); }
255 { return getNSAlias()->compoundTypeString(); }
256 int countVisibleMembers() const override
257 { return getNSAlias()->countVisibleMembers(); }
258};
259
260std::unique_ptr<NamespaceDef> createNamespaceDefAlias(const Definition *newScope,const NamespaceDef *nd)
261{
262 auto alnd = std::make_unique<NamespaceDefAliasImpl>(newScope,nd);
263 //printf("alnd name=%s localName=%s qualifiedName=%s displayName()=%s\n",
264 // qPrint(alnd->name()),qPrint(alnd->localName()),qPrint(alnd->qualifiedName()),
265 // qPrint(alnd->displayName()));
266 return alnd;
267}
268
269//------------------------------------------------------------------
270
272 const QCString &name,const QCString &lref,
273 const QCString &fName, const QCString &type,
274 bool isPublished) :
275 DefinitionMixin(df,dl,dc,name)
276 ,m_isPublished(isPublished)
277{
278 if (!fName.isEmpty())
279 {
280 if (!lref.isEmpty())
281 {
282 fileName = stripExtension(fName);
283 }
284 else
285 {
286 fileName = convertNameToFile(stripExtension(fName));
287 }
288 }
289 else
290 {
291 setFileNameLocal(name);
292 }
293 setReference(lref);
294 m_inline=FALSE;
295 m_subGrouping=Config_getBool(SUBGROUPING);
296 if (type=="module")
297 {
298 m_type = MODULE;
299 }
300 else if (type=="constants")
301 {
302 m_type = CONSTANT_GROUP;
303 }
304 else if (type=="library")
305 {
306 m_type = LIBRARY;
307 }
308 else
309 {
310 m_type = NAMESPACE;
311 }
312
313 updateLocalName();
314}
315
317{
318 QCString locName=name();
319 int i=locName.findRev("::");
320 if (i!=-1)
321 {
322 locName=locName.mid(i+2);
323 }
324 setLocalName(locName);
325}
326
332
336
338{
339 if (isReference())
340 {
341 fileName = "namespace"+fn;
342 }
343 else
344 {
345 fileName = convertNameToFile("namespace"+fn);
346 }
347}
348
350{
352}
353
355{
356 for (const auto &mg : m_memberGroups)
357 {
358 mg->distributeMemberGroupDocumentation();
359 }
360}
361
363{
367 for (const auto &mg : m_memberGroups)
368 {
369 mg->findSectionsInDocumentation(this);
370 }
371 for (auto &ml : m_memberLists)
372 {
373 if (ml->listType().isDeclaration())
374 {
375 ml->findSectionsInDocumentation(this);
376 }
377 }
378}
379
381{
382 if (fd==nullptr) return;
383 auto it = std::find(files.begin(),files.end(),fd);
384 if (it==files.end())
385 {
386 files.push_back(fd);
387 }
388}
389
391{
392 //printf("%s:NamespaceDefImpl::addInnerCompound(%s)\n",qPrint(name()),qPrint(d->name()));
393 m_innerCompounds.add(d->localName(),d);
395 {
397 }
399 {
401 }
403 {
405 }
406}
407
409{
411
412 if (Config_getBool(OPTIMIZE_OUTPUT_SLICE))
413 {
415 {
416 d = &m_interfaces;
417 }
418 else if (cd->compoundType()==ClassDef::Struct)
419 {
420 d = &m_structs;
421 }
422 else if (cd->compoundType()==ClassDef::Exception)
423 {
424 d = &m_exceptions;
425 }
426 }
427
428 d->add(cd->name(),cd);
429}
430
432{
433 m_concepts.add(cd->name(),cd);
434}
435
440
441
443{
444 for (auto &ml : m_memberLists)
445 {
446 if (ml->listType().isDeclaration())
447 {
449 }
450 }
451
452 // add members inside sections to their groups
453 for (const auto &mg : m_memberGroups)
454 {
455 if (mg->allMembersInSameSection() && m_subGrouping)
456 {
457 //printf("----> addToDeclarationSection(%s)\n",qPrint(mg->header()));
458 mg->addToDeclarationSection();
459 }
460 }
461}
462
464{
465 //printf("%s::insertMember(%s) isInline=%d hasDocs=%d\n",qPrint(name()),qPrint(md->name()),
466 // isInline(),hasDocumentation());
467 if (md->isHidden()) return;
469
470 // if this is an inline namespace that is not documented, then insert the
471 // member in the parent scope instead
472 if (isInline() && !hasDocumentation())
473 {
474 Definition *outerScope = getOuterScope();
475 if (outerScope)
476 {
477 if (outerScope->definitionType()==Definition::TypeNamespace)
478 {
480 if (nd && nd!=Doxygen::globalScope)
481 {
482 nd->insertMember(md);
483 if (mdm)
484 {
485 mdm->setNamespace(nd);
486 }
487 }
488 }
489 else if (outerScope->definitionType()==Definition::TypeFile)
490 {
491 FileDef *fd = toFileDef(outerScope);
492 fd->insertMember(md);
493 if (mdm)
494 {
495 mdm->setFileDef(fd);
496 mdm->setOuterScope(fd);
497 }
498 }
499 }
500 }
501 else // member is a non-inline namespace or a documented inline namespace
502 {
503 MemberList *allMemberList = getMemberList(MemberListType::AllMembersList());
504 if (allMemberList==nullptr)
505 {
506 m_memberLists.emplace_back(std::make_unique<MemberList>(MemberListType::AllMembersList(),MemberListContainer::Namespace));
507 allMemberList = m_memberLists.back().get();
508 }
509 allMemberList->push_back(md);
510 //printf("%s::m_allMembersDict->append(%s)\n",qPrint(name()),qPrint(md->localName()));
511 m_allMembers.add(md->localName(),md);
512 switch(md->memberType())
513 {
515 addMemberToList(MemberListType::DecVarMembers(),md);
516 addMemberToList(MemberListType::DocVarMembers(),md);
517 break;
519 addMemberToList(MemberListType::DecFuncMembers(),md);
520 addMemberToList(MemberListType::DocFuncMembers(),md);
521 break;
523 addMemberToList(MemberListType::DecTypedefMembers(),md);
524 addMemberToList(MemberListType::DocTypedefMembers(),md);
525 break;
527 addMemberToList(MemberListType::DecSequenceMembers(),md);
528 addMemberToList(MemberListType::DocSequenceMembers(),md);
529 break;
531 addMemberToList(MemberListType::DecDictionaryMembers(),md);
532 addMemberToList(MemberListType::DocDictionaryMembers(),md);
533 break;
535 addMemberToList(MemberListType::DecEnumMembers(),md);
536 addMemberToList(MemberListType::DocEnumMembers(),md);
537 break;
539 break;
541 addMemberToList(MemberListType::DecDefineMembers(),md);
542 addMemberToList(MemberListType::DocDefineMembers(),md);
543 break;
545 if (md->getLanguage() == SrcLangExt::Python)
546 {
547 addMemberToList(MemberListType::PropertyMembers(),md);
548 addMemberToList(MemberListType::Properties(),md);
549 break;
550 }
551 // fallthrough, explicitly no break here
552 default:
553 err("NamespaceDefImpl::insertMembers(): "
554 "member '{}' with unexpected type '{}' and class scope '{}' inserted in namespace scope '{}'!\n",
555 md->name(), md->memberTypeName(), md->getClassDef() ? md->getClassDef()->name() : "", name());
556 }
557 // if this is an inline namespace, then insert an alias of this member in the outer scope.
558 if (isInline())
559 {
560 Definition *outerScope = getOuterScope();
561 if (outerScope)
562 {
563 std::unique_ptr<MemberDef> aliasMd = createMemberDefAlias(outerScope,md);
564 if (outerScope->definitionType()==Definition::TypeNamespace)
565 {
567 if (ndm)
568 {
569 ndm->insertMember(aliasMd.get());
570 }
571 }
572 else if (outerScope->definitionType()==Definition::TypeFile)
573 {
574 toFileDef(outerScope)->insertMember(aliasMd.get());
575 }
576 if (aliasMd)
577 {
579 mn->push_back(std::move(aliasMd));
580 }
581 }
582 }
583 }
584}
585
587{
588 MemberList *allMemberList = getMemberList(MemberListType::AllMembersList());
589 if (allMemberList) allMemberList->setAnchors();
590}
591
593{
594 bool repeatBrief = Config_getBool(REPEAT_BRIEF);
595 return ((!briefDescription().isEmpty() && repeatBrief) ||
596 !documentation().isEmpty());
597}
598
600{
603 tagFile << " <compound kind=\"namespace\">\n";
604 tagFile << " <name>" << convertToXML(name()) << "</name>\n";
605 tagFile << " <filename>" << fn << "</filename>\n";
606 QCString idStr = id();
607 if (!idStr.isEmpty())
608 {
609 tagFile << " <clangid>" << convertToXML(idStr) << "</clangid>\n";
610 }
611 for (const auto &lde : LayoutDocManager::instance().docEntries(LayoutDocManager::Namespace))
612 {
613 switch (lde->kind())
614 {
615 case LayoutDocEntry::NamespaceNestedNamespaces:
616 {
617 for (const auto &nd : m_namespaces)
618 {
619 if (nd->isLinkableInProject())
620 {
621 tagFile << " <namespace>" << convertToXML(nd->name()) << "</namespace>\n";
622 }
623 }
624 }
625 break;
626 case LayoutDocEntry::NamespaceClasses:
627 {
629 }
630 break;
631 case LayoutDocEntry::NamespaceInterfaces:
632 {
634 }
635 break;
636 case LayoutDocEntry::NamespaceStructs:
637 {
639 }
640 break;
641 case LayoutDocEntry::NamespaceExceptions:
642 {
644 }
645 break;
646 case LayoutDocEntry::NamespaceConcepts:
647 {
648 writeConceptsToTagFile(tagFile);
649 }
650 break;
651 case LayoutDocEntry::MemberDecl:
652 {
653 const LayoutDocEntryMemberDecl *lmd = dynamic_cast<const LayoutDocEntryMemberDecl*>(lde.get());
654 if (lmd)
655 {
656 MemberList * ml = getMemberList(lmd->type);
657 if (ml)
658 {
659 ml->writeTagFile(tagFile);
660 }
661 }
662 }
663 break;
664 case LayoutDocEntry::MemberGroups:
665 {
666 for (const auto &mg : m_memberGroups)
667 {
668 mg->writeTagFile(tagFile);
669 }
670 }
671 break;
672 default:
673 break;
674 }
675 }
677 tagFile << " </compound>\n";
678}
679
681{
683 {
686 ol.writeRuler();
690 ol.writeAnchor(QCString(),"details");
692 ol.startGroupHeader("details");
693 ol.parseText(title);
694 ol.endGroupHeader();
695
696 ol.startTextBlock();
697 if (!briefDescription().isEmpty() && Config_getBool(REPEAT_BRIEF))
698 {
700 briefLine(),
701 this,
702 nullptr,
704 DocOptions());
705 }
706 if (!briefDescription().isEmpty() && Config_getBool(REPEAT_BRIEF) &&
707 !documentation().isEmpty())
708 {
712 ol.enableAll();
715 ol.writeString("\n\n");
717 }
718 if (!documentation().isEmpty())
719 {
720 ol.generateDoc(docFile(),
721 docLine(),
722 this,
723 nullptr,
724 documentation()+"\n",
725 DocOptions()
726 .setIndexWords(true));
727 }
728 ol.endTextBlock();
729 }
730}
731
733{
735 {
736 auto parser { createDocParser() };
737 auto ast { validatingParseDoc(*parser.get(),
738 briefFile(),
739 briefLine(),
740 this,
741 nullptr,
743 DocOptions()
744 .setIndexWords(true)
745 .setSingleLine(true))
746 };
747 if (!ast->isEmpty())
748 {
749 ol.startParagraph();
752 ol.writeString(" - ");
754 ol.writeDoc(ast.get(),this,nullptr);
757 ol.writeString(" \n");
759
761 {
763 ol.startTextLink(getOutputFileBase(),"details");
764 ol.parseText(theTranslator->trMore());
765 ol.endTextLink();
766 }
768 ol.endParagraph();
769 }
770 }
771
772 // Write a summary of the Slice definition including metadata.
773 if (getLanguage() == SrcLangExt::Slice)
774 {
775 ol.startParagraph();
776 ol.startTypewriter();
777 if (!metaData.isEmpty())
778 {
779 ol.docify(metaData);
780 ol.lineBreak();
781 }
782 ol.docify("module ");
783 ol.docify(stripScope(name()));
784 ol.docify(" { ... }");
785 ol.endTypewriter();
786 ol.endParagraph();
787 }
788
789 ol.writeSynopsis();
790}
791
796
801
803{
804 if (Config_getBool(SEPARATE_MEMBER_PAGES))
805 {
808 }
809}
810
812{
813 if (Config_getBool(SEPARATE_MEMBER_PAGES))
814 {
817 }
818}
819
824
826{
827 m_concepts.writeDeclaration(ol,title,TRUE);
828}
829
831{
832 m_classes.writeDocumentation(ol,this);
833}
834
840
842{
843 /* write user defined member groups */
844 for (const auto &mg : m_memberGroups)
845 {
846 if (!mg->allMembersInSameSection() || !m_subGrouping)
847 {
848 mg->writeDeclarations(ol,nullptr,this,nullptr,nullptr,nullptr);
849 }
850 }
851}
852
854{
855 // write Author section (Man only)
858 ol.startGroupHeader();
859 ol.parseText(theTranslator->trAuthor(TRUE,TRUE));
860 ol.endGroupHeader();
861 ol.parseText(theTranslator->trGeneratedAutomatically(Config_getString(PROJECT_NAME)));
863}
864
866{
869 bool first=TRUE;
870 SrcLangExt lang = getLanguage();
871 for (const auto &lde : LayoutDocManager::instance().docEntries(LayoutDocManager::Namespace))
872 {
873 const LayoutDocEntrySection *ls = dynamic_cast<const LayoutDocEntrySection*>(lde.get());
874 if (lde->kind()==LayoutDocEntry::NamespaceClasses && m_classes.declVisible() && ls)
875 {
876 QCString label = "nested-classes";
877 ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
878 first=FALSE;
879 }
880 else if (lde->kind()==LayoutDocEntry::NamespaceInterfaces && m_interfaces.declVisible() && ls)
881 {
882 QCString label = "interfaces";
883 ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
884 first=FALSE;
885 }
886 else if (lde->kind()==LayoutDocEntry::NamespaceStructs && m_structs.declVisible() && ls)
887 {
888 QCString label = "structs";
889 ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
890 first=FALSE;
891 }
892 else if (lde->kind()==LayoutDocEntry::NamespaceExceptions && m_exceptions.declVisible() && ls)
893 {
894 QCString label = "exceptions";
895 ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
896 first=FALSE;
897 }
898 else if (lde->kind()==LayoutDocEntry::NamespaceNestedNamespaces && m_namespaces.declVisible(false) && ls)
899 {
900 QCString label = "namespaces";
901 ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
902 first=FALSE;
903 }
904 else if (lde->kind()==LayoutDocEntry::NamespaceNestedConstantGroups && m_namespaces.declVisible(true) && ls)
905 {
906 QCString label = "constantgroups";
907 ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
908 first=FALSE;
909 }
910 else if (lde->kind()==LayoutDocEntry::NamespaceConcepts && m_concepts.declVisible() && ls)
911 {
912 QCString label = "concepts";
913 ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
914 first=FALSE;
915 }
916 else if (lde->kind()== LayoutDocEntry::MemberDecl)
917 {
918 const LayoutDocEntryMemberDecl *lmd = dynamic_cast<const LayoutDocEntryMemberDecl*>(lde.get());
919 if (lmd)
920 {
921 MemberList * ml = getMemberList(lmd->type);
922 if (ml && ml->declVisible())
923 {
924 ol.writeSummaryLink(QCString(),ml->listType().toLabel(),lmd->title(lang),first);
925 first=FALSE;
926 }
927 }
928 }
929 }
930 if (!first)
931 {
932 ol.writeString(" </div>\n");
933 }
935}
936
941
943{
944 // UNO IDL constant groups may be published
945 if (getLanguage()==SrcLangExt::IDL && isConstantGroup() && m_isPublished)
946 {
949 ol.startLabels();
950 ol.writeLabel("published",false);
951 ol.endLabels();
953 }
954 else if (isExported())
955 {
958 ol.startLabels();
959 ol.writeLabel("export",false);
960 ol.endLabels();
962 }
963}
964
966{
967 for (const auto &cd : list)
968 {
969 if (cd->isLinkableInProject())
970 {
971 tagFile << " <class kind=\"" << cd->compoundTypeString()
972 << "\">" << convertToXML(cd->name()) << "</class>\n";
973 }
974 }
975}
976
978{
979 for (const auto &cd : m_concepts)
980 {
981 if (cd->isLinkableInProject())
982 {
983 tagFile << " <concept>" << convertToXML(cd->name()) << "</concept>\n";
984 }
985 }
986}
987
989{
990 bool generateTreeView = Config_getBool(GENERATE_TREEVIEW);
991 //bool outputJava = Config_getBool(OPTIMIZE_OUTPUT_JAVA);
992 //bool fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
993
994 QCString pageTitle = title();
995 startFile(ol,getOutputFileBase(),false,name(),pageTitle,HighlightedItem::NamespaceVisible,!generateTreeView);
996
997 if (!generateTreeView)
998 {
1000 {
1002 }
1003 ol.endQuickIndices();
1004 }
1005
1006 startTitle(ol,getOutputFileBase(),this);
1007 ol.parseText(pageTitle);
1008 addGroupListToTitle(ol,this);
1011 ol.startContents();
1012
1013 //---------------------------------------- start flexible part -------------------------------
1014
1015 SrcLangExt lang = getLanguage();
1016 for (const auto &lde : LayoutDocManager::instance().docEntries(LayoutDocManager::Namespace))
1017 {
1018 const LayoutDocEntrySection *ls = dynamic_cast<const LayoutDocEntrySection*>(lde.get());
1019 switch (lde->kind())
1020 {
1021 case LayoutDocEntry::BriefDesc:
1023 break;
1024 case LayoutDocEntry::MemberDeclStart:
1026 break;
1027 case LayoutDocEntry::NamespaceClasses:
1028 {
1029 if (ls) writeClassDeclarations(ol,ls->title(lang),m_classes);
1030 }
1031 break;
1032 case LayoutDocEntry::NamespaceInterfaces:
1033 {
1034 if (ls) writeClassDeclarations(ol,ls->title(lang),m_interfaces);
1035 }
1036 break;
1037 case LayoutDocEntry::NamespaceStructs:
1038 {
1039 if (ls) writeClassDeclarations(ol,ls->title(lang),m_structs);
1040 }
1041 break;
1042 case LayoutDocEntry::NamespaceExceptions:
1043 {
1044 if (ls) writeClassDeclarations(ol,ls->title(lang),m_exceptions);
1045 }
1046 break;
1047 case LayoutDocEntry::NamespaceConcepts:
1048 {
1049 if (ls) writeConcepts(ol,ls->title(lang));
1050 }
1051 break;
1052 case LayoutDocEntry::NamespaceNestedNamespaces:
1053 {
1054 if (ls) writeNamespaceDeclarations(ol,ls->title(lang),false);
1055 }
1056 break;
1057 case LayoutDocEntry::NamespaceNestedConstantGroups:
1058 {
1059 if (ls) writeNamespaceDeclarations(ol,ls->title(lang),true);
1060 }
1061 break;
1062 case LayoutDocEntry::MemberGroups:
1064 break;
1065 case LayoutDocEntry::MemberDecl:
1066 {
1067 const LayoutDocEntryMemberDecl *lmd = dynamic_cast<const LayoutDocEntryMemberDecl*>(lde.get());
1068 if (lmd) writeMemberDeclarations(ol,lmd->type,lmd->title(lang));
1069 }
1070 break;
1071 case LayoutDocEntry::MemberDeclEnd:
1073 break;
1074 case LayoutDocEntry::DetailedDesc:
1075 {
1076 if (ls) writeDetailedDescription(ol,ls->title(lang));
1077 }
1078 break;
1079 case LayoutDocEntry::MemberDefStart:
1081 break;
1082 case LayoutDocEntry::NamespaceInlineClasses:
1084 break;
1085 case LayoutDocEntry::MemberDef:
1086 {
1087 const LayoutDocEntryMemberDef *lmd = dynamic_cast<const LayoutDocEntryMemberDef*>(lde.get());
1088 if (lmd) writeMemberDocumentation(ol,lmd->type,lmd->title(lang));
1089 }
1090 break;
1091 case LayoutDocEntry::MemberDefEnd:
1093 break;
1094 case LayoutDocEntry::AuthorSection:
1096 break;
1097 case LayoutDocEntry::ClassIncludes:
1098 case LayoutDocEntry::ClassInheritanceGraph:
1099 case LayoutDocEntry::ClassNestedClasses:
1100 case LayoutDocEntry::ClassCollaborationGraph:
1101 case LayoutDocEntry::ClassAllMembersLink:
1102 case LayoutDocEntry::ClassUsedFiles:
1103 case LayoutDocEntry::ClassInlineClasses:
1104 case LayoutDocEntry::ConceptDefinition:
1105 case LayoutDocEntry::FileClasses:
1106 case LayoutDocEntry::FileConcepts:
1107 case LayoutDocEntry::FileInterfaces:
1108 case LayoutDocEntry::FileStructs:
1109 case LayoutDocEntry::FileExceptions:
1110 case LayoutDocEntry::FileNamespaces:
1111 case LayoutDocEntry::FileConstantGroups:
1112 case LayoutDocEntry::FileIncludes:
1113 case LayoutDocEntry::FileIncludeGraph:
1114 case LayoutDocEntry::FileIncludedByGraph:
1115 case LayoutDocEntry::FileSourceLink:
1116 case LayoutDocEntry::FileInlineClasses:
1117 case LayoutDocEntry::GroupClasses:
1118 case LayoutDocEntry::GroupConcepts:
1119 case LayoutDocEntry::GroupModules:
1120 case LayoutDocEntry::GroupInlineClasses:
1121 case LayoutDocEntry::GroupNamespaces:
1122 case LayoutDocEntry::GroupDirs:
1123 case LayoutDocEntry::GroupNestedGroups:
1124 case LayoutDocEntry::GroupFiles:
1125 case LayoutDocEntry::GroupGraph:
1126 case LayoutDocEntry::GroupPageDocs:
1127 case LayoutDocEntry::ModuleExports:
1128 case LayoutDocEntry::ModuleClasses:
1129 case LayoutDocEntry::ModuleConcepts:
1130 case LayoutDocEntry::ModuleUsedFiles:
1131 case LayoutDocEntry::DirSubDirs:
1132 case LayoutDocEntry::DirFiles:
1133 case LayoutDocEntry::DirGraph:
1134 err("Internal inconsistency: member '{}' should not be part of "
1135 "LayoutDocManager::Namespace entry list\n",lde->entryToString());
1136 break;
1137 }
1138 }
1139
1140 //---------------------------------------- end flexible part -------------------------------
1141
1142 ol.endContents();
1143
1144 endFileWithNavPath(ol,this);
1145
1146 if (Config_getBool(SEPARATE_MEMBER_PAGES))
1147 {
1148 MemberList *allMemberList = getMemberList(MemberListType::AllMembersList());
1149 if (allMemberList) allMemberList->sort();
1150 writeMemberPages(ol);
1151 }
1152}
1153
1155{
1156 ol.pushGeneratorState();
1158
1159 for (const auto &ml : m_memberLists)
1160 {
1161 if (ml->listType().isDocumentation())
1162 {
1163 ml->writeDocumentationPage(ol,displayName(),this);
1164 }
1165 }
1166 ol.popGeneratorState();
1167}
1168
1170{
1171 bool createSubDirs=Config_getBool(CREATE_SUBDIRS);
1172
1173 ol.writeString(" <div class=\"navtab\">\n");
1174 ol.writeString(" <table>\n");
1175
1176 MemberList *allMemberList = getMemberList(MemberListType::AllMembersList());
1177 if (allMemberList)
1178 {
1179 for (const auto &md : *allMemberList)
1180 {
1181 if (md->getNamespaceDef()==this && md->isLinkable() && !md->isEnumValue())
1182 {
1183 if (md->isLinkableInProject())
1184 {
1185 QCString fn = md->getOutputFileBase();
1187 if (md==currentMd) // selected item => highlight
1188 {
1189 ol.writeString(" <tr><td class=\"navtabHL\">");
1190 }
1191 else
1192 {
1193 ol.writeString(" <tr><td class=\"navtab\">");
1194 }
1195 ol.writeString("<span class=\"label\"><a ");
1196 ol.writeString("href=\"");
1197 if (createSubDirs) ol.writeString("../../");
1198 ol.writeString(fn+"#"+md->anchor());
1199 ol.writeString("\">");
1200 ol.writeString(convertToHtml(md->localName()));
1201 ol.writeString("</a></span>");
1202 ol.writeString("</td></tr>\n");
1203 }
1204 }
1205 }
1206 }
1207
1208 ol.writeString(" </table>\n");
1209 ol.writeString(" </div>\n");
1210}
1211
1213{
1214 for (auto &ml : m_memberLists)
1215 {
1216 ml->countDecMembers();
1217 ml->countDocMembers();
1218 }
1219 for (const auto &mg : m_memberGroups)
1220 {
1221 mg->countDecMembers();
1222 mg->countDocMembers();
1223 }
1224}
1225
1227{
1228 MemberList *allMemberList = getMemberList(MemberListType::AllMembersList());
1229 return (allMemberList ? allMemberList->numDocMembers() : 0) + static_cast<int>(m_innerCompounds.size());
1230}
1231
1233{
1234 m_usingDirList.add(nd->qualifiedName(),nd);
1235 //printf("%s: NamespaceDefImpl::addUsingDirective: %s:%zu\n",qPrint(name()),qPrint(nd->qualifiedName()),m_usingDirList.size());
1236}
1237
1242
1247
1249{
1250 if (n==nullptr) return nullptr;
1251 const Definition *d = m_innerCompounds.find(n);
1252 if (d==nullptr)
1253 {
1254 if (!m_usingDirList.empty())
1255 {
1256 d = m_usingDirList.find(n);
1257 }
1258 if (d==nullptr && !m_usingDeclList.empty())
1259 {
1260 d = m_usingDeclList.find(n);
1261 }
1262 }
1263 return d;
1264}
1265
1267{
1268 //bool fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
1269 {
1270 const RefItemVector &xrefItems = xrefListItems();
1271 addRefItem(xrefItems,
1272 qualifiedName(),
1273 getLanguage()==SrcLangExt::Fortran ?
1274 theTranslator->trModule(TRUE,TRUE) :
1275 theTranslator->trNamespace(TRUE,TRUE),
1277 QCString(),
1278 this
1279 );
1280 }
1281 for (const auto &mg : m_memberGroups)
1282 {
1283 mg->addListReferences(this);
1284 }
1285 for (auto &ml : m_memberLists)
1286 {
1287 if (ml->listType().isDocumentation())
1288 {
1289 ml->addListReferences(this);
1290 }
1291 }
1292}
1293
1295{
1296 return makeDisplayName(this,includeScope);
1297}
1298
1300{
1301 if (visitedNamespaces.find(this)!=visitedNamespaces.end()) return; // already processed
1302 visitedNamespaces.insert(this);
1303
1305 for (auto &nd : usingDirList)
1306 {
1308 if (ndm)
1309 {
1310 ndm->combineUsingRelations(visitedNamespaces);
1311 }
1312 }
1313
1314 for (auto &nd : usingDirList)
1315 {
1316 // add used namespaces of namespace nd to this namespace
1317 for (const auto &und : nd->getUsedNamespaces())
1318 {
1319 addUsingDirective(und);
1320 }
1321 // add used classes of namespace nd to this namespace
1322 for (const auto &ud : nd->getUsedDefinitions())
1323 {
1325 }
1326 }
1327}
1328
1330{
1331 int count=0;
1332 for (const auto &lde : LayoutDocManager::instance().docEntries(LayoutDocManager::Namespace))
1333 {
1334 if (lde->kind()==LayoutDocEntry::MemberDef)
1335 {
1336 const LayoutDocEntryMemberDef *lmd = dynamic_cast<const LayoutDocEntryMemberDef*>(lde.get());
1337 if (lmd)
1338 {
1339 MemberList *ml = getMemberList(lmd->type);
1340 if (ml)
1341 {
1342 for (const auto &md : *ml)
1343 {
1344 if (md->visibleInIndex())
1345 {
1346 count++;
1347 }
1348 }
1349 }
1350 }
1351 }
1352 }
1353 return count;
1354}
1355
1356
1357
1358//-------------------------------------------------------------------------------
1359
1360bool NamespaceLinkedRefMap::declVisible(bool isConstantGroup) const
1361{
1362 bool found=false;
1363 for (const auto &nd : *this)
1364 {
1365 if (nd->isLinkable() && nd->hasDocumentation())
1366 {
1367 SrcLangExt lang = nd->getLanguage();
1368 if (SrcLangExt::IDL==lang)
1369 {
1370 if (isConstantGroup == nd->isConstantGroup())
1371 {
1372 found=true;
1373 break;
1374 }
1375 }
1376 else if (!isConstantGroup) // ensure we only get extra section in IDL
1377 {
1378 if (nd->isConstantGroup())
1379 {
1380 err("Internal inconsistency: constant group but not IDL?\n");
1381 }
1382 found=true;
1383 break;
1384 }
1385 }
1386 }
1387 return found;
1388}
1389
1391 bool const isConstantGroup,bool localName)
1392{
1393
1394
1395 if (empty()) return; // no namespaces in the list
1396
1397 if (Config_getBool(OPTIMIZE_OUTPUT_VHDL)) return;
1398
1399 if (!declVisible(isConstantGroup)) return;
1400
1401 // write list of namespaces
1402 ol.startMemberHeader(isConstantGroup ? "constantgroups" : "namespaces");
1403 //bool javaOpt = Config_getBool(OPTIMIZE_OUTPUT_JAVA);
1404 //bool fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
1405 ol.parseText(title);
1406 ol.endMemberHeader();
1407 ol.startMemberList();
1408 for (const auto &nd : *this)
1409 {
1410 if (nd->isLinkable() && nd->hasDocumentation())
1411 {
1412 SrcLangExt lang = nd->getLanguage();
1413 if (lang==SrcLangExt::IDL && (isConstantGroup != nd->isConstantGroup()))
1414 continue; // will be output in another pass, see layout_default.xml
1416 QCString name = localName ? nd->localName() : nd->displayName();
1417 QCString anc = nd->anchor();
1418 if (anc.isEmpty()) anc=name; else anc.prepend(name+"_");
1420 QCString ct = nd->compoundTypeString();
1421 ol.docify(ct);
1422 ol.docify(" ");
1423 ol.insertMemberAlign();
1424 ol.writeObjectLink(nd->getReference(),nd->getOutputFileBase(),QCString(),name);
1426 if (!nd->briefDescription().isEmpty() && Config_getBool(BRIEF_MEMBER_DESC))
1427 {
1428 ol.startMemberDescription(nd->getOutputFileBase());
1429 ol.generateDoc(nd->briefFile(),
1430 nd->briefLine(),
1431 nd,
1432 nullptr,
1433 nd->briefDescription(),
1434 DocOptions()
1435 .setSingleLine(true));
1437 }
1439 }
1440 }
1441 ol.endMemberList();
1442}
1443
1444//-------------------------------------------------------------------------------
1445
1447{
1448 bool sortBriefDocs = Config_getBool(SORT_BRIEF_DOCS);
1449 bool sortMemberDocs = Config_getBool(SORT_MEMBER_DOCS);
1450 const auto &ml = m_memberLists.get(lt,MemberListContainer::Namespace);
1451 ml->setNeedsSorting(
1452 (ml->listType().isDeclaration() && sortBriefDocs) ||
1453 (ml->listType().isDocumentation() && sortMemberDocs));
1454 ml->push_back(md);
1455
1456 if (ml->listType().isDeclaration())
1457 {
1459 if (mdm)
1460 {
1461 mdm->setSectionList(this,ml.get());
1462 }
1463 }
1464}
1465
1467{
1468 for (auto &ml : m_memberLists)
1469 {
1470 if (ml->needsSorting()) { ml->sort(); ml->setNeedsSorting(FALSE); }
1471 }
1472
1473 if (Config_getBool(SORT_BRIEF_DOCS))
1474 {
1475 auto classComp = [](const ClassLinkedRefMap::Ptr &c1,const ClassLinkedRefMap::Ptr &c2)
1476 {
1477 return Config_getBool(SORT_BY_SCOPE_NAME) ?
1478 qstricmp_sort(c1->name(), c2->name())<0 :
1479 qstricmp_sort(c1->className(), c2->className())<0;
1480 };
1481
1482 std::stable_sort(m_classes.begin(), m_classes.end(), classComp);
1483 std::stable_sort(m_interfaces.begin(),m_interfaces.end(),classComp);
1484 std::stable_sort(m_structs.begin(), m_structs.end(), classComp);
1485 std::stable_sort(m_exceptions.begin(),m_exceptions.end(),classComp);
1486
1487 auto conceptComp = [](const ConceptLinkedRefMap::Ptr &c1,const ConceptLinkedRefMap::Ptr &c2)
1488 {
1489 return qstricmp_sort(c1->name(),c2->name())<0;
1490 };
1491
1492 std::stable_sort(m_concepts.begin(), m_concepts.end(), conceptComp);
1493
1494 auto namespaceComp = [](const NamespaceLinkedRefMap::Ptr &n1,const NamespaceLinkedRefMap::Ptr &n2)
1495 {
1496 return qstricmp_sort(n1->name(),n2->name())<0;
1497 };
1498
1499 std::stable_sort(m_namespaces.begin(),m_namespaces.end(),namespaceComp);
1500 }
1501
1502}
1503
1505{
1506 for (auto &ml : m_memberLists)
1507 {
1508 if (ml->listType()==lt)
1509 {
1510 return ml.get();
1511 }
1512 }
1513 return nullptr;
1514}
1515
1517{
1518 MemberList * ml = getMemberList(lt);
1519 if (ml) ml->writeDeclarations(ol,nullptr,this,nullptr,nullptr,nullptr,title,QCString());
1520}
1521
1527
1528static bool hasNonReferenceNestedNamespaceRec(const NamespaceDef *nd,int level)
1529{
1530 if (level>30)
1531 {
1532 err("Possible recursive namespace relation while inside {}\n",nd->name());
1533 return false;
1534 }
1535 bool found=nd->isLinkableInProject();
1536 if (found)
1537 {
1538 return true;
1539 }
1540 else
1541 {
1542 for (const auto &ind : nd->getNamespaces())
1543 {
1544 found = found || hasNonReferenceNestedNamespaceRec(ind,level+1);
1545 if (found) break;
1546 }
1547 }
1548 return found;
1549}
1550
1552{
1553 bool allExternals = Config_getBool(ALLEXTERNALS);
1554 return allExternals || hasNonReferenceNestedNamespaceRec(this,0) || isLinkable();
1555}
1556
1558{
1559 int i = name().findRev("::");
1560 if (i==-1) i=0; else i+=2;
1561 bool extractAnonNs = Config_getBool(EXTRACT_ANON_NSPACES);
1562 bool hideUndoc = Config_getBool(HIDE_UNDOC_NAMESPACES);
1563 if (extractAnonNs && // extract anonymous ns
1564 name().mid(i,20)=="anonymous_namespace{" // correct prefix
1565 ) // not disabled by config
1566 {
1567 return TRUE;
1568 }
1569 return !name().isEmpty() && name().at(i)!='@' && // not anonymous
1570 (hasDocumentation() || !hideUndoc || getLanguage()==SrcLangExt::CSharp) && // documented
1571 !isReference() && // not an external reference
1572 !isHidden() && // not hidden
1573 !isArtificial(); // or artificial
1574}
1575
1577{
1578 return isLinkableInProject() || isReference();
1579}
1580
1582{
1583 return m_allMembers.find(n);
1584}
1585
1587{
1588 QCString pageTitle;
1589 SrcLangExt lang = getLanguage();
1590
1591 auto getReferenceTitle = [this](std::function<QCString()> translateFunc) -> QCString
1592 {
1593 return Config_getBool(HIDE_COMPOUND_REFERENCE) ? displayName() : translateFunc();
1594 };
1595
1596 if (lang==SrcLangExt::Java)
1597 {
1598 pageTitle = theTranslator->trPackage(displayName());
1599 }
1600 else if (lang==SrcLangExt::Fortran || lang==SrcLangExt::Slice)
1601 {
1602 pageTitle = getReferenceTitle([this](){
1603 return theTranslator->trModuleReference(displayName());
1604 });
1605 }
1606 else if (lang==SrcLangExt::IDL)
1607 {
1608 pageTitle = getReferenceTitle([this](){
1609 return isConstantGroup()
1610 ? theTranslator->trConstantGroupReference(displayName())
1611 : theTranslator->trModuleReference(displayName());
1612 });
1613 }
1614 else
1615 {
1616 pageTitle = getReferenceTitle([this](){
1617 return theTranslator->trNamespaceReference(displayName());
1618 });
1619 }
1620 return pageTitle;
1621}
1622
1624{
1625 SrcLangExt lang = getLanguage();
1626 if (lang==SrcLangExt::Java)
1627 {
1628 return "package";
1629 }
1630 else if(lang==SrcLangExt::CSharp)
1631 {
1632 return "namespace";
1633 }
1634 else if (lang==SrcLangExt::Fortran)
1635 {
1636 return "module";
1637 }
1638 else if (lang==SrcLangExt::IDL)
1639 {
1640 if (isModule())
1641 {
1642 return "module";
1643 }
1644 else if (isConstantGroup())
1645 {
1646 return "constants";
1647 }
1648 else if (isLibrary())
1649 {
1650 return "library";
1651 }
1652 else
1653 {
1654 err_full(getDefFileName(),getDefLine(),"Internal inconsistency: namespace in IDL not module, library or constant group");
1655 }
1656 }
1657 return "namespace";
1658}
1659
1661{
1662 metaData = m;
1663}
1664
1665// --- Cast functions
1666//
1668{
1669 if (d && (typeid(*d)==typeid(NamespaceDefImpl) || typeid(*d)==typeid(NamespaceDefAliasImpl)))
1670 {
1671 return static_cast<NamespaceDef*>(d);
1672 }
1673 else
1674 {
1675 return nullptr;
1676 }
1677}
1678
1680{
1681 Definition *d = toDefinition(md);
1682 if (d && typeid(*d)==typeid(NamespaceDefImpl))
1683 {
1684 return static_cast<NamespaceDef*>(d);
1685 }
1686 else
1687 {
1688 return nullptr;
1689 }
1690}
1691
1692
1694{
1695 if (d && (typeid(*d)==typeid(NamespaceDefImpl) || typeid(*d)==typeid(NamespaceDefAliasImpl)))
1696 {
1697 return static_cast<const NamespaceDef*>(d);
1698 }
1699 else
1700 {
1701 return nullptr;
1702 }
1703}
1704
1706{
1707 if (d && typeid(*d)==typeid(NamespaceDefImpl))
1708 {
1709 return static_cast<NamespaceDefMutable*>(d);
1710 }
1711 else
1712 {
1713 return nullptr;
1714 }
1715}
1716
1717// --- Helpers
1718
1719static NamespaceDef *getResolvedNamespaceRec(StringSet &namespacesTried,const NamespaceAliasInfo &aliasInfo);
1720
1721static QCString replaceNamespaceAliasesRec(StringSet &namespacesTried,const QCString &name)
1722{
1723 QCString result = name;
1724 //printf("> replaceNamespaceAliasesRec(%s)\n",qPrint(name));
1725 if (namespacesTried.find(name.str())==namespacesTried.end())
1726 {
1727 namespacesTried.insert(name.str());
1728 size_t p = 0;
1729 for (;;)
1730 {
1731 size_t i = name.str().find("::",p);
1732 if (i==std::string::npos)
1733 {
1734 auto it = Doxygen::namespaceAliasMap.find(name.str());
1735 if (it != Doxygen::namespaceAliasMap.end())
1736 {
1737 //printf("found map %s->%s\n",qPrint(name),qPrint(it->second.alias));
1738 auto ns = getResolvedNamespaceRec(namespacesTried,it->second);
1739 if (ns)
1740 {
1741 result = replaceNamespaceAliasesRec(namespacesTried,ns->qualifiedName());
1742 }
1743 }
1744 break;
1745 }
1746 else
1747 {
1748 auto it = Doxygen::namespaceAliasMap.find(name.left(i).str());
1749 if (it != Doxygen::namespaceAliasMap.end())
1750 {
1751 //printf("found map %s|%s->%s\n",qPrint(name.left(i)),qPrint(name.mid(i)),qPrint(it->second.alias));
1752 auto ns = getResolvedNamespaceRec(namespacesTried,it->second);
1753 if (ns)
1754 {
1755 result = replaceNamespaceAliasesRec(namespacesTried,ns->qualifiedName()+name.mid(i));
1756 break;
1757 }
1758 }
1759 }
1760 p = i+2;
1761 }
1762 }
1763 //printf("< replaceNamespaceAliasesRec(%s)=%s\n",qPrint(name),qPrint(result));
1764 return result;
1765}
1766
1767static NamespaceDef *getResolvedNamespaceRec(StringSet &namespacesTried,const NamespaceAliasInfo &aliasInfo)
1768{
1769 size_t j = aliasInfo.context.length();
1770 for (;;)
1771 {
1772 if (j>0)
1773 {
1774 //printf("candidate %s|::%s\n",qPrint(aliasInfo.context.substr(0,j)),qPrint(aliasInfo.alias));
1775 auto candidate = replaceNamespaceAliasesRec(namespacesTried,aliasInfo.context.substr(0,j)+"::"+aliasInfo.alias);
1776 auto nd = Doxygen::namespaceLinkedMap->find(candidate);
1777 if (nd)
1778 {
1779 return nd;
1780 }
1781 }
1782 if (j>0) // strip one level from context, i.e. given N1::N2::N3
1783 // j==10 -> j==6 (N1::N2::N3->N1::N2), and then
1784 // j==6 -> j==2 (N1::N2->N1), and then
1785 // j==2 -> j==std::string::npos (N1->"")
1786 {
1787 j = aliasInfo.context.rfind("::",j-1);
1788 }
1789 else
1790 {
1791 j = std::string::npos;
1792 }
1793 if (j==std::string::npos)
1794 {
1795 //printf("candidate %s\n",qPrint(aliasInfo.alias));
1796 auto candidate = replaceNamespaceAliasesRec(namespacesTried,aliasInfo.alias);
1797 auto nd = Doxygen::namespaceLinkedMap->find(candidate);
1798 if (nd)
1799 {
1800 return nd;
1801 }
1802 break;
1803 }
1804 }
1805 return nullptr;
1806}
1807
1809{
1810 //printf("> replaceNamespaceAliases(%s)\n",qPrint(name));
1811 StringSet namespacesTried;
1812 name = replaceNamespaceAliasesRec(namespacesTried,name);
1813 //printf("< replaceNamespaceAliases: result=%s\n",qPrint(name));
1814}
1815
1817{
1818 //printf("> getResolvedNamespace(%s)\n",qPrint(name));
1819 if (name.isEmpty()) return nullptr;
1820 StringSet namespacesTried;
1821 auto ns = getResolvedNamespaceRec(namespacesTried,NamespaceAliasInfo(name.str()));
1822 //printf("< getResolvedNamespace(%s)=%s\n",qPrint(name),ns?qPrint(ns->qualifiedName()):"nullptr");
1823 return ns;
1824}
1825
1826//--------------------------------------------------------------------------------------
1827//
1829{
1830 for (const auto &cnd : nd->getNamespaces())
1831 {
1832 if (cnd->isLinkableInProject() && !cnd->isAnonymous())
1833 {
1834 return true;
1835 }
1836 }
1837 return false;
1838}
1839
1841{
1842 //printf(">namespaceHasNestedConcept(%s)\n",qPrint(nd->name()));
1843 for (const auto &cnd : nd->getNamespaces())
1844 {
1846 {
1847 //printf("<namespaceHasNestedConcept(%s): case1\n",qPrint(nd->name()));
1848 return true;
1849 }
1850 }
1851 for (const auto &cnd : nd->getConcepts())
1852 {
1853 //printf("candidate %s isLinkableInProject()=%d\n",qPrint(cnd->name()),cnd->isLinkableInProject());
1854 if (cnd->isLinkableInProject())
1855 {
1856 //printf("<namespaceHasNestedConcept(%s): case2\n",qPrint(nd->name()));
1857 return true;
1858 }
1859 }
1860 //printf("<namespaceHasNestedConcept(%s): case3\n",qPrint(nd->name()));
1861 return false;
1862}
1863
1865{
1866 //printf(">namespaceHasNestedClass(%s,filterClasses=%d)\n",qPrint(nd->name()),filterClasses);
1867 for (const auto &cnd : nd->getNamespaces())
1868 {
1869 if (namespaceHasNestedClass(cnd,filterClasses,ct))
1870 {
1871 //printf("<namespaceHasNestedClass(%s,filterClasses=%d): case1\n",qPrint(nd->name()),filterClasses);
1872 return true;
1873 }
1874 }
1875
1876 ClassLinkedRefMap list = nd->getClasses();
1877 if (filterClasses)
1878 {
1879 switch (ct)
1880 {
1882 list = nd->getInterfaces();
1883 break;
1884 case ClassDef::Struct:
1885 list = nd->getStructs();
1886 break;
1888 list = nd->getExceptions();
1889 break;
1890 default:
1891 break;
1892 }
1893 }
1894
1895 for (const auto &cd : list)
1896 {
1897 //printf("candidate %s isLinkableInProject()=%d\n",qPrint(cd->name()),cd->isLinkableInProject());
1898 if (cd->isLinkableInProject())
1899 {
1900 //printf("<namespaceHasNestedClass(%s,filterClasses=%d): case2\n",qPrint(nd->name()),filterClasses);
1901 return true;
1902 }
1903 }
1904 //printf("<namespaceHasNestedClass(%s,filterClasses=%d): case3\n",qPrint(nd->name()),filterClasses);
1905 return false;
1906}
1907
1908
A abstract class representing of a compound symbol.
Definition classdef.h:104
virtual QCString className() const =0
Returns the name of the class including outer classes, but not including namespaces.
CompoundType
The various compound types.
Definition classdef.h:109
@ Interface
Definition classdef.h:112
@ Exception
Definition classdef.h:115
virtual CompoundType compoundType() const =0
Returns the type of compound this is, i.e.
void writeDeclaration(OutputList &ol, const ClassDef::CompoundType *filter, const QCString &header, bool localNames) const
Definition classlist.cpp:53
const QCString & name() const override
const Definition * getAlias() const
DefinitionAliasMixin(const Definition *scope, const Definition *alias)
The common base class of all entity definitions found in the sources.
Definition definition.h:76
virtual const QCString & localName() const =0
virtual SrcLangExt getLanguage() const =0
Returns the programming language this definition was written in.
virtual bool isLinkable() const =0
virtual DefType definitionType() const =0
virtual QCString anchor() const =0
virtual bool isLinkableInProject() const =0
virtual bool isAnonymous() const =0
virtual bool isHidden() const =0
virtual const Definition * findInnerCompound(const QCString &name) const =0
virtual QCString qualifiedName() const =0
virtual CodeSymbolType codeSymbolType() const =0
virtual QCString getOutputFileBase() const =0
virtual const QCString & name() const =0
const QCString & name() const override
QCString getDefFileName() const override
void writeNavigationPath(OutputList &ol) const override
QCString briefFile() const override
QCString qualifiedName() const override
const RefItemVector & xrefListItems() const override
void setName(const QCString &name) override
QCString briefDescription(bool abbreviate=FALSE) const override
Definition * getOuterScope() const override
DefinitionMixin(const QCString &defFileName, int defLine, int defColumn, const QCString &name, const char *b=nullptr, const char *d=nullptr, bool isSymbol=TRUE)
void setLocalName(const QCString &name) override
QCString inbodyDocumentation() const override
QCString documentation() const override
void writeDocAnchorsToTagFile(TextStream &fs) const override
SrcLangExt getLanguage() const override
virtual void setOuterScope(Definition *d)=0
static NamespaceLinkedMap * namespaceLinkedMap
Definition doxygen.h:115
static bool suppressDocWarnings
Definition doxygen.h:132
static MemberNameLinkedMap * functionNameLinkedMap
Definition doxygen.h:112
static NamespaceDefMutable * globalScope
Definition doxygen.h:121
static NamespaceAliasInfoMap namespaceAliasMap
Definition doxygen.h:113
A model of a file symbol.
Definition filedef.h:99
virtual void insertMember(MemberDef *md)=0
static LayoutDocManager & instance()
Returns a reference to this singleton.
Definition layout.cpp:1437
Container class representing a vector of objects with keys.
Definition linkedmap.h:232
bool add(const char *k, T *obj)
Definition linkedmap.h:284
A model of a class/file/namespace member symbol.
Definition memberdef.h:48
virtual const ClassDef * getClassDef() const =0
virtual MemberType memberType() const =0
virtual QCString memberTypeName() const =0
virtual void setSectionList(const Definition *container, const MemberList *sl)=0
virtual void setFileDef(FileDef *fd)=0
virtual void setNamespace(NamespaceDef *nd)=0
A list of MemberDef objects as shown in documentation sections.
Definition memberlist.h:125
int numDocMembers() const
Definition memberlist.h:138
void writeDeclarations(OutputList &ol, const ClassDef *cd, const NamespaceDef *nd, const FileDef *fd, const GroupDef *gd, const ModuleDef *mod, const QCString &title, const QCString &subtitle, bool showEnumValues=FALSE, bool showInline=FALSE, const ClassDef *inheritedFrom=nullptr, MemberListType lt=MemberListType::PubMethods(), bool showSectionTitle=true) const
Writes the list of members to the output.
void writeTagFile(TextStream &, bool useQualifiedName=false, bool showNamespaceMembers=true)
MemberListType listType() const
Definition memberlist.h:130
void writeDocumentation(OutputList &ol, const QCString &scopeName, const Definition *container, const QCString &title, const QCString &anchor, bool showEnumValues=FALSE, bool showInline=FALSE) const
void setAnchors()
bool declVisible() const
Wrapper class for the MemberListType type.
Definition types.h:346
constexpr const char * toLabel() const noexcept
Definition types.h:402
void push_back(Ptr &&p)
Definition membername.h:54
void sort()
Definition memberlist.h:76
void push_back(const T &value)
Definition memberlist.h:48
ClassLinkedRefMap getInterfaces() const override
bool subGrouping() const override
ClassLinkedRefMap getExceptions() const override
const MemberDef * getMemberByName(const QCString &name) const override
QCString getOutputFileBase() const override
ClassLinkedRefMap getStructs() const override
ConceptLinkedRefMap getConcepts() const override
QCString displayName(bool b=TRUE) const override
ClassLinkedRefMap getClasses() const override
DefType definitionType() const override
bool isLinkableInProject() const override
const NamespaceDef * getNSAlias() const
QCString title() const override
QCString anchor() const override
int numDocMembers() const override
bool isLinkable() const override
const MemberGroupList & getMemberGroups() const override
const LinkedRefMap< const Definition > & getUsedDefinitions() const override
int countVisibleMembers() const override
~NamespaceDefAliasImpl() override
const QCString & localName() const override
bool isLibrary() const override
bool hasDetailedDescription() const override
bool isVisibleInHierarchy() const override
MemberList * getMemberList(MemberListType lt) const override
NamespaceDefAliasImpl(const Definition *newScope, const NamespaceDef *nd)
bool isModule() const override
QCString compoundTypeString() const override
bool isInline() const override
NamespaceLinkedRefMap getNamespaces() const override
const LinkedRefMap< NamespaceDef > & getUsedNamespaces() const override
CodeSymbolType codeSymbolType() const override
const MemberLists & getMemberLists() const override
bool isConstantGroup() const override
const Definition * findInnerCompound(const QCString &name) const override
An abstract interface of a namespace symbol.
virtual bool isLibrary() const =0
virtual MemberList * getMemberList(MemberListType lt) const =0
virtual bool isConstantGroup() const =0
virtual ConceptLinkedRefMap getConcepts() const =0
virtual ClassLinkedRefMap getStructs() const =0
virtual QCString compoundTypeString() const =0
virtual const LinkedRefMap< NamespaceDef > & getUsedNamespaces() const =0
virtual ClassLinkedRefMap getExceptions() const =0
virtual const MemberLists & getMemberLists() const =0
virtual NamespaceLinkedRefMap getNamespaces() const =0
virtual bool isModule() const =0
virtual bool subGrouping() const =0
virtual int countVisibleMembers() const =0
virtual int numDocMembers() const =0
virtual bool hasDetailedDescription() const =0
virtual bool isInline() const =0
virtual bool isVisibleInHierarchy() const =0
virtual const MemberDef * getMemberByName(const QCString &) const =0
virtual QCString title() const =0
virtual ClassLinkedRefMap getClasses() const =0
virtual ClassLinkedRefMap getInterfaces() const =0
virtual const LinkedRefMap< const Definition > & getUsedDefinitions() const =0
virtual const MemberGroupList & getMemberGroups() const =0
MemberGroupList m_memberGroups
void writeQuickMemberLinks(OutputList &ol, const MemberDef *currentMd) const override
const MemberDef * getMemberByName(const QCString &) const override
bool isConstantGroup() const override
LinkedRefMap< NamespaceDef > m_usingDirList
void addUsingDirective(NamespaceDef *nd) override
const LinkedRefMap< const Definition > & getUsedDefinitions() const override
NamespaceLinkedRefMap getNamespaces() const override
void computeAnchors() override
NamespaceLinkedRefMap m_namespaces
void writeConceptsToTagFile(TextStream &)
void writeMemberPages(OutputList &ol) override
bool isLibrary() const override
void insertNamespace(NamespaceDef *nd) override
void writeMemberGroups(OutputList &ol)
void addInnerCompound(Definition *d) override
void insertClass(ClassDef *cd) override
int countVisibleMembers() const override
bool isLinkable() const override
void insertConcept(ConceptDef *cd) override
bool isInline() const override
void addMemberToList(MemberListType lt, MemberDef *md)
void writeMemberDocumentation(OutputList &ol, MemberListType lt, const QCString &title)
MemberLinkedRefMap m_allMembers
void startMemberDeclarations(OutputList &ol)
void writeTagFile(TextStream &) override
void writeAuthorSection(OutputList &ol)
CodeSymbolType codeSymbolType() const override
ClassLinkedRefMap m_structs
void writeClassDeclarations(OutputList &ol, const QCString &title, const ClassLinkedRefMap &d)
void setFileNameLocal(const QCString &fn)
ClassLinkedRefMap getClasses() const override
MemberList * getMemberList(MemberListType lt) const override
void setFileName(const QCString &fn) override
void endMemberDocumentation(OutputList &ol)
const MemberLists & getMemberLists() const override
ClassLinkedRefMap m_interfaces
const MemberGroupList & getMemberGroups() const override
enum NamespaceDefImpl::@152056333015234071026257214045103374127312105332 m_type
void writeInlineClasses(OutputList &ol)
void writeBriefDescription(OutputList &ol)
~NamespaceDefImpl() override
void combineUsingRelations(NamespaceDefSet &visitedNamespace) override
int numDocMembers() const override
ClassLinkedRefMap m_exceptions
bool subGrouping() const override
QCString anchor() const override
bool isModule() const override
bool isVisibleInHierarchy() const override
void startMemberDocumentation(OutputList &ol)
LinkedRefMap< const Definition > m_usingDeclList
bool hasDetailedDescription() const override
ClassLinkedRefMap getInterfaces() const override
void insertUsedFile(FileDef *fd) override
NamespaceDefImpl(const QCString &defFileName, int defLine, int defColumn, const QCString &name, const QCString &ref=QCString(), const QCString &refFile=QCString(), const QCString &type=QCString(), bool isPublished=false)
QCString title() const override
void writeMemberDeclarations(OutputList &ol, MemberListType lt, const QCString &title)
QCString getOutputFileBase() const override
void endMemberDeclarations(OutputList &ol)
const LinkedRefMap< NamespaceDef > & getUsedNamespaces() const override
void addMembersToMemberGroup() override
void writeDocumentation(OutputList &ol) override
QCString displayName(bool=TRUE) const override
void findSectionsInDocumentation() override
void addUsingDeclaration(const Definition *cd) override
bool isLinkableInProject() const override
void setMetaData(const QCString &m) override
void writeConcepts(OutputList &ol, const QCString &title)
LinkedRefMap< const Definition > m_innerCompounds
ConceptLinkedRefMap getConcepts() const override
void setInline(bool isInline) override
ClassLinkedRefMap getStructs() const override
void addNamespaceAttributes(OutputList &ol)
void distributeMemberGroupDocumentation() override
const Definition * findInnerCompound(const QCString &name) const override
void writeNamespaceDeclarations(OutputList &ol, const QCString &title, bool isConstantGroup=false)
ClassLinkedRefMap m_classes
void countMembers() override
void writeDetailedDescription(OutputList &ol, const QCString &title)
MemberLists m_memberLists
void insertMember(MemberDef *md) override
ClassLinkedRefMap getExceptions() const override
void setName(const QCString &name) override
void writePageNavigation(OutputList &ol) const override
void sortMemberLists() override
void addListReferences() override
ConceptLinkedRefMap m_concepts
QCString compoundTypeString() const override
DefType definitionType() const override
void writeClassesToTagFile(TextStream &, const ClassLinkedRefMap &d)
void writeSummaryLinks(OutputList &ol) const override
virtual void insertMember(MemberDef *md)=0
virtual void combineUsingRelations(NamespaceDefSet &visitedNamespace)=0
void writeDeclaration(OutputList &ol, const QCString &title, bool isConstantGroup=false, bool localName=FALSE)
bool declVisible(bool isContantGroup) const
Class representing a list of output generators that are written to in parallel.
Definition outputlist.h:315
void writeDoc(const IDocNodeAST *ast, const Definition *ctx, const MemberDef *md, int sectionLevel=-1)
Definition outputlist.h:383
void endTextBlock(bool paraBreak=FALSE)
Definition outputlist.h:672
void writeString(const QCString &text)
Definition outputlist.h:411
void startMemberDeclaration()
Definition outputlist.h:569
void disable(OutputType o)
void writeRuler()
Definition outputlist.h:521
void startGroupHeader(const QCString &id=QCString(), int extraLevels=0)
Definition outputlist.h:453
void enable(OutputType o)
void endContents()
Definition outputlist.h:620
void endMemberDescription()
Definition outputlist.h:567
void writeObjectLink(const QCString &ref, const QCString &file, const QCString &anchor, const QCString &name)
Definition outputlist.h:439
void startMemberDescription(const QCString &anchor, const QCString &inheritId=QCString(), bool typ=false)
Definition outputlist.h:565
void docify(const QCString &s)
Definition outputlist.h:437
void generateDoc(const QCString &fileName, int startLine, const Definition *ctx, const MemberDef *md, const QCString &docStr, const DocOptions &options)
void startParagraph(const QCString &classDef=QCString())
Definition outputlist.h:407
void startTextBlock(bool dense=FALSE)
Definition outputlist.h:670
void endParagraph()
Definition outputlist.h:409
void startMemberSections()
Definition outputlist.h:461
void startMemberList()
Definition outputlist.h:481
void endTextLink()
Definition outputlist.h:444
void endMemberItem(OutputGenerator::MemberItemType type)
Definition outputlist.h:495
void endMemberList()
Definition outputlist.h:483
void writeSynopsis()
Definition outputlist.h:592
void startTypewriter()
Definition outputlist.h:449
void pushGeneratorState()
void insertMemberAlign(bool templ=FALSE)
Definition outputlist.h:517
void disableAllBut(OutputType o)
void popGeneratorState()
void writeSummaryLink(const QCString &file, const QCString &anchor, const QCString &title, bool first)
Definition outputlist.h:614
void writeAnchor(const QCString &fileName, const QCString &name)
Definition outputlist.h:523
void endGroupHeader(int extraLevels=0)
Definition outputlist.h:455
void endLabels()
Definition outputlist.h:742
void endQuickIndices()
Definition outputlist.h:604
void writePageOutline()
Definition outputlist.h:616
void writeLabel(const QCString &l, bool isLast)
Definition outputlist.h:740
void startLabels()
Definition outputlist.h:738
void startContents()
Definition outputlist.h:618
void endMemberDeclaration(const QCString &anchor, const QCString &inheritId)
Definition outputlist.h:571
void enableAll()
void endMemberHeader()
Definition outputlist.h:471
void startMemberItem(const QCString &anchor, OutputGenerator::MemberItemType type, const QCString &id=QCString())
Definition outputlist.h:493
void endTypewriter()
Definition outputlist.h:451
void lineBreak(const QCString &style=QCString())
Definition outputlist.h:559
void parseText(const QCString &textStr)
void startTextLink(const QCString &file, const QCString &anchor)
Definition outputlist.h:442
void startMemberHeader(const QCString &anchor, int typ=2)
Definition outputlist.h:469
void endMemberSections()
Definition outputlist.h:463
This is an alternative implementation of QCString.
Definition qcstring.h:101
QCString & prepend(const char *s)
Definition qcstring.h:422
QCString mid(size_t index, size_t len=static_cast< size_t >(-1)) const
Definition qcstring.h:241
char & at(size_t i)
Returns a reference to the character at index i.
Definition qcstring.h:593
bool isEmpty() const
Returns TRUE iff the string is empty.
Definition qcstring.h:163
const std::string & str() const
Definition qcstring.h:552
int findRev(char c, int index=-1, bool cs=TRUE) const
Definition qcstring.cpp:96
QCString left(size_t len) const
Definition qcstring.h:229
Text streaming class that buffers data.
Definition textstream.h:36
ClassDef * toClassDef(Definition *d)
ConceptDef * toConceptDef(Definition *d)
#define Config_getBool(name)
Definition config.h:33
#define Config_getString(name)
Definition config.h:32
#define NON_COPYABLE(cls)
Macro to help implementing the rule of 5 for a non-copyable & movable class.
Definition construct.h:37
std::set< std::string > StringSet
Definition containers.h:31
Definition * toDefinition(DefinitionMutable *dm)
DirIterator end(const DirIterator &) noexcept
Definition dir.cpp:175
void docFindSections(const QCString &input, const Definition *d, const QCString &fileName)
IDocNodeASTPtr validatingParseDoc(IDocParser &parserIntf, const QCString &fileName, int startLine, const Definition *ctx, const MemberDef *md, const QCString &input, const DocOptions &options)
IDocParserPtr createDocParser()
factory function to create a parser
Definition docparser.cpp:55
static void writeTagFile()
static void combineUsingRelations()
Definition doxygen.cpp:9198
FileDef * toFileDef(Definition *d)
Definition filedef.cpp:1956
void startTitle(OutputList &ol, const QCString &fileName, const DefinitionMutable *def)
Definition index.cpp:384
void endTitle(OutputList &ol, const QCString &fileName, const QCString &name)
Definition index.cpp:394
void startFile(OutputList &ol, const QCString &name, bool isSource, const QCString &manName, const QCString &title, HighlightedItem hli, bool additionalIndices, const QCString &altSidebarName, int hierarchyLevel, const QCString &allMembersFile)
Definition index.cpp:401
void endFileWithNavPath(OutputList &ol, const DefinitionMutable *d, bool showPageNavigation)
Definition index.cpp:448
@ NamespaceVisible
Definition index.h:92
Translator * theTranslator
Definition language.cpp:71
std::unique_ptr< MemberDef > createMemberDefAlias(const Definition *newScope, const MemberDef *aliasMd)
MemberDefMutable * toMemberDefMutable(Definition *d)
#define err(fmt,...)
Definition message.h:127
#define err_full(file, line, fmt,...)
Definition message.h:132
bool namespaceHasNestedNamespace(const NamespaceDef *nd)
void replaceNamespaceAliases(QCString &name)
bool namespaceHasNestedClass(const NamespaceDef *nd, bool filterClasses, ClassDef::CompoundType ct)
static NamespaceDef * getResolvedNamespaceRec(StringSet &namespacesTried, const NamespaceAliasInfo &aliasInfo)
std::unique_ptr< NamespaceDef > createNamespaceDefAlias(const Definition *newScope, const NamespaceDef *nd)
Factory method to create an alias of an existing namespace.
static bool hasNonReferenceNestedNamespaceRec(const NamespaceDef *nd, int level)
static QCString replaceNamespaceAliasesRec(StringSet &namespacesTried, const QCString &name)
std::unique_ptr< NamespaceDef > createNamespaceDef(const QCString &defFileName, int defLine, int defColumn, const QCString &name, const QCString &ref, const QCString &refFile, const QCString &type, bool isPublished)
Factory method to create new NamespaceDef instance.
NamespaceDef * getResolvedNamespace(const QCString &name)
static QCString makeDisplayName(const NamespaceDef *nd, bool includeScope)
NamespaceDef * toNamespaceDef(Definition *d)
NamespaceDefMutable * toNamespaceDefMutable(Definition *d)
bool namespaceHasNestedConcept(const NamespaceDef *nd)
std::unordered_set< const NamespaceDef * > NamespaceDefSet
QCString substitute(const QCString &s, const QCString &src, const QCString &dst)
substitute all occurrences of src in s by dst
Definition qcstring.cpp:482
int qstricmp_sort(const char *str1, const char *str2)
Definition qcstring.h:86
#define TRUE
Definition qcstring.h:37
#define FALSE
Definition qcstring.h:34
std::vector< RefItem * > RefItemVector
Definition reflist.h:133
Web server based search engine.
Represents of a member declaration list with configurable title and subtitle.
Definition layout.h:112
QCString title(SrcLangExt lang) const
Definition layout.cpp:1788
MemberListType type
Definition layout.h:118
Represents of a member definition list with configurable title.
Definition layout.h:132
MemberListType type
Definition layout.h:137
QCString title(SrcLangExt lang) const
Definition layout.cpp:1800
Definition layout.h:102
QCString title(SrcLangExt lang) const
Definition layout.cpp:1781
std::string context
Definition doxygen.h:78
std::string alias
Definition doxygen.h:77
CodeSymbolType
Definition types.h:481
@ Enumeration
Definition types.h:557
@ EnumValue
Definition types.h:558
@ Dictionary
Definition types.h:568
@ Sequence
Definition types.h:567
@ Variable
Definition types.h:555
@ Property
Definition types.h:563
@ Typedef
Definition types.h:556
@ Function
Definition types.h:554
SrcLangExt
Definition types.h:207
QCString convertToHtml(const QCString &s, bool keepEntities)
Definition util.cpp:3900
void addRefItem(const RefItemVector &sli, const QCString &key, const QCString &prefix, const QCString &name, const QCString &title, const QCString &args, const Definition *scope)
Definition util.cpp:4753
void addGroupListToTitle(OutputList &ol, const Definition *d)
Definition util.cpp:4840
QCString removeAnonymousScopes(const QCString &str)
Definition util.cpp:163
void createSubDirs(const Dir &d)
Definition util.cpp:3577
QCString stripScope(const QCString &name)
Definition util.cpp:3716
QCString convertNameToFile(const QCString &name, bool allowDots, bool allowUnderscore)
Definition util.cpp:3441
QCString convertToXML(const QCString &s, bool keepEntities)
Definition util.cpp:3849
QCString getLanguageSpecificSeparator(SrcLangExt lang, bool classScope)
Returns the scope separator to use given the programming language lang.
Definition util.cpp:5836
void addHtmlExtensionIfMissing(QCString &fName)
Definition util.cpp:4850
A bunch of utility functions.