Doxygen
Loading...
Searching...
No Matches
layout.cpp
Go to the documentation of this file.
1/******************************************************************************
2 *
3 * Copyright (C) 1997-2024 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// own header
17#include "layout.h"
18
19// standard includes
20#include <array>
21
22// other includes
23#include "config.h"
24#include "debug.h"
25#include "docnode.h"
26#include "docparser.h"
27#include "language.h"
28#include "message.h"
29#include "regex.h"
30#include "resourcemgr.h"
31#include "textstream.h"
32#include "types.h"
33#include "util.h"
34#include "version.h"
35#include "xml.h"
36
37inline DString compileOptions(const DString &def)
38{
39 return def;
40}
41
42inline DString compileOptions(const DString &def,SrcLangExt langId1,const DString &value1)
43{
44 return compileOptions(def)+"|"+DString().setNum(static_cast<long>(langId1))+"="+value1;
45}
46
47inline DString compileOptions(const DString &def,SrcLangExt langId1,const DString &value1,
48 SrcLangExt langId2,const DString &value2)
49{
50 return compileOptions(def,langId1,value1)+
51 "|"+DString().setNum(static_cast<long>(langId2))+"="+value2;
52}
53
54inline DString compileOptions(const DString &def,SrcLangExt langId1,const DString &value1,
55 SrcLangExt langId2,const DString &value2,
56 SrcLangExt langId3,const DString &value3)
57{
58 return compileOptions(def,langId1,value1,langId2,value2)+
59 "|"+DString().setNum(static_cast<long>(langId3))+"="+value3;
60}
61
62inline DString compileOptions(const DString &def,SrcLangExt langId1,const DString &value1,
63 SrcLangExt langId2,const DString &value2,
64 SrcLangExt langId3,const DString &value3,
65 SrcLangExt langId4,const DString &value4)
66{
67 return compileOptions(def,langId1,value1,langId2,value2,langId3,value3)+
68 "|"+DString().setNum(static_cast<long>(langId4))+"="+value4;
69}
70
71inline DString compileOptions(const DString &def,SrcLangExt langId1,const DString &value1,
72 SrcLangExt langId2,const DString &value2,
73 SrcLangExt langId3,const DString &value3,
74 SrcLangExt langId4,const DString &value4,
75 SrcLangExt langId5,const DString &value5)
76{
77 return compileOptions(def,langId1,value1,langId2,value2,langId3,value3,langId4,value4)+
78 "|"+DString().setNum(static_cast<long>(langId5))+"="+value5;
79}
80
81static bool elemIsVisible(const XMLHandlers::Attributes &attrib,bool defVal=true)
82{
83 DString visible = XMLHandlers::value(attrib,"visible");
84 //printf("visible_attribute=%s\n",qPrint(visible));
85 if (visible.empty()) return defVal;
86 if (visible.at(0)=='$' && visible.length()>1)
87 {
88 DString id = visible.mid(1);
89 const ConfigValues::Info *opt = ConfigValues::instance().get(id);
90 if (opt && opt->type==ConfigValues::Info::Bool)
91 {
92 return ConfigValues::instance().*(opt->value.b);
93 }
94 else if (opt && opt->type==ConfigValues::Info::String)
95 {
96 return opt->getBooleanRepresentation();
97 }
98 else if (!opt)
99 {
100 err("found unsupported value '{}' for visible attribute in layout file, reverting to '{}'\n",
101 visible,(defVal?"yes":"no"));
102 return defVal;
103 }
104 }
105 DString visibleLow = visible.lower();
106 if (visibleLow=="no" || visibleLow=="false" || visibleLow=="0") return false;
107 else if (visibleLow=="yes" || visibleLow=="true" || visibleLow=="1") return true;
108 else
109 {
110 err("found unsupported value '{}' for visible attribute in layout file, reverting to '{}'\n",
111 visible,(defVal?"yes":"no"));
112 return defVal;
113 }
114}
115
116//---------------------------------------------------------------------------------
117
118void LayoutNavEntry::updateVisibility(LayoutNavEntry *parent)
119{
120 m_visible = m_visible && (parent==nullptr || parent->visible());
121}
122
123void LayoutNavEntry::appendChild(std::unique_ptr<LayoutNavEntry> &&e)
124{
125 e->updateVisibility(this);
126 m_children.push_back(std::move(e));
127}
128
129void LayoutNavEntry::insertChild(size_t pos,std::unique_ptr<LayoutNavEntry> &&e)
130{
131 e->updateVisibility(this);
132 m_children.insert(m_children.begin()+pos,std::move(e));
133}
134
135LayoutNavEntry *LayoutNavEntry::find(LayoutNavEntry::Kind kind,
136 const DString &file) const
137{
138 LayoutNavEntry *result=nullptr;
139 for (const auto &entry : m_children)
140 {
141 // depth first search, needed to find the entry furthest from the
142 // root in case an entry is in the tree twice
143 result = entry->find(kind,file);
144 if (result) return result;
145 if (entry->kind()==kind && (file==DString() || entry->baseFile()==file))
146 {
147 return entry.get();
148 }
149 }
150 return result;
151}
152
153DString LayoutNavEntry::url() const
154{
155 DString url = baseFile().stripWhiteSpace();
156 if ((kind()!=LayoutNavEntry::User && kind()!=LayoutNavEntry::UserGroup) ||
157 (kind()==LayoutNavEntry::UserGroup && url.startsWith("usergroup")))
158 {
159 addHtmlExtensionIfMissing(url);
160 }
161 else if (url.startsWith("@ref ") || url.startsWith("\\ref "))
162 {
163 bool found=false;
164 DString relPath = "";
165 DString context = DString();
166 auto parser { createDocParser() };
167 auto dfAst { createRef( *parser.get(), url.mid(5).stripWhiteSpace(), context ) };
168 auto dfAstImpl = dynamic_cast<const DocNodeAST*>(dfAst.get());
169 const DocRef *df = std::get_if<DocRef>(&dfAstImpl->root);
170 if (!df->file().empty() || !df->anchor().empty())
171 {
172 found = true;
173 url=externalRef(relPath,df->ref());
174 if (!df->file().empty())
175 {
176 DString fn = df->file();
177 addHtmlExtensionIfMissing(fn);
178 url += fn;
179 }
180 if (!df->anchor().empty())
181 {
182 url += "#" + df->anchor();
183 }
184 }
185 if (!found)
186 {
187 msg("explicit link request to '{}' in layout file '{}' could not be resolved\n",url.mid(5),Config_getString(LAYOUT_FILE));
188 }
189 }
190 //printf("LayoutNavEntry::url()=%s\n",qPrint(url));
191 return url;
192}
193
194//---------------------------------------------------------------------------------
195
196class LayoutParser
197{
198 public:
199 LayoutParser(LayoutDocManager &manager) : m_layoutDocManager(manager) {}
200
201 // =========== XMLHandler events
202 void setDocumentLocator(const XMLLocator *locator)
203 {
204 m_locator = locator;
205 }
206 void error( const std::string &fileName,int lineNr,const std::string &msg)
207 {
208 warn_layout(fileName,lineNr,"{}",msg);
209 }
210 void startElement( const std::string &name, const XMLHandlers::Attributes& attrib );
211 void endElement( const std::string &name );
212
213 void startSimpleEntry(LayoutDocEntry::Kind k,const std::string &id,const XMLHandlers::Attributes &attrib)
214 {
215 bool isVisible = m_visible && elemIsVisible(attrib);
216 if (m_part!=LayoutDocManager::Undefined)
217 {
218 auto elem = std::make_unique<LayoutDocEntrySimple>(k,id,isVisible);
219 //printf("startSimpleEntry(%s) isVisible=%d visible=%d\n",qPrint(elem->entryToString()),isVisible,elem->visible());
220 m_layoutDocManager.addEntry(m_part,std::move(elem));
221 }
222 }
223
224 // ============ Specific callbacks
225
226 void startSectionEntry(LayoutDocEntry::Kind k,const std::string &id,const XMLHandlers::Attributes &attrib,
227 const DString &title)
228 {
229 bool isVisible = m_visible && elemIsVisible(attrib);
230 DString userTitle = XMLHandlers::value(attrib,"title");
231 //printf("startSectionEntry: title='%s' userTitle='%s'\n",
232 // qPrint(title),qPrint(userTitle));
233 if (userTitle.empty()) userTitle = title;
234 if (m_part!=LayoutDocManager::Undefined)
235 {
236 m_layoutDocManager.addEntry(m_part,std::make_unique<LayoutDocEntrySection>(k,id,userTitle,isVisible));
237 }
238 }
239
240
241 void startMemberDeclEntry(const std::string &id,const XMLHandlers::Attributes &attrib,MemberListType type,
242 const DString &title,const DString &subscript)
243 {
244 DString userTitle = XMLHandlers::value(attrib,"title");
245 DString userSubscript = XMLHandlers::value(attrib,"subtitle");
246 if (userTitle.empty()) userTitle = title;
247 if (userSubscript.empty()) userSubscript = subscript;
248 bool isVisible = m_visible && elemIsVisible(attrib);
249 if (m_part!=LayoutDocManager::Undefined)
250 {
251 m_layoutDocManager.addEntry(m_part,std::make_unique<LayoutDocEntryMemberDecl>(type,id,userTitle,userSubscript,isVisible));
252 }
253 }
254
255 void startMemberDefEntry(const std::string &id,const XMLHandlers::Attributes &attrib,MemberListType type,
256 const DString &title,const DString &)
257 {
258 DString userTitle = XMLHandlers::value(attrib,"title");
259 if (userTitle.empty()) userTitle = title;
260 //printf("memberdef: %s\n",qPrint(userTitle));
261 bool isVisible = m_visible && elemIsVisible(attrib);
262 if (m_part!=LayoutDocManager::Undefined)
263 {
264 m_layoutDocManager.addEntry(m_part,std::make_unique<LayoutDocEntryMemberDef>(type,id,userTitle,isVisible));
265 }
266 }
267
268 void startLayout(const std::string &,const XMLHandlers::Attributes &attrib)
269 {
270 // extract and store version number
271 DString version = XMLHandlers::value(attrib,"version");
272 static const reg::Ex re(R"((\d+)\.(\d+))");
273 reg::Match match;
274 if (reg::match(version.view(),match,re))
275 {
276 m_majorVersion = atoi(match[1].str().c_str());
277 m_minorVersion = atoi(match[2].str().c_str());
278 //printf("layout version %d.%d\n",m_versionMajor,m_versionMinor);
279 }
280 }
281
282 void startNavIndex(const std::string &,const XMLHandlers::Attributes &)
283 {
284 m_scope="navindex/";
285 m_rootNav = m_layoutDocManager.rootNavEntry();
286 }
287
288 void endNavIndex(const std::string &)
289 {
290 m_scope="";
291 if (m_rootNav && !m_rootNav->find(LayoutNavEntry::MainPage))
292 {
293 // no MainPage node... add one as the first item of the root node...
294 m_rootNav->insertChild(0,std::make_unique<LayoutNavEntry>(m_rootNav,LayoutNavEntry::MainPage, true,
295 "index",theTranslator->trMainPage(),""));
296 }
297 }
298
299 void startNavEntry(const std::string &,const XMLHandlers::Attributes &attrib)
300 {
301 bool javaOpt = Config_getBool(OPTIMIZE_OUTPUT_JAVA);
302 bool fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
303 bool vhdlOpt = Config_getBool(OPTIMIZE_OUTPUT_VHDL);
304 bool sliceOpt = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
305 bool hasGraphicalHierarchy = Config_getBool(HAVE_DOT) &&
306 Config_getBool(GRAPHICAL_HIERARCHY);
307 bool extractAll = Config_getBool(EXTRACT_ALL);
308 static struct NavEntryMap
309 {
310 const char *typeStr; // type attribute name in the XML file
311 LayoutNavEntry::Kind kind; // corresponding enum name
312 DString mainName; // default title for an item if it has children
313 DString subName; // optional name for an item if it is rendered as a child
314 DString intro; // introduction text to be put on the index page
315 DString baseFile; // base name of the file containing the index page
316 } mapping[] =
317 {
318 { "mainpage",
319 LayoutNavEntry::MainPage,
320 theTranslator->trMainPage(),
321 DString(),
322 DString(),
323 "index"
324 },
325 { "pages",
326 LayoutNavEntry::Pages,
327 theTranslator->trRelatedPages(),
328 DString(),
329 theTranslator->trRelatedPagesDescription(),
330 "pages"
331 },
332 { "topics",
333 LayoutNavEntry::Topics,
334 theTranslator->trTopics(),
335 DString(),
336 theTranslator->trTopicListDescription(),
337 "topics"
338 },
339 { "modules",
340 LayoutNavEntry::Modules,
341 theTranslator->trModules(),
342 theTranslator->trModulesList(),
343 theTranslator->trModulesDescription(),
344 "modules"
345 },
346 { "modulelist",
347 LayoutNavEntry::ModuleList,
348 theTranslator->trModulesList(),
349 DString(),
350 theTranslator->trModulesListDescription(extractAll),
351 "modules"
352 },
353 { "modulemembers",
354 LayoutNavEntry::ModuleMembers,
355 theTranslator->trModulesMembers(),
356 DString(),
357 theTranslator->trModulesMemberDescription(extractAll),
358 "modulemembers"
359 },
360 { "namespaces",
361 LayoutNavEntry::Namespaces,
362 javaOpt || vhdlOpt ? theTranslator->trPackages() : fortranOpt || sliceOpt ? theTranslator->trModules() : theTranslator->trNamespaces(),
363 javaOpt || vhdlOpt ? theTranslator->trPackageList() : fortranOpt || sliceOpt ? theTranslator->trModulesList() : theTranslator->trNamespaceList(),
364 javaOpt || vhdlOpt ? theTranslator->trPackageListDescription() : fortranOpt || sliceOpt ? theTranslator->trModulesListDescription(extractAll) : theTranslator->trNamespaceListDescription(extractAll),
365 "namespaces"
366 },
367 { "namespacelist",
368 LayoutNavEntry::NamespaceList,
369 javaOpt || vhdlOpt ? theTranslator->trPackageList() : fortranOpt || sliceOpt ? theTranslator->trModulesList() : theTranslator->trNamespaceList(),
370 DString(),
371 javaOpt || vhdlOpt ? theTranslator->trPackageListDescription() : fortranOpt || sliceOpt ? theTranslator->trModulesListDescription(extractAll) : theTranslator->trNamespaceListDescription(extractAll),
372 "namespaces"
373 },
374 { "namespacemembers",
375 LayoutNavEntry::NamespaceMembers,
376 javaOpt || vhdlOpt ? theTranslator->trPackageMembers() : fortranOpt || sliceOpt ? theTranslator->trModulesMembers() : theTranslator->trNamespaceMembers(),
377 DString(),
378 fortranOpt || sliceOpt ? theTranslator->trModulesMemberDescription(extractAll) : theTranslator->trNamespaceMemberDescription(extractAll),
379 "namespacemembers"
380 },
381 { "concepts",
382 LayoutNavEntry::Concepts,
383 theTranslator->trConcept(true,false),
384 theTranslator->trConceptList(),
385 theTranslator->trConceptListDescription(extractAll),
386 "concepts"
387 },
388 { "classindex",
389 LayoutNavEntry::ClassIndex,
390 fortranOpt ? theTranslator->trCompoundIndexFortran() : vhdlOpt ? theTranslator->trDesignUnitIndex() : theTranslator->trCompoundIndex(),
391 DString(),
392 DString(),
393 "classes"
394 },
395 { "classes",
396 LayoutNavEntry::Classes,
397 fortranOpt ? theTranslator->trDataTypes() : vhdlOpt ? theTranslator->trDesignUnits() : theTranslator->trClasses(),
398 theTranslator->trCompoundList(),
399 fortranOpt ? theTranslator->trCompoundListDescriptionFortran() : vhdlOpt ? theTranslator->trDesignUnitListDescription() : theTranslator->trCompoundListDescription(),
400 "annotated"
401 },
402 { "classlist",
403 LayoutNavEntry::ClassList,
404 fortranOpt ? theTranslator->trCompoundListFortran() : vhdlOpt ? theTranslator->trDesignUnitList() : theTranslator->trCompoundList(),
405 DString(),
406 fortranOpt ? theTranslator->trCompoundListDescriptionFortran() : vhdlOpt ? theTranslator->trDesignUnitListDescription() : theTranslator->trCompoundListDescription(),
407 "annotated"
408 },
409 { "hierarchy",
410 LayoutNavEntry::ClassHierarchy,
411 vhdlOpt ? theTranslator->trDesignUnitHierarchy() : theTranslator->trClassHierarchy(),
412 DString(),
413 theTranslator->trClassHierarchyDescription(),
414 hasGraphicalHierarchy ? "inherits" : "hierarchy"
415 },
416 { "classmembers",
417 LayoutNavEntry::ClassMembers,
418 fortranOpt ? theTranslator->trCompoundMembersFortran() : vhdlOpt ? theTranslator->trDesignUnitMembers() : theTranslator->trCompoundMembers(),
419 DString(),
420 fortranOpt ? theTranslator->trCompoundMembersDescriptionFortran(extractAll) : theTranslator->trCompoundMembersDescription(extractAll),
421 "functions"
422 },
423 { "interfaceindex",
424 LayoutNavEntry::InterfaceIndex,
425 theTranslator->trInterfaceIndex(),
426 DString(),
427 DString(),
428 "interfaces"
429 },
430 { "interfaces",
431 LayoutNavEntry::Interfaces,
432 theTranslator->trSliceInterfaces(),
433 theTranslator->trInterfaceList(),
434 theTranslator->trInterfaceListDescription(),
435 "annotatedinterfaces"
436 },
437 { "interfacelist",
438 LayoutNavEntry::InterfaceList,
439 theTranslator->trInterfaceList(),
440 DString(),
441 theTranslator->trInterfaceListDescription(),
442 "annotatedinterfaces"
443 },
444 { "interfacehierarchy",
445 LayoutNavEntry::InterfaceHierarchy,
446 theTranslator->trInterfaceHierarchy(),
447 DString(),
448 theTranslator->trInterfaceHierarchyDescription(),
449 hasGraphicalHierarchy ? "interfaceinherits" : "interfacehierarchy"
450 },
451 { "structindex",
452 LayoutNavEntry::StructIndex,
453 theTranslator->trStructIndex(),
454 DString(),
455 DString(),
456 "structs"
457 },
458 { "structs",
459 LayoutNavEntry::Structs,
460 theTranslator->trStructs(),
461 theTranslator->trStructList(),
462 theTranslator->trStructListDescription(),
463 "annotatedstructs"
464 },
465 { "structlist",
466 LayoutNavEntry::StructList,
467 theTranslator->trStructList(),
468 DString(),
469 theTranslator->trStructListDescription(),
470 "annotatedstructs"
471 },
472 { "exceptionindex",
473 LayoutNavEntry::ExceptionIndex,
474 theTranslator->trExceptionIndex(),
475 DString(),
476 DString(),
477 "exceptions"
478 },
479 { "exceptions",
480 LayoutNavEntry::Exceptions,
481 theTranslator->trExceptions(),
482 theTranslator->trExceptionList(),
483 theTranslator->trExceptionListDescription(),
484 "annotatedexceptions"
485 },
486 { "exceptionlist",
487 LayoutNavEntry::ExceptionList,
488 theTranslator->trExceptionList(),
489 DString(),
490 theTranslator->trExceptionListDescription(),
491 "annotatedexceptions"
492 },
493 { "exceptionhierarchy",
494 LayoutNavEntry::ExceptionHierarchy,
495 theTranslator->trExceptionHierarchy(),
496 DString(),
497 theTranslator->trExceptionHierarchyDescription(),
498 hasGraphicalHierarchy ? "exceptioninherits" : "exceptionhierarchy"
499 },
500 { "files",
501 LayoutNavEntry::Files,
502 theTranslator->trFile(true,false),
503 theTranslator->trFileList(),
504 theTranslator->trFileListDescription(extractAll),
505 "files"
506 },
507 { "filelist",
508 LayoutNavEntry::FileList,
509 theTranslator->trFileList(),
510 DString(),
511 theTranslator->trFileListDescription(extractAll),
512 "files"
513 },
514 { "globals",
515 LayoutNavEntry::FileGlobals,
516 theTranslator->trFileMembers(),
517 DString(),
518 theTranslator->trFileMembersDescription(extractAll),
519 "globals"
520 },
521 { "examples",
522 LayoutNavEntry::Examples,
523 theTranslator->trExamples(),
524 DString(),
525 theTranslator->trExamplesDescription(),
526 "examples"
527 },
528 { "user",
529 LayoutNavEntry::User,
530 DString(),
531 DString(),
532 DString(),
533 "user"
534 },
535 { "usergroup",
536 LayoutNavEntry::UserGroup,
537 DString(),
538 DString(),
539 DString(),
540 "usergroup"
541 },
542 { nullptr, // end of list
543 static_cast<LayoutNavEntry::Kind>(0),
544 DString(),
545 DString(),
546 DString(),
547 DString()
548 }
549 };
550 // find type in the table
551 int i=0;
552 DString type = XMLHandlers::value(attrib,"type");
553 while (mapping[i].typeStr)
554 {
555 if (mapping[i].typeStr==type)
556 break;
557 i++;
558 }
559 if (mapping[i].typeStr==nullptr)
560 {
561 DString fileName = m_locator->fileName();
562 if (type.empty())
563 {
564 warn_layout(fileName,m_locator->lineNr(),"an entry tag within a navindex has no type attribute! Check your layout file!");
565 }
566 else
567 {
568 warn_layout(fileName,m_locator->lineNr(),"the type '{}' is not supported for the entry tag within a navindex! Check your layout file!",type);
569 }
570 m_invalidEntry=true;
571 return;
572 }
573 LayoutNavEntry::Kind kind = mapping[i].kind;
574 DString baseFile = mapping[i].baseFile;
575 DString title = XMLHandlers::value(attrib,"title");
576 bool isVisible = m_visible && elemIsVisible(attrib);
577 if (title.empty()) // use default title
578 {
579 title = mapping[i].mainName; // use title for main row
580 if (m_rootNav!=m_layoutDocManager.rootNavEntry() && !mapping[i].subName.empty())
581 {
582 title = mapping[i].subName; // if this is a child of another row, use the subName if available
583 // this is mainly done to get compatible naming with older versions.
584 }
585 }
586 DString intro = XMLHandlers::value(attrib,"intro");
587 if (intro.empty()) // use default intro text
588 {
589 intro = mapping[i].intro;
590 }
591 DString url = XMLHandlers::value(attrib,"url");
592 if (mapping[i].kind==LayoutNavEntry::User && !url.empty())
593 {
594 baseFile=url;
595 }
596 else if (kind==LayoutNavEntry::UserGroup)
597 {
598 if (!url.empty())
599 {
600 if (url == "[none]")
601 {
602 baseFile = DString();
603 }
604 else
605 {
606 baseFile=url;
607 }
608 }
609 else
610 {
611 baseFile+=DString().sprintf("%d",m_userGroupCount++);
612 }
613 }
614 // create new item and make it the new root
615 m_rootNav = m_layoutDocManager.createChildNavEntry(m_rootNav,kind,isVisible,baseFile,title,intro);
616 }
617
618 void endNavEntry(const std::string &)
619 {
620 // set the root back to the parent
621 if (m_rootNav && !m_invalidEntry) m_rootNav = m_rootNav->parent();
622 m_invalidEntry=false;
623 }
624
625 void startTop(const std::string &,const XMLHandlers::Attributes &attrib,LayoutDocManager::LayoutPart part,
626 const DString &scope, LayoutNavEntry::Kind nav)
627 {
628 //printf("startTop(scope=%s)\n",qPrint(scope));
629 m_scope = scope;
630 m_part = part;
631 m_visible = elemIsVisible(attrib);
632 }
633
634 void endTop(const std::string &)
635 {
636 m_scope="";
637 m_part = LayoutDocManager::Undefined;
638 }
639
640 void startMemberDef(const std::string &id,const XMLHandlers::Attributes &attrib)
641 {
642 m_scope+="memberdef/";
643 bool isVisible = m_visible && elemIsVisible(attrib);
644 if (m_part!=LayoutDocManager::Undefined)
645 {
646 m_layoutDocManager.addEntry(m_part,std::make_unique<LayoutDocEntrySimple>(LayoutDocEntry::MemberDefStart,id,isVisible));
647 }
648 }
649
650 void endMemberDef(const std::string &id)
651 {
652 DString scopeOrg = m_scope;
653 if (size_t i=m_scope.rfind("memberdef/"); i!=DString::npos)
654 {
655 m_scope=m_scope.left(i);
656 bool isVisible = true;
657 for (const auto &lde : m_layoutDocManager.docEntries(m_part))
658 {
659 if (lde->kind() == LayoutDocEntry::MemberDefStart)
660 {
661 isVisible = static_cast<const LayoutDocEntrySimple*>(lde.get())->visible();
662 break;
663 }
664 }
665 if (m_part!=LayoutDocManager::Undefined)
666 {
667 m_layoutDocManager.addEntry(m_part,std::make_unique<LayoutDocEntrySimple>(LayoutDocEntry::MemberDefEnd,id,isVisible));
668 }
669 }
670 }
671
672 void startMemberDecl(const std::string &id,const XMLHandlers::Attributes &attrib)
673 {
674 m_scope+="memberdecl/";
675 bool isVisible = m_visible && elemIsVisible(attrib);
676 if (m_part!=LayoutDocManager::Undefined)
677 {
678 m_layoutDocManager.addEntry(m_part,std::make_unique<LayoutDocEntrySimple>(LayoutDocEntry::MemberDeclStart,id,isVisible));
679 }
680 }
681
682 void endMemberDecl(const std::string &id)
683 {
684 if (size_t i=m_scope.rfind("memberdecl/"); i!=DString::npos)
685 {
686 m_scope=m_scope.left(i);
687 bool isVisible = true;
688 for (const auto &lde : m_layoutDocManager.docEntries(m_part))
689 {
690 if (lde->kind() == LayoutDocEntry::MemberDeclStart)
691 {
692 isVisible = static_cast<const LayoutDocEntrySimple*>(lde.get())->visible();
693 break;
694 }
695 }
696 if (m_part!=LayoutDocManager::Undefined)
697 {
698 m_layoutDocManager.addEntry(m_part,std::make_unique<LayoutDocEntrySimple>(LayoutDocEntry::MemberDeclEnd,id,isVisible));
699 }
700 }
701 }
702
703 int majorVersion() const { return m_majorVersion; }
704 int minorVersion() const { return m_minorVersion; }
705
706 private:
707 DString m_scope;
708 LayoutDocManager &m_layoutDocManager;
709 LayoutDocManager::LayoutPart m_part = LayoutDocManager::Undefined;
710 LayoutNavEntry *m_rootNav = nullptr;
711 bool m_invalidEntry = false;
712 bool m_visible = true;
713 static int m_userGroupCount;
714 const XMLLocator *m_locator = nullptr;
715 int m_majorVersion = 1;
716 int m_minorVersion = 0;
717};
718
719//---------------------------------------------------------------------------------
720
721namespace {
722
723struct ElementCallbacks
724{
725 using StartCallback = std::function<void(LayoutParser&,const std::string &,const XMLHandlers::Attributes&)>;
726 using EndCallback = std::function<void(LayoutParser&,const std::string &)>;
727
728 StartCallback startCb;
729 EndCallback endCb = [](LayoutParser &,const std::string &){};
730};
731
732template<class...Args>
733static auto startCb(void (LayoutParser::*fn)(Args...))
734{
735 return [=](LayoutParser &parser,const std::string &id,const XMLHandlers::Attributes &attr) { (parser.*fn)(id,attr); };
736}
737
738template<class...Args>
739static auto startCb(void (LayoutParser::*fn)(Args...),
740 LayoutDocEntry::Kind kind
741 )
742{
743 return [=](LayoutParser &parser,const std::string &id,const XMLHandlers::Attributes &attr) { (parser.*fn)(kind,id,attr); };
744}
745
746template<class...Args>
747static auto startCb(void (LayoutParser::*fn)(Args...),
748 LayoutDocEntry::Kind kind,
749 const std::function<DString()> &title
750 )
751{
752 return [=](LayoutParser &parser,const std::string &id,const XMLHandlers::Attributes &attr) { (parser.*fn)(kind,id,attr,title()); };
753}
754
755template<class...Args>
756static auto startCb(void (LayoutParser::*fn)(Args...),
757 MemberListType type,
758 const std::function<DString()> &title
759 )
760{
761 return [=](LayoutParser &parser,const std::string &id,const XMLHandlers::Attributes &attr) { (parser.*fn)(id,attr,type,title(),DString()); };
762}
763
764template<class...Args>
765static auto startCb(void (LayoutParser::*fn)(Args...),
766 MemberListType type,
767 const std::function<DString()> &title,
768 const std::function<DString()> &subtitle
769 )
770{
771 return [=](LayoutParser &parser,const std::string &id,const XMLHandlers::Attributes &attr) { (parser.*fn)(id,attr,type,title(),subtitle()); };
772}
773
774template<class...Args>
775static auto startCb(void (LayoutParser::*fn)(Args...),
776 LayoutDocManager::LayoutPart part,
777 const DString &scope,
778 LayoutNavEntry::Kind nav
779 )
780{
781 return [=](LayoutParser &parser,const std::string &id,const XMLHandlers::Attributes &attr) { (parser.*fn)(id,attr,part,scope,nav); };
782}
783
784template<class...Args>
785static auto endCb(void (LayoutParser::*fn)(Args...))
786{
787 return [=](LayoutParser &parser,const std::string &id) { (parser.*fn)(id); };
788}
789
790// clang-format off
791static const std::map< std::string, ElementCallbacks > g_elementHandlers =
792{
793 // path/name
794 { "doxygenlayout", { startCb(&LayoutParser::startLayout) } },
795 { "navindex", { startCb(&LayoutParser::startNavIndex), endCb(&LayoutParser::endNavIndex) } },
796 { "navindex/tab", { startCb(&LayoutParser::startNavEntry),
797 endCb(&LayoutParser::endNavEntry)
798 } },
799
800 // class layout handlers
801 { "class", { startCb(&LayoutParser::startTop,LayoutDocManager::Class,"class/",LayoutNavEntry::Classes),
802 endCb(&LayoutParser::endTop)
803 } },
804 { "class/briefdescription", { startCb(&LayoutParser::startSimpleEntry,LayoutDocEntry::BriefDesc) } },
805 { "class/detaileddescription", { startCb(&LayoutParser::startSectionEntry,LayoutDocEntry::DetailedDesc,
806 [](){ return compileOptions(theTranslator->trDetailedDescription()); })
807 } },
808 { "class/authorsection", { startCb(&LayoutParser::startSimpleEntry,LayoutDocEntry::AuthorSection) } },
809 { "class/includes", { startCb(&LayoutParser::startSimpleEntry,LayoutDocEntry::ClassIncludes) } },
810 { "class/inheritancegraph", { startCb(&LayoutParser::startSimpleEntry,LayoutDocEntry::ClassInheritanceGraph) } },
811 { "class/collaborationgraph", { startCb(&LayoutParser::startSimpleEntry,LayoutDocEntry::ClassCollaborationGraph) } },
812 { "class/allmemberslink", { startCb(&LayoutParser::startSimpleEntry,LayoutDocEntry::ClassAllMembersLink) } },
813 { "class/usedfiles", { startCb(&LayoutParser::startSimpleEntry,LayoutDocEntry::ClassUsedFiles) } },
814 { "class/memberdecl", { startCb(&LayoutParser::startMemberDecl), endCb(&LayoutParser::endMemberDecl) } },
815 { "class/memberdecl/membergroups", { startCb(&LayoutParser::startSimpleEntry,LayoutDocEntry::MemberGroups) } },
816 { "class/memberdecl/nestedclasses", { startCb(&LayoutParser::startSectionEntry,LayoutDocEntry::ClassNestedClasses,
817 []() { return compileOptions(/*default*/ theTranslator->trCompounds(),
818 SrcLangExt::VHDL, theTranslator->trVhdlType(VhdlSpecifier::ENTITY,false),
819 SrcLangExt::Fortran,theTranslator->trDataTypes()); })
820 } },
821 { "class/memberdecl/services", { startCb(&LayoutParser::startMemberDeclEntry,MemberListType::Services(),
822 []() { return compileOptions(theTranslator->trServices()); })
823 } },
824 { "class/memberdecl/interfaces", { startCb(&LayoutParser::startMemberDeclEntry,MemberListType::Interfaces(),
825 []() { return compileOptions(theTranslator->trInterfaces()); })
826 } },
827 { "class/memberdecl/publictypes", { startCb(&LayoutParser::startMemberDeclEntry,MemberListType::PubTypes(),
828 []() { return compileOptions(theTranslator->trPublicTypes()); })
829 } },
830 { "class/memberdecl/publicslots", { startCb(&LayoutParser::startMemberDeclEntry,MemberListType::PubSlots(),
831 []() { return compileOptions(theTranslator->trPublicSlots()); })
832 } },
833 { "class/memberdecl/signals", { startCb(&LayoutParser::startMemberDeclEntry,MemberListType::Signals(),
834 []() { return compileOptions(theTranslator->trSignals()); })
835 } },
836 { "class/memberdecl/publicmethods", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::PubMethods(),
837 []() { return compileOptions(/* default */ theTranslator->trPublicMembers(),
838 SrcLangExt::ObjC, theTranslator->trInstanceMethods(),
839 SrcLangExt::Slice,theTranslator->trOperations()); })
840 } },
841 { "class/memberdecl/publicstaticmethods", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::PubStaticMethods(),
842 []() { return compileOptions(/* default */ theTranslator->trStaticPublicMembers(),
843 SrcLangExt::ObjC, theTranslator->trClassMethods()); })
844 } },
845 { "class/memberdecl/publicattributes", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::PubAttribs(),
846 []() { return compileOptions(/* default */ theTranslator->trPublicAttribs(),
847 SrcLangExt::Slice,theTranslator->trDataMembers()); })
848 } },
849 { "class/memberdecl/publicstaticattributes", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::PubStaticAttribs(),
850 []() { return compileOptions(theTranslator->trStaticPublicAttribs()); })
851 } },
852 { "class/memberdecl/protectedtypes", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::ProTypes(),
853 []() { return compileOptions(theTranslator->trProtectedTypes()); })
854 } },
855 { "class/memberdecl/protectedslots", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::ProSlots(),
856 []() { return compileOptions(theTranslator->trProtectedSlots()); })
857 } },
858 { "class/memberdecl/protectedmethods", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::ProMethods(),
859 []() { return compileOptions(theTranslator->trProtectedMembers()); })
860 } },
861 { "class/memberdecl/protectedstaticmethods", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::ProStaticMethods(),
862 []() { return compileOptions(theTranslator->trStaticProtectedMembers()); })
863 } },
864 { "class/memberdecl/protectedattributes", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::ProAttribs(),
865 []() { return compileOptions(theTranslator->trProtectedAttribs()); })
866 } },
867 { "class/memberdecl/protectedstaticattributes", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::ProStaticAttribs(),
868 []() { return compileOptions(theTranslator->trStaticProtectedAttribs()); })
869 } },
870 { "class/memberdecl/packagetypes", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::PacTypes(),
871 []() { return compileOptions(theTranslator->trPackageTypes()); })
872 } },
873 { "class/memberdecl/packagemethods", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::PacMethods(),
874 []() { return compileOptions(theTranslator->trPackageFunctions()); })
875 } },
876 { "class/memberdecl/packagestaticmethods", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::PacStaticMethods(),
877 []() { return compileOptions(theTranslator->trStaticPackageFunctions()); })
878 } },
879 { "class/memberdecl/packageattributes", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::PacAttribs(),
880 []() { return compileOptions(theTranslator->trPackageAttribs()); })
881 } },
882 { "class/memberdecl/packagestaticattributes", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::PacStaticAttribs(),
883 []() { return compileOptions(theTranslator->trStaticPackageAttribs()); })
884 } },
885 { "class/memberdecl/properties", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::Properties(),
886 []() { return compileOptions(theTranslator->trProperties()); })
887 } },
888 { "class/memberdecl/events", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::Events(),
889 []() { return compileOptions(theTranslator->trEvents()); })
890 } },
891 { "class/memberdecl/privatetypes", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::PriTypes(),
892 []() { return compileOptions(theTranslator->trPrivateTypes()); })
893 } },
894 { "class/memberdecl/privateslots", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::PriSlots(),
895 []() { return compileOptions(theTranslator->trPrivateSlots()); })
896 } },
897 { "class/memberdecl/privatemethods", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::PriMethods(),
898 []() { return compileOptions(theTranslator->trPrivateMembers()); })
899 } },
900 { "class/memberdecl/privatestaticmethods", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::PriStaticMethods(),
901 []() { return compileOptions(theTranslator->trStaticPrivateMembers()); })
902 } },
903 { "class/memberdecl/privateattributes", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::PriAttribs(),
904 []() { return compileOptions(theTranslator->trPrivateAttribs()); })
905 } },
906 { "class/memberdecl/privatestaticattributes", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::PriStaticAttribs(),
907 []() { return compileOptions(theTranslator->trStaticPrivateAttribs()); })
908 } },
909 { "class/memberdecl/friends", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::Friends(),
910 []() { return compileOptions(theTranslator->trFriends()); })
911 } },
912 { "class/memberdecl/related", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::Related(),
913 []() { return compileOptions(theTranslator->trRelatedSymbols()); },
914 []() { return compileOptions(theTranslator->trRelatedSymbolsSubscript()); })
915 } },
916 { "class/memberdef", { startCb(&LayoutParser::startMemberDef), endCb(&LayoutParser::endMemberDef) } },
917 { "class/memberdef/inlineclasses", { startCb(&LayoutParser::startSectionEntry, LayoutDocEntry::ClassInlineClasses,
918 []() { return compileOptions(/* default */ theTranslator->trClassDocumentation(),
919 SrcLangExt::Fortran,theTranslator->trTypeDocumentation()); })
920 } },
921 { "class/memberdef/typedefs", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::TypedefMembers(),
922 []() { return compileOptions(theTranslator->trMemberTypedefDocumentation()); })
923 } },
924 { "class/memberdef/enums", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::EnumMembers(),
925 []() { return compileOptions(theTranslator->trMemberEnumerationDocumentation()); })
926 } },
927 { "class/memberdef/services", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::ServiceMembers(),
928 []() { return compileOptions(theTranslator->trInterfaces()); })
929 } },
930 { "class/memberdef/interfaces", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::InterfaceMembers(),
931 []() { return compileOptions(theTranslator->trInterfaces()); })
932 } },
933 { "class/memberdef/constructors", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::Constructors(),
934 []() { return compileOptions(theTranslator->trConstructorDocumentation()); })
935 } },
936 { "class/memberdef/functions", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::FunctionMembers(),
937 []() { return compileOptions(/* default */ theTranslator->trMemberFunctionDocumentation(), SrcLangExt::ObjC, theTranslator->trMethodDocumentation(),
938 SrcLangExt::Fortran,theTranslator->trMemberFunctionDocumentationFortran(),
939 SrcLangExt::Slice, theTranslator->trOperationDocumentation()); })
940 } },
941 { "class/memberdef/related", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::RelatedMembers(),
942 []() { return compileOptions(theTranslator->trRelatedSymbolDocumentation()); })
943 } },
944 { "class/memberdef/variables", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::VariableMembers(),
945 []() { return compileOptions(/* default */ theTranslator->trMemberDataDocumentation(),
946 SrcLangExt::Slice, theTranslator->trDataMemberDocumentation()); })
947 } },
948 { "class/memberdef/properties", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::PropertyMembers(),
949 []() { return compileOptions(theTranslator->trPropertyDocumentation()); })
950 } },
951 { "class/memberdef/events", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::EventMembers(),
952 []() { return compileOptions(theTranslator->trEventDocumentation()); })
953 } },
954
955 // concept layout handlers
956 { "concept", { startCb(&LayoutParser::startTop,LayoutDocManager::Concept,"concept/",LayoutNavEntry::Concepts),
957 endCb(&LayoutParser::endTop)
958 } },
959 { "concept/briefdescription", { startCb(&LayoutParser::startSimpleEntry, LayoutDocEntry::BriefDesc) } },
960 { "concept/definition", { startCb(&LayoutParser::startSectionEntry, LayoutDocEntry::ConceptDefinition,
961 []() { return compileOptions(theTranslator->trConceptDefinition()); }),
962 } },
963 { "concept/includes", { startCb(&LayoutParser::startSimpleEntry, LayoutDocEntry::ClassIncludes) } },
964 { "concept/sourcelink", { startCb(&LayoutParser::startSimpleEntry, LayoutDocEntry::FileSourceLink) } },
965 { "concept/detaileddescription", { startCb(&LayoutParser::startSectionEntry,LayoutDocEntry::DetailedDesc,
966 []() { return compileOptions(theTranslator->trDetailedDescription()); })
967 } },
968 { "concept/authorsection", { startCb(&LayoutParser::startSimpleEntry, LayoutDocEntry::AuthorSection) } },
969 // namespace layout handlers
970 { "namespace", { startCb(&LayoutParser::startTop,LayoutDocManager::Namespace,"namespace/",LayoutNavEntry::Namespaces),
971 endCb(&LayoutParser::endTop)
972 } },
973 { "namespace/briefdescription", { startCb(&LayoutParser::startSimpleEntry, LayoutDocEntry::BriefDesc) } },
974 { "namespace/detaileddescription", { startCb(&LayoutParser::startSectionEntry,LayoutDocEntry::DetailedDesc,
975 []() { return compileOptions(theTranslator->trDetailedDescription()); })
976 } },
977 { "namespace/authorsection", { startCb(&LayoutParser::startSimpleEntry, LayoutDocEntry::AuthorSection) } },
978 { "namespace/memberdecl", { startCb(&LayoutParser::startMemberDecl),
979 endCb(&LayoutParser::endMemberDecl)
980 } },
981 { "namespace/memberdecl/nestednamespaces", { startCb(&LayoutParser::startSectionEntry, LayoutDocEntry::NamespaceNestedNamespaces,
982 []() { return compileOptions(/* default */ theTranslator->trNamespaces(),
983 SrcLangExt::Java, theTranslator->trPackages(),
984 SrcLangExt::VHDL, theTranslator->trPackages(),
985 SrcLangExt::IDL, theTranslator->trModules(),
986 SrcLangExt::Fortran,theTranslator->trModules(),
987 SrcLangExt::Slice,(Config_getBool(OPTIMIZE_OUTPUT_SLICE) ?
988 theTranslator->trModules() :
989 theTranslator->trNamespaces())); })
990 } },
991 { "namespace/memberdecl/constantgroups", { startCb(&LayoutParser::startSectionEntry, LayoutDocEntry::NamespaceNestedConstantGroups,
992 []() { return compileOptions(theTranslator->trConstantGroups()); })
993 } },
994 { "namespace/memberdecl/interfaces", { startCb(&LayoutParser::startSectionEntry,LayoutDocEntry::NamespaceInterfaces,
995 []() { return compileOptions(theTranslator->trSliceInterfaces()); })
996 } },
997 { "namespace/memberdecl/classes", { startCb(&LayoutParser::startSectionEntry,LayoutDocEntry::NamespaceClasses,
998 []() { return compileOptions(/* default */ theTranslator->trCompounds(),
999 SrcLangExt::VHDL, theTranslator->trVhdlType(VhdlSpecifier::ENTITY,false),
1000 SrcLangExt::Fortran,theTranslator->trDataTypes()); })
1001 } },
1002 { "namespace/memberdecl/concepts", { startCb(&LayoutParser::startSectionEntry, LayoutDocEntry::NamespaceConcepts,
1003 []() { return compileOptions(theTranslator->trConcept(true,false)); })
1004 } },
1005 { "namespace/memberdecl/structs", { startCb(&LayoutParser::startSectionEntry,LayoutDocEntry::NamespaceStructs,
1006 []() { return compileOptions(theTranslator->trStructs()); })
1007 } },
1008 { "namespace/memberdecl/exceptions", { startCb(&LayoutParser::startSectionEntry,LayoutDocEntry::NamespaceExceptions,
1009 []() { return compileOptions(theTranslator->trExceptions()); })
1010 } },
1011 { "namespace/memberdecl/membergroups", { startCb(&LayoutParser::startSimpleEntry,LayoutDocEntry::MemberGroups) } },
1012 { "namespace/memberdecl/typedefs", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::DecTypedefMembers(),
1013 []() { return compileOptions(theTranslator->trTypedefs()); })
1014 } },
1015 { "namespace/memberdecl/sequences", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::DecSequenceMembers(),
1016 []() { return compileOptions(theTranslator->trSequences()); })
1017 } },
1018 { "namespace/memberdecl/dictionaries", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::DecDictionaryMembers(),
1019 []() { return compileOptions(theTranslator->trDictionaries()); })
1020 } },
1021 { "namespace/memberdecl/enums", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::DecEnumMembers(),
1022 []() { return compileOptions(theTranslator->trEnumerations()); })
1023 } },
1024 { "namespace/memberdecl/functions", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::DecFuncMembers(),
1025 []() { return compileOptions(/* default */ theTranslator->trFunctions(),
1026 SrcLangExt::Fortran,theTranslator->trSubprograms(),
1027 SrcLangExt::VHDL, theTranslator->trFunctionAndProc()); })
1028 } },
1029 { "namespace/memberdecl/variables", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::DecVarMembers(),
1030 []() { return compileOptions(Config_getBool(OPTIMIZE_OUTPUT_SLICE) ?
1031 theTranslator->trConstants() :
1032 theTranslator->trVariables()); })
1033 } },
1034 { "namespace/memberdecl/properties", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::Properties(),
1035 []() { return compileOptions(theTranslator->trProperties()); })
1036 } },
1037 { "namespace/memberdef", { startCb(&LayoutParser::startMemberDef), endCb(&LayoutParser::endMemberDef) } },
1038 { "namespace/memberdef/inlineclasses", { startCb(&LayoutParser::startSectionEntry, LayoutDocEntry::NamespaceInlineClasses,
1039 []() { return compileOptions(/* default */ theTranslator->trClassDocumentation(),
1040 SrcLangExt::Fortran,theTranslator->trTypeDocumentation()); })
1041 } },
1042 { "namespace/memberdef/typedefs", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::DocTypedefMembers(),
1043 []() { return compileOptions(theTranslator->trTypedefDocumentation()); })
1044 } },
1045 { "namespace/memberdef/sequences", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::DocSequenceMembers(),
1046 []() { return compileOptions(theTranslator->trSequenceDocumentation()); })
1047 } },
1048 { "namespace/memberdef/dictionaries", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::DocDictionaryMembers(),
1049 []() { return compileOptions(theTranslator->trDictionaryDocumentation()); })
1050 } },
1051 { "namespace/memberdef/enums", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::DocEnumMembers(),
1052 []() { return compileOptions(theTranslator->trEnumerationTypeDocumentation()); })
1053 } },
1054 { "namespace/memberdef/functions", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::DocFuncMembers(),
1055 []() { return compileOptions(/* default */ theTranslator->trFunctionDocumentation(),
1056 SrcLangExt::Fortran,theTranslator->trSubprogramDocumentation()); })
1057 } },
1058 { "namespace/memberdef/variables", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::DocVarMembers(),
1059 []() { return compileOptions(Config_getBool(OPTIMIZE_OUTPUT_SLICE) ?
1060 theTranslator->trConstantDocumentation() :
1061 theTranslator->trVariableDocumentation()); })
1062 } },
1063 { "namespace/memberdef/properties", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::PropertyMembers(),
1064 []() { return compileOptions(theTranslator->trPropertyDocumentation()); })
1065 } },
1066
1067 // file layout handlers
1068 { "file", { startCb(&LayoutParser::startTop,LayoutDocManager::File,"file/",LayoutNavEntry::Files),
1069 endCb(&LayoutParser::endTop)
1070 } },
1071 { "file/briefdescription", { startCb(&LayoutParser::startSimpleEntry, LayoutDocEntry::BriefDesc) } },
1072 { "file/detaileddescription", { startCb(&LayoutParser::startSectionEntry, LayoutDocEntry::DetailedDesc,
1073 []() { return compileOptions(theTranslator->trDetailedDescription()); })
1074 } },
1075 { "file/authorsection", { startCb(&LayoutParser::startSimpleEntry, LayoutDocEntry::AuthorSection) } },
1076 { "file/includes", { startCb(&LayoutParser::startSimpleEntry, LayoutDocEntry::FileIncludes) } },
1077 { "file/includegraph", { startCb(&LayoutParser::startSimpleEntry, LayoutDocEntry::FileIncludeGraph) } },
1078 { "file/includedbygraph", { startCb(&LayoutParser::startSimpleEntry, LayoutDocEntry::FileIncludedByGraph) } },
1079 { "file/sourcelink", { startCb(&LayoutParser::startSimpleEntry, LayoutDocEntry::FileSourceLink) } },
1080 { "file/memberdecl/membergroups", { startCb(&LayoutParser::startSimpleEntry, LayoutDocEntry::MemberGroups) } },
1081 { "file/memberdecl", { startCb(&LayoutParser::startMemberDecl), endCb(&LayoutParser::endMemberDecl) } },
1082 { "file/memberdecl/interfaces", { startCb(&LayoutParser::startSectionEntry,LayoutDocEntry::FileInterfaces,
1083 []() { return compileOptions(theTranslator->trSliceInterfaces()); })
1084 } },
1085 { "file/memberdecl/classes", { startCb(&LayoutParser::startSectionEntry,LayoutDocEntry::FileClasses,
1086 []() { return compileOptions(/* default */ theTranslator->trCompounds(),
1087 SrcLangExt::VHDL, theTranslator->trVhdlType(VhdlSpecifier::ENTITY,false),
1088 SrcLangExt::Fortran,theTranslator->trDataTypes()); })
1089 } },
1090 { "file/memberdecl/concepts", { startCb(&LayoutParser::startSectionEntry, LayoutDocEntry::FileConcepts,
1091 []() { return compileOptions(theTranslator->trConcept(true,false)); })
1092 } },
1093 { "file/memberdecl/structs", { startCb(&LayoutParser::startSectionEntry,LayoutDocEntry::FileStructs,
1094 []() { return compileOptions(theTranslator->trStructs()); })
1095 } },
1096 { "file/memberdecl/exceptions", { startCb(&LayoutParser::startSectionEntry,LayoutDocEntry::FileExceptions,
1097 []() { return compileOptions(theTranslator->trExceptions()); })
1098 } },
1099 { "file/memberdecl/namespaces", { startCb(&LayoutParser::startSectionEntry,LayoutDocEntry::FileNamespaces,
1100 []() { return compileOptions(/* default */ theTranslator->trNamespaces(),
1101 SrcLangExt::Java, theTranslator->trPackages(),
1102 SrcLangExt::IDL, theTranslator->trModules(),
1103 SrcLangExt::Fortran,theTranslator->trModules(),
1104 SrcLangExt::Slice, theTranslator->trModules()); })
1105 } },
1106 { "file/memberdecl/constantgroups", { startCb(&LayoutParser::startSectionEntry,LayoutDocEntry::FileConstantGroups,
1107 []() { return compileOptions(theTranslator->trConstantGroups()); })
1108 } },
1109 { "file/memberdecl/defines", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::DecDefineMembers(),
1110 []() { return compileOptions(theTranslator->trDefines()); })
1111 } },
1112 { "file/memberdecl/typedefs", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::DecTypedefMembers(),
1113 []() { return compileOptions(theTranslator->trTypedefs()); })
1114 } },
1115 { "file/memberdecl/sequences", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::DecSequenceMembers(),
1116 []() { return compileOptions(theTranslator->trSequences()); })
1117 } },
1118 { "file/memberdecl/dictionaries", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::DecDictionaryMembers(),
1119 []() { return compileOptions(theTranslator->trDictionaries()); })
1120 } },
1121 { "file/memberdecl/enums", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::DecEnumMembers(),
1122 []() { return compileOptions(theTranslator->trEnumerations()); })
1123 } },
1124 { "file/memberdecl/functions", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::DecFuncMembers(),
1125 []() { return compileOptions(/* default */ theTranslator->trFunctions(),
1126 SrcLangExt::Fortran,theTranslator->trSubprograms(),
1127 SrcLangExt::VHDL, theTranslator->trFunctionAndProc()); })
1128 } },
1129 { "file/memberdecl/variables", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::DecVarMembers(),
1130 []() { return compileOptions(Config_getBool(OPTIMIZE_OUTPUT_SLICE) ?
1131 theTranslator->trConstants() :
1132 theTranslator->trVariables()); })
1133 } },
1134 { "file/memberdecl/properties", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::Properties(),
1135 []() { return compileOptions(theTranslator->trProperties()); })
1136 } },
1137 { "file/memberdef", { startCb(&LayoutParser::startMemberDef), endCb(&LayoutParser::endMemberDef) } },
1138
1139 { "file/memberdef/inlineclasses", { startCb(&LayoutParser::startSectionEntry,LayoutDocEntry::FileInlineClasses,
1140 []() { return compileOptions(/* default */ theTranslator->trClassDocumentation(),
1141 SrcLangExt::Fortran, theTranslator->trTypeDocumentation()); })
1142 } },
1143 { "file/memberdef/defines", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::DocDefineMembers(),
1144 []() { return compileOptions(theTranslator->trDefineDocumentation()); })
1145 } },
1146 { "file/memberdef/typedefs", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::DocTypedefMembers(),
1147 []() { return compileOptions(theTranslator->trTypedefDocumentation()); })
1148 } },
1149 { "file/memberdef/sequences", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::DocSequenceMembers(),
1150 []() { return compileOptions(theTranslator->trSequenceDocumentation()); })
1151 } },
1152 { "file/memberdef/dictionaries", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::DocDictionaryMembers(),
1153 []() { return compileOptions(theTranslator->trDictionaryDocumentation()); })
1154 } },
1155 { "file/memberdef/enums", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::DocEnumMembers(),
1156 []() { return compileOptions(theTranslator->trEnumerationTypeDocumentation()); })
1157 } },
1158 { "file/memberdef/functions", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::DocFuncMembers(),
1159 []() { return compileOptions(/* default */ theTranslator->trFunctionDocumentation(),
1160 SrcLangExt::Fortran, theTranslator->trSubprogramDocumentation()); })
1161 } },
1162 { "file/memberdef/variables", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::DocVarMembers(),
1163 []() { return compileOptions(theTranslator->trVariableDocumentation()); })
1164 } },
1165
1166 { "file/memberdef/properties", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::PropertyMembers(),
1167 []() { return compileOptions(theTranslator->trPropertyDocumentation()); })
1168 } },
1169 // group layout handlers
1170 { "group", { startCb(&LayoutParser::startTop,LayoutDocManager::Group,"group/",LayoutNavEntry::None),
1171 endCb(&LayoutParser::endTop)
1172 } },
1173 { "group/briefdescription", { startCb(&LayoutParser::startSimpleEntry, LayoutDocEntry::BriefDesc) } },
1174 { "group/detaileddescription", { startCb(&LayoutParser::startSectionEntry, LayoutDocEntry::DetailedDesc,
1175 []() { return compileOptions(theTranslator->trDetailedDescription()); })
1176 } },
1177 { "group/authorsection", { startCb(&LayoutParser::startSimpleEntry, LayoutDocEntry::AuthorSection) } },
1178 { "group/groupgraph", { startCb(&LayoutParser::startSimpleEntry, LayoutDocEntry::GroupGraph) } },
1179 { "group/memberdecl", { startCb(&LayoutParser::startMemberDecl), endCb(&LayoutParser::endMemberDecl) } },
1180 { "group/memberdecl/membergroups", { startCb(&LayoutParser::startSimpleEntry, LayoutDocEntry::MemberGroups) } },
1181 { "group/memberdecl/classes", { startCb(&LayoutParser::startSectionEntry, LayoutDocEntry::GroupClasses,
1182 []() { return compileOptions(/* default */ theTranslator->trCompounds(),
1183 SrcLangExt::VHDL, theTranslator->trVhdlType(VhdlSpecifier::ENTITY,false),
1184 SrcLangExt::Fortran, theTranslator->trDataTypes()); })
1185 } },
1186 { "group/memberdecl/concepts", { startCb(&LayoutParser::startSectionEntry, LayoutDocEntry::GroupConcepts,
1187 []() { return compileOptions(theTranslator->trConcept(true,false)); })
1188 } },
1189 { "group/memberdecl/modules", { startCb(&LayoutParser::startSectionEntry, LayoutDocEntry::GroupModules,
1190 []() { return compileOptions(theTranslator->trModule(true,false)); })
1191 } },
1192 { "group/memberdecl/namespaces", { startCb(&LayoutParser::startSectionEntry, LayoutDocEntry::GroupNamespaces,
1193 []() { return compileOptions(/* default */ theTranslator->trNamespaces(),
1194 SrcLangExt::Java, theTranslator->trPackages(),
1195 SrcLangExt::Fortran, theTranslator->trModules()); })
1196 } },
1197 { "group/memberdecl/dirs", { startCb(&LayoutParser::startSectionEntry, LayoutDocEntry::GroupDirs,
1198 []() { return compileOptions(theTranslator->trDirectories()); })
1199 } },
1200 { "group/memberdecl/nestedgroups", { startCb(&LayoutParser::startSectionEntry, LayoutDocEntry::GroupNestedGroups,
1201 []() { return compileOptions(theTranslator->trTopics()); })
1202 } },
1203 { "group/memberdecl/files", { startCb(&LayoutParser::startSectionEntry, LayoutDocEntry::GroupFiles,
1204 []() { return compileOptions(theTranslator->trFile(true,false)); })
1205 } },
1206 { "group/memberdecl/defines", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::DecDefineMembers(),
1207 []() { return compileOptions(theTranslator->trDefines()); })
1208 } },
1209 { "group/memberdecl/typedefs", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::DecTypedefMembers(),
1210 []() { return compileOptions(theTranslator->trTypedefs()); })
1211 } },
1212 { "group/memberdecl/sequences", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::DecSequenceMembers(),
1213 []() { return compileOptions(theTranslator->trSequences()); })
1214 } },
1215 { "group/memberdecl/dictionaries", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::DecDictionaryMembers(),
1216 []() { return compileOptions(theTranslator->trDictionaries()); })
1217 } },
1218 { "group/memberdecl/enums", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::DecEnumMembers(),
1219 []() { return compileOptions(theTranslator->trEnumerations()); })
1220 } },
1221 { "group/memberdecl/enumvalues", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::DecEnumValMembers(),
1222 []() { return compileOptions(theTranslator->trEnumerationValues()); })
1223 } },
1224 { "group/memberdecl/functions", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::DecFuncMembers(),
1225 []() { return compileOptions(/* default */ theTranslator->trFunctions(),
1226 SrcLangExt::Fortran,theTranslator->trSubprograms(),
1227 SrcLangExt::VHDL, theTranslator->trFunctionAndProc()); })
1228 } },
1229 { "group/memberdecl/variables", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::DecVarMembers(),
1230 []() { return compileOptions(theTranslator->trVariables()); })
1231 } },
1232 { "group/memberdecl/signals", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::DecSignalMembers(),
1233 []() { return compileOptions(theTranslator->trSignals()); })
1234 } },
1235 { "group/memberdecl/publicslots", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::DecPubSlotMembers(),
1236 []() { return compileOptions(theTranslator->trPublicSlots()); })
1237 } },
1238 { "group/memberdecl/protectedslots", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::DecProSlotMembers(),
1239 []() { return compileOptions(theTranslator->trProtectedSlots()); })
1240 } },
1241 { "group/memberdecl/privateslots", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::DecPriSlotMembers(),
1242 []() { return compileOptions(theTranslator->trPrivateSlots()); })
1243 } },
1244 { "group/memberdecl/events", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::DecEventMembers(),
1245 []() { return compileOptions(theTranslator->trEvents()); })
1246 } },
1247 { "group/memberdecl/properties", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::DecPropMembers(),
1248 []() { return compileOptions(theTranslator->trProperties()); })
1249 } },
1250 { "group/memberdecl/friends", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::DecFriendMembers(),
1251 []() { return compileOptions(theTranslator->trFriends()); })
1252 } },
1253 { "group/memberdef", { startCb(&LayoutParser::startMemberDef), endCb(&LayoutParser::endMemberDef) } },
1254 { "group/memberdef/pagedocs", { startCb(&LayoutParser::startSimpleEntry, LayoutDocEntry::GroupPageDocs) } },
1255 { "group/memberdef/inlineclasses", { startCb(&LayoutParser::startSectionEntry, LayoutDocEntry::GroupInlineClasses,
1256 []() { return compileOptions(/* default */ theTranslator->trClassDocumentation(),
1257 SrcLangExt::Fortran,theTranslator->trTypeDocumentation()); })
1258 } },
1259 { "group/memberdef/defines", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::DocDefineMembers(),
1260 []() { return compileOptions(theTranslator->trDefineDocumentation()); })
1261 } },
1262 { "group/memberdef/typedefs", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::DocTypedefMembers(),
1263 []() { return compileOptions(theTranslator->trTypedefDocumentation()); })
1264 } },
1265 { "group/memberdef/sequences", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::DocSequenceMembers(),
1266 []() { return compileOptions(theTranslator->trSequenceDocumentation()); })
1267 } },
1268 { "group/memberdef/dictionaries", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::DocDictionaryMembers(),
1269 []() { return compileOptions(theTranslator->trDictionaryDocumentation()); })
1270 } },
1271 { "group/memberdef/enums", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::DocEnumMembers(),
1272 []() { return compileOptions(theTranslator->trEnumerationTypeDocumentation()); })
1273 } },
1274 { "group/memberdef/enumvalues", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::DocEnumValMembers(),
1275 []() { return compileOptions(theTranslator->trEnumerationValueDocumentation()); })
1276 } },
1277 { "group/memberdef/functions", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::DocFuncMembers(),
1278 []() { return compileOptions(/* default */ theTranslator->trFunctionDocumentation(),
1279 SrcLangExt::Fortran,theTranslator->trSubprogramDocumentation()); })
1280 } },
1281 { "group/memberdef/variables", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::DocVarMembers(),
1282 []() { return compileOptions(theTranslator->trVariableDocumentation()); })
1283 } },
1284 { "group/memberdef/signals", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::DocSignalMembers(),
1285 []() { return compileOptions(theTranslator->trSignals()); })
1286 } },
1287 { "group/memberdef/publicslots", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::DocPubSlotMembers(),
1288 []() { return compileOptions(theTranslator->trPublicSlots()); })
1289 } },
1290 { "group/memberdef/protectedslots", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::DocProSlotMembers(),
1291 []() { return compileOptions(theTranslator->trProtectedSlots()); })
1292 } },
1293 { "group/memberdef/privateslots", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::DocPriSlotMembers(),
1294 []() { return compileOptions(theTranslator->trPrivateSlots()); })
1295 } },
1296 { "group/memberdef/events", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::DocEventMembers(),
1297 []() { return compileOptions(theTranslator->trEvents()); })
1298 } },
1299 { "group/memberdef/properties", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::DocPropMembers(),
1300 []() { return compileOptions(theTranslator->trProperties()); })
1301 } },
1302 { "group/memberdef/friends", { startCb(&LayoutParser::startMemberDefEntry, MemberListType::DocFriendMembers(),
1303 []() { return compileOptions(theTranslator->trFriends()); })
1304 } },
1305
1306 // module layout handlers
1307 { "module", { startCb(&LayoutParser::startTop,LayoutDocManager::Module,"module/",LayoutNavEntry::Modules),
1308 endCb(&LayoutParser::endTop)
1309 } },
1310 { "module/briefdescription", { startCb(&LayoutParser::startSimpleEntry, LayoutDocEntry::BriefDesc) } },
1311 { "module/exportedmodules", { startCb(&LayoutParser::startSectionEntry, LayoutDocEntry::ModuleExports,
1312 []() { return compileOptions(theTranslator->trExportedModules()); })
1313 } },
1314 { "module/detaileddescription", { startCb(&LayoutParser::startSectionEntry, LayoutDocEntry::DetailedDesc,
1315 []() { return compileOptions(theTranslator->trDetailedDescription()); })
1316 } },
1317 { "module/authorsection", { startCb(&LayoutParser::startSimpleEntry, LayoutDocEntry::AuthorSection) } },
1318 { "module/memberdecl", { startCb(&LayoutParser::startMemberDecl), endCb(&LayoutParser::endMemberDecl) } },
1319 { "module/memberdecl/concepts", { startCb(&LayoutParser::startSectionEntry, LayoutDocEntry::ModuleConcepts,
1320 []() { return compileOptions(theTranslator->trConcept(true,false)); })
1321 } },
1322 { "module/memberdecl/classes", { startCb(&LayoutParser::startSectionEntry, LayoutDocEntry::ModuleClasses,
1323 []() { return compileOptions(theTranslator->trCompounds()); })
1324 } },
1325 { "module/memberdecl/enums", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::DecEnumMembers(),
1326 []() { return compileOptions(theTranslator->trEnumerations()); })
1327 } },
1328 { "module/memberdecl/typedefs", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::DecTypedefMembers(),
1329 []() { return compileOptions(theTranslator->trTypedefs()); })
1330 } },
1331 { "module/memberdecl/functions", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::DecFuncMembers(),
1332 []() { return compileOptions(theTranslator->trFunctions()); })
1333 } },
1334 { "module/memberdecl/variables", { startCb(&LayoutParser::startMemberDeclEntry, MemberListType::DecVarMembers(),
1335 []() { return compileOptions(theTranslator->trVariables()); })
1336 } },
1337 { "module/memberdecl/membergroups", { startCb(&LayoutParser::startSimpleEntry, LayoutDocEntry::MemberGroups) } },
1338 { "module/memberdecl/files", { startCb(&LayoutParser::startSectionEntry, LayoutDocEntry::ModuleUsedFiles,
1339 []() { return compileOptions(theTranslator->trFile(true,false)); })
1340 } },
1341
1342 // directory layout handlers
1343 { "directory", { startCb(&LayoutParser::startTop,LayoutDocManager::Directory,"directory/",LayoutNavEntry::None),
1344 endCb(&LayoutParser::endTop)
1345 } },
1346 { "directory/briefdescription", { startCb(&LayoutParser::startSimpleEntry, LayoutDocEntry::BriefDesc) } },
1347 { "directory/detaileddescription", { startCb(&LayoutParser::startSectionEntry, LayoutDocEntry::DetailedDesc,
1348 []() { return compileOptions(theTranslator->trDetailedDescription()); })
1349 } },
1350 { "directory/directorygraph", { startCb(&LayoutParser::startSimpleEntry, LayoutDocEntry::DirGraph) } },
1351 { "directory/memberdecl", { startCb(&LayoutParser::startMemberDecl), endCb(&LayoutParser::endMemberDecl) } },
1352 { "directory/memberdecl/dirs", { startCb(&LayoutParser::startSimpleEntry, LayoutDocEntry::DirSubDirs) } },
1353 { "directory/memberdecl/files", { startCb(&LayoutParser::startSimpleEntry, LayoutDocEntry::DirFiles) } },
1354};
1355// clang-format on
1356
1357} // namespace
1358
1359void LayoutParser::startElement( const std::string &name, const XMLHandlers::Attributes& attrib )
1360{
1361 //printf("startElement [%s]::[%s]\n",qPrint(m_scope),qPrint(name));
1362 auto it = g_elementHandlers.find(m_scope.str()+name);
1363 if (it!=g_elementHandlers.end())
1364 {
1365 it->second.startCb(*this,it->first,attrib);
1366 }
1367 else
1368 {
1369 DString fileName = m_locator->fileName();
1370 warn_layout(fileName,m_locator->lineNr(),"Unexpected start tag '{}' found in scope='{}'!",
1371 name,m_scope);
1372 }
1373}
1374
1375void LayoutParser::endElement( const std::string &name )
1376{
1377 //printf("endElement [%s]::[%s]\n",qPrint(m_scope),qPrint(name));
1378 auto it=g_elementHandlers.end();
1379
1380 if (!m_scope.empty() && m_scope.right(name.length()+1)==name+"/")
1381 { // element ends current scope
1382 it = g_elementHandlers.find(m_scope.left(m_scope.length()-1).str());
1383 }
1384 else // continue with current scope
1385 {
1386 it = g_elementHandlers.find(m_scope.str()+name);
1387 }
1388 if (it!=g_elementHandlers.end())
1389 {
1390 it->second.endCb(*this,it->first+" end"); // added end to id to make it unique
1391 }
1392}
1393
1394//---------------------------------------------------------------------------------
1395
1396int LayoutParser::m_userGroupCount=0;
1397
1398//---------------------------------------------------------------------------------
1399
1400class LayoutDocManager::Private
1401{
1402 public:
1403 std::array<LayoutDocEntryList,LayoutDocManager::NrParts> docEntries;
1404 LayoutNavEntry rootNav;
1405 int majorVersion;
1406 int minorVersion;
1407};
1408
1409LayoutDocManager::LayoutDocManager() : d(std::make_unique<Private>())
1410{
1411}
1412
1416
1417void LayoutDocManager::init()
1418{
1419 LayoutParser layoutParser(LayoutDocManager::instance());
1420 XMLHandlers handlers;
1421 handlers.startElement = [&layoutParser](const std::string &name,const XMLHandlers::Attributes &attrs) { layoutParser.startElement(name,attrs); };
1422 handlers.endElement = [&layoutParser](const std::string &name) { layoutParser.endElement(name); };
1423 handlers.error = [&layoutParser](const std::string &fileName,int lineNr,const std::string &msg) { layoutParser.error(fileName,lineNr,msg); };
1424 XMLParser parser(handlers);
1425 layoutParser.setDocumentLocator(&parser);
1426 constexpr auto layoutFile = "layout_default.xml";
1427 DString layout_default = ResourceMgr::instance().getAsString(layoutFile);
1428 parser.parse(layoutFile,layout_default.data(),Debug::isFlagSet(Debug::Lex_xml),
1429 [&]() { DebugLex::print(Debug::Lex_xml,"Entering","libxml/xml.l",layoutFile); },
1430 [&]() { DebugLex::print(Debug::Lex_xml,"Finished", "libxml/xml.l",layoutFile); }
1431 );
1432 removeInvisibleDocEntries();
1433 d->majorVersion = layoutParser.majorVersion();
1434 d->minorVersion = layoutParser.minorVersion();
1435}
1436
1437LayoutDocManager & LayoutDocManager::instance()
1438{
1439 static LayoutDocManager theInstance;
1440 return theInstance;
1441}
1442
1443const LayoutDocEntryList &LayoutDocManager::docEntries(LayoutDocManager::LayoutPart part) const
1444{
1445 return d->docEntries[static_cast<int>(part)];
1446}
1447
1448LayoutNavEntry* LayoutDocManager::rootNavEntry() const
1449{
1450 return &d->rootNav;
1451}
1452
1453LayoutNavEntry *LayoutDocManager::createChildNavEntry(LayoutNavEntry *parent,
1454 LayoutNavEntry::Kind k,bool vs,const DString &bf,
1455 const DString &tl,const DString &intro)
1456{
1457 if (parent==nullptr) parent = &d->rootNav;
1458 auto ptr = std::make_unique<LayoutNavEntry>(parent,k,vs,bf,tl,intro);
1459 auto child = ptr.get();
1460 parent->appendChild(std::move(ptr));
1461 return child;
1462}
1463
1464void LayoutDocManager::addEntry(LayoutDocManager::LayoutPart p,LayoutDocEntryPtr &&e)
1465{
1466 auto &docEntry = d->docEntries[static_cast<int>(p)];
1467 docEntry.push_back(std::move(e)); // add
1468}
1469
1470void LayoutDocManager::parse(const DString &fileName, const char *data)
1471{
1472 //printf("============ LayoutDocManager::parse(%s)\n",qPrint(fileName));
1473 LayoutDocManager layoutDocManager;
1474 LayoutParser layoutParser(layoutDocManager);
1475 XMLHandlers handlers;
1476 handlers.startElement = [&layoutParser](const std::string &name,const XMLHandlers::Attributes &attrs) { layoutParser.startElement(name,attrs); };
1477 handlers.endElement = [&layoutParser](const std::string &name) { layoutParser.endElement(name); };
1478 handlers.error = [&layoutParser](const std::string &fn,int lineNr,const std::string &msg) { layoutParser.error(fn,lineNr,msg); };
1479 XMLParser parser(handlers);
1480 layoutParser.setDocumentLocator(&parser);
1481 parser.parse(fileName.data(),
1482 data ? data : fileToString(fileName).data(),
1483 Debug::isFlagSet(Debug::Lex_xml),
1484 [&]() { DebugLex::print(Debug::Lex_xml,"Entering","libxml/xml.l",qPrint(fileName)); },
1485 [&]() { DebugLex::print(Debug::Lex_xml,"Finished", "libxml/xml.l",qPrint(fileName)); },
1486 transcodeCharacterStringToUTF8
1487 );
1488
1489 // version in the user defined layout overrides default one
1490 d->majorVersion = layoutParser.majorVersion();
1491 d->minorVersion = layoutParser.minorVersion();
1492
1493 // merge missing parts of the default layout into the user defined layout
1494 // For now merging in defaults has been disabled for navigation entries
1495 // to avoid "extra entries" for projects that work with partial layout files.
1496 //mergeNavEntries(layoutDocManager);
1497
1498 // for compatibility reasons we only merge defaults when the user defined layout has at least version 2.0 or higher
1499 if (d->majorVersion>=2)
1500 {
1501 mergeDocEntries(fileName,layoutDocManager);
1502 }
1503
1504 layoutDocManager.removeInvisibleDocEntries();
1505
1506 // replace default layout with merged layout
1507 d->docEntries.swap(layoutDocManager.d->docEntries);
1508 d->rootNav.swap(layoutDocManager.d->rootNav);
1509}
1510
1511void LayoutDocManager::removeInvisibleDocEntries()
1512{
1513 // remove invisible entries
1514 for (auto &list : d->docEntries)
1515 {
1516 auto it = list.begin();
1517 while (it!=list.end())
1518 {
1519 if (*it==nullptr || !(*it)->visible())
1520 {
1521 it = list.erase(it);
1522 }
1523 else
1524 {
1525 ++it;
1526 }
1527 }
1528 }
1529}
1530
1531int LayoutDocManager::majorVersion() const
1532{
1533 return d->majorVersion;
1534}
1535
1536int LayoutDocManager::minorVersion() const
1537{
1538 return d->minorVersion;
1539}
1540
1541// search for candidate node in tree with root target. Returns the match target node if found, or nullptr otherwise.
1542static LayoutNavEntry *findNavEntryRec(LayoutNavEntry *root, const std::string &id)
1543{
1544 if (root)
1545 {
1546 if (root->id()==id) return root;
1547 for (auto &child : root->children())
1548 {
1549 LayoutNavEntry *childNavEntry = findNavEntryRec(child.get(),id);
1550 if (childNavEntry) return childNavEntry;
1551 }
1552 }
1553 return nullptr;
1554}
1555
1556// merge the missing nodes
1557static void mergeNavTreeNodesRec(LayoutNavEntry *targetTree,LayoutNavEntry *sourceTree)
1558{
1559 using IdSet = std::unordered_set<std::string>;
1560 using IdMap = std::unordered_map<std::string,size_t>;
1561
1562 auto prepareSet = [](const LayoutNavEntry *tree, IdSet &set) {
1563 for (const auto &e : tree->children())
1564 {
1565 set.insert(e->id());
1566 }
1567 };
1568
1569 auto prepareMap = [](const LayoutNavEntry *tree, const IdSet &set, IdMap &map) {
1570 for (size_t i=0; i<tree->children().size(); i++)
1571 {
1572 std::string id = tree->children()[i]->id();
1573 auto it = set.find(id);
1574 if (it != set.end())
1575 {
1576 map[id]=i;
1577 }
1578 }
1579 };
1580
1581 IdSet sourceSet, targetSet;
1582 prepareSet(sourceTree,sourceSet);
1583 prepareSet(targetTree,targetSet);
1584
1585 IdMap sourceMap, targetMap;
1586 prepareMap(targetTree,sourceSet,targetMap);
1587 prepareMap(sourceTree,targetSet,sourceMap);
1588
1589 // calculate list of insertion positions in the target list for each id in the source list
1590 std::vector<size_t> insertionList;
1591 for (size_t i=0; i<sourceTree->children().size(); i++)
1592 {
1593 std::string id = sourceTree->children()[i]->id();
1594 // If an id in the source list appears before a set of shared ids we want it also to
1595 // appear before these id in the target list. To do this find the lowest target index of all shared
1596 // ids that come after position i in the source list
1597 size_t minIdx = targetTree->children().size();
1598 for (const auto &kv : sourceMap) // iterator over shared ids
1599 {
1600 if (i < kv.second) // i appears before this shared id
1601 {
1602 size_t idx = targetMap[kv.first]; // get the corresponding index in the target list
1603 if (idx<minIdx) // update minimum
1604 {
1605 minIdx=idx;
1606 }
1607 }
1608 }
1609 insertionList.push_back(minIdx);
1610 }
1611
1612 // Insert the missing elements of the source list into the target list.
1613 // Work backwards so the calculated insertion points don't change due to insertions.
1614 size_t idx = sourceTree->children().size()-1;
1615 for (auto it=insertionList.rbegin(); it!=insertionList.rend(); ++it, idx--)
1616 {
1617 std::string id = sourceTree->children()[idx]->id();
1618 if (targetSet.find(id)==targetSet.end()) // need to add id
1619 {
1620 // for efficiency we move the elements from the source list to the target list, thus modifying the source list!
1621 targetTree->insertChild(*it, std::move(sourceTree->children()[idx]));
1622 }
1623 }
1624
1625 for (auto &targetChild : targetTree->children())
1626 {
1627 auto *node = findNavEntryRec(sourceTree,targetChild->id());
1628 if (node)
1629 {
1630 mergeNavTreeNodesRec(targetChild.get(),node);
1631 }
1632 }
1633}
1634
1639
1640static void mergeDocEntryLists(const DString &fileName,LayoutDocEntryList &targetList,LayoutDocEntryList &sourceList)
1641{
1642 using IdSet = std::unordered_set<std::string>;
1643 using IdMap = std::unordered_map<std::string,size_t>;
1644
1645 auto prepareSet = [](const LayoutDocEntryList &list, IdSet &set) {
1646 //size_t idx=0;
1647 for (const auto &e : list)
1648 {
1649 //printf("idx=%zu set(%s)\n",idx,qPrint(e->id()));
1650 set.insert(e->id());
1651 //idx++;
1652 }
1653 };
1654
1655 auto prepareMap = [](const LayoutDocEntryList &list, const IdSet &set, IdMap &map) {
1656 for (size_t i=0; i<list.size(); i++)
1657 {
1658 std::string id = list[i]->id();
1659 auto it = set.find(id);
1660 if (it != set.end())
1661 {
1662 //printf("map %s->%zu\n",qPrint(id),i);
1663 map[id]=i;
1664 }
1665 }
1666 };
1667
1668 IdSet sourceSet, targetSet;
1669 //printf("---- sourceSet\n");
1670 prepareSet(sourceList,sourceSet);
1671 //printf("---- targetSet\n");
1672 prepareSet(targetList,targetSet);
1673
1674 IdMap sourceMap, targetMap;
1675 //printf("---- targetMap\n");
1676 prepareMap(targetList,sourceSet,targetMap);
1677 //printf("---- sourceMap\n");
1678 prepareMap(sourceList,targetSet,sourceMap);
1679
1680 // calculate list of insertion positions in the target list for each id in the source list
1681 std::vector<size_t> insertionList;
1682 for (size_t i=0; i<sourceList.size(); i++)
1683 {
1684 std::string id = sourceList[i]->id();
1685 // If an id in the source list appears before a set of shared ids we want it also to
1686 // appear before these id in the target list. To do this find the lowest target index of all shared
1687 // ids that come after position i in the source list
1688 size_t minIdx = targetList.size();
1689 for (const auto &kv : sourceMap) // iterator over shared ids
1690 {
1691 if (i < kv.second) // i appears before this shared id
1692 {
1693 size_t idx = targetMap[kv.first]; // get the corresponding index in the target list
1694 //printf(" evaluating %s->%zu min=%zu\n",qPrint(kv.first),idx,minIdx);
1695 if (idx<minIdx) // update minimum
1696 {
1697 minIdx=idx;
1698 }
1699 }
1700 }
1701 //printf("insertion %s->%zu\n",qPrint(id),minIdx);
1702 insertionList.push_back(minIdx);
1703 }
1704
1705 // Insert the missing elements of the source list into the target list.
1706 // Work backwards so the calculated insertion points don't change due to insertions.
1707 size_t idx = sourceList.size()-1;
1708 for (auto it=insertionList.rbegin(); it!=insertionList.rend(); ++it, idx--)
1709 {
1710 std::string id = sourceList[idx]->id();
1711 //printf("idx=%zu entry %s\n",idx,qPrint(id));
1712 if (targetSet.find(id)==targetSet.end()) // need to add id
1713 {
1714 // for efficiency we move the elements from the source list to the target list, thus modifying the source list!
1715 //printf("--> insert at %zu before %s\n",*it,qPrint(*it<targetList.size()?targetList[*it]->id():"none"));
1716 warn_layout(fileName,1,"User defined layout misses entry '{}'. Using default value.",id);
1717 targetList.insert(targetList.begin()+*it, std::move(sourceList[idx]));
1718 }
1719 }
1720
1721}
1722
1723void LayoutDocManager::mergeDocEntries(const DString &fileName,LayoutDocManager &other)
1724{
1725 for (size_t i=0; i<d->docEntries.size(); i++)
1726 {
1727 //printf("========= part %zu\n",i);
1728 mergeDocEntryLists(fileName,other.d->docEntries[i],d->docEntries[i]);
1729 }
1730}
1731
1732//---------------------------------------------------------------------------------
1733
1734void writeDefaultLayoutFile(const DString &fileName)
1735{
1736 std::ofstream f;
1737 if (openOutputFile(fileName,f))
1738 {
1739 TextStream t(&f);
1740 DString layout_default = ResourceMgr::instance().getAsString("layout_default.xml");
1741 t << substitute(layout_default,"$doxygenversion",getDoxygenVersion());
1742 }
1743 else
1744 {
1745 err("Failed to open file {} for writing!\n",fileName);
1746 return;
1747 }
1748 f.close();
1749}
1750
1751//----------------------------------------------------------------------------------
1752
1753// Convert input to a title.
1754// The format of input can be a simple title "A title" or in case there are different
1755// titles for some programming languages they can take the following form:
1756// "A title|16=Another title|8=Yet Another title"
1757// where the number is a value of SrcLangExt in decimal notation (i.e. 16=Java, 8=IDL).
1758DString extractLanguageSpecificTitle(const DString &input,SrcLangExt lang)
1759{
1760 size_t s=0,e=input.find('|');
1761 if (e==DString::npos) return input; // simple title case
1762 size_t e1=e;
1763 while (e!=DString::npos) // look for 'number=title' pattern separated by '|'
1764 {
1765 s=e+1;
1766 e=input.find('|',s);
1767 size_t i=input.find('=',s);
1768 ASSERT(i!=DString::npos && i>s);
1769 SrcLangExt key= static_cast<SrcLangExt>(input.mid(s,i-s).toUInt());
1770 if (key==lang) // found matching key
1771 {
1772 if (e==DString::npos) e=input.length();
1773 return input.mid(i+1,e-i-1);
1774 }
1775 }
1776 return input.left(e1); // fallback, no explicit language key found
1777}
1778
1779//----------------------------------------------------------------------------------
1780
1785
1786//----------------------------------------------------------------------------------
1787
1792
1797
1798//----------------------------------------------------------------------------------
1799
1804
1805//----------------------------------------------------------------------------------
1806
1807static void printNavLayout(LayoutNavEntry *root,int indent)
1808{
1809 if (Debug::isFlagSet(Debug::Layout))
1810 {
1811 DString indentStr;
1812 indentStr.fill(' ',indent);
1813 Debug::print(Debug::Layout,0,"{}kind={} visible={} title='{}'\n",
1814 indentStr, root->navToString(), root->visible(), root->title());
1815 for (const auto &e : root->children())
1816 {
1817 printNavLayout(e.get(),indent+2);
1818 }
1819 }
1820}
1821
1822void printLayout()
1823{
1824 bool extraIndent = false;
1825
1826 auto &mgr = LayoutDocManager::instance();
1827 Debug::print(Debug::Layout,0,"Layout version {}.{}\n",mgr.majorVersion(),mgr.minorVersion());
1828
1829 Debug::print(Debug::Layout,0,"Part: Navigation index\n");
1830 for (const auto &e : mgr.rootNavEntry()->children())
1831 {
1832 printNavLayout(e.get(),2);
1833 }
1834
1835 for (int i = 0; i < LayoutDocManager::NrParts; i++)
1836 {
1837 Debug::print(Debug::Layout,0,"\nPart: {}\n", LayoutDocManager::partToString(i));
1838 for (const auto &lde : mgr.docEntries(static_cast<LayoutDocManager::LayoutPart>(i)))
1839 {
1840 if (const LayoutDocEntrySimple *ldes = dynamic_cast<const LayoutDocEntrySimple*>(lde.get()))
1841 {
1842 if (lde->kind() == LayoutDocEntry::MemberDeclEnd || lde->kind() == LayoutDocEntry::MemberDefEnd) extraIndent = false;
1843 Debug::print(Debug::Layout,0," {}kind: {}, visible={}\n",
1844 extraIndent? " " : "",lde->entryToString(), ldes->visible());
1845 if (lde->kind() == LayoutDocEntry::MemberDeclStart || lde->kind() == LayoutDocEntry::MemberDefStart) extraIndent = true;
1846 }
1847 else if (const LayoutDocEntryMemberDecl *lmdecl = dynamic_cast<const LayoutDocEntryMemberDecl*>(lde.get()))
1848 {
1849 Debug::print(Debug::Layout,0," {}complex kind: {}, visible={}, type: {}\n",
1850 extraIndent? " " : "",lde->entryToString(),lmdecl->visible(),lmdecl->type.to_string());
1851 }
1852 else if (const LayoutDocEntryMemberDef *lmdef = dynamic_cast<const LayoutDocEntryMemberDef*>(lde.get()))
1853 {
1854 Debug::print(Debug::Layout,0," {}complex kind: {}, visible={}, type: {}\n",
1855 extraIndent? " " : "",lde->entryToString(),lmdef->visible(),lmdef->type.to_string());
1856 }
1857 else
1858 {
1859 // should not happen
1860 Debug::print(Debug::Layout,0," {}not handled kind: {}\n",extraIndent? " " : "",lde->entryToString());
1861 }
1862 }
1863 }
1864}
1865
1866
1867
DString
A String class for use with Doxygen wrapping std::string and adding some additional functionality off...
Definition dstring.h:84
DString::setNum
DString & setNum(short n)
Definition dstring.h:552
DString::rfind
size_t rfind(char c, size_t pos=npos) const
Definition dstring.h:244
DString::fill
DString fill(char c, size_t len)
Fills a string with a predefined character.
Definition dstring.h:278
DString::mid
DString mid(size_t index, size_t len=npos) const
Definition dstring.h:318
DString::lower
DString lower() const
Definition dstring.h:326
DString::empty
bool empty() const
Returns true iff the string is empty (std::string compatible alias for isEmpty()).
Definition dstring.h:148
DString::view
std::string_view view() const
Definition dstring.h:162
DString::npos
static constexpr size_t npos
value used to indicate 'not found' or 'to the end of the string', matching std::string::npos
Definition dstring.h:178
DString::at
char & at(size_t i)
Returns a reference to the character at index i.
Definition dstring.h:686
DString::right
DString right(size_t len) const
Definition dstring.h:311
DString::find
size_t find(char c, size_t pos=0) const
Definition dstring.h:239
DString::sprintf
DString & sprintf(const char *format,...)
Definition dstring.cpp:34
DString::stripWhiteSpace
DString stripWhiteSpace() const
returns a copy of this string with leading and trailing whitespace removed
Definition dstring.h:337
DString::left
DString left(size_t len) const
Definition dstring.h:306
DString::str
const std::string & str() const
Definition dstring.h:645
DString::data
const char * data() const
Returns a pointer to the contents of the string in the form of a 0-terminated C string.
Definition dstring.h:157
DString::startsWith
bool startsWith(const char *s) const
Definition dstring.h:600
DString::length
size_t length() const
Returns the length of the string, not counting the 0-terminator.
Definition dstring.h:151
Debug::Layout
@ Layout
Definition debug.h:51
Debug::Lex_xml
@ Lex_xml
Definition debug.h:72
Debug::isFlagSet
static bool isFlagSet(const DebugMask mask)
Definition debug.cpp:132
Debug::print
static void print(DebugMask mask, int prio, fmt::format_string< Args... > fmt, Args &&... args)
Definition debug.h:78
DebugLex::print
static void print(Debug::DebugMask mask, const char *state, const char *lexName, const char *fileName)
Definition debug.cpp:156
DocNodeAST
Class representing the abstract syntax tree of a documentation block.
Definition docnode.h:1471
DocRef
Node representing a reference to some item.
Definition docnode.h:787
DocRef::ref
DString ref() const
Definition docnode.h:793
DocRef::file
DString file() const
Definition docnode.h:791
DocRef::anchor
DString anchor() const
Definition docnode.h:794
LayoutDocManager::Private::docEntries
std::array< LayoutDocEntryList, LayoutDocManager::NrParts > docEntries
Definition layout.cpp:1403
LayoutDocManager::Private::rootNav
LayoutNavEntry rootNav
Definition layout.cpp:1404
LayoutDocManager
Singleton providing access to the (user configurable) layout of the documentation.
Definition layout.h:260
LayoutDocManager::mergeNavEntries
void mergeNavEntries(LayoutDocManager &manager)
Definition layout.cpp:1635
LayoutDocManager::partToString
static std::string partToString(int k)
Definition layout.h:271
LayoutDocManager::parse
void parse(const DString &fileName, const char *data=nullptr)
Parses a user provided layout.
Definition layout.cpp:1470
LayoutDocManager::d
std::unique_ptr< Private > d
Definition layout.h:303
LayoutDocManager::createChildNavEntry
LayoutNavEntry * createChildNavEntry(LayoutNavEntry *root, LayoutNavEntry::Kind k, bool vs, const DString &bf, const DString &tl, const DString &intro)
append a new node as a child to root.
Definition layout.cpp:1453
LayoutDocManager::instance
static LayoutDocManager & instance()
Returns a reference to this singleton.
Definition layout.cpp:1437
LayoutDocManager::majorVersion
int majorVersion() const
Definition layout.cpp:1531
LayoutDocManager::minorVersion
int minorVersion() const
Definition layout.cpp:1536
LayoutDocManager::LayoutParser
friend class LayoutParser
Definition layout.h:304
LayoutDocManager::mergeDocEntries
void mergeDocEntries(const DString &fileName, LayoutDocManager &manager)
Definition layout.cpp:1723
LayoutDocManager::addEntry
void addEntry(LayoutPart p, LayoutDocEntryPtr &&e)
Definition layout.cpp:1464
LayoutDocManager::rootNavEntry
LayoutNavEntry * rootNavEntry() const
returns the (invisible) root of the navigation tree.
Definition layout.cpp:1448
LayoutDocManager::removeInvisibleDocEntries
void removeInvisibleDocEntries()
Definition layout.cpp:1511
LayoutDocManager::docEntries
const LayoutDocEntryList & docEntries(LayoutPart part) const
Returns the list of LayoutDocEntry's in representation order for a given page identified by part.
Definition layout.cpp:1443
LayoutParser::endTop
void endTop(const std::string &)
Definition layout.cpp:634
LayoutParser::endNavIndex
void endNavIndex(const std::string &)
Definition layout.cpp:288
LayoutParser::setDocumentLocator
void setDocumentLocator(const XMLLocator *locator)
Definition layout.cpp:202
LayoutParser::m_userGroupCount
static int m_userGroupCount
Definition layout.cpp:713
LayoutParser::startMemberDefEntry
void startMemberDefEntry(const std::string &id, const XMLHandlers::Attributes &attrib, MemberListType type, const DString &title, const DString &)
Definition layout.cpp:255
LayoutParser::startSimpleEntry
void startSimpleEntry(LayoutDocEntry::Kind k, const std::string &id, const XMLHandlers::Attributes &attrib)
Definition layout.cpp:213
LayoutParser::startNavIndex
void startNavIndex(const std::string &, const XMLHandlers::Attributes &)
Definition layout.cpp:282
LayoutParser::LayoutParser
LayoutParser(LayoutDocManager &manager)
Definition layout.cpp:199
LayoutParser::startTop
void startTop(const std::string &, const XMLHandlers::Attributes &attrib, LayoutDocManager::LayoutPart part, const DString &scope, LayoutNavEntry::Kind nav)
Definition layout.cpp:625
LayoutParser::error
void error(const std::string &fileName, int lineNr, const std::string &msg)
Definition layout.cpp:206
LayoutParser::m_locator
const XMLLocator * m_locator
Definition layout.cpp:714
LayoutParser::m_minorVersion
int m_minorVersion
Definition layout.cpp:716
LayoutParser::majorVersion
int majorVersion() const
Definition layout.cpp:703
LayoutParser::startMemberDecl
void startMemberDecl(const std::string &id, const XMLHandlers::Attributes &attrib)
Definition layout.cpp:672
LayoutParser::endMemberDecl
void endMemberDecl(const std::string &id)
Definition layout.cpp:682
LayoutParser::endMemberDef
void endMemberDef(const std::string &id)
Definition layout.cpp:650
LayoutParser::minorVersion
int minorVersion() const
Definition layout.cpp:704
LayoutParser::m_invalidEntry
bool m_invalidEntry
Definition layout.cpp:711
LayoutParser::endNavEntry
void endNavEntry(const std::string &)
Definition layout.cpp:618
LayoutParser::startSectionEntry
void startSectionEntry(LayoutDocEntry::Kind k, const std::string &id, const XMLHandlers::Attributes &attrib, const DString &title)
Definition layout.cpp:226
LayoutParser::m_layoutDocManager
LayoutDocManager & m_layoutDocManager
Definition layout.cpp:708
LayoutParser::startMemberDeclEntry
void startMemberDeclEntry(const std::string &id, const XMLHandlers::Attributes &attrib, MemberListType type, const DString &title, const DString &subscript)
Definition layout.cpp:241
LayoutParser::startNavEntry
void startNavEntry(const std::string &, const XMLHandlers::Attributes &attrib)
Definition layout.cpp:299
LayoutParser::startMemberDef
void startMemberDef(const std::string &id, const XMLHandlers::Attributes &attrib)
Definition layout.cpp:640
LayoutParser::m_visible
bool m_visible
Definition layout.cpp:712
LayoutParser::endElement
void endElement(const std::string &name)
Definition layout.cpp:1375
LayoutParser::m_scope
DString m_scope
Definition layout.cpp:707
LayoutParser::m_rootNav
LayoutNavEntry * m_rootNav
Definition layout.cpp:710
LayoutParser::startLayout
void startLayout(const std::string &, const XMLHandlers::Attributes &attrib)
Definition layout.cpp:268
LayoutParser::startElement
void startElement(const std::string &name, const XMLHandlers::Attributes &attrib)
Definition layout.cpp:1359
LayoutParser::m_part
LayoutDocManager::LayoutPart m_part
Definition layout.cpp:709
LayoutParser::m_majorVersion
int m_majorVersion
Definition layout.cpp:715
MemberListType
Wrapper class for the MemberListType type.
Definition types.h:346
ResourceMgr::instance
static ResourceMgr & instance()
Returns the one and only instance of this class.
Definition resourcemgr.cpp:36
ResourceMgr::getAsString
DString getAsString(const DString &name) const
Gets the resource data as a C string.
Definition resourcemgr.cpp:137
TextStream
Text streaming class that buffers data.
Definition textstream.h:36
Translator::trCompoundMembers
virtual DString trCompoundMembers()=0
Translator::trFunctionAndProc
virtual DString trFunctionAndProc()=0
Translator::trStaticProtectedAttribs
virtual DString trStaticProtectedAttribs()=0
Translator::trProtectedTypes
virtual DString trProtectedTypes()=0
Translator::trTypedefs
virtual DString trTypedefs()=0
Translator::trConceptList
virtual DString trConceptList()=0
Translator::trTopics
virtual DString trTopics()=0
Translator::trModulesMembers
virtual DString trModulesMembers()=0
Translator::trCompoundMembersFortran
virtual DString trCompoundMembersFortran()=0
Translator::trStaticProtectedMembers
virtual DString trStaticProtectedMembers()=0
Translator::trPublicAttribs
virtual DString trPublicAttribs()=0
Translator::trExceptions
virtual DString trExceptions()=0
Translator::trModulesList
virtual DString trModulesList()=0
Translator::trEnumerations
virtual DString trEnumerations()=0
Translator::trRelatedSymbolDocumentation
virtual DString trRelatedSymbolDocumentation()=0
Translator::trClasses
virtual DString trClasses()=0
Translator::trDetailedDescription
virtual DString trDetailedDescription()=0
Translator::trDataMemberDocumentation
virtual DString trDataMemberDocumentation()=0
Translator::trInterfaceIndex
virtual DString trInterfaceIndex()=0
Translator::trNamespaceMembers
virtual DString trNamespaceMembers()=0
Translator::trVariableDocumentation
virtual DString trVariableDocumentation()=0
Translator::trNamespaceMemberDescription
virtual DString trNamespaceMemberDescription(bool extractAll)=0
Translator::trFileMembersDescription
virtual DString trFileMembersDescription(bool extractAll)=0
Translator::trPackageMembers
virtual DString trPackageMembers()=0
Translator::trNamespaceList
virtual DString trNamespaceList()=0
Translator::trPrivateAttribs
virtual DString trPrivateAttribs()=0
Translator::trExceptionList
virtual DString trExceptionList()=0
Translator::trSequenceDocumentation
virtual DString trSequenceDocumentation()=0
Translator::trTypedefDocumentation
virtual DString trTypedefDocumentation()=0
Translator::trPrivateSlots
virtual DString trPrivateSlots()=0
Translator::trStructs
virtual DString trStructs()=0
Translator::trPrivateTypes
virtual DString trPrivateTypes()=0
Translator::trClassDocumentation
virtual DString trClassDocumentation()=0
Translator::trExceptionHierarchyDescription
virtual DString trExceptionHierarchyDescription()=0
Translator::trOperationDocumentation
virtual DString trOperationDocumentation()=0
Translator::trInterfaceList
virtual DString trInterfaceList()=0
Translator::trSequences
virtual DString trSequences()=0
Translator::trClassMethods
virtual DString trClassMethods()=0
Translator::trFunctions
virtual DString trFunctions()=0
Translator::trMemberEnumerationDocumentation
virtual DString trMemberEnumerationDocumentation()=0
Translator::trProtectedSlots
virtual DString trProtectedSlots()=0
Translator::trInterfaceListDescription
virtual DString trInterfaceListDescription()=0
Translator::trFriends
virtual DString trFriends()=0
Translator::trPropertyDocumentation
virtual DString trPropertyDocumentation()=0
Translator::trInstanceMethods
virtual DString trInstanceMethods()=0
Translator::trExceptionHierarchy
virtual DString trExceptionHierarchy()=0
Translator::trCompoundList
virtual DString trCompoundList()=0
Translator::trPackageAttribs
virtual DString trPackageAttribs()=0
Translator::trEnumerationTypeDocumentation
virtual DString trEnumerationTypeDocumentation()=0
Translator::trInterfaceHierarchy
virtual DString trInterfaceHierarchy()=0
Translator::trTypeDocumentation
virtual DString trTypeDocumentation()=0
Translator::trPackageList
virtual DString trPackageList()=0
Translator::trMemberTypedefDocumentation
virtual DString trMemberTypedefDocumentation()=0
Translator::trEnumerationValueDocumentation
virtual DString trEnumerationValueDocumentation()=0
Translator::trModulesDescription
virtual DString trModulesDescription()=0
Translator::trStaticPackageAttribs
virtual DString trStaticPackageAttribs()=0
Translator::trStructListDescription
virtual DString trStructListDescription()=0
Translator::trOperations
virtual DString trOperations()=0
Translator::trConceptDefinition
virtual DString trConceptDefinition()=0
Translator::trDefineDocumentation
virtual DString trDefineDocumentation()=0
Translator::trDesignUnitListDescription
virtual DString trDesignUnitListDescription()=0
Translator::trExamplesDescription
virtual DString trExamplesDescription()=0
Translator::trCompounds
virtual DString trCompounds()=0
Translator::trFileList
virtual DString trFileList()=0
Translator::trModules
virtual DString trModules()=0
Translator::trDefines
virtual DString trDefines()=0
Translator::trRelatedPages
virtual DString trRelatedPages()=0
Translator::trPublicMembers
virtual DString trPublicMembers()=0
Translator::trSubprogramDocumentation
virtual DString trSubprogramDocumentation()=0
Translator::trCompoundListDescriptionFortran
virtual DString trCompoundListDescriptionFortran()=0
Translator::trVhdlType
virtual DString trVhdlType(VhdlSpecifier type, bool single)=0
Translator::trInterfaces
virtual DString trInterfaces()=0
Translator::trRelatedSymbols
virtual DString trRelatedSymbols()=0
Translator::trFileMembers
virtual DString trFileMembers()=0
Translator::trDesignUnitHierarchy
virtual DString trDesignUnitHierarchy()=0
Translator::trDesignUnits
virtual DString trDesignUnits()=0
Translator::trProtectedMembers
virtual DString trProtectedMembers()=0
Translator::trDirectories
virtual DString trDirectories()=0
Translator::trInterfaceHierarchyDescription
virtual DString trInterfaceHierarchyDescription()=0
Translator::trStaticPrivateAttribs
virtual DString trStaticPrivateAttribs()=0
Translator::trStructIndex
virtual DString trStructIndex()=0
Translator::trExceptionIndex
virtual DString trExceptionIndex()=0
Translator::trConstructorDocumentation
virtual DString trConstructorDocumentation()=0
Translator::trPackageTypes
virtual DString trPackageTypes()=0
Translator::trExportedModules
virtual DString trExportedModules()=0
Translator::trModule
virtual DString trModule(bool first_capital, bool singular)=0
Translator::trDictionaryDocumentation
virtual DString trDictionaryDocumentation()=0
Translator::trProtectedAttribs
virtual DString trProtectedAttribs()=0
Translator::trDesignUnitMembers
virtual DString trDesignUnitMembers()=0
Translator::trConstantGroups
virtual DString trConstantGroups()=0
Translator::trExceptionListDescription
virtual DString trExceptionListDescription()=0
Translator::trProperties
virtual DString trProperties()=0
Translator::trRelatedPagesDescription
virtual DString trRelatedPagesDescription()=0
Translator::trDesignUnitList
virtual DString trDesignUnitList()=0
Translator::trModulesMemberDescription
virtual DString trModulesMemberDescription(bool extractAll)=0
Translator::trCompoundIndexFortran
virtual DString trCompoundIndexFortran()=0
Translator::trDataTypes
virtual DString trDataTypes()=0
Translator::trCompoundListDescription
virtual DString trCompoundListDescription()=0
Translator::trConcept
virtual DString trConcept(bool first_capital, bool singular)=0
Translator::trTopicListDescription
virtual DString trTopicListDescription()=0
Translator::trDataMembers
virtual DString trDataMembers()=0
Translator::trFileListDescription
virtual DString trFileListDescription(bool extractAll)=0
Translator::trClassHierarchyDescription
virtual DString trClassHierarchyDescription()=0
Translator::trSliceInterfaces
virtual DString trSliceInterfaces()=0
Translator::trConceptListDescription
virtual DString trConceptListDescription(bool extractAll)=0
Translator::trFunctionDocumentation
virtual DString trFunctionDocumentation()=0
Translator::trSubprograms
virtual DString trSubprograms()=0
Translator::trMemberFunctionDocumentationFortran
virtual DString trMemberFunctionDocumentationFortran()=0
Translator::trMemberFunctionDocumentation
virtual DString trMemberFunctionDocumentation()=0
Translator::trCompoundListFortran
virtual DString trCompoundListFortran()=0
Translator::trPackageFunctions
virtual DString trPackageFunctions()=0
Translator::trPackages
virtual DString trPackages()=0
Translator::trPrivateMembers
virtual DString trPrivateMembers()=0
Translator::trPackageListDescription
virtual DString trPackageListDescription()=0
Translator::trConstantDocumentation
virtual DString trConstantDocumentation()=0
Translator::trPublicTypes
virtual DString trPublicTypes()=0
Translator::trVariables
virtual DString trVariables()=0
Translator::trStaticPublicMembers
virtual DString trStaticPublicMembers()=0
Translator::trMethodDocumentation
virtual DString trMethodDocumentation()=0
Translator::trEnumerationValues
virtual DString trEnumerationValues()=0
Translator::trRelatedSymbolsSubscript
virtual DString trRelatedSymbolsSubscript()=0
Translator::trStaticPublicAttribs
virtual DString trStaticPublicAttribs()=0
Translator::trModulesListDescription
virtual DString trModulesListDescription(bool extractAll)=0
Translator::trServices
virtual DString trServices()=0
Translator::trStructList
virtual DString trStructList()=0
Translator::trNamespaceListDescription
virtual DString trNamespaceListDescription(bool extractAll)=0
Translator::trSignals
virtual DString trSignals()=0
Translator::trClassHierarchy
virtual DString trClassHierarchy()=0
Translator::trPublicSlots
virtual DString trPublicSlots()=0
Translator::trCompoundIndex
virtual DString trCompoundIndex()=0
Translator::trFile
virtual DString trFile(bool first_capital, bool singular)=0
Translator::trDesignUnitIndex
virtual DString trDesignUnitIndex()=0
Translator::trConstants
virtual DString trConstants()=0
Translator::trCompoundMembersDescription
virtual DString trCompoundMembersDescription(bool extractAll)=0
Translator::trEventDocumentation
virtual DString trEventDocumentation()=0
Translator::trMainPage
virtual DString trMainPage()=0
Translator::trNamespaces
virtual DString trNamespaces()=0
Translator::trCompoundMembersDescriptionFortran
virtual DString trCompoundMembersDescriptionFortran(bool extractAll)=0
Translator::trMemberDataDocumentation
virtual DString trMemberDataDocumentation()=0
Translator::trEvents
virtual DString trEvents()=0
Translator::trDictionaries
virtual DString trDictionaries()=0
Translator::trStaticPackageFunctions
virtual DString trStaticPackageFunctions()=0
Translator::trExamples
virtual DString trExamples()=0
Translator::trStaticPrivateMembers
virtual DString trStaticPrivateMembers()=0
XMLHandlers
Event handlers that can installed by the client and called while parsing a XML document.
Definition xml.h:27
XMLHandlers::Attributes
std::unordered_map< std::string, std::string > Attributes
Definition xml.h:29
XMLHandlers::endElement
std::function< EndElementType > endElement
handler invoked when a closing tag has been found
Definition xml.h:40
XMLHandlers::startElement
std::function< StartElementType > startElement
handler invoked when an opening tag has been found
Definition xml.h:39
XMLHandlers::value
static std::string value(const Attributes &attrib, const std::string &key)
Definition xml.h:44
XMLHandlers::error
std::function< ErrorType > error
handler invoked when the parser encounters an error
Definition xml.h:42
XMLLocator::lineNr
virtual int lineNr() const =0
XMLLocator::fileName
virtual std::string fileName() const =0
XMLParser::parse
void parse(const char *fileName, const char *inputString, bool debugEnabled, std::function< void()> debugStart, std::function< void()> debugEnd, std::function< Transcode > transcoder=[](std::string &s, const char *){ return true;})
Definition xml.l:447
reg::Ex
Class representing a regular expression.
Definition regex.h:39
reg::Match
Object representing the matching results.
Definition regex.h:154
Config_getBool
#define Config_getBool(name)
Definition config.h:33
Config_getString
#define Config_getString(name)
Definition config.h:32
parent
constexpr DocNodeVariant * parent(DocNodeVariant *n)
returns the parent node of a given node n or nullptr if the node has no parent.
Definition docnode.h:1335
createDocParser
IDocParserPtr createDocParser()
factory function to create a parser
Definition docparser.cpp:59
createRef
IDocNodeASTPtr createRef(IDocParser &parserIntf, const DString &target, const DString &context, const DString &srcFile, int srcLine)
Definition docparser.cpp:2452
substitute
DString substitute(const DString &s, const DString &src, const DString &dst)
substitute all occurrences of src in s by dst
Definition dstring.cpp:485
qPrint
const char * qPrint(const char *s)
Definition dstring.h:783
theTranslator
Translator * theTranslator
Definition language.cpp:76
mergeNavTreeNodesRec
static void mergeNavTreeNodesRec(LayoutNavEntry *targetTree, LayoutNavEntry *sourceTree)
Definition layout.cpp:1557
mergeDocEntryLists
static void mergeDocEntryLists(const DString &fileName, LayoutDocEntryList &targetList, LayoutDocEntryList &sourceList)
Definition layout.cpp:1640
elemIsVisible
static bool elemIsVisible(const XMLHandlers::Attributes &attrib, bool defVal=true)
Definition layout.cpp:81
extractLanguageSpecificTitle
DString extractLanguageSpecificTitle(const DString &input, SrcLangExt lang)
Definition layout.cpp:1758
findNavEntryRec
static LayoutNavEntry * findNavEntryRec(LayoutNavEntry *root, const std::string &id)
Definition layout.cpp:1542
compileOptions
DString compileOptions(const DString &def)
Definition layout.cpp:37
writeDefaultLayoutFile
void writeDefaultLayoutFile(const DString &fileName)
Definition layout.cpp:1734
printLayout
void printLayout()
Definition layout.cpp:1822
printNavLayout
static void printNavLayout(LayoutNavEntry *root, int indent)
Definition layout.cpp:1807
LayoutDocEntryPtr
std::unique_ptr< LayoutDocEntry > LayoutDocEntryPtr
Definition layout.h:146
LayoutDocEntryList
std::vector< LayoutDocEntryPtr > LayoutDocEntryList
Definition layout.h:147
msg
#define msg(fmt,...)
Definition message.h:94
err
#define err(fmt,...)
Definition message.h:127
ASSERT
#define ASSERT(x)
Definition message.h:142
warn_layout
#define warn_layout(file, line, fmt,...)
Definition message.h:117
anonymous_namespace{layout.cpp}::startCb
static auto startCb(void(LayoutParser::*fn)(Args...))
Definition layout.cpp:733
anonymous_namespace{layout.cpp}::g_elementHandlers
static const std::map< std::string, ElementCallbacks > g_elementHandlers
Definition layout.cpp:791
anonymous_namespace{layout.cpp}::endCb
static auto endCb(void(LayoutParser::*fn)(Args...))
Definition layout.cpp:785
reg::match
bool match(std::string_view str, Match &match, const Ex &re)
Matches a given string str for a match against regular expression re.
Definition regex.cpp:861
std
Definition dstring.h:913
LayoutDocEntry::Kind
Kind
Definition layout.h:66
LayoutDocEntryMemberDecl
Represents of a member declaration list with configurable title and subtitle.
Definition layout.h:111
LayoutDocEntryMemberDecl::m_title
DString m_title
Definition layout.h:124
LayoutDocEntryMemberDecl::subtitle
DString subtitle(SrcLangExt lang) const
Definition layout.cpp:1793
LayoutDocEntryMemberDecl::m_subscript
DString m_subscript
Definition layout.h:125
LayoutDocEntryMemberDecl::title
DString title(SrcLangExt lang) const
Definition layout.cpp:1788
LayoutDocEntryMemberDef
Represents of a member definition list with configurable title.
Definition layout.h:131
LayoutDocEntryMemberDef::m_title
DString m_title
Definition layout.h:142
LayoutDocEntryMemberDef::title
DString title(SrcLangExt lang) const
Definition layout.cpp:1800
LayoutDocEntrySection::title
DString title(SrcLangExt lang) const
Definition layout.cpp:1781
LayoutDocEntrySection::m_title
DString m_title
Definition layout.h:106
LayoutDocEntrySimple
Represents of a piece of a documentation page without configurable parts.
Definition layout.h:88
LayoutDocEntrySimple::visible
bool visible() const override
Definition layout.h:92
LayoutNavEntry
Base class for the layout of a navigation item at the top of the HTML pages.
Definition layout.h:155
LayoutNavEntry::m_visible
bool m_visible
Definition layout.h:246
LayoutNavEntry::m_children
LayoutNavEntryList m_children
Definition layout.h:250
LayoutNavEntry::children
const LayoutNavEntryList & children() const
Definition layout.h:218
LayoutNavEntry::find
LayoutNavEntry * find(LayoutNavEntry::Kind k, const DString &file=DString()) const
Definition layout.cpp:135
LayoutNavEntry::id
std::string id() const
Definition layout.h:214
LayoutNavEntry::updateVisibility
void updateVisibility(LayoutNavEntry *parent)
Definition layout.cpp:118
LayoutNavEntry::appendChild
void appendChild(std::unique_ptr< LayoutNavEntry > &&e)
Definition layout.cpp:123
LayoutNavEntry::insertChild
void insertChild(size_t pos, std::unique_ptr< LayoutNavEntry > &&e)
Definition layout.cpp:129
LayoutNavEntry::parent
LayoutNavEntry * parent() const
Definition layout.h:211
LayoutNavEntry::title
DString title() const
Definition layout.h:215
LayoutNavEntry::url
DString url() const
Definition layout.cpp:153
LayoutNavEntry::baseFile
DString baseFile() const
Definition layout.h:213
LayoutNavEntry::kind
Kind kind() const
Definition layout.h:212
LayoutNavEntry::visible
bool visible() const
Definition layout.h:221
LayoutNavEntry::LayoutNavEntry
LayoutNavEntry(LayoutNavEntry *parent, Kind k, bool vs, const DString &bf, const DString &tl, const DString &intro)
Definition layout.h:208
LayoutNavEntry::Kind
Kind
Definition layout.h:192
LayoutNavEntry::navToString
std::string navToString() const
Definition layout.h:197
anonymous_namespace{layout.cpp}::ElementCallbacks
Definition layout.cpp:724
anonymous_namespace{layout.cpp}::ElementCallbacks::startCb
StartCallback startCb
Definition layout.cpp:728
anonymous_namespace{layout.cpp}::ElementCallbacks::EndCallback
std::function< void(LayoutParser &, const std::string &)> EndCallback
Definition layout.cpp:726
anonymous_namespace{layout.cpp}::ElementCallbacks::StartCallback
std::function< void(LayoutParser &, const std::string &, const XMLHandlers::Attributes &)> StartCallback
Definition layout.cpp:725
anonymous_namespace{layout.cpp}::ElementCallbacks::endCb
EndCallback endCb
Definition layout.cpp:729
types.h
This file contains a number of basic enums and types.
SrcLangExt
SrcLangExt
Definition types.h:207
transcodeCharacterStringToUTF8
bool transcodeCharacterStringToUTF8(std::string &input, const char *inputEncoding)
Recodes the input string from the given input encoding to UTF8.
Definition utf8.cpp:244
addHtmlExtensionIfMissing
void addHtmlExtensionIfMissing(DString &fName)
Definition util.cpp:3931
fileToString
DString fileToString(const DString &name, bool filter, bool isSourceCode)
Definition util.cpp:1053
externalRef
DString externalRef(const DString &relPath, const DString &ref)
Definition util.cpp:4538
openOutputFile
bool openOutputFile(const DString &outFile, std::ofstream &f)
Definition util.cpp:4971
util.h
A bunch of utility functions.