Skip to main content

The DotGfxHierarchyTable Class Reference

Represents a graphical class hierarchy. More...

Declaration​

class DotGfxHierarchyTable { ... }

Included Headers​

#include <src/dotgfxhierarchytable.h>

Base class​

classDotGraph

A dot graph. More...

Private Member Typedefs Index​

usingDotNodeMap = std::unordered_multimap< std::string, std::unique_ptr< DotNode > >

Public Constructors Index​

DotGfxHierarchyTable (const QCString &prefix="", ClassDef::CompoundType ct=ClassDef::Class)

Public Destructor Index​

~DotGfxHierarchyTable () override=default

Public Member Functions Index​

voidcreateGraph (DotNode *rootNode, TextStream &t, const QCString &path, const QCString &fileName, int id)
voidwriteGraph (TextStream &t, const QCString &path, const QCString &fileName)
const std::vector< DotNode * >subGraphs () const

Protected Member Functions Index​

QCStringgetBaseName () const override
QCStringgetMapLabel () const override
voidcomputeTheGraph () override

Private Member Functions Index​

voidaddHierarchy (DotNode *n, const ClassDef *cd, ClassDefSet &visited)
voidaddClassList (const ClassLinkedMap &cl, ClassDefSet &visited)

Private Member Attributes Index​

intm_graphId
QCStringm_prefix
ClassDef::CompoundTypem_classType
std::vector< DotNode * >m_rootNodes
DotNodeMapm_usedNodes
std::vector< DotNode * >m_rootSubgraphs
DotNode *m_rootSubgraphNode

Description​

Represents a graphical class hierarchy.

Definition at line 31 of file dotgfxhierarchytable.h.

Private Member Typedefs​

DotNodeMap​

using DotGfxHierarchyTable::DotNodeMap = std::unordered_multimap< std::string, std::unique_ptr<DotNode> >

Definition at line 52 of file dotgfxhierarchytable.h.

52 using DotNodeMap = std::unordered_multimap< std::string, std::unique_ptr<DotNode> >;

Public Constructors​

DotGfxHierarchyTable()​

DotGfxHierarchyTable::DotGfxHierarchyTable (const QCString & prefix="", ClassDef::CompoundType ct=ClassDef::Class)

Declaration at line 34 of file dotgfxhierarchytable.h, definition at line 226 of file dotgfxhierarchytable.cpp.

226DotGfxHierarchyTable::DotGfxHierarchyTable(const QCString &prefix,ClassDef::CompoundType ct)
227 : m_prefix(prefix)
228 , m_classType(ct)
229{
230 // build a graph with each class as a node and the inheritance relations
231 // as edges
232 ClassDefSet visitedClasses;
233 addClassList(*Doxygen::classLinkedMap,visitedClasses);
234 addClassList(*Doxygen::hiddenClassLinkedMap,visitedClasses);
235 // m_usedNodes now contains all nodes in the graph
236
237 // color the graph into a set of independent subgraphs
238 bool done=FALSE;
239 int curColor=0;
240 while (!done) // there are still nodes to color
241 {
242 done=TRUE; // we are done unless there are still uncolored nodes
243 for (auto n : m_rootNodes)
244 {
245 if (n->subgraphId()==-1) // not yet colored
246 {
247 //printf("Starting at node %s (%p): %d\n",qPrint(n->label()),n,curColor);
248 done=FALSE; // still uncolored nodes
249 n->setSubgraphId(curColor);
250 n->markAsVisible();
251 n->colorConnectedNodes(curColor);
252 curColor++;
253 m_rootSubgraphs.push_back(n);
254 }
255 }
256 }
257
258 //printf("Number of independent subgraphs: %d\n",curColor);
259 for (auto n : m_rootSubgraphs)
260 {
261 //printf("Node %s color=%d (c=%d,p=%d)\n",
262 // qPrint(n->label()),n->m_subgraphId,
263 // n->children()?n->children()->count():0,
264 // n->parents()?n->parents()->count():0);
265 int number=0;
266 n->renumberNodes(number);
267 }
268}

References addClassList, Doxygen::classLinkedMap, FALSE, Doxygen::hiddenClassLinkedMap, m_classType, m_prefix, m_rootNodes, m_rootSubgraphs, prefix and TRUE.

Referenced by ~DotGfxHierarchyTable.

Public Destructor​

~DotGfxHierarchyTable()​

DotGfxHierarchyTable::~DotGfxHierarchyTable ()
 default

Definition at line 35 of file dotgfxhierarchytable.h.

References DotGfxHierarchyTable and DotGraph::DotNode.

Public Member Functions​

createGraph()​

void DotGfxHierarchyTable::createGraph (DotNode * rootNode, TextStream & t, const QCString & path, const QCString & fileName, int id)

Declaration at line 38 of file dotgfxhierarchytable.h, definition at line 65 of file dotgfxhierarchytable.cpp.

65void DotGfxHierarchyTable::createGraph(DotNode *n,TextStream &out,
66 const QCString &path,const QCString &fileName,int id)
67{
68 m_rootSubgraphNode = n;
69 m_graphId = id;
70 m_noDivTag = TRUE;
71 m_zoomable = FALSE;
72 DotGraph::writeGraph(out, GraphOutputFormat::BITMAP, EmbeddedOutputFormat::Html, path, fileName, "", TRUE, 0);
73}

References BITMAP, DotGraph::DotNode, FALSE, Html, m_graphId, DotGraph::m_noDivTag, m_rootSubgraphNode, DotGraph::m_zoomable, TRUE and DotGraph::writeGraph.

Referenced by writeGraph.

subGraphs()​

const std::vector< DotNode * > DotGfxHierarchyTable::subGraphs ()
 inline

Definition at line 41 of file dotgfxhierarchytable.h.

41 const std::vector<DotNode*> subGraphs() const { return m_rootSubgraphs; }

Reference m_rootSubgraphs.

writeGraph()​

void DotGfxHierarchyTable::writeGraph (TextStream & t, const QCString & path, const QCString & fileName)

Declaration at line 40 of file dotgfxhierarchytable.h, definition at line 75 of file dotgfxhierarchytable.cpp.

75void DotGfxHierarchyTable::writeGraph(TextStream &out,
76 const QCString &path,const QCString &fileName)
77{
78 //printf("DotGfxHierarchyTable::writeGraph(%s)\n",name);
79 //printf("m_rootNodes=%p count=%d\n",m_rootNodes,m_rootNodes->count());
80
81 if (m_rootSubgraphs.empty()) return;
82
83 Dir d(path.str());
84 // store the original directory
85 if (!d.exists())
86 {
87 term("Output dir {} does not exist!\n",path);
88 }
89
90 // put each connected subgraph of the hierarchy in a row of the HTML output
91 out << "<table border=\"0\" cellspacing=\"10\" cellpadding=\"0\">\n";
92
93 int count=0;
94 std::stable_sort(m_rootSubgraphs.begin(),m_rootSubgraphs.end(),
95 [](auto n1,auto n2) { return qstricmp_sort(n1->label(),n2->label())<0; });
96 for (auto n : m_rootSubgraphs)
97 {
98 out << "<tr><td>";
99 createGraph(n,out,path,fileName,count++);
100 out << "</td></tr>\n";
101 }
102 out << "</table>\n";
103}

References createGraph, Dir::exists, m_rootSubgraphs, QCString::str and term.

Referenced by HtmlGenerator::writeGraphicalHierarchy.

Protected Member Functions​

computeTheGraph()​

void DotGfxHierarchyTable::computeTheGraph ()
 protected virtual

Declaration at line 46 of file dotgfxhierarchytable.h, definition at line 37 of file dotgfxhierarchytable.cpp.

37void DotGfxHierarchyTable::computeTheGraph()
38{
39 TextStream md5stream;
40 writeGraphHeader(md5stream,theTranslator->trGraphicalHierarchy());
41 md5stream << " rankdir=\"LR\";\n";
42 for (auto node : m_rootNodes)
43 {
44 if (node->subgraphId()==m_rootSubgraphNode->subgraphId())
45 {
46 node->clearWriteFlag();
47 }
48 }
49 for (auto node : m_rootNodes)
50 {
51 if (node->subgraphId()==m_rootSubgraphNode->subgraphId())
52 {
53 node->write(md5stream,GraphType::Hierarchy,GraphOutputFormat::BITMAP,FALSE,TRUE,TRUE);
54 }
55 }
56 writeGraphFooter(md5stream);
57 m_theGraph = md5stream.str();
58}

References BITMAP, FALSE, Hierarchy, m_rootNodes, m_rootSubgraphNode, DotGraph::m_theGraph, TextStream::str, theTranslator, TRUE, DotGraph::writeGraphFooter and DotGraph::writeGraphHeader.

getBaseName()​

QCString DotGfxHierarchyTable::getBaseName ()
 protected virtual

Declaration at line 44 of file dotgfxhierarchytable.h, definition at line 27 of file dotgfxhierarchytable.cpp.

27QCString DotGfxHierarchyTable::getBaseName() const
28{
29 QCString baseName;
30 if (m_prefix.isEmpty())
31 baseName.sprintf("inherit_graph_%d", m_graphId);
32 else
33 baseName.sprintf("%sinherit_graph_%d",qPrint(m_prefix), m_graphId);
34 return baseName;
35}

References m_graphId, m_prefix, qPrint and QCString::sprintf.

getMapLabel()​

QCString DotGfxHierarchyTable::getMapLabel ()
 protected virtual

Declaration at line 45 of file dotgfxhierarchytable.h, definition at line 60 of file dotgfxhierarchytable.cpp.

60QCString DotGfxHierarchyTable::getMapLabel() const
61{
62 return escapeCharsInString(m_rootSubgraphNode->label(),FALSE);
63}

References escapeCharsInString, FALSE and m_rootSubgraphNode.

Private Member Functions​

addClassList()​

void DotGfxHierarchyTable::addClassList (const ClassLinkedMap & cl, ClassDefSet & visited)

Declaration at line 50 of file dotgfxhierarchytable.h, definition at line 179 of file dotgfxhierarchytable.cpp.

179void DotGfxHierarchyTable::addClassList(const ClassLinkedMap &cl,ClassDefSet &visitedClasses)
180{
181 for (const auto &cd : cl)
182 {
183 //printf("Trying %s subClasses=%d\n",qPrint(cd->name()),cd->subClasses()->count());
184 if (cd->getLanguage()==SrcLangExt::VHDL &&
185 VhdlDocGen::convert(cd->protection())!=VhdlDocGen::ENTITYCLASS
186 )
187 {
188 continue;
189 }
190 if (Config_getBool(OPTIMIZE_OUTPUT_SLICE) && cd->compoundType() != m_classType)
191 {
192 continue;
193 }
194 if (!classHasVisibleRoot(cd->baseClasses()) &&
195 cd->isVisibleInHierarchy()
196 ) // root node in the forest
197 {
198 QCString tmp_url="";
199 if (cd->isLinkable() && !cd->isHidden())
200 {
201 tmp_url=cd->getReference()+"$"+cd->getOutputFileBase();
202 if (!cd->anchor().isEmpty())
203 {
204 tmp_url+="#"+cd->anchor();
205 }
206 }
207 //printf("Inserting root class %s\n",qPrint(cd->name()));
208 QCString tooltip = cd->briefDescriptionAsTooltip();
209 auto n = std::make_unique<DotNode>(this,
210 cd->displayName(),
211 tooltip,
212 tmp_url);
213 DotNode *root = n.get();
214
215 m_usedNodes.emplace(cd->name().str(),std::move(n));
216 m_rootNodes.push_back(root);
217 if (visitedClasses.find(cd.get())==visitedClasses.end() && !cd->subClasses().empty())
218 {
219 addHierarchy(root,cd.get(),visitedClasses);
220 visitedClasses.insert(cd.get());
221 }
222 }
223 }
224}

References addHierarchy, classHasVisibleRoot, Config_getBool, VhdlDocGen::convert, DotGraph::DotNode, VhdlDocGen::ENTITYCLASS, m_classType, m_rootNodes and m_usedNodes.

Referenced by DotGfxHierarchyTable.

addHierarchy()​

void DotGfxHierarchyTable::addHierarchy (DotNode * n, const ClassDef * cd, ClassDefSet & visited)

Declaration at line 49 of file dotgfxhierarchytable.h, definition at line 105 of file dotgfxhierarchytable.cpp.

105void DotGfxHierarchyTable::addHierarchy(DotNode *n,const ClassDef *cd,ClassDefSet &visitedClasses)
106{
107 //printf("addHierarchy '%s' baseClasses=%d\n",qPrint(cd->name()),cd->baseClasses()->count());
108 for (const auto &bcd : cd->subClasses())
109 {
110 ClassDef *bClass=bcd.classDef;
111 //printf(" Trying sub class='%s' usedNodes=%d\n",qPrint(bClass->name()),m_usedNodes->count());
112 if (bClass && bClass->isVisibleInHierarchy() && classHasVisibleRoot(bClass->baseClasses()))
113 {
114 auto it = m_usedNodes.find(bClass->name().str());
115 //printf(" Node '%s' Found visible class='%s'\n",qPrint(n->label()),
116 // qPrint(bClass->name()));
117 DotNode *root = nullptr;
118 if (it!=m_usedNodes.end()) // node already present
119 {
120 const auto &bn = it->second;
121 root = bn.get();
122 const auto &children = n->children();
123 auto child_it = std::find(children.begin(),children.end(),bn.get());
124 if (child_it==children.end()) // no arrow yet
125 {
126 n->addChild(bn.get(),EdgeInfo::protectionToColor(bcd.prot));
127 bn->addParent(n);
128 //printf(" Adding node %s to existing base node %s (c=%d,p=%d)\n",
129 // qPrint(n->label()),
130 // qPrint(bn->label()),
131 // bn->children() ? bn->children()->count() : 0,
132 // bn->parents() ? bn->parents()->count() : 0
133 // );
134 }
135 //else
136 //{
137 // printf(" Class already has an arrow!\n");
138 //}
139 }
140 else
141 {
142 QCString tmp_url="";
143 if (bClass->isLinkable() && !bClass->isHidden())
144 {
145 tmp_url=bClass->getReference()+"$"+bClass->getOutputFileBase();
146 if (!bClass->anchor().isEmpty())
147 {
148 tmp_url+="#"+bClass->anchor();
149 }
150 }
151 QCString tooltip = bClass->briefDescriptionAsTooltip();
152 auto bn = std::make_unique<DotNode>(this,
153 bClass->displayName(),
154 tooltip,
155 tmp_url
156 );
157 n->addChild(bn.get(),EdgeInfo::protectionToColor(bcd.prot));
158 bn->addParent(n);
159 root = bn.get();
160 //printf(" Adding node %s to new base node %s (c=%d,p=%d)\n",
161 // qPrint(n->label()),
162 // qPrint(bn->label()),
163 // bn->children() ? bn->children()->count() : 0,
164 // bn->parents() ? bn->parents()->count() : 0
165 // );
166 //printf(" inserting %s (%p)\n",qPrint(bClass->name()),bn);
167 m_usedNodes.emplace(bClass->name().str(),std::move(bn)); // add node to the used list
168 }
169 if (visitedClasses.find(bClass)==visitedClasses.end() && !bClass->subClasses().empty())
170 {
171 visitedClasses.insert(bClass);
172 addHierarchy(root,bClass,visitedClasses);
173 }
174 }
175 }
176 //printf("end addHierarchy\n");
177}

References DotNode::addChild, addHierarchy, Definition::anchor, ClassDef::baseClasses, Definition::briefDescriptionAsTooltip, DotNode::children, classHasVisibleRoot, Definition::displayName, DotGraph::DotNode, Definition::getOutputFileBase, Definition::getReference, QCString::isEmpty, Definition::isHidden, Definition::isLinkable, ClassDef::isVisibleInHierarchy, m_usedNodes, Definition::name, EdgeInfo::protectionToColor, QCString::str and ClassDef::subClasses.

Referenced by addClassList and addHierarchy.

Private Member Attributes​

m_classType​

ClassDef::CompoundType DotGfxHierarchyTable::m_classType

Definition at line 55 of file dotgfxhierarchytable.h.

55 ClassDef::CompoundType m_classType;

Referenced by addClassList and DotGfxHierarchyTable.

m_graphId​

int DotGfxHierarchyTable::m_graphId

Definition at line 53 of file dotgfxhierarchytable.h.

53 int m_graphId;

Referenced by createGraph and getBaseName.

m_prefix​

QCString DotGfxHierarchyTable::m_prefix

Definition at line 54 of file dotgfxhierarchytable.h.

54 QCString m_prefix;

Referenced by DotGfxHierarchyTable and getBaseName.

m_rootNodes​

std::vector<DotNode*> DotGfxHierarchyTable::m_rootNodes

Definition at line 56 of file dotgfxhierarchytable.h.

56 std::vector<DotNode*> m_rootNodes;

Referenced by addClassList, computeTheGraph and DotGfxHierarchyTable.

m_rootSubgraphNode​

DotNode* DotGfxHierarchyTable::m_rootSubgraphNode

Definition at line 59 of file dotgfxhierarchytable.h.

59 DotNode * m_rootSubgraphNode;

Referenced by computeTheGraph, createGraph and getMapLabel.

m_rootSubgraphs​

std::vector<DotNode*> DotGfxHierarchyTable::m_rootSubgraphs

Definition at line 58 of file dotgfxhierarchytable.h.

58 std::vector<DotNode*> m_rootSubgraphs;

Referenced by DotGfxHierarchyTable, subGraphs and writeGraph.

m_usedNodes​

DotNodeMap DotGfxHierarchyTable::m_usedNodes

Definition at line 57 of file dotgfxhierarchytable.h.

57 DotNodeMap m_usedNodes;

Referenced by addClassList and addHierarchy.

The documentation for this class was generated from the following files:

Generated via doxygen2docusaurus by Doxygen 1.14.0.