faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr > Class Template Reference
[Generator Classes]

#include <agenerator.h>

Inheritance diagram for faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >:

faudes::vGenerator faudes::TcGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr > List of all members.

Detailed Description

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
class faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >

Model of the common five-tupel G := (X, Sigma, Delta, X_0, X_m).

Core Members

Generators are be used to represent the closed and the marked language L(G) and L_m(G) respectively. The core members of a Generator are

Parameters:
mAlphabet the Alphabet Sigma, type faudes::EventSet
mStates the stateset X, type faudes::StateSet
mTransRel the transitionrelation Delta, type faudes::TransSet
mInitStates the set of initial states X_0, type faudes::StateSet
mMarkedStates the set of marked statesX_m, type faudes::StateSet
The main purpose of this class is to provide functions that allow read and write access to the core mebmers, ie inserting and deleting of events, states and transitions. There are also functions for reachability properties eg trimming the generator.

States, events and transitions in a generator can be addressed in three alternative methods:

For read access, const refererences to sets are provided. In order to allow for consistency checks, write access is via generator methods only. When the compiletime option FAUDES_CHECKED is defined, write methods throw an exception on inconsistent data, eg. setting an initial state that is not an element of the state set, or introducung a transition with an event label that is not in the alphabet.

Events Versus States

While both events and states are represented by the integer type faudes::Idx, there is a fundamental distinction between both. Events are global enteties in the sense that whether two generators share events or not does matter. Thus, each two events are related regardless the generators in which they occur. States however, are local to the generator where they are defined and whether states from different generators have or dont have the same index is irrelevant.

In consequence of the different charakter of events and states, there is one global sybmoltable that provides event names, while there is a local state symbol table for each generator. Furthermore, state names are considered cosmetic and hence are optional, while event names are mandatory.

Example: two machines both refer to the event name "alpha" that models the process of passing a workpiece from one machine to the other. In libFAUDES this is indeed modelled as one event which is represented by one index. However, both machines may have a state "Idle" which indicates that the respective machine is idle. In libFAUDES the two states are treated locally to the generators and whether or not they have the same index is regarded irrelevant.

The Generator class carries a flag to indicate that functions with result type Generator shall attach names to the newly created states, perhaps based on the state names of the respective arguments. Turning of this feature and avoiding state names alltogether considerably increases libFAUDES performance.

File IO

The fileformat of a Generator consists of a Generator section that includes one subsection for each core member. It is illustrated by the below example

 <Generator>
 % libFAUDES Generator for the simple machine
 "simple machine"                   

 <Alphabet>                         
 "alpha" "beta" "mue" "lambda"      
 </Alphabet>

 <States>                           
 "idle" "busy" "down"
 </States>

 <TransRel>
 "idle" "alpha" "busy"
 "busy" "beta" "idle"
 "busy" "mue" "down"
 "down" "lambda" "idle"
 </TransRel>
 
 <InitStates>
 "idle"
 </InitStates>
 
 <MarkedStates>
 "idle"
 </MarkedStates>
 </Generator>

Note that for file IO states may be represented either ba symbolic name or index. However, when writing a file indices will be chosen consecutively and beginning at 1. Thus, state indices are not maintained by file IO. Events are always represented by their symbolic name.

Attributes

The TaGenerator takes four template parameters for attribute classes. There is a dummy class faudes::AttributeVoid that effectively results in a generator with no attributes. A convenience typedef defines the type Generator as a TaGenerator with void attributes and this is the intended type to represent plain finite state machines.

In the context of a TaGenerator, also non-trivial attributes attributes have only minimal sematics: they can be accessed in a per event, state and transition manner and they can have default or non-default value. The minimum interface that an attribute class parameter must provide, is given in faudes::AttributeVoid. Derived classes can provide addtional semantics, eg faudes::AttributeFlags for boolean flags and faudes::AttributeCFlags for controllability properties. The TaGenerator transparently support extended attribute semantics, buit does not provide taylored acces function. This is done in TaGenerator derivates eg TcGenerator.

Definition at line 167 of file agenerator.h.

Public Types

typedef TaTransSet< TransAttr > ATransSet
 Convenience typdef for member transiton set.

Public Member Functions

Constructors & Destructor
 TaGenerator (void)
 Construct an emtpy Generator.
 TaGenerator (const TaGenerator &rOtherGen)
 Copy-constructor (from TaGenerator, incl attributes).
 TaGenerator (const vGenerator &rOtherGen)
 Copy-constructor (from vGenerator, set attributes to default).
 TaGenerator (const char *pFileName)
 Construct from file.
TaGeneratorNewP (void) const
 Construct on heap.
virtual TaGenerator NewAGen (void) const
 Construct on stack.
virtual ~TaGenerator (void)
 Destructor.
Copy and Assignment
virtual void Copy (TaGenerator &rGen) const
 Copy to other TaGenerator (incl attributes).
virtual void Copy (vGenerator &rGen) const
 Copy to other vGenerator (set attributes to default).
virtual void Move (TaGenerator &rGen)
 Destructive copy to other TaGenerator (incl attributes).
virtual void Move (vGenerator &rGen)
 Destructive copy to other vGenerator (set attributes to default).
virtual TaGeneratoroperator= (const TaGenerator &rOtherGen)
 Assignment operator (uses Copy(TaGenerator&) ).
virtual TaGeneratoroperator= (const vGenerator &rOtherGen)
 Assignment operator (uses Copy(vGenerator&) ).
void Version (Idx version, TaGenerator &rResGen)
 Create another version of this generator.
void Version (const std::string &rVersion, TaGenerator &rResGen)
 Create another version of this generator.
File IO
void Write (void) const
 Write to console.
std::string ToString (void) const
 Write to string.
void Write (const char *pFileName, std::ios::openmode openmode=std::ios::out|std::ios::trunc)
 Write to file (using minimal state indices).
void Write (TokenWriter &rTw) const
 Write to TokenWriter.
void DWrite (void) const
 Write to console (for debugging).
void WriteAlphabet (void) const
 Write generators alphabet to console.
std::string AlphabetToString (void) const
 Write generators alphabet to string.
void WriteAlphabet (TokenWriter &rTw) const
 Write generators alphabet to tokenwriter.
template<class OtherAttr>
void WriteStateSet (const TaIndexSet< OtherAttr > &rStateSet) const
 Write a stateset to console.
void WriteStateSet (const StateSet &rStateSet) const
 Write a stateset to console.
template<class OtherAttr>
std::string StateSetToString (const TaIndexSet< OtherAttr > &rStateSet) const
 Write a stateset to string.
std::string StateSetToString (const StateSet &rStateSet) const
 Write a stateset to string.
template<class OtherAttr>
void WriteStateSet (TokenWriter &rTw, const TaIndexSet< OtherAttr > &rStateSet) const
 Write a stateset to TokenWriter.
void WriteStateSet (TokenWriter &rTw, const StateSet &rStateSet) const
 Write a stateset to TokenWriter.
template<class OtherAttr>
void DWriteStateSet (TokenWriter &rTw, const TaIndexSet< OtherAttr > &rStateSet) const
 Write a stateset to TokenWriter (debug version).
void DWriteStateSet (TokenWriter &rTw, const StateSet &rStateSet) const
 Write a stateset to TokenWriter (debug version, no re-indexing).
std::string StatesToString (void) const
 Write stateset of this generator to a string (no re-indexing).
std::string MarkedStatesToString (void) const
 Write set of marked states to a string (no re-indexing).
std::string InitStatesToString (void) const
 Write set of initial states to a string (no re-indexing).
void WriteTransRel (void) const
 Write transition relation to console (no re-indexing).
std::string TransRelToString (void) const
 Write transition relation to string (no re-indexing).
void WriteTransRel (TokenWriter &rTw) const
 Write transition relation to tokenwriter (no re-indexing) Re-indexing and symbolic state names are handled in the same way as with state sets: this function refers to the generators state symboltable to obtain state names and uses the mMinStateIndexMap to re-index the output.
void DWriteTransRel (TokenWriter &rTw) const
 Write transition relation to tokenwriter (debug version).
void WriteStatistics (void) const
 Write statistics to console.
std::string StatisticsToString (void) const
 Write statistics to string.
void WriteStatistics (TokenWriter &rTw) const
 Write statistics to tokenwriter Produce statistics (number of states etc.
void DotWrite (const std::string &rFileName)
 Writes generator to dot input format.
void DDotWrite (const std::string &rFileName) const
 Writes generator to dot input format (no re-indexing) Variant of DotWrite() without re-indexing.
void XDotWrite (const std::string &rFileName) const
 Writes generator to dot input format (for export to VioLib).
void Read (const char *pFileName)
 Read generator from file.
void Read (TokenReader &rTr)
 Read generator from TokenReader.
void ReadStateSet (TokenReader &rTr, const std::string &rLabel, StateSet &rStateSet) const
 Read a state set.
Basic Maintenance
bool Valid (void)
 Check if generator is valid.
virtual void Clear (void)
 Clear alphabet, states and transitions (initial states and marked states also).
void ClearStates (void)
 Clear all states and transitions.
Idx AlphabetSize (void) const
 Get number of events in mAlphabet.
Idx Size (void) const
 Get generator size (# of states).
Idx TransRelSize (void) const
 Get number of transitions.
Idx InitStatesSize (void) const
 Get number of initial states.
Idx MarkedStatesSize (void) const
 Get number of marked states.
bool Empty (void) const
 Check if generator is empty (no states).
bool AlphabetEmpty (void) const
 Check if mAlphabet is Empty.
bool TransRelEmpty (void) const
 Check if transition relation is empty.
bool InitStatesEmpty (void) const
 Check if set of initial states is empty.
bool MarkedStatesEmpty (void) const
 Check if set of marked states is empty.
EventSet UsedEvents (void) const
 Return used events (executed in transitions).
EventSet UnusedEvents (void) const
 Return unused events.
EventSet ActiveEventSet (Idx x1) const
 Return active event set at state x1.
StateSet TransRelStateSpace (void) const
 Return the states covered by transitions als indices.
StateSet TransRelStateSpace (Idx x1) const
 Return the successor states of state x1.
virtual bool UpdateAttributes (void)
 Updates internal attributes.
Read Access to Core Members
EventSet::Iterator AlphabetBegin (void) const
 iterator to Begin() of mAlphabet
EventSet::Iterator AlphabetEnd (void) const
 iterator to End() of mAlphabet
bool ExistsEvent (Idx index) const
 Test existence of event in mAlphabet.
bool ExistsEvent (const std::string &rName) const
 Test existence of event in mAlphabet.
EventSet::Iterator FindEvent (Idx index) const
 Returns a iterator to event index in mAlphabet.
EventSet::Iterator FindEvent (const std::string &rName) const
 Returns a iterator to event index in mAlphabet.
const TaNameSet< EventAttr > & Alphabet (void) const
 Return const reference to mAlphabet.
StateSet::Iterator StatesBegin (void) const
 iterator to Begin() of mStates
StateSet::Iterator StatesEnd (void) const
 iterator to End() of mStates
bool ExistsState (Idx index) const
 Test existence of state in mStates.
bool ExistsState (const std::string &name) const
 Test existence of state in mStates.
StateSet::Iterator FindState (Idx index) const
 Returns a iterator to state index in mStates.
StateSet::Iterator FindState (const std::string &rName) const
 Returns a iterator to state with specified name.
const TaIndexSet< StateAttr > & States (void) const
 Return reference to mStates.
Idx InitState (void) const
 Return initial state.
StateSet::Iterator InitStatesBegin (void) const
 Iterator to Begin() of mInitStates.
StateSet::Iterator InitStatesEnd (void) const
 Iterator to End() of mInitStates.
bool ExistsInitState (Idx index) const
 Test existence of state in mInitStates.
StateSet::Iterator FindInitState (Idx index) const
 Returns a iterator to state index in mInitStates.
const StateSetInitStates (void) const
 Return const ref to initial states.
StateSet::Iterator MarkedStatesBegin (void) const
 iterator to Begin() of mMarkedStates
StateSet::Iterator MarkedStatesEnd (void) const
 iterator to End() of mMarkedStates
bool ExistsMarkedState (Idx index) const
 Test existence of state in mMarkedStates.
StateSet::Iterator FindMarkedState (Idx index) const
 Returns a iterator to state index in mMarkedStates.
const StateSetMarkedStates (void) const
 Return const ref of marked states.
ATransSet::Iterator TransRelBegin (void) const
 iterator to Begin() of transition relation
ATransSet::Iterator TransRelEnd (void) const
 iterator to End() of transition relation
ATransSet::Iterator TransRelBegin (Idx x1) const
 iterator to begin of transitions with x1 as predecessor state.
ATransSet::Iterator TransRelEnd (Idx x1) const
 iterator to end of transitions with x1 as predecessor state.
ATransSet::Iterator TransRelBegin (Idx x1, Idx ev) const
 iterator to begin of transitions with x1 as predecessor state and event ev.
ATransSet::Iterator TransRelEnd (Idx x1, Idx ev) const
 iterator to end of transitions with x1 as predecessor state and event ev.
ATransSet::Iterator FindTransition (const std::string &rX1, const std::string &rEv, const std::string &rX2) const
 iterator to transition given by x1, ev, x2
ATransSet::Iterator FindTransition (Idx x1, Idx ev, Idx x2) const
 iterator to transition given by x1, ev, x2
ATransSet::Iterator FindTransition (const Transition &rTrans) const
 iterator to transition
bool ExistsTransition (const std::string &rX1, const std::string &rEv, const std::string &rX2) const
 test for transition given by x1, ev, x2
bool ExistsTransition (Idx x1, Idx ev, Idx x2) const
 test for transition given by x1, ev, x2
bool ExistsTransition (const Transition &rTrans) const
 test for transition
const ATransSetTransRel (void) const
 Return reference to transition relation.
void TransRel (TransSetX1EvX2 &res) const
 Get copy of trantision relation sorted by other compare operator, e.g.
void TransRel (TransSetEvX1X2 &res) const
void TransRel (TransSetEvX2X1 &res) const
void TransRel (TransSetX2EvX1 &res) const
void TransRel (TransSetX2X1Ev &res) const
void TransRel (TransSetX1X2Ev &res) const
Write Access to Core Members
bool InsEvent (Idx index)
 Add an existing event to mAlphabet by index.
Idx InsEvent (const std::string &rName)
 Add named event to generator.
bool InsEvent (Idx index, const EventAttr &attr)
 Add an existing event to mAlphabet by index, with attribute.
Idx InsEvent (const std::string &rName, const EventAttr &attr)
 Add named event with attribute to generator.
void InsEvents (const EventSet &events)
 Add new named events to generator.
bool DelEvent (Idx index)
 Delete event from generator by index.
bool DelEvent (const std::string &rName)
 Delete event from generator by name.
void DelEvents (const EventSet &rEvents)
 Delete a set of events from generator.
bool DelEventFromAlphabet (Idx index)
 Delete event from Alphabet without consistency check.
void InjectAlphabet (const EventSet &rNewalphabet)
 Set mAlphabet without consistency check.
void InjectAlphabet (const TaNameSet< EventAttr > &rNewalphabet)
 Set mAlphabet without consistency check (incl attributes).
Idx InsState (void)
 Add new anonymous state to generator.
Idx InsState (const StateAttr &attr)
 Add new anonymous state with attribute to generator.
bool InsState (Idx index)
 Add (perhaps new) state to generator.
Idx InsState (const std::string &rName)
 Add new named state to generator.
Idx InsState (const std::string &rName, const StateAttr &attr)
 Add new named state with attribute to generator.
bool InsState (Idx index, const StateAttr &attr)
 Add (perhaps new) state with attribute to generator.
bool DelState (Idx index)
 Delete a state from generator by index.
bool DelState (const std::string &rName)
 Delete a state from generator by name.
void DelStates (const StateSet &rDelStates)
 Delete a set of states Cleans mStates, mInitStates, mMarkedStates, mTransrel, and mpStateSymboltable.
bool DelStateFromStates (Idx index)
 Delete a state from generator without consistency check.
StateSet::Iterator DelStateFromStates (StateSet::Iterator pos)
 Delete a state from generator without consistency check.
void InjectState (Idx index)
 Inject an existing state index into generators mStates Use with care! For use in optimized functions.
void InjectStates (const StateSet &rNewStates)
 Inject a complete mStates without consistency checks (without attributes).
Idx InsInitState (void)
 Create new anonymous state and set as initial state.
Idx InsInitState (const std::string &rName)
 Create a new named state and set as initial state.
Idx InsMarkedState (void)
 Create new anonymous state and set as marked state.
Idx InsMarkedState (const std::string &rName)
 Create a new named state and set as marked state.
void SetInitState (Idx index)
 Set an existing state as initial state by index.
void SetInitState (const std::string &rName)
 Set an existing state as initial state by name.
void InjectInitStates (const StateSet &rNewInitStates)
 Replace mInitStates with StateSet given as parameter without consistency checks.
void ClrInitState (Idx index)
 Unset an existing state as initial state by index.
void ClrInitState (const std::string &rName)
 Unset an existing state as initial state by name (only for user interactions).
void ClrInitState (StateSet::Iterator pos)
 Unset an existing state as initial state by iterator.
void ClearInitStates (void)
 Clear all mInitStates.
void SetMarkedState (Idx index)
 Set an existing state as marked state by index.
void SetMarkedState (const std::string &rName)
 Set an existing state as marked state by name.
void ClrMarkedState (Idx index)
 Unset an existing state as marked state by index.
void ClrMarkedState (const std::string &rName)
 Unset an existing state as marked state by name (only for user interactions).
void ClrMarkedState (StateSet::Iterator pos)
 Unset an existing state as marked state by iterator.
void ClearMarkedStates (void)
 Clear all marked states.
void InjectMarkedStates (const StateSet &rNewMarkedStates)
 Replace mMarkedStates with StateSet given as parameter without consistency checks.
bool SetTransition (Idx x1, Idx ev, Idx x2)
 Add a transition to generator by indices.
bool SetTransition (const std::string &rX1, const std::string &rEv, const std::string &rX2)
 Add a transition to generator by names.
bool SetTransition (const Transition &rTransition)
 Add a transition to generator.
bool SetTransition (const Transition &rTransition, const TransAttr &rAttr)
 Add a transition with attribute to generator.
void ClrTransition (Idx x1, Idx ev, Idx x2)
 Remove a transition by indices.
void ClrTransition (const Transition &rTrans)
 Remove a transition by transition object.
ATransSet::Iterator ClrTransition (typename ATransSet::Iterator it)
 Remove a transition by iterator.
void ClearTransRel (void)
 Clear all transitions.
void InjectTransition (const Transition &rTrans)
 Set transition without consistency check.
void InjectTransRel (const TransSet &rNewtransrel)
 Set mTransRel without consistency check.
Attributes
void ClearAttributes (void)
 Clear Attributes.
void DetermineAttributes (void)
 Determine and set those attributes, that are a conseqence of other given data.
void ClearEventAttributes (void)
 Clear event attributes.
void ClrEventAttribute (Idx index)
 Clear attribute for existing event.
void EventAttribute (Idx index, const EventAttr &rAttr)
 Set attribute for existing event.
const EventAttr & EventAttribute (Idx index) const
 Event attribute lookup.
const EventAttr & EventAttribute (const std::string &rName) const
 Event attribute lookup.
EventAttr * EventAttributep (Idx index)
 Event attribute pointer (to access Attribute methods) note: may insert explicit default attribute.
EventAttr * EventAttributep (const std::string &rName)
 Event attribute pointer (to access Attribute methods) note: may insert explicit default attribute.
void ClearStateAttributes (void)
 Clear state attributes.
void ClrStateAttribute (Idx index)
 Clear attribute for existing state.
void StateAttribute (Idx index, const StateAttr &rAttr)
 Set attribute for existing state.
const StateAttr & StateAttribute (Idx index) const
 State attribute lookup.
StateAttr * StateAttributep (Idx index)
 State attribute pointer (to access Attribute methods) note: may insert explicit default attribute.
void ClearTransAttributes (void)
 Clear transition attributes.
void TransAttribute (const Transition &rTrans, const TransAttr &rAttr)
 Set attribute for existing transition.
void ClrTransAttribute (const Transition &rTrans)
 Clear attribute for existing transition.
const TransAttr & TransAttribute (const Transition &rTrans) const
 get attribute for existing transition
TransAttr * TransAttributep (const Transition &rTrans)
 get attribute pointer for existing transition note: may insert explicit default attribute
void ClearGlobalAttribute (void)
 Clear global attribute.
void GlobalAttribute (const GlobalAttr &rAttr)
 Set global attribute.
const GlobalAttr & GlobalAttribute (void) const
 Get attribute ref.
GlobalAttr * GlobalAttributep (void)
 Get attribute pointer.
Reachability
StateSet AccessibleSet (void) const
 Compute set of accessible states.
bool Accessible (void)
 Make generator accessible.
bool IsAccessible (void) const
 Check if generator is accessible.
StateSet CoaccessibleSet (void) const
 Compute set of Coaccessible states.
bool Coaccessible (void)
 Make generator Coaccessible.
bool IsCoaccessible (void) const
 Check if generator is Coaccessible.
StateSet TrimSet (void) const
 Computer set of trim states.
bool Trim (void)
 Make generator trim.
bool IsTrim (void) const
 Check if generator is trim.
Misc
void MinimizeAlphabet (void)
 Set the alphabet to events executed in transitions.
bool IsDeterministic (void) const
 Check if generator is deterministique We insit in exactly one initial state and for each state and event at most one transition (to some successor state).
void SetMinStateIndexMap (void)
 Set minimal index map for file io of generator states.
void ClearMinStateIndexMap (void)
 Clear minimal index map for 1:1 file io.
Idx MinStateIndex (Idx index) const
 Get state index as is it will be written to file.
SymbolTableEventSymbolTablep (void) const
 Get Pointer to EventSymbolTable.
void EventSymbolTablep (SymbolTable *pSymTab)
 Set Pointer to EventSymbolTable.
virtual void EventSymbolTablep (const vGenerator &rOtherGen)
 Set Pointer to EventSymbolTable.

Protected Member Functions

void ReadGeneratorName (const char *pFileName)
 Read the generator's name from a file.
void ReadGeneratorName (TokenReader &rTr)
 Read the generator's name from a TokenReader.
void ReadAlphabet (const char *pFileName)
 Read the generator's alphabet from a file.
void ReadAlphabet (TokenReader &rTr)
 Read the generator's alphabet from a TokenReader.
void ReadStates (const char *pFileName)
 Read the generator's mStates from a file.
void ReadStates (TokenReader &rTr)
 Read the generator's stateset from a TokenReader.
void ReadTransRel (const char *pFileName)
 Read the generator's transition relation from a file.
void ReadTransRel (TokenReader &rTr)
 Read the generator's transition relation from a TokenReader.
void CheckAccessible (StateSet &accessibleset, Idx startState) const
 Get accessible states by filling accessibleset recursive.
void CheckCoaccessible (StateSet &Coaccessibleset, const TransSetX2EvX1 &rtrel, Idx startState) const
 Get Coaccessible states by filling Coaccessibleset recursive.

Protected Attributes

TaNameSet< EventAttr > mAlphabet
 Generator alphabet.
TaIndexSet< StateAttr > mStates
 Generator state set.
ATransSet mTransRel
 Transition relation.
StateSet mInitStates
 Initial states.
StateSet mMarkedStates
 Marked states.
std::map< Idx, IdxmMinStateIndexMap
 Map State indices to consecutive indices.
GlobalAttr mGlobalAttribute
 global attribute


Member Typedef Documentation

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
typedef TaTransSet<TransAttr> faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ATransSet
 

Convenience typdef for member transiton set.

Definition at line 171 of file agenerator.h.


Constructor & Destructor Documentation

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::TaGenerator void   ) 
 

Construct an emtpy Generator.

Definition at line 2434 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::TaGenerator const TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr > &  rOtherGen  ) 
 

Copy-constructor (from TaGenerator, incl attributes).

Parameters:
rOtherGen 

Definition at line 2447 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::TaGenerator const vGenerator rOtherGen  ) 
 

Copy-constructor (from vGenerator, set attributes to default).

Parameters:
rOtherGen 

Definition at line 2458 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::TaGenerator const char *  pFileName  ) 
 

Construct from file.

This constructor uses the Read(TokenReader&) function to read.

Parameters:
pFileName Name of file
Exceptions:
Exception 
  • IO errors (id 1)
  • token mismatch (id 50, 51, 52, 80, 85)

Definition at line 2468 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::~TaGenerator void   )  [virtual]
 

Destructor.

Definition at line 2553 of file agenerator.h.


Member Function Documentation

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
bool faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::Accessible void   )  [virtual]
 

Make generator accessible.

Returns:
True if generator contains at least one initial state

Implements faudes::vGenerator.

Definition at line 4420 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
StateSet faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::AccessibleSet void   )  const [virtual]
 

Compute set of accessible states.

Implements faudes::vGenerator.

Definition at line 4409 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
EventSet faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ActiveEventSet Idx  x1  )  const [virtual]
 

Return active event set at state x1.

Parameters:
x1 x1 Idx
Returns:
EventSet

Implements faudes::vGenerator.

Definition at line 4331 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
const TaNameSet< EventAttr > & faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::Alphabet void   )  const [virtual]
 

Return const reference to mAlphabet.

Returns:
EventSet

Implements faudes::vGenerator.

Definition at line 4276 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
EventSet::Iterator faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::AlphabetBegin void   )  const [virtual]
 

iterator to Begin() of mAlphabet

Returns:
iterator to begin of mAlphabet

Implements faudes::vGenerator.

Definition at line 3493 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
bool faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::AlphabetEmpty void   )  const [virtual]
 

Check if mAlphabet is Empty.

Returns:
True if mAlphabet is empty

Implements faudes::vGenerator.

Definition at line 3468 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
EventSet::Iterator faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::AlphabetEnd void   )  const [virtual]
 

iterator to End() of mAlphabet

Returns:
iterator to end of mAlphabet

Implements faudes::vGenerator.

Definition at line 3498 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
Idx faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::AlphabetSize void   )  const [virtual]
 

Get number of events in mAlphabet.

Returns:
Number of events

Implements faudes::vGenerator.

Definition at line 3392 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
std::string faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::AlphabetToString void   )  const [virtual]
 

Write generators alphabet to string.

Returns:
std::string
Exceptions:
Exception 
  • IO errors (id 2)

Implements faudes::vGenerator.

Definition at line 2688 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::CheckAccessible StateSet accessibleset,
Idx  startState
const [protected]
 

Get accessible states by filling accessibleset recursive.

Parameters:
accessibleset Reference to StateSet with accessibel states
startState State index to start with

Definition at line 4563 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::CheckCoaccessible StateSet Coaccessibleset,
const TransSetX2EvX1 rtrel,
Idx  startState
const [protected]
 

Get Coaccessible states by filling Coaccessibleset recursive.

Parameters:
Coaccessibleset Reference to StateSet with coaccessibel states
rtrel Reverse transition relation where x1 <-> x2
startState State index to start with

Definition at line 4575 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::Clear void   )  [virtual]
 

Clear alphabet, states and transitions (initial states and marked states also).

Implements faudes::vGenerator.

Definition at line 3403 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ClearAttributes void   ) 
 

Clear Attributes.

Definition at line 3435 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ClearEventAttributes void   ) 
 

Clear event attributes.

Definition at line 3425 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ClearGlobalAttribute void   ) 
 

Clear global attribute.

Definition at line 3415 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ClearInitStates void   )  [virtual]
 

Clear all mInitStates.

Implements faudes::vGenerator.

Definition at line 3930 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ClearMarkedStates void   )  [virtual]
 

Clear all marked states.

Implements faudes::vGenerator.

Definition at line 4005 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ClearMinStateIndexMap void   )  [virtual]
 

Clear minimal index map for 1:1 file io.

Implements faudes::vGenerator.

Definition at line 4611 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ClearStateAttributes void   ) 
 

Clear state attributes.

Definition at line 3420 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ClearStates void   )  [virtual]
 

Clear all states and transitions.

Alphabet stays untouched.

Implements faudes::vGenerator.

Definition at line 3444 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ClearTransAttributes void   ) 
 

Clear transition attributes.

Definition at line 3430 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ClearTransRel void   )  [virtual]
 

Clear all transitions.

Implements faudes::vGenerator.

Definition at line 4156 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ClrEventAttribute Idx  index  ) 
 

Clear attribute for existing event.

Parameters:
index Event index

Definition at line 4168 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ClrInitState StateSet::Iterator  pos  )  [virtual]
 

Unset an existing state as initial state by iterator.

Parameters:
pos StateSet::iterator

Implements faudes::vGenerator.

Definition at line 3924 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ClrInitState const std::string &  rName  )  [virtual]
 

Unset an existing state as initial state by name (only for user interactions).

Parameters:
rName State name
Exceptions:
Exception 
  • State name not known in generator (id 90)

Implements faudes::vGenerator.

Definition at line 3910 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ClrInitState Idx  index  )  [virtual]
 

Unset an existing state as initial state by index.

Define FAUDES_CHECKED for consistency checks.

Parameters:
index State index
Exceptions:
Exception 
  • State index not found in generator (id 91)

Implements faudes::vGenerator.

Definition at line 3896 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ClrMarkedState StateSet::Iterator  pos  )  [virtual]
 

Unset an existing state as marked state by iterator.

Parameters:
pos StateSet::iterator

Implements faudes::vGenerator.

Definition at line 3999 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ClrMarkedState const std::string &  rName  )  [virtual]
 

Unset an existing state as marked state by name (only for user interactions).

Parameters:
rName State name
Exceptions:
Exception 
  • State index not found in generator (id 91)

Implements faudes::vGenerator.

Definition at line 3985 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ClrMarkedState Idx  index  )  [virtual]
 

Unset an existing state as marked state by index.

Define FAUDES_CHECKED for consistency checks.

Parameters:
index State index
Exceptions:
Exception 
  • State index not found in generator (id 91)

Implements faudes::vGenerator.

Definition at line 3971 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ClrStateAttribute Idx  index  ) 
 

Clear attribute for existing state.

Parameters:
index State index

Definition at line 4181 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ClrTransAttribute const Transition rTrans  ) 
 

Clear attribute for existing transition.

Parameters:
rTrans transition

Definition at line 4150 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ATransSet::Iterator faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ClrTransition typename ATransSet::Iterator  it  ) 
 

Remove a transition by iterator.

Parameters:
it TransSet::iterator
Returns:
iterator to next transition

Definition at line 4125 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ClrTransition const Transition rTrans  )  [virtual]
 

Remove a transition by transition object.

Parameters:
rTrans Transition object

Implements faudes::vGenerator.

Definition at line 4119 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ClrTransition Idx  x1,
Idx  ev,
Idx  x2
[virtual]
 

Remove a transition by indices.

Parameters:
x1 Predecessor state index
ev Event index
x2 Successor state index

Implements faudes::vGenerator.

Definition at line 4112 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
bool faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::Coaccessible void   )  [virtual]
 

Make generator Coaccessible.

Returns:
True if generator contains at least one marked state

Implements faudes::vGenerator.

Definition at line 4481 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
StateSet faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::CoaccessibleSet void   )  const [virtual]
 

Compute set of Coaccessible states.

Implements faudes::vGenerator.

Definition at line 4467 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::Copy vGenerator rGen  )  const [virtual]
 

Copy to other vGenerator (set attributes to default).

Parameters:
rGen Destination for copy operation.

Implements faudes::vGenerator.

Definition at line 2511 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::Copy TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr > &  rGen  )  const [virtual]
 

Copy to other TaGenerator (incl attributes).

Parameters:
rGen Destination for copy operation.

Definition at line 2480 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::DDotWrite const std::string &  rFileName  )  const [virtual]
 

Writes generator to dot input format (no re-indexing) Variant of DotWrite() without re-indexing.

Parameters:
rFileName File to write
Exceptions:
Exception 
  • IO errors (id 2)

Implements faudes::vGenerator.

Definition at line 2987 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
bool faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::DelEvent const std::string &  rName  )  [virtual]
 

Delete event from generator by name.

mpEventSymbolTable stays untouched. Transitions containing event will be removed too.

Parameters:
rName Name of event
Returns:
true, if event was in alphabet

Implements faudes::vGenerator.

Definition at line 3682 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
bool faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::DelEvent Idx  index  )  [virtual]
 

Delete event from generator by index.

mpEventSymbolTable stays untouched. Transitions containing event will be removed too.

Parameters:
index Index of event
Returns:
true, if event was in alphabet

Implements faudes::vGenerator.

Definition at line 3675 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
bool faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::DelEventFromAlphabet Idx  index  )  [virtual]
 

Delete event from Alphabet without consistency check.

The event is only deleted from mAlphabet but not from transition relation.

Parameters:
index Index of event
Returns:
true, if event was in alphabet

Implements faudes::vGenerator.

Definition at line 3700 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::DelEvents const EventSet rEvents  )  [virtual]
 

Delete a set of events from generator.

mpEventSymbolTable stays untouched. Transitions containing events will be removed too.

Parameters:
rEvents EventSet containing events to remove

Implements faudes::vGenerator.

Definition at line 3690 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
bool faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::DelState const std::string &  rName  )  [virtual]
 

Delete a state from generator by name.

Cleans mStates, mInitStates, mMarkedStates, mTransRel and mpStateSymbolTable.

Parameters:
rName Name of state to delete. Will be erased in mpStateSymbolTable too
Returns:
true, if state was in stateset
Exceptions:
Exception 
  • symbolic name not known (id 90)

Implements faudes::vGenerator.

Definition at line 3808 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
bool faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::DelState Idx  index  )  [virtual]
 

Delete a state from generator by index.

Cleans mStates, mInitStates, mMarkedStates, mTransRel and mpStateSymbolTable.

Parameters:
index Index of state to delete. Will be erased in mpStateSymbolTable too.
Returns:
true, if state was in stateset

Implements faudes::vGenerator.

Definition at line 3794 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
StateSet::Iterator faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::DelStateFromStates StateSet::Iterator  pos  )  [virtual]
 

Delete a state from generator without consistency check.

This removes the state from mStates and mpStateSymbolTable but doesn't touch mTransRel, mInitStates and mMarkedStates. Index to delete is given by iterator.

Parameters:
pos StateSet::iterator
Returns:
iteraror to next state

Implements faudes::vGenerator.

Definition at line 3854 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
bool faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::DelStateFromStates Idx  index  )  [virtual]
 

Delete a state from generator without consistency check.

This removes the state from mStates and mpStateSymbolTable but doesn't touch mTransRel, mInitStates and mMarkedStates.

Parameters:
index Index of state to delete. Will be erased in mpStateSymbolTable too
Returns:
true, if state was in stateset

Implements faudes::vGenerator.

Definition at line 3847 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::DelStates const StateSet rDelStates  )  [virtual]
 

Delete a set of states Cleans mStates, mInitStates, mMarkedStates, mTransrel, and mpStateSymboltable.

Parameters:
rDelStates StateSet containing states to delete

Implements faudes::vGenerator.

Definition at line 3824 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::DetermineAttributes void   )  [inline]
 

Determine and set those attributes, that are a conseqence of other given data.

E.g. you may set particular state flag, if this state is reachable.

This method does nothing and may be reimplemented by a class that adds semantics to attributes.

Definition at line 1923 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::DotWrite const std::string &  rFileName  )  [virtual]
 

Writes generator to dot input format.

The dot file format is specified by the graphiz package; see http://www.graphviz.org. The package includes the dot command line tool to generate a graphical representation of the generators graph. See also vGenerator::GraphWrite(). This functions sets the re-indexing to minimal indices.

Parameters:
rFileName File to write
Exceptions:
Exception 
  • IO errors (id 2)

Implements faudes::vGenerator.

Definition at line 2928 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::DWrite void   )  const [virtual]
 

Write to console (for debugging).

Implements faudes::vGenerator.

Definition at line 2657 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::DWriteStateSet TokenWriter rTw,
const StateSet rStateSet
const [virtual]
 

Write a stateset to TokenWriter (debug version, no re-indexing).

Parameters:
rTw Reference to TokenWriter
rStateSet Reference to stateset
Exceptions:
Exception 
  • IO errors (id 2)

Implements faudes::vGenerator.

Definition at line 2797 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
template<class OtherAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::DWriteStateSet TokenWriter rTw,
const TaIndexSet< OtherAttr > &  rStateSet
const
 

Write a stateset to TokenWriter (debug version).

Parameters:
rTw Reference to TokenWriter
rStateSet Reference to stateset
Exceptions:
Exception 
  • IO errors (id 2)

Definition at line 2783 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::DWriteTransRel TokenWriter rTw  )  const [virtual]
 

Write transition relation to tokenwriter (debug version).

Parameters:
rTw Reference to TokenWriter
Exceptions:
Exception 
  • IO errors (id 2)

Implements faudes::vGenerator.

Definition at line 2879 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
bool faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::Empty void   )  const [virtual]
 

Check if generator is empty (no states).

Returns:
True if mStates is empty

Implements faudes::vGenerator.

Definition at line 3473 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
const EventAttr & faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::EventAttribute const std::string &  rName  )  const
 

Event attribute lookup.

Parameters:
rName 
Returns:
reference to attribute

Definition at line 4257 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
const EventAttr & faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::EventAttribute Idx  index  )  const
 

Event attribute lookup.

Parameters:
index 
Returns:
reference to attribute

Definition at line 4247 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::EventAttribute Idx  index,
const EventAttr &  rAttr
 

Set attribute for existing event.

Parameters:
index Event index
rAttr New attribute
Exceptions:
Exception Index not found in EventSymbolMap (id 42) Name already associated with another index (id 44)

Definition at line 4161 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
EventAttr * faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::EventAttributep const std::string &  rName  ) 
 

Event attribute pointer (to access Attribute methods) note: may insert explicit default attribute.

Parameters:
rName 
Returns:
pointer to attribute

Definition at line 4262 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
EventAttr * faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::EventAttributep Idx  index  ) 
 

Event attribute pointer (to access Attribute methods) note: may insert explicit default attribute.

Parameters:
index 
Returns:
pointer to attribute

Definition at line 4252 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::EventSymbolTablep const vGenerator rOtherGen  )  [virtual]
 

Set Pointer to EventSymbolTable.

This function sets the reference to the global event symboltable according to the one used in the specified generator. The current implementation clears the generator, future versions may implement a re-indexing.

Parameters:
rOtherGen Generator to provide global event symboltable

Reimplemented from faudes::vGenerator.

Definition at line 2605 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::EventSymbolTablep SymbolTable pSymTab  )  [virtual]
 

Set Pointer to EventSymbolTable.

This function sets the reference to the event symboltable. The current implementation clears the generator, future versions may implement a re-indexing.

Parameters:
pSymTab Pointer to SymbolTable

Reimplemented from faudes::vGenerator.

Definition at line 2597 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
SymbolTable * faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::EventSymbolTablep void   )  const
 

Get Pointer to EventSymbolTable.

Returns:
Pointer to EventSymbolTable

Reimplemented from faudes::vGenerator.

Definition at line 2592 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
bool faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ExistsEvent const std::string &  rName  )  const [virtual]
 

Test existence of event in mAlphabet.

Parameters:
rName Event name
Returns:
true / false

Implements faudes::vGenerator.

Definition at line 4192 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
bool faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ExistsEvent Idx  index  )  const [virtual]
 

Test existence of event in mAlphabet.

Parameters:
index Event index
Returns:
true / false

Implements faudes::vGenerator.

Definition at line 4187 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
bool faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ExistsInitState Idx  index  )  const [virtual]
 

Test existence of state in mInitStates.

Parameters:
index State index
Returns:
true / false

Implements faudes::vGenerator.

Definition at line 4227 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
bool faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ExistsMarkedState Idx  index  )  const [virtual]
 

Test existence of state in mMarkedStates.

Parameters:
index State index
Returns:
true / false

Implements faudes::vGenerator.

Definition at line 4237 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
bool faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ExistsState const std::string &  name  )  const [virtual]
 

Test existence of state in mStates.

Parameters:
name State name
Returns:
true / false

Implements faudes::vGenerator.

Definition at line 4212 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
bool faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ExistsState Idx  index  )  const [virtual]
 

Test existence of state in mStates.

Parameters:
index State index
Returns:
true / false

Implements faudes::vGenerator.

Definition at line 4207 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
bool faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ExistsTransition const Transition rTrans  )  const [virtual]
 

test for transition

Parameters:
rTrans transition
Returns:
true / false

Implements faudes::vGenerator.

Definition at line 3568 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
bool faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ExistsTransition Idx  x1,
Idx  ev,
Idx  x2
const [virtual]
 

test for transition given by x1, ev, x2

Parameters:
x1 Predecessor state
ev Event
x2 Successor state
Returns:
true / false

Implements faudes::vGenerator.

Definition at line 3573 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
bool faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ExistsTransition const std::string &  rX1,
const std::string &  rEv,
const std::string &  rX2
const [virtual]
 

test for transition given by x1, ev, x2

Parameters:
rX1 name of Predecessor state
rEv name of Event
rX2 name of Successor state
Returns:
true / false

Implements faudes::vGenerator.

Definition at line 3578 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
EventSet::Iterator faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::FindEvent const std::string &  rName  )  const [virtual]
 

Returns a iterator to event index in mAlphabet.

Parameters:
rName Event name of index to find
Returns:
EventSet::iterator to event index

Implements faudes::vGenerator.

Definition at line 4202 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
EventSet::Iterator faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::FindEvent Idx  index  )  const [virtual]
 

Returns a iterator to event index in mAlphabet.

Parameters:
index Index to find
Returns:
EventSet::iterator to event index

Implements faudes::vGenerator.

Definition at line 4197 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
StateSet::Iterator faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::FindInitState Idx  index  )  const [virtual]
 

Returns a iterator to state index in mInitStates.

Parameters:
index Index to find
Returns:
StateSet::Iterator to state index

Implements faudes::vGenerator.

Definition at line 4232 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
StateSet::Iterator faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::FindMarkedState Idx  index  )  const [virtual]
 

Returns a iterator to state index in mMarkedStates.

Parameters:
index Index to find
Returns:
StateSet::Iterator to state index

Implements faudes::vGenerator.

Definition at line 4242 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
StateSet::Iterator faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::FindState const std::string &  rName  )  const [virtual]
 

Returns a iterator to state with specified name.

Parameters:
rName name of state to find
Returns:
StateSet::Iterator to state

Implements faudes::vGenerator.

Definition at line 4217 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
StateSet::Iterator faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::FindState Idx  index  )  const [virtual]
 

Returns a iterator to state index in mStates.

Parameters:
index Index to find
Returns:
StateSet::Iterator to state index

Implements faudes::vGenerator.

Definition at line 4222 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ATransSet::Iterator faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::FindTransition const Transition rTrans  )  const [virtual]
 

iterator to transition

Parameters:
rTrans transition
Returns:
iterator to transition or end() if not exists

Implements faudes::vGenerator.

Definition at line 3550 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ATransSet::Iterator faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::FindTransition Idx  x1,
Idx  ev,
Idx  x2
const [virtual]
 

iterator to transition given by x1, ev, x2

Parameters:
x1 Predecessor state
ev Event
x2 Successor state
Returns:
iterator to transition or End() if not exists

Implements faudes::vGenerator.

Definition at line 3556 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ATransSet::Iterator faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::FindTransition const std::string &  rX1,
const std::string &  rEv,
const std::string &  rX2
const [virtual]
 

iterator to transition given by x1, ev, x2

Parameters:
rX1 name of Predecessor state
rEv name of Event
rX2 name of Successor state
Returns:
iterator to transition or end() if not exists

Implements faudes::vGenerator.

Definition at line 3561 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
const GlobalAttr& faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::GlobalAttribute void   )  const [inline]
 

Get attribute ref.

Definition at line 2099 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::GlobalAttribute const GlobalAttr &  rAttr  )  [inline]
 

Set global attribute.

Parameters:
rAttr attribute

Definition at line 2094 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
GlobalAttr* faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::GlobalAttributep void   )  [inline]
 

Get attribute pointer.

Definition at line 2105 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
Idx faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::InitState void   )  const [virtual]
 

Return initial state.

Returns:
Index of initial state
Exceptions:
Exception 
  • initial state does not exist uniquely (id 92)

Implements faudes::vGenerator.

Definition at line 3586 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
const StateSet & faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::InitStates void   )  const [virtual]
 

Return const ref to initial states.

Returns:
StateSet

Implements faudes::vGenerator.

Definition at line 4301 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
StateSet::Iterator faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::InitStatesBegin void   )  const [virtual]
 

Iterator to Begin() of mInitStates.

Returns:
Iterator to begin of mInitStates

Implements faudes::vGenerator.

Definition at line 3598 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
bool faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::InitStatesEmpty void   )  const [virtual]
 

Check if set of initial states is empty.

Returns:
True if mInitStates is empty

Implements faudes::vGenerator.

Definition at line 3483 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
StateSet::Iterator faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::InitStatesEnd void   )  const [virtual]
 

Iterator to End() of mInitStates.

Returns:
Iterator to end of mInitStates

Implements faudes::vGenerator.

Definition at line 3603 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
Idx faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::InitStatesSize void   )  const [virtual]
 

Get number of initial states.

Returns:
Number of initial states

Implements faudes::vGenerator.

Definition at line 3458 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
std::string faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::InitStatesToString void   )  const [virtual]
 

Write set of initial states to a string (no re-indexing).

Returns:
std::string
Exceptions:
Exception 
  • IO errors (id 2)

Implements faudes::vGenerator.

Definition at line 2813 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::InjectAlphabet const TaNameSet< EventAttr > &  rNewalphabet  ) 
 

Set mAlphabet without consistency check (incl attributes).

Parameters:
rNewalphabet EventSet with new alphabet

Definition at line 3632 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::InjectAlphabet const EventSet rNewalphabet  )  [virtual]
 

Set mAlphabet without consistency check.

Parameters:
rNewalphabet EventSet with new alphabet

Implements faudes::vGenerator.

Definition at line 3618 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::InjectInitStates const StateSet rNewInitStates  )  [virtual]
 

Replace mInitStates with StateSet given as parameter without consistency checks.

Parameters:
rNewInitStates StateSet containing new mInitStates

Implements faudes::vGenerator.

Definition at line 3888 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::InjectMarkedStates const StateSet rNewMarkedStates  )  [virtual]
 

Replace mMarkedStates with StateSet given as parameter without consistency checks.

Parameters:
rNewMarkedStates StateSet containing new marked states

Implements faudes::vGenerator.

Definition at line 3963 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::InjectState Idx  index  )  [virtual]
 

Inject an existing state index into generators mStates Use with care! For use in optimized functions.

Parameters:
index State index to inject

Implements faudes::vGenerator.

Definition at line 3743 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::InjectStates const StateSet rNewStates  )  [virtual]
 

Inject a complete mStates without consistency checks (without attributes).

Parameters:
rNewStates StateSet

Implements faudes::vGenerator.

Definition at line 3750 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::InjectTransition const Transition rTrans  )  [virtual]
 

Set transition without consistency check.

Parameters:
rTrans Transition to insert

Implements faudes::vGenerator.

Definition at line 4010 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::InjectTransRel const TransSet rNewtransrel  )  [virtual]
 

Set mTransRel without consistency check.

Parameters:
rNewtransrel EventSet with new alphabet

Implements faudes::vGenerator.

Definition at line 4016 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
Idx faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::InsEvent const std::string &  rName,
const EventAttr &  attr
 

Add named event with attribute to generator.

An entry in the mpEventSymbolTable will be made if event is new.

Parameters:
rName Name of the event to add
attr attribute of event
Returns:
New unique index

Definition at line 3664 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
bool faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::InsEvent Idx  index,
const EventAttr &  attr
 

Add an existing event to mAlphabet by index, with attribute.

Parameters:
attr attribute of event
index Event index
Returns:
true, if event was new to alphabet

Definition at line 3658 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
Idx faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::InsEvent const std::string &  rName  )  [virtual]
 

Add named event to generator.

An entry in the mpEventSymbolTable will be made if event is new.

Parameters:
rName Name of the event to add
Returns:
New unique index

Implements faudes::vGenerator.

Definition at line 3652 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
bool faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::InsEvent Idx  index  )  [virtual]
 

Add an existing event to mAlphabet by index.

Parameters:
index Event index
Returns:
true, if event was new to alphabet

Implements faudes::vGenerator.

Definition at line 3646 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::InsEvents const EventSet events  )  [virtual]
 

Add new named events to generator.

Parameters:
events EventSet

Implements faudes::vGenerator.

Definition at line 3670 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
Idx faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::InsInitState const std::string &  rName  )  [virtual]
 

Create a new named state and set as initial state.

Parameters:
rName Name of the state to add
Returns:
Index of new unique state

Implements faudes::vGenerator.

Definition at line 3767 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
Idx faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::InsInitState void   )  [virtual]
 

Create new anonymous state and set as initial state.

Returns:
Index of new unique

Implements faudes::vGenerator.

Definition at line 3758 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
Idx faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::InsMarkedState const std::string &  rName  )  [virtual]
 

Create a new named state and set as marked state.

Parameters:
rName Name of the state to add
Returns:
Index of new unique state

Implements faudes::vGenerator.

Definition at line 3785 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
Idx faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::InsMarkedState void   )  [virtual]
 

Create new anonymous state and set as marked state.

Returns:
Index of new unique state

Implements faudes::vGenerator.

Definition at line 3776 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
bool faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::InsState Idx  index,
const StateAttr &  attr
 

Add (perhaps new) state with attribute to generator.

Parameters:
index index of state to add
attr attribute of new state
Returns:
true, if event was new to alphabet

Definition at line 3719 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
Idx faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::InsState const std::string &  rName,
const StateAttr &  attr
 

Add new named state with attribute to generator.

Parameters:
rName Name of the state to add
attr attribute of new state
Returns:
Index of new unique state
Exceptions:
Exception Name already exists (id 44)

Definition at line 3733 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
Idx faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::InsState const std::string &  rName  )  [virtual]
 

Add new named state to generator.

Parameters:
rName Name of the state to add
Returns:
Index of new unique state
Exceptions:
Exception Name already exists (id 44)

Implements faudes::vGenerator.

Definition at line 3725 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
bool faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::InsState Idx  index  )  [virtual]
 

Add (perhaps new) state to generator.

Returns:
true to indicate that state was new to generator

Implements faudes::vGenerator.

Definition at line 3713 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
Idx faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::InsState const StateAttr &  attr  ) 
 

Add new anonymous state with attribute to generator.

Parameters:
attr attribute of new state
Returns:
Index of new unique state

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
Idx faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::InsState void   )  [virtual]
 

Add new anonymous state to generator.

Returns:
Index of new unique state

Implements faudes::vGenerator.

Definition at line 3707 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
bool faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::IsAccessible void   )  const [virtual]
 

Check if generator is accessible.

Returns:
True if generator contains at least one initial state

Implements faudes::vGenerator.

Definition at line 4455 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
bool faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::IsCoaccessible void   )  const [virtual]
 

Check if generator is Coaccessible.

Returns:
True if generator contains at least one marked state

Implements faudes::vGenerator.

Definition at line 4516 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
bool faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::IsDeterministic void   )  const [virtual]
 

Check if generator is deterministique We insit in exactly one initial state and for each state and event at most one transition (to some successor state).

This definition matches the situation where a generator is defined to have one inital state as opposed to a set set of initial states (which may be empty). In particular, the generated language of a determinitstic generator allways includes the empty string and therefor is not the empty set. When focuus is on the marked language only, this issue does not exists.

Returns:
True if Generator is deterministic

Implements faudes::vGenerator.

Definition at line 4588 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
bool faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::IsTrim void   )  const [virtual]
 

Check if generator is trim.

Returns:
True if generator is trim

Implements faudes::vGenerator.

Definition at line 4551 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
const StateSet & faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::MarkedStates void   )  const [virtual]
 

Return const ref of marked states.

Returns:
StateSet

Implements faudes::vGenerator.

Definition at line 4306 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
StateSet::Iterator faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::MarkedStatesBegin void   )  const [virtual]
 

iterator to Begin() of mMarkedStates

Returns:
iterator to Begin of mMarkedStates

Implements faudes::vGenerator.

Definition at line 3608 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
bool faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::MarkedStatesEmpty void   )  const [virtual]
 

Check if set of marked states is empty.

Returns:
True if mMarkedStates is empty

Implements faudes::vGenerator.

Definition at line 3488 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
StateSet::Iterator faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::MarkedStatesEnd void   )  const [virtual]
 

iterator to End() of mMarkedStates

Returns:
iterator to End of mMarkedStates

Implements faudes::vGenerator.

Definition at line 3613 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
Idx faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::MarkedStatesSize void   )  const [virtual]
 

Get number of marked states.

Returns:
Number of marked states

Implements faudes::vGenerator.

Definition at line 3463 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
std::string faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::MarkedStatesToString void   )  const [virtual]
 

Write set of marked states to a string (no re-indexing).

Returns:
std::string
Exceptions:
Exception 
  • IO errors (id 2)

Implements faudes::vGenerator.

Definition at line 2808 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::MinimizeAlphabet void   )  [virtual]
 

Set the alphabet to events executed in transitions.

Implements faudes::vGenerator.

Definition at line 4311 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
Idx faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::MinStateIndex Idx  index  )  const
 

Get state index as is it will be written to file.

Parameters:
index state index
Returns:
minimal index

Definition at line 4617 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::Move vGenerator rGen  )  [virtual]
 

Destructive copy to other vGenerator (set attributes to default).

This is the intended interface definition for a copy method with increased performance at the cost of clearing the source data. However, the current implementation calls std copy.

Parameters:
rGen Destination for copy operation.

Implements faudes::vGenerator.

Definition at line 2546 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::Move TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr > &  rGen  )  [virtual]
 

Destructive copy to other TaGenerator (incl attributes).

This is the intended interface definition for a copy method with increased performance at the cost of clearing the source data. However, the current implementation calls std copy.

Parameters:
rGen Destination for copy operation.

Definition at line 2538 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr > faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::NewAGen void   )  const [virtual]
 

Construct on stack.

Technically not a constructor, this function creates a TaGenerator with the same event symboltable and the same attribute type.

Returns:
new Generator

Definition at line 2568 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr > * faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::NewP void   )  const [virtual]
 

Construct on heap.

Technically not a constructor, this function creates a TaGenerator with the same event symboltable and the same attribute type. Since NewP() is defined as virtual vGenerator function, it can be accessed from all generator classes. It is the callers reponsebilty to delete the object when no longer needed.

Returns:
new Generator

Implements faudes::vGenerator.

Reimplemented in faudes::TcGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >.

Definition at line 2558 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr > & faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::operator= const vGenerator rOtherGen  )  [virtual]
 

Assignment operator (uses Copy(vGenerator&) ).

Parameters:
rOtherGen Other generator

Implements faudes::vGenerator.

Definition at line 2585 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr > & faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::operator= const TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr > &  rOtherGen  )  [virtual]
 

Assignment operator (uses Copy(TaGenerator&) ).

Parameters:
rOtherGen Other generator

Definition at line 2578 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::Read TokenReader rTr  )  [virtual]
 

Read generator from TokenReader.

Parameters:
rTr Reference to TokenReader
Exceptions:
Exception 
  • IO errors (id 1)
  • token mismatch (id 50, 51, 52, 80, 85)

Implements faudes::vGenerator.

Definition at line 3077 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::Read const char *  pFileName  )  [virtual]
 

Read generator from file.

Used Read(TokenReader&) to read a generator from file.

Parameters:
pFileName Name of file
Exceptions:
Exception 
  • IO errors (id 1)
  • token mismatch (id 50, 51, 52, 80, 85)

Implements faudes::vGenerator.

Definition at line 3071 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ReadAlphabet TokenReader rTr  )  [protected]
 

Read the generator's alphabet from a TokenReader.

Parameters:
rTr Reference to TokenReader
Exceptions:
Exception 
  • IO errors (id 1)
  • token mismatch (id 50, 51, 52)

Definition at line 3122 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ReadAlphabet const char *  pFileName  )  [protected]
 

Read the generator's alphabet from a file.

Parameters:
pFileName File to read from
Exceptions:
Exception 
  • IO errors (id 1)
  • token mismatch (id 50, 51, 52)

Definition at line 3116 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ReadGeneratorName TokenReader rTr  )  [protected]
 

Read the generator's name from a TokenReader.

Parameters:
rTr Reference to TokenReader
Exceptions:
Exception 
  • IO errors (id 1)
  • token mismatch (id 50, 51, 52)

Definition at line 3109 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ReadGeneratorName const char *  pFileName  )  [protected]
 

Read the generator's name from a file.

Parameters:
pFileName File to read from
Exceptions:
Exception 
  • IO errors (id 1)
  • token mismatch (id 50, 51, 52)

Definition at line 3102 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ReadStates TokenReader rTr  )  [protected]
 

Read the generator's stateset from a TokenReader.

This sets up the StateSymbolTable

Parameters:
rTr Reference to TokenReader
Exceptions:
Exception 
  • IO errors (id 1)
  • token mismatch (id 50, 51, 52)

Definition at line 3135 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ReadStates const char *  pFileName  )  [protected]
 

Read the generator's mStates from a file.

This sets up the StateSymbolTable

Parameters:
pFileName File to read from
Exceptions:
Exception 
  • IO errors (id 1)
  • token mismatch (id 50, 51, 52)

Definition at line 3129 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ReadStateSet TokenReader rTr,
const std::string &  rLabel,
StateSet rStateSet
const [virtual]
 

Read a state set.

Refer to the generators state symboltable while reading a state set. Ignore any attributes.

Parameters:
rTr Reference to TokenReader
rLabel Label of set in source
rStateSet Destination state set
Exceptions:
Exception 
  • IO errors (id 1)
  • token mismatch (id 50, 51, 52, 80, 85)

Implements faudes::vGenerator.

Definition at line 3218 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ReadTransRel TokenReader rTr  )  [protected]
 

Read the generator's transition relation from a TokenReader.

Parameters:
rTr Reference to TokenReader
Exceptions:
Exception 
  • IO errors (id 1)
  • token mismatch (id 50, 51, 52)

Definition at line 3299 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ReadTransRel const char *  pFileName  )  [protected]
 

Read the generator's transition relation from a file.

Parameters:
pFileName File to read from
Exceptions:
Exception 
  • IO errors (id 1)
  • token mismatch (id 50, 51, 52)

Definition at line 3293 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::SetInitState const std::string &  rName  )  [virtual]
 

Set an existing state as initial state by name.

(only for user interactions)

Parameters:
rName Name of state to set as initial state
Exceptions:
Exception 
  • State name not known in generator (id 90)

Implements faudes::vGenerator.

Definition at line 3874 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::SetInitState Idx  index  )  [virtual]
 

Set an existing state as initial state by index.

Parameters:
index Index of state to set as initial state
Exceptions:
Exception 
  • State index not found in generator (id 91)

Implements faudes::vGenerator.

Definition at line 3860 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::SetMarkedState const std::string &  rName  )  [virtual]
 

Set an existing state as marked state by name.

(only for user interactions)

Parameters:
rName Name of state to set as marked state
Exceptions:
Exception 
  • State name not known in generator (id 90)

Implements faudes::vGenerator.

Definition at line 3949 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::SetMarkedState Idx  index  )  [virtual]
 

Set an existing state as marked state by index.

Define FAUDES_CHECKED for consistency checks.

Parameters:
index Index of state to set as initial state
Exceptions:
Exception 
  • State index not found in generator (id 91)

Implements faudes::vGenerator.

Definition at line 3935 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::SetMinStateIndexMap void   )  [virtual]
 

Set minimal index map for file io of generator states.

Implements faudes::vGenerator.

Definition at line 4631 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
bool faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::SetTransition const Transition rTransition,
const TransAttr &  rAttr
 

Add a transition with attribute to generator.

States and event must already exist!

Parameters:
rTransition transition
rAttr attribute
Returns:
True, if the transition was new the generator
Exceptions:
Exception 
  • state or event not in generator (id 95)

Definition at line 4085 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
bool faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::SetTransition const Transition rTransition  )  [virtual]
 

Add a transition to generator.

States and event must already exist!

Parameters:
rTransition Transition
Returns:
True, if the transition was new the generator
Exceptions:
Exception 
  • state or event not in generator (id 95)

Implements faudes::vGenerator.

Definition at line 4058 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
bool faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::SetTransition const std::string &  rX1,
const std::string &  rEv,
const std::string &  rX2
[virtual]
 

Add a transition to generator by names.

Statename and eventname must already exist!

Parameters:
rX1 Predecessor state name
rEv Event name
rX2 Successor state name
Returns:
True, if the transition was new the generator
Exceptions:
Exception 
  • state or event not in generator (id 95)
  • state name not known (id 90)
  • event name not known (id 66)

Implements faudes::vGenerator.

Definition at line 4022 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
bool faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::SetTransition Idx  x1,
Idx  ev,
Idx  x2
[virtual]
 

Add a transition to generator by indices.

States and event must already exist!

Define FAUDES_CHECKED for consistency checks.

Parameters:
x1 Predecessor state index
ev Event index
x2 Successor state index
Returns:
True, if the transition was new the generator
Exceptions:
Exception 
  • state or event not in generator (id 95)

Implements faudes::vGenerator.

Definition at line 4053 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
Idx faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::Size void   )  const [virtual]
 

Get generator size (# of states).

Returns:
Number of states

Implements faudes::vGenerator.

Definition at line 3397 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
const StateAttr & faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::StateAttribute Idx  index  )  const
 

State attribute lookup.

Parameters:
index 
Returns:
ref to attribute of state

Definition at line 4266 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::StateAttribute Idx  index,
const StateAttr &  rAttr
 

Set attribute for existing state.

Parameters:
index Index
rAttr attriute
Exceptions:
Exception Name already associated with another index (id 44)

Definition at line 4174 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
StateAttr * faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::StateAttributep Idx  index  ) 
 

State attribute pointer (to access Attribute methods) note: may insert explicit default attribute.

Parameters:
index 
Returns:
pointer to attribute of state

Definition at line 4271 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
const TaIndexSet< StateAttr > & faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::States void   )  const [virtual]
 

Return reference to mStates.

Returns:
StateSet reference

Implements faudes::vGenerator.

Definition at line 4281 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
StateSet::Iterator faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::StatesBegin void   )  const [virtual]
 

iterator to Begin() of mStates

Returns:
iterator to begin of mStates

Implements faudes::vGenerator.

Definition at line 3503 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
StateSet::Iterator faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::StatesEnd void   )  const [virtual]
 

iterator to End() of mStates

Returns:
iterator to end of mStates

Implements faudes::vGenerator.

Definition at line 3508 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
std::string faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::StateSetToString const StateSet rStateSet  )  const [virtual]
 

Write a stateset to string.

Uses WriteStateSet(TokenWriter& rTw, const StateSet&) const to write the specified state set to a string referring to this generators state names.

Parameters:
rStateSet Reference to stateset
Returns:
std::string
Exceptions:
Exception 
  • IO errors (id 2)

Implements faudes::vGenerator.

Definition at line 2721 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
template<class OtherAttr>
std::string faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::StateSetToString const TaIndexSet< OtherAttr > &  rStateSet  )  const
 

Write a stateset to string.

Uses WriteStateSet(TokenWriter& rTw, const TaStateSet&) const to write the specified state set to a string referring to this generators state names.

Parameters:
rStateSet Reference to stateset
Returns:
std::string
Exceptions:
Exception 
  • IO errors (id 2)

Definition at line 2714 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
std::string faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::StatesToString void   )  const [virtual]
 

Write stateset of this generator to a string (no re-indexing).

Returns:
std::string
Exceptions:
Exception 
  • IO errors (id 2)

Implements faudes::vGenerator.

Definition at line 2803 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
std::string faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::StatisticsToString void   )  const [virtual]
 

Write statistics to string.

Produce statistics (number of states etc.) in comment form (lines starting with %)

Implements faudes::vGenerator.

Definition at line 2904 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
std::string faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ToString void   )  const [virtual]
 

Write to string.

Returns:
std::string
Exceptions:
Exception 
  • IO errors (id 2)

Implements faudes::vGenerator.

Definition at line 2625 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
const TransAttr & faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::TransAttribute const Transition rTrans  )  const
 

get attribute for existing transition

Returns:
attribute

Definition at line 4145 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::TransAttribute const Transition rTrans,
const TransAttr &  rAttr
 

Set attribute for existing transition.

Parameters:
rTrans transition
rAttr New attribute

Definition at line 4132 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
TransAttr * faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::TransAttributep const Transition rTrans  ) 
 

get attribute pointer for existing transition note: may insert explicit default attribute

Returns:
attribute pointer

Definition at line 4139 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::TransRel TransSetX1X2Ev res  )  const [virtual]
 

Implements faudes::vGenerator.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::TransRel TransSetX2X1Ev res  )  const [virtual]
 

Implements faudes::vGenerator.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::TransRel TransSetX2EvX1 res  )  const [virtual]
 

Implements faudes::vGenerator.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::TransRel TransSetEvX2X1 res  )  const [virtual]
 

Implements faudes::vGenerator.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::TransRel TransSetEvX1X2 res  )  const [virtual]
 

Implements faudes::vGenerator.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::TransRel TransSetX1EvX2 res  )  const [virtual]
 

Get copy of trantision relation sorted by other compare operator, e.g.

"x2,ev,x1"

Parameters:
res resulting transition relation

Implements faudes::vGenerator.

Definition at line 4292 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
const TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ATransSet & faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::TransRel void   )  const [virtual]
 

Return reference to transition relation.

Returns:
TransRel

Implements faudes::vGenerator.

Definition at line 4286 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ATransSet::Iterator faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::TransRelBegin Idx  x1,
Idx  ev
const [virtual]
 

iterator to begin of transitions with x1 as predecessor state and event ev.

Parameters:
x1 Predecessor state
ev Event
Returns:
iterator to begin of transitions with x1 and ev

Implements faudes::vGenerator.

Definition at line 3538 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ATransSet::Iterator faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::TransRelBegin Idx  x1  )  const [virtual]
 

iterator to begin of transitions with x1 as predecessor state.

Parameters:
x1 Predecessor state
Returns:
iterator to begin of transitions with x1

Implements faudes::vGenerator.

Definition at line 3526 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ATransSet::Iterator faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::TransRelBegin void   )  const [virtual]
 

iterator to Begin() of transition relation

Returns:
iterator to Begin of mTransRel

Implements faudes::vGenerator.

Definition at line 3514 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
bool faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::TransRelEmpty void   )  const [virtual]
 

Check if transition relation is empty.

Returns:
True if transition relation is empty

Implements faudes::vGenerator.

Definition at line 3478 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ATransSet::Iterator faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::TransRelEnd Idx  x1,
Idx  ev
const [virtual]
 

iterator to end of transitions with x1 as predecessor state and event ev.

Note: Set the End(x1,ev) iterator to a variable, so it won't be recalculated every iteration.

Parameters:
x1 Predecessor state
ev Event
Returns:
iterator to end of transitions with x1 and ev (one after last matching transition)

Implements faudes::vGenerator.

Definition at line 3544 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ATransSet::Iterator faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::TransRelEnd Idx  x1  )  const [virtual]
 

iterator to end of transitions with x1 as predecessor state.

Note: Set the End(x1) iterator to a variable, so it won't be recalculated every iteration.

Parameters:
x1 Predecessor state
Returns:
iterator to end of transitions with x1 (one after last matching transition)

Implements faudes::vGenerator.

Definition at line 3532 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::ATransSet::Iterator faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::TransRelEnd void   )  const [virtual]
 

iterator to End() of transition relation

Returns:
iterator to End of mTransRel

Implements faudes::vGenerator.

Definition at line 3520 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
Idx faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::TransRelSize void   )  const [virtual]
 

Get number of transitions.

Returns:
Number of transitions

Implements faudes::vGenerator.

Definition at line 3453 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
StateSet faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::TransRelStateSpace Idx  x1  )  const [virtual]
 

Return the successor states of state x1.

Returns:
StateSet

Implements faudes::vGenerator.

Definition at line 4352 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
StateSet faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::TransRelStateSpace void   )  const [virtual]
 

Return the states covered by transitions als indices.

Returns:
StateSet

Implements faudes::vGenerator.

Definition at line 4341 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
std::string faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::TransRelToString void   )  const [virtual]
 

Write transition relation to string (no re-indexing).

Implements faudes::vGenerator.

Definition at line 2825 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
bool faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::Trim void   )  [virtual]
 

Make generator trim.

Returns:
True if generator contains at least one initial state and one marked state after internally calling Accessible() and Coaccessible().

Implements faudes::vGenerator.

Definition at line 4535 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
StateSet faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::TrimSet void   )  const [virtual]
 

Computer set of trim states.

Implements faudes::vGenerator.

Definition at line 4528 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
EventSet faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::UnusedEvents void   )  const [virtual]
 

Return unused events.

Returns:
EventSet

Implements faudes::vGenerator.

Definition at line 4326 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
virtual bool faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::UpdateAttributes void   )  [inline, virtual]
 

Updates internal attributes.

Since a plain generator does not have any internal attributes, this is just an interface. Reimplement to your needs.

Returns:
true if value changed

Definition at line 879 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
EventSet faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::UsedEvents void   )  const [virtual]
 

Return used events (executed in transitions).

Returns:
EventSet

Implements faudes::vGenerator.

Definition at line 4316 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
bool faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::Valid void   )  [virtual]
 

Check if generator is valid.

Returns:
Success

Implements faudes::vGenerator.

Definition at line 3369 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::Version const std::string &  rVersion,
TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr > &  rResGen
 

Create another version of this generator.

Assembles a copy of this generator, however, with versioned events. The new event names are created by appending an underscore and a specified string. State names and indices as well as any attributes are maintained.

Parameters:
rVersion String value to be appended to event names
rResGen Resulting versioned generator

Definition at line 4371 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::Version Idx  version,
TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr > &  rResGen
 

Create another version of this generator.

Assembles a copy of this generator, however, with versioned events. The new event names are created by appending an underscore and a numeric index. State names and indices as well as any attributes are maintained.

Parameters:
version Numeric value to be appended to event names
rResGen Resulting versioned generator

Definition at line 4363 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::Write TokenWriter rTw  )  const [virtual]
 

Write to TokenWriter.

All writing functions are implemented to write to an accordingly initialised TokenWriter. Events are always written as symbolic names, states in state sets as indices or names if present. For the transition relation, a compiletime option defines whether or not states may be written as symbolic names.

Output of generators always uses the mMinStateIndexMap to re-index states. However, this map is only set up automatically for file output. If You require re-indexed output to eg a string, you must set up the map by calling SetMinStateIndexMap(). To ensure that no re-indexing takes place, call ClearMinStateIndexMap().

Parameters:
rTw Reference to TokenWriter
Exceptions:
Exception 
  • IO errors (id 2)

Implements faudes::vGenerator.

Definition at line 2632 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::Write const char *  pFileName,
std::ios::openmode  openmode = std::ios::out|std::ios::trunc
[virtual]
 

Write to file (using minimal state indices).

Writing to a file is always done with minimal state indices, ie states are re.indexed consecutively starting from 1. This is implemented by the member mMinStateIndexMap, which is set before calling the Write(TokenWriter&) const and cleared afterwards.

Parameters:
pFileName Filen to write
openmode std::ios::openmode (optiona, defaults to truncate)
Exceptions:
Exception 
  • IO errors (id 2)

Implements faudes::vGenerator.

Definition at line 2616 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::Write void   )  const [virtual]
 

Write to console.

Implements faudes::vGenerator.

Definition at line 2610 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::WriteAlphabet TokenWriter rTw  )  const [virtual]
 

Write generators alphabet to tokenwriter.

Parameters:
rTw Reference to TokenWriter
Exceptions:
Exception 
  • IO errors (id 2)

Implements faudes::vGenerator.

Definition at line 2695 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::WriteAlphabet void   )  const [virtual]
 

Write generators alphabet to console.

Implements faudes::vGenerator.

Definition at line 2682 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::WriteStateSet TokenWriter rTw,
const StateSet rStateSet
const [virtual]
 

Write a stateset to TokenWriter.

All output of statesets with no attributes is done with this function. See WriteStateSet(TokenWriter&, const TaStateSet&) const for further details.

Parameters:
rTw Reference to TokenWriter
rStateSet Reference to stateset
Exceptions:
Exception 
  • IO errors (id 2)

Implements faudes::vGenerator.

Definition at line 2776 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
template<class OtherAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::WriteStateSet TokenWriter rTw,
const TaIndexSet< OtherAttr > &  rStateSet
const
 

Write a stateset to TokenWriter.

All output of state sets with attributes is done with this function. Recall that a StateSet technically is a set of plain indices, no reference to symbolic names. Thus, it is only the context of a Generator that provides the symbolic names for file output.

Output of state sets always uses the mMinStateIndexMap to re-index states. However, this map is only set up automatically for file output. If You require re-indexed output to eg a string, you must set up the map by calling SetMinStateIndexMap(). To ensure that no re-indexing takes place, call ClearMinStateIndexMap().

Parameters:
rTw Reference to TokenWriter
rStateSet Reference to stateset
Exceptions:
Exception 
  • IO errors (id 2)

Definition at line 2728 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::WriteStateSet const StateSet rStateSet  )  const [virtual]
 

Write a stateset to console.

Uses WriteStateSet(TokenWriter& rTw, const StateSet&) const to write the specified state set to console referring to this generators state names.

Parameters:
rStateSet Reference to stateset

Implements faudes::vGenerator.

Definition at line 2707 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
template<class OtherAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::WriteStateSet const TaIndexSet< OtherAttr > &  rStateSet  )  const
 

Write a stateset to console.

Uses WriteStateSet(TokenWriter& rTw, const TaStateSet&) const to write the specified state set to console referring to this generators state names.

Parameters:
rStateSet Reference to stateset

Definition at line 2701 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::WriteStatistics TokenWriter rTw  )  const [virtual]
 

Write statistics to tokenwriter Produce statistics (number of states etc.

) in comment form (lines starting with %)

Parameters:
rTw Reference to TokenWriter
Exceptions:
Exception 
  • IO errors (id 2)

Implements faudes::vGenerator.

Definition at line 2911 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::WriteStatistics void   )  const [virtual]
 

Write statistics to console.

Produce statistics (number of states etc.) in comment form (lines starting with %)

Implements faudes::vGenerator.

Definition at line 2897 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::WriteTransRel TokenWriter rTw  )  const [virtual]
 

Write transition relation to tokenwriter (no re-indexing) Re-indexing and symbolic state names are handled in the same way as with state sets: this function refers to the generators state symboltable to obtain state names and uses the mMinStateIndexMap to re-index the output.

Parameters:
rTw Reference to TokenWriter
Exceptions:
Exception 
  • IO errors (id 2)

Implements faudes::vGenerator.

Definition at line 2832 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::WriteTransRel void   )  const [virtual]
 

Write transition relation to console (no re-indexing).

Implements faudes::vGenerator.

Definition at line 2819 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
void faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::XDotWrite const std::string &  rFileName  )  const
 

Writes generator to dot input format (for export to VioLib).

Variant of DotWrite() using strategig state and event names to simplify import to VioLib (qt widget for graphical representation of FAUDES generators).

Parameters:
rFileName File to write
Exceptions:
Exception 
  • IO errors (id 2)

Definition at line 3038 of file agenerator.h.


Member Data Documentation

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
TaNameSet<EventAttr> faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::mAlphabet [protected]
 

Generator alphabet.

Definition at line 2277 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
GlobalAttr faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::mGlobalAttribute [protected]
 

global attribute

Definition at line 2295 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
StateSet faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::mInitStates [protected]
 

Initial states.

Definition at line 2286 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
StateSet faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::mMarkedStates [protected]
 

Marked states.

Definition at line 2289 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
std::map<Idx,Idx> faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::mMinStateIndexMap [protected]
 

Map State indices to consecutive indices.

Definition at line 2292 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
TaIndexSet<StateAttr> faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::mStates [protected]
 

Generator state set.

Definition at line 2280 of file agenerator.h.

template<class GlobalAttr, class StateAttr, class EventAttr, class TransAttr>
ATransSet faudes::TaGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >::mTransRel [protected]
 

Transition relation.

Definition at line 2283 of file agenerator.h.


The documentation for this class was generated from the following file:
Generated on Fri May 9 11:26:48 2008 for libFAUDES 2.09b by  doxygen 1.4.4