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
DString	writeGraph (TextStream &t, GraphOutputFormat gf, EmbeddedOutputFormat ef, const DString &path, const DString &fileName, const DString &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
DString	getBaseName () const override
DString	getMapLabel () const override
void	computeTheGraph () override
DString	getImgAltText () const override
Protected Member Functions inherited from DotGraph
int	getNextNodeNumber ()
	returns the node number.
int	getNextEdgeNumber ()
	returns the edge number.
DString	writeGraph (TextStream &t, GraphOutputFormat gf, EmbeddedOutputFormat ef, const DString &path, const DString &fileName, const DString &relPath, bool writeImageMap=true, int graphId=-1)
virtual DString	absMapName () const
DString	absBaseName () const
DString	absDotName () const
DString	imgName () const
DString	absImgName () const
DString	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 DString &label, const DString &usedName, const DString &templSpec, bool base, int distance)

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

Additional Inherited Members
Static Protected Member Functions inherited from DotGraph
static void	writeGraphHeader (TextStream &t, const DString &title=DString())
static void	writeGraphFooter (TextStream &t)
static void	computeGraph (DotNode *root, GraphType gt, GraphOutputFormat format, const DString &rank, bool renderParents, bool backArrows, const DString &title, DString &graphStr)
Protected Attributes inherited from DotGraph
GraphOutputFormat	m_graphFormat = GraphOutputFormat::BITMAP
EmbeddedOutputFormat	m_textFormat = EmbeddedOutputFormat::Html
Dir	m_dir
DString	m_fileName
DString	m_relPath
bool	m_generateImageMap = false
int	m_graphId = 0
DString	m_absPath
DString	m_baseName
DString	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 29 of file dotclassgraph.h.

Constructor & Destructor Documentation

DotClassGraph()

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

Definition at line 317 of file dotclassgraph.cpp.

{
  //printf("--------------- DotClassGraph::DotClassGraph '%s'\n",qPrint(cd->displayName()));
  m_graphType = t;
  DString tmp_url="";
  if (cd->isLinkable() && !cd->isHidden())
  {
    tmp_url=cd->getReference()+"$"+cd->getOutputFileBase();
    if (!cd->anchor().empty())
    {
      tmp_url+="#"+cd->anchor();
    }
  }
  DString className = cd->displayName();
  DString 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(), DotNode::DotNode(), DString::empty(), Definition::getOutputFileBase(), Definition::getReference(), Inheritance, ClassDef::inheritanceGraphFileName(), Definition::isHidden(), Definition::isLinkable(), m_collabFileName, m_graphType, m_inheritFileName, m_lrRank, m_startNode, m_usedNodes, DotNode::setDistance(), and DString::str().

~DotClassGraph()

DotClassGraph::~DotClassGraph ( )

override

Definition at line 378 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 DString & label, const DString & usedName, const DString & templSpec, bool base, int distance )

private

Definition at line 27 of file dotclassgraph.cpp.

{
  if (Config_getBool(HIDE_UNDOC_CLASSES) && !cd->isLinkable()) return;
 
  EdgeInfo::Styles edgeStyle = (!label.empty() || color==EdgeInfo::Orange || color==EdgeInfo::Orange2) ? EdgeInfo::Dashed : EdgeInfo::Solid;
  DString className;
  DString fullName;
  if (cd->isAnonymous())
  {
    className="anonymous:";
    className+=label;
    fullName = className;
  }
  else if (!usedName.empty()) // name is a typedef
  {
    className=usedName;
    fullName = className;
  }
  else if (!templSpec.empty()) // 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
  {
    DString displayName=className;
    if (Config_getBool(HIDE_SCOPE_NAMES)) displayName=stripScope(displayName);
    DString tmp_url;
    if (cd->isLinkable() && !cd->isHidden())
    {
      tmp_url=cd->getReference()+"$"+cd->getOutputFileBase();
      if (!cd->anchor().empty())
      {
        tmp_url+="#"+cd->anchor();
      }
    }
    DString 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, DotNode::DotNode(), DString::empty(), Definition::getOutputFileBase(), Definition::getReference(), insertTemplateSpecifierInScope(), Definition::isAnonymous(), Definition::isHidden(), Definition::isLinkable(), m_usedNodes, Definition::name(), EdgeInfo::Orange, EdgeInfo::Orange2, DotNode::setDistance(), EdgeInfo::Solid, DString::str(), and stripScope().

Referenced by buildGraph().

buildGraph()

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

private

Definition at line 253 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),DString(),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),DString(),
          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),DString(),
        DString(),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,DString(),DString(),true,distance);
        }
      }
    }
    else // template relations for super classes
    {
      for (const auto &ti : cd->getTemplateInstances())
      {
        addClass(ti.classDef,n,EdgeInfo::Orange,ti.templSpec,DString(),DString(),false,distance);
      }
    }
  }
}

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

Referenced by addClass(), and DotClassGraph().

computeTheGraph()

void DotClassGraph::computeTheGraph ( )

overrideprotectedvirtual

Implements DotGraph.

Definition at line 400 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, DotNode::label(), DotGraph::m_graphFormat, m_graphType, m_lrRank, m_startNode, and DotGraph::m_theGraph.

determineTruncatedNodes()

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

private

Definition at line 115 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, DotNode::isTruncated(), DotNode::isVisible(), DotNode::markAsTruncated(), DotNode::parents(), and DotNode::Unknown.

Referenced by DotClassGraph().

determineVisibleNodes()

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

private

Definition at line 146 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, DotNode::isVisible(), DotNode::label(), DString::length(), DotNode::markAsVisible(), and DotNode::parents().

Referenced by DotClassGraph().

getBaseName()

DString DotClassGraph::getBaseName ( ) const

overrideprotectedvirtual

Implements DotGraph.

Definition at line 383 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()

DString DotClassGraph::getImgAltText ( ) const

overrideprotectedvirtual

Reimplemented from DotGraph.

Definition at line 433 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()

DString DotClassGraph::getMapLabel ( ) const

overrideprotectedvirtual

Implements DotGraph.

Definition at line 414 of file dotclassgraph.cpp.

{
  DString 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(), Inheritance, DotNode::label(), m_graphType, and m_startNode.

isTooBig()

bool DotClassGraph::isTooBig

(

)

const

Definition at line 362 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 354 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 DotNode::children(), Config_getBool, Inheritance, m_graphType, m_startNode, and DotNode::parents().

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

numNodes()

int DotClassGraph::numNodes

(

)

const

Definition at line 367 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 DotNode::children(), Inheritance, m_graphType, m_startNode, numNodes(), and DotNode::parents().

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

writeDEF()

void DotClassGraph::writeDEF

(

TextStream &

t

)

Definition at line 483 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 475 of file dotclassgraph.cpp.

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

References m_usedNodes.

writeGraph()

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

Definition at line 450 of file dotclassgraph.cpp.

{
  m_doNotAddImageToIndex = textFormat!=EmbeddedOutputFormat::Html;
 
  return DotGraph::writeGraph(out, graphFormat, textFormat, path, fileName, relPath, generateImageMap, graphId);
}

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

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

writeXML()

void DotClassGraph::writeXML

(

TextStream &

t

)

Definition at line 467 of file dotclassgraph.cpp.

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

References m_usedNodes.

Referenced by generateXMLForClass().

Member Data Documentation

m_collabFileName

DString DotClassGraph::m_collabFileName

private

Definition at line 64 of file dotclassgraph.h.

Referenced by DotClassGraph(), and getBaseName().

m_graphType

GraphType DotClassGraph::m_graphType

private

Definition at line 63 of file dotclassgraph.h.

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

m_inheritFileName

DString DotClassGraph::m_inheritFileName

private

Definition at line 65 of file dotclassgraph.h.

Referenced by DotClassGraph(), and getBaseName().

m_lrRank

bool DotClassGraph::m_lrRank

private

Definition at line 66 of file dotclassgraph.h.

Referenced by computeTheGraph(), and DotClassGraph().

m_startNode

DotNode* DotClassGraph::m_startNode

private

Definition at line 61 of file dotclassgraph.h.

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

m_usedNodes

DotNodeMap DotClassGraph::m_usedNodes

private

Definition at line 62 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