---
name: "GraphViz2::Parse::STT"
section: "3pm"
platform: "linux"
package: "libgraphviz2-perl"
version: "2.67-2"
release: "Debian 13 (Trixie)"
platforms: ["linux"]
url: "https://new.carta.tech/GraphViz2::Parse::STT"
---

# GraphViz2::Parse::STT(3pm)

Visualize a Set::FA::Element state transition table as a graph

## NAME

GraphViz2::Parse::STT - Visualize a Set::FA::Element state transition table as a graph

## SYNOPSIS

```
    use GraphViz2::Parse::STT;
    use File::Slurp; # For read_file().
    my $stt = read_file('sample.stt.1.dat');
    # no objects - quicker
    my $gd = GraphViz2::Parse::STT::to_graph($stt);
    # populate a GraphViz2 object with a Graph::Directed of a parser
    my $gv = GraphViz2->from_graph(GraphViz2::Parse::STT::graphvizify($gd));
    # visualise with another mode
    $gd = GraphViz2::Parse::STT::graphvizify($gd, 're_nodes'); # or 're_edges'
    # OO interface, using lazy-built attributes
    my $gvp = GraphViz2::Parse::STT->new(stt => $stt, mode => 're_structs');
    my $gd = $gvp->as_graph; # Graph::Directed object
    # or supply a suitable Graph::Directed object
    my $gvp = GraphViz2::Parse::STT->new(as_graph => $gd);
    # then get the GraphViz2 object
    my $gv = $gvp->graph;
    # DEPRECATED ways to get $gvp with populated $gv
    my $gvp = GraphViz2::Parse::STT->new;
    $gvp->create(stt => $stt);
    my $gv = $gvp->graph;
    # or give it a pre-set-up GraphViz2 object
    my $gv = GraphViz2->new(...);
    my $gvp = GraphViz2::Parse::STT->new(graph => $gv);
    # call ->create as above
    # produce a visualisation
    my $format = shift || 'svg';
    my $output_file = shift || "output.$format";
    $gv->run(format => $format, output_file => $output_file);
```

See *t/gen.parse.stt.t*.

Note: *t/sample.stt.2.dat* is output from Graph::Easy::Marpa::DFA V 0.70, and can be used instead of *t/sample.stt.1.dat* in the above code.

## DESCRIPTION

Takes a Set::FA::Element-style state transition table and converts it into a Graph::Directed object, or directly into a GraphViz2 object.

## FUNCTIONS

This is the recommended interface.

### to\_graph

```
    my $gd = GraphViz2::Parse::STT::to_graph($stt);
```

Given STT text, returns a Graph::Directed object describing the finite state machine for it.

The nodes are all states, and the edges are regular expressions that cause a transition to another state.

### graphvizify

```
    my $gv = GraphViz2->from_graph(GraphViz2::Parse::STT::graphvizify($gd, $mode));
```

Mutates the given graph object to add to it the `"graphviz"` attributes visualisation "hints" that will make the "from\_graph" in GraphViz2 method visualise this regular expression in the most meaningful way, including labels and groupings.

It is idempotent, but in `"re_nodes"` mode, it deletes the transition edges and replaces them with additional nodes and edges.

If a second argument is given, it will be the visualisation "mode". The default is `"re_structs"`. Also available is `"re_nodes"`, and `"re_edges"` where the regular expressions are simply added as labels to the state-transition edges.

Returns the graph object for convenience.

## METHODS

This is a Moo class, but with a recommended functional interface.

### Constructor attributes

*stt*

Text with a state transition table, with a Perl-ish list of arrayrefs, each with 3 elements.

That is, it is the *contents* of the arrayref 'transitions', which is one of the keys in the parameter list to Set::FA::Element's **new()**.

A quick summary of each element of this list, where each element is an arrayref with 3 elements:

- o \[0\] A state name

  - o \[1\] A regexp

  - o \[2\] Another state name (which may be the same as the first)

  The DFA in Set::FA::Element tests the 'current' state against the state name (\[0\]), and for each state name which matches, tests the regexp (\[1\]) against the next character in the input stream. The first regexp to match causes the DFA to transition to the state named in the 3rd element of the arrayref (\[2\]).

See *t/sample.stt.1.dat* for an example.

This key is optional. You need to provide it by the time you access either the "as\_graph" or "graph".

*as\_graph*

The Graph::Directed object to use. If not given, will be lazily built on access, from the "stt".

*graph*

The GraphViz2 object to use. This allows you to configure it as desired.

This key is optional. If provided, the `"create"` method will populate it. If not, it will have these defaults, lazy-built and populated from the "as\_graph".

```
    my $gv = GraphViz2->new(
            edge   => {color => 'grey'},
            global => {directed => 1},
            graph  => {rankdir => 'TB'},
            node   => {color => 'blue', shape => 'oval'},
    );
```

*mode*

The mode to be used by "graphvizify".

### create(regexp =\> $regexp, mode =\> $mode)

DEPRECATED. Mutates the object to set the `"stt"` attribute, then accesses the `"as_graph"` attribute (possibly lazy-building it), then `"graphvizify"`s its `"as_graph"` attribute with that information, then `"from_graph"`s its `"graph"`.

Returns `$self` for method chaining.

## THANKS

Many thanks are due to the people who chose to make Graphviz \<http://www.graphviz.org/\> Open Source.

And thanks to Leon Brocard \<http://search.cpan.org/~lbrocard/\>, who wrote GraphViz, and kindly gave me co-maint of the module.

## AUTHOR

GraphViz2 was written by Ron Savage *\<ron@savage.net.au\>* in 2011.

Home page: \<http://savage.net.au/index.html\>.

## COPYRIGHT

Australian copyright (c) 2011, Ron Savage.

All Programs of mine are 'OSI Certified Open Source Software'; you can redistribute them and/or modify them under the terms of The Perl License, a copy of which is available at: http://dev.perl.org/licenses/