Main Page | Modules | Namespace List | Class Hierarchy | Class List | Directories | File List | Namespace Members | Class Members | File Members

spot::tgba_explicit Class Reference
[TGBA representations]

#include <tgba/tgbaexplicit.hh>

Inheritance diagram for spot::tgba_explicit:

Inheritance graph
[legend]
Collaboration diagram for spot::tgba_explicit:

Collaboration graph
[legend]
List of all members.

Public Types

typedef std::list< transition * > state

Public Member Functions

 tgba_explicit (bdd_dict *dict)
stateset_init_state (const std::string &state)
transitioncreate_transition (const std::string &source, const std::string &dest)
transitioncreate_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 ()
stateadd_state (const std::string &name)
virtual ~tgba_explicit ()
virtual spot::stateget_init_state () const
 Get the initial state of the automaton.
virtual tgba_succ_iteratorsucc_iter (const spot::state *local_state, const spot::state *global_state=0, const tgba *global_automaton=0) const
virtual bdd_dictget_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_iteratorsucc_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 stateproject_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_dictdict_
tgba_explicit::stateinit_
bdd all_acceptance_conditions_
bdd neg_acceptance_conditions_
bool all_acceptance_conditions_computed_

Private Member Functions

 tgba_explicit (const tgba_explicit &other)
tgba_explicittgba_explicit::operator= (const tgba_explicit &other)

Classes

struct  transition
 Explicit transitions (used by spot::tgba_explicit). More...

Detailed Description

Explicit representation of a spot::tgba.


Member Typedef Documentation

typedef Sgi::hash_map<const std::string, tgba_explicit::state*, string_hash> spot::tgba_explicit::ns_map [protected]
 

typedef Sgi::hash_map<const tgba_explicit::state*, std::string, ptr_hash<tgba_explicit::state> > spot::tgba_explicit::sn_map [protected]
 

typedef std::list<transition*> spot::tgba_explicit::state
 


Constructor & Destructor Documentation

spot::tgba_explicit::tgba_explicit bdd_dict dict  ) 
 

virtual spot::tgba_explicit::~tgba_explicit  )  [virtual]
 

spot::tgba_explicit::tgba_explicit const tgba_explicit other  )  [private]
 


Member Function Documentation

void spot::tgba_explicit::add_acceptance_condition transition t,
const ltl::formula f
 

void spot::tgba_explicit::add_acceptance_conditions transition t,
bdd  f
 

This assumes that all acceptance conditions in f are known from dict.

void spot::tgba_explicit::add_condition transition t,
const ltl::formula f
 

void spot::tgba_explicit::add_conditions transition t,
bdd  f
 

This assumes that all variables in f are known from dict.

state* spot::tgba_explicit::add_state const std::string &  name  ) 
 

Return the tgba_explicit::state for name, creating the state if it does not exist.

virtual bdd spot::tgba_explicit::all_acceptance_conditions  )  const [virtual]
 

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.

void spot::tgba_explicit::complement_all_acceptance_conditions  ) 
 

virtual bdd spot::tgba::compute_support_conditions const state state  )  const [protected, pure virtual, inherited]
 

Do the actual computation of tgba::support_conditions().

Implemented in spot::tgba_bdd_concrete, spot::tgba_product, and spot::tgba_tba_proxy.

virtual bdd spot::tgba_explicit::compute_support_conditions const spot::state state  )  const [protected, virtual]
 

virtual bdd spot::tgba::compute_support_variables const state state  )  const [protected, pure virtual, inherited]
 

Do the actual computation of tgba::support_variables().

Implemented in spot::tgba_bdd_concrete, spot::tgba_product, and spot::tgba_tba_proxy.

virtual bdd spot::tgba_explicit::compute_support_variables const spot::state state  )  const [protected, virtual]
 

void spot::tgba_explicit::copy_acceptance_conditions_of const tgba a  ) 
 

Copy the acceptance conditions of a tgba.

If used, this function should be called before creating any transition.

transition* spot::tgba_explicit::create_transition state source,
const state dest
 

transition* spot::tgba_explicit::create_transition const std::string &  source,
const std::string &  dest
 

void spot::tgba_explicit::declare_acceptance_condition const ltl::formula f  ) 
 

virtual std::string spot::tgba::format_state const state state  )  const [pure virtual, inherited]
 

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.

virtual std::string spot::tgba_explicit::format_state const spot::state state  )  const [virtual]
 

Reimplemented in spot::tgba_reduc.

bdd spot::tgba_explicit::get_acceptance_condition const ltl::formula f  )  [protected]
 

virtual bdd_dict* spot::tgba_explicit::get_dict  )  const [virtual]
 

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.

virtual spot::state* spot::tgba_explicit::get_init_state  )  const [virtual]
 

Get the initial state of the automaton.

The state has been allocated with new. It is the responsability of the caller to delete it when no longer needed.

Implements spot::tgba.

bool spot::tgba_explicit::has_acceptance_condition const ltl::formula f  )  const
 

void spot::tgba_explicit::merge_transitions  ) 
 

virtual bdd spot::tgba_explicit::neg_acceptance_conditions  )  const [virtual]
 

Return the conjuction of all negated acceptance variables.

For instance if the automaton uses variables Acc[a], Acc[b] and Acc[c] to describe acceptance sets, this function should return !Acc[a]&!Acc[b]&!Acc[c].

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.

virtual int spot::tgba::number_of_acceptance_conditions  )  const [virtual, inherited]
 

The number of acceptance conditions.

virtual state* spot::tgba::project_state const state s,
const tgba t
const [virtual, inherited]
 

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).

Returns:
0 if the projection fails (s is unrelated to t), or a new state* (the projected state) that must be deleted by the caller.

Reimplemented in spot::tgba_product, and spot::tgba_tba_proxy.

state* spot::tgba_explicit::set_init_state const std::string &  state  ) 
 

virtual tgba_succ_iterator* spot::tgba::succ_iter const state local_state,
const state global_state = 0,
const tgba global_automaton = 0
const [pure virtual, inherited]
 

Get an iterator over the successors of local_state.

The iterator has been allocated with new. It is the responsability of the caller to delete it when no longer needed.

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.

Parameters:
local_state The state whose successors are to be explored. This pointer is not adopted in any way by succ_iter, and it is still the caller's responsability to delete it when appropriate (this can be done during the lifetime of the iterator).
global_state In a product, the state of the global product automaton. Otherwise, 0. Like locale_state, global_state is not adopted by succ_iter.
global_automaton In a product, the global product automaton. Otherwise, 0.

Implemented in spot::tgba_bdd_concrete, spot::tgba_product, and spot::tgba_tba_proxy.

virtual tgba_succ_iterator* spot::tgba_explicit::succ_iter const spot::state local_state,
const spot::state global_state = 0,
const tgba global_automaton = 0
const [virtual]
 

bdd spot::tgba::support_conditions const state state  )  const [inherited]
 

Get a formula that must hold whatever successor is taken.

Returns:
A formula which must be verified for all successors of state.
This can be as simple as 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.

bdd spot::tgba::support_variables const state state  )  const [inherited]
 

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 succ_iter() to reduce the number of successor to compute in a product.

Sub classes should implement compute_support_variables(), this function is just a wrapper that will cache the last return value for efficiency.

tgba_explicit& spot::tgba_explicit::tgba_explicit::operator= const tgba_explicit other  )  [private]
 

virtual std::string spot::tgba::transition_annotation const tgba_succ_iterator t  )  const [virtual, inherited]
 

Return a possible annotation for the transition pointed to by the iterator.

Implementing this function is optional; the default annotation it the empty string.

Parameters:
t a non-done tgba_succ_iterator for this automata

Reimplemented in spot::tgba_product, and spot::tgba_tba_proxy.


Member Data Documentation

bdd spot::tgba_explicit::all_acceptance_conditions_ [mutable, protected]
 

bool spot::tgba_explicit::all_acceptance_conditions_computed_ [mutable, protected]
 

bdd_dict* spot::tgba_explicit::dict_ [protected]
 

tgba_explicit::state* spot::tgba_explicit::init_ [protected]
 

ns_map spot::tgba_explicit::name_state_map_ [protected]
 

bdd spot::tgba_explicit::neg_acceptance_conditions_ [protected]
 

sn_map spot::tgba_explicit::state_name_map_ [protected]
 


The documentation for this class was generated from the following file:
Please comment this page and report errors about it on the RefDocComments page.
Generated on Mon Jan 31 12:55:37 2005 for spot by doxygen 1.4.0