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