Copyright	(c) Matthew Sackman Ivan Lazar Miljenovic
License	3-Clause BSD-style
Maintainer	Ivan.Miljenovic@gmail.com
Safe Haskell	None
Language	Haskell2010

Data.GraphViz.Types.Canonical

Contents

Sub-components of a DotGraph.
Re-exported from Data.GraphViz.Types

Description

A canonical Dot graph requires that within each graph/sub-graph, the statements are in the following order:

global attributes
sub-graphs/clusters
nodes
edges

This Dot graph representation is ideally suited for converting other data structures to Dot form (especially with the help of graphElemsToDot from Data.GraphViz).

If you require arbitrary ordering of statements, then use Data.GraphViz.Types.Generalised.

The sample graph could be implemented (this is actually the result of calling canonicalise from Data.GraphViz.Algorithms on the generalised one) as:

DotGraph { strictGraph = False
         , directedGraph = True
         , graphID = Just (Str "G")
         , graphStatements = DotStmts { attrStmts = []
                                      , subGraphs = [ DotSG { isCluster = True
                                                            , subGraphID = Just (Num (Int 0))
                                                            , subGraphStmts = DotStmts { attrStmts = [ GraphAttrs [ style filled
                                                                                                                  , color LightGray
                                                                                                                  , textLabel "process #1"]
                                                                                                     , NodeAttrs [style filled, color White]]
                                                                                       , subGraphs = []
                                                                                       , nodeStmts = [ DotNode "a0" []
                                                                                                     , DotNode "a1" []
                                                                                                     , DotNode "a2" []
                                                                                                     , DotNode "a3" []]
                                                                                       , edgeStmts = [ DotEdge "a0" "a1" []
                                                                                                     , DotEdge "a1" "a2" []
                                                                                                     , DotEdge "a2" "a3" []
                                                                                                     , DotEdge "a3" "a0" []]}}
                                                    , DotSG { isCluster = True
                                                            , subGraphID = Just (Num (Int 1))
                                                            , subGraphStmts = DotStmts { attrStmts = [ GraphAttrs [textLabel "process #2", color Blue]
                                                                                                     , NodeAttrs [style filled]]
                                                                                       , subGraphs = []
                                                                                       , nodeStmts = [ DotNode "b0" []
                                                                                                     , DotNode "b1" []
                                                                                                     , DotNode "b2" []
                                                                                                     , DotNode "b3" []]
                                                                                       , edgeStmts = [ DotEdge "b0" "b1" []
                                                                                                     , DotEdge "b1" "b2" []
                                                                                                     , DotEdge "b2" "b3" []]}}]
                                      , nodeStmts = [ DotNode "end" [shape MSquare]
                                                    , DotNode "start" [shape MDiamond]]
                                      , edgeStmts = [ DotEdge "start" "a0" []
                                                    , DotEdge "start" "b0" []
                                                    , DotEdge "a1" "b3" []
                                                    , DotEdge "b2" "a3" []
                                                    , DotEdge "a3" "end" []
                                                    , DotEdge "b3" "end" []]}}

Note that whilst the above graph represents the same Dot graph as specified in Data.GraphViz.Types.Generalised, etc., it may be drawn slightly differently by the various Graphviz tools.

Synopsis

Documentation

data DotGraph n Source #

A Dot graph in canonical form.

Constructors

DotGraph
Fields strictGraph :: Bool If `True`, no multiple edges are drawn. directedGraph :: Bool graphID :: Maybe GraphID graphStatements :: DotStatements n

Instances

Functor DotGraph Source #	Assumed to be an injective mapping function.
Methods fmap :: (a -> b) -> DotGraph a -> DotGraph b # (<$) :: a -> DotGraph b -> DotGraph a #
(Ord n, PrintDot n, ParseDot n) => PPDotRepr DotGraph n Source #

(Ord n, ParseDot n) => ParseDotRepr DotGraph n Source #

(Ord n, PrintDot n) => PrintDotRepr DotGraph n Source #

Ord n => DotRepr DotGraph n Source #
Methods fromCanonical :: DotGraph n -> DotGraph n Source # getID :: DotGraph n -> Maybe GraphID Source # setID :: GraphID -> DotGraph n -> DotGraph n Source # graphIsDirected :: DotGraph n -> Bool Source # setIsDirected :: Bool -> DotGraph n -> DotGraph n Source # graphIsStrict :: DotGraph n -> Bool Source # setStrictness :: Bool -> DotGraph n -> DotGraph n Source # mapDotGraph :: DotRepr DotGraph n' => (n -> n') -> DotGraph n -> DotGraph n' Source # graphStructureInformation :: DotGraph n -> (GlobalAttributes, ClusterLookup) Source # nodeInformation :: Bool -> DotGraph n -> NodeLookup n Source # edgeInformation :: Bool -> DotGraph n -> [DotEdge n] Source # unAnonymise :: DotGraph n -> DotGraph n Source #
Ord n => FromGeneralisedDot DotGraph n Source #
Methods fromGeneralised :: DotGraph n -> DotGraph n Source #
Eq n => Eq (DotGraph n) Source #
Methods (==) :: DotGraph n -> DotGraph n -> Bool # (/=) :: DotGraph n -> DotGraph n -> Bool #
Ord n => Ord (DotGraph n) Source #
Methods compare :: DotGraph n -> DotGraph n -> Ordering # (<) :: DotGraph n -> DotGraph n -> Bool # (<=) :: DotGraph n -> DotGraph n -> Bool # (>) :: DotGraph n -> DotGraph n -> Bool # (>=) :: DotGraph n -> DotGraph n -> Bool # max :: DotGraph n -> DotGraph n -> DotGraph n # min :: DotGraph n -> DotGraph n -> DotGraph n #
Read n => Read (DotGraph n) Source #
Methods readsPrec :: Int -> ReadS (DotGraph n) # readList :: ReadS [DotGraph n] # readPrec :: ReadPrec (DotGraph n) # readListPrec :: ReadPrec [DotGraph n] #
Show n => Show (DotGraph n) Source #
Methods showsPrec :: Int -> DotGraph n -> ShowS # show :: DotGraph n -> String # showList :: [DotGraph n] -> ShowS #
ParseDot n => ParseDot (DotGraph n) Source #
Methods parseUnqt :: Parse (DotGraph n) Source # parse :: Parse (DotGraph n) Source # parseUnqtList :: Parse [DotGraph n] Source # parseList :: Parse [DotGraph n] Source #
PrintDot n => PrintDot (DotGraph n) Source #
Methods unqtDot :: DotGraph n -> DotCode Source # toDot :: DotGraph n -> DotCode Source # unqtListToDot :: [DotGraph n] -> DotCode Source # listToDot :: [DotGraph n] -> DotCode Source #

Sub-components of a `DotGraph`.

data DotStatements n Source #

Constructors

DotStmts
Fields attrStmts :: [GlobalAttributes] subGraphs :: [DotSubGraph n] nodeStmts :: [DotNode n] edgeStmts :: [DotEdge n]

Instances

Functor DotStatements Source #
Methods fmap :: (a -> b) -> DotStatements a -> DotStatements b # (<$) :: a -> DotStatements b -> DotStatements a #
Eq n => Eq (DotStatements n) Source #
Methods (==) :: DotStatements n -> DotStatements n -> Bool # (/=) :: DotStatements n -> DotStatements n -> Bool #
Ord n => Ord (DotStatements n) Source #
Methods compare :: DotStatements n -> DotStatements n -> Ordering # (<) :: DotStatements n -> DotStatements n -> Bool # (<=) :: DotStatements n -> DotStatements n -> Bool # (>) :: DotStatements n -> DotStatements n -> Bool # (>=) :: DotStatements n -> DotStatements n -> Bool # max :: DotStatements n -> DotStatements n -> DotStatements n # min :: DotStatements n -> DotStatements n -> DotStatements n #
Read n => Read (DotStatements n) Source #
Methods readsPrec :: Int -> ReadS (DotStatements n) # readList :: ReadS [DotStatements n] # readPrec :: ReadPrec (DotStatements n) # readListPrec :: ReadPrec [DotStatements n] #
Show n => Show (DotStatements n) Source #
Methods showsPrec :: Int -> DotStatements n -> ShowS # show :: DotStatements n -> String # showList :: [DotStatements n] -> ShowS #
ParseDot n => ParseDot (DotStatements n) Source #
Methods parseUnqt :: Parse (DotStatements n) Source # parse :: Parse (DotStatements n) Source # parseUnqtList :: Parse [DotStatements n] Source # parseList :: Parse [DotStatements n] Source #
PrintDot n => PrintDot (DotStatements n) Source #
Methods unqtDot :: DotStatements n -> DotCode Source # toDot :: DotStatements n -> DotCode Source # unqtListToDot :: [DotStatements n] -> DotCode Source # listToDot :: [DotStatements n] -> DotCode Source #

data DotSubGraph n Source #

Constructors

DotSG
Fields isCluster :: Bool subGraphID :: Maybe GraphID subGraphStmts :: DotStatements n

Instances

Functor DotSubGraph Source #
Methods fmap :: (a -> b) -> DotSubGraph a -> DotSubGraph b # (<$) :: a -> DotSubGraph b -> DotSubGraph a #
Eq n => Eq (DotSubGraph n) Source #
Methods (==) :: DotSubGraph n -> DotSubGraph n -> Bool # (/=) :: DotSubGraph n -> DotSubGraph n -> Bool #
Ord n => Ord (DotSubGraph n) Source #
Methods compare :: DotSubGraph n -> DotSubGraph n -> Ordering # (<) :: DotSubGraph n -> DotSubGraph n -> Bool # (<=) :: DotSubGraph n -> DotSubGraph n -> Bool # (>) :: DotSubGraph n -> DotSubGraph n -> Bool # (>=) :: DotSubGraph n -> DotSubGraph n -> Bool # max :: DotSubGraph n -> DotSubGraph n -> DotSubGraph n # min :: DotSubGraph n -> DotSubGraph n -> DotSubGraph n #
Read n => Read (DotSubGraph n) Source #
Methods readsPrec :: Int -> ReadS (DotSubGraph n) # readList :: ReadS [DotSubGraph n] # readPrec :: ReadPrec (DotSubGraph n) # readListPrec :: ReadPrec [DotSubGraph n] #
Show n => Show (DotSubGraph n) Source #
Methods showsPrec :: Int -> DotSubGraph n -> ShowS # show :: DotSubGraph n -> String # showList :: [DotSubGraph n] -> ShowS #
ParseDot n => ParseDot (DotSubGraph n) Source #
Methods parseUnqt :: Parse (DotSubGraph n) Source # parse :: Parse (DotSubGraph n) Source # parseUnqtList :: Parse [DotSubGraph n] Source # parseList :: Parse [DotSubGraph n] Source #
PrintDot n => PrintDot (DotSubGraph n) Source #
Methods unqtDot :: DotSubGraph n -> DotCode Source # toDot :: DotSubGraph n -> DotCode Source # unqtListToDot :: [DotSubGraph n] -> DotCode Source # listToDot :: [DotSubGraph n] -> DotCode Source #

Re-exported from `Data.GraphViz.Types`

data GraphID Source #

A polymorphic type that covers all possible ID values allowed by Dot syntax. Note that whilst the ParseDot and PrintDot instances for String will properly take care of the special cases for numbers, they are treated differently here.

Constructors

Str Text
Num Number

Instances

Eq GraphID Source #
Methods (==) :: GraphID -> GraphID -> Bool # (/=) :: GraphID -> GraphID -> Bool #
Ord GraphID Source #
Methods compare :: GraphID -> GraphID -> Ordering # (<) :: GraphID -> GraphID -> Bool # (<=) :: GraphID -> GraphID -> Bool # (>) :: GraphID -> GraphID -> Bool # (>=) :: GraphID -> GraphID -> Bool # max :: GraphID -> GraphID -> GraphID # min :: GraphID -> GraphID -> GraphID #
Read GraphID Source #
Methods readsPrec :: Int -> ReadS GraphID # readList :: ReadS [GraphID] # readPrec :: ReadPrec GraphID # readListPrec :: ReadPrec [GraphID] #
Show GraphID Source #
Methods showsPrec :: Int -> GraphID -> ShowS # show :: GraphID -> String # showList :: [GraphID] -> ShowS #
ParseDot GraphID Source #
Methods parseUnqt :: Parse GraphID Source # parse :: Parse GraphID Source # parseUnqtList :: Parse [GraphID] Source # parseList :: Parse [GraphID] Source #
PrintDot GraphID Source #
Methods unqtDot :: GraphID -> DotCode Source # toDot :: GraphID -> DotCode Source # unqtListToDot :: [GraphID] -> DotCode Source # listToDot :: [GraphID] -> DotCode Source #

data GlobalAttributes Source #

Represents a list of top-level list of Attributes for the entire graph/sub-graph. Note that GraphAttrs also applies to DotSubGraphs.

Note that Dot allows a single Attribute to be listed on a line; if this is the case then when parsing, the type of Attribute it is determined and that type of GlobalAttribute is created.

Constructors

GraphAttrs
Fields attrs :: Attributes
NodeAttrs
Fields attrs :: Attributes
EdgeAttrs
Fields attrs :: Attributes

Instances

Eq GlobalAttributes Source #
Methods (==) :: GlobalAttributes -> GlobalAttributes -> Bool # (/=) :: GlobalAttributes -> GlobalAttributes -> Bool #
Ord GlobalAttributes Source #
Methods compare :: GlobalAttributes -> GlobalAttributes -> Ordering # (<) :: GlobalAttributes -> GlobalAttributes -> Bool # (<=) :: GlobalAttributes -> GlobalAttributes -> Bool # (>) :: GlobalAttributes -> GlobalAttributes -> Bool # (>=) :: GlobalAttributes -> GlobalAttributes -> Bool # max :: GlobalAttributes -> GlobalAttributes -> GlobalAttributes # min :: GlobalAttributes -> GlobalAttributes -> GlobalAttributes #
Read GlobalAttributes Source #
Methods readsPrec :: Int -> ReadS GlobalAttributes # readList :: ReadS [GlobalAttributes] # readPrec :: ReadPrec GlobalAttributes # readListPrec :: ReadPrec [GlobalAttributes] #
Show GlobalAttributes Source #
Methods showsPrec :: Int -> GlobalAttributes -> ShowS # show :: GlobalAttributes -> String # showList :: [GlobalAttributes] -> ShowS #
ParseDot GlobalAttributes Source #
Methods parseUnqt :: Parse GlobalAttributes Source # parse :: Parse GlobalAttributes Source # parseUnqtList :: Parse [GlobalAttributes] Source # parseList :: Parse [GlobalAttributes] Source #
PrintDot GlobalAttributes Source #
Methods unqtDot :: GlobalAttributes -> DotCode Source # toDot :: GlobalAttributes -> DotCode Source # unqtListToDot :: [GlobalAttributes] -> DotCode Source # listToDot :: [GlobalAttributes] -> DotCode Source #

data DotNode n Source #

A node in DotGraph.

Constructors

DotNode
Fields nodeID :: n nodeAttributes :: Attributes

Instances

Functor DotNode Source #
Methods fmap :: (a -> b) -> DotNode a -> DotNode b # (<$) :: a -> DotNode b -> DotNode a #
Eq n => Eq (DotNode n) Source #
Methods (==) :: DotNode n -> DotNode n -> Bool # (/=) :: DotNode n -> DotNode n -> Bool #
Ord n => Ord (DotNode n) Source #
Methods compare :: DotNode n -> DotNode n -> Ordering # (<) :: DotNode n -> DotNode n -> Bool # (<=) :: DotNode n -> DotNode n -> Bool # (>) :: DotNode n -> DotNode n -> Bool # (>=) :: DotNode n -> DotNode n -> Bool # max :: DotNode n -> DotNode n -> DotNode n # min :: DotNode n -> DotNode n -> DotNode n #
Read n => Read (DotNode n) Source #
Methods readsPrec :: Int -> ReadS (DotNode n) # readList :: ReadS [DotNode n] # readPrec :: ReadPrec (DotNode n) # readListPrec :: ReadPrec [DotNode n] #
Show n => Show (DotNode n) Source #
Methods showsPrec :: Int -> DotNode n -> ShowS # show :: DotNode n -> String # showList :: [DotNode n] -> ShowS #
ParseDot n => ParseDot (DotNode n) Source #
Methods parseUnqt :: Parse (DotNode n) Source # parse :: Parse (DotNode n) Source # parseUnqtList :: Parse [DotNode n] Source # parseList :: Parse [DotNode n] Source #
PrintDot n => PrintDot (DotNode n) Source #
Methods unqtDot :: DotNode n -> DotCode Source # toDot :: DotNode n -> DotCode Source # unqtListToDot :: [DotNode n] -> DotCode Source # listToDot :: [DotNode n] -> DotCode Source #

data DotEdge n Source #

An edge in DotGraph.

Constructors

DotEdge
Fields fromNode :: n toNode :: n edgeAttributes :: Attributes

Instances

Functor DotEdge Source #
Methods fmap :: (a -> b) -> DotEdge a -> DotEdge b # (<$) :: a -> DotEdge b -> DotEdge a #
Eq n => Eq (DotEdge n) Source #
Methods (==) :: DotEdge n -> DotEdge n -> Bool # (/=) :: DotEdge n -> DotEdge n -> Bool #
Ord n => Ord (DotEdge n) Source #
Methods compare :: DotEdge n -> DotEdge n -> Ordering # (<) :: DotEdge n -> DotEdge n -> Bool # (<=) :: DotEdge n -> DotEdge n -> Bool # (>) :: DotEdge n -> DotEdge n -> Bool # (>=) :: DotEdge n -> DotEdge n -> Bool # max :: DotEdge n -> DotEdge n -> DotEdge n # min :: DotEdge n -> DotEdge n -> DotEdge n #
Read n => Read (DotEdge n) Source #
Methods readsPrec :: Int -> ReadS (DotEdge n) # readList :: ReadS [DotEdge n] # readPrec :: ReadPrec (DotEdge n) # readListPrec :: ReadPrec [DotEdge n] #
Show n => Show (DotEdge n) Source #
Methods showsPrec :: Int -> DotEdge n -> ShowS # show :: DotEdge n -> String # showList :: [DotEdge n] -> ShowS #
ParseDot n => ParseDot (DotEdge n) Source #
Methods parseUnqt :: Parse (DotEdge n) Source # parse :: Parse (DotEdge n) Source # parseUnqtList :: Parse [DotEdge n] Source # parseList :: Parse [DotEdge n] Source #
PrintDot n => PrintDot (DotEdge n) Source #
Methods unqtDot :: DotEdge n -> DotCode Source # toDot :: DotEdge n -> DotCode Source # unqtListToDot :: [DotEdge n] -> DotCode Source # listToDot :: [DotEdge n] -> DotCode Source #

Documentation

Sub-components of a DotGraph.

Re-exported from Data.GraphViz.Types

Sub-components of a `DotGraph`.

Re-exported from `Data.GraphViz.Types`