LCOV - code coverage report
Current view: top level - include/llvm/Support - DOTGraphTraits.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 7 9 77.8 %
Date: 2017-09-14 15:23:50 Functions: 0 0 -
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-- llvm/Support/DotGraphTraits.h - Customize .dot output ---*- C++ -*-===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : //
      10             : // This file defines a template class that can be used to customize dot output
      11             : // graphs generated by the GraphWriter.h file.  The default implementation of
      12             : // this file will produce a simple, but not very polished graph.  By
      13             : // specializing this template, lots of customization opportunities are possible.
      14             : //
      15             : //===----------------------------------------------------------------------===//
      16             : 
      17             : #ifndef LLVM_SUPPORT_DOTGRAPHTRAITS_H
      18             : #define LLVM_SUPPORT_DOTGRAPHTRAITS_H
      19             : 
      20             : #include <string>
      21             : 
      22             : namespace llvm {
      23             : 
      24             : /// DefaultDOTGraphTraits - This class provides the default implementations of
      25             : /// all of the DOTGraphTraits methods.  If a specialization does not need to
      26             : /// override all methods here it should inherit so that it can get the default
      27             : /// implementations.
      28             : ///
      29             : struct DefaultDOTGraphTraits {
      30             : private:
      31             :   bool IsSimple;
      32             : 
      33             : protected:
      34             :   bool isSimple() {
      35          22 :     return IsSimple;
      36             :   }
      37             : 
      38             : public:
      39           8 :   explicit DefaultDOTGraphTraits(bool simple=false) : IsSimple (simple) {}
      40             : 
      41             :   /// getGraphName - Return the label for the graph as a whole.  Printed at the
      42             :   /// top of the graph.
      43             :   ///
      44             :   template<typename GraphType>
      45           0 :   static std::string getGraphName(const GraphType &) { return ""; }
      46             : 
      47             :   /// getGraphProperties - Return any custom properties that should be included
      48             :   /// in the top level graph structure for dot.
      49             :   ///
      50             :   template<typename GraphType>
      51             :   static std::string getGraphProperties(const GraphType &) {
      52           4 :     return "";
      53             :   }
      54             : 
      55             :   /// renderGraphFromBottomUp - If this function returns true, the graph is
      56             :   /// emitted bottom-up instead of top-down.  This requires graphviz 2.0 to work
      57             :   /// though.
      58             :   static bool renderGraphFromBottomUp() {
      59             :     return false;
      60             :   }
      61             : 
      62             :   /// isNodeHidden - If the function returns true, the given node is not
      63             :   /// displayed in the graph.
      64             :   static bool isNodeHidden(const void *) {
      65             :     return false;
      66             :   }
      67             : 
      68             :   /// getNodeLabel - Given a node and a pointer to the top level graph, return
      69             :   /// the label to print in the node.
      70             :   template<typename GraphType>
      71             :   std::string getNodeLabel(const void *, const GraphType &) {
      72             :     return "";
      73             :   }
      74             : 
      75             :   // getNodeIdentifierLabel - Returns a string representing the
      76             :   // address or other unique identifier of the node. (Only used if
      77             :   // non-empty.)
      78             :   template <typename GraphType>
      79             :   static std::string getNodeIdentifierLabel(const void *, const GraphType &) {
      80          22 :     return "";
      81             :   }
      82             : 
      83             :   template<typename GraphType>
      84             :   static std::string getNodeDescription(const void *, const GraphType &) {
      85          22 :     return "";
      86             :   }
      87             : 
      88             :   /// If you want to specify custom node attributes, this is the place to do so
      89             :   ///
      90             :   template<typename GraphType>
      91             :   static std::string getNodeAttributes(const void *,
      92             :                                        const GraphType &) {
      93          22 :     return "";
      94             :   }
      95             : 
      96             :   /// If you want to override the dot attributes printed for a particular edge,
      97             :   /// override this method.
      98             :   template<typename EdgeIter, typename GraphType>
      99             :   static std::string getEdgeAttributes(const void *, EdgeIter,
     100             :                                        const GraphType &) {
     101           0 :     return "";
     102             :   }
     103             : 
     104             :   /// getEdgeSourceLabel - If you want to label the edge source itself,
     105             :   /// implement this method.
     106             :   template<typename EdgeIter>
     107             :   static std::string getEdgeSourceLabel(const void *, EdgeIter) {
     108          40 :     return "";
     109             :   }
     110             : 
     111             :   /// edgeTargetsEdgeSource - This method returns true if this outgoing edge
     112             :   /// should actually target another edge source, not a node.  If this method is
     113             :   /// implemented, getEdgeTarget should be implemented.
     114             :   template<typename EdgeIter>
     115             :   static bool edgeTargetsEdgeSource(const void *, EdgeIter) {
     116             :     return false;
     117             :   }
     118             : 
     119             :   /// getEdgeTarget - If edgeTargetsEdgeSource returns true, this method is
     120             :   /// called to determine which outgoing edge of Node is the target of this
     121             :   /// edge.
     122             :   template<typename EdgeIter>
     123             :   static EdgeIter getEdgeTarget(const void *, EdgeIter I) {
     124             :     return I;
     125             :   }
     126             : 
     127             :   /// hasEdgeDestLabels - If this function returns true, the graph is able
     128             :   /// to provide labels for edge destinations.
     129             :   static bool hasEdgeDestLabels() {
     130             :     return false;
     131             :   }
     132             : 
     133             :   /// numEdgeDestLabels - If hasEdgeDestLabels, this function returns the
     134             :   /// number of incoming edge labels the given node has.
     135             :   static unsigned numEdgeDestLabels(const void *) {
     136             :     return 0;
     137             :   }
     138             : 
     139             :   /// getEdgeDestLabel - If hasEdgeDestLabels, this function returns the
     140             :   /// incoming edge label with the given index in the given node.
     141             :   static std::string getEdgeDestLabel(const void *, unsigned) {
     142             :     return "";
     143             :   }
     144             : 
     145             :   /// addCustomGraphFeatures - If a graph is made up of more than just
     146             :   /// straight-forward nodes and edges, this is the place to put all of the
     147             :   /// custom stuff necessary.  The GraphWriter object, instantiated with your
     148             :   /// GraphType is passed in as an argument.  You may call arbitrary methods on
     149             :   /// it to add things to the output graph.
     150             :   ///
     151             :   template<typename GraphType, typename GraphWriter>
     152             :   static void addCustomGraphFeatures(const GraphType &, GraphWriter &) {}
     153             : };
     154             : 
     155             : 
     156             : /// DOTGraphTraits - Template class that can be specialized to customize how
     157             : /// graphs are converted to 'dot' graphs.  When specializing, you may inherit
     158             : /// from DefaultDOTGraphTraits if you don't need to override everything.
     159             : ///
     160             : template <typename Ty>
     161             : struct DOTGraphTraits : public DefaultDOTGraphTraits {
     162             :   DOTGraphTraits (bool simple=false) : DefaultDOTGraphTraits (simple) {}
     163             : };
     164             : 
     165             : } // End llvm namespace
     166             : 
     167             : #endif

Generated by: LCOV version 1.13