DotClassGraph Class Reference

Representation of a class inheritance or dependency graph. More...

#include <src/dotclassgraph.h>

Inheritance diagram for DotClassGraph:

Collaboration diagram for DotClassGraph:

Public Member Functions
	DotClassGraph (const ClassDef *cd, GraphType t)
	~DotClassGraph () override
bool	isTrivial () const
bool	isTooBig () const
int	numNodes () const
QCString	writeGraph (TextStream &t, GraphOutputFormat gf, EmbeddedOutputFormat ef, const QCString &path, const QCString &fileName, const QCString &relPath, bool TBRank=TRUE, bool imageMap=TRUE, int graphId=-1)
void	writeXML (TextStream &t)
void	writeDocbook (TextStream &t)
void	writeDEF (TextStream &t)
Public Member Functions inherited from DotGraph
	DotGraph ()
virtual	~DotGraph ()=default

Protected Member Functions
QCString	getBaseName () const override
QCString	getMapLabel () const override
void	computeTheGraph () override
QCString	getImgAltText () const override
Protected Member Functions inherited from DotGraph
int	getNextNodeNumber ()
	returns the node number.
int	getNextEdgeNumber ()
	returns the edge number.
QCString	writeGraph (TextStream &t, GraphOutputFormat gf, EmbeddedOutputFormat ef, const QCString &path, const QCString &fileName, const QCString &relPath, bool writeImageMap=TRUE, int graphId=-1)
virtual QCString	absMapName () const
QCString	absBaseName () const
QCString	absDotName () const
QCString	imgName () const
QCString	absImgName () const
QCString	relImgName () const

Private Member Functions
void	buildGraph (const ClassDef *cd, DotNode *n, bool base, int distance)
bool	determineVisibleNodes (DotNode *rootNode, int maxNodes, bool includeParents)
void	determineTruncatedNodes (DotNodeDeque &queue, bool includeParents)
void	addClass (const ClassDef *cd, DotNode *n, EdgeInfo::Colors color, const QCString &label, const QCString &usedName, const QCString &templSpec, bool base, int distance)

Private Attributes
DotNode *	m_startNode
DotNodeMap	m_usedNodes
GraphType	m_graphType
QCString	m_collabFileName
QCString	m_inheritFileName
bool	m_lrRank

Additional Inherited Members
Static Protected Member Functions inherited from DotGraph
static void	writeGraphHeader (TextStream &t, const QCString &title=QCString())
static void	writeGraphFooter (TextStream &t)
static void	computeGraph (DotNode *root, GraphType gt, GraphOutputFormat format, const QCString &rank, bool renderParents, bool backArrows, const QCString &title, QCString &graphStr)
Protected Attributes inherited from DotGraph
GraphOutputFormat	m_graphFormat = GraphOutputFormat::BITMAP
EmbeddedOutputFormat	m_textFormat = EmbeddedOutputFormat::Html
Dir	m_dir
QCString	m_fileName
QCString	m_relPath
bool	m_generateImageMap = false
int	m_graphId = 0
QCString	m_absPath
QCString	m_baseName
QCString	m_theGraph
bool	m_regenerate = false
bool	m_doNotAddImageToIndex = false
bool	m_noDivTag = false
bool	m_zoomable = true
bool	m_urlOnly = false

Detailed Description

Representation of a class inheritance or dependency graph.

Definition at line 28 of file dotclassgraph.h.

Constructor & Destructor Documentation

DotClassGraph()

DotClassGraph::DotClassGraph	(	const ClassDef *	cd,
		GraphType	t )

Definition at line 316 of file dotclassgraph.cpp.

{
  //printf("--------------- DotClassGraph::DotClassGraph '%s'\n",qPrint(cd->displayName()));
  m_graphType = t;
  QCString tmp_url="";
  if (cd->isLinkable() && !cd->isHidden())
  {
    tmp_url=cd->getReference()+"$"+cd->getOutputFileBase();
    if (!cd->anchor().isEmpty())
    {
      tmp_url+="#"+cd->anchor();
    }
  }
  QCString className = cd->displayName();
  QCString tooltip = cd->briefDescriptionAsTooltip();
  m_startNode = new DotNode(this,
    className,
    tooltip,
    tmp_url,
    TRUE,                      // is a root node
    cd
  );
  m_startNode->setDistance(0);
  m_usedNodes.emplace(className.str(),m_startNode);
 
  buildGraph(cd,m_startNode,TRUE,1);
  if (t==GraphType::Inheritance) buildGraph(cd,m_startNode,FALSE,1);
 
  m_lrRank = determineVisibleNodes(m_startNode,Config_getInt(DOT_GRAPH_MAX_NODES),t==GraphType::Inheritance);
  DotNodeDeque openNodeQueue;
  openNodeQueue.push_back(m_startNode);
  determineTruncatedNodes(openNodeQueue,t==GraphType::Inheritance);
 
  m_collabFileName = cd->collaborationGraphFileName();
  m_inheritFileName = cd->inheritanceGraphFileName();
}

References Definition::anchor(), Definition::briefDescriptionAsTooltip(), buildGraph(), ClassDef::collaborationGraphFileName(), Config_getInt, determineTruncatedNodes(), determineVisibleNodes(), Definition::displayName(), DotGraph::DotNode, FALSE, Definition::getOutputFileBase(), Definition::getReference(), Inheritance, ClassDef::inheritanceGraphFileName(), QCString::isEmpty(), Definition::isHidden(), Definition::isLinkable(), m_collabFileName, m_graphType, m_inheritFileName, m_lrRank, m_startNode, m_usedNodes, QCString::str(), and TRUE.

~DotClassGraph()

DotClassGraph::~DotClassGraph ( )

override

Definition at line 377 of file dotclassgraph.cpp.

{
  DotNode::deleteNodes(m_startNode);
}

References DotNode::deleteNodes(), and m_startNode.

Member Function Documentation

addClass()

void DotClassGraph::addClass ( const ClassDef * cd, DotNode * n, EdgeInfo::Colors color, const QCString & label, const QCString & usedName, const QCString & templSpec, bool base, int distance )

private

Definition at line 26 of file dotclassgraph.cpp.

{
  if (Config_getBool(HIDE_UNDOC_CLASSES) && !cd->isLinkable()) return;
 
  EdgeInfo::Styles edgeStyle = (!label.isEmpty() || color==EdgeInfo::Orange || color==EdgeInfo::Orange2) ? EdgeInfo::Dashed : EdgeInfo::Solid;
  QCString className;
  QCString fullName;
  if (cd->isAnonymous())
  {
    className="anonymous:";
    className+=label;
    fullName = className;
  }
  else if (!usedName.isEmpty()) // name is a typedef
  {
    className=usedName;
    fullName = className;
  }
  else if (!templSpec.isEmpty()) // name has a template part
  {
    className=insertTemplateSpecifierInScope(cd->displayName(),templSpec);
    fullName =insertTemplateSpecifierInScope(cd->name(),templSpec);
  }
  else // just a normal name
  {
    className=cd->displayName();
    fullName = cd->name();
  }
  //printf("DotClassGraph::addClass(class='%s',parent=%s,prot=%d,label=%s,dist=%d,usedName=%s,templSpec=%s,base=%d)\n",
  //                                 qPrint(className),qPrint(n->label()),prot,label,distance,usedName,templSpec,base);
  auto it = m_usedNodes.find(fullName.str());
  if (it!=m_usedNodes.end()) // class already inserted
  {
    DotNode *bn = it->second;
    if (base)
    {
      n->addChild(bn,color,edgeStyle,label);
      bn->addParent(n);
    }
    else
    {
      bn->addChild(n,color,edgeStyle,label);
      n->addParent(bn);
    }
    bn->setDistance(distance);
    //printf(" add exiting node %s of %s\n",qPrint(bn->label()),qPrint(n->label()));
  }
  else // new class
  {
    QCString displayName=className;
    if (Config_getBool(HIDE_SCOPE_NAMES)) displayName=stripScope(displayName);
    QCString tmp_url;
    if (cd->isLinkable() && !cd->isHidden())
    {
      tmp_url=cd->getReference()+"$"+cd->getOutputFileBase();
      if (!cd->anchor().isEmpty())
      {
        tmp_url+="#"+cd->anchor();
      }
    }
    QCString tooltip = cd->briefDescriptionAsTooltip();
    DotNode *bn = new DotNode(this,
      displayName,
      tooltip,
      tmp_url,
      FALSE,        // rootNode
      cd
    );
    if (base)
    {
      n->addChild(bn,color,edgeStyle,label);
      bn->addParent(n);
    }
    else
    {
      bn->addChild(n,color,edgeStyle,label);
      n->addParent(bn);
    }
    bn->setDistance(distance);
    m_usedNodes.emplace(fullName.str(),bn);
    //printf(" add new child node '%s' to %s hidden=%d url=%s\n",
    //    qPrint(className),qPrint(n->label()),cd->isHidden(),qPrint(tmp_url));
 
    buildGraph(cd,bn,base,distance+1);
  }
}

References DotNode::addChild(), DotNode::addParent(), Definition::anchor(), Definition::briefDescriptionAsTooltip(), buildGraph(), Config_getBool, EdgeInfo::Dashed, Definition::displayName(), DotGraph::DotNode, FALSE, Definition::getOutputFileBase(), Definition::getReference(), insertTemplateSpecifierInScope(), Definition::isAnonymous(), QCString::isEmpty(), Definition::isHidden(), Definition::isLinkable(), m_usedNodes, Definition::name(), EdgeInfo::Orange, EdgeInfo::Orange2, DotNode::setDistance(), EdgeInfo::Solid, QCString::str(), and stripScope().

Referenced by buildGraph().

buildGraph()

void DotClassGraph::buildGraph ( const ClassDef * cd, DotNode * n, bool base, int distance )

private

Definition at line 252 of file dotclassgraph.cpp.

{
  //printf("DocClassGraph::buildGraph(%s,distance=%d,base=%d)\n",
  //    qPrint(cd->name()),distance,base);
  // ---- Add inheritance relations
 
  if (m_graphType == GraphType::Inheritance || m_graphType==GraphType::Collaboration)
  {
    for (const auto &bcd : base ? cd->baseClasses() : cd->subClasses())
    {
      //printf("-------- inheritance relation %s->%s templ='%s'\n",
      //            qPrint(cd->name()),qPrint(bcd->classDef->name()),qPrint(bcd->templSpecifiers));
      addClass(bcd.classDef,n,EdgeInfo::protectionToColor(bcd.prot),QCString(),bcd.usedName,bcd.templSpecifiers,base,distance);
    }
  }
  if (m_graphType == GraphType::Collaboration)
  {
    // ---- Add usage relations
 
    const UsesClassList &list = base ? cd->usedImplementationClasses()   :
                                       cd->usedByImplementationClasses() ;
    for (const auto &ucd : list)
    {
      //printf("addClass: %s templSpec=%s\n",qPrint(ucd.classDef->name()),qPrint(ucd.templSpecifiers));
      addClass(ucd.classDef,n,EdgeInfo::Purple,joinLabels(ucd.accessors),QCString(),
          ucd.templSpecifiers,base,distance);
    }
  }
  if (Config_getBool(TEMPLATE_RELATIONS) && base)
  {
    for (const auto &ccd : cd->templateTypeConstraints())
    {
      //printf("addClass: %s\n",qPrint(ccd.classDef->name()));
      addClass(ccd.classDef,n,EdgeInfo::Orange2,joinLabels(ccd.accessors),QCString(),
        QCString(),TRUE,distance);
    }
  }
 
  // ---- Add template instantiation relations
 
  if (Config_getBool(TEMPLATE_RELATIONS))
  {
    if (base) // template relations for base classes
    {
      const ClassDef *templMaster=cd->templateMaster();
      if (templMaster)
      {
        for (const auto &ti : templMaster->getTemplateInstances())
        if (ti.classDef==cd)
        {
          addClass(templMaster,n,EdgeInfo::Orange,ti.templSpec,QCString(),QCString(),TRUE,distance);
        }
      }
    }
    else // template relations for super classes
    {
      for (const auto &ti : cd->getTemplateInstances())
      {
        addClass(ti.classDef,n,EdgeInfo::Orange,ti.templSpec,QCString(),QCString(),FALSE,distance);
      }
    }
  }
}

References addClass(), ClassDef::baseClasses(), Collaboration, Config_getBool, DotGraph::DotNode, FALSE, ClassDef::getTemplateInstances(), Inheritance, joinLabels(), m_graphType, EdgeInfo::Orange, EdgeInfo::Orange2, EdgeInfo::protectionToColor(), EdgeInfo::Purple, ClassDef::subClasses(), ClassDef::templateMaster(), ClassDef::templateTypeConstraints(), TRUE, ClassDef::usedByImplementationClasses(), and ClassDef::usedImplementationClasses().

Referenced by addClass(), and DotClassGraph().

computeTheGraph()

void DotClassGraph::computeTheGraph ( )

overrideprotectedvirtual

Implements DotGraph.

Definition at line 399 of file dotclassgraph.cpp.

{
  computeGraph(
    m_startNode,
    m_graphType,
    m_graphFormat,
    m_lrRank ? "LR" : "",
    m_graphType == GraphType::Inheritance,
    TRUE,
    m_startNode->label(),
    m_theGraph
  );
}

References DotGraph::computeGraph(), Inheritance, DotGraph::m_graphFormat, m_graphType, m_lrRank, m_startNode, DotGraph::m_theGraph, and TRUE.

determineTruncatedNodes()

void DotClassGraph::determineTruncatedNodes ( DotNodeDeque & queue, bool includeParents )

private

Definition at line 114 of file dotclassgraph.cpp.

{
  while (!queue.empty())
  {
    DotNode *n = queue.front();
    queue.pop_front();
    if (n->isVisible() && n->isTruncated()==DotNode::Unknown)
    {
      bool truncated = FALSE;
      for (const auto &dn : n->children())
      {
        if (!dn->isVisible())
          truncated = TRUE;
        else
          queue.push_back(dn);
      }
      if (includeParents)
      {
        for (const auto &dn : n->parents())
        {
          if (!dn->isVisible())
            truncated = TRUE;
          else
            queue.push_back(dn);
        }
      }
      n->markAsTruncated(truncated);
    }
  }
}

References DotNode::children(), DotGraph::DotNode, FALSE, DotNode::isTruncated(), DotNode::isVisible(), DotNode::markAsTruncated(), DotNode::parents(), TRUE, and DotNode::Unknown.

Referenced by DotClassGraph().

determineVisibleNodes()

bool DotClassGraph::determineVisibleNodes ( DotNode * rootNode, int maxNodes, bool includeParents )

private

Definition at line 145 of file dotclassgraph.cpp.

{
  DotNodeDeque childQueue;
  DotNodeDeque parentQueue;
  std::vector<size_t> childTreeWidth;
  std::vector<size_t> parentTreeWidth;
  childQueue.push_back(rootNode);
  if (includeParents) parentQueue.push_back(rootNode);
  bool firstNode=TRUE; // flag to force reprocessing rootNode in the parent loop
                       // despite being marked visible in the child loop
  while ((!childQueue.empty() || !parentQueue.empty()) && maxNodes>0)
  {
    if (!childQueue.empty())
    {
      DotNode *n = childQueue.front();
      childQueue.pop_front();
      size_t distance = n->distance();
      if (!n->isVisible() && distance<=static_cast<size_t>(Config_getInt(MAX_DOT_GRAPH_DEPTH))) // not yet processed
      {
        if (distance>0)
        {
          size_t oldSize=childTreeWidth.size();
          if (distance>oldSize)
          {
            childTreeWidth.resize(std::max(childTreeWidth.size(),distance));
            for (size_t i=oldSize;i<distance;i++) childTreeWidth[i]=0;
          }
          childTreeWidth[distance-1]+=n->label().length();
        }
        n->markAsVisible();
        maxNodes--;
        // add direct children
        for (const auto &dn : n->children())
        {
          childQueue.push_back(dn);
        }
      }
    }
    if (includeParents && !parentQueue.empty())
    {
      DotNode *n = parentQueue.front();
      parentQueue.pop_front();
      if ((!n->isVisible() || firstNode) && n->distance()<=Config_getInt(MAX_DOT_GRAPH_DEPTH)) // not yet processed
      {
        firstNode=FALSE;
        size_t distance = n->distance();
        if (distance>0)
        {
          size_t oldSize = parentTreeWidth.size();
          if (distance>oldSize)
          {
            parentTreeWidth.resize(std::max(parentTreeWidth.size(),distance));
            for (size_t i=oldSize;i<distance;i++) parentTreeWidth[i]=0;
          }
          parentTreeWidth[distance-1]+=n->label().length();
        }
        n->markAsVisible();
        maxNodes--;
        // add direct parents
        for (const auto &dn : n->parents())
        {
          parentQueue.push_back(dn);
        }
      }
    }
  }
  if (Config_getBool(UML_LOOK)) return FALSE; // UML graph are always top to bottom
  size_t maxWidth=0;
  size_t maxHeight=std::max(childTreeWidth.size(),parentTreeWidth.size());
  for (size_t i=0;i<childTreeWidth.size();i++)
  {
    if (childTreeWidth.at(i)>maxWidth) maxWidth=childTreeWidth.at(i);
  }
  for (size_t i=0;i<parentTreeWidth.size();i++)
  {
    if (parentTreeWidth.at(i)>maxWidth) maxWidth=parentTreeWidth.at(i);
  }
  //printf("max tree width=%d, max tree height=%d\n",maxWidth,maxHeight);
  return maxWidth>80 && maxHeight<12; // used metric to decide to render the tree
                                      // from left to right instead of top to bottom,
                                      // with the idea to render very wide trees in
                                      // left to right order.
}

References DotNode::children(), Config_getBool, Config_getInt, DotNode::distance(), DotGraph::DotNode, FALSE, DotNode::isVisible(), DotNode::label(), QCString::length(), DotNode::markAsVisible(), DotNode::parents(), and TRUE.

Referenced by DotClassGraph().

getBaseName()

QCString DotClassGraph::getBaseName ( ) const

overrideprotectedvirtual

Implements DotGraph.

Definition at line 382 of file dotclassgraph.cpp.

{
  switch (m_graphType)
  {
  case GraphType::Collaboration:
    return m_collabFileName;
    break;
  case GraphType::Inheritance:
    return m_inheritFileName;
    break;
  default:
    ASSERT(0);
    break;
  }
  return "";
}

References ASSERT, Collaboration, Inheritance, m_collabFileName, m_graphType, and m_inheritFileName.

getImgAltText()

QCString DotClassGraph::getImgAltText ( ) const

overrideprotectedvirtual

Reimplemented from DotGraph.

Definition at line 432 of file dotclassgraph.cpp.

{
  switch (m_graphType)
  {
  case GraphType::Collaboration:
    return "Collaboration graph";
    break;
  case GraphType::Inheritance:
    return "Inheritance graph";
    break;
  default:
    ASSERT(0);
    break;
  }
  return "";
}

References ASSERT, Collaboration, Inheritance, and m_graphType.

getMapLabel()

QCString DotClassGraph::getMapLabel ( ) const

overrideprotectedvirtual

Implements DotGraph.

Definition at line 413 of file dotclassgraph.cpp.

{
  QCString mapName;
  switch (m_graphType)
  {
  case GraphType::Collaboration:
    mapName="coll_map";
    break;
  case GraphType::Inheritance:
    mapName="inherit_map";
    break;
  default:
    ASSERT(0);
    break;
  }
 
  return escapeCharsInString(m_startNode->label(),FALSE)+"_"+escapeCharsInString(mapName,FALSE);
}

References ASSERT, Collaboration, escapeCharsInString(), FALSE, Inheritance, m_graphType, and m_startNode.

isTooBig()

bool DotClassGraph::isTooBig

(

)

const

Definition at line 361 of file dotclassgraph.cpp.

{
  return numNodes()>=Config_getInt(DOT_GRAPH_MAX_NODES);
}

References Config_getInt, and numNodes().

Referenced by ClassDefImpl::writeCollaborationGraph(), and ClassDefImpl::writeInheritanceGraph().

isTrivial()

bool DotClassGraph::isTrivial

(

)

const

Definition at line 353 of file dotclassgraph.cpp.

{
  if (m_graphType==GraphType::Inheritance)
    return m_startNode->children().empty() && m_startNode->parents().empty();
  else
    return !Config_getBool(UML_LOOK) && m_startNode->children().empty();
}

References Config_getBool, Inheritance, m_graphType, and m_startNode.

Referenced by generateDEFForClass(), PerlModGenerator::generatePerlModForClass(), generateXMLForClass(), ClassDefImpl::writeCollaborationGraph(), and ClassDefImpl::writeInheritanceGraph().

numNodes()

int DotClassGraph::numNodes

(

)

const

Definition at line 366 of file dotclassgraph.cpp.

{
  size_t numNodes = 0;
  numNodes+= m_startNode->children().size();
  if (m_graphType==GraphType::Inheritance)
  {
    numNodes+= m_startNode->parents().size();
  }
  return static_cast<int>(numNodes);
}

References Inheritance, m_graphType, m_startNode, and numNodes().

Referenced by isTooBig(), numNodes(), ClassDefImpl::writeCollaborationGraph(), and ClassDefImpl::writeInheritanceGraph().

writeDEF()

void DotClassGraph::writeDEF

(

TextStream &

t

)

Definition at line 480 of file dotclassgraph.cpp.

{
  for (const auto &[name,node] : m_usedNodes)
  {
    node->writeDEF(t);
  }
}

References m_usedNodes.

Referenced by generateDEFForClass().

writeDocbook()

void DotClassGraph::writeDocbook

(

TextStream &

t

)

Definition at line 472 of file dotclassgraph.cpp.

{
  for (const auto &[name,node] : m_usedNodes)
  {
    node->writeDocbook(t,TRUE);
  }
}

References m_usedNodes, and TRUE.

writeGraph()

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

Definition at line 449 of file dotclassgraph.cpp.

{
  return DotGraph::writeGraph(out, graphFormat, textFormat, path, fileName, relPath, generateImageMap, graphId);
}

References DotGraph::writeGraph().

Referenced by DocbookGenerator::endDotGraph(), HtmlGenerator::endDotGraph(), LatexGenerator::endDotGraph(), and RTFGenerator::endDotGraph().

writeXML()

void DotClassGraph::writeXML

(

TextStream &

t

)

Definition at line 464 of file dotclassgraph.cpp.

{
  for (const auto &[name,node] : m_usedNodes)
  {
    node->writeXML(t,TRUE);
  }
}

References m_usedNodes, and TRUE.

Referenced by generateXMLForClass().

Member Data Documentation

m_collabFileName

QCString DotClassGraph::m_collabFileName

private

Definition at line 63 of file dotclassgraph.h.

Referenced by DotClassGraph(), and getBaseName().

m_graphType

GraphType DotClassGraph::m_graphType

private

Definition at line 62 of file dotclassgraph.h.

Referenced by buildGraph(), computeTheGraph(), DotClassGraph(), getBaseName(), getImgAltText(), getMapLabel(), isTrivial(), and numNodes().

m_inheritFileName

QCString DotClassGraph::m_inheritFileName

private

Definition at line 64 of file dotclassgraph.h.

Referenced by DotClassGraph(), and getBaseName().

m_lrRank

bool DotClassGraph::m_lrRank

private

Definition at line 65 of file dotclassgraph.h.

Referenced by computeTheGraph(), and DotClassGraph().

m_startNode

DotNode* DotClassGraph::m_startNode

private

Definition at line 60 of file dotclassgraph.h.

Referenced by computeTheGraph(), DotClassGraph(), getMapLabel(), isTrivial(), numNodes(), and ~DotClassGraph().

m_usedNodes

DotNodeMap DotClassGraph::m_usedNodes

private

Definition at line 61 of file dotclassgraph.h.

Referenced by addClass(), DotClassGraph(), writeDEF(), writeDocbook(), and writeXML().

---

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

• src/dotclassgraph.h
• src/dotclassgraph.cpp