Doxygen
namespacedef.cpp
浏览该文件的文档.
1 /******************************************************************************
2  *
3  *
4  *
5  * Copyright (C) 1997-2015 by Dimitri van Heesch.
6  *
7  * Permission to use, copy, modify, and distribute this software and its
8  * documentation under the terms of the GNU General Public License is hereby
9  * granted. No representations are made about the suitability of this software
10  * for any purpose. It is provided "as is" without express or implied warranty.
11  * See the GNU General Public License for more details.
12  *
13  * Documents produced by Doxygen are derivative works derived from the
14  * input used in their production; they are not affected by this license.
15  *
16  */
17 
18 #include "namespacedef.h"
19 #include "outputlist.h"
20 #include "util.h"
21 #include "language.h"
22 #include "classdef.h"
23 #include "classlist.h"
24 #include "memberlist.h"
25 #include "doxygen.h"
26 #include "message.h"
27 #include "docparser.h"
28 #include "searchindex.h"
29 #include "vhdldocgen.h"
30 #include "layout.h"
31 #include "membergroup.h"
32 #include "config.h"
33 #include "definitionimpl.h"
34 #include "membername.h"
35 #include "conceptdef.h"
36 
37 //------------------------------------------------------------------
38 static QCString makeDisplayName(const NamespaceDef *nd,bool includeScope)
39 {
40  QCString result=includeScope ? nd->name() : nd->localName();
41  SrcLangExt lang = nd->getLanguage();
42  QCString sep = getLanguageSpecificSeparator(lang);
43  if (sep!="::")
44  {
45  result = substitute(result,"::",sep);
46  }
47  //printf("makeDisplayName() %s->%s lang=%d\n",qPrint(name()),qPrint(result),lang);
48  return result;
49 }
50 //------------------------------------------------------------------
51 
52 class NamespaceDefImpl : public DefinitionMixin<NamespaceDefMutable>
53 {
54  public:
55  NamespaceDefImpl(const QCString &defFileName,int defLine,int defColumn,
56  const QCString &name,const QCString &ref=QCString(),
57  const QCString &refFile=QCString(),const QCString &type=QCString(),
58  bool isPublished=false);
59  virtual ~NamespaceDefImpl();
60  virtual DefType definitionType() const { return TypeNamespace; }
61  virtual CodeSymbolType codeSymbolType() const
62  { return getLanguage()==SrcLangExt_Java ? CodeSymbolType::Package : CodeSymbolType::Namespace; }
63  virtual QCString getOutputFileBase() const;
64  virtual QCString anchor() const { return QCString(); }
65  virtual void insertUsedFile(FileDef *fd);
66  virtual void writeDocumentation(OutputList &ol);
67  virtual void writeMemberPages(OutputList &ol);
68  virtual void writeQuickMemberLinks(OutputList &ol,const MemberDef *currentMd) const;
69  virtual void writeTagFile(TextStream &);
70  virtual void insertClass(const ClassDef *cd);
71  virtual void insertConcept(const ConceptDef *cd);
72  virtual void insertNamespace(const NamespaceDef *nd);
73  virtual void insertMember(MemberDef *md);
74  virtual void computeAnchors();
75  virtual void countMembers();
76  virtual int numDocMembers() const;
77  virtual void addUsingDirective(const NamespaceDef *nd);
78  virtual LinkedRefMap<const NamespaceDef> getUsedNamespaces() const { return m_usingDirList; }
79  virtual void addUsingDeclaration(const ClassDef *cd);
80  virtual LinkedRefMap<const ClassDef> getUsedClasses() const { return m_usingDeclList; }
81  virtual void combineUsingRelations(NamespaceDefSet &visitedNamespace);
82  virtual QCString displayName(bool=TRUE) const;
83  virtual QCString localName() const;
84  virtual void setInline(bool isInline) { m_inline = isInline; }
85  virtual bool isConstantGroup() const { return CONSTANT_GROUP == m_type; }
86  virtual bool isModule() const { return NAMESPACE == m_type || MODULE == m_type; }
87  virtual bool isLibrary() const { return LIBRARY == m_type; }
88  virtual bool isInline() const { return m_inline; }
89  virtual bool isLinkableInProject() const;
90  virtual bool isLinkable() const;
91  virtual bool hasDetailedDescription() const;
92  virtual void addMembersToMemberGroup();
93  virtual void distributeMemberGroupDocumentation();
94  virtual void findSectionsInDocumentation();
95  virtual void sortMemberLists();
96  virtual const Definition *findInnerCompound(const QCString &name) const;
97  virtual void addInnerCompound(const Definition *d);
98  virtual void addListReferences();
99  virtual void setFileName(const QCString &fn);
100  virtual bool subGrouping() const { return m_subGrouping; }
101  virtual MemberList *getMemberList(MemberListType lt) const;
102  virtual const MemberLists &getMemberLists() const { return m_memberLists; }
103  virtual const MemberDef *getMemberByName(const QCString &) const;
104  virtual const MemberGroupList &getMemberGroups() const { return m_memberGroups; }
105  virtual ClassLinkedRefMap getClasses() const { return classes; }
106  virtual ClassLinkedRefMap getInterfaces() const { return interfaces; }
107  virtual ClassLinkedRefMap getStructs() const { return structs; }
108  virtual ClassLinkedRefMap getExceptions() const { return exceptions; }
109  virtual NamespaceLinkedRefMap getNamespaces() const { return namespaces; }
110  virtual ConceptLinkedRefMap getConcepts() const { return m_concepts; }
111 
112  virtual QCString title() const;
113  virtual QCString compoundTypeString() const;
114 
115  virtual void setMetaData(const QCString &m);
116 
117  private:
118  void addMemberToList(MemberListType lt,MemberDef *md);
119  void writeMemberDeclarations(OutputList &ol,MemberListType lt,const QCString &title);
120  void writeMemberDocumentation(OutputList &ol,MemberListType lt,const QCString &title);
121  void writeDetailedDescription(OutputList &ol,const QCString &title);
122  void writeBriefDescription(OutputList &ol);
123  void startMemberDeclarations(OutputList &ol);
124  void endMemberDeclarations(OutputList &ol);
125  void writeClassDeclarations(OutputList &ol,const QCString &title,const ClassLinkedRefMap &d);
126  void writeConcepts(OutputList &ol,const QCString &title);
127  void writeInlineClasses(OutputList &ol);
128  void writeMemberGroups(OutputList &ol);
129  void writeAuthorSection(OutputList &ol);
130  void startMemberDocumentation(OutputList &ol);
131  void endMemberDocumentation(OutputList &ol);
132  void writeSummaryLinks(OutputList &ol) const;
133  void addNamespaceAttributes(OutputList &ol);
134  void writeClassesToTagFile(TextStream &,const ClassLinkedRefMap &d);
135  void writeConceptsToTagFile(TextStream &);
136 
137  void writeNamespaceDeclarations(OutputList &ol,const QCString &title,
138  bool isConstantGroup=false);
139 
140  QCString fileName;
141  FileList files;
142 
143  LinkedRefMap<const NamespaceDef> m_usingDirList;
144  LinkedRefMap<const ClassDef> m_usingDeclList;
145  LinkedRefMap<const Definition> m_innerCompounds;
146 
147  MemberLinkedRefMap m_allMembers;
148  MemberLists m_memberLists;
149  MemberGroupList m_memberGroups;
150  ClassLinkedRefMap classes;
151  ClassLinkedRefMap interfaces;
152  ClassLinkedRefMap structs;
153  ClassLinkedRefMap exceptions;
154  ConceptLinkedRefMap m_concepts;
155  NamespaceLinkedRefMap namespaces;
156  bool m_subGrouping = false;
157  enum { NAMESPACE, MODULE, CONSTANT_GROUP, LIBRARY } m_type;
158  bool m_isPublished = false;
159  QCString metaData;
160  bool m_inline = false;
161 };
162 
163 NamespaceDefMutable *createNamespaceDef(const QCString &defFileName,int defLine,int defColumn,
164  const QCString &name,const QCString &ref,
165  const QCString &refFile,const QCString &type,
166  bool isPublished)
167 {
168  return new NamespaceDefImpl(defFileName,defLine,defColumn,name,ref,refFile,type,isPublished);
169 }
170 
171 //------------------------------------------------------------------
172 
173 class NamespaceDefAliasImpl : public DefinitionAliasMixin<NamespaceDef>
174 {
175  public:
176  NamespaceDefAliasImpl(const Definition *newScope,const NamespaceDef *nd)
177  : DefinitionAliasMixin(newScope,nd) { init(); }
178  virtual ~NamespaceDefAliasImpl() { deinit(); }
179  virtual DefType definitionType() const { return TypeNamespace; }
180 
181  const NamespaceDef *getNSAlias() const { return toNamespaceDef(getAlias()); }
182 
183  // ---- getters
184  virtual CodeSymbolType codeSymbolType() const
185  { return getNSAlias()->codeSymbolType(); }
186  virtual QCString getOutputFileBase() const
187  { return getNSAlias()->getOutputFileBase(); }
188  virtual QCString anchor() const
189  { return getNSAlias()->anchor(); }
190  virtual int numDocMembers() const
191  { return getNSAlias()->numDocMembers(); }
192  virtual LinkedRefMap<const NamespaceDef> getUsedNamespaces() const
193  { return getNSAlias()->getUsedNamespaces(); }
194  virtual LinkedRefMap<const ClassDef> getUsedClasses() const
195  { return getNSAlias()->getUsedClasses(); }
196  virtual QCString displayName(bool b=TRUE) const
197  { return makeDisplayName(this,b); }
198  virtual QCString localName() const
199  { return getNSAlias()->localName(); }
200  virtual bool isConstantGroup() const
201  { return getNSAlias()->isConstantGroup(); }
202  virtual bool isModule() const
203  { return getNSAlias()->isModule(); }
204  virtual bool isLibrary() const
205  { return getNSAlias()->isLibrary(); }
206  virtual bool isInline() const
207  { return getNSAlias()->isInline(); }
208  virtual bool isLinkableInProject() const
209  { return getNSAlias()->isLinkableInProject(); }
210  virtual bool isLinkable() const
211  { return getNSAlias()->isLinkable(); }
212  virtual bool hasDetailedDescription() const
213  { return getNSAlias()->hasDetailedDescription(); }
214  virtual const Definition *findInnerCompound(const QCString &name) const
215  { return getNSAlias()->findInnerCompound(name); }
216  virtual bool subGrouping() const
217  { return getNSAlias()->subGrouping(); }
218  virtual MemberList *getMemberList(MemberListType lt) const
219  { return getNSAlias()->getMemberList(lt); }
220  virtual const MemberLists &getMemberLists() const
221  { return getNSAlias()->getMemberLists(); }
222  virtual const MemberDef *getMemberByName(const QCString &name) const
223  { return getNSAlias()->getMemberByName(name); }
224  virtual const MemberGroupList &getMemberGroups() const
225  { return getNSAlias()->getMemberGroups(); }
226  virtual ClassLinkedRefMap getClasses() const
227  { return getNSAlias()->getClasses(); }
228  virtual ClassLinkedRefMap getInterfaces() const
229  { return getNSAlias()->getInterfaces(); }
230  virtual ClassLinkedRefMap getStructs() const
231  { return getNSAlias()->getStructs(); }
232  virtual ClassLinkedRefMap getExceptions() const
233  { return getNSAlias()->getExceptions(); }
234  virtual NamespaceLinkedRefMap getNamespaces() const
235  { return getNSAlias()->getNamespaces(); }
236  virtual ConceptLinkedRefMap getConcepts() const
237  { return getNSAlias()->getConcepts(); }
238  virtual QCString title() const
239  { return getNSAlias()->title(); }
240  virtual QCString compoundTypeString() const
241  { return getNSAlias()->compoundTypeString(); }
242 };
243 
244 NamespaceDef *createNamespaceDefAlias(const Definition *newScope,const NamespaceDef *nd)
245 {
246  NamespaceDef *alnd = new NamespaceDefAliasImpl(newScope,nd);
247  //printf("alnd name=%s localName=%s qualifiedName=%s displayName()=%s\n",
248  // qPrint(alnd->name()),qPrint(alnd->localName()),qPrint(alnd->qualifiedName()),
249  // qPrint(alnd->displayName()));
250  return alnd;
251 }
252 
253 //------------------------------------------------------------------
254 
255 NamespaceDefImpl::NamespaceDefImpl(const QCString &df,int dl,int dc,
256  const QCString &name,const QCString &lref,
257  const QCString &fName, const QCString &type,
258  bool isPublished) :
259  DefinitionMixin(df,dl,dc,name)
260  ,m_isPublished(isPublished)
261 {
262  if (!fName.isEmpty())
263  {
264  if (!lref.isEmpty())
265  {
266  fileName = stripExtension(fName);
267  }
268  else
269  {
270  fileName = convertNameToFile(stripExtension(fName));
271  }
272  }
273  else
274  {
275  setFileName(name);
276  }
277  setReference(lref);
278  m_inline=FALSE;
279  m_subGrouping=Config_getBool(SUBGROUPING);
280  if (type=="module")
281  {
282  m_type = MODULE;
283  }
284  else if (type=="constants")
285  {
286  m_type = CONSTANT_GROUP;
287  }
288  else if (type=="library")
289  {
290  m_type = LIBRARY;
291  }
292  else
293  {
294  m_type = NAMESPACE;
295  }
296 }
297 
298 NamespaceDefImpl::~NamespaceDefImpl()
299 {
300 }
301 
302 void NamespaceDefImpl::setFileName(const QCString &fn)
303 {
304  if (isReference())
305  {
306  fileName = "namespace"+fn;
307  }
308  else
309  {
310  fileName = convertNameToFile("namespace"+fn);
311  }
312 }
313 
314 void NamespaceDefImpl::distributeMemberGroupDocumentation()
315 {
316  for (const auto &mg : m_memberGroups)
317  {
318  mg->distributeMemberGroupDocumentation();
319  }
320 }
321 
322 void NamespaceDefImpl::findSectionsInDocumentation()
323 {
324  docFindSections(briefDescription(),this,docFile());
325  docFindSections(documentation(),this,docFile());
326  for (const auto &mg : m_memberGroups)
327  {
328  mg->findSectionsInDocumentation(this);
329  }
330  for (auto &ml : m_memberLists)
331  {
332  if (ml->listType()&MemberListType_declarationLists)
333  {
334  ml->findSectionsInDocumentation(this);
335  }
336  }
337 }
338 
339 void NamespaceDefImpl::insertUsedFile(FileDef *fd)
340 {
341  if (fd==0) return;
342  auto it = std::find(files.begin(),files.end(),fd);
343  if (it==files.end())
344  {
345  files.push_back(fd);
346  }
347 }
348 
349 void NamespaceDefImpl::addInnerCompound(const Definition *d)
350 {
351  m_innerCompounds.add(d->localName(),d);
352  if (d->definitionType()==Definition::TypeNamespace)
353  {
354  insertNamespace(toNamespaceDef(d));
355  }
356  else if (d->definitionType()==Definition::TypeClass)
357  {
358  insertClass(toClassDef(d));
359  }
360  else if (d->definitionType()==Definition::TypeConcept)
361  {
362  insertConcept(toConceptDef(d));
363  }
364 }
365 
366 void NamespaceDefImpl::insertClass(const ClassDef *cd)
367 {
368  ClassLinkedRefMap &d = classes;
369 
370  if (Config_getBool(OPTIMIZE_OUTPUT_SLICE))
371  {
372  if (cd->compoundType()==ClassDef::Interface)
373  {
374  d = interfaces;
375  }
376  else if (cd->compoundType()==ClassDef::Struct)
377  {
378  d = structs;
379  }
380  else if (cd->compoundType()==ClassDef::Exception)
381  {
382  d = exceptions;
383  }
384  }
385 
386  d.add(cd->name(),cd);
387 }
388 
389 void NamespaceDefImpl::insertConcept(const ConceptDef *cd)
390 {
391  m_concepts.add(cd->name(),cd);
392 }
393 
394 void NamespaceDefImpl::insertNamespace(const NamespaceDef *nd)
395 {
396  namespaces.add(nd->name(),nd);
397 }
398 
399 
400 void NamespaceDefImpl::addMembersToMemberGroup()
401 {
402  for (auto &ml : m_memberLists)
403  {
404  if (ml->listType()&MemberListType_declarationLists)
405  {
406  ::addMembersToMemberGroup(ml.get(),&m_memberGroups,this);
407  }
408  }
409 
410  // add members inside sections to their groups
411  for (const auto &mg : m_memberGroups)
412  {
413  if (mg->allMembersInSameSection() && m_subGrouping)
414  {
415  //printf("----> addToDeclarationSection(%s)\n",qPrint(mg->header()));
416  mg->addToDeclarationSection();
417  }
418  }
419 }
420 
421 void NamespaceDefImpl::insertMember(MemberDef *md)
422 {
423  //printf("%s::insertMember(%s) isInline=%d hasDocs=%d\n",qPrint(name()),qPrint(md->name()),
424  // isInline(),hasDocumentation());
425  if (md->isHidden()) return;
426  MemberDefMutable *mdm = toMemberDefMutable(md);
427 
428  // if this is an inline namespace that is not documented, then insert the
429  // member in the parent scope instead
430  if (isInline() && !hasDocumentation())
431  {
432  Definition *outerScope = getOuterScope();
433  if (outerScope)
434  {
435  if (outerScope->definitionType()==Definition::TypeNamespace)
436  {
437  NamespaceDefMutable *nd = toNamespaceDefMutable(outerScope);
438  if (nd)
439  {
440  nd->insertMember(md);
441  if (mdm)
442  {
443  mdm->setNamespace(nd);
444  }
445  }
446  }
447  else if (outerScope->definitionType()==Definition::TypeFile)
448  {
449  FileDef *fd = toFileDef(outerScope);
450  fd->insertMember(md);
451  if (mdm)
452  {
453  mdm->setFileDef(fd);
454  mdm->setOuterScope(fd);
455  }
456  }
457  }
458  }
459  else // member is a non-inline namespace or a documented inline namespace
460  {
461  MemberList *allMemberList = getMemberList(MemberListType_allMembersList);
462  if (allMemberList==0)
463  {
464  m_memberLists.emplace_back(std::make_unique<MemberList>(MemberListType_allMembersList,MemberListContainer::Namespace));
465  allMemberList = m_memberLists.back().get();
466  }
467  allMemberList->push_back(md);
468  //printf("%s::m_allMembersDict->append(%s)\n",qPrint(name()),qPrint(md->localName()));
469  m_allMembers.add(md->localName(),md);
470  //::addNamespaceMemberNameToIndex(md);
471  //static bool sortBriefDocs=Config_getBool(SORT_BRIEF_DOCS);
472  switch(md->memberType())
473  {
474  case MemberType_Variable:
475  addMemberToList(MemberListType_decVarMembers,md);
476  addMemberToList(MemberListType_docVarMembers,md);
477  break;
478  case MemberType_Function:
479  addMemberToList(MemberListType_decFuncMembers,md);
480  addMemberToList(MemberListType_docFuncMembers,md);
481  break;
482  case MemberType_Typedef:
483  addMemberToList(MemberListType_decTypedefMembers,md);
484  addMemberToList(MemberListType_docTypedefMembers,md);
485  break;
486  case MemberType_Sequence:
487  addMemberToList(MemberListType_decSequenceMembers,md);
488  addMemberToList(MemberListType_docSequenceMembers,md);
489  break;
490  case MemberType_Dictionary:
491  addMemberToList(MemberListType_decDictionaryMembers,md);
492  addMemberToList(MemberListType_docDictionaryMembers,md);
493  break;
494  case MemberType_Enumeration:
495  addMemberToList(MemberListType_decEnumMembers,md);
496  addMemberToList(MemberListType_docEnumMembers,md);
497  break;
498  case MemberType_EnumValue:
499  break;
500  case MemberType_Define:
501  addMemberToList(MemberListType_decDefineMembers,md);
502  addMemberToList(MemberListType_docDefineMembers,md);
503  break;
504  default:
505  err("NamespaceDefImpl::insertMembers(): "
506  "member '%s' with class scope '%s' inserted in namespace scope '%s'!\n",
507  qPrint(md->name()),
508  md->getClassDef() ? qPrint(md->getClassDef()->name()) : "",
509  qPrint(name()));
510  }
511  // if this is an inline namespace, then insert an alias of this member in the outer scope.
512  if (isInline())
513  {
514  Definition *outerScope = getOuterScope();
515  if (outerScope)
516  {
517  std::unique_ptr<MemberDef> aliasMd;
518  if (outerScope->definitionType()==Definition::TypeNamespace)
519  {
520  aliasMd.reset(createMemberDefAlias(outerScope,md));
521  NamespaceDefMutable *ndm = toNamespaceDefMutable(outerScope);
522  if (ndm)
523  {
524  ndm->insertMember(aliasMd.get());
525  }
526  }
527  else if (outerScope->definitionType()==Definition::TypeFile)
528  {
529  aliasMd.reset(createMemberDefAlias(outerScope,md));
530  toFileDef(outerScope)->insertMember(aliasMd.get());
531  }
532  if (aliasMd)
533  {
534  MemberName *mn;
535  QCString name = md->name();
536  mn = Doxygen::functionNameLinkedMap->add(name);
537  mn->push_back(std::move(aliasMd));
538  }
539  }
540  }
541  }
542 }
543 
544 void NamespaceDefImpl::computeAnchors()
545 {
546  MemberList *allMemberList = getMemberList(MemberListType_allMembersList);
547  if (allMemberList) allMemberList->setAnchors();
548 }
549 
550 bool NamespaceDefImpl::hasDetailedDescription() const
551 {
552  static bool repeatBrief = Config_getBool(REPEAT_BRIEF);
553  return ((!briefDescription().isEmpty() && repeatBrief) ||
554  !documentation().isEmpty());
555 }
556 
557 void NamespaceDefImpl::writeTagFile(TextStream &tagFile)
558 {
559  tagFile << " <compound kind=\"namespace\">\n";
560  tagFile << " <name>" << convertToXML(name()) << "</name>\n";
561  tagFile << " <filename>" << addHtmlExtensionIfMissing(getOutputFileBase()) << "</filename>\n";
562  QCString idStr = id();
563  if (!idStr.isEmpty())
564  {
565  tagFile << " <clangid>" << convertToXML(idStr) << "</clangid>\n";
566  }
567  for (const auto &lde : LayoutDocManager::instance().docEntries(LayoutDocManager::Namespace))
568  {
569  switch (lde->kind())
570  {
571  case LayoutDocEntry::NamespaceNestedNamespaces:
572  {
573  for (const auto &nd : namespaces)
574  {
575  if (nd->isLinkableInProject())
576  {
577  tagFile << " <namespace>" << convertToXML(nd->name()) << "</namespace>\n";
578  }
579  }
580  }
581  break;
582  case LayoutDocEntry::NamespaceClasses:
583  {
584  writeClassesToTagFile(tagFile, classes);
585  }
586  break;
587  case LayoutDocEntry::NamespaceInterfaces:
588  {
589  writeClassesToTagFile(tagFile, interfaces);
590  }
591  break;
592  case LayoutDocEntry::NamespaceStructs:
593  {
594  writeClassesToTagFile(tagFile, structs);
595  }
596  break;
597  case LayoutDocEntry::NamespaceExceptions:
598  {
599  writeClassesToTagFile(tagFile, exceptions);
600  }
601  break;
602  case LayoutDocEntry::NamespaceConcepts:
603  {
604  writeConceptsToTagFile(tagFile);
605  }
606  break;
607  case LayoutDocEntry::MemberDecl:
608  {
609  const LayoutDocEntryMemberDecl *lmd = (const LayoutDocEntryMemberDecl*)lde.get();
610  MemberList * ml = getMemberList(lmd->type);
611  if (ml)
612  {
613  ml->writeTagFile(tagFile);
614  }
615  }
616  break;
617  case LayoutDocEntry::MemberGroups:
618  {
619  for (const auto &mg : m_memberGroups)
620  {
621  mg->writeTagFile(tagFile);
622  }
623  }
624  break;
625  default:
626  break;
627  }
628  }
629  writeDocAnchorsToTagFile(tagFile);
630  tagFile << " </compound>\n";
631 }
632 
633 void NamespaceDefImpl::writeDetailedDescription(OutputList &ol,const QCString &title)
634 {
635  if (hasDetailedDescription())
636  {
637  ol.pushGeneratorState();
638  ol.disable(OutputGenerator::Html);
639  ol.writeRuler();
640  ol.popGeneratorState();
641  ol.pushGeneratorState();
642  ol.disableAllBut(OutputGenerator::Html);
643  ol.writeAnchor(QCString(),"details");
644  ol.popGeneratorState();
645  ol.startGroupHeader();
646  ol.parseText(title);
647  ol.endGroupHeader();
648 
649  ol.startTextBlock();
650  if (!briefDescription().isEmpty() && Config_getBool(REPEAT_BRIEF))
651  {
652  ol.generateDoc(briefFile(),briefLine(),this,0,briefDescription(),FALSE,FALSE,
653  QCString(),FALSE,FALSE,Config_getBool(MARKDOWN_SUPPORT));
654  }
655  if (!briefDescription().isEmpty() && Config_getBool(REPEAT_BRIEF) &&
656  !documentation().isEmpty())
657  {
658  ol.pushGeneratorState();
659  ol.disable(OutputGenerator::Man);
660  ol.disable(OutputGenerator::RTF);
661  //ol.newParagraph(); // FIXME:PARA
662  ol.enableAll();
663  ol.disableAllBut(OutputGenerator::Man);
664  ol.enable(OutputGenerator::Latex);
665  ol.writeString("\n\n");
666  ol.popGeneratorState();
667  }
668  if (!documentation().isEmpty())
669  {
670  ol.generateDoc(docFile(),docLine(),this,0,documentation()+"\n",TRUE,FALSE,
671  QCString(),FALSE,FALSE,Config_getBool(MARKDOWN_SUPPORT));
672  }
673  ol.endTextBlock();
674  }
675 }
676 
677 void NamespaceDefImpl::writeBriefDescription(OutputList &ol)
678 {
679  if (hasBriefDescription())
680  {
681  std::unique_ptr<IDocParser> parser { createDocParser() };
682  std::unique_ptr<DocRoot> rootNode { validatingParseDoc(*parser.get(),
683  briefFile(),briefLine(),this,0,
684  briefDescription(),TRUE,FALSE,
685  QCString(),TRUE,FALSE,Config_getBool(MARKDOWN_SUPPORT)) };
686  if (rootNode && !rootNode->isEmpty())
687  {
688  ol.startParagraph();
689  ol.pushGeneratorState();
690  ol.disableAllBut(OutputGenerator::Man);
691  ol.writeString(" - ");
692  ol.popGeneratorState();
693  ol.writeDoc(rootNode.get(),this,0);
694  ol.pushGeneratorState();
695  ol.disable(OutputGenerator::RTF);
696  ol.writeString(" \n");
697  ol.enable(OutputGenerator::RTF);
698 
699  if (hasDetailedDescription())
700  {
701  ol.disableAllBut(OutputGenerator::Html);
702  ol.startTextLink(getOutputFileBase(),"details");
703  ol.parseText(theTranslator->trMore());
704  ol.endTextLink();
705  }
706  ol.popGeneratorState();
707  ol.endParagraph();
708  }
709 
710  // FIXME:PARA
711  //ol.pushGeneratorState();
712  //ol.disable(OutputGenerator::RTF);
713  //ol.newParagraph();
714  //ol.popGeneratorState();
715  }
716 
717  // Write a summary of the Slice definition including metadata.
718  if (getLanguage() == SrcLangExt_Slice)
719  {
720  ol.startParagraph();
721  ol.startTypewriter();
722  if (!metaData.isEmpty())
723  {
724  ol.docify(metaData);
725  ol.lineBreak();
726  }
727  ol.docify("module ");
728  ol.docify(stripScope(name()));
729  ol.docify(" { ... }");
730  ol.endTypewriter();
731  ol.endParagraph();
732  }
733 
734  ol.writeSynopsis();
735 }
736 
737 void NamespaceDefImpl::startMemberDeclarations(OutputList &ol)
738 {
739  ol.startMemberSections();
740 }
741 
742 void NamespaceDefImpl::endMemberDeclarations(OutputList &ol)
743 {
744  ol.endMemberSections();
745 }
746 
747 void NamespaceDefImpl::startMemberDocumentation(OutputList &ol)
748 {
749  if (Config_getBool(SEPARATE_MEMBER_PAGES))
750  {
751  ol.disable(OutputGenerator::Html);
752  Doxygen::suppressDocWarnings = TRUE;
753  }
754 }
755 
756 void NamespaceDefImpl::endMemberDocumentation(OutputList &ol)
757 {
758  if (Config_getBool(SEPARATE_MEMBER_PAGES))
759  {
760  ol.enable(OutputGenerator::Html);
761  Doxygen::suppressDocWarnings = FALSE;
762  }
763 }
764 
765 void NamespaceDefImpl::writeClassDeclarations(OutputList &ol,const QCString &title,const ClassLinkedRefMap &d)
766 {
767  d.writeDeclaration(ol,0,title,TRUE);
768 }
769 
770 void NamespaceDefImpl::writeConcepts(OutputList &ol,const QCString &title)
771 {
772  m_concepts.writeDeclaration(ol,title,TRUE);
773 }
774 
775 void NamespaceDefImpl::writeInlineClasses(OutputList &ol)
776 {
777  classes.writeDocumentation(ol,this);
778 }
779 
780 void NamespaceDefImpl::writeNamespaceDeclarations(OutputList &ol,const QCString &title,
781  bool const isConstantGroup)
782 {
783  namespaces.writeDeclaration(ol,title,isConstantGroup,TRUE);
784 }
785 
786 void NamespaceDefImpl::writeMemberGroups(OutputList &ol)
787 {
788  /* write user defined member groups */
789  for (const auto &mg : m_memberGroups)
790  {
791  if ((!mg->allMembersInSameSection() || !m_subGrouping)
792  && mg->header()!="[NOHEADER]")
793  {
794  mg->writeDeclarations(ol,0,this,0,0);
795  }
796  }
797 }
798 
799 void NamespaceDefImpl::writeAuthorSection(OutputList &ol)
800 {
801  // write Author section (Man only)
802  ol.pushGeneratorState();
803  ol.disableAllBut(OutputGenerator::Man);
804  ol.startGroupHeader();
805  ol.parseText(theTranslator->trAuthor(TRUE,TRUE));
806  ol.endGroupHeader();
807  ol.parseText(theTranslator->trGeneratedAutomatically(Config_getString(PROJECT_NAME)));
808  ol.popGeneratorState();
809 }
810 
811 void NamespaceDefImpl::writeSummaryLinks(OutputList &ol) const
812 {
813  ol.pushGeneratorState();
814  ol.disableAllBut(OutputGenerator::Html);
815  bool first=TRUE;
816  SrcLangExt lang = getLanguage();
817  for (const auto &lde : LayoutDocManager::instance().docEntries(LayoutDocManager::Namespace))
818  {
819  if (lde->kind()==LayoutDocEntry::NamespaceClasses && classes.declVisible())
820  {
821  const LayoutDocEntrySection *ls = (const LayoutDocEntrySection*)lde.get();
822  QCString label = "nested-classes";
823  ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
824  first=FALSE;
825  }
826  else if (lde->kind()==LayoutDocEntry::NamespaceInterfaces && interfaces.declVisible())
827  {
828  const LayoutDocEntrySection *ls = (const LayoutDocEntrySection*)lde.get();
829  QCString label = "interfaces";
830  ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
831  first=FALSE;
832  }
833  else if (lde->kind()==LayoutDocEntry::NamespaceStructs && structs.declVisible())
834  {
835  const LayoutDocEntrySection *ls = (const LayoutDocEntrySection*)lde.get();
836  QCString label = "structs";
837  ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
838  first=FALSE;
839  }
840  else if (lde->kind()==LayoutDocEntry::NamespaceExceptions && exceptions.declVisible())
841  {
842  const LayoutDocEntrySection *ls = (const LayoutDocEntrySection*)lde.get();
843  QCString label = "exceptions";
844  ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
845  first=FALSE;
846  }
847  else if (lde->kind()==LayoutDocEntry::NamespaceNestedNamespaces && namespaces.declVisible(false))
848  {
849  const LayoutDocEntrySection *ls = (const LayoutDocEntrySection*)lde.get();
850  QCString label = "namespaces";
851  ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
852  first=FALSE;
853  }
854  else if (lde->kind()==LayoutDocEntry::NamespaceNestedConstantGroups && namespaces.declVisible(true))
855  {
856  const LayoutDocEntrySection *ls = (const LayoutDocEntrySection*)lde.get();
857  QCString label = "constantgroups";
858  ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
859  first=FALSE;
860  }
861  else if (lde->kind()==LayoutDocEntry::NamespaceConcepts && m_concepts.declVisible())
862  {
863  const LayoutDocEntrySection *ls = (const LayoutDocEntrySection*)lde.get();
864  QCString label = "concepts";
865  ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
866  first=FALSE;
867  }
868  else if (lde->kind()== LayoutDocEntry::MemberDecl)
869  {
870  const LayoutDocEntryMemberDecl *lmd = (const LayoutDocEntryMemberDecl*)lde.get();
871  MemberList * ml = getMemberList(lmd->type);
872  if (ml && ml->declVisible())
873  {
874  ol.writeSummaryLink(QCString(),MemberList::listTypeAsString(ml->listType()),lmd->title(lang),first);
875  first=FALSE;
876  }
877  }
878  }
879  if (!first)
880  {
881  ol.writeString(" </div>\n");
882  }
883  ol.popGeneratorState();
884 }
885 
886 void NamespaceDefImpl::addNamespaceAttributes(OutputList &ol)
887 {
888  // UNO IDL constant groups may be published
889  if (getLanguage()==SrcLangExt_IDL && isConstantGroup() && m_isPublished)
890  {
891  ol.pushGeneratorState();
892  ol.disableAllBut(OutputGenerator::Html);
893  ol.startLabels();
894  ol.writeLabel("published",false);
895  ol.endLabels();
896  ol.popGeneratorState();
897  }
898 }
899 
900 void NamespaceDefImpl::writeClassesToTagFile(TextStream &tagFile,const ClassLinkedRefMap &list)
901 {
902  for (const auto &cd : list)
903  {
904  if (cd->isLinkableInProject())
905  {
906  tagFile << " <class kind=\"" << cd->compoundTypeString()
907  << "\">" << convertToXML(cd->name()) << "</class>\n";
908  }
909  }
910 }
911 
912 void NamespaceDefImpl::writeConceptsToTagFile(TextStream &tagFile)
913 {
914  for (const auto &cd : m_concepts)
915  {
916  if (cd->isLinkableInProject())
917  {
918  tagFile << " <concept>" << convertToXML(cd->name()) << "</concept>\n";
919  }
920  }
921 }
922 
923 void NamespaceDefImpl::writeDocumentation(OutputList &ol)
924 {
925  static bool generateTreeView = Config_getBool(GENERATE_TREEVIEW);
926  //static bool outputJava = Config_getBool(OPTIMIZE_OUTPUT_JAVA);
927  //static bool fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
928 
929  QCString pageTitle = title();
930  startFile(ol,getOutputFileBase(),name(),pageTitle,HLI_NamespaceVisible,!generateTreeView);
931 
932  if (!generateTreeView)
933  {
934  if (getOuterScope()!=Doxygen::globalScope)
935  {
936  writeNavigationPath(ol);
937  }
938  ol.endQuickIndices();
939  }
940 
941  startTitle(ol,getOutputFileBase(),this);
942  ol.parseText(pageTitle);
943  addGroupListToTitle(ol,this);
944  addNamespaceAttributes(ol);
945  endTitle(ol,getOutputFileBase(),displayName());
946  ol.startContents();
947 
948  //if (Doxygen::searchIndex)
949  //{
950  // Doxygen::searchIndex->setCurrentDoc(this,anchor(),FALSE);
951  // Doxygen::searchIndex->addWord(localName(),TRUE);
952  //}
953  //Doxygen::indexList->addIndexItem(this,0);
954 
955  //---------------------------------------- start flexible part -------------------------------
956 
957  SrcLangExt lang = getLanguage();
958  for (const auto &lde : LayoutDocManager::instance().docEntries(LayoutDocManager::Namespace))
959  {
960  switch (lde->kind())
961  {
962  case LayoutDocEntry::BriefDesc:
963  writeBriefDescription(ol);
964  break;
965  case LayoutDocEntry::MemberDeclStart:
966  startMemberDeclarations(ol);
967  break;
968  case LayoutDocEntry::NamespaceClasses:
969  {
970  const LayoutDocEntrySection *ls = (const LayoutDocEntrySection*)lde.get();
971  writeClassDeclarations(ol,ls->title(lang),classes);
972  }
973  break;
974  case LayoutDocEntry::NamespaceInterfaces:
975  {
976  const LayoutDocEntrySection *ls = (const LayoutDocEntrySection*)lde.get();
977  writeClassDeclarations(ol,ls->title(lang),interfaces);
978  }
979  break;
980  case LayoutDocEntry::NamespaceStructs:
981  {
982  const LayoutDocEntrySection *ls = (const LayoutDocEntrySection*)lde.get();
983  writeClassDeclarations(ol,ls->title(lang),structs);
984  }
985  break;
986  case LayoutDocEntry::NamespaceExceptions:
987  {
988  const LayoutDocEntrySection *ls = (const LayoutDocEntrySection*)lde.get();
989  writeClassDeclarations(ol,ls->title(lang),exceptions);
990  }
991  break;
992  case LayoutDocEntry::NamespaceConcepts:
993  {
994  const LayoutDocEntrySection *ls = (const LayoutDocEntrySection*)lde.get();
995  writeConcepts(ol,ls->title(lang));
996  }
997  break;
998  case LayoutDocEntry::NamespaceNestedNamespaces:
999  {
1000  const LayoutDocEntrySection *ls = (const LayoutDocEntrySection*)lde.get();
1001  writeNamespaceDeclarations(ol,ls->title(lang),false);
1002  }
1003  break;
1004  case LayoutDocEntry::NamespaceNestedConstantGroups:
1005  {
1006  const LayoutDocEntrySection *ls = (const LayoutDocEntrySection*)lde.get();
1007  writeNamespaceDeclarations(ol,ls->title(lang),true);
1008  }
1009  break;
1010  case LayoutDocEntry::MemberGroups:
1011  writeMemberGroups(ol);
1012  break;
1013  case LayoutDocEntry::MemberDecl:
1014  {
1015  const LayoutDocEntryMemberDecl *lmd = (const LayoutDocEntryMemberDecl*)lde.get();
1016  writeMemberDeclarations(ol,lmd->type,lmd->title(lang));
1017  }
1018  break;
1019  case LayoutDocEntry::MemberDeclEnd:
1020  endMemberDeclarations(ol);
1021  break;
1022  case LayoutDocEntry::DetailedDesc:
1023  {
1024  const LayoutDocEntrySection *ls = (const LayoutDocEntrySection*)lde.get();
1025  writeDetailedDescription(ol,ls->title(lang));
1026  }
1027  break;
1028  case LayoutDocEntry::MemberDefStart:
1029  startMemberDocumentation(ol);
1030  break;
1031  case LayoutDocEntry::NamespaceInlineClasses:
1032  writeInlineClasses(ol);
1033  break;
1034  case LayoutDocEntry::MemberDef:
1035  {
1036  const LayoutDocEntryMemberDef *lmd = (const LayoutDocEntryMemberDef*)lde.get();
1037  writeMemberDocumentation(ol,lmd->type,lmd->title(lang));
1038  }
1039  break;
1040  case LayoutDocEntry::MemberDefEnd:
1041  endMemberDocumentation(ol);
1042  break;
1043  case LayoutDocEntry::AuthorSection:
1044  writeAuthorSection(ol);
1045  break;
1046  case LayoutDocEntry::ClassIncludes:
1047  case LayoutDocEntry::ClassInheritanceGraph:
1048  case LayoutDocEntry::ClassNestedClasses:
1049  case LayoutDocEntry::ClassCollaborationGraph:
1050  case LayoutDocEntry::ClassAllMembersLink:
1051  case LayoutDocEntry::ClassUsedFiles:
1052  case LayoutDocEntry::ClassInlineClasses:
1053  case LayoutDocEntry::ConceptDefinition:
1054  case LayoutDocEntry::FileClasses:
1055  case LayoutDocEntry::FileConcepts:
1056  case LayoutDocEntry::FileInterfaces:
1057  case LayoutDocEntry::FileStructs:
1058  case LayoutDocEntry::FileExceptions:
1059  case LayoutDocEntry::FileNamespaces:
1060  case LayoutDocEntry::FileConstantGroups:
1061  case LayoutDocEntry::FileIncludes:
1062  case LayoutDocEntry::FileIncludeGraph:
1063  case LayoutDocEntry::FileIncludedByGraph:
1064  case LayoutDocEntry::FileSourceLink:
1065  case LayoutDocEntry::FileInlineClasses:
1066  case LayoutDocEntry::GroupClasses:
1067  case LayoutDocEntry::GroupConcepts:
1068  case LayoutDocEntry::GroupInlineClasses:
1069  case LayoutDocEntry::GroupNamespaces:
1070  case LayoutDocEntry::GroupDirs:
1071  case LayoutDocEntry::GroupNestedGroups:
1072  case LayoutDocEntry::GroupFiles:
1073  case LayoutDocEntry::GroupGraph:
1074  case LayoutDocEntry::GroupPageDocs:
1075  case LayoutDocEntry::DirSubDirs:
1076  case LayoutDocEntry::DirFiles:
1077  case LayoutDocEntry::DirGraph:
1078  err("Internal inconsistency: member %d should not be part of "
1079  "LayoutDocManager::Namespace entry list\n",lde->kind());
1080  break;
1081  }
1082  }
1083 
1084  //---------------------------------------- end flexible part -------------------------------
1085 
1086  ol.endContents();
1087 
1088  endFileWithNavPath(this,ol);
1089 
1090  if (Config_getBool(SEPARATE_MEMBER_PAGES))
1091  {
1092  MemberList *allMemberList = getMemberList(MemberListType_allMembersList);
1093  if (allMemberList) allMemberList->sort();
1094  writeMemberPages(ol);
1095  }
1096 }
1097 
1098 void NamespaceDefImpl::writeMemberPages(OutputList &ol)
1099 {
1100  ol.pushGeneratorState();
1101  ol.disableAllBut(OutputGenerator::Html);
1102 
1103  for (const auto &ml : m_memberLists)
1104  {
1105  if (ml->listType()&MemberListType_documentationLists)
1106  {
1107  ml->writeDocumentationPage(ol,displayName(),this);
1108  }
1109  }
1110  ol.popGeneratorState();
1111 }
1112 
1113 void NamespaceDefImpl::writeQuickMemberLinks(OutputList &ol,const MemberDef *currentMd) const
1114 {
1115  static bool createSubDirs=Config_getBool(CREATE_SUBDIRS);
1116 
1117  ol.writeString(" <div class=\"navtab\">\n");
1118  ol.writeString(" <table>\n");
1119 
1120  MemberList *allMemberList = getMemberList(MemberListType_allMembersList);
1121  if (allMemberList)
1122  {
1123  for (const auto &md : *allMemberList)
1124  {
1125  if (md->getNamespaceDef()==this && md->isLinkable() && !md->isEnumValue())
1126  {
1127  if (md->isLinkableInProject())
1128  {
1129  if (md==currentMd) // selected item => highlight
1130  {
1131  ol.writeString(" <tr><td class=\"navtabHL\">");
1132  }
1133  else
1134  {
1135  ol.writeString(" <tr><td class=\"navtab\">");
1136  }
1137  ol.writeString("<a class=\"navtab\" ");
1138  ol.writeString("href=\"");
1139  if (createSubDirs) ol.writeString("../../");
1140  ol.writeString(addHtmlExtensionIfMissing(md->getOutputFileBase())+"#"+md->anchor());
1141  ol.writeString("\">");
1142  ol.writeString(convertToHtml(md->localName()));
1143  ol.writeString("</a>");
1144  ol.writeString("</td></tr>\n");
1145  }
1146  }
1147  }
1148  }
1149 
1150  ol.writeString(" </table>\n");
1151  ol.writeString(" </div>\n");
1152 }
1153 
1154 void NamespaceDefImpl::countMembers()
1155 {
1156  for (auto &ml : m_memberLists)
1157  {
1158  ml->countDecMembers();
1159  ml->countDocMembers();
1160  }
1161  for (const auto &mg : m_memberGroups)
1162  {
1163  mg->countDecMembers();
1164  mg->countDocMembers();
1165  }
1166 }
1167 
1168 int NamespaceDefImpl::numDocMembers() const
1169 {
1170  MemberList *allMemberList = getMemberList(MemberListType_allMembersList);
1171  return (allMemberList ? allMemberList->numDocMembers() : 0) + (int)m_innerCompounds.size();
1172 }
1173 
1174 void NamespaceDefImpl::addUsingDirective(const NamespaceDef *nd)
1175 {
1176  m_usingDirList.add(nd->qualifiedName(),nd);
1177  //printf("%p: NamespaceDefImpl::addUsingDirective: %s:%d\n",this,qPrint(name()),m_usingDirList->count());
1178 }
1179 
1180 void NamespaceDefImpl::addUsingDeclaration(const ClassDef *cd)
1181 {
1182  m_usingDeclList.add(cd->qualifiedName(),cd);
1183 }
1184 
1185 QCString NamespaceDefImpl::getOutputFileBase() const
1186 {
1187  return fileName;
1188 }
1189 
1190 const Definition *NamespaceDefImpl::findInnerCompound(const QCString &n) const
1191 {
1192  if (n==0) return 0;
1193  const Definition *d = m_innerCompounds.find(n);
1194  if (d==0)
1195  {
1196  if (!m_usingDirList.empty())
1197  {
1198  d = m_usingDirList.find(n);
1199  }
1200  if (d==0 && !m_usingDeclList.empty())
1201  {
1202  d = m_usingDeclList.find(n);
1203  }
1204  }
1205  return d;
1206 }
1207 
1208 void NamespaceDefImpl::addListReferences()
1209 {
1210  //bool fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
1211  {
1212  const RefItemVector &xrefItems = xrefListItems();
1213  addRefItem(xrefItems,
1214  qualifiedName(),
1215  getLanguage()==SrcLangExt_Fortran ?
1216  theTranslator->trModule(TRUE,TRUE) :
1217  theTranslator->trNamespace(TRUE,TRUE),
1218  getOutputFileBase(),displayName(),
1219  QCString(),
1220  this
1221  );
1222  }
1223  for (const auto &mg : m_memberGroups)
1224  {
1225  mg->addListReferences(this);
1226  }
1227  for (auto &ml : m_memberLists)
1228  {
1229  if (ml->listType()&MemberListType_documentationLists)
1230  {
1231  ml->addListReferences(this);
1232  }
1233  }
1234 }
1235 
1236 QCString NamespaceDefImpl::displayName(bool includeScope) const
1237 {
1238  return makeDisplayName(this,includeScope);
1239 }
1240 
1241 QCString NamespaceDefImpl::localName() const
1242 {
1243  QCString result=name();
1244  int i=result.findRev("::");
1245  if (i!=-1)
1246  {
1247  result=result.mid(i+2);
1248  }
1249  return result;
1250 }
1251 
1252 void NamespaceDefImpl::combineUsingRelations(NamespaceDefSet &visitedNamespaces)
1253 {
1254  if (visitedNamespaces.find(this)!=visitedNamespaces.end()) return; // already processed
1255  visitedNamespaces.insert(this);
1256 
1257  LinkedRefMap<const NamespaceDef> usingDirList = m_usingDirList;
1258  for (auto &nd : usingDirList)
1259  {
1260  NamespaceDefMutable *ndm = toNamespaceDefMutable(nd);
1261  if (ndm)
1262  {
1263  ndm->combineUsingRelations(visitedNamespaces);
1264  }
1265  }
1266 
1267  for (auto &nd : usingDirList)
1268  {
1269  // add used namespaces of namespace nd to this namespace
1270  for (const auto &und : nd->getUsedNamespaces())
1271  {
1272  addUsingDirective(und);
1273  }
1274  // add used classes of namespace nd to this namespace
1275  for (const auto &ucd : nd->getUsedClasses())
1276  {
1277  addUsingDeclaration(ucd);
1278  }
1279  }
1280 }
1281 
1282 //-------------------------------------------------------------------------------
1283 
1284 bool NamespaceLinkedRefMap::declVisible(bool isConstantGroup) const
1285 {
1286  bool found=false;
1287  for (const auto &nd : *this)
1288  {
1289  if (nd->isLinkable() && nd->hasDocumentation())
1290  {
1291  SrcLangExt lang = nd->getLanguage();
1292  if (SrcLangExt_IDL==lang)
1293  {
1294  if (isConstantGroup == nd->isConstantGroup())
1295  {
1296  found=true;
1297  break;
1298  }
1299  }
1300  else if (!isConstantGroup) // ensure we only get extra section in IDL
1301  {
1302  if (nd->isConstantGroup())
1303  {
1304  err("Internal inconsistency: constant group but not IDL?\n");
1305  }
1306  found=true;
1307  break;
1308  }
1309  }
1310  }
1311  return found;
1312 }
1313 
1314 void NamespaceLinkedRefMap::writeDeclaration(OutputList &ol,const QCString &title,
1315  bool const isConstantGroup,bool localName)
1316 {
1317 
1318 
1319  if (empty()) return; // no namespaces in the list
1320 
1321  if (Config_getBool(OPTIMIZE_OUTPUT_VHDL)) return;
1322 
1323  if (!declVisible(isConstantGroup)) return;
1324 
1325  // write list of namespaces
1326  ol.startMemberHeader(isConstantGroup ? "constantgroups" : "namespaces");
1327  //bool javaOpt = Config_getBool(OPTIMIZE_OUTPUT_JAVA);
1328  //bool fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
1329  ol.parseText(title);
1330  ol.endMemberHeader();
1331  ol.startMemberList();
1332  for (const auto &nd : *this)
1333  {
1334  if (nd->isLinkable() && nd->hasDocumentation())
1335  {
1336  SrcLangExt lang = nd->getLanguage();
1337  if (lang==SrcLangExt_IDL && (isConstantGroup != nd->isConstantGroup()))
1338  continue; // will be output in another pass, see layout_default.xml
1339  ol.startMemberDeclaration();
1340  ol.startMemberItem(nd->getOutputFileBase(),0);
1341  QCString ct = nd->compoundTypeString();
1342  ol.docify(ct);
1343  ol.docify(" ");
1344  ol.insertMemberAlign();
1345  QCString name;
1346  if (localName)
1347  {
1348  name = nd->localName();
1349  }
1350  else
1351  {
1352  name = nd->displayName();
1353  }
1354  ol.writeObjectLink(nd->getReference(),nd->getOutputFileBase(),QCString(),name);
1355  ol.endMemberItem();
1356  if (!nd->briefDescription().isEmpty() && Config_getBool(BRIEF_MEMBER_DESC))
1357  {
1358  ol.startMemberDescription(nd->getOutputFileBase());
1359  ol.generateDoc(nd->briefFile(),nd->briefLine(),nd,0,nd->briefDescription(),FALSE,FALSE,
1360  QCString(),TRUE,FALSE,Config_getBool(MARKDOWN_SUPPORT));
1361  ol.endMemberDescription();
1362  }
1363  ol.endMemberDeclaration(QCString(),QCString());
1364  }
1365  }
1366  ol.endMemberList();
1367 }
1368 
1369 //-------------------------------------------------------------------------------
1370 
1371 void NamespaceDefImpl::addMemberToList(MemberListType lt,MemberDef *md)
1372 {
1373  static bool sortBriefDocs = Config_getBool(SORT_BRIEF_DOCS);
1374  static bool sortMemberDocs = Config_getBool(SORT_MEMBER_DOCS);
1375  const auto &ml = m_memberLists.get(lt,MemberListContainer::Namespace);
1376  ml->setNeedsSorting(
1377  ((ml->listType()&MemberListType_declarationLists) && sortBriefDocs) ||
1378  ((ml->listType()&MemberListType_documentationLists) && sortMemberDocs));
1379  ml->push_back(md);
1380 
1381  if (ml->listType()&MemberListType_declarationLists)
1382  {
1383  MemberDefMutable *mdm = toMemberDefMutable(md);
1384  if (mdm)
1385  {
1386  mdm->setSectionList(this,ml.get());
1387  }
1388  }
1389 }
1390 
1391 void NamespaceDefImpl::sortMemberLists()
1392 {
1393  for (auto &ml : m_memberLists)
1394  {
1395  if (ml->needsSorting()) { ml->sort(); ml->setNeedsSorting(FALSE); }
1396  }
1397 
1398  auto classComp = [](const ClassLinkedRefMap::Ptr &c1,const ClassLinkedRefMap::Ptr &c2)
1399  {
1400  return Config_getBool(SORT_BY_SCOPE_NAME) ?
1401  qstricmp(c1->name(), c2->name())<0 :
1402  qstricmp(c1->className(), c2->className())<0;
1403  };
1404 
1405  std::sort(classes.begin(), classes.end(), classComp);
1406  std::sort(interfaces.begin(),interfaces.end(),classComp);
1407  std::sort(structs.begin(), structs.end(), classComp);
1408  std::sort(exceptions.begin(),exceptions.end(),classComp);
1409 
1410 
1411  auto namespaceComp = [](const NamespaceLinkedRefMap::Ptr &n1,const NamespaceLinkedRefMap::Ptr &n2)
1412  {
1413  return qstricmp(n1->name(),n2->name())<0;
1414  };
1415 
1416  std::sort(namespaces.begin(),namespaces.end(),namespaceComp);
1417 }
1418 
1419 MemberList *NamespaceDefImpl::getMemberList(MemberListType lt) const
1420 {
1421  for (auto &ml : m_memberLists)
1422  {
1423  if (ml->listType()==lt)
1424  {
1425  return ml.get();
1426  }
1427  }
1428  return 0;
1429 }
1430 
1431 void NamespaceDefImpl::writeMemberDeclarations(OutputList &ol,MemberListType lt,const QCString &title)
1432 {
1433  MemberList * ml = getMemberList(lt);
1434  if (ml) ml->writeDeclarations(ol,0,this,0,0,title,QCString());
1435 }
1436 
1437 void NamespaceDefImpl::writeMemberDocumentation(OutputList &ol,MemberListType lt,const QCString &title)
1438 {
1439  MemberList * ml = getMemberList(lt);
1440  if (ml) ml->writeDocumentation(ol,displayName(),this,title);
1441 }
1442 
1443 
1444 bool NamespaceDefImpl::isLinkableInProject() const
1445 {
1446  int i = name().findRev("::");
1447  if (i==-1) i=0; else i+=2;
1448  static bool extractAnonNs = Config_getBool(EXTRACT_ANON_NSPACES);
1449  if (extractAnonNs && // extract anonymous ns
1450  name().mid(i,20)=="anonymous_namespace{" // correct prefix
1451  ) // not disabled by config
1452  {
1453  return TRUE;
1454  }
1455  return !name().isEmpty() && name().at(i)!='@' && // not anonymous
1456  (hasDocumentation() || getLanguage()==SrcLangExt_CSharp) && // documented
1457  !isReference() && // not an external reference
1458  !isHidden() && // not hidden
1459  !isArtificial(); // or artificial
1460 }
1461 
1462 bool NamespaceDefImpl::isLinkable() const
1463 {
1464  return isLinkableInProject() || isReference();
1465 }
1466 
1467 const MemberDef * NamespaceDefImpl::getMemberByName(const QCString &n) const
1468 {
1469  return m_allMembers.find(n);
1470 }
1471 
1472 QCString NamespaceDefImpl::title() const
1473 {
1474  SrcLangExt lang = getLanguage();
1475  QCString pageTitle;
1476  if (lang==SrcLangExt_Java)
1477  {
1478  pageTitle = theTranslator->trPackage(displayName());
1479  }
1480  else if (lang==SrcLangExt_Fortran || lang==SrcLangExt_Slice)
1481  {
1482  pageTitle = theTranslator->trModuleReference(displayName());
1483  }
1484  else if (lang==SrcLangExt_IDL)
1485  {
1486  pageTitle = isConstantGroup()
1487  ? theTranslator->trConstantGroupReference(displayName())
1488  : theTranslator->trModuleReference(displayName());
1489  }
1490  else
1491  {
1492  pageTitle = theTranslator->trNamespaceReference(displayName());
1493  }
1494  return pageTitle;
1495 }
1496 
1497 QCString NamespaceDefImpl::compoundTypeString() const
1498 {
1499  SrcLangExt lang = getLanguage();
1500  if (lang==SrcLangExt_Java)
1501  {
1502  return "package";
1503  }
1504  else if(lang==SrcLangExt_CSharp)
1505  {
1506  return "namespace";
1507  }
1508  else if (lang==SrcLangExt_Fortran)
1509  {
1510  return "module";
1511  }
1512  else if (lang==SrcLangExt_IDL)
1513  {
1514  if (isModule())
1515  {
1516  return "module";
1517  }
1518  else if (isConstantGroup())
1519  {
1520  return "constants";
1521  }
1522  else if (isLibrary())
1523  {
1524  return "library";
1525  }
1526  else
1527  {
1528  err_full(getDefFileName(),getDefLine(),"Internal inconsistency: namespace in IDL not module, library or constant group");
1529  }
1530  }
1531  return "namespace";
1532 }
1533 
1534 void NamespaceDefImpl::setMetaData(const QCString &m)
1535 {
1536  metaData = m;
1537 }
1538 
1539 // --- Cast functions
1540 //
1541 NamespaceDef *toNamespaceDef(Definition *d)
1542 {
1543  if (d && (typeid(*d)==typeid(NamespaceDefImpl) || typeid(*d)==typeid(NamespaceDefAliasImpl)))
1544  {
1545  return static_cast<NamespaceDef*>(d);
1546  }
1547  else
1548  {
1549  return 0;
1550  }
1551 }
1552 
1553 NamespaceDef *toNamespaceDef(DefinitionMutable *md)
1554 {
1555  Definition *d = toDefinition(md);
1556  if (d && typeid(*d)==typeid(NamespaceDefImpl))
1557  {
1558  return static_cast<NamespaceDef*>(d);
1559  }
1560  else
1561  {
1562  return 0;
1563  }
1564 }
1565 
1566 
1567 const NamespaceDef *toNamespaceDef(const Definition *d)
1568 {
1569  if (d && (typeid(*d)==typeid(NamespaceDefImpl) || typeid(*d)==typeid(NamespaceDefAliasImpl)))
1570  {
1571  return static_cast<const NamespaceDef*>(d);
1572  }
1573  else
1574  {
1575  return 0;
1576  }
1577 }
1578 
1579 NamespaceDefMutable *toNamespaceDefMutable(Definition *d)
1580 {
1581  if (d && typeid(*d)==typeid(NamespaceDefImpl))
1582  {
1583  return static_cast<NamespaceDefMutable*>(d);
1584  }
1585  else
1586  {
1587  return 0;
1588  }
1589 }
1590 
1591 NamespaceDefMutable *toNamespaceDefMutable(const Definition *d)
1592 {
1593  if (d && typeid(*d)==typeid(NamespaceDefImpl))
1594  {
1595  return const_cast<NamespaceDefMutable*>(static_cast<const NamespaceDefMutable*>(d));
1596  }
1597  else
1598  {
1599  return 0;
1600  }
1601 }
1602 
1603 // --- Helpers
1604 
1605 
1606 NamespaceDef *getResolvedNamespace(const QCString &name)
1607 {
1608  if (name.isEmpty()) return 0;
1609  auto it = Doxygen::namespaceAliasMap.find(name.str());
1610  if (it!=Doxygen::namespaceAliasMap.end())
1611  {
1612  int count=0; // recursion detection guard
1613  StringUnorderedMap::iterator it2;
1614  while ((it2=Doxygen::namespaceAliasMap.find(it->second))!=Doxygen::namespaceAliasMap.end() &&
1615  count<10)
1616  {
1617  it=it2;
1618  count++;
1619  }
1620  if (count==10)
1621  {
1622  warn_uncond("possible recursive namespace alias detected for %s!\n",qPrint(name));
1623  }
1624  return Doxygen::namespaceLinkedMap->find(it->second);
1625  }
1626  else
1627  {
1628  return Doxygen::namespaceLinkedMap->find(name);
1629  }
1630 }
1631 
1632 //--------------------------------------------------------------------------------------
1633 //
1634 bool namespaceHasNestedNamespace(const NamespaceDef *nd)
1635 {
1636  for (const auto &cnd : nd->getNamespaces())
1637  {
1638  if (cnd->isLinkableInProject() && !cnd->isAnonymous())
1639  {
1640  return true;
1641  }
1642  }
1643  return false;
1644 }
1645 
1646 bool namespaceHasNestedConcept(const NamespaceDef *nd)
1647 {
1648  for (const auto &cnd : nd->getNamespaces())
1649  {
1650  if (namespaceHasNestedConcept(cnd))
1651  {
1652  //printf("<namespaceHasVisibleChild(%s,includeClasses=%d): case2\n",qPrint(nd->name()),includeClasses);
1653  return true;
1654  }
1655  }
1656  for (const auto &cnd : nd->getConcepts())
1657  {
1658  if (cnd->isLinkableInProject())
1659  {
1660  return true;
1661  }
1662  }
1663  return false;
1664 }
1665 
1666 bool namespaceHasNestedClass(const NamespaceDef *nd,bool filterClasses,ClassDef::CompoundType ct)
1667 {
1668  //printf(">namespaceHasVisibleChild(%s,includeClasses=%d)\n",qPrint(nd->name()),includeClasses);
1669  for (const auto &cnd : nd->getNamespaces())
1670  {
1671  if (namespaceHasNestedClass(cnd,filterClasses,ct))
1672  {
1673  //printf("<namespaceHasVisibleChild(%s,includeClasses=%d): case2\n",qPrint(nd->name()),includeClasses);
1674  return TRUE;
1675  }
1676  }
1677 
1678  ClassLinkedRefMap list = nd->getClasses();
1679  if (filterClasses)
1680  {
1681  if (ct == ClassDef::Interface)
1682  {
1683  list = nd->getInterfaces();
1684  }
1685  else if (ct == ClassDef::Struct)
1686  {
1687  list = nd->getStructs();
1688  }
1689  else if (ct == ClassDef::Exception)
1690  {
1691  list = nd->getExceptions();
1692  }
1693  }
1694 
1695  for (const auto &cd : list)
1696  {
1697  if (cd->isLinkableInProject() && cd->templateMaster()==0)
1698  {
1699  //printf("<namespaceHasVisibleChild(%s,includeClasses=%d): case3\n",qPrint(nd->name()),includeClasses);
1700  return TRUE;
1701  }
1702  }
1703  return FALSE;
1704 }
1705 
1706 
NamespaceDefImpl::anchor
virtual QCString anchor() const
Definition: namespacedef.cpp:64
createNamespaceDef
NamespaceDefMutable * 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
Definition: namespacedef.cpp:163
toDefinition
Definition * toDefinition(DefinitionMutable *dm)
Definition: definition.cpp:1950
DefinitionMixin< NamespaceDefMutable >::briefFile
virtual QCString briefFile() const
Definition: definitionimpl.h:171
LayoutDocEntry::GroupPageDocs
@ GroupPageDocs
Definition: layout.h:65
NamespaceDefImpl::writeInlineClasses
void writeInlineClasses(OutputList &ol)
Definition: namespacedef.cpp:775
LinkedRefMap::add
bool add(const char *k, T *obj)
Adds an object reference to the ordered vector if it was not added already.
Definition: linkedmap.h:284
NamespaceDefAliasImpl::isInline
virtual bool isInline() const
Definition: namespacedef.cpp:206
NamespaceDefImpl::getClasses
virtual ClassLinkedRefMap getClasses() const
Definition: namespacedef.cpp:105
OutputList::disableAllBut
void disableAllBut(OutputGenerator::OutputType o)
Definition: outputlist.cpp:76
NamespaceDefAliasImpl::getUsedClasses
virtual LinkedRefMap< const ClassDef > getUsedClasses() const
Definition: namespacedef.cpp:194
DefinitionMixin< NamespaceDefMutable >::isReference
virtual bool isReference() const
Definition: definitionimpl.h:183
OutputList::startMemberDescription
void startMemberDescription(const QCString &anchor, const QCString &inheritId=QCString(), bool typ=false)
Definition: outputlist.h:306
startTitle
void startTitle(OutputList &ol, const QCString &fileName, const DefinitionMutable *def)
Definition: index.cpp:219
Translator::trNamespaceReference
virtual QCString trNamespaceReference(const QCString &namespaceName)=0
NamespaceDefAliasImpl::codeSymbolType
virtual CodeSymbolType codeSymbolType() const
Definition: namespacedef.cpp:184
outputlist.h
NamespaceDefAliasImpl::isLinkableInProject
virtual bool isLinkableInProject() const
Definition: namespacedef.cpp:208
LinkedRefMap::empty
bool empty() const
Definition: linkedmap.h:374
OutputList::startLabels
void startLabels()
Definition: outputlist.h:472
NamespaceDefImpl::namespaces
NamespaceLinkedRefMap namespaces
Definition: namespacedef.cpp:155
OutputList::endGroupHeader
void endGroupHeader(int extraLevels=0)
Definition: outputlist.h:171
namespaceHasNestedConcept
bool namespaceHasNestedConcept(const NamespaceDef *nd)
Definition: namespacedef.cpp:1646
NamespaceDefImpl::writeAuthorSection
void writeAuthorSection(OutputList &ol)
Definition: namespacedef.cpp:799
NamespaceDef::getOutputFileBase
virtual QCString getOutputFileBase() const =0
LayoutDocEntryMemberDecl::type
MemberListType type
Definition: layout.h:101
OutputList::startMemberList
void startMemberList()
Definition: outputlist.h:197
LayoutDocEntryMemberDecl
Represents of a member declaration list with configurable title and subtitle.
Definition: layout.h:94
LayoutDocEntry::NamespaceNestedNamespaces
@ NamespaceNestedNamespaces
Definition: layout.h:52
NamespaceDefAliasImpl::compoundTypeString
virtual QCString compoundTypeString() const
Definition: namespacedef.cpp:240
LinkedRefMap< const NamespaceDef >
NamespaceDefImpl::distributeMemberGroupDocumentation
virtual void distributeMemberGroupDocumentation()
Definition: namespacedef.cpp:314
NamespaceDefImpl::m_memberLists
MemberLists m_memberLists
Definition: namespacedef.cpp:148
MemberType_Variable
@ MemberType_Variable
Definition: types.h:278
MemberListType_docDictionaryMembers
@ MemberListType_docDictionaryMembers
Definition: types.h:193
ConceptLinkedRefMap::writeDeclaration
void writeDeclaration(OutputList &ol, const QCString &header, bool localNames) const
Definition: conceptdef.cpp:662
NamespaceDef::getUsedNamespaces
virtual LinkedRefMap< const NamespaceDef > getUsedNamespaces() const =0
endTitle
void endTitle(OutputList &ol, const QCString &fileName, const QCString &name)
Definition: index.cpp:228
ConceptDef
Definition: conceptdef.h:22
toMemberDefMutable
MemberDefMutable * toMemberDefMutable(Definition *d)
Definition: memberdef.cpp:6125
OutputList::endMemberDeclaration
void endMemberDeclaration(const QCString &anchor, const QCString &inheritId)
Definition: outputlist.h:312
NamespaceDefImpl::addInnerCompound
virtual void addInnerCompound(const Definition *d)
Definition: namespacedef.cpp:349
NamespaceDef::isConstantGroup
virtual bool isConstantGroup() const =0
NamespaceDefImpl::m_concepts
ConceptLinkedRefMap m_concepts
Definition: namespacedef.cpp:154
NamespaceDefImpl::addListReferences
virtual void addListReferences()
Definition: namespacedef.cpp:1208
membergroup.h
NamespaceDefImpl::writeMemberDocumentation
void writeMemberDocumentation(OutputList &ol, MemberListType lt, const QCString &title)
Definition: namespacedef.cpp:1437
LayoutDocEntry::GroupConcepts
@ GroupConcepts
Definition: layout.h:63
NamespaceDefImpl::~NamespaceDefImpl
virtual ~NamespaceDefImpl()
Definition: namespacedef.cpp:298
NamespaceDefAliasImpl
Definition: namespacedef.cpp:173
MemberListType
MemberListType
Definition: types.h:100
Doxygen::namespaceAliasMap
static StringUnorderedMap namespaceAliasMap
Definition: doxygen.h:95
Definition
The common base class of all entity definitions found in the sources.
Definition: definition.h:76
NamespaceDefImpl::writeTagFile
virtual void writeTagFile(TextStream &)
Definition: namespacedef.cpp:557
MemberListType_docEnumMembers
@ MemberListType_docEnumMembers
Definition: types.h:167
LayoutDocEntry::GroupFiles
@ GroupFiles
Definition: layout.h:64
DefinitionMixin< NamespaceDefMutable >::xrefListItems
virtual const RefItemVector & xrefListItems() const
Definition: definitionimpl.h:192
NamespaceDefImpl::subGrouping
virtual bool subGrouping() const
Definition: namespacedef.cpp:100
stripScope
QCString stripScope(const QCString &name)
Definition: util.cpp:3815
NamespaceDef::localName
virtual QCString localName() const =0
LayoutDocEntry::NamespaceInlineClasses
@ NamespaceInlineClasses
Definition: layout.h:54
NamespaceDef
An abstract interface of a namespace symbol.
Definition: namespacedef.h:54
MemberType_EnumValue
@ MemberType_EnumValue
Definition: types.h:281
NamespaceDefAliasImpl::NamespaceDefAliasImpl
NamespaceDefAliasImpl(const Definition *newScope, const NamespaceDef *nd)
Definition: namespacedef.cpp:176
LayoutDocEntry::MemberDef
@ MemberDef
Definition: layout.h:38
LayoutDocEntry::FileClasses
@ FileClasses
Definition: layout.h:57
CodeSymbolType::Namespace
@ Namespace
ClassLinkedRefMap::writeDeclaration
void writeDeclaration(OutputList &ol, const ClassDef::CompoundType *filter, const QCString &header, bool localNames) const
Definition: classlist.cpp:53
OutputList::docify
void docify(const QCString &s)
Definition: outputlist.h:137
LayoutDocEntry::ConceptDefinition
@ ConceptDefinition
Definition: layout.h:49
DefinitionMixin< NamespaceDefMutable >::writeDocAnchorsToTagFile
virtual void writeDocAnchorsToTagFile(TextStream &fs) const
Definition: definitionimpl.h:268
NamespaceDefImpl::endMemberDeclarations
void endMemberDeclarations(OutputList &ol)
Definition: namespacedef.cpp:742
NamespaceDefImpl::endMemberDocumentation
void endMemberDocumentation(OutputList &ol)
Definition: namespacedef.cpp:756
NamespaceDef::getExceptions
virtual ClassLinkedRefMap getExceptions() const =0
OutputList::endMemberDescription
void endMemberDescription()
Definition: outputlist.h:308
NamespaceDefImpl::interfaces
ClassLinkedRefMap interfaces
Definition: namespacedef.cpp:151
MemberLists::get
const std::unique_ptr< MemberList > & get(MemberListType lt, MemberListContainer con)
Definition: memberlist.h:142
QCString::findRev
int findRev(char c, int index=-1, bool cs=TRUE) const
Definition: qcstring.cpp:86
MemberName::push_back
void push_back(Ptr &&p)
Definition: membername.h:68
NamespaceDefImpl::isModule
virtual bool isModule() const
Definition: namespacedef.cpp:86
DefinitionMixin< NamespaceDefMutable >::docFile
virtual QCString docFile() const
Definition: definitionimpl.h:164
NamespaceDefImpl::addUsingDirective
virtual void addUsingDirective(const NamespaceDef *nd)
Definition: namespacedef.cpp:1174
QCString::isEmpty
bool isEmpty() const
Returns TRUE iff the string is empty
Definition: qcstring.h:144
MemberListType_allMembersList
@ MemberListType_allMembersList
Definition: types.h:147
NamespaceDef::getMemberLists
virtual const MemberLists & getMemberLists() const =0
Translator::trPackage
virtual QCString trPackage(const QCString &name)=0
NamespaceDefImpl::writeClassDeclarations
void writeClassDeclarations(OutputList &ol, const QCString &title, const ClassLinkedRefMap &d)
Definition: namespacedef.cpp:765
OutputList::writeLabel
void writeLabel(const QCString &l, bool isLast)
Definition: outputlist.h:474
NamespaceDefImpl::title
virtual QCString title() const
Definition: namespacedef.cpp:1472
namespacedef.h
ClassDef::CompoundType
CompoundType
The various compound types
Definition: classdef.h:107
NamespaceDefImpl::writeClassesToTagFile
void writeClassesToTagFile(TextStream &, const ClassLinkedRefMap &d)
Definition: namespacedef.cpp:900
OutputList::startMemberSections
void startMemberSections()
Definition: outputlist.h:177
namespaceHasNestedClass
bool namespaceHasNestedClass(const NamespaceDef *nd, bool filterClasses, ClassDef::CompoundType ct)
Definition: namespacedef.cpp:1666
OutputList::writeString
void writeString(const QCString &text)
Definition: outputlist.h:111
NamespaceDefAliasImpl::displayName
virtual QCString displayName(bool b=TRUE) const
Definition: namespacedef.cpp:196
NamespaceDefImpl::countMembers
virtual void countMembers()
Definition: namespacedef.cpp:1154
LayoutDocEntryMemberDef::title
QCString title(SrcLangExt lang) const
Definition: layout.cpp:1680
OutputList::insertMemberAlign
void insertMemberAlign(bool templ=FALSE)
Definition: outputlist.h:233
MemberVector::sort
void sort()
Definition: memberlist.h:58
LayoutDocEntry::ClassInheritanceGraph
@ ClassInheritanceGraph
Definition: layout.h:44
NamespaceDef::title
virtual QCString title() const =0
DefinitionMixin< NamespaceDefMutable >::getDefLine
virtual int getDefLine() const
Definition: definitionimpl.h:174
membername.h
ClassDef::Interface
@ Interface
Definition: classdef.h:110
NamespaceDefImpl::m_usingDirList
LinkedRefMap< const NamespaceDef > m_usingDirList
Definition: namespacedef.cpp:143
CodeSymbolType::Package
@ Package
NamespaceDefAliasImpl::localName
virtual QCString localName() const
Definition: namespacedef.cpp:198
NamespaceDef::getInterfaces
virtual ClassLinkedRefMap getInterfaces() const =0
MemberVector::push_back
void push_back(const MemberDef *md)
Definition: memberlist.h:42
DefinitionMixin< NamespaceDefMutable >::id
virtual QCString id() const
Definition: definitionimpl.h:200
NamespaceDefAliasImpl::getNamespaces
virtual NamespaceLinkedRefMap getNamespaces() const
Definition: namespacedef.cpp:234
NamespaceDefImpl::getConcepts
virtual ConceptLinkedRefMap getConcepts() const
Definition: namespacedef.cpp:110
SrcLangExt
SrcLangExt
Language as given by extension
Definition: types.h:41
LayoutDocEntry::MemberDeclStart
@ MemberDeclStart
Definition: layout.h:37
NamespaceDefImpl::files
FileList files
Definition: namespacedef.cpp:141
LinkedMap::add
T * add(const char *k, Args &&... args)
Adds a new object to the ordered vector if it was not added already.
Definition: linkedmap.h:103
MemberListType_docSequenceMembers
@ MemberListType_docSequenceMembers
Definition: types.h:191
ClassLinkedRefMap::writeDocumentation
void writeDocumentation(OutputList &ol, const Definition *container=0) const
Definition: classlist.cpp:74
NamespaceDefImpl::compoundTypeString
virtual QCString compoundTypeString() const
Definition: namespacedef.cpp:1497
Doxygen::globalScope
static NamespaceDefMutable * globalScope
Definition: doxygen.h:102
NamespaceDefImpl::writeNamespaceDeclarations
void writeNamespaceDeclarations(OutputList &ol, const QCString &title, bool isConstantGroup=false)
Definition: namespacedef.cpp:780
NamespaceDefImpl::structs
ClassLinkedRefMap structs
Definition: namespacedef.cpp:152
MemberType_Enumeration
@ MemberType_Enumeration
Definition: types.h:280
DefinitionMixin< NamespaceDefMutable >::getOuterScope
virtual Definition * getOuterScope() const
Definition: definitionimpl.h:194
NamespaceDefImpl::isLinkableInProject
virtual bool isLinkableInProject() const
Definition: namespacedef.cpp:1444
namespaceHasNestedNamespace
bool namespaceHasNestedNamespace(const NamespaceDef *nd)
Definition: namespacedef.cpp:1634
toConceptDef
ConceptDef * toConceptDef(Definition *d)
Definition: conceptdef.cpp:676
QCString::str
std::string str() const
Definition: qcstring.h:442
NamespaceDefAliasImpl::getOutputFileBase
virtual QCString getOutputFileBase() const
Definition: namespacedef.cpp:186
MemberType_Typedef
@ MemberType_Typedef
Definition: types.h:279
NamespaceDefAliasImpl::getMemberLists
virtual const MemberLists & getMemberLists() const
Definition: namespacedef.cpp:220
NamespaceDef::isInline
virtual bool isInline() const =0
Definition::isHidden
virtual bool isHidden() const =0
NamespaceDefAliasImpl::getMemberByName
virtual const MemberDef * getMemberByName(const QCString &name) const
Definition: namespacedef.cpp:222
NamespaceDefImpl::insertNamespace
virtual void insertNamespace(const NamespaceDef *nd)
Definition: namespacedef.cpp:394
LayoutDocEntry::NamespaceClasses
@ NamespaceClasses
Definition: layout.h:53
definitionimpl.h
MemberListType_docDefineMembers
@ MemberListType_docDefineMembers
Definition: types.h:164
LayoutDocEntry::GroupClasses
@ GroupClasses
Definition: layout.h:63
NamespaceDef::anchor
virtual QCString anchor() const =0
DefinitionMixin< NamespaceDefMutable >::getLanguage
virtual SrcLangExt getLanguage() const
Definition: definitionimpl.h:189
MemberDefMutable::setSectionList
virtual void setSectionList(const Definition *container, const MemberList *sl)=0
MemberListType_decDictionaryMembers
@ MemberListType_decDictionaryMembers
Definition: types.h:192
NamespaceDefImpl::m_memberGroups
MemberGroupList m_memberGroups
Definition: namespacedef.cpp:149
err
void err(const char *fmt,...)
Definition: message.cpp:203
SrcLangExt_Java
@ SrcLangExt_Java
Definition: types.h:45
MemberLists
Definition: memberlist.h:138
OutputList::endLabels
void endLabels()
Definition: outputlist.h:476
QCString::at
char & at(size_t i)
Returns a reference to the character at index i.
Definition: qcstring.h:477
DefinitionAliasMixin< NamespaceDef >::name
virtual QCString name() const
Definition: definitionimpl.h:326
TextStream
Text streaming class that buffers data.
Definition: textstream.h:33
DefinitionMixin< NamespaceDefMutable >::name
virtual QCString name() const
Definition: definitionimpl.h:155
NamespaceDefImpl::writeDocumentation
virtual void writeDocumentation(OutputList &ol)
Definition: namespacedef.cpp:923
NamespaceDefImpl::writeMemberDeclarations
void writeMemberDeclarations(OutputList &ol, MemberListType lt, const QCString &title)
Definition: namespacedef.cpp:1431
DefinitionMixin< NamespaceDefMutable >::getDefFileName
virtual QCString getDefFileName() const
Definition: definitionimpl.h:172
NamespaceDefImpl::m_isPublished
bool m_isPublished
Definition: namespacedef.cpp:158
LayoutDocEntry::ClassIncludes
@ ClassIncludes
Definition: layout.h:43
LayoutDocEntry::FileNamespaces
@ FileNamespaces
Definition: layout.h:57
LayoutDocEntryMemberDef::type
MemberListType type
Definition: layout.h:116
NamespaceDef::getMemberByName
virtual const MemberDef * getMemberByName(const QCString &) const =0
MemberDefMutable
Definition: memberdef.h:296
NamespaceDef::getMemberGroups
virtual const MemberGroupList & getMemberGroups() const =0
getResolvedNamespace
NamespaceDef * getResolvedNamespace(const QCString &name)
Definition: namespacedef.cpp:1606
LayoutDocEntry::FileConcepts
@ FileConcepts
Definition: layout.h:57
DefinitionMixin< NamespaceDefMutable >::briefLine
virtual int briefLine() const
Definition: definitionimpl.h:167
OutputList::endTypewriter
void endTypewriter()
Definition: outputlist.h:167
NamespaceDefImpl::writeBriefDescription
void writeBriefDescription(OutputList &ol)
Definition: namespacedef.cpp:677
NamespaceDefAliasImpl::getStructs
virtual ClassLinkedRefMap getStructs() const
Definition: namespacedef.cpp:230
NamespaceDefImpl::writeMemberPages
virtual void writeMemberPages(OutputList &ol)
Definition: namespacedef.cpp:1098
NamespaceDefImpl::NamespaceDefImpl
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)
Definition: namespacedef.cpp:255
endFileWithNavPath
void endFileWithNavPath(const Definition *d, OutputList &ol)
Definition: index.cpp:274
LayoutDocEntry::MemberDefEnd
@ MemberDefEnd
Definition: layout.h:38
LayoutDocEntry::DirSubDirs
@ DirSubDirs
Definition: layout.h:68
DefinitionMixin< NamespaceDefMutable >::hasBriefDescription
virtual bool hasBriefDescription() const
Definition: definitionimpl.h:199
OutputList::writeDoc
void writeDoc(DocRoot *root, const Definition *ctx, const MemberDef *md, int id=0)
Definition: outputlist.cpp:169
NamespaceDefImpl::displayName
virtual QCString displayName(bool=TRUE) const
Definition: namespacedef.cpp:1236
MemberList::declVisible
bool declVisible() const
Definition: memberlist.cpp:279
DefinitionAliasMixin< NamespaceDef >::deinit
void deinit()
Definition: definitionimpl.h:319
NamespaceDefImpl::addMemberToList
void addMemberToList(MemberListType lt, MemberDef *md)
Definition: namespacedef.cpp:1371
NamespaceDefImpl::isLibrary
virtual bool isLibrary() const
Definition: namespacedef.cpp:87
NamespaceLinkedRefMap
Definition: namespacedef.h:45
Definition::getLanguage
virtual SrcLangExt getLanguage() const =0
Returns the programming language this definition was written in.
MemberListContainer::Namespace
@ Namespace
LayoutDocEntry::NamespaceNestedConstantGroups
@ NamespaceNestedConstantGroups
Definition: layout.h:52
OutputList::startTypewriter
void startTypewriter()
Definition: outputlist.h:165
LayoutDocEntry::GroupInlineClasses
@ GroupInlineClasses
Definition: layout.h:63
OutputList::writeSummaryLink
void writeSummaryLink(const QCString &file, const QCString &anchor, const QCString &title, bool first)
Definition: outputlist.h:359
NamespaceDefImpl::getUsedClasses
virtual LinkedRefMap< const ClassDef > getUsedClasses() const
Definition: namespacedef.cpp:80
OutputList::endTextBlock
void endTextBlock(bool paraBreak=FALSE)
Definition: outputlist.h:411
end
DirIterator end(const DirIterator &) noexcept
Definition: dir.cpp:128
NamespaceDefAliasImpl::isModule
virtual bool isModule() const
Definition: namespacedef.cpp:202
MemberListType_declarationLists
@ MemberListType_declarationLists
Definition: types.h:104
MemberName
Definition: membername.h:24
DefinitionMixin< NamespaceDefMutable >::isHidden
virtual bool isHidden() const
Definition: definitionimpl.h:180
OutputGenerator::RTF
@ RTF
Definition: outputgen.h:333
MemberListType_decSequenceMembers
@ MemberListType_decSequenceMembers
Definition: types.h:190
NamespaceDefImpl::getMemberByName
virtual const MemberDef * getMemberByName(const QCString &) const
Definition: namespacedef.cpp:1467
ConceptLinkedRefMap::declVisible
bool declVisible() const
Definition: conceptdef.cpp:648
LayoutDocEntry::ClassCollaborationGraph
@ ClassCollaborationGraph
Definition: layout.h:45
DefinitionMixin< NamespaceDefMutable >::qualifiedName
virtual QCString qualifiedName() const
Definition: definitionimpl.h:158
LayoutDocEntryMemberDecl::title
QCString title(SrcLangExt lang) const
Definition: layout.cpp:1668
toNamespaceDefMutable
NamespaceDefMutable * toNamespaceDefMutable(Definition *d)
Definition: namespacedef.cpp:1579
NamespaceDefMutable::combineUsingRelations
virtual void combineUsingRelations(NamespaceDefSet &visitedNamespace)=0
LayoutDocManager::Namespace
@ Namespace
Definition: layout.h:203
NamespaceDefImpl::insertConcept
virtual void insertConcept(const ConceptDef *cd)
Definition: namespacedef.cpp:389
NamespaceDef::isLinkableInProject
virtual bool isLinkableInProject() const =0
createMemberDefAlias
MemberDef * createMemberDefAlias(const Definition *newScope, const MemberDef *aliasMd)
Definition: memberdef.cpp:781
MemberList::listTypeAsString
static QCString listTypeAsString(MemberListType type)
Definition: memberlist.cpp:882
NamespaceDefImpl::computeAnchors
virtual void computeAnchors()
Definition: namespacedef.cpp:544
OutputList
Class representing a list of output generators that are written to in parallel.
Definition: outputlist.h:37
Definition::qualifiedName
virtual QCString qualifiedName() const =0
NamespaceDef::getUsedClasses
virtual LinkedRefMap< const ClassDef > getUsedClasses() const =0
NamespaceDef::subGrouping
virtual bool subGrouping() const =0
LayoutDocEntry::FileStructs
@ FileStructs
Definition: layout.h:57
LayoutDocEntryMemberDef
Represents of a member definition list with configurable title.
Definition: layout.h:110
OutputList::endQuickIndices
void endQuickIndices()
Definition: outputlist.h:349
addHtmlExtensionIfMissing
QCString addHtmlExtensionIfMissing(const QCString &fName)
Definition: util.cpp:5275
MemberType_Function
@ MemberType_Function
Definition: types.h:277
MemberDef
A model of a class/file/namespace member symbol.
Definition: memberdef.h:45
LayoutDocEntry::FileIncludes
@ FileIncludes
Definition: layout.h:58
MemberList::writeTagFile
void writeTagFile(TextStream &)
Definition: memberlist.cpp:940
warn_uncond
void warn_uncond(const char *fmt,...)
Definition: message.cpp:194
NamespaceDefImpl::getUsedNamespaces
virtual LinkedRefMap< const NamespaceDef > getUsedNamespaces() const
Definition: namespacedef.cpp:78
NamespaceDefImpl::m_inline
bool m_inline
Definition: namespacedef.cpp:160
OutputGenerator::Latex
@ Latex
Definition: outputgen.h:333
DefinitionMixin< NamespaceDefMutable >::briefDescription
virtual QCString briefDescription(bool abbreviate=FALSE) const
Definition: definitionimpl.h:165
NamespaceDef::hasDetailedDescription
virtual bool hasDetailedDescription() const =0
NamespaceDefImpl::isConstantGroup
virtual bool isConstantGroup() const
Definition: namespacedef.cpp:85
Definition::TypeNamespace
@ TypeNamespace
Definition: definition.h:89
ClassDef
A abstract class representing of a compound symbol.
Definition: classdef.h:103
MemberListType_decVarMembers
@ MemberListType_decVarMembers
Definition: types.h:154
classlist.h
Doxygen::functionNameLinkedMap
static MemberNameLinkedMap * functionNameLinkedMap
Definition: doxygen.h:94
OutputList::startTextBlock
void startTextBlock(bool dense=FALSE)
Definition: outputlist.h:409
OutputList::startMemberItem
void startMemberItem(const QCString &anchor, int i1, const QCString &id=QCString())
Definition: outputlist.h:209
OutputList::disable
void disable(OutputGenerator::OutputType o)
Definition: outputlist.cpp:100
OutputList::startMemberHeader
void startMemberHeader(const QCString &anchor, int typ=2)
Definition: outputlist.h:185
NamespaceDefImpl::setFileName
virtual void setFileName(const QCString &fn)
Definition: namespacedef.cpp:302
NamespaceDef::isModule
virtual bool isModule() const =0
message.h
NamespaceDefImpl::combineUsingRelations
virtual void combineUsingRelations(NamespaceDefSet &visitedNamespace)
Definition: namespacedef.cpp:1252
MemberList::listType
MemberListType listType() const
Definition: memberlist.h:86
LayoutDocEntrySection
Definition: layout.h:84
LayoutDocEntry::MemberDeclEnd
@ MemberDeclEnd
Definition: layout.h:37
NamespaceDefImpl::hasDetailedDescription
virtual bool hasDetailedDescription() const
Definition: namespacedef.cpp:550
OutputList::writeAnchor
void writeAnchor(const QCString &fileName, const QCString &name)
Definition: outputlist.h:239
Translator::trMore
virtual QCString trMore()=0
DefinitionMutable
Definition: definition.h:308
NamespaceDefImpl::writeConcepts
void writeConcepts(OutputList &ol, const QCString &title)
Definition: namespacedef.cpp:770
NamespaceDefAliasImpl::getMemberList
virtual MemberList * getMemberList(MemberListType lt) const
Definition: namespacedef.cpp:218
FileList
Definition: filedef.h:205
Definition::TypeFile
@ TypeFile
Definition: definition.h:88
OutputList::endContents
void endContents()
Definition: outputlist.h:363
MemberList::numDocMembers
int numDocMembers() const
Definition: memberlist.h:92
LayoutDocEntry::MemberDefStart
@ MemberDefStart
Definition: layout.h:38
NamespaceDef::getClasses
virtual ClassLinkedRefMap getClasses() const =0
NamespaceDefAliasImpl::numDocMembers
virtual int numDocMembers() const
Definition: namespacedef.cpp:190
NamespaceDefImpl
Definition: namespacedef.cpp:52
qstricmp
int qstricmp(const char *str1, const char *str2)
Definition: qcstring.cpp:433
LayoutDocEntry::DirFiles
@ DirFiles
Definition: layout.h:68
OutputList::lineBreak
void lineBreak(const QCString &style=QCString())
Definition: outputlist.h:300
theTranslator
Translator * theTranslator
Definition: language.cpp:156
NamespaceDefImpl::fileName
QCString fileName
Definition: namespacedef.cpp:140
Definition::name
virtual QCString name() const =0
NamespaceDefImpl::m_subGrouping
bool m_subGrouping
Definition: namespacedef.cpp:156
doxygen.h
MemberLinkedRefMap
Definition: memberlist.h:134
LayoutDocEntry::NamespaceExceptions
@ NamespaceExceptions
Definition: layout.h:53
OutputList::writeRuler
void writeRuler()
Definition: outputlist.h:237
LayoutDocEntry::FileConstantGroups
@ FileConstantGroups
Definition: layout.h:57
Definition::TypeConcept
@ TypeConcept
Definition: definition.h:95
MemberDef::getClassDef
virtual const ClassDef * getClassDef() const =0
NamespaceDefImpl::findSectionsInDocumentation
virtual void findSectionsInDocumentation()
Definition: namespacedef.cpp:322
language.h
NamespaceDefImpl::numDocMembers
virtual int numDocMembers() const
Definition: namespacedef.cpp:1168
NamespaceDefAliasImpl::definitionType
virtual DefType definitionType() const
Definition: namespacedef.cpp:179
NamespaceDefAliasImpl::anchor
virtual QCString anchor() const
Definition: namespacedef.cpp:188
NamespaceDefAliasImpl::getConcepts
virtual ConceptLinkedRefMap getConcepts() const
Definition: namespacedef.cpp:236
Translator::trGeneratedAutomatically
virtual QCString trGeneratedAutomatically(const QCString &s)=0
NamespaceDef::findInnerCompound
virtual const Definition * findInnerCompound(const QCString &name) const =0
validatingParseDoc
DocRoot * validatingParseDoc(IDocParser &parserIntf, const QCString &fileName, int startLine, const Definition *ctx, const MemberDef *md, const QCString &input, bool indexWords, bool isExample, const QCString &exampleName, bool singleLine, bool linkFromIndex, bool markdownSupport)
Definition: docparser.cpp:7495
DefinitionMutable::setOuterScope
virtual void setOuterScope(Definition *d)=0
MemberListType_docFuncMembers
@ MemberListType_docFuncMembers
Definition: types.h:168
getLanguageSpecificSeparator
QCString getLanguageSpecificSeparator(SrcLangExt lang, bool classScope)
Returns the scope separator to use given the programming language lang
Definition: util.cpp:6545
NamespaceDefImpl::CONSTANT_GROUP
@ CONSTANT_GROUP
Definition: namespacedef.cpp:157
LayoutDocEntry::GroupGraph
@ GroupGraph
Definition: layout.h:65
LayoutDocEntry::NamespaceStructs
@ NamespaceStructs
Definition: layout.h:53
OutputList::endParagraph
void endParagraph()
Definition: outputlist.h:109
startFile
void startFile(OutputList &ol, const QCString &name, const QCString &manName, const QCString &title, HighlightedItem hli, bool additionalIndices, const QCString &altSidebarName)
Definition: index.cpp:235
NamespaceDefImpl::getNamespaces
virtual NamespaceLinkedRefMap getNamespaces() const
Definition: namespacedef.cpp:109
NamespaceDef::getMemberList
virtual MemberList * getMemberList(MemberListType lt) const =0
docparser.h
NamespaceDefImpl::getMemberGroups
virtual const MemberGroupList & getMemberGroups() const
Definition: namespacedef.cpp:104
TRUE
#define TRUE
Definition: qcstring.h:36
OutputList::endMemberList
void endMemberList()
Definition: outputlist.h:199
createNamespaceDefAlias
NamespaceDef * createNamespaceDefAlias(const Definition *newScope, const NamespaceDef *nd)
Factory method to create an alias of an existing namespace.
Definition: namespacedef.cpp:244
NamespaceDefImpl::getOutputFileBase
virtual QCString getOutputFileBase() const
Definition: namespacedef.cpp:1185
NamespaceDefAliasImpl::isLibrary
virtual bool isLibrary() const
Definition: namespacedef.cpp:204
SrcLangExt_Fortran
@ SrcLangExt_Fortran
Definition: types.h:53
LayoutDocEntry::GroupNestedGroups
@ GroupNestedGroups
Definition: layout.h:64
MemberList::writeDeclarations
void writeDeclarations(OutputList &ol, const ClassDef *cd, const NamespaceDef *nd, const FileDef *fd, const GroupDef *gd, const QCString &title, const QCString &subtitle, bool showEnumValues=FALSE, bool showInline=FALSE, const ClassDef *inheritedFrom=0, MemberListType lt=MemberListType_pubMethods) const
Writes the list of members to the output.
Definition: memberlist.cpp:526
ClassDef::Struct
@ Struct
Definition: classdef.h:108
OutputList::endMemberItem
void endMemberItem()
Definition: outputlist.h:211
OutputGenerator::Html
@ Html
Definition: outputgen.h:333
LinkedMap::find
const T * find(const std::string &key) const
Find an object given the key.
Definition: linkedmap.h:60
toClassDef
ClassDef * toClassDef(Definition *d)
Definition: classdef.cpp:4907
NamespaceDefAliasImpl::subGrouping
virtual bool subGrouping() const
Definition: namespacedef.cpp:216
NamespaceDefImpl::setInline
virtual void setInline(bool isInline)
Definition: namespacedef.cpp:84
OutputList::enableAll
void enableAll()
Definition: outputlist.cpp:84
Definition::DefType
DefType
Definition: definition.h:85
NamespaceDef::getNamespaces
virtual NamespaceLinkedRefMap getNamespaces() const =0
MemberListType_decEnumMembers
@ MemberListType_decEnumMembers
Definition: types.h:152
SrcLangExt_CSharp
@ SrcLangExt_CSharp
Definition: types.h:46
NamespaceDefImpl::LIBRARY
@ LIBRARY
Definition: namespacedef.cpp:157
NamespaceDefImpl::getInterfaces
virtual ClassLinkedRefMap getInterfaces() const
Definition: namespacedef.cpp:106
NamespaceDefImpl::insertUsedFile
virtual void insertUsedFile(FileDef *fd)
Definition: namespacedef.cpp:339
LinkedRefMap::begin
iterator begin()
Definition: linkedmap.h:366
memberlist.h
DefinitionAliasMixin
Definition: definitionimpl.h:312
addRefItem
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:4880
DefinitionMixin< NamespaceDefMutable >::docLine
virtual int docLine() const
Definition: definitionimpl.h:163
NamespaceDefImpl::writeDetailedDescription
void writeDetailedDescription(OutputList &ol, const QCString &title)
Definition: namespacedef.cpp:633
Definition::TypeClass
@ TypeClass
Definition: definition.h:87
NamespaceDefImpl::m_allMembers
MemberLinkedRefMap m_allMembers
Definition: namespacedef.cpp:147
OutputList::startContents
void startContents()
Definition: outputlist.h:361
Definition::definitionType
virtual DefType definitionType() const =0
OutputList::startGroupHeader
void startGroupHeader(int extraLevels=0)
Definition: outputlist.h:169
MemberDefMutable::setNamespace
virtual void setNamespace(const NamespaceDef *nd)=0
Translator::trConstantGroupReference
virtual QCString trConstantGroupReference(const QCString &namespaceName)=0
NamespaceDefImpl::m_innerCompounds
LinkedRefMap< const Definition > m_innerCompounds
Definition: namespacedef.cpp:145
MemberListType_decDefineMembers
@ MemberListType_decDefineMembers
Definition: types.h:149
OutputList::endMemberSections
void endMemberSections()
Definition: outputlist.h:179
OutputList::popGeneratorState
void popGeneratorState()
Definition: outputlist.cpp:134
OutputList::startTextLink
void startTextLink(const QCString &file, const QCString &anchor)
Definition: outputlist.h:152
MemberType_Dictionary
@ MemberType_Dictionary
Definition: types.h:291
ClassDef::compoundType
virtual CompoundType compoundType() const =0
Returns the type of compound this is, i.e.
NamespaceDefImpl::writeQuickMemberLinks
virtual void writeQuickMemberLinks(OutputList &ol, const MemberDef *currentMd) const
Definition: namespacedef.cpp:1113
Definition::codeSymbolType
virtual CodeSymbolType codeSymbolType() const =0
HLI_NamespaceVisible
@ HLI_NamespaceVisible
Definition: index.h:173
NamespaceDefImpl::insertMember
virtual void insertMember(MemberDef *md)
Definition: namespacedef.cpp:421
docFindSections
void docFindSections(const QCString &input, const Definition *d, const QCString &fileName)
Definition: docparser.cpp:7681
NamespaceDefImpl::MODULE
@ MODULE
Definition: namespacedef.cpp:157
NamespaceDefImpl::getMemberList
virtual MemberList * getMemberList(MemberListType lt) const
Definition: namespacedef.cpp:1419
MemberListType_decFuncMembers
@ MemberListType_decFuncMembers
Definition: types.h:153
DefinitionMixin< NamespaceDefMutable >::documentation
virtual QCString documentation() const
Definition: definitionimpl.h:162
Translator::trNamespace
virtual QCString trNamespace(bool first_capital, bool singular)=0
NamespaceDefImpl::getStructs
virtual ClassLinkedRefMap getStructs() const
Definition: namespacedef.cpp:107
NamespaceDefImpl::m_usingDeclList
LinkedRefMap< const ClassDef > m_usingDeclList
Definition: namespacedef.cpp:144
classdef.h
QCString::mid
QCString mid(size_t index, size_t len=static_cast< size_t >(-1)) const
Definition: qcstring.h:224
OutputList::endMemberHeader
void endMemberHeader()
Definition: outputlist.h:187
substitute
QCString substitute(const QCString &s, const QCString &src, const QCString &dst)
substitute all occurrences of src in s by dst
Definition: qcstring.cpp:465
NamespaceDefImpl::getMemberLists
virtual const MemberLists & getMemberLists() const
Definition: namespacedef.cpp:102
NamespaceDefImpl::definitionType
virtual DefType definitionType() const
Definition: namespacedef.cpp:60
RefItemVector
std::vector< RefItem * > RefItemVector
Definition: reflist.h:132
NamespaceDef::getConcepts
virtual ConceptLinkedRefMap getConcepts() const =0
NamespaceDefAliasImpl::~NamespaceDefAliasImpl
virtual ~NamespaceDefAliasImpl()
Definition: namespacedef.cpp:178
MemberList::setAnchors
void setAnchors()
Definition: memberlist.cpp:975
LayoutDocEntry::ClassAllMembersLink
@ ClassAllMembersLink
Definition: layout.h:45
NamespaceDef::isLinkable
virtual bool isLinkable() const =0
NamespaceDefImpl::classes
ClassLinkedRefMap classes
Definition: namespacedef.cpp:150
Config_getBool
#define Config_getBool(name)
Definition: config.h:33
NamespaceDefImpl::startMemberDocumentation
void startMemberDocumentation(OutputList &ol)
Definition: namespacedef.cpp:747
LayoutDocEntry::GroupDirs
@ GroupDirs
Definition: layout.h:64
layout.h
NamespaceDefImpl::codeSymbolType
virtual CodeSymbolType codeSymbolType() const
Definition: namespacedef.cpp:61
toNamespaceDef
NamespaceDef * toNamespaceDef(Definition *d)
Definition: namespacedef.cpp:1541
MemberList::writeDocumentation
void writeDocumentation(OutputList &ol, const QCString &scopeName, const Definition *container, const QCString &title, bool showEnumValues=FALSE, bool showInline=FALSE) const
Definition: memberlist.cpp:658
LayoutDocEntry::DetailedDesc
@ DetailedDesc
Definition: layout.h:39
MemberListType_documentationLists
@ MemberListType_documentationLists
Definition: types.h:105
NamespaceDefImpl::addUsingDeclaration
virtual void addUsingDeclaration(const ClassDef *cd)
Definition: namespacedef.cpp:1180
MemberListType_docVarMembers
@ MemberListType_docVarMembers
Definition: types.h:169
LayoutDocManager::instance
static LayoutDocManager & instance()
Returns a reference to this singleton.
Definition: layout.cpp:1574
LayoutDocEntry::FileInterfaces
@ FileInterfaces
Definition: layout.h:57
NamespaceDefImpl::addMembersToMemberGroup
virtual void addMembersToMemberGroup()
Definition: namespacedef.cpp:400
DefinitionMixin< NamespaceDefMutable >::hasDocumentation
virtual bool hasDocumentation() const
Definition: definitionimpl.h:176
NamespaceDefAliasImpl::findInnerCompound
virtual const Definition * findInnerCompound(const QCString &name) const
Definition: namespacedef.cpp:214
MemberGroupList
Definition: membergroup.h:109
NamespaceDefImpl::NAMESPACE
@ NAMESPACE
Definition: namespacedef.cpp:157
OutputList::writeSynopsis
void writeSynopsis()
Definition: outputlist.h:337
MemberListType_decTypedefMembers
@ MemberListType_decTypedefMembers
Definition: types.h:151
OutputList::parseText
void parseText(const QCString &textStr)
Definition: outputlist.cpp:179
NamespaceDefImpl::addNamespaceAttributes
void addNamespaceAttributes(OutputList &ol)
Definition: namespacedef.cpp:886
NamespaceDefImpl::isLinkable
virtual bool isLinkable() const
Definition: namespacedef.cpp:1462
NamespaceDefImpl::writeSummaryLinks
void writeSummaryLinks(OutputList &ol) const
Definition: namespacedef.cpp:811
NamespaceLinkedRefMap::declVisible
bool declVisible(bool isContantGroup) const
Definition: namespacedef.cpp:1284
MemberType_Sequence
@ MemberType_Sequence
Definition: types.h:290
qPrint
const char * qPrint(const char *s)
Definition: qcstring.h:589
Translator::trModule
virtual QCString trModule(bool first_capital, bool singular)=0
SrcLangExt_IDL
@ SrcLangExt_IDL
Definition: types.h:44
ConceptLinkedRefMap
Definition: conceptdef.h:67
LayoutDocEntry::MemberGroups
@ MemberGroups
Definition: layout.h:36
Config_getString
#define Config_getString(name)
Definition: config.h:32
LayoutDocEntry::ClassInlineClasses
@ ClassInlineClasses
Definition: layout.h:43
LinkedRefMap::end
iterator end()
Definition: linkedmap.h:367
OutputList::generateDoc
void generateDoc(const QCString &fileName, int startLine, const Definition *ctx, const MemberDef *md, const QCString &docStr, bool indexWords, bool isExample, const QCString &exampleName, bool singleLine, bool linkFromIndex, bool markdownSupport)
Definition: outputlist.cpp:142
addGroupListToTitle
void addGroupListToTitle(OutputList &ol, const Definition *d)
Definition: util.cpp:4929
NamespaceDef::compoundTypeString
virtual QCString compoundTypeString() const =0
NamespaceDef::numDocMembers
virtual int numDocMembers() const =0
NamespaceDefImpl::metaData
QCString metaData
Definition: namespacedef.cpp:159
convertNameToFile
QCString convertNameToFile(const QCString &name, bool allowDots, bool allowUnderscore)
Definition: util.cpp:3604
config.h
err_full
void err_full(const QCString &file, int line, const char *fmt,...)
Definition: message.cpp:212
ClassLinkedRefMap::declVisible
bool declVisible(const ClassDef::CompoundType *filter=0) const
Definition: classlist.cpp:29
Doxygen::namespaceLinkedMap
static NamespaceLinkedMap * namespaceLinkedMap
Definition: doxygen.h:97
NamespaceDefAliasImpl::getClasses
virtual ClassLinkedRefMap getClasses() const
Definition: namespacedef.cpp:226
OutputList::pushGeneratorState
void pushGeneratorState()
Definition: outputlist.cpp:126
Translator::trModuleReference
virtual QCString trModuleReference(const QCString &namespaceName)=0
convertToXML
QCString convertToXML(const QCString &s, bool keepEntities)
Definition: util.cpp:3948
NamespaceDefMutable
Definition: namespacedef.h:106
FileDef
A model of a file symbol.
Definition: filedef.h:73
NamespaceDefImpl::insertClass
virtual void insertClass(const ClassDef *cd)
Definition: namespacedef.cpp:366
DefinitionMixin< NamespaceDefMutable >::setReference
virtual void setReference(const QCString &r)
Definition: definitionimpl.h:214
toFileDef
FileDef * toFileDef(Definition *d)
Definition: filedef.cpp:1778
MemberType_Define
@ MemberType_Define
Definition: types.h:276
LayoutDocEntry::BriefDesc
@ BriefDesc
Definition: layout.h:39
NamespaceDefAliasImpl::getInterfaces
virtual ClassLinkedRefMap getInterfaces() const
Definition: namespacedef.cpp:228
DefinitionMixin< NamespaceDefMutable >::isArtificial
virtual bool isArtificial() const
Definition: definitionimpl.h:181
LayoutDocEntry::NamespaceConcepts
@ NamespaceConcepts
Definition: layout.h:53
NamespaceDefAliasImpl::getUsedNamespaces
virtual LinkedRefMap< const NamespaceDef > getUsedNamespaces() const
Definition: namespacedef.cpp:192
NamespaceDefImpl::writeMemberGroups
void writeMemberGroups(OutputList &ol)
Definition: namespacedef.cpp:786
conceptdef.h
stripExtension
QCString stripExtension(const QCString &fName)
Definition: util.cpp:5295
LayoutDocEntry::DirGraph
@ DirGraph
Definition: layout.h:68
DefinitionMixin< NamespaceDefMutable >::writeNavigationPath
virtual void writeNavigationPath(OutputList &ol) const
Definition: definitionimpl.h:258
NamespaceDefImpl::writeConceptsToTagFile
void writeConceptsToTagFile(TextStream &)
Definition: namespacedef.cpp:912
LayoutDocEntry::FileIncludeGraph
@ FileIncludeGraph
Definition: layout.h:58
LayoutDocEntry::FileIncludedByGraph
@ FileIncludedByGraph
Definition: layout.h:59
Doxygen::suppressDocWarnings
static bool suppressDocWarnings
Definition: doxygen.h:112
OutputList::writeObjectLink
void writeObjectLink(const QCString &ref, const QCString &file, const QCString &anchor, const QCString &name)
Definition: outputlist.h:141
LayoutDocEntry::ClassUsedFiles
@ ClassUsedFiles
Definition: layout.h:46
LayoutDocEntry::FileSourceLink
@ FileSourceLink
Definition: layout.h:59
OutputList::startMemberDeclaration
void startMemberDeclaration()
Definition: outputlist.h:310
searchindex.h
NamespaceDef::getStructs
virtual ClassLinkedRefMap getStructs() const =0
LinkedRefMap::find
const T * find(const std::string &key) const
find an object given the key.
Definition: linkedmap.h:243
NamespaceDefAliasImpl::title
virtual QCString title() const
Definition: namespacedef.cpp:238
NamespaceDefImpl::findInnerCompound
virtual const Definition * findInnerCompound(const QCString &name) const
Definition: namespacedef.cpp:1190
NamespaceDefAliasImpl::isConstantGroup
virtual bool isConstantGroup() const
Definition: namespacedef.cpp:200
ClassDef::Exception
@ Exception
Definition: classdef.h:113
LayoutDocEntry::ClassNestedClasses
@ ClassNestedClasses
Definition: layout.h:44
MemberDefMutable::setFileDef
virtual void setFileDef(const FileDef *fd)=0
util.h
A bunch of utility functions.
NamespaceDefAliasImpl::getNSAlias
const NamespaceDef * getNSAlias() const
Definition: namespacedef.cpp:181
DefinitionAliasMixin< NamespaceDef >::init
void init()
Definition: definitionimpl.h:318
createSubDirs
void createSubDirs(const Dir &d)
Definition: util.cpp:3677
NamespaceDefAliasImpl::isLinkable
virtual bool isLinkable() const
Definition: namespacedef.cpp:210
NamespaceDefImpl::getExceptions
virtual ClassLinkedRefMap getExceptions() const
Definition: namespacedef.cpp:108
Definition::localName
virtual QCString localName() const =0
LayoutDocEntry::FileExceptions
@ FileExceptions
Definition: layout.h:57
NamespaceDefImpl::localName
virtual QCString localName() const
Definition: namespacedef.cpp:1241
OutputList::enable
void enable(OutputGenerator::OutputType o)
Definition: outputlist.cpp:108
NamespaceLinkedRefMap::writeDeclaration
void writeDeclaration(OutputList &ol, const QCString &title, bool isConstantGroup=false, bool localName=FALSE)
Definition: namespacedef.cpp:1314
NamespaceDefSet
std::set< const NamespaceDef * > NamespaceDefSet
Definition: namespacedef.h:39
NamespaceDefImpl::sortMemberLists
virtual void sortMemberLists()
Definition: namespacedef.cpp:1391
CodeSymbolType
CodeSymbolType
Definition: types.h:204
LayoutDocEntry::NamespaceInterfaces
@ NamespaceInterfaces
Definition: layout.h:53
MemberList
A list of MemberDef objects as shown in documentation sections.
Definition: memberlist.h:81
LayoutDocEntry::FileInlineClasses
@ FileInlineClasses
Definition: layout.h:60
LayoutDocEntry::GroupNamespaces
@ GroupNamespaces
Definition: layout.h:63
NamespaceDefAliasImpl::getExceptions
virtual ClassLinkedRefMap getExceptions() const
Definition: namespacedef.cpp:232
ClassLinkedRefMap
Definition: classlist.h:30
NamespaceDefImpl::startMemberDeclarations
void startMemberDeclarations(OutputList &ol)
Definition: namespacedef.cpp:737
LinkedRefMap::size
size_t size() const
Definition: linkedmap.h:375
DefinitionAliasMixin< NamespaceDef >::getAlias
const Definition * getAlias() const
Definition: definitionimpl.h:426
ClassDef::className
virtual QCString className() const =0
Returns the name of the class including outer classes, but not including namespaces.
MemberListType_docTypedefMembers
@ MemberListType_docTypedefMembers
Definition: types.h:166
OutputList::endTextLink
void endTextLink()
Definition: outputlist.h:154
MemberDef::memberType
virtual MemberType memberType() const =0
NamespaceDef::isLibrary
virtual bool isLibrary() const =0
NamespaceDefImpl::isInline
virtual bool isInline() const
Definition: namespacedef.cpp:88
convertToHtml
QCString convertToHtml(const QCString &s, bool keepEntities)
Definition: util.cpp:4063
NamespaceDefImpl::m_type
enum NamespaceDefImpl::@2 m_type
NamespaceDefImpl::setMetaData
virtual void setMetaData(const QCString &m)
Definition: namespacedef.cpp:1534
LayoutDocEntry::MemberDecl
@ MemberDecl
Definition: layout.h:37
OutputList::startParagraph
void startParagraph(const QCString &classDef=QCString())
Definition: outputlist.h:107
DefinitionMixin
Definition: definitionimpl.h:142
vhdldocgen.h
NamespaceDefMutable::insertMember
virtual void insertMember(MemberDef *md)=0
LayoutDocEntry::AuthorSection
@ AuthorSection
Definition: layout.h:40
LayoutDocEntrySection::title
QCString title(SrcLangExt lang) const
Definition: layout.cpp:1661
createDocParser
std::unique_ptr< IDocParser > createDocParser()
Definition: docparser.cpp:179
FileDef::insertMember
virtual void insertMember(MemberDef *md)=0
FALSE
#define FALSE
Definition: qcstring.h:33
NamespaceDefImpl::exceptions
ClassLinkedRefMap exceptions
Definition: namespacedef.cpp:153
NamespaceDefAliasImpl::getMemberGroups
virtual const MemberGroupList & getMemberGroups() const
Definition: namespacedef.cpp:224
Translator::trAuthor
virtual QCString trAuthor(bool first_capital, bool singular)=0
makeDisplayName
static QCString makeDisplayName(const NamespaceDef *nd, bool includeScope)
Definition: namespacedef.cpp:38
SrcLangExt_Slice
@ SrcLangExt_Slice
Definition: types.h:59
NamespaceDefAliasImpl::hasDetailedDescription
virtual bool hasDetailedDescription() const
Definition: namespacedef.cpp:212
OutputGenerator::Man
@ Man
Definition: outputgen.h:333
QCString
This is an alternative implementation of QCString.
Definition: qcstring.h:108