DotGfxHierarchyTable Class Reference

Represents a graphical class hierarchy. More...

#include <src/dotgfxhierarchytable.h>

Inheritance diagram for DotGfxHierarchyTable:

Collaboration diagram for DotGfxHierarchyTable:

Public Member Functions
	DotGfxHierarchyTable (const QCString &prefix="", ClassDef::CompoundType ct=ClassDef::Class)
	~DotGfxHierarchyTable () override=default
void	createGraph (DotNode *rootNode, TextStream &t, const QCString &path, const QCString &fileName, int id)
void	writeGraph (TextStream &t, const QCString &path, const QCString &fileName)
const std::vector< DotNode * >	subGraphs () const
Public Member Functions inherited from DotGraph
	DotGraph ()
virtual	~DotGraph ()=default

Protected Member Functions
QCString	getBaseName () const override
QCString	getMapLabel () const override
void	computeTheGraph () 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
virtual QCString	getImgAltText () const
QCString	absBaseName () const
QCString	absDotName () const
QCString	imgName () const
QCString	absImgName () const
QCString	relImgName () const

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

Private Member Functions
void	addHierarchy (DotNode *n, const ClassDef *cd, ClassDefSet &visited)
void	addClassList (const ClassLinkedMap &cl, ClassDefSet &visited)

Private Attributes
int	m_graphId
QCString	m_prefix
ClassDef::CompoundType	m_classType
std::vector< DotNode * >	m_rootNodes
DotNodeMap	m_usedNodes
std::vector< DotNode * >	m_rootSubgraphs
DotNode *	m_rootSubgraphNode

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

Represents a graphical class hierarchy.

Definition at line 31 of file dotgfxhierarchytable.h.

Member Typedef Documentation

DotNodeMap

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

private

Definition at line 52 of file dotgfxhierarchytable.h.

Constructor & Destructor Documentation

DotGfxHierarchyTable()

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

Definition at line 226 of file dotgfxhierarchytable.cpp.

  : m_prefix(prefix)
  , m_classType(ct)
{
  // build a graph with each class as a node and the inheritance relations
  // as edges
  ClassDefSet visitedClasses;
  addClassList(*Doxygen::classLinkedMap,visitedClasses);
  addClassList(*Doxygen::hiddenClassLinkedMap,visitedClasses);
  // m_usedNodes now contains all nodes in the graph
 
  // color the graph into a set of independent subgraphs
  bool done=FALSE;
  int curColor=0;
  while (!done) // there are still nodes to color
  {
    done=TRUE; // we are done unless there are still uncolored nodes
    for (auto n : m_rootNodes)
    {
      if (n->subgraphId()==-1) // not yet colored
      {
        //printf("Starting at node %s (%p): %d\n",qPrint(n->label()),n,curColor);
        done=FALSE; // still uncolored nodes
        n->setSubgraphId(curColor);
        n->markAsVisible();
        n->colorConnectedNodes(curColor);
        curColor++;
        m_rootSubgraphs.push_back(n);
      }
    }
  }
 
  //printf("Number of independent subgraphs: %d\n",curColor);
  for (auto n : m_rootSubgraphs)
  {
    //printf("Node %s color=%d (c=%d,p=%d)\n",
    //    qPrint(n->label()),n->m_subgraphId,
    //    n->children()?n->children()->count():0,
    //    n->parents()?n->parents()->count():0);
    int number=0;
    n->renumberNodes(number);
  }
}

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

Referenced by ~DotGfxHierarchyTable().

~DotGfxHierarchyTable()

DotGfxHierarchyTable::~DotGfxHierarchyTable ( )

overridedefault

References DotGfxHierarchyTable(), and DotGraph::DotNode.

Member Function Documentation

addClassList()

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

private

Definition at line 179 of file dotgfxhierarchytable.cpp.

{
  for (const auto &cd : cl)
  {
    //printf("Trying %s subClasses=%d\n",qPrint(cd->name()),cd->subClasses()->count());
    if (cd->getLanguage()==SrcLangExt::VHDL &&
      VhdlDocGen::convert(cd->protection())!=VhdlDocGen::ENTITYCLASS
      )
    {
      continue;
    }
    if (Config_getBool(OPTIMIZE_OUTPUT_SLICE) && cd->compoundType() != m_classType)
    {
      continue;
    }
    if (!classHasVisibleRoot(cd->baseClasses()) &&
      cd->isVisibleInHierarchy()
      ) // root node in the forest
    {
      QCString tmp_url="";
      if (cd->isLinkable() && !cd->isHidden())
      {
        tmp_url=cd->getReference()+"$"+cd->getOutputFileBase();
        if (!cd->anchor().isEmpty())
        {
          tmp_url+="#"+cd->anchor();
        }
      }
      //printf("Inserting root class %s\n",qPrint(cd->name()));
      QCString tooltip = cd->briefDescriptionAsTooltip();
      auto n = std::make_unique<DotNode>(this,
        cd->displayName(),
        tooltip,
        tmp_url);
      DotNode *root = n.get();
 
      m_usedNodes.emplace(cd->name().str(),std::move(n));
      m_rootNodes.push_back(root);
      if (visitedClasses.find(cd.get())==visitedClasses.end() && !cd->subClasses().empty())
      {
        addHierarchy(root,cd.get(),visitedClasses);
        visitedClasses.insert(cd.get());
      }
    }
  }
}

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

Referenced by DotGfxHierarchyTable().

addHierarchy()

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

private

Definition at line 105 of file dotgfxhierarchytable.cpp.

{
  //printf("addHierarchy '%s' baseClasses=%d\n",qPrint(cd->name()),cd->baseClasses()->count());
  for (const auto &bcd : cd->subClasses())
  {
    ClassDef *bClass=bcd.classDef;
    //printf("  Trying sub class='%s' usedNodes=%d\n",qPrint(bClass->name()),m_usedNodes->count());
    if (bClass && bClass->isVisibleInHierarchy() && classHasVisibleRoot(bClass->baseClasses()))
    {
      auto it = m_usedNodes.find(bClass->name().str());
      //printf("  Node '%s' Found visible class='%s'\n",qPrint(n->label()),
      //                                              qPrint(bClass->name()));
      DotNode *root = nullptr;
      if (it!=m_usedNodes.end()) // node already present
      {
        const auto &bn = it->second;
        root = bn.get();
        const auto &children = n->children();
        auto child_it = std::find(children.begin(),children.end(),bn.get());
        if (child_it==children.end()) // no arrow yet
        {
          n->addChild(bn.get(),EdgeInfo::protectionToColor(bcd.prot));
          bn->addParent(n);
          //printf("  Adding node %s to existing base node %s (c=%d,p=%d)\n",
          //       qPrint(n->label()),
          //       qPrint(bn->label()),
          //       bn->children() ? bn->children()->count() : 0,
          //       bn->parents()  ? bn->parents()->count()  : 0
          //     );
        }
        //else
        //{
        //  printf("  Class already has an arrow!\n");
        //}
      }
      else
      {
        QCString tmp_url="";
        if (bClass->isLinkable() && !bClass->isHidden())
        {
          tmp_url=bClass->getReference()+"$"+bClass->getOutputFileBase();
          if (!bClass->anchor().isEmpty())
          {
            tmp_url+="#"+bClass->anchor();
          }
        }
        QCString tooltip = bClass->briefDescriptionAsTooltip();
        auto bn = std::make_unique<DotNode>(this,
            bClass->displayName(),
            tooltip,
            tmp_url
            );
        n->addChild(bn.get(),EdgeInfo::protectionToColor(bcd.prot));
        bn->addParent(n);
        root = bn.get();
        //printf("  Adding node %s to new base node %s (c=%d,p=%d)\n",
        //   qPrint(n->label()),
        //   qPrint(bn->label()),
        //   bn->children() ? bn->children()->count() : 0,
        //   bn->parents()  ? bn->parents()->count()  : 0
        //  );
        //printf("  inserting %s (%p)\n",qPrint(bClass->name()),bn);
        m_usedNodes.emplace(bClass->name().str(),std::move(bn)); // add node to the used list
      }
      if (visitedClasses.find(bClass)==visitedClasses.end() && !bClass->subClasses().empty())
      {
        visitedClasses.insert(bClass);
        addHierarchy(root,bClass,visitedClasses);
      }
    }
  }
  //printf("end addHierarchy\n");
}

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().

computeTheGraph()

void DotGfxHierarchyTable::computeTheGraph ( )

overrideprotectedvirtual

Implements DotGraph.

Definition at line 37 of file dotgfxhierarchytable.cpp.

{
  TextStream md5stream;
  writeGraphHeader(md5stream,theTranslator->trGraphicalHierarchy());
  md5stream << "  rankdir=\"LR\";\n";
  for (auto node : m_rootNodes)
  {
    if (node->subgraphId()==m_rootSubgraphNode->subgraphId())
    {
      node->clearWriteFlag();
    }
  }
  for (auto node : m_rootNodes)
  {
    if (node->subgraphId()==m_rootSubgraphNode->subgraphId())
    {
      node->write(md5stream,GraphType::Hierarchy,GraphOutputFormat::BITMAP,FALSE,TRUE,TRUE);
    }
  }
  writeGraphFooter(md5stream);
  m_theGraph = md5stream.str();
}

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

createGraph()

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

Definition at line 65 of file dotgfxhierarchytable.cpp.

{
  m_rootSubgraphNode = n;
  m_graphId = id;
  m_noDivTag = TRUE;
  m_zoomable = FALSE;
  DotGraph::writeGraph(out, GraphOutputFormat::BITMAP, EmbeddedOutputFormat::Html, path, fileName, "", TRUE, 0);
}

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

Referenced by writeGraph().

getBaseName()

QCString DotGfxHierarchyTable::getBaseName ( ) const

overrideprotectedvirtual

Implements DotGraph.

Definition at line 27 of file dotgfxhierarchytable.cpp.

{
  QCString baseName;
  if (m_prefix.isEmpty())
    baseName.sprintf("inherit_graph_%d", m_graphId);
  else
    baseName.sprintf("%sinherit_graph_%d",qPrint(m_prefix), m_graphId);
  return baseName;
}

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

getMapLabel()

QCString DotGfxHierarchyTable::getMapLabel ( ) const

overrideprotectedvirtual

Implements DotGraph.

Definition at line 60 of file dotgfxhierarchytable.cpp.

{
  return escapeCharsInString(m_rootSubgraphNode->label(),FALSE);
}

References escapeCharsInString(), FALSE, and m_rootSubgraphNode.

subGraphs()

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

inline

Definition at line 41 of file dotgfxhierarchytable.h.

{ return m_rootSubgraphs; }

References m_rootSubgraphs.

writeGraph()

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

Definition at line 75 of file dotgfxhierarchytable.cpp.

{
  //printf("DotGfxHierarchyTable::writeGraph(%s)\n",name);
  //printf("m_rootNodes=%p count=%d\n",m_rootNodes,m_rootNodes->count());
 
  if (m_rootSubgraphs.empty()) return;
 
  Dir d(path.str());
  // store the original directory
  if (!d.exists())
  {
    term("Output dir %s does not exist!\n",qPrint(path));
  }
 
  // put each connected subgraph of the hierarchy in a row of the HTML output
  out << "<table border=\"0\" cellspacing=\"10\" cellpadding=\"0\">\n";
 
  int count=0;
  std::stable_sort(m_rootSubgraphs.begin(),m_rootSubgraphs.end(),
            [](auto n1,auto n2) { return qstricmp_sort(n1->label(),n2->label())<0; });
  for (auto n : m_rootSubgraphs)
  {
    out << "<tr><td>";
    createGraph(n,out,path,fileName,count++);
    out << "</td></tr>\n";
  }
  out << "</table>\n";
}

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

Referenced by HtmlGenerator::writeGraphicalHierarchy().

Member Data Documentation

m_classType

ClassDef::CompoundType DotGfxHierarchyTable::m_classType

private

Definition at line 55 of file dotgfxhierarchytable.h.

Referenced by addClassList(), and DotGfxHierarchyTable().

m_graphId

int DotGfxHierarchyTable::m_graphId

private

Definition at line 53 of file dotgfxhierarchytable.h.

Referenced by createGraph(), and getBaseName().

m_prefix

QCString DotGfxHierarchyTable::m_prefix

private

Definition at line 54 of file dotgfxhierarchytable.h.

Referenced by DotGfxHierarchyTable(), and getBaseName().

m_rootNodes

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

private

Definition at line 56 of file dotgfxhierarchytable.h.

Referenced by addClassList(), computeTheGraph(), and DotGfxHierarchyTable().

m_rootSubgraphNode

DotNode* DotGfxHierarchyTable::m_rootSubgraphNode

private

Definition at line 59 of file dotgfxhierarchytable.h.

Referenced by computeTheGraph(), createGraph(), and getMapLabel().

m_rootSubgraphs

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

private

Definition at line 58 of file dotgfxhierarchytable.h.

Referenced by DotGfxHierarchyTable(), subGraphs(), and writeGraph().

m_usedNodes

DotNodeMap DotGfxHierarchyTable::m_usedNodes

private

Definition at line 57 of file dotgfxhierarchytable.h.

Referenced by addClassList(), and addHierarchy().

---

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

• src/dotgfxhierarchytable.h
• src/dotgfxhierarchytable.cpp