The DotGroupCollaboration Class Reference

Representation of a group collaboration graph. More...

Declaration

class DotGroupCollaboration { ... }

Included Headers

#include <src/dotgroupcollaboration.h>

Base class

class	DotGraph
	A dot graph. More...

Enumerations Index

enum	EdgeType { ... }

Public Constructors Index

	DotGroupCollaboration (const GroupDef *gd)

Public Destructor Index

	~DotGroupCollaboration () override

Public Member Functions Index

QCString	writeGraph (TextStream &t, GraphOutputFormat gf, EmbeddedOutputFormat ef, const QCString &path, const QCString &fileName, const QCString &relPath, bool writeImageMap=TRUE, int graphId=-1)
bool	isTrivial () const
bool	isTooBig () const
int	numNodes () const

Protected Member Functions Index

QCString	getBaseName () const override
QCString	getMapLabel () const override
void	computeTheGraph () override

Private Member Functions Index

void	buildGraph (const GroupDef *gd)
void	addCollaborationMember (const Definition *def, QCString &url, EdgeType eType)
void	addMemberList (class MemberList *ml)
void	writeGraphHeader (TextStream &t, const QCString &title) const
Edge *	addEdge (DotNode *_pNStart, DotNode *_pNEnd, EdgeType _eType, const QCString &_label, const QCString &_url)

Private Member Attributes Index

DotNode *	m_rootNode
DotNodeMap	m_usedNodes
QCString	m_diskName
std::vector< std::unique_ptr< Edge > >	m_edges

Description

Representation of a group collaboration graph.

Definition at line 28 of file dotgroupcollaboration.h.

Enumerations

EdgeType

enum DotGroupCollaboration::EdgeType

Enumeration values

tmember	(= 0)
tclass
tnamespace
tfile
tpages
tdir
thierarchy

Definition at line 48 of file dotgroupcollaboration.h.

49 {

50 tmember = 0,

51 tclass,

52 tnamespace,

53 tfile,

54 tpages,

55 tdir,

56 thierarchy

57 };

Public Constructors

DotGroupCollaboration()

DotGroupCollaboration::DotGroupCollaboration (const GroupDef * gd)

Declaration at line 31 of file dotgroupcollaboration.h, definition at line 25 of file dotgroupcollaboration.cpp.

25DotGroupCollaboration::DotGroupCollaboration(const GroupDef* gd)

26{

27 QCString tmp_url = gd->getReference()+"$"+gd->getOutputFileBase();

28 QCString tooltip = gd->briefDescriptionAsTooltip();

29 m_rootNode = new DotNode(this, gd->groupTitle(), tooltip, tmp_url, TRUE );

30 m_rootNode->markAsVisible();

31 m_usedNodes.emplace(gd->name().str(), m_rootNode);

32

33 m_diskName = gd->getOutputFileBase();

34

35 buildGraph( gd );

36}

References Definition::briefDescriptionAsTooltip, buildGraph, DotGraph::DotNode, Definition::getOutputFileBase, Definition::getReference, GroupDef::groupTitle, m_diskName, m_rootNode, m_usedNodes, Definition::name, QCString::str and TRUE.

Public Destructor

~DotGroupCollaboration()

DotGroupCollaboration::~DotGroupCollaboration ()

Declaration at line 32 of file dotgroupcollaboration.h, definition at line 38 of file dotgroupcollaboration.cpp.

38DotGroupCollaboration::~DotGroupCollaboration()

39{

40 // delete all created Nodes saved in m_usedNodes map

41 for (const auto &[name,node] : m_usedNodes)

42 {

43 delete node;

44 }

45}

Reference m_usedNodes.

Public Member Functions

isTooBig()

bool DotGroupCollaboration::isTooBig ()

Declaration at line 39 of file dotgroupcollaboration.h, definition at line 324 of file dotgroupcollaboration.cpp.

324bool DotGroupCollaboration::isTooBig() const

325{

326 return numNodes()>=Config_getInt(DOT_GRAPH_MAX_NODES);

327}

References Config_getInt and numNodes.

Referenced by GroupDefImpl::writeGroupGraph.

isTrivial()

bool DotGroupCollaboration::isTrivial ()

Declaration at line 38 of file dotgroupcollaboration.h, definition at line 319 of file dotgroupcollaboration.cpp.

319bool DotGroupCollaboration::isTrivial() const

320{

321 return m_usedNodes.size() <= 1;

322}

Reference m_usedNodes.

Referenced by GroupDefImpl::writeGroupGraph.

numNodes()

int DotGroupCollaboration::numNodes ()

Declaration at line 40 of file dotgroupcollaboration.h, definition at line 329 of file dotgroupcollaboration.cpp.

329int DotGroupCollaboration::numNodes() const

330{

331 return static_cast<int>(m_usedNodes.size());

332}

Reference m_usedNodes.

Referenced by isTooBig and GroupDefImpl::writeGroupGraph.

writeGraph()

QCString DotGroupCollaboration::writeGraph (TextStream & t, GraphOutputFormat gf, EmbeddedOutputFormat ef, const QCString & path, const QCString & fileName, const QCString & relPath, bool writeImageMap=TRUE, int graphId=-1)

Declaration at line 35 of file dotgroupcollaboration.h, definition at line 249 of file dotgroupcollaboration.cpp.

249QCString DotGroupCollaboration::writeGraph( TextStream &t,

250 GraphOutputFormat graphFormat, EmbeddedOutputFormat textFormat,

251 const QCString &path, const QCString &fileName, const QCString &relPath,

252 bool generateImageMap,int graphId)

253{

254 m_doNotAddImageToIndex = textFormat!=EmbeddedOutputFormat::Html;

255

256 return DotGraph::writeGraph(t, graphFormat, textFormat, path, fileName, relPath, generateImageMap, graphId);

257}

References Html, DotGraph::m_doNotAddImageToIndex and DotGraph::writeGraph.

Referenced by DocbookGenerator::endGroupCollaboration, HtmlGenerator::endGroupCollaboration and LatexGenerator::endGroupCollaboration.

Protected Member Functions

computeTheGraph()

void DotGroupCollaboration::computeTheGraph ()

protected virtual

Declaration at line 45 of file dotgroupcollaboration.h, definition at line 216 of file dotgroupcollaboration.cpp.

216void DotGroupCollaboration::computeTheGraph()

217{

218 TextStream md5stream;

219 writeGraphHeader(md5stream,m_rootNode->label());

220

221 // clean write flags

222 for (const auto &[name,node] : m_usedNodes)

223 {

224 node->clearWriteFlag();

225 }

226

227 // write other nodes.

228 for (const auto &[name,node] : m_usedNodes)

229 {

230 node->write(md5stream,GraphType::Inheritance,m_graphFormat,TRUE,FALSE,FALSE);

231 }

232

233 // write edges

234 for (const auto &edge : m_edges)

235 {

236 edge->write( md5stream );

237 }

238

239 writeGraphFooter(md5stream);

240

241 m_theGraph = md5stream.str();

242}

References FALSE, Inheritance, m_edges, DotGraph::m_graphFormat, m_rootNode, DotGraph::m_theGraph, m_usedNodes, TextStream::str, TRUE, DotGraph::writeGraphFooter and writeGraphHeader.

getBaseName()

QCString DotGroupCollaboration::getBaseName ()

protected virtual

Declaration at line 43 of file dotgroupcollaboration.h, definition at line 211 of file dotgroupcollaboration.cpp.

211QCString DotGroupCollaboration::getBaseName() const

212{

213 return m_diskName;

214}

Reference m_diskName.

getMapLabel()

QCString DotGroupCollaboration::getMapLabel ()

protected virtual

Declaration at line 44 of file dotgroupcollaboration.h, definition at line 244 of file dotgroupcollaboration.cpp.

244QCString DotGroupCollaboration::getMapLabel() const

245{

246 return escapeCharsInString(m_baseName, FALSE);

247}

References escapeCharsInString, FALSE and DotGraph::m_baseName.

Private Member Functions

addCollaborationMember()

void DotGroupCollaboration::addCollaborationMember (const Definition * def, QCString & url, EdgeType eType)

Declaration at line 80 of file dotgroupcollaboration.h, definition at line 186 of file dotgroupcollaboration.cpp.

186void DotGroupCollaboration::addCollaborationMember(

187 const Definition* def, QCString& url, EdgeType eType )

188{

189 // Create group nodes

190 QCString tmp_str;

191 for (const auto &d : def->partOfGroups())

192 {

193 auto it = m_usedNodes.find(d->name().str());

194 DotNode* nnode = it!=m_usedNodes.end() ? it->second : nullptr;

195 if ( nnode != m_rootNode )

196 {

197 if ( nnode==nullptr )

198 { // add node

199 tmp_str = d->getReference()+"$"+d->getOutputFileBase();

200 QCString tooltip = d->briefDescriptionAsTooltip();

201 nnode = new DotNode(this, d->groupTitle(), tooltip, tmp_str );

202 nnode->markAsVisible();

203 m_usedNodes.emplace(d->name().str(), nnode);

204 }

205 tmp_str = def->qualifiedName();

206 addEdge( m_rootNode, nnode, eType, tmp_str, url );

207 }

208 }

209}

References addEdge, DotGraph::DotNode, m_rootNode, m_usedNodes, DotNode::markAsVisible, Definition::partOfGroups and Definition::qualifiedName.

Referenced by addMemberList and buildGraph.

addEdge()

DotGroupCollaboration::Edge * DotGroupCollaboration::addEdge (DotNode * _pNStart, DotNode * _pNEnd, EdgeType _eType, const QCString & _label, const QCString & _url)

Declaration at line 83 of file dotgroupcollaboration.h, definition at line 162 of file dotgroupcollaboration.cpp.

162DotGroupCollaboration::Edge* DotGroupCollaboration::addEdge(

163 DotNode* _pNStart, DotNode* _pNEnd, EdgeType _eType,

164 const QCString& _label, const QCString& _url )

165{

166 // search a existing link.

167 auto it = std::find_if(m_edges.begin(),m_edges.end(),

168 [&_pNStart,&_pNEnd,&_eType](const auto &edge)

169 { return edge->pNStart==_pNStart && edge->pNEnd==_pNEnd && edge->eType==_eType; });

170

171 if (it==m_edges.end()) // new link

172 {

173 m_edges.emplace_back(std::make_unique<Edge>(_pNStart,_pNEnd,_eType));

174 it = m_edges.end()-1;

175 }

176

177 if (!_label.isEmpty()) // add label

178 {

179 (*it)->links.emplace_back(_label,_url);

180 }

181

182 // return found or added edge

183 return (*it).get();

184}

References DotGraph::DotNode, QCString::isEmpty and m_edges.

Referenced by addCollaborationMember and buildGraph.

addMemberList()

void DotGroupCollaboration::addMemberList (class MemberList * ml)

Declaration at line 81 of file dotgroupcollaboration.h, definition at line 151 of file dotgroupcollaboration.cpp.

151void DotGroupCollaboration::addMemberList( MemberList* ml )

152{

153 QCString url;

154 if ( ml==nullptr || ml->empty() ) return;

155 for (const auto &def : *ml)

156 {

157 makeURL(def,url);

158 addCollaborationMember( def, url, DotGroupCollaboration::tmember );

159 }

160}

References addCollaborationMember, MemberVector::empty, makeURL and tmember.

Referenced by buildGraph.

buildGraph()

void DotGroupCollaboration::buildGraph (const GroupDef * gd)

Declaration at line 79 of file dotgroupcollaboration.h, definition at line 58 of file dotgroupcollaboration.cpp.

58void DotGroupCollaboration::buildGraph(const GroupDef* gd)

59{

60 QCString url;

61 //===========================

62 // hierarchy.

63

64 // Write parents

65 for (const auto &d : gd->partOfGroups())

66 {

67 DotNode *nnode = nullptr;

68 auto it = m_usedNodes.find(d->name().str());

69 if ( it==m_usedNodes.end())

70 { // add node

71 makeURL(d,url);

72 QCString tooltip = d->briefDescriptionAsTooltip();

73 nnode = new DotNode(this, d->groupTitle(), tooltip, url );

74 nnode->markAsVisible();

75 m_usedNodes.emplace(d->name().str(), nnode);

76 }

77 else

78 {

79 nnode = it->second;

80 }

81 url = "";

82 addEdge( nnode, m_rootNode, DotGroupCollaboration::thierarchy, url, url );

83 }

84

85 // Add subgroups

86 for (const auto &def : gd->getSubGroups())

87 {

88 DotNode *nnode = nullptr;

89 auto it = m_usedNodes.find(def->name().str());

90 if ( it==m_usedNodes.end())

91 { // add node

92 makeURL(def,url);

93 QCString tooltip = def->briefDescriptionAsTooltip();

94 nnode = new DotNode(this, def->groupTitle(), tooltip, url );

95 nnode->markAsVisible();

96 m_usedNodes.emplace(def->name().str(), nnode);

97 }

98 else

99 {

100 nnode = it->second;

101 }

102 url = "";

103 addEdge( m_rootNode, nnode, DotGroupCollaboration::thierarchy, url, url );

104 }

105

106 //=======================

107 // Write collaboration

108

109 // Add members

110 addMemberList( gd->getMemberList(MemberListType::AllMembersList()) );

111

112 // Add classes

113 for (const auto &def : gd->getClasses())

114 {

115 makeURL(def,url);

116 addCollaborationMember( def, url, DotGroupCollaboration::tclass );

117 }

118

119 // Add namespaces

120 for (const auto &def : gd->getNamespaces())

121 {

122 makeURL(def,url);

123 addCollaborationMember( def, url, DotGroupCollaboration::tnamespace );

124 }

125

126 // Add files

127 for (const auto &def : gd->getFiles())

128 {

129 makeURL(def,url);

130 addCollaborationMember( def, url, DotGroupCollaboration::tfile );

131 }

132

133 // Add pages

134 for (const auto &def : gd->getPages())

135 {

136 makeURL(def,url);

137 addCollaborationMember( def, url, DotGroupCollaboration::tpages );

138 }

139

140 // Add directories

141 if ( !gd->getDirs().empty() )

142 {

143 for(const auto def : gd->getDirs())

144 {

145 makeURL(def,url);

146 addCollaborationMember( def, url, DotGroupCollaboration::tdir );

147 }

148 }

149}

References addCollaborationMember, addEdge, addMemberList, DotGraph::DotNode, GroupDef::getClasses, GroupDef::getDirs, GroupDef::getFiles, GroupDef::getMemberList, GroupDef::getNamespaces, GroupDef::getPages, GroupDef::getSubGroups, m_rootNode, m_usedNodes, makeURL, DotNode::markAsVisible, Definition::partOfGroups, tclass, tdir, tfile, thierarchy, tnamespace and tpages.

Referenced by DotGroupCollaboration.

writeGraphHeader()

void DotGroupCollaboration::writeGraphHeader (TextStream & t, const QCString & title)

Declaration at line 82 of file dotgroupcollaboration.h, definition at line 334 of file dotgroupcollaboration.cpp.

334void DotGroupCollaboration::writeGraphHeader(TextStream &t,const QCString &title) const

335{

336 DotGraph::writeGraphHeader(t, title);

337 t << " rankdir=LR;\n";

338}

Reference DotGraph::writeGraphHeader.

Referenced by computeTheGraph.

Private Member Attributes

m_diskName

QCString DotGroupCollaboration::m_diskName

Definition at line 88 of file dotgroupcollaboration.h.

88 QCString m_diskName;

Referenced by DotGroupCollaboration and getBaseName.

m_edges

std::vector< std::unique_ptr<Edge> > DotGroupCollaboration::m_edges

Definition at line 89 of file dotgroupcollaboration.h.

89 std::vector< std::unique_ptr<Edge> > m_edges;

Referenced by addEdge and computeTheGraph.

m_rootNode

DotNode* DotGroupCollaboration::m_rootNode

Definition at line 86 of file dotgroupcollaboration.h.

86 DotNode *m_rootNode;

Referenced by addCollaborationMember, buildGraph, computeTheGraph and DotGroupCollaboration.

m_usedNodes

DotNodeMap DotGroupCollaboration::m_usedNodes

Definition at line 87 of file dotgroupcollaboration.h.

87 DotNodeMap m_usedNodes;

Referenced by addCollaborationMember, buildGraph, computeTheGraph, DotGroupCollaboration, isTrivial, numNodes and ~DotGroupCollaboration.

---

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

• dotgroupcollaboration.cpp
• dotgroupcollaboration.h

---

Generated via doxygen2docusaurus by Doxygen 1.14.0.