#include <tgba/tgbaexplicit.hh>
Inheritance diagram for spot::tgba_explicit:
Public Types | |
typedef std::list< transition * > | state |
Public Member Functions | |
tgba_explicit (bdd_dict *dict) | |
state * | set_init_state (const std::string &state) |
transition * | create_transition (const std::string &source, const std::string &dest) |
transition * | create_transition (state *source, const state *dest) |
void | add_condition (transition *t, const ltl::formula *f) |
void | add_conditions (transition *t, bdd f) |
This assumes that all variables in f are known from dict. | |
void | declare_acceptance_condition (const ltl::formula *f) |
void | copy_acceptance_conditions_of (const tgba *a) |
Copy the acceptance conditions of a tgba. | |
bool | has_acceptance_condition (const ltl::formula *f) const |
void | add_acceptance_condition (transition *t, const ltl::formula *f) |
void | add_acceptance_conditions (transition *t, bdd f) |
This assumes that all acceptance conditions in f are known from dict. | |
void | complement_all_acceptance_conditions () |
void | merge_transitions () |
state * | add_state (const std::string &name) |
virtual | ~tgba_explicit () |
virtual spot::state * | get_init_state () const |
Get the initial state of the automaton. | |
virtual tgba_succ_iterator * | succ_iter (const spot::state *local_state, const spot::state *global_state=0, const tgba *global_automaton=0) const |
virtual bdd_dict * | get_dict () const |
Get the dictionary associated to the automaton. | |
virtual std::string | format_state (const spot::state *state) const |
virtual bdd | all_acceptance_conditions () const |
Return the set of all acceptance conditions used by this automaton. | |
virtual bdd | neg_acceptance_conditions () const |
Return the conjuction of all negated acceptance variables. | |
virtual tgba_succ_iterator * | succ_iter (const state *local_state, const state *global_state=0, const tgba *global_automaton=0) const =0 |
Get an iterator over the successors of local_state. | |
bdd | support_conditions (const state *state) const |
Get a formula that must hold whatever successor is taken. | |
bdd | support_variables (const state *state) const |
Get the conjunctions of variables tested by the outgoing transitions of state. | |
virtual std::string | format_state (const state *state) const =0 |
Format the state as a string for printing. | |
virtual std::string | transition_annotation (const tgba_succ_iterator *t) const |
Return a possible annotation for the transition pointed to by the iterator. | |
virtual state * | project_state (const state *s, const tgba *t) const |
Project a state on an automaton. | |
virtual int | number_of_acceptance_conditions () const |
The number of acceptance conditions. | |
Protected Types | |
typedef Sgi::hash_map< const std::string, tgba_explicit::state *, string_hash > | ns_map |
typedef Sgi::hash_map< const tgba_explicit::state *, std::string, ptr_hash< tgba_explicit::state > > | sn_map |
Protected Member Functions | |
virtual bdd | compute_support_conditions (const spot::state *state) const |
virtual bdd | compute_support_variables (const spot::state *state) const |
bdd | get_acceptance_condition (const ltl::formula *f) |
virtual bdd | compute_support_conditions (const state *state) const =0 |
Do the actual computation of tgba::support_conditions(). | |
virtual bdd | compute_support_variables (const state *state) const =0 |
Do the actual computation of tgba::support_variables(). | |
Protected Attributes | |
ns_map | name_state_map_ |
sn_map | state_name_map_ |
bdd_dict * | dict_ |
tgba_explicit::state * | init_ |
bdd | all_acceptance_conditions_ |
bdd | neg_acceptance_conditions_ |
bool | all_acceptance_conditions_computed_ |
Private Member Functions | |
tgba_explicit (const tgba_explicit &other) | |
tgba_explicit & | tgba_explicit::operator= (const tgba_explicit &other) |
Classes | |
struct | transition |
Explicit transitions (used by spot::tgba_explicit). More... |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
This assumes that all acceptance conditions in f are known from dict.
|
|
|
|
This assumes that all variables in f are known from dict.
|
|
Return the tgba_explicit::state for name, creating the state if it does not exist. |
|
Return the set of all acceptance conditions used by this automaton. The goal of the emptiness check is to ensure that a strongly connected component walks through each of these acceptiong conditions. I.e., the union of the acceptiong conditions of all transition in the SCC should be equal to the result of this function. Implements spot::tgba. |
|
|
|
Do the actual computation of tgba::support_conditions().
Implemented in spot::tgba_bdd_concrete, spot::tgba_product, and spot::tgba_tba_proxy. |
|
|
|
Do the actual computation of tgba::support_variables().
Implemented in spot::tgba_bdd_concrete, spot::tgba_product, and spot::tgba_tba_proxy. |
|
|
|
Copy the acceptance conditions of a tgba. If used, this function should be called before creating any transition. |
|
|
|
|
|
|
|
Format the state as a string for printing. This formating is the responsability of the automata who owns the state. Implemented in spot::tgba_bdd_concrete, spot::tgba_product, and spot::tgba_tba_proxy. |
|
Reimplemented in spot::tgba_reduc. |
|
|
|
Get the dictionary associated to the automaton. State are represented as BDDs. The dictionary allows to map BDD variables back to formulae, and vice versa. This is useful when dealing with several automata (which may use the same BDD variable for different formula), or simply when printing. Implements spot::tgba. |
|
Get the initial state of the automaton.
The state has been allocated with Implements spot::tgba. |
|
|
|
|
|
Return the conjuction of all negated acceptance variables.
For instance if the automaton uses variables This is useful when making products: each operand's condition set should be augmented with the neg_acceptance_conditions() of the other operand. Implements spot::tgba. |
|
The number of acceptance conditions.
|
|
Project a state on an automaton. This converts s, into that corresponding spot::state for t. This is useful when you have the state of a product, and want restrict this state to a specific automata occuring in the product. It goes without saying that s and t should be compatible (i.e., s is a state of t).
Reimplemented in spot::tgba_product, and spot::tgba_tba_proxy. |
|
|
|
Get an iterator over the successors of local_state.
The iterator has been allocated with During synchornized products, additional informations are passed about the entire product and its state. Recall that products can be nested, forming a tree of spot::tgba where most values are computed on demand. global_automaton designate the root spot::tgba, and global_state its state. This two objects can be used by succ_iter() to restrict the set of successors to compute.
Implemented in spot::tgba_bdd_concrete, spot::tgba_product, and spot::tgba_tba_proxy. |
|
|
|
Get a formula that must hold whatever successor is taken.
bddtrue , or more completely the disjunction of the condition of all successors. This is used as an hint by succ_iter() to reduce the number of successor to compute in a product.Sub classes should implement compute_support_conditions(), this function is just a wrapper that will cache the last return value for efficiency. |
|
Get the conjunctions of variables tested by the outgoing transitions of state. All variables tested by outgoing transitions must be returned. This is mandatory.
This is used as an hint by some Sub classes should implement compute_support_variables(), this function is just a wrapper that will cache the last return value for efficiency. |
|
|
|
Return a possible annotation for the transition pointed to by the iterator. Implementing this function is optional; the default annotation it the empty string.
Reimplemented in spot::tgba_product, and spot::tgba_tba_proxy. |
|
|
|
|
|
|
|
|
|
|
|
|
|
|