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

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ DotClassGraph()

◆ ~DotClassGraph()

Member Function Documentation

◆ addClass()

◆ buildGraph()

◆ computeTheGraph()

◆ determineTruncatedNodes()

◆ determineVisibleNodes()

◆ getBaseName()

◆ getImgAltText()

◆ getMapLabel()

◆ isTooBig()

◆ isTrivial()

◆ numNodes()

◆ writeDEF()

◆ writeDocbook()

◆ writeGraph()

◆ writeXML()

Member Data Documentation

◆ m_collabFileName

◆ m_graphType

◆ m_inheritFileName

◆ m_lrRank

◆ m_startNode

◆ m_usedNodes