Enhance the GraphWriter support for edge destinations, and teach the
[oota-llvm.git] / include / llvm / Support / DOTGraphTraits.h
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   /// getGraphName - Return the label for the graph as a whole.  Printed at the
31   /// top of the graph.
32   ///
33   template<typename GraphType>
34   static std::string getGraphName(const GraphType& Graph) { return ""; }
35
36   /// getGraphProperties - Return any custom properties that should be included
37   /// in the top level graph structure for dot.
38   ///
39   template<typename GraphType>
40   static std::string getGraphProperties(const GraphType& Graph) {
41     return "";
42   }
43
44   /// renderGraphFromBottomUp - If this function returns true, the graph is
45   /// emitted bottom-up instead of top-down.  This requires graphviz 2.0 to work
46   /// though.
47   static bool renderGraphFromBottomUp() {
48     return false;
49   }
50
51   /// getNodeLabel - Given a node and a pointer to the top level graph, return
52   /// the label to print in the node.
53   template<typename GraphType>
54   static std::string getNodeLabel(const void *Node, const GraphType& Graph) {
55     return "";
56   }
57   
58   /// hasNodeAddressLabel - If this method returns true, the address of the node
59   /// is added to the label of the node.
60   template<typename GraphType>
61   static bool hasNodeAddressLabel(const void *Node, const GraphType& Graph) {
62     return false;
63   }
64
65   /// If you want to specify custom node attributes, this is the place to do so
66   ///
67   template<typename GraphType>
68   static std::string getNodeAttributes(const void *Node,
69                                        const GraphType& Graph) {
70     return "";
71   }
72
73   /// If you want to override the dot attributes printed for a particular edge,
74   /// override this method.
75   template<typename EdgeIter>
76   static std::string getEdgeAttributes(const void *Node, EdgeIter EI) {
77     return "";
78   }
79
80   /// getEdgeSourceLabel - If you want to label the edge source itself,
81   /// implement this method.
82   template<typename EdgeIter>
83   static std::string getEdgeSourceLabel(const void *Node, EdgeIter I) {
84     return "";
85   }
86
87   /// edgeTargetsEdgeSource - This method returns true if this outgoing edge
88   /// should actually target another edge source, not a node.  If this method is
89   /// implemented, getEdgeTarget should be implemented.
90   template<typename EdgeIter>
91   static bool edgeTargetsEdgeSource(const void *Node, EdgeIter I) {
92     return false;
93   }
94
95   /// getEdgeTarget - If edgeTargetsEdgeSource returns true, this method is
96   /// called to determine which outgoing edge of Node is the target of this
97   /// edge.
98   template<typename EdgeIter>
99   static EdgeIter getEdgeTarget(const void *Node, EdgeIter I) {
100     return I;
101   }
102
103   /// hasEdgeDestLabels - If this function returns true, the graph is able
104   /// to provide labels for edge destinations.
105   static bool hasEdgeDestLabels() {
106     return false;
107   }
108
109   /// numEdgeDestLabels - If hasEdgeDestLabels, this function returns the
110   /// number of incoming edge labels the given node has.
111   static unsigned numEdgeDestLabels(const void *Node) {
112     return 0;
113   }
114
115   /// getEdgeDestLabel - If hasEdgeDestLabels, this function returns the
116   /// incoming edge label with the given index in the given node.
117   static std::string getEdgeDestLabel(const void *Node, unsigned i) {
118     return "";
119   }
120
121   /// addCustomGraphFeatures - If a graph is made up of more than just
122   /// straight-forward nodes and edges, this is the place to put all of the
123   /// custom stuff necessary.  The GraphWriter object, instantiated with your
124   /// GraphType is passed in as an argument.  You may call arbitrary methods on
125   /// it to add things to the output graph.
126   ///
127   template<typename GraphType, typename GraphWriter>
128   static void addCustomGraphFeatures(const GraphType& Graph, GraphWriter &GW) {}
129 };
130
131
132 /// DOTGraphTraits - Template class that can be specialized to customize how
133 /// graphs are converted to 'dot' graphs.  When specializing, you may inherit
134 /// from DefaultDOTGraphTraits if you don't need to override everything.
135 ///
136 template <typename Ty>
137 struct DOTGraphTraits : public DefaultDOTGraphTraits {};
138
139 } // End llvm namespace
140
141 #endif