Data.GraphViz.Types.Canonical

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.

Documentation

data DotGraph n

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

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

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

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

Ord n => DotRepr DotGraph n

Methods

fromCanonical :: DotGraph n -> DotGraph n

getID :: DotGraph n -> Maybe GraphID

setID :: GraphID -> DotGraph n -> DotGraph n

graphIsDirected :: DotGraph n -> Bool

setIsDirected :: Bool -> DotGraph n -> DotGraph n

graphIsStrict :: DotGraph n -> Bool

setStrictness :: Bool -> DotGraph n -> DotGraph n

mapDotGraph :: DotRepr DotGraph n' => (n -> n') -> DotGraph n -> DotGraph n'

graphStructureInformation :: DotGraph n -> (GlobalAttributes, ClusterLookup)

nodeInformation :: Bool -> DotGraph n -> NodeLookup n

edgeInformation :: Bool -> DotGraph n -> [DotEdge n]

unAnonymise :: DotGraph n -> DotGraph n

Ord n => FromGeneralisedDot DotGraph n

Methods

fromGeneralised :: DotGraph n -> DotGraph n

Eq n => Eq (DotGraph n)

Methods

(==) :: DotGraph n -> DotGraph n -> Bool

(/=) :: DotGraph n -> DotGraph n -> Bool

Ord n => Ord (DotGraph n)

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)

Methods

readsPrec :: Int -> ReadS (DotGraph n)

readList :: ReadS [DotGraph n]

readPrec :: ReadPrec (DotGraph n)

readListPrec :: ReadPrec [DotGraph n]

Show n => Show (DotGraph n)

Methods

showsPrec :: Int -> DotGraph n -> ShowS

show :: DotGraph n -> String

showList :: [DotGraph n] -> ShowS

ParseDot n => ParseDot (DotGraph n)

Methods

parseUnqt :: Parse (DotGraph n)

parse :: Parse (DotGraph n)

parseUnqtList :: Parse [DotGraph n]

parseList :: Parse [DotGraph n]

PrintDot n => PrintDot (DotGraph n)

Methods

unqtDot :: DotGraph n -> DotCode

toDot :: DotGraph n -> DotCode

unqtListToDot :: [DotGraph n] -> DotCode

listToDot :: [DotGraph n] -> DotCode

Sub-components of a DotGraph.

data DotStatements n

Constructors

DotStmts

Fields

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

Instances

Functor DotStatements

Methods

fmap :: (a -> b) -> DotStatements a -> DotStatements b

(<$) :: a -> DotStatements b -> DotStatements a

Eq n => Eq (DotStatements n)

Methods

(==) :: DotStatements n -> DotStatements n -> Bool

(/=) :: DotStatements n -> DotStatements n -> Bool

Ord n => Ord (DotStatements n)

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)

Methods

readsPrec :: Int -> ReadS (DotStatements n)

readList :: ReadS [DotStatements n]

readPrec :: ReadPrec (DotStatements n)

readListPrec :: ReadPrec [DotStatements n]

Show n => Show (DotStatements n)

Methods

showsPrec :: Int -> DotStatements n -> ShowS

show :: DotStatements n -> String

showList :: [DotStatements n] -> ShowS

ParseDot n => ParseDot (DotStatements n)

Methods

parseUnqt :: Parse (DotStatements n)

parse :: Parse (DotStatements n)

parseUnqtList :: Parse [DotStatements n]

parseList :: Parse [DotStatements n]

PrintDot n => PrintDot (DotStatements n)

Methods

unqtDot :: DotStatements n -> DotCode

toDot :: DotStatements n -> DotCode

unqtListToDot :: [DotStatements n] -> DotCode

listToDot :: [DotStatements n] -> DotCode

data DotSubGraph n

Constructors

DotSG

Fields

• isCluster :: Bool
• subGraphID :: Maybe GraphID
• subGraphStmts :: DotStatements n

Instances

Functor DotSubGraph

Methods

fmap :: (a -> b) -> DotSubGraph a -> DotSubGraph b

(<$) :: a -> DotSubGraph b -> DotSubGraph a

Eq n => Eq (DotSubGraph n)

Methods

(==) :: DotSubGraph n -> DotSubGraph n -> Bool

(/=) :: DotSubGraph n -> DotSubGraph n -> Bool

Ord n => Ord (DotSubGraph n)

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)

Methods

readsPrec :: Int -> ReadS (DotSubGraph n)

readList :: ReadS [DotSubGraph n]

readPrec :: ReadPrec (DotSubGraph n)

readListPrec :: ReadPrec [DotSubGraph n]

Show n => Show (DotSubGraph n)

Methods

showsPrec :: Int -> DotSubGraph n -> ShowS

show :: DotSubGraph n -> String

showList :: [DotSubGraph n] -> ShowS

ParseDot n => ParseDot (DotSubGraph n)

Methods

parseUnqt :: Parse (DotSubGraph n)

parse :: Parse (DotSubGraph n)

parseUnqtList :: Parse [DotSubGraph n]

parseList :: Parse [DotSubGraph n]

PrintDot n => PrintDot (DotSubGraph n)

Methods

unqtDot :: DotSubGraph n -> DotCode

toDot :: DotSubGraph n -> DotCode

unqtListToDot :: [DotSubGraph n] -> DotCode

listToDot :: [DotSubGraph n] -> DotCode

Re-exported from Data.GraphViz.Types

data GraphID

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

Methods

(==) :: GraphID -> GraphID -> Bool

(/=) :: GraphID -> GraphID -> Bool

Ord GraphID

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

Methods

readsPrec :: Int -> ReadS GraphID

readList :: ReadS [GraphID]

readPrec :: ReadPrec GraphID

readListPrec :: ReadPrec [GraphID]

Show GraphID

Methods

showsPrec :: Int -> GraphID -> ShowS

show :: GraphID -> String

showList :: [GraphID] -> ShowS

ParseDot GraphID

Methods

parseUnqt :: Parse GraphID

parse :: Parse GraphID

parseUnqtList :: Parse [GraphID]

parseList :: Parse [GraphID]

PrintDot GraphID

Methods

unqtDot :: GraphID -> DotCode

toDot :: GraphID -> DotCode

unqtListToDot :: [GraphID] -> DotCode

listToDot :: [GraphID] -> DotCode

data GlobalAttributes

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

Methods

(==) :: GlobalAttributes -> GlobalAttributes -> Bool

(/=) :: GlobalAttributes -> GlobalAttributes -> Bool

Ord GlobalAttributes

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

Methods

readsPrec :: Int -> ReadS GlobalAttributes

readList :: ReadS [GlobalAttributes]

readPrec :: ReadPrec GlobalAttributes

readListPrec :: ReadPrec [GlobalAttributes]

Show GlobalAttributes

Methods

showsPrec :: Int -> GlobalAttributes -> ShowS

show :: GlobalAttributes -> String

showList :: [GlobalAttributes] -> ShowS

ParseDot GlobalAttributes

Methods

parseUnqt :: Parse GlobalAttributes

parse :: Parse GlobalAttributes

parseUnqtList :: Parse [GlobalAttributes]

parseList :: Parse [GlobalAttributes]

PrintDot GlobalAttributes

Methods

unqtDot :: GlobalAttributes -> DotCode

toDot :: GlobalAttributes -> DotCode

unqtListToDot :: [GlobalAttributes] -> DotCode

listToDot :: [GlobalAttributes] -> DotCode

data DotNode n

A node in DotGraph.

Constructors

DotNode

Fields

• nodeID :: n
• nodeAttributes :: Attributes

Instances

Functor DotNode

Methods

fmap :: (a -> b) -> DotNode a -> DotNode b

(<$) :: a -> DotNode b -> DotNode a

Eq n => Eq (DotNode n)

Methods

(==) :: DotNode n -> DotNode n -> Bool

(/=) :: DotNode n -> DotNode n -> Bool

Ord n => Ord (DotNode n)

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)

Methods

readsPrec :: Int -> ReadS (DotNode n)

readList :: ReadS [DotNode n]

readPrec :: ReadPrec (DotNode n)

readListPrec :: ReadPrec [DotNode n]

Show n => Show (DotNode n)

Methods

showsPrec :: Int -> DotNode n -> ShowS

show :: DotNode n -> String

showList :: [DotNode n] -> ShowS

ParseDot n => ParseDot (DotNode n)

Methods

parseUnqt :: Parse (DotNode n)

parse :: Parse (DotNode n)

parseUnqtList :: Parse [DotNode n]

parseList :: Parse [DotNode n]

PrintDot n => PrintDot (DotNode n)

Methods

unqtDot :: DotNode n -> DotCode

toDot :: DotNode n -> DotCode

unqtListToDot :: [DotNode n] -> DotCode

listToDot :: [DotNode n] -> DotCode

data DotEdge n

An edge in DotGraph.

Constructors

DotEdge

Fields

• fromNode :: n
• toNode :: n
• edgeAttributes :: Attributes

Instances

Functor DotEdge

Methods

fmap :: (a -> b) -> DotEdge a -> DotEdge b

(<$) :: a -> DotEdge b -> DotEdge a

Eq n => Eq (DotEdge n)

Methods

(==) :: DotEdge n -> DotEdge n -> Bool

(/=) :: DotEdge n -> DotEdge n -> Bool

Ord n => Ord (DotEdge n)

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)

Methods

readsPrec :: Int -> ReadS (DotEdge n)

readList :: ReadS [DotEdge n]

readPrec :: ReadPrec (DotEdge n)

readListPrec :: ReadPrec [DotEdge n]

Show n => Show (DotEdge n)

Methods

showsPrec :: Int -> DotEdge n -> ShowS

show :: DotEdge n -> String

showList :: [DotEdge n] -> ShowS

ParseDot n => ParseDot (DotEdge n)

Methods

parseUnqt :: Parse (DotEdge n)

parse :: Parse (DotEdge n)

parseUnqtList :: Parse [DotEdge n]

parseList :: Parse [DotEdge n]

PrintDot n => PrintDot (DotEdge n)

Methods

unqtDot :: DotEdge n -> DotCode

toDot :: DotEdge n -> DotCode

unqtListToDot :: [DotEdge n] -> DotCode

listToDot :: [DotEdge n] -> DotCode