1 /******************************************************************************
2 *
3 * Copyright (C) 1997-2015 by Dimitri van Heesch.
4 *
5 * Permission to use, copy, modify, and distribute this software and its
6 * documentation under the terms of the GNU General Public License is hereby
7 * granted. No representations are made about the suitability of this software
8 * for any purpose. It is provided "as is" without express or implied warranty.
9 * See the GNU General Public License for more details.
10 *
11 * Documents produced by Doxygen are derivative works derived from the
12 * input used in their production; they are not affected by this license.
13 *
14 */
15
16 #include <assert.h>
17 #include <sstream>
18
19 #include "context.h"
20 #include "config.h"
21 #include "index.h"
22 #include "classlist.h"
23 #include "doxygen.h"
24 #include "namespacedef.h"
25 #include "filedef.h"
26 #include "pagedef.h"
27 #include "groupdef.h"
28 #include "util.h"
29 #include "version.h"
30 #include "language.h"
31 #include "message.h"
32 #include "vhdldocgen.h"
33 #include "filename.h"
34 #include "dirdef.h"
35 #include "docparser.h"
36 #include "htmlgen.h"
37 #include "htmldocvisitor.h"
38 #include "htmlhelp.h"
39 #include "latexgen.h"
40 #include "latexdocvisitor.h"
41 #include "dot.h"
42 #include "dotcallgraph.h"
43 #include "dotclassgraph.h"
44 #include "dotdirdeps.h"
45 #include "dotgfxhierarchytable.h"
46 #include "dotgroupcollaboration.h"
47 #include "dotincldepgraph.h"
48 #include "diagram.h"
49 #include "example.h"
50 #include "membername.h"
51 #include "parserintf.h"
52 #include "portable.h"
53 #include "arguments.h"
54 #include "groupdef.h"
55 #include "searchindex.h"
56 #include "resourcemgr.h"
57 #include "dir.h"
58
59 // TODO: pass the current file to Dot*::writeGraph, so the user can put dot graphs in other
60 // files as well
61
62 enum ContextOutputFormat
63 {
64 ContextOutputFormat_Unspecified=0,
65 ContextOutputFormat_Html,
66 ContextOutputFormat_Latex,
67 ContextOutputFormat_Rtf,
68 ContextOutputFormat_ManPage,
69 ContextOutputFormat_DocBook,
70 ContextOutputFormat_Xml,
71 ContextOutputFormat_TagFile
72 };
73
74 struct ContextGlobals
75 {
76 int dynSectionId;
77 QCString outputDir;
78 ContextOutputFormat outputFormat;
79 } g_globals;
80
81
82 /** Wrapper for data that needs to be cached.
83 * The cached data can be accessed via the get() method from multiple threads.
84 * The first thread that calls get() will trigger creation of the data item via
85 * the creator method, blocking other threads until the item is available in the cache.
86 * @tparam T the type of the data item in the cache.
87 * @tparam TOwner the class containing the cached item.
88 * @tparam creator the method of TOwner to call in order to create the data item to be cached.
89 */
90 template<typename T, typename TOwner, T(TOwner::*creator)() const>
91 class CachedItem
92 {
93 public:
94 /** Returns a reference to the cached data.
95 * Conceptually this is a const method, i.e. it will always return the same data
96 * The first time it is called, the owner will be asked to create the data.
97 */
get(const TOwner * owner) const98 T &get(const TOwner *owner) const
99 {
100 // create a lamda function to create the cached data
101 auto creatorFunc = [this,owner]() { m_item = (owner->*creator)(); };
102 // use std::call_once to let one thread invoke the creator func
103 std::call_once(m_cache_flag, creatorFunc);
104 // return the cached results
105 return m_item;
106 }
107 private:
108 mutable std::once_flag m_cache_flag; // flag to keep track if the item is already cached
109 mutable T m_item; // the cached data item
110 };
111
112 //------------------------------------------------------------------------
113
114 /** Class representing a mapping of properties and the corresponding getter function.
115 * The map should be initialized at initialization time.
116 */
117 template<class T>
118 class PropertyMap
119 {
120 public:
121 using Map = std::map< std::string, TemplateVariant(T::*)() const >;
122
PropertyMap(std::initializer_list<typename Map::value_type> init)123 PropertyMap(std::initializer_list<typename Map::value_type> init)
124 : m_map(init) {}
125
get(const T * obj,const QCString & n) const126 TemplateVariant get(const T *obj,const QCString &n) const
127 {
128 auto it = m_map.find(n.str());
129 return it!=m_map.end() ? (obj->*(it->second))() : TemplateVariant();
130 }
fields() const131 StringVector fields() const
132 {
133 StringVector result;
134 result.reserve(m_map.size());
135 for (const auto &imap : m_map) result.push_back(imap.first);
136 return result;
137 }
138
map()139 Map &map() { return m_map; }
140
141 private:
142 const Map m_map;
143 };
144
145 //------------------------------------------------------------------------
146
147 /** @brief Template List iterator support */
148 class GenericConstIterator : public TemplateListIntf::ConstIterator
149 {
150 public:
GenericConstIterator(const TemplateVariantList & list)151 GenericConstIterator(const TemplateVariantList &list) : m_list(list) {}
~GenericConstIterator()152 virtual ~GenericConstIterator() {}
toFirst()153 void toFirst()
154 {
155 m_index=0;
156 }
toLast()157 void toLast()
158 {
159 m_index=static_cast<int>(m_list.size())-1;
160 }
toNext()161 void toNext()
162 {
163 if (m_index < static_cast<int>(m_list.size())) ++m_index;
164 }
toPrev()165 void toPrev()
166 {
167 if (m_index>=0) --m_index;
168 }
current(TemplateVariant & v) const169 bool current(TemplateVariant &v) const
170 {
171 if (m_index>=0 && m_index < static_cast<int>(m_list.size()))
172 {
173 v = m_list[m_index];
174 return true;
175 }
176 else
177 {
178 v = TemplateVariant();
179 return false;
180 }
181 }
182 private:
183 const TemplateVariantList &m_list;
184 int m_index=0;
185 };
186
187 //------------------------------------------------------------------------
188
189 /** @brief standard template list implementation */
190 class GenericNodeListContext : public TemplateListIntf
191 {
192 public:
GenericNodeListContext()193 GenericNodeListContext()
194 {
195 }
alloc()196 static TemplateListIntfPtr alloc()
197 {
198 return std::static_pointer_cast<TemplateListIntf>(std::make_shared<GenericNodeListContext>());
199 }
200
201 // TemplateListIntf methods
count() const202 uint count() const
203 {
204 return static_cast<uint>(m_children.size());
205 }
at(uint index) const206 TemplateVariant at(uint index) const
207 {
208 TemplateVariant result;
209 if (index<count())
210 {
211 result = m_children[index];
212 }
213 return result;
214 }
createIterator() const215 TemplateListIntf::ConstIteratorPtr createIterator() const
216 {
217 return std::make_unique<GenericConstIterator>(m_children);
218 }
219
append(const TemplateVariant & ctn)220 void append(const TemplateVariant &ctn)
221 {
222 m_children.emplace_back(ctn);
223 }
isEmpty() const224 bool isEmpty() const
225 {
226 return m_children.empty();
227 }
228 private:
229 std::vector< TemplateVariant > m_children;
230 };
231
232 //------------------------------------------------------------------------
233
234 //%% struct Config : configuration options
235 //%% {
236 class ConfigContext::Private
237 {
238 public:
239 // TemplateStructIntf methods
fields() const240 StringVector fields() const
241 {
242 return m_fields.get(this);
243 }
get(const QCString & name) const244 TemplateVariant get(const QCString &name) const
245 {
246 auto &data = m_configData.get(this);
247 auto it = data.find(name.str());
248 return (it!=data.end()) ? it->second : TemplateVariant();
249 }
250 private:
251 using ConfigData = std::map<std::string,TemplateVariant>;
252
createConfigData() const253 ConfigData createConfigData() const
254 {
255 std::map<std::string,TemplateVariant> map;
256 for (auto name : ConfigValues::instance().fields())
257 {
258 const ConfigValues::Info *option = ConfigValues::instance().get(QCString(name));
259 if (option)
260 {
261 switch (option->type)
262 {
263 case ConfigValues::Info::Bool:
264 {
265 bool b = ConfigValues::instance().*(option->value.b);
266 map.insert(std::make_pair(name,TemplateVariant(b)));
267 }
268 break;
269 case ConfigValues::Info::Int:
270 {
271 int i = ConfigValues::instance().*(option->value.i);
272 map.insert(std::make_pair(name,TemplateVariant(i)));
273 }
274 break;
275 case ConfigValues::Info::String:
276 {
277 QCString s = ConfigValues::instance().*(option->value.s);
278 map.insert(std::make_pair(name,TemplateVariant(s)));
279 }
280 break;
281 case ConfigValues::Info::List:
282 {
283 auto fetchList = [](const StringVector &list) -> TemplateVariant
284 {
285 TemplateVariantList elements;
286 elements.reserve(list.size());
287 for (const auto &s : list)
288 {
289 elements.push_back(TemplateVariant(s));
290 }
291 return TemplateImmutableList::alloc(elements);
292 };
293 const StringVector &l = ConfigValues::instance().*(option->value.l);
294 map.insert(std::make_pair(name,fetchList(l)));
295 }
296 break;
297 default:
298 break;
299 }
300 }
301 }
302 return map;
303 }
304
createFields() const305 StringVector createFields() const
306 {
307 return ConfigValues::instance().fields();
308 }
309
310 CachedItem<StringVector, Private, &Private::createFields > m_fields;
311 CachedItem<ConfigData, Private, &Private::createConfigData> m_configData;
312 };
313 //%% }
314
ConfigContext()315 ConfigContext::ConfigContext() : p(std::make_unique<Private>())
316 {
317 }
318
~ConfigContext()319 ConfigContext::~ConfigContext()
320 {
321 }
322
get(const QCString & name) const323 TemplateVariant ConfigContext::get(const QCString &name) const
324 {
325 return p->get(name);
326 }
327
fields() const328 StringVector ConfigContext::fields() const
329 {
330 return p->fields();
331 }
332
333 //------------------------------------------------------------------------
334
335 class DoxygenContext::Private
336 {
337 public:
338 // TemplateStructIntf methods
get(const QCString & n) const339 TemplateVariant get(const QCString &n) const { return s_inst.get(this,n); }
fields() const340 StringVector fields() const { return s_inst.fields(); }
341
342 private:
343 // Property getters
version() const344 TemplateVariant version() const { return getDoxygenVersion(); }
date() const345 TemplateVariant date() const { return dateToString(TRUE); }
mathJaxCodeFile() const346 TemplateVariant mathJaxCodeFile() const { return m_mathJaxCodeFile.get(this); }
mathJaxMacros() const347 TemplateVariant mathJaxMacros() const { return m_mathJaxMacros.get(this); }
348
349 private:
createMathJaxCodeFile() const350 QCString createMathJaxCodeFile() const { return fileToString(Config_getString(MATHJAX_CODEFILE)); }
createMathJaxMacros() const351 QCString createMathJaxMacros() const { return HtmlGenerator::getMathJaxMacros(); }
352 CachedItem<QCString, Private, &Private::createMathJaxCodeFile> m_mathJaxCodeFile;
353 CachedItem<QCString, Private, &Private::createMathJaxMacros> m_mathJaxMacros;
354 static const PropertyMap<DoxygenContext::Private> s_inst;
355 };
356
357 //%% struct Doxygen: global information
358 //%% {
359 const PropertyMap<DoxygenContext::Private> DoxygenContext::Private::s_inst {
360 {
361 //%% string version
362 { "version", &Private::version },
363 //%% string date
364 { "date", &Private::date },
365 //%% string maxJaxCodeFile
366 { "mathJaxCodeFile", &Private::mathJaxCodeFile },
367 //%% string maxJaxMacros
368 { "mathJaxMacros", &Private::mathJaxMacros }
369 } };
370 //%% }
371
DoxygenContext()372 DoxygenContext::DoxygenContext() : p(std::make_unique<Private>())
373 {
374 }
375
~DoxygenContext()376 DoxygenContext::~DoxygenContext()
377 {
378 }
379
get(const QCString & n) const380 TemplateVariant DoxygenContext::get(const QCString &n) const
381 {
382 return p->get(n);
383 }
384
fields() const385 StringVector DoxygenContext::fields() const
386 {
387 return p->fields();
388 }
389
390 //------------------------------------------------------------------------
391
392 class TranslateContext::Private
393 {
394 public:
395
Private()396 Private()
397 {
398 m_javaOpt = Config_getBool(OPTIMIZE_OUTPUT_JAVA);
399 m_fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
400 m_vhdlOpt = Config_getBool(OPTIMIZE_OUTPUT_VHDL);
401 m_sliceOpt = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
402 }
403
404 // TemplateStructIntf methods
get(const QCString & n) const405 TemplateVariant get(const QCString &n) const { return s_inst.get(this,n); }
fields() const406 StringVector fields() const { return s_inst.fields(); }
407 private:
408
409 // Handlers for properties with parameters
handleGeneratedAt(const TemplateVariantList & args) const410 TemplateVariant handleGeneratedAt(const TemplateVariantList &args) const
411 {
412 if (args.size()==2)
413 {
414 return theTranslator->trGeneratedAt(args[0].toString(),args[1].toString());
415 }
416 else
417 {
418 err("tr.generateAt should take two arguments, got %zu!\n",args.size());
419 }
420 return TemplateVariant();
421 }
handleInheritanceDiagramFor(const TemplateVariantList & args) const422 TemplateVariant handleInheritanceDiagramFor(const TemplateVariantList &args) const
423 {
424 if (args.size()==1)
425 {
426 return theTranslator->trClassDiagram(args[0].toString());
427 }
428 else
429 {
430 err("tr.inheritanceDiagramFor should take one argument, got %zu!\n",args.size());
431 }
432 return TemplateVariant();
433 }
handleCollaborationDiagramFor(const TemplateVariantList & args) const434 TemplateVariant handleCollaborationDiagramFor(const TemplateVariantList &args) const
435 {
436 if (args.size()==1)
437 {
438 return theTranslator->trCollaborationDiagram(args[0].toString());
439 }
440 else
441 {
442 err("tr.collaborationDiagramFor should take one argument, got %zu!\n",args.size());
443 }
444 return TemplateVariant();
445 }
handleDirDependencyGraphFor(const TemplateVariantList & args) const446 TemplateVariant handleDirDependencyGraphFor(const TemplateVariantList &args) const
447 {
448 if (args.size()==1)
449 {
450 return theTranslator->trDirDepGraph(args[0].toString());
451 }
452 else
453 {
454 err("tr.dirDependencyGraphFor should take one argument, got %zu!\n",args.size());
455 }
456 return TemplateVariant();
457 }
handleInheritsList(const TemplateVariantList & args) const458 TemplateVariant handleInheritsList(const TemplateVariantList &args) const
459 {
460 if (args.size()==1)
461 {
462 return theTranslator->trInheritsList(args[0].toInt());
463 }
464 else
465 {
466 err("tr.inheritsList should take one integer argument, got %zu!\n",args.size());
467 }
468 return TemplateVariant();
469 }
handleInheritedByList(const TemplateVariantList & args) const470 TemplateVariant handleInheritedByList(const TemplateVariantList &args) const
471 {
472 if (args.size()==1)
473 {
474 return theTranslator->trInheritedByList(args[0].toInt());
475 }
476 else
477 {
478 err("tr.inheritedByList should take one integer argument, got %zu!\n",args.size());
479 }
480 return TemplateVariant();
481 }
handleWriteList(const TemplateVariantList & args) const482 TemplateVariant handleWriteList(const TemplateVariantList &args) const
483 {
484 if (args.size()==1)
485 {
486 return theTranslator->trWriteList(args[0].toInt());
487 }
488 else
489 {
490 err("tr.*List should take one integer argument, got %zu!\n",args.size());
491 }
492 return TemplateVariant();
493 }
handleImplementedBy(const TemplateVariantList & args) const494 TemplateVariant handleImplementedBy(const TemplateVariantList &args) const
495 {
496 if (args.size()==1)
497 {
498 return theTranslator->trImplementedInList(args[0].toInt());
499 }
500 else
501 {
502 err("tr.implementedBy should take one integer argument, got %zu!\n",args.size());
503 }
504 return TemplateVariant();
505 }
handleReimplementedBy(const TemplateVariantList & args) const506 TemplateVariant handleReimplementedBy(const TemplateVariantList &args) const
507 {
508 if (args.size()==1)
509 {
510 return theTranslator->trReimplementedInList(args[0].toInt());
511 }
512 else
513 {
514 err("tr.reimplementedBy should take one integer argument, got %zu!\n",args.size());
515 }
516 return TemplateVariant();
517 }
handleSourceRefs(const TemplateVariantList & args) const518 TemplateVariant handleSourceRefs(const TemplateVariantList &args) const
519 {
520 if (args.size()==1)
521 {
522 return theTranslator->trReferences()+" "+theTranslator->trWriteList(args[0].toInt())+".";
523 }
524 else
525 {
526 err("tr.sourceRefs should take one integer argument, got %zu\n",args.size());
527 }
528 return TemplateVariant();
529 }
handleSourceRefBys(const TemplateVariantList & args) const530 TemplateVariant handleSourceRefBys(const TemplateVariantList &args) const
531 {
532 if (args.size()==1)
533 {
534 return theTranslator->trReferencedBy()+" "+theTranslator->trWriteList(args[0].toInt())+".";
535 }
536 else
537 {
538 err("tr.sourceRefBys should take one integer argument, got %zu\n",args.size());
539 }
540 return TemplateVariant();
541 }
handleIncludeDependencyGraph(const TemplateVariantList & args) const542 TemplateVariant handleIncludeDependencyGraph(const TemplateVariantList &args) const
543 {
544 if (args.size()==1)
545 {
546 return theTranslator->trInclDepGraph(args[0].toString());
547 }
548 else
549 {
550 err("tr.includeDependencyGraph should take one string argument, got %zu\n",args.size());
551 }
552 return TemplateVariant();
553 }
554
555 // Property getters
generatedBy() const556 TemplateVariant generatedBy() const
557 {
558 return theTranslator->trGeneratedBy();
559 }
generatedAt() const560 TemplateVariant generatedAt() const
561 {
562 return TemplateVariant(std::bind(&Private::handleGeneratedAt,this,std::placeholders::_1));
563 }
inheritanceDiagramFor() const564 TemplateVariant inheritanceDiagramFor() const
565 {
566 return TemplateVariant(std::bind(&Private::handleInheritanceDiagramFor,this,std::placeholders::_1));
567 }
collaborationDiagramFor() const568 TemplateVariant collaborationDiagramFor() const
569 {
570 return TemplateVariant(std::bind(&Private::handleCollaborationDiagramFor,this,std::placeholders::_1));
571 }
dirDependencyGraphFor() const572 TemplateVariant dirDependencyGraphFor() const
573 {
574 return TemplateVariant(std::bind(&Private::handleDirDependencyGraphFor,this,std::placeholders::_1));
575 }
search() const576 TemplateVariant search() const
577 {
578 return theTranslator->trSearch();
579 }
mainPage() const580 TemplateVariant mainPage() const
581 {
582 return theTranslator->trMainPage();
583 }
classes() const584 TemplateVariant classes() const
585 {
586 return theTranslator->trClasses();
587 // TODO: VHDL: theTranslator->trVhdlType(VhdlDocGen::ENTITY,FALSE)
588 // TODO: Fortran: trDataTypes()
589 }
concepts() const590 TemplateVariant concepts() const
591 {
592 return theTranslator->trConcept(true,false);
593 }
conceptDefinition() const594 TemplateVariant conceptDefinition() const
595 {
596 return theTranslator->trConceptDefinition();
597 }
classList() const598 TemplateVariant classList() const
599 {
600 return theTranslator->trCompoundList();
601 }
classListDescription() const602 TemplateVariant classListDescription() const
603 {
604 return theTranslator->trCompoundListDescription();
605 }
classIndex() const606 TemplateVariant classIndex() const
607 {
608 return theTranslator->trCompoundIndex();
609 }
namespaceIndex() const610 TemplateVariant namespaceIndex() const
611 {
612 return theTranslator->trNamespaceIndex();
613 }
classHierarchy() const614 TemplateVariant classHierarchy() const
615 {
616 return theTranslator->trClassHierarchy();
617 }
classMembers() const618 TemplateVariant classMembers() const
619 {
620 return theTranslator->trCompoundMembers();
621 }
modules() const622 TemplateVariant modules() const
623 {
624 return theTranslator->trModules();
625 }
moduleIndex() const626 TemplateVariant moduleIndex() const
627 {
628 return theTranslator->trModuleIndex();
629 }
namespaces() const630 TemplateVariant namespaces() const
631 {
632 if (m_javaOpt || m_vhdlOpt)
633 {
634 return theTranslator->trPackages();
635 }
636 else if (m_fortranOpt || m_sliceOpt)
637 {
638 return theTranslator->trModules();
639 }
640 else
641 {
642 return theTranslator->trNamespaces();
643 }
644 }
files() const645 TemplateVariant files() const
646 {
647 return theTranslator->trFile(TRUE,FALSE);
648 }
fileIndex() const649 TemplateVariant fileIndex() const
650 {
651 return theTranslator->trFileIndex();
652 }
pages() const653 TemplateVariant pages() const
654 {
655 return theTranslator->trRelatedPages();
656 }
examples() const657 TemplateVariant examples() const
658 {
659 return theTranslator->trExamples();
660 }
namespaceList() const661 TemplateVariant namespaceList() const
662 {
663 if (m_javaOpt || m_vhdlOpt)
664 {
665 return theTranslator->trPackages();
666 }
667 else if (m_fortranOpt || m_sliceOpt)
668 {
669 return theTranslator->trModulesList();
670 }
671 else
672 {
673 return theTranslator->trNamespaceList();
674 }
675 }
namespaceMembers() const676 TemplateVariant namespaceMembers() const
677 {
678 if (m_javaOpt || m_vhdlOpt)
679 {
680 return theTranslator->trPackageMembers();
681 }
682 else if (m_fortranOpt || m_sliceOpt)
683 {
684 return theTranslator->trModulesMembers();
685 }
686 else
687 {
688 return theTranslator->trNamespaceMembers();
689 }
690 }
moduleDocumentation() const691 TemplateVariant moduleDocumentation() const
692 {
693 return theTranslator->trModuleDocumentation();
694 }
fileDocumentation() const695 TemplateVariant fileDocumentation() const
696 {
697 return theTranslator->trFileDocumentation();
698 }
fileList() const699 TemplateVariant fileList() const
700 {
701 return theTranslator->trFileList();
702 }
fileMembers() const703 TemplateVariant fileMembers() const
704 {
705 return theTranslator->trFileMembers();
706 }
fileMembersDescription() const707 TemplateVariant fileMembersDescription() const
708 {
709 static bool extractAll = Config_getBool(EXTRACT_ALL);
710 return theTranslator->trFileMembersDescription(extractAll);
711 }
namespaceMembersDescription() const712 TemplateVariant namespaceMembersDescription() const
713 {
714 static bool extractAll = Config_getBool(EXTRACT_ALL);
715 return theTranslator->trNamespaceMemberDescription(extractAll);
716 }
classHierarchyDescription() const717 TemplateVariant classHierarchyDescription() const
718 {
719 return theTranslator->trClassHierarchyDescription();
720 }
gotoGraphicalHierarchy() const721 TemplateVariant gotoGraphicalHierarchy() const
722 {
723 return theTranslator->trGotoGraphicalHierarchy();
724 }
gotoTextualHierarchy() const725 TemplateVariant gotoTextualHierarchy() const
726 {
727 return theTranslator->trGotoTextualHierarchy();
728 }
classMembersDescription() const729 TemplateVariant classMembersDescription() const
730 {
731 static bool extractAll = Config_getBool(EXTRACT_ALL);
732 static bool fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
733 if (fortranOpt)
734 {
735 return theTranslator->trCompoundMembersDescriptionFortran(extractAll);
736 }
737 else
738 {
739 return theTranslator->trCompoundMembersDescription(extractAll);
740 }
741 }
relatedPagesDesc() const742 TemplateVariant relatedPagesDesc() const
743 {
744 return theTranslator->trRelatedPagesDescription();
745 }
more() const746 TemplateVariant more() const
747 {
748 return theTranslator->trMore();
749 }
detailedDesc() const750 TemplateVariant detailedDesc() const
751 {
752 return theTranslator->trDetailedDescription();
753 }
inheritsList() const754 TemplateVariant inheritsList() const
755 {
756 return TemplateVariant(std::bind(&Private::handleInheritsList,this,std::placeholders::_1));
757 }
inheritedByList() const758 TemplateVariant inheritedByList() const
759 {
760 return TemplateVariant(std::bind(&Private::handleInheritedByList,this,std::placeholders::_1));
761 }
definedAtLineInSourceFile() const762 TemplateVariant definedAtLineInSourceFile() const
763 {
764 return theTranslator->trDefinedAtLineInSourceFile();
765 }
typeConstraints() const766 TemplateVariant typeConstraints() const
767 {
768 return theTranslator->trTypeConstraints();
769 }
exampleList() const770 TemplateVariant exampleList() const
771 {
772 return TemplateVariant(std::bind(&Private::handleWriteList,this,std::placeholders::_1));
773 }
listOfAllMembers() const774 TemplateVariant listOfAllMembers() const
775 {
776 return theTranslator->trListOfAllMembers();
777 }
memberList() const778 TemplateVariant memberList() const
779 {
780 return theTranslator->trMemberList();
781 }
theListOfAllMembers() const782 TemplateVariant theListOfAllMembers() const
783 {
784 return theTranslator->trThisIsTheListOfAllMembers();
785 }
incInheritedMembers() const786 TemplateVariant incInheritedMembers() const
787 {
788 return theTranslator->trIncludingInheritedMembers();
789 }
defineValue() const790 TemplateVariant defineValue() const
791 {
792 return theTranslator->trDefineValue();
793 }
initialValue() const794 TemplateVariant initialValue() const
795 {
796 return theTranslator->trInitialValue();
797 }
enumerationValues() const798 TemplateVariant enumerationValues() const
799 {
800 return theTranslator->trEnumerationValues();
801 }
implements() const802 TemplateVariant implements() const
803 {
804 return theTranslator->trImplementedFromList(1);
805 }
reimplements() const806 TemplateVariant reimplements() const
807 {
808 return theTranslator->trReimplementedFromList(1);
809 }
implementedBy() const810 TemplateVariant implementedBy() const
811 {
812 return TemplateVariant(std::bind(&Private::handleImplementedBy,this,std::placeholders::_1));
813 }
reimplementedBy() const814 TemplateVariant reimplementedBy() const
815 {
816 return TemplateVariant(std::bind(&Private::handleReimplementedBy,this,std::placeholders::_1));
817 }
sourceRefs() const818 TemplateVariant sourceRefs() const
819 {
820 return TemplateVariant(std::bind(&Private::handleSourceRefs,this,std::placeholders::_1));
821 }
sourceRefBys() const822 TemplateVariant sourceRefBys() const
823 {
824 return TemplateVariant(std::bind(&Private::handleSourceRefBys,this,std::placeholders::_1));
825 }
callGraph() const826 TemplateVariant callGraph() const
827 {
828 return theTranslator->trCallGraph();
829 }
callerGraph() const830 TemplateVariant callerGraph() const
831 {
832 return theTranslator->trCallerGraph();
833 }
referencedByRelation() const834 TemplateVariant referencedByRelation() const
835 {
836 return theTranslator->trReferencedBy();
837 }
referencesRelation() const838 TemplateVariant referencesRelation() const
839 {
840 return theTranslator->trReferences();
841 }
inheritedFrom() const842 TemplateVariant inheritedFrom() const
843 {
844 return theTranslator->trInheritedFrom("@0","@1");
845 }
additionalInheritedMembers() const846 TemplateVariant additionalInheritedMembers() const
847 {
848 return theTranslator->trAdditionalInheritedMembers();
849 }
includeDependencyGraph() const850 TemplateVariant includeDependencyGraph() const
851 {
852 return TemplateVariant(std::bind(&Private::handleIncludeDependencyGraph,this,std::placeholders::_1));
853 }
includedByDependencyGraph() const854 TemplateVariant includedByDependencyGraph() const
855 {
856 return theTranslator->trInclByDepGraph();
857 }
gotoSourceCode() const858 TemplateVariant gotoSourceCode() const
859 {
860 return theTranslator->trGotoSourceCode();
861 }
gotoDocumentation() const862 TemplateVariant gotoDocumentation() const
863 {
864 return theTranslator->trGotoDocumentation();
865 }
constantgroups() const866 TemplateVariant constantgroups() const
867 {
868 return theTranslator->trConstantGroups();
869 }
classDocumentation() const870 TemplateVariant classDocumentation() const
871 {
872 return theTranslator->trClassDocumentation();
873 }
namespaceDocumentation() const874 TemplateVariant namespaceDocumentation() const
875 {
876 return theTranslator->trNamespaceDocumentation();
877 }
compoundMembers() const878 TemplateVariant compoundMembers() const
879 {
880 return theTranslator->trCompoundMembers();
881 }
detailLevel() const882 TemplateVariant detailLevel() const
883 {
884 return theTranslator->trDetailLevel();
885 }
fileListDescription() const886 TemplateVariant fileListDescription() const
887 {
888 bool extractAll = Config_getBool(EXTRACT_ALL);
889 return theTranslator->trFileListDescription(extractAll);
890 }
modulesDescription() const891 TemplateVariant modulesDescription() const
892 {
893 bool extractAll = Config_getBool(EXTRACT_ALL);
894 return theTranslator->trModulesListDescription(extractAll);
895 }
namespaceListDescription() const896 TemplateVariant namespaceListDescription() const
897 {
898 bool extractAll = Config_getBool(EXTRACT_ALL);
899 return theTranslator->trNamespaceListDescription(extractAll);
900 }
conceptListDescription() const901 TemplateVariant conceptListDescription() const
902 {
903 bool extractAll = Config_getBool(EXTRACT_ALL);
904 return theTranslator->trConceptListDescription(extractAll);
905 }
directories() const906 TemplateVariant directories() const
907 {
908 return theTranslator->trDirectories();
909 }
all() const910 TemplateVariant all() const
911 {
912 return theTranslator->trAll();
913 }
functions() const914 TemplateVariant functions() const
915 {
916 static bool fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
917 static bool vhdlOpt = Config_getBool(OPTIMIZE_OUTPUT_VHDL);
918 return fortranOpt ? theTranslator->trSubprograms() :
919 vhdlOpt ? theTranslator->trFunctionAndProc() :
920 theTranslator->trFunctions();
921 }
variables() const922 TemplateVariant variables() const
923 {
924 static bool sliceOpt = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
925 return sliceOpt ? theTranslator->trConstants() : theTranslator->trVariables();
926 }
typedefs() const927 TemplateVariant typedefs() const
928 {
929 return theTranslator->trTypedefs();
930 }
enums() const931 TemplateVariant enums() const
932 {
933 return theTranslator->trEnumerations();
934 }
properties() const935 TemplateVariant properties() const
936 {
937 return theTranslator->trProperties();
938 }
events() const939 TemplateVariant events() const
940 {
941 return theTranslator->trEvents();
942 }
related() const943 TemplateVariant related() const
944 {
945 return theTranslator->trRelatedFunctions();
946 }
macros() const947 TemplateVariant macros() const
948 {
949 return theTranslator->trDefines();
950 }
loading() const951 TemplateVariant loading() const
952 {
953 return theTranslator->trLoading();
954 }
searching() const955 TemplateVariant searching() const
956 {
957 return theTranslator->trSearching();
958 }
noMatches() const959 TemplateVariant noMatches() const
960 {
961 return theTranslator->trNoMatches();
962 }
enumName() const963 TemplateVariant enumName() const
964 {
965 return theTranslator->trEnumName();
966 }
enumValue() const967 TemplateVariant enumValue() const
968 {
969 return theTranslator->trEnumValue();
970 }
referenceManual() const971 TemplateVariant referenceManual() const
972 {
973 return theTranslator->trReferenceManual();
974 }
index() const975 TemplateVariant index() const
976 {
977 return theTranslator->trRTFGeneralIndex();
978 }
panelSyncOn() const979 TemplateVariant panelSyncOn() const
980 {
981 return theTranslator->trPanelSynchronisationTooltip(FALSE);
982 }
panelSyncOff() const983 TemplateVariant panelSyncOff() const
984 {
985 return theTranslator->trPanelSynchronisationTooltip(TRUE);
986 }
providedByCategory() const987 TemplateVariant providedByCategory() const
988 {
989 return theTranslator->trProvidedByCategory();
990 }
extendsClass() const991 TemplateVariant extendsClass() const
992 {
993 return theTranslator->trExtendsClass();
994 }
examplesDescription() const995 TemplateVariant examplesDescription() const
996 {
997 return theTranslator->trExamplesDescription();
998 }
langString() const999 TemplateVariant langString() const
1000 {
1001 return HtmlHelp::getLanguageString();
1002 }
code() const1003 TemplateVariant code() const
1004 {
1005 return theTranslator->trCode();
1006 }
1007
1008 private:
1009 bool m_javaOpt;
1010 bool m_fortranOpt;
1011 bool m_vhdlOpt;
1012 bool m_sliceOpt;
1013 static const PropertyMap<TranslateContext::Private> s_inst;
1014 };
1015
1016 //%% struct Translator: translation methods
1017 //%% {
1018 const PropertyMap<TranslateContext::Private> TranslateContext::Private::s_inst {
1019 {
1020 //%% string generatedBy
1021 { "generatedBy", &Private::generatedBy },
1022 //%% string generatedAt
1023 { "generatedAt", &Private::generatedAt },
1024 //%% string search
1025 { "search", &Private::search },
1026 //%% string mainPage
1027 { "mainPage", &Private::mainPage },
1028 //%% string classes
1029 { "classes", &Private::classes },
1030 //%% string classList
1031 { "classList", &Private::classList },
1032 //%% string classListDescription
1033 { "classListDescription", &Private::classListDescription },
1034 //%% string classIndex
1035 { "classIndex", &Private::classIndex },
1036 //%% string concepts
1037 { "concepts", &Private::concepts },
1038 //%% string conceptDefintion
1039 { "conceptDefinition", &Private::conceptDefinition },
1040 //%% string namespaceIndex
1041 { "namespaceIndex", &Private::namespaceIndex },
1042 //%% string classHierarchy
1043 { "classHierarchy", &Private::classHierarchy },
1044 //%% string classMembers
1045 { "classMembers", &Private::classMembers },
1046 //%% string classMembersDescription
1047 { "classMembersDescription",&Private::classMembersDescription },
1048 //%% string modules
1049 { "modules", &Private::modules },
1050 //%% string moduleIndex
1051 { "moduleIndex", &Private::moduleIndex },
1052 //%% string namespaces
1053 { "namespaces", &Private::namespaces },
1054 //%% string fileIndex
1055 { "fileIndex", &Private::fileIndex },
1056 //%% string files
1057 { "files", &Private::files },
1058 //%% string pages
1059 { "pages", &Private::pages },
1060 //%% string examples
1061 { "examples", &Private::examples },
1062 //%% string namespaceList
1063 { "namespaceList", &Private::namespaceList },
1064 //%% string namespaceMembers
1065 { "namespaceMembers", &Private::namespaceMembers },
1066 //%% string fileList
1067 { "fileList", &Private::fileList },
1068 //%% string fileMembers
1069 { "fileMembers", &Private::fileMembers },
1070 //%% string fileMembersDescription
1071 { "fileMembersDescription", &Private::fileMembersDescription },
1072 //%% string relatedPagesDescription
1073 { "relatedPagesDesc", &Private::relatedPagesDesc },
1074 //%% string more
1075 { "more", &Private::more },
1076 //%% string detailedDescription
1077 { "detailedDesc", &Private::detailedDesc },
1078 //%% string inheritanceDiagramFor
1079 { "inheritanceDiagramFor", &Private::inheritanceDiagramFor },
1080 //%% string collaborationDiagramFor
1081 { "collaborationDiagramFor", &Private::collaborationDiagramFor },
1082 //%% markerstring inheritsList
1083 { "inheritsList", &Private::inheritsList },
1084 //%% markerstring inheritedByList
1085 { "inheritedByList", &Private::inheritedByList },
1086 //%% markerstring definedAtLineInSourceFile
1087 { "definedAtLineInSourceFile", &Private::definedAtLineInSourceFile },
1088 //%% string typeConstraints
1089 { "typeConstraints", &Private::typeConstraints },
1090 //%% string exampleList
1091 { "exampleList", &Private::exampleList },
1092 //%% string listOfAllMembers
1093 { "listOfAllMembers", &Private::listOfAllMembers },
1094 //%% string memberList
1095 { "memberList", &Private::memberList },
1096 //%% string theListOfAllMembers
1097 { "theListOfAllMembers",&Private::theListOfAllMembers },
1098 //%% string incInheritedMembers
1099 { "incInheritedMembers",&Private::incInheritedMembers },
1100 //%% string defineValue
1101 { "defineValue", &Private::defineValue },
1102 //%% string initialValue
1103 { "initialValue", &Private::initialValue },
1104 //%% markerstring implements
1105 { "implements", &Private::implements },
1106 //%% markerstring reimplements
1107 { "reimplements", &Private::reimplements },
1108 //%% markerstring implementedBy
1109 { "implementedBy", &Private::implementedBy },
1110 //%% markerstring reimplementedBy
1111 { "reimplementedBy", &Private::reimplementedBy },
1112 //%% markerstring sourceRefs
1113 { "sourceRefs", &Private::sourceRefs },
1114 //%% markerstring sourceRefBys
1115 { "sourceRefBys", &Private::sourceRefBys },
1116 //%% string callGraph
1117 { "callGraph", &Private::callGraph },
1118 //%% string callerGraph
1119 { "callerGraph", &Private::callerGraph },
1120 //%% string referencedByRelation
1121 { "referencedByRelation", &Private::referencedByRelation },
1122 //%% string referencesRelation
1123 { "referencesRelation", &Private::referencesRelation },
1124 //%% markerstring inheritedFrom
1125 { "inheritedFrom", &Private::inheritedFrom },
1126 //%% string additionalInheritedMembers
1127 { "additionalInheritedMembers",&Private::additionalInheritedMembers },
1128 //%% string includeDependencyGraph:container_name
1129 { "includeDependencyGraph",&Private::includeDependencyGraph },
1130 //%% string includedByDependencyGraph
1131 { "includedByDependencyGraph",&Private::includedByDependencyGraph },
1132 //%% string gotoSourceCode
1133 { "gotoSourceCode", &Private::gotoSourceCode },
1134 //%% string gotoDocumentation
1135 { "gotoDocumentation", &Private::gotoDocumentation },
1136 //%% string constantgroups
1137 { "constantgroups", &Private::constantgroups },
1138 //%% string classDocumentation
1139 { "classDocumentation", &Private::classDocumentation },
1140 //%% string namespaceDocumentation
1141 { "namespaceDocumentation", &Private::namespaceDocumentation },
1142 //%% string moduleDocumentation
1143 { "moduleDocumentation",&Private::moduleDocumentation },
1144 //%% string fileDocumentation
1145 { "fileDocumentation", &Private::fileDocumentation },
1146 //%% string compoundMembers
1147 { "compoundMembers", &Private::compoundMembers },
1148 //%% string detailLevel
1149 { "detailLevel", &Private::detailLevel },
1150 //%% string fileListDescription
1151 { "fileListDescription",&Private::fileListDescription },
1152 //%% string namespaceListDescription
1153 { "namespaceListDescription",&Private::namespaceListDescription },
1154 //%% string conceptListDescription
1155 { "conceptListDescription",&Private::conceptListDescription },
1156 //%% string directories
1157 { "directories", &Private::directories },
1158 //%% string moduleDescription
1159 { "modulesDescription", &Private::modulesDescription },
1160 //%% string all
1161 { "all", &Private::all },
1162 //%% string functions
1163 { "functions", &Private::functions },
1164 //%% string variables
1165 { "variables", &Private::variables },
1166 //%% string typedefs
1167 { "typedefs", &Private::typedefs },
1168 //%% string enums
1169 { "enums", &Private::enums },
1170 //%% string enumValues
1171 { "enumValues", &Private::enumerationValues },
1172 //%% string properties
1173 { "properties", &Private::properties },
1174 //%% string events
1175 { "events", &Private::events },
1176 //%% string related
1177 { "related", &Private::related },
1178 //%% string macros
1179 { "macros", &Private::macros },
1180 //%% string namespaceMembersDescription
1181 { "namespaceMembersDescription",&Private::namespaceMembersDescription },
1182 //%% string classHierarchyDescription
1183 { "classHierarchyDescription",&Private::classHierarchyDescription },
1184 //%% string gotoGraphicalHierarchy
1185 { "gotoGraphicalHierarchy",&Private::gotoGraphicalHierarchy },
1186 //%% string gotoTextualHierarchy
1187 { "gotoTextualHierarchy",&Private::gotoTextualHierarchy },
1188 //%% string loading
1189 { "loading", &Private::loading },
1190 //%% string searching
1191 { "searching", &Private::searching },
1192 //%% string noMatches
1193 { "noMatches", &Private::noMatches },
1194 //%% string enumValue
1195 { "enumValue", &Private::enumValue },
1196 //%% string enumName
1197 { "enumName", &Private::enumName },
1198 //%% string referenceManual
1199 { "referenceManual", &Private::referenceManual },
1200 //%% string index
1201 { "index", &Private::index },
1202 //%% string panelSyncOn
1203 { "panelSyncOn", &Private::panelSyncOn },
1204 //%% string panelSyncOff
1205 { "panelSyncOff", &Private::panelSyncOff },
1206 //%% string dirDependencyGraph
1207 { "dirDependencyGraphFor", &Private::dirDependencyGraphFor },
1208 //%% string providedByCategory
1209 { "providedByCategory", &Private::providedByCategory },
1210 //%% string extendsClass
1211 { "extendsClass", &Private::extendsClass },
1212 //%% string examplesDescription
1213 { "examplesDescription",&Private::examplesDescription },
1214 //%% string langstring
1215 { "langString", &Private::langString },
1216 //%% string code
1217 { "code", &Private::code }
1218 } };
1219 //%% }
1220
TranslateContext()1221 TranslateContext::TranslateContext() : p(std::make_unique<Private>())
1222 {
1223 }
1224
~TranslateContext()1225 TranslateContext::~TranslateContext()
1226 {
1227 }
1228
get(const QCString & n) const1229 TemplateVariant TranslateContext::get(const QCString &n) const
1230 {
1231 return p->get(n);
1232 }
1233
fields() const1234 StringVector TranslateContext::fields() const
1235 {
1236 return p->fields();
1237 }
1238
1239 //------------------------------------------------------------------------------------------
1240
parseDoc(const Definition * def,const QCString & file,int line,const QCString & relPath,const QCString & docStr,bool isBrief)1241 static TemplateVariant parseDoc(const Definition *def,const QCString &file,int line,
1242 const QCString &relPath,const QCString &docStr,bool isBrief)
1243 {
1244 TemplateVariant result;
1245 std::unique_ptr<IDocParser> parser { createDocParser() };
1246 std::unique_ptr<DocRoot> root { validatingParseDoc(
1247 *parser.get(),file,line,def,0,docStr,TRUE,FALSE,
1248 QCString(),isBrief,FALSE,Config_getBool(MARKDOWN_SUPPORT))
1249 };
1250 TextStream ts;
1251 switch (g_globals.outputFormat)
1252 {
1253 case ContextOutputFormat_Html:
1254 {
1255 HtmlCodeGenerator codeGen(ts,relPath);
1256 HtmlDocVisitor visitor(ts,codeGen,def);
1257 root->accept(&visitor);
1258 }
1259 break;
1260 case ContextOutputFormat_Latex:
1261 {
1262 LatexCodeGenerator codeGen(ts,relPath,file);
1263 LatexDocVisitor visitor(ts,codeGen,def->getDefFileExtension(),FALSE);
1264 root->accept(&visitor);
1265 }
1266 break;
1267 // TODO: support other generators
1268 default:
1269 err("context.cpp: output format not yet supported\n");
1270 break;
1271 }
1272 bool isEmpty = root->isEmpty();
1273 if (isEmpty)
1274 result = "";
1275 else
1276 result = TemplateVariant(ts.str().c_str(),TRUE);
1277 return result;
1278 }
1279
parseCode(const Definition * d,const QCString & scopeName,const QCString & relPath,const QCString & code,int startLine=-1,int endLine=-1,bool showLineNumbers=FALSE)1280 static TemplateVariant parseCode(const Definition *d,const QCString &scopeName,const QCString &relPath,
1281 const QCString &code,int startLine=-1,int endLine=-1,bool showLineNumbers=FALSE)
1282 {
1283 auto intf = Doxygen::parserManager->getCodeParser(d->getDefFileExtension());
1284 intf->resetCodeParserState();
1285 TextStream t;
1286 switch (g_globals.outputFormat)
1287 {
1288 case ContextOutputFormat_Html:
1289 {
1290 HtmlCodeGenerator codeGen(t,relPath);
1291 intf->parseCode(codeGen,scopeName,code,d->getLanguage(),FALSE,QCString(),d->getBodyDef(),
1292 startLine,endLine,TRUE,toMemberDef(d),showLineNumbers,d);
1293 }
1294 break;
1295 case ContextOutputFormat_Latex:
1296 {
1297 LatexCodeGenerator codeGen(t,relPath,d->docFile());
1298 intf->parseCode(codeGen,scopeName,code,d->getLanguage(),FALSE,QCString(),d->getBodyDef(),
1299 startLine,endLine,TRUE,toMemberDef(d),showLineNumbers,d);
1300 }
1301 break;
1302 // TODO: support other generators
1303 default:
1304 err("context.cpp: output format not yet supported\n");
1305 break;
1306 }
1307 return TemplateVariant(t.str(),TRUE);
1308 }
1309
parseCode(const FileDef * fd,const QCString & relPath)1310 static TemplateVariant parseCode(const FileDef *fd,const QCString &relPath)
1311 {
1312 static bool filterSourceFiles = Config_getBool(FILTER_SOURCE_FILES);
1313 auto intf = Doxygen::parserManager->getCodeParser(fd->getDefFileExtension());
1314 intf->resetCodeParserState();
1315 TextStream t;
1316 switch (g_globals.outputFormat)
1317 {
1318 case ContextOutputFormat_Html:
1319 {
1320 HtmlCodeGenerator codeGen(t,relPath);
1321 intf->parseCode(codeGen,QCString(),
1322 fileToString(fd->absFilePath(),filterSourceFiles,TRUE), // the sources
1323 fd->getLanguage(), // lang
1324 FALSE, // isExampleBlock
1325 QCString(), // exampleName
1326 const_cast<FileDef*>(fd), // fileDef, TODO: should be const
1327 -1, // startLine
1328 -1, // endLine
1329 FALSE, // inlineFragment
1330 0, // memberDef
1331 TRUE, // showLineNumbers
1332 0, // searchCtx
1333 TRUE // collectXRefs, TODO: should become FALSE
1334 );
1335 }
1336 break;
1337 case ContextOutputFormat_Latex:
1338 {
1339 LatexCodeGenerator codeGen(t,relPath,fd->docFile());
1340 intf->parseCode(codeGen,QCString(),
1341 fileToString(fd->absFilePath(),filterSourceFiles,TRUE), // the sources
1342 fd->getLanguage(), // lang
1343 FALSE, // isExampleBlock
1344 QCString(), // exampleName
1345 const_cast<FileDef*>(fd), // fileDef, TODO: should be const
1346 -1, // startLine
1347 -1, // endLine
1348 FALSE, // inlineFragment
1349 0, // memberDef
1350 TRUE, // showLineNumbers
1351 0, // searchCtx
1352 TRUE // collectXRefs, TODO: should become FALSE
1353 );
1354 }
1355 break;
1356 // TODO: support other generators
1357 default:
1358 err("context.cpp: output format not yet supported\n");
1359 break;
1360 }
1361 return TemplateVariant(t.str().c_str(),TRUE);
1362 }
1363
1364 //------------------------------------------------------------------------
1365
1366 template<typename T>
1367 class DefinitionContext
1368 {
1369 public:
DefinitionContext(const Definition * d)1370 DefinitionContext(const Definition *d) : m_def(d)
1371 {
1372 assert(d!=0);
1373
1374 if (m_def && !m_def->getSourceFileBase().isEmpty())
1375 {
1376 TemplateStructIntfPtr lineLink = TemplateImmutableStruct::alloc(
1377 {
1378 { "text", TemplateVariant(m_def->getStartBodyLine()) },
1379 { "isLinkable", TemplateVariant(TRUE) },
1380 { "fileName", TemplateVariant(m_def->getSourceFileBase()) },
1381 { "anchor", TemplateVariant(m_def->getSourceAnchor()) },
1382 { "isReference", TemplateVariant(FALSE) },
1383 { "externalReference", TemplateVariant("") }
1384 });
1385
1386 QCString text = m_def->definitionType()==Definition::TypeFile ? m_def->name() :
1387 m_def->getBodyDef() ? m_def->getBodyDef()->name() :
1388 m_def->displayName(TRUE);
1389
1390 TemplateStructIntfPtr fileLink = TemplateImmutableStruct::alloc(
1391 {
1392 { "text", TemplateVariant(text) },
1393 { "isLinkable", TemplateVariant(TRUE) },
1394 { "fileName", TemplateVariant(m_def->getSourceFileBase()) },
1395 { "anchor", TemplateVariant("") },
1396 { "isReference", TemplateVariant(FALSE) },
1397 { "externalReference", TemplateVariant("") }
1398 });
1399
1400 m_sourceDef = TemplateImmutableList::alloc( { lineLink, fileLink });
1401 }
1402 else
1403 {
1404 m_sourceDef = TemplateImmutableList::alloc( {} );
1405 }
1406 }
~DefinitionContext()1407 virtual ~DefinitionContext() {}
1408
1409 protected:
1410 // Property getters
fileName() const1411 TemplateVariant fileName() const { return m_def->getOutputFileBase(); }
anchor() const1412 TemplateVariant anchor() const { return m_def->anchor(); }
sourceFileName() const1413 TemplateVariant sourceFileName() const { return m_def->getSourceFileBase(); }
isLinkable() const1414 TemplateVariant isLinkable() const { return m_def->isLinkable(); }
isLinkableInProject() const1415 TemplateVariant isLinkableInProject() const { return m_def->isLinkableInProject(); }
name() const1416 TemplateVariant name() const { return m_def->displayName(TRUE); }
bareName() const1417 TemplateVariant bareName() const { return m_def->displayName(FALSE); }
details() const1418 TemplateVariant details() const { return m_cachable.details.get(this); }
brief() const1419 TemplateVariant brief() const { return m_cachable.brief.get(this); }
inbodyDocs() const1420 TemplateVariant inbodyDocs() const { return m_cachable.inbodyDocs.get(this); }
dynSectionId() const1421 TemplateVariant dynSectionId() const { return g_globals.dynSectionId; }
sourceDef() const1422 TemplateVariant sourceDef() const { return std::static_pointer_cast<TemplateListIntf>(m_sourceDef); }
navigationPath() const1423 TemplateVariant navigationPath() const { return m_cachable.navPath.get(this); }
partOfGroups() const1424 TemplateVariant partOfGroups() const { return m_cachable.partOfGroups.get(this); }
isReference() const1425 TemplateVariant isReference() const { return m_def->isReference(); }
externalReference() const1426 TemplateVariant externalReference() const { return m_def->externalReference(relPathAsString()); }
language() const1427 TemplateVariant language() const
1428 {
1429 SrcLangExt lang = m_def->getLanguage();
1430 QCString result = "unknown";
1431 switch (lang)
1432 {
1433 case SrcLangExt_Unknown: break;
1434 case SrcLangExt_IDL: result="idl"; break;
1435 case SrcLangExt_Java: result="java"; break;
1436 case SrcLangExt_CSharp: result="csharp"; break;
1437 case SrcLangExt_D: result="d"; break;
1438 case SrcLangExt_PHP: result="php"; break;
1439 case SrcLangExt_ObjC: result="objc"; break;
1440 case SrcLangExt_Cpp: result="cpp"; break;
1441 case SrcLangExt_JS: result="js"; break;
1442 case SrcLangExt_Python: result="python"; break;
1443 case SrcLangExt_Fortran: result="fortran"; break;
1444 case SrcLangExt_VHDL: result="vhdl"; break;
1445 case SrcLangExt_XML: result="xml"; break;
1446 case SrcLangExt_SQL: result="sql"; break;
1447 case SrcLangExt_Markdown: result="markdown"; break;
1448 case SrcLangExt_Slice: result="slice"; break;
1449 case SrcLangExt_Lex: result="lex"; break;
1450 }
1451 return result;
1452 }
compoundKind() const1453 TemplateVariant compoundKind() const
1454 {
1455 QCString result = "unspecified";
1456 switch (m_def->definitionType())
1457 {
1458 case Definition::TypeClass: result="class"; break;
1459 case Definition::TypeFile: result="file"; break;
1460 case Definition::TypeNamespace: result="namespace"; break;
1461 case Definition::TypeGroup: result="module"; break;
1462 case Definition::TypePackage: result="package"; break;
1463 case Definition::TypePage: result="page"; break;
1464 case Definition::TypeDir: result="dir"; break;
1465 case Definition::TypeConcept: result="concept"; break;
1466 case Definition::TypeMember: break;
1467 }
1468 return result;
1469 }
1470
1471 protected:
1472
relPathAsString() const1473 QCString relPathAsString() const
1474 {
1475 static bool createSubdirs = Config_getBool(CREATE_SUBDIRS);
1476 return createSubdirs ? QCString("../../") : QCString("");
1477 }
relPath() const1478 virtual TemplateVariant relPath() const { return relPathAsString(); }
1479
1480
1481 private:
1482
createDetails() const1483 TemplateVariant createDetails() const
1484 {
1485 return TemplateVariant(parseDoc(m_def,m_def->docFile(),m_def->docLine(),
1486 relPathAsString(),m_def->documentation(),FALSE));
1487 }
createBrief() const1488 TemplateVariant createBrief() const
1489 {
1490 if (m_def->hasBriefDescription())
1491 {
1492 return TemplateVariant(parseDoc(m_def,m_def->briefFile(),m_def->briefLine(),
1493 relPathAsString(),m_def->briefDescription(),TRUE));
1494 }
1495 else
1496 {
1497 return TemplateVariant("");
1498 }
1499 }
createInbodyDocs() const1500 TemplateVariant createInbodyDocs() const
1501 {
1502 if (!m_def->inbodyDocumentation().isEmpty())
1503 {
1504 return TemplateVariant(parseDoc(m_def,m_def->inbodyFile(),m_def->inbodyLine(),
1505 relPathAsString(),m_def->inbodyDocumentation(),FALSE));
1506 }
1507 else
1508 {
1509 return TemplateVariant("");
1510 }
1511 }
fillPath(const Definition * def,TemplateVariantList & list) const1512 void fillPath(const Definition *def,TemplateVariantList &list) const
1513 {
1514 const Definition *outerScope = def->getOuterScope();
1515 Definition::DefType type = def->definitionType();
1516 if (outerScope && outerScope!=Doxygen::globalScope)
1517 {
1518 fillPath(outerScope,list);
1519 }
1520 else if (type==Definition::TypeFile && (toFileDef(def))->getDirDef())
1521 {
1522 fillPath((toFileDef(def))->getDirDef(),list);
1523 }
1524 list.push_back(NavPathElemContext::alloc(def));
1525 }
createNavigationPath() const1526 TemplateListIntfPtr createNavigationPath() const
1527 {
1528 TemplateVariantList list;
1529 if (m_def->getOuterScope() && m_def->getOuterScope()!=Doxygen::globalScope)
1530 {
1531 fillPath(m_def,list);
1532 }
1533 else if (m_def->definitionType()==Definition::TypeFile && (toFileDef(m_def))->getDirDef())
1534 {
1535 fillPath((toFileDef(m_def))->getDirDef(),list);
1536 }
1537 return TemplateImmutableList::alloc(list);
1538 }
createPartOfGroups() const1539 TemplateListIntfPtr createPartOfGroups() const
1540 {
1541 TemplateVariantList list;
1542 list.reserve(m_def->partOfGroups().size());
1543 for (const auto &gd : m_def->partOfGroups())
1544 {
1545 list.push_back(ModuleContext::alloc(gd));
1546 }
1547 return TemplateImmutableList::alloc(list);
1548 }
1549
1550 protected:
1551 struct Cachable : public Definition::Cookie
1552 {
1553 using DC = DefinitionContext<T>;
1554 CachedItem<TemplateVariant, DC, &DC::createDetails> details;
1555 CachedItem<TemplateVariant, DC, &DC::createBrief> brief;
1556 CachedItem<TemplateVariant, DC, &DC::createInbodyDocs> inbodyDocs;
1557 CachedItem<TemplateListIntfPtr, DC, &DC::createNavigationPath> navPath;
1558 CachedItem<TemplateListIntfPtr, DC, &DC::createPartOfGroups> partOfGroups;
1559 };
1560
1561 private:
1562 Cachable m_cachable;
1563 const Definition *m_def;
1564 TemplateListIntfPtr m_sourceDef;
1565 static const PropertyMap< DefinitionContext<T> > s_baseProperties;
1566 };
1567
1568 //%% struct Definition: shared info for all symbols
1569 //%% {
1570 #define BASE_PROPERTIES \
1571 { "name", &Private::name }, \
1572 { "bareName", &Private::bareName }, \
1573 { "relPath", &Private::relPath }, \
1574 { "fileName", &Private::fileName }, \
1575 { "anchor", &Private::anchor }, \
1576 { "details", &Private::details }, \
1577 { "brief", &Private::brief }, \
1578 { "inbodyDocs", &Private::inbodyDocs }, \
1579 { "sourceFileName", &Private::sourceFileName }, \
1580 { "isLinkable", &Private::isLinkable }, \
1581 { "isLinkableInProject",&Private::isLinkableInProject }, \
1582 { "dynSectionId", &Private::dynSectionId }, \
1583 { "language", &Private::language }, \
1584 { "sourceDef", &Private::sourceDef }, \
1585 { "navigationPath", &Private::navigationPath }, \
1586 { "partOfGroups", &Private::partOfGroups }, \
1587 { "compoundKind", &Private::compoundKind }, \
1588 { "isReference", &Private::isReference }, \
1589 { "externalReference", &Private::externalReference }
1590 //%% }
1591
1592
1593 //------------------------------------------------------------------------
1594
1595 class IncludeInfoContext::Private
1596 {
1597 public:
Private(const IncludeInfo * info,SrcLangExt lang)1598 Private(const IncludeInfo *info,SrcLangExt lang) :
1599 m_info(info),
1600 m_lang(lang)
1601 {
1602 }
get(const QCString & n) const1603 TemplateVariant get(const QCString &n) const
1604 {
1605 return s_inst.get(this,n);
1606 }
fields() const1607 StringVector fields() const
1608 {
1609 return s_inst.fields();
1610 }
isLocal() const1611 TemplateVariant isLocal() const
1612 {
1613 bool isIDLorJava = m_lang==SrcLangExt_IDL || m_lang==SrcLangExt_Java;
1614 return m_info->local || isIDLorJava;
1615 }
isImport() const1616 TemplateVariant isImport() const
1617 {
1618 return m_info->imported || m_lang==SrcLangExt_ObjC;
1619 }
file() const1620 TemplateVariant file() const
1621 {
1622 return m_fileContext.get(this);
1623 }
name() const1624 TemplateVariant name() const
1625 {
1626 return m_info->includeName;
1627 }
1628 private:
1629 const IncludeInfo *m_info;
createFileContext() const1630 TemplateVariant createFileContext() const
1631 {
1632 return m_info && m_info->fileDef ?
1633 TemplateVariant(FileContext::alloc(m_info->fileDef)) :
1634 TemplateVariant(false);
1635 }
1636 CachedItem<TemplateVariant, Private, &Private::createFileContext> m_fileContext;
1637 SrcLangExt m_lang;
1638 static const PropertyMap<IncludeInfoContext::Private> s_inst;
1639 };
1640
1641 //%% struct IncludeInfo: include file information
1642 //%% {
1643 const PropertyMap<IncludeInfoContext::Private> IncludeInfoContext::Private::s_inst {
1644 { "file",&Private::file },
1645 { "name",&Private::name },
1646 { "isImport",&Private::isImport },
1647 { "isLocal",&Private::isLocal }
1648 };
1649 //%% }
1650
IncludeInfoContext(const IncludeInfo * info,SrcLangExt lang)1651 IncludeInfoContext::IncludeInfoContext(const IncludeInfo *info,SrcLangExt lang) : p(std::make_unique<Private>(info,lang))
1652 {
1653 }
1654
~IncludeInfoContext()1655 IncludeInfoContext::~IncludeInfoContext()
1656 {
1657 }
1658
get(const QCString & n) const1659 TemplateVariant IncludeInfoContext::get(const QCString &n) const
1660 {
1661 return p->get(n);
1662 }
1663
fields() const1664 StringVector IncludeInfoContext::fields() const
1665 {
1666 return p->fields();
1667 }
1668
1669 //%% }
1670
1671 //------------------------------------------------------------------------
1672
1673 //%% list IncludeInfoList[Class] : list of nested classes
1674 class IncludeInfoListContext::Private : public GenericNodeListContext
1675 {
1676 public:
Private(const IncludeInfoList & list,SrcLangExt lang)1677 Private(const IncludeInfoList &list,SrcLangExt lang)
1678 {
1679 for (const auto &ii : list)
1680 {
1681 append(IncludeInfoContext::alloc(&ii,lang));
1682 }
1683 }
1684 };
1685
IncludeInfoListContext(const IncludeInfoList & list,SrcLangExt lang)1686 IncludeInfoListContext::IncludeInfoListContext(const IncludeInfoList &list,SrcLangExt lang) : p(std::make_unique<Private>(list,lang))
1687 {
1688 }
1689
~IncludeInfoListContext()1690 IncludeInfoListContext::~IncludeInfoListContext()
1691 {
1692 }
1693
1694 // TemplateListIntf
count() const1695 uint IncludeInfoListContext::count() const
1696 {
1697 return p->count();
1698 }
1699
at(uint index) const1700 TemplateVariant IncludeInfoListContext::at(uint index) const
1701 {
1702 return p->at(index);
1703 }
1704
createIterator() const1705 TemplateListIntf::ConstIteratorPtr IncludeInfoListContext::createIterator() const
1706 {
1707 return p->createIterator();
1708 }
1709
1710 //------------------------------------------------------------------------
1711
1712 class ClassContext::Private : public DefinitionContext<ClassContext::Private>
1713 {
1714 public:
Private(const ClassDef * cd)1715 Private(const ClassDef *cd) : DefinitionContext<ClassContext::Private>(cd),
1716 m_classDef(cd)
1717 {
1718 }
~Private()1719 virtual ~Private() {}
1720
1721 // TemplateStructIntf methods
get(const QCString & n) const1722 TemplateVariant get(const QCString &n) const { return s_inst.get(this,n); }
fields() const1723 StringVector fields() const { return s_inst.fields(); }
1724
1725 private:
1726 // Property getters
title() const1727 TemplateVariant title() const { return TemplateVariant(m_classDef->title()); }
highlight() const1728 TemplateVariant highlight() const { return TemplateVariant("classes"); }
subHighlight() const1729 TemplateVariant subHighlight() const { return TemplateVariant(""); }
hasDetails() const1730 TemplateVariant hasDetails() const { return m_classDef->hasDetailedDescription(); }
generatedFromFiles() const1731 TemplateVariant generatedFromFiles() const { return m_classDef->generatedFromFiles(); }
usedFiles() const1732 TemplateVariant usedFiles() const { return m_cachable.usedFiles.get(this); }
getClassGraph() const1733 DotClassGraphPtr getClassGraph() const { return m_cachable.classGraph.get(this); }
numInheritanceNodes() const1734 int numInheritanceNodes() const { return m_cachable.numInheritanceNodes.get(this); }
includeInfo() const1735 TemplateVariant includeInfo() const { return m_cachable.includeInfo.get(this); }
inherits() const1736 TemplateVariant inherits() const { return m_cachable.inheritsList.get(this); }
inheritedBy() const1737 TemplateVariant inheritedBy() const { return m_cachable.inheritedByList.get(this); }
unoIDLServices() const1738 TemplateVariant unoIDLServices() const { return m_cachable.unoIDLServices.get(this); }
unoIDLInterfaces() const1739 TemplateVariant unoIDLInterfaces() const { return m_cachable.unoIDLInterfaces.get(this); }
signals() const1740 TemplateVariant signals() const { return m_cachable.signals.get(this); }
publicTypes() const1741 TemplateVariant publicTypes() const { return m_cachable.publicTypes.get(this); }
publicMethods() const1742 TemplateVariant publicMethods() const { return m_cachable.publicMethods.get(this); }
publicStaticMethods() const1743 TemplateVariant publicStaticMethods() const { return m_cachable.publicStaticMethods.get(this); }
publicAttributes() const1744 TemplateVariant publicAttributes() const { return m_cachable.publicAttributes.get(this); }
publicStaticAttributes() const1745 TemplateVariant publicStaticAttributes() const { return m_cachable.publicStaticAttributes.get(this); }
publicSlots() const1746 TemplateVariant publicSlots() const { return m_cachable.publicSlots.get(this); }
protectedTypes() const1747 TemplateVariant protectedTypes() const { return m_cachable.protectedTypes.get(this); }
protectedMethods() const1748 TemplateVariant protectedMethods() const { return m_cachable.protectedMethods.get(this); }
protectedStaticMethods() const1749 TemplateVariant protectedStaticMethods() const { return m_cachable.protectedStaticMethods.get(this); }
protectedAttributes() const1750 TemplateVariant protectedAttributes() const { return m_cachable.protectedAttributes.get(this); }
protectedStaticAttributes() const1751 TemplateVariant protectedStaticAttributes() const { return m_cachable.protectedStaticAttributes.get(this); }
protectedSlots() const1752 TemplateVariant protectedSlots() const { return m_cachable.protectedSlots.get(this); }
privateTypes() const1753 TemplateVariant privateTypes() const { return m_cachable.privateTypes.get(this); }
privateSlots() const1754 TemplateVariant privateSlots() const { return m_cachable.privateSlots.get(this); }
privateMethods() const1755 TemplateVariant privateMethods() const { return m_cachable.privateMethods.get(this); }
privateStaticMethods() const1756 TemplateVariant privateStaticMethods() const { return m_cachable.privateStaticMethods.get(this); }
privateAttributes() const1757 TemplateVariant privateAttributes() const { return m_cachable.privateAttributes.get(this); }
privateStaticAttributes() const1758 TemplateVariant privateStaticAttributes() const { return m_cachable.privateStaticAttributes.get(this); }
packageTypes() const1759 TemplateVariant packageTypes() const { return m_cachable.packageTypes.get(this); }
packageMethods() const1760 TemplateVariant packageMethods() const { return m_cachable.packageMethods.get(this); }
packageStaticMethods() const1761 TemplateVariant packageStaticMethods() const { return m_cachable.packageStaticMethods.get(this); }
packageAttributes() const1762 TemplateVariant packageAttributes() const { return m_cachable.packageAttributes.get(this); }
packageStaticAttributes() const1763 TemplateVariant packageStaticAttributes() const { return m_cachable.packageStaticAttributes.get(this); }
properties() const1764 TemplateVariant properties() const { return m_cachable.properties.get(this); }
events() const1765 TemplateVariant events() const { return m_cachable.events.get(this); }
friends() const1766 TemplateVariant friends() const { return m_cachable.friends.get(this); }
related() const1767 TemplateVariant related() const { return m_cachable.related.get(this); }
detailedTypedefs() const1768 TemplateVariant detailedTypedefs() const { return m_cachable.detailedTypedefs.get(this); }
detailedEnums() const1769 TemplateVariant detailedEnums() const { return m_cachable.detailedEnums.get(this); }
detailedServices() const1770 TemplateVariant detailedServices() const { return m_cachable.detailedServices.get(this); }
detailedInterfaces() const1771 TemplateVariant detailedInterfaces() const { return m_cachable.detailedInterfaces.get(this); }
detailedConstructors() const1772 TemplateVariant detailedConstructors() const { return m_cachable.detailedConstructors.get(this); }
detailedMethods() const1773 TemplateVariant detailedMethods() const { return m_cachable.detailedMethods.get(this); }
detailedRelated() const1774 TemplateVariant detailedRelated() const { return m_cachable.detailedRelated.get(this); }
detailedVariables() const1775 TemplateVariant detailedVariables() const { return m_cachable.detailedVariables.get(this); }
detailedProperties() const1776 TemplateVariant detailedProperties() const { return m_cachable.detailedProperties.get(this); }
detailedEvents() const1777 TemplateVariant detailedEvents() const { return m_cachable.detailedEvents.get(this); }
classes() const1778 TemplateVariant classes() const { return m_cachable.classes.get(this); }
innerClasses() const1779 TemplateVariant innerClasses() const { return m_cachable.innerClasses.get(this); }
compoundType() const1780 TemplateVariant compoundType() const { return m_classDef->compoundTypeString(); }
templateDecls() const1781 TemplateVariant templateDecls() const { return m_cachable.templateDecls.get(this); }
typeConstraints() const1782 TemplateVariant typeConstraints() const { return m_cachable.typeConstraints.get(this); }
examples() const1783 TemplateVariant examples() const { return m_cachable.examples.get(this); }
members() const1784 TemplateVariant members() const { return m_cachable.members.get(this); }
allMembersList() const1785 TemplateVariant allMembersList() const { return m_cachable.allMembersList.get(this); }
allMembersFileName() const1786 TemplateVariant allMembersFileName() const { return m_classDef->getMemberListFileName(); }
memberGroups() const1787 TemplateVariant memberGroups() const { return m_cachable.memberGroups.get(this); }
additionalInheritedMembers() const1788 TemplateVariant additionalInheritedMembers() const { return m_cachable.additionalInheritedMembers.get(this); }
isSimple() const1789 TemplateVariant isSimple() const { return m_classDef->isSimple(); }
categoryOf() const1790 TemplateVariant categoryOf() const { return m_cachable.categoryOf.get(this); }
1791
hasInheritanceDiagram() const1792 TemplateVariant hasInheritanceDiagram() const
1793 {
1794 bool result=FALSE;
1795 static bool haveDot = Config_getBool(HAVE_DOT);
1796 static auto classGraph = Config_getEnum(CLASS_GRAPH);
1797 bool classGraphEnabled = classGraph==CLASS_GRAPH_t::YES || classGraph==CLASS_GRAPH_t::GRAPH;
1798
1799 if (haveDot && classGraphEnabled)
1800 {
1801 DotClassGraphPtr cg = getClassGraph();
1802 result = !cg->isTrivial() && !cg->isTooBig();
1803 }
1804 else if (classGraphEnabled)
1805 {
1806 result = numInheritanceNodes()>0;
1807 }
1808 return result;
1809 }
inheritanceDiagram() const1810 TemplateVariant inheritanceDiagram() const
1811 {
1812 TextStream t;
1813 static bool haveDot = Config_getBool(HAVE_DOT);
1814 static auto classGraph = Config_getEnum(CLASS_GRAPH);
1815 bool classGraphEnabled = classGraph==CLASS_GRAPH_t::YES || classGraph==CLASS_GRAPH_t::GRAPH;
1816
1817 if (haveDot && classGraphEnabled)
1818 {
1819 DotClassGraphPtr cg = getClassGraph();
1820 switch (g_globals.outputFormat)
1821 {
1822 case ContextOutputFormat_Html:
1823 {
1824 cg->writeGraph(t,GOF_BITMAP,EOF_Html,
1825 g_globals.outputDir,
1826 g_globals.outputDir+Portable::pathSeparator()+addHtmlExtensionIfMissing(m_classDef->getOutputFileBase()),
1827 relPathAsString(),TRUE,TRUE,g_globals.dynSectionId
1828 );
1829 }
1830 break;
1831 case ContextOutputFormat_Latex:
1832 {
1833 cg->writeGraph(t,GOF_EPS,EOF_LaTeX,
1834 g_globals.outputDir,
1835 g_globals.outputDir+Portable::pathSeparator()+m_classDef->getOutputFileBase()+".tex",
1836 relPathAsString(),TRUE,TRUE,g_globals.dynSectionId
1837 );
1838 }
1839 break;
1840 // TODO: support other generators
1841 default:
1842 err("context.cpp: output format not yet supported\n");
1843 break;
1844 }
1845 g_globals.dynSectionId++;
1846 }
1847 else if (classGraphEnabled)
1848 {
1849 ClassDiagram d(m_classDef);
1850 switch (g_globals.outputFormat)
1851 {
1852 case ContextOutputFormat_Html:
1853 {
1854 TextStream tt;
1855
1856 QCString name = convertToHtml(m_classDef->displayName());
1857 d.writeImage(tt,g_globals.outputDir,
1858 relPathAsString(),
1859 m_classDef->getOutputFileBase());
1860 if (!tt.empty())
1861 {
1862 t << "<div class=\"center\">\n";
1863 t << " <img src=\"";
1864 t << relPathAsString() << m_classDef->getOutputFileBase();
1865 t << ".png\" usemap=\"#" << convertToId(name) << "_map\" alt=\"\"/>\n";
1866 t << " <map id=\"" << convertToId(name) << "_map\" name=\"" << convertToId(name) << "_map\">\n";
1867 t << tt.str();
1868 t << " </map>\n";
1869 t << "</div>";
1870 }
1871 else
1872 {
1873 t << "<div class=\"center\">\n";
1874 t << " <img src=\"";
1875 t << relPathAsString() << m_classDef->getOutputFileBase();
1876 t << ".png\" alt=\"\"/>\n";
1877 t << "</div>";
1878 }
1879 }
1880 break;
1881 case ContextOutputFormat_Latex:
1882 {
1883 d.writeFigure(t,g_globals.outputDir,m_classDef->getOutputFileBase());
1884 }
1885 break;
1886 // TODO: support other generators
1887 default:
1888 err("context.cpp: output format not yet supported\n");
1889 break;
1890 }
1891 g_globals.dynSectionId++;
1892 }
1893 return TemplateVariant(t.str().c_str(),TRUE);
1894 }
getCollaborationGraph() const1895 DotClassGraphPtr getCollaborationGraph() const
1896 {
1897 return m_cachable.collaborationGraph.get(this);
1898 }
hasCollaborationDiagram() const1899 TemplateVariant hasCollaborationDiagram() const
1900 {
1901 static bool haveDot = Config_getBool(HAVE_DOT);
1902 return haveDot && !getCollaborationGraph()->isTrivial();
1903 }
collaborationDiagram() const1904 TemplateVariant collaborationDiagram() const
1905 {
1906 static bool haveDot = Config_getBool(HAVE_DOT);
1907 TextStream t;
1908 if (haveDot)
1909 {
1910 DotClassGraphPtr cg = getCollaborationGraph();
1911 switch (g_globals.outputFormat)
1912 {
1913 case ContextOutputFormat_Html:
1914 {
1915 cg->writeGraph(t,GOF_BITMAP,EOF_Html,
1916 g_globals.outputDir,
1917 g_globals.outputDir+Portable::pathSeparator()+addHtmlExtensionIfMissing(m_classDef->getOutputFileBase()),
1918 relPathAsString(),TRUE,TRUE,g_globals.dynSectionId
1919 );
1920 }
1921 break;
1922 case ContextOutputFormat_Latex:
1923 {
1924 cg->writeGraph(t,GOF_EPS,EOF_LaTeX,
1925 g_globals.outputDir,
1926 g_globals.outputDir+Portable::pathSeparator()+m_classDef->getOutputFileBase()+".tex",
1927 relPathAsString(),TRUE,TRUE,g_globals.dynSectionId
1928 );
1929 }
1930 break;
1931 // TODO: support other generators
1932 default:
1933 err("context.cpp: output format not yet supported\n");
1934 break;
1935 }
1936 g_globals.dynSectionId++;
1937 }
1938 return TemplateVariant(t.str().c_str(),TRUE);
1939 }
1940
1941
1942 private:
1943
createIncludeInfo() const1944 TemplateVariant createIncludeInfo() const
1945 {
1946 return m_classDef->includeInfo() ?
1947 IncludeInfoContext::alloc(m_classDef->includeInfo(),m_classDef->getLanguage()) :
1948 TemplateVariant(false);
1949 }
createInheritsList() const1950 TemplateVariant createInheritsList() const
1951 {
1952 return InheritanceListContext::alloc(m_classDef->baseClasses(),TRUE);
1953 }
createInheritedByList() const1954 TemplateVariant createInheritedByList() const
1955 {
1956 return InheritanceListContext::alloc(m_classDef->subClasses(),FALSE);
1957 }
createClassGraph() const1958 DotClassGraphPtr createClassGraph() const
1959 {
1960 return std::make_shared<DotClassGraph>(m_classDef,Inheritance);
1961 }
createCollaborationGraph() const1962 DotClassGraphPtr createCollaborationGraph() const
1963 {
1964 return std::make_shared<DotClassGraph>(m_classDef,Collaboration);
1965 }
createClasses() const1966 TemplateVariant createClasses() const
1967 {
1968 TemplateVariantList classList;
1969 classList.reserve(m_classDef->getClasses().size());
1970 for (const auto &cd : m_classDef->getClasses())
1971 {
1972 if (cd->visibleInParentsDeclList())
1973 {
1974 classList.push_back(ClassContext::alloc(cd));
1975 }
1976 }
1977 return TemplateImmutableList::alloc(classList);
1978 }
createInnerClasses() const1979 TemplateVariant createInnerClasses() const
1980 {
1981 TemplateVariantList classList;
1982 classList.reserve(m_classDef->getClasses().size());
1983 for (const auto &cd : m_classDef->getClasses())
1984 {
1985 if (!cd->isAnonymous() &&
1986 cd->isLinkableInProject() &&
1987 cd->isEmbeddedInOuterScope() &&
1988 cd->partOfGroups().empty()
1989 )
1990 {
1991 classList.push_back(ClassContext::alloc(cd));
1992 }
1993 }
1994 return TemplateImmutableList::alloc(classList);
1995 }
createMemberList(MemberListType type,const QCString & title) const1996 TemplateVariant createMemberList(MemberListType type,const QCString &title) const
1997 {
1998 const MemberList *ml = m_classDef->getMemberList(type);
1999 return ml ? TemplateVariant(MemberListInfoContext::alloc(m_classDef,relPathAsString(),ml,title,""))
2000 : TemplateVariant(false);
2001 }
createPublicTypes() const2002 TemplateVariant createPublicTypes() const
2003 {
2004 return createMemberList(MemberListType_pubTypes,theTranslator->trPublicTypes());
2005 }
createPublicMethods() const2006 TemplateVariant createPublicMethods() const
2007 {
2008 return createMemberList(MemberListType_pubMethods,
2009 m_classDef->getLanguage()==SrcLangExt_ObjC ? theTranslator->trInstanceMethods()
2010 : theTranslator->trPublicMembers());
2011 }
createPublicStaticMethods() const2012 TemplateVariant createPublicStaticMethods() const
2013 {
2014 return createMemberList(MemberListType_pubStaticMethods,
2015 m_classDef->getLanguage()==SrcLangExt_ObjC ? theTranslator->trClassMethods()
2016 : theTranslator->trStaticPublicMembers());
2017 }
createPublicAttributes() const2018 TemplateVariant createPublicAttributes() const
2019 {
2020 return createMemberList(MemberListType_pubAttribs,theTranslator->trPublicAttribs());
2021 }
createPublicStaticAttributes() const2022 TemplateVariant createPublicStaticAttributes() const
2023 {
2024 return createMemberList(MemberListType_pubStaticAttribs,theTranslator->trStaticPublicAttribs());
2025 }
createPublicSlots() const2026 TemplateVariant createPublicSlots() const
2027 {
2028 return createMemberList(MemberListType_pubSlots,theTranslator->trPublicSlots());
2029 }
createUnoIDLServices() const2030 TemplateVariant createUnoIDLServices() const
2031 {
2032 return createMemberList(MemberListType_services,theTranslator->trServices());
2033 }
createUnoIDLInterfaces() const2034 TemplateVariant createUnoIDLInterfaces() const
2035 {
2036 return createMemberList(MemberListType_interfaces,theTranslator->trInterfaces());
2037 }
createSignals() const2038 TemplateVariant createSignals() const
2039 {
2040 return createMemberList(MemberListType_signals,theTranslator->trSignals());
2041 }
createProtectedTypes() const2042 TemplateVariant createProtectedTypes() const
2043 {
2044 return createMemberList(MemberListType_proTypes,theTranslator->trProtectedTypes());
2045 }
createProtectedMethods() const2046 TemplateVariant createProtectedMethods() const
2047 {
2048 return createMemberList(MemberListType_proMethods,theTranslator->trProtectedMembers());
2049 }
createProtectedStaticMethods() const2050 TemplateVariant createProtectedStaticMethods() const
2051 {
2052 return createMemberList(MemberListType_proStaticMethods,theTranslator->trStaticProtectedMembers());
2053 }
createProtectedAttributes() const2054 TemplateVariant createProtectedAttributes() const
2055 {
2056 return createMemberList(MemberListType_proAttribs,theTranslator->trProtectedAttribs());
2057 }
createProtectedStaticAttributes() const2058 TemplateVariant createProtectedStaticAttributes() const
2059 {
2060 return createMemberList(MemberListType_proStaticAttribs,theTranslator->trStaticProtectedAttribs());
2061 }
createProtectedSlots() const2062