Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
spot::acss_statisticsAccepting Cycle Search Space statistics
spot::bdd_dict::anon_free_list
spot::ars_statisticsAccepting Run Search statistics
spot::ltl::atomic_propAtomic propositions
spot::ltl::automatopAutomaton operators
spot::barand< gen >Compute pseudo-random integer value between 0 and n included, following a binomial distribution for probability p
spot::bdd_allocatorManage ranges of variables
spot::bdd_dict
spot::bdd_less_thanComparison functor for BDDs
spot::bdd_ordered
spot::bfs_stepsMake a BFS in a spot::tgba to compute a tgba_run::steps.This class should be used to compute the shortest path between a state of a spot::tgba and the first transition or state that matches some conditions
spot::ltl::binopBinary operator
spot::char_ptr_less_thanStrict Weak Ordering for char*.This is meant to be used as a comparison functor for STL map whose key are of type const char*
spot::ltl::clone_visitorClone a formula.This visitor is public, because it's convenient to derive from it and override part of its methods. But if you just want the functionality, consider using spot::ltl::formula::clone instead, it is way faster
spot::scc_stack::connected_component
spot::connected_component_hash_set
spot::connected_component_hash_set_factoryFactory for connected_component_hash_set
spot::ltl::const_visitorFormula visitor that cannot modify the formula
spot::ltl::constantA constant (True or False)
spot::couvreur99_checkAn implementation of the Couvreur99 emptiness-check algorithm
spot::couvreur99_check_resultCompute a counter example from a spot::couvreur99_check_status
spot::couvreur99_check_shyA version of spot::couvreur99_check that tries to visit known states first
spot::couvreur99_check_statusThe status of the emptiness-check on success
spot::ltl::declarative_environmentA declarative environment.This environment recognizes all atomic propositions that have been previously declared. It will reject other
spot::ltl::default_environmentA laxist environment.This environment recognizes all atomic propositions
spot::delayed_simulation_relation
spot::direct_simulation_relation
spot::taa_succ_iterator::distance_sort
spot::dotty_decoratorChoose state and link styles for spot::dotty_reachable
spot::duplicator_nodeDuplicator node of parity game graph
spot::duplicator_node_delayedDuplicator node of parity game graph for delayed simulation
spot::ec_statisticsEmptiness-check statistics
spot::emptiness_checkCommon interface to emptiness check algorithms
spot::emptiness_check_instantiator
spot::emptiness_check_resultThe result of an emptiness check
spot::ltl::environmentAn environment that describes atomic propositions
spot::evtgba
spot::evtgba_explicit
spot::evtgba_iterator
spot::evtgba_product
spot::evtgba_reachable_iteratorIterate over all reachable states of a spot::evtgba
spot::evtgba_reachable_iterator_breadth_firstAn implementation of spot::evtgba_reachable_iterator that browses states breadth first
spot::evtgba_reachable_iterator_depth_firstAn implementation of spot::evtgba_reachable_iterator that browses states depth first
spot::explicit_connected_componentAn SCC storing all its states explicitly
spot::explicit_connected_component_factoryAbstract factory for explicit_connected_component
spot::explicit_state_conjunctionBasic implementation of saba_state_conjunction.This class provides a basic implementation to iterate over a conjunction of states of a saba
spot::fair_kripkeInterface for a Fair Kripke structure.A Kripke structure is a graph in which each node (=state) is labeled by a conjunction of atomic proposition, and a set of acceptance conditions
spot::fair_kripke_succ_iteratorIterator code for a Fair Kripke structure.This iterator can be used to simplify the writing of an iterator on a Fair Kripke structure (or lookalike)
spot::ltl::formulaAn LTL formula.The only way you can work with a formula is to build a spot::ltl::visitor or spot::ltl::const_visitor
spot::ltl::formula_ptr_hashHash Function for const formula*.This is meant to be used as a hash functor for Sgi's hash_map whose key are of type const formula*
spot::ltl::formula_ptr_less_thanStrict Weak Ordering for const formula*.This is meant to be used as a comparison functor for STL map whose key are of type const formula*
spot::free_listManage list of free integers
spot::future_conditions_collectorWrap a tgba to offer information about upcoming conditions.This class is a spot::tgba wrapper that simply add a new method, future_conditions(), to any spot::tgba
spot::gspn_exceptionAn exception used to forward GSPN errors
spot::gspn_interface
spot::gspn_ssp_interface
spot::identity_hash< T >A hash function that returns identity
spot::kripkeInterface for a Kripke structureA Kripke structure is a graph in which each node (=state) is labeled by a conjunction of atomic proposition
spot::kripke_succ_iteratorIterator code for Kripke structureThis iterator can be used to simplify the writing of an iterator on a Kripke structure (or lookalike)
spot::ltl::language_containment_checker
spot::minato_isop::local_varsInternal variables for minato_isop
neverclaimyy::locationAbstract a location
eltlyy::locationAbstract a location
ltlyy::locationAbstract a location
sautyy::locationAbstract a location
spot::loopless_modular_mixed_radix_gray_codeLoopless modular mixed radix Gray code iteration.This class is based on the loopless modular mixed radix gray code algorithm described in exercise 77 of "The Art of Computer Programming", Pre-Fascicle 2A (Draft of section 7.2.1.1: generating all n-tuples) by Donald E. Knuth
spot::ltl::ltl_fileRead LTL formulae from a file, one by one
spot::minato_isopGenerate an irredundant sum-of-products (ISOP) form of a BDD function.This algorithm implements a derecursived version the Minato-Morreale algorithm presented in the following paper
spot::ltl::multopMulti-operand operators.These operators are considered commutative and associative
spot::ltl::nfaNondeterministic Finite Automata used by automata operators
spot::nips_exceptionAn exception used to forward NIPS errors
spot::nips_interfaceAn interface to provide a PROMELA front-end
spot::ltl::formula_tree::node
spot::ltl::formula_tree::node_atomic
spot::ltl::formula_tree::node_binop
spot::ltl::formula_tree::node_multop
spot::ltl::formula_tree::node_nfa
spot::ltl::formula_tree::node_unop
spot::numbered_state_heapKeep track of a large quantity of indexed states
spot::numbered_state_heap_const_iteratorIterator on numbered_state_heap objects
spot::numbered_state_heap_factoryAbstract factory for numbered_state_heap
spot::numbered_state_heap_hash_mapA straightforward implementation of numbered_state_heap with a hash map
spot::numbered_state_heap_hash_map_factoryFactory for numbered_state_heap_hash_map
spot::ltl::random_ltl::op_proba
spot::option_mapManage a map of options.Each option is defined by a string and is associated to an integer value
spot::ltl::multop::paircmpComparison functor used internally by ltl::multop
spot::parity_game_graphParity game graph which compute a simulation relation
spot::parity_game_graph_delayed
spot::parity_game_graph_directParity game graph which compute the direct simulation relation
neverclaimyy::positionAbstract a position
ltlyy::positionAbstract a position
eltlyy::positionAbstract a position
sautyy::positionAbstract a position
spot::ltl::postfix_visitorApply an algorithm on each node of an AST, during a postfix traversal.Override one or more of the postifix_visitor::doit methods with the algorithm to apply
spot::power_map
spot::ptr_hash< T >A hash function for pointers
spot::ltl::random_ltlGenerate random LTL formulae.This class recursively construct LTL formulae of a given size. The formulae will use the use atomic propositions from the set of proposition passed to the constructor, in addition to the constant and all LTL operators supported by Spot
spot::ltl::language_containment_checker::record_
spot::ltl::ref_formulaA reference-counted LTL formula
spot::rsymbol
spot::sabaA State-based Alternating (Generalized) Büchi Automaton.Browsing such automaton can be achieved using two functions: get_init_state, and succ_iter. The former returns the initial state while the latter lists the successor states of any state
spot::saba_complement_tgbaComplement a TGBA and produce a SABA.The original TGBA is transformed into a States-based Büchi Automaton
spot::saba_reachable_iteratorIterate over all reachable states of a spot::saba
spot::saba_reachable_iterator_breadth_firstAn implementation of spot::saba_reachable_iterator that browses states breadth first
spot::saba_reachable_iterator_depth_firstAn implementation of spot::saba_reachable_iterator that browses states depth first
spot::saba_stateAbstract class for saba states
spot::saba_state_conjunctionIterate over a conjunction of saba_state.This class provides the basic functionalities required to iterate over a conjunction of states of a saba
spot::saba_state_ptr_equalAn Equivalence Relation for saba_state*.This is meant to be used as a comparison functor for Sgi hash_map whose key are of type saba_state*
spot::saba_state_ptr_hashHash Function for saba_state*.This is meant to be used as a hash functor for Sgi's hash_map whose key are of type saba_state*
spot::saba_state_ptr_less_thanStrict Weak Ordering for saba_state*.This is meant to be used as a comparison functor for STL map whose key are of type saba_state*
spot::saba_state_shared_ptr_equalAn Equivalence Relation for shared_saba_state (shared_ptr<const saba_state*>).This is meant to be used as a comparison functor for Sgi hash_map whose key are of type shared_saba_state
spot::saba_state_shared_ptr_hashHash Function for shared_saba_state (shared_ptr<const saba_state*>).This is meant to be used as a hash functor for Sgi's hash_map whose key are of type shared_saba_state
spot::saba_state_shared_ptr_less_thanStrict Weak Ordering for shared_saba_state (shared_ptr<const saba_state*>).This is meant to be used as a comparison functor for STL map whose key are of type shared_saba_state
spot::saba_succ_iteratorIterate over the successors of a saba_state.This class provides the basic functionalities required to iterate over the successors of a state of a saba. Since transitions of an alternating automaton are defined as a boolean function with conjunctions (universal) and disjunctions (non-deterministic),
spot::scc_map::scc
spot::scc_mapBuild a map of Strongly Connected components in in a TGBA
spot::scc_stack
spot::scc_stats
spot::sccs_set
spot::ltl::simplify_f_g_visitorReplace true U f and false R g by F f and G g
eltlyy::slice< T, S >Present a slice of the top of a stack
sautyy::slice< T, S >Present a slice of the top of a stack
neverclaimyy::slice< T, S >Present a slice of the top of a stack
ltlyy::slice< T, S >Present a slice of the top of a stack
spot::spoiler_nodeSpoiler node of parity game graph
spot::spoiler_node_delayedSpoiler node of parity game graph for delayed simulation
neverclaimyy::stack< T, S >
sautyy::stack< T, S >
eltlyy::stack< T, S >
ltlyy::stack< T, S >
spot::evtgba_explicit::state
spot::stateAbstract class for states
spot::state_bdd
spot::state_evtgba_explicitStates used by spot::tgba_evtgba_explicit
spot::state_explicit
spot::state_productA state for spot::tgba_product.This state is in fact a pair of state: the state from the left automaton and that of the right
spot::state_ptr_equalAn Equivalence Relation for state*.This is meant to be used as a comparison functor for Sgi hash_map whose key are of type state*
spot::state_ptr_hashHash Function for state*.This is meant to be used as a hash functor for Sgi's hash_map whose key are of type state*
spot::state_ptr_less_thanStrict Weak Ordering for state*.This is meant to be used as a comparison functor for STL map whose key are of type state*
spot::state_setSet of states deriving from spot::state
spot::state_shared_ptr_equalAn Equivalence Relation for shared_state (shared_ptr<const state*>).This is meant to be used as a comparison functor for Sgi hash_map whose key are of type shared_state
spot::state_shared_ptr_hashHash Function for shared_state (shared_ptr<const state*>).This is meant to be used as a hash functor for Sgi's hash_map whose key are of type shared_state
spot::state_shared_ptr_less_thanStrict Weak Ordering for shared_state (shared_ptr<const state*>).This is meant to be used as a comparison functor for STL map whose key are of type shared_state
spot::state_unionA state for spot::tgba_union.This state is in fact a pair. If the first member equals 0 and the second is different from 0, the state belongs to the left automaton. If the first member is different from 0 and the second is 0, the state belongs to the right automaton. If both members are 0, the state is the initial state
spot::tgba_run::step
spot::string_hashA hash function for strings
spot::ltl::succ_iterator
spot::couvreur99_check_shy::successor
spot::symbol
spot::taa_succ_iterator
spot::taa_tgbaA self-loop Transition-based Alternating Automaton (TAA) which is seen as a TGBA (abstract class, see below)
spot::taa_tgba_formula
spot::taa_tgba_labelled< label, label_hash >
spot::taa_tgba_string
spot::tgbaA Transition-based Generalized Büchi Automaton.The acronym TGBA (Transition-based Generalized Büchi Automaton) was coined by Dimitra Giannakopoulou and Flavio Lerda in "From States to Transitions: Improving Translation of LTL Formulae to Büchi Automata". (FORTE'02)
spot::tgba_bdd_concreteA concrete spot::tgba implemented using BDDs
spot::tgba_bdd_concrete_factoryHelper class to build a spot::tgba_bdd_concrete object
spot::tgba_bdd_core_dataCore data for a TGBA encoded using BDDs
spot::tgba_bdd_factoryAbstract class for spot::tgba_bdd_concrete factories
spot::tgba_explicit
spot::tgba_explicit_formula
spot::tgba_explicit_labelled< label, label_hash >A tgba_explicit instance with states labeled by a given type
spot::tgba_explicit_number
spot::tgba_explicit_string
spot::tgba_explicit_succ_iterator
spot::tgba_kv_complementBuild a complemented automaton.The construction comes from:
spot::tgba_productA lazy product. (States are computed on the fly.)
spot::tgba_product_initA lazy product with different initial states
spot::tgba_reachable_iteratorIterate over all reachable states of a spot::tgba
spot::tgba_reachable_iterator_breadth_firstAn implementation of spot::tgba_reachable_iterator that browses states breadth first
spot::tgba_reachable_iterator_depth_firstAn implementation of spot::tgba_reachable_iterator that browses states depth first
spot::tgba_reduc
spot::tgba_runAn accepted run, for a tgba
spot::tgba_run_dotty_decoratorHighlight a spot::tgba_run on a spot::tgba.An instance of this class can be passed to spot::dotty_reachable
spot::tgba_safra_complementBuild a complemented automaton.It creates an automaton that recognizes the negated language of aut
spot::tgba_sba_proxyDegeneralize a spot::tgba on the fly, producing an SBA.This class acts as a proxy in front of a spot::tgba, that should be degeneralized on the fly
spot::tgba_sccWrap a tgba to offer information about strongly connected components.This class is a spot::tgba wrapper that simply add a new method scc_of_state() to retrieve the number of a SCC a state belongs to
spot::tgba_sgba_proxyChange the labeling-mode of spot::tgba on the fly, producing a state-based generalized Büchi automaton.This class acts as a proxy in front of a spot::tgba, that should label on states on-the-fly. The result is still a spot::tgba, but acceptances conditions are also on states
spot::tgba_statistics
spot::tgba_succ_iteratorIterate over the successors of a state.This class provides the basic functionalities required to iterate over the successors of a state, as well as querying transition labels. Because transitions are never explicitely encoded, labels (conditions and acceptance conditions) can only be queried while iterating over the successors
spot::tgba_succ_iterator_concrete
spot::tgba_succ_iterator_productIterate over the successors of a product computed on the fly
spot::tgba_succ_iterator_unionIterate over the successors of an union computed on the fly
spot::tgba_tba_proxyDegeneralize a spot::tgba on the fly, producing a TBA.This class acts as a proxy in front of a spot::tgba, that should be degeneralized on the fly. The result is still a spot::tgba, but it will always have exactly one acceptance condition so it could be called TBA (without the G)
spot::tgba_unionA lazy union. (States are computed on the fly.)
spot::time_infoA structure to record elapsed time in clock ticks
spot::timerA timekeeper that accumulate interval of time
spot::timer_mapA map of timer, where each timer has a name
spot::couvreur99_check_shy::todo_item
spot::taa_tgba::transitionExplicit transitions
spot::ltl::nfa::transitionExplicit transitions
spot::tgba_explicit::transitionExplicit transitions (used by spot::tgba_explicit)
spot::evtgba_explicit::transitionExplicit transitions (used by spot::evtgba_explicit)
spot::ltl::automatop::tripletcmpComparison functor used internally by ltl::automatop
spot::ltl::unabbreviate_logic_visitorClone and rewrite a formula to remove most of the abbreviated logical operators.This will rewrite binary operators such as binop::Implies, binop::Equals, and binop::Xor, using only unop::Not, multop::Or, and multop::And
spot::ltl::unabbreviate_ltl_visitorClone and rewrite a formula to remove most of the abbreviated LTL and logical operators.The rewriting performed on logical operator is the same as the one done by spot::ltl::unabbreviate_logic_visitor
spot::ltl::unopUnary operators
spot::unsigned_statistics
spot::unsigned_statistics_copyComparable statistics
spot::ltl::visitorFormula visitor that can modify the formula.Writing visitors is the prefered way to traverse a formula, since it doesn't involve any cast
spot::weightManage for a given automaton a vector of counter indexed by its acceptance condition

Please comment this page and report errors about it on the RefDocComments page.
Generated on Tue Feb 1 2011 12:00:53 for spot by doxygen 1.7.1