spot
0.8.2
|
#include <tgba/tgbaexplicit.hh>
Classes | |
struct | transition |
Explicit transitions. More... | |
Public Types | |
typedef std::list< transition > | transitions_t |
Public Member Functions | |
state_explicit () | |
virtual int | compare (const spot::state *other) const |
Compares two states (that come from the same automaton). | |
virtual size_t | hash () const |
Hash a state. | |
virtual state_explicit * | clone () const |
Duplicate a state. | |
bool | empty () const |
virtual void | destroy () const |
Release a state. | |
Public Attributes | |
transitions_t | successors |
Private Member Functions | |
state_explicit (const state_explicit &other) | |
state_explicit & | operator= (const state_explicit &other) |
virtual | ~state_explicit () |
Friends | |
class | tgba_explicit_string |
class | tgba_explicit_formula |
class | tgba_explicit_number |
States used by spot::tgba_explicit.
typedef std::list<transition> spot::state_explicit::transitions_t |
spot::state_explicit::state_explicit | ( | ) | [inline] |
spot::state_explicit::state_explicit | ( | const state_explicit & | other | ) | [private] |
virtual spot::state_explicit::~state_explicit | ( | ) | [inline, private, virtual] |
virtual state_explicit* spot::state_explicit::clone | ( | ) | const [inline, virtual] |
Duplicate a state.
Implements spot::state.
virtual int spot::state_explicit::compare | ( | const spot::state * | other | ) | const [virtual] |
Compares two states (that come from the same automaton).
This method returns an integer less than, equal to, or greater than zero if this is found, respectively, to be less than, equal to, or greater than other according to some implicit total order.
This method should not be called to compare states from different automata.
Implements spot::state.
virtual void spot::state_explicit::destroy | ( | ) | const [inline, virtual] |
Release a state.
Methods from the tgba or tgba_succ_iterator always return a new state that you should deallocate with this function. Before Spot 0.7, you had to "delete" your state directly. Starting with Spot 0.7, you update your code to this function instead (which simply calls "delete"). In a future version, some subclasses will redefine destroy() to allow better memory management (e.g. no memory allocation for explicit automata).
Reimplemented from spot::state.
bool spot::state_explicit::empty | ( | ) | const [inline] |
References successors.
virtual size_t spot::state_explicit::hash | ( | ) | const [virtual] |
Hash a state.
This method returns an integer that can be used as a hash value for this state.
Note that the hash value is guaranteed to be unique for all equal states (in compare()'s sense) for only has long has one of these states exists. So it's OK to use a spot::state as a key in a hash_map
because the mere use of the state as a key in the hash will ensure the state continues to exist.
However if you create the state, get its hash key, delete the state, recreate the same state, and get its hash key, you may obtain two different hash keys if the same state were not already used elsewhere. In practice this weird situation can occur only when the state is BDD-encoded, because BDD numbers (used to build the hash value) can be reused for other formulas. That probably doesn't matter, since the hash value is meant to be used in a hash_map
, but it had to be noted.
Implements spot::state.
state_explicit& spot::state_explicit::operator= | ( | const state_explicit & | other | ) | [private] |
friend class tgba_explicit_formula [friend] |
friend class tgba_explicit_number [friend] |
friend class tgba_explicit_string [friend] |
Referenced by empty(), and spot::tgba_explicit_labelled< std::string, string_hash >::merge_transitions().