Data.GraphViz.Types.Generalised

graphviz-2999.18.1.2: Bindings to Graphviz for graph visualisation.

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

Data.GraphViz.Types.Generalised

Contents

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

Description

The generalised Dot representation most closely matches the implementation of actual Dot code, as it places no restrictions on ordering of elements, etc. As such it should be able to parse any existing Dot code (taking into account the parsing limitations/assumptions).

The sample graph could be implemented (this is actually a prettied version of parsing in the Dot code) as:

    DotGraph { strictGraph = False
             , directedGraph = True
             , graphID = Just (Str "G")
             , graphStatements = Seq.fromList [ SG $ DotSG { isCluster = True
                                                           , subGraphID = Just (Int 0)
                                                           , subGraphStmts = Seq.fromList [ GA $ GraphAttrs [style filled]
                                                                                          , GA $ GraphAttrs [color LightGray]
                                                                                          , GA $ NodeAttrs [style filled, color White]
                                                                                          , DE $ DotEdge "a0" "a1" []
                                                                                          , DE $ DotEdge "a1" "a2" []
                                                                                          , DE $ DotEdge "a2" "a3" []
                                                                                          , GA $ GraphAttrs [textLabel "process #1"]]}
                                              , SG $ DotSG { isCluster = True
                                                           , subGraphID = Just (Int 1)
                                                           , subGraphStmts = fromList [ GA $ NodeAttrs [style filled]
                                                                                      , DE $ DotEdge "b0" "b1" []
                                                                                      , DE $ DotEdge "b1" "b2" []
                                                                                      , DE $ DotEdge "b2" "b3" []
                                                                                      , GA $ GraphAttrs [textLabel "process #2"]
                                                                                      , GA $ GraphAttrs [color Blue]]}
                                              , DE $ DotEdge "start" "a0" []
                                              , DE $ DotEdge "start" "b0" []
                                              , DE $ DotEdge "a1" "b3" []
                                              , DE $ DotEdge "b2" "a3" []
                                              , DE $ DotEdge "a3" "a0" []
                                              , DE $ DotEdge "a3" "end" []
                                              , DE $ DotEdge "b3" "end" []
                                              , DN $ DotNode "start" [shape MDiamond]
                                              , DN $ DotNode "end" [shape MSquare]]}

Synopsis

- data DotGraph n = DotGraph {
  - strictGraph :: Bool
  - directedGraph :: Bool
  - graphID :: Maybe GraphID
  - graphStatements :: DotStatements n
  }
- class DotRepr dg n => FromGeneralisedDot dg n where
- type DotStatements n = Seq (DotStatement n)
- data DotStatement n
  - = GA GlobalAttributes
  - | SG (DotSubGraph n)
  - | DN (DotNode n)
  - | DE (DotEdge n)
- data DotSubGraph n = DotSG {
  - isCluster :: Bool
  - subGraphID :: Maybe GraphID
  - subGraphStmts :: DotStatements n
  }
- data GraphID
  - = Str Text
  - | Num Number
- data GlobalAttributes
  - = GraphAttrs {
    - attrs :: Attributes
    }
  - | NodeAttrs {
    - attrs :: Attributes
    }
  - | EdgeAttrs {
    - attrs :: Attributes
    }
- data DotNode n = DotNode {
  - nodeID :: n
  - nodeAttributes :: Attributes
  }
- data DotEdge n = DotEdge {
  - fromNode :: n
  - toNode :: n
  - edgeAttributes :: Attributes
  }

# Documentation

data DotGraph n #

The internal representation of a generalised graph in Dot 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 #

class DotRepr dg n => FromGeneralisedDot dg n where #

This class is useful for being able to parse in a dot graph as a generalised one, and then convert it to your preferred representation.

This can be seen as a semi-inverse of `fromCanonical`.

Minimal complete definition

fromGeneralised

Methods

fromGeneralised :: DotGraph n -> dg n #

Instances

Ord n => FromGeneralisedDot DotGraph n # |
Methods fromGeneralised :: DotGraph n -> DotGraph n #
Ord n => FromGeneralisedDot DotGraph n # |
Methods fromGeneralised :: DotGraph n -> DotGraph n #
Ord n => FromGeneralisedDot DotGraph n # |
Methods fromGeneralised :: DotGraph n -> DotGraph n #

# Sub-components of a `DotGraph`.

type DotStatements n = Seq (DotStatement n) #

data DotStatement n #

Constructors

GA GlobalAttributes |
SG (DotSubGraph n) |
DN (DotNode n) |
DE (DotEdge n) |

Instances

Functor DotStatement # |
Methods fmap :: (a -> b) -> DotStatement a -> DotStatement b # (<$) :: a -> DotStatement b -> DotStatement a #
Eq n => Eq (DotStatement n) # |
Methods (==) :: DotStatement n -> DotStatement n -> Bool # (/=) :: DotStatement n -> DotStatement n -> Bool #
Ord n => Ord (DotStatement n) # |
Methods compare :: DotStatement n -> DotStatement n -> Ordering # (<) :: DotStatement n -> DotStatement n -> Bool # (<=) :: DotStatement n -> DotStatement n -> Bool # (>) :: DotStatement n -> DotStatement n -> Bool # (>=) :: DotStatement n -> DotStatement n -> Bool # max :: DotStatement n -> DotStatement n -> DotStatement n # min :: DotStatement n -> DotStatement n -> DotStatement n #
Read n => Read (DotStatement n) # |
Methods readsPrec :: Int -> ReadS (DotStatement n) # readList :: ReadS [DotStatement n] # readPrec :: ReadPrec (DotStatement n) # readListPrec :: ReadPrec [DotStatement n] #
Show n => Show (DotStatement n) # |
Methods showsPrec :: Int -> DotStatement n -> ShowS # show :: DotStatement n -> String # showList :: [DotStatement n] -> ShowS #
ParseDot n => ParseDot (DotStatement n) # |
Methods parseUnqt :: Parse (DotStatement n) # parse :: Parse (DotStatement n) # parseUnqtList :: Parse [DotStatement n] # parseList :: Parse [DotStatement n] #
PrintDot n => PrintDot (DotStatement n) # |
Methods unqtDot :: DotStatement n -> DotCode # toDot :: DotStatement n -> DotCode # unqtListToDot :: [DotStatement n] -> DotCode # listToDot :: [DotStatement 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 `Attribute`s for the entire graph/sub-graph. Note that `GraphAttrs` also applies to `DotSubGraph`s.

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 #