 spot::acc_dict | |
 spot::ap_dict | This class is used to create a dictionary that will contain all atomic propositions that are needed by an (and possibly many) automaton |
 spot::barand< gen > | Compute pseudo-random integer value between 0 and n included, following a binomial distribution for probability p |
 spot::bdd_dict | Map BDD variables to formulae |
 spot::bdd_dict::bdd_info | |
 spot::bdd_ordered | |
 spot::bfs_steps | Make a BFS in a spot::tgba to compute a tgba_run::steps |
 binary_function | |
  spot::bdd_less_than | Comparison functor for BDDs |
  spot::char_ptr_less_than | Strict Weak Ordering for char* |
  spot::fasttgba_state_ptr_equal | |
  spot::ltl::formula_ptr_less_than | Strict Weak Ordering for const formula* |
  spot::ltl::formula_ptr_less_than_bool_first | Strict Weak Ordering for const formula* inside ltl::multop.This is the comparison functor used by to order the ltl::multop operands. It keeps Boolean formulae first in order to speed up implication checks |
  spot::saba_state_ptr_equal | An Equivalence Relation for saba_state* |
  spot::saba_state_ptr_less_than | Strict Weak Ordering for saba_state* |
  spot::saba_state_shared_ptr_equal | An Equivalence Relation for shared_saba_state (shared_ptr<const saba_state*>) |
  spot::saba_state_shared_ptr_less_than | Strict Weak Ordering for shared_saba_state (shared_ptr<const saba_state*>) |
  spot::state_ptr_equal | An Equivalence Relation for state* |
  spot::state_ptr_less_than | Strict Weak Ordering for state* |
  spot::state_shared_ptr_equal | An Equivalence Relation for shared_state (shared_ptr<const state*>) |
  spot::state_shared_ptr_less_than | Strict Weak Ordering for shared_state (shared_ptr<const state*>) |
 spot::bitvect | A bit vector |
 spot::bitvect_array | |
 spot::clause_counter | |
 spot::scc_stack::connected_component | |
  spot::explicit_connected_component | An SCC storing all its states explicitly |
   spot::connected_component_hash_set | |
 spot::scc_stack_ta::connected_component | |
 spot::couvreur99_check_status | The status of the emptiness-check on success |
 spot::cube | This class represents conjunction of variables |
 spot::deadstore | This class represent a dead store. For now it's just a set but it can be combined with bitstate hasing |
 spot::destroy_key< T > | |
 spot::destroy_key< const ltl::formula * > | |
 spot::enumerate_cycles::dfs_entry | |
 spot::dotty_decorator | Choose state and link styles for spot::dotty_reachable |
  spot::tgba_run_dotty_decorator | Highlight a spot::tgba_run on a spot::tgba |
 spot::dstar_aut | Temporary encoding of an omega automaton produced by ltl2dstar |
 spot::ec | |
  spot::concur_ec_stat | |
   spot::concur_opt_dijkstra_scc | The class that will be used by thread performing a Dijkstra SCC |
   spot::concur_opt_tarjan_scc | The class that will be used by thread performing a Tarjan SCC |
    spot::concur_opt_tarjan_ec | An emptiness based on the tarjan parallel computation algorithm above |
  spot::dead_share | Wrapper Launch all threads |
  spot::dijkstra_scc | |
  spot::dijkstracheck | |
  spot::lazycheck | |
  spot::opt_dijkstra_scc | This is the Dijkstra SCC computation algorithm This class also include the optimisation for the live stack (provided by Nuutila for Tarjan's algorithm but adapted here) and a possibly stack compression technique |
   spot::concur_opt_dijkstra_scc | The class that will be used by thread performing a Dijkstra SCC |
   spot::opt_dijkstra_ec | Transform the previous algorithm into an emptiness check. Only refine specific methods |
  spot::opt_tarjan_scc | Compute the SCCs of a TGBA |
   spot::concur_opt_tarjan_scc | The class that will be used by thread performing a Tarjan SCC |
   spot::opt_tarjan_ec | This class is the implementation of the tarjan-based emptiness check. It onlys needs to refine two methods that deal with acceptance sets : update and pop |
  spot::stats | |
  spot::tarjan_scc | |
  spot::union_scc | |
  spot::unioncheck | |
 spot::emptiness_check | Common interface to emptiness check algorithms |
  spot::couvreur99_check | An implementation of the Couvreur99 emptiness-check algorithm |
   spot::couvreur99_check_shy | A version of spot::couvreur99_check that tries to visit known states first |
 spot::emptiness_check_instantiator | |
 spot::emptiness_check_result | The result of an emptiness check |
  spot::couvreur99_check_result | Compute a counter example from a spot::couvreur99_check_status |
 spot::enumerate_cycles | Enumerate elementary cycles in a SCC |
 spot::ltl::environment | An environment that describes atomic propositions |
  spot::ltl::declarative_environment | A declarative environment |
  spot::ltl::default_environment | A laxist environment |
 spot::explicit_connected_component_factory | Abstract factory for explicit_connected_component |
  spot::connected_component_hash_set_factory | Factory for connected_component_hash_set |
 spot::fasttgba | |
  spot::fasttgba_product | This class allows to do a synchronized product between two fast tgba |
   spot::fasttgba_kripke_product | |
  spot::fasttgbaexplicit | |
 spot::fasttgba_state | This class act as an interface for all classes |
  spot::fast_explicit_state | |
  spot::fast_product_state | This class represents a product state |
 spot::fasttgba_succ_iterator | Iterate over the successors of a state |
  spot::fast_explicit_iterator | Iterator for fast_explicit_state |
  spot::fast_product_iterator | This is an iterator for the product |
 spot::fixed_size_pool | A fixed-size memory pool implementation |
 spot::formater | |
  spot::stat_printer | Prints various statistics about a TGBA |
   aut_stat_printer | |
 spot::ltl::formula | An LTL formula |
  spot::ltl::constant | A constant (True or False) |
  spot::ltl::ref_formula | A reference-counted LTL formula |
   spot::ltl::atomic_prop | Atomic propositions |
   spot::ltl::automatop | Automaton operators |
   spot::ltl::binop | Binary operator |
   spot::ltl::bunop | Bounded unary operator |
   spot::ltl::multop | Multi-operand operators |
   spot::ltl::unop | Unary operators |
 spot::generic_dfs | |
  spot::dotty_dfs | |
  spot::lbtt_dfs | |
  spot::stats_dfs | |
 graph | |
  spot::explicit_conf< graph, Type > | |
  spot::explicit_conf< graph, state_explicit_formula > | |
  spot::explicit_conf< graph, state_explicit_string > | |
 spot::gspn_exception | An exception used to forward GSPN errors |
 spot::gspn_interface | |
 spot::gspn_ssp_interface | |
 hash_map | |
  spot::ltl::relabeling_map | |
 spot::instance_automaton | A simple wrapper for an automaton |
  spot::dve2product_instance | |
  spot::simple_instance | |
 spot::instanciator | |
  spot::dve2product_instanciator | |
  spot::simple_instanciator | |
 job | |
 job_processor | |
 spot::ltl::language_containment_checker | Check containment between LTL formulae |
 spot::compressed_stack_of_lowlink::ll_elt | |
 tgbayy::location | Abstract a location |
 neverclaimyy::location | Abstract a location |
 eltlyy::location | Abstract a location |
 ltlyy::location | Abstract a location |
 spot::ltl::ltl_file | Read LTL formulae from a file, one by one |
 spot::ltl::formula::ltl_prop | |
 spot::ltl::ltl_simplifier | Rewrite or simplify f in various ways |
 spot::ltl::ltl_simplifier_options | |
 spot::ltl::mark_tools | |
 spot::markset | This class represents a set of acceptance marks |
 spot::minato_isop | Generate an irredundant sum-of-products (ISOP) form of a BDD function |
 spot::multiple_size_pool | A multiple-size memory pool implementation |
 spot::ltl::nfa | Nondeterministic Finite Automata used by automata operators |
 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_heap | Keep track of a large quantity of indexed states |
  spot::numbered_state_heap_hash_map | A straightforward implementation of numbered_state_heap with a hash map |
 spot::numbered_state_heap_const_iterator | Iterator on numbered_state_heap objects |
 spot::numbered_state_heap_factory | Abstract factory for numbered_state_heap |
  spot::numbered_state_heap_hash_map_factory | Factory for numbered_state_heap_hash_map |
 spot::ltl::random_formula::op_proba | |
 spot::option_map | Manage a map of options |
 spot::union_scc::pair_state_iter | |
 spot::dijkstra_scc::pair_state_iter | |
 spot::dijkstracheck::pair_state_iter | |
 spot::unioncheck::pair_state_iter | |
 spot::lazycheck::pair_state_iter | |
 spot::opt_dijkstra_scc::pair_state_iter | |
 spot::opt_tarjan_scc::pair_state_iter | |
 spot::stats::pair_state_iter | |
 spot::tarjan_scc::pair_state_iter | |
 spot::ltl::multop::paircmp | Comparison functor used internally by ltl::multop |
 eltlyy::position | Abstract a position |
 neverclaimyy::position | Abstract a position |
 tgbayy::position | Abstract a position |
 ltlyy::position | Abstract a position |
 spot::postprocessor | Wrap TGBA/BA/Monitor post-processing algorithms in an easy interface |
  spot::translator | Translate an LTL formula into an optimized spot::tgba |
 spot::power_map | |
 spot::printable | |
  spot::printable_value< const ltl::formula * > | |
   spot::printable_formula | |
  spot::printable_value< const spot::ltl::formula * > | |
   printable_formula | |
  spot::printable_value< double > | |
  spot::printable_value< unsigned > | |
  spot::printable_id | The default callback simply writes "%c" |
  spot::printable_percent | Called by default for "%%" and "%\0" |
  spot::printable_value< T > | |
  spot::temporary_file | Temporary file name |
   spot::open_temporary_file | Open temporary file |
 spot::ltl::random_formula | Base class for random formula generators |
  spot::ltl::random_boolean | Generate random Boolean formulae |
  spot::ltl::random_ltl | Generate random LTL formulae |
   spot::ltl::random_psl | Generate random PSL formulae |
  spot::ltl::random_sere | Generate random SERE |
 range | |
 spot::saba | A State-based Alternating (Generalized) Büchi Automaton |
  spot::saba_complement_tgba | Complement a TGBA and produce a SABA |
 spot::saba_reachable_iterator | Iterate over all reachable states of a spot::saba |
  spot::saba_reachable_iterator_breadth_first | An implementation of spot::saba_reachable_iterator that browses states breadth first |
  spot::saba_reachable_iterator_depth_first | An implementation of spot::saba_reachable_iterator that browses states depth first |
 spot::saba_state | Abstract class for saba states |
 spot::saba_state_conjunction | Iterate over a conjunction of saba_state |
  spot::explicit_state_conjunction | Basic implementation of saba_state_conjunction |
 spot::saba_succ_iterator | Iterate over the successors of a saba_state |
 spot::scc_map::scc | |
 spot::scc_map | Build a map of Strongly Connected components in in a TGBA |
 spot::scc_stack | |
 spot::scc_stack_ta | |
 spot::scc_stats | |
 spot::sccs_set | |
 spot::tarjan_scc::stack_entry | |
 spot::lazycheck::stack_entry | |
 spot::stats::stack_entry | |
 spot::tgba_reachable_iterator_depth_first::stack_item | |
 spot::stack_of_lowlink | |
  spot::compressed_stack_of_lowlink | This class represents a compaction of the lowlink stack |
 spot::stack_of_roots | |
  spot::compressed_stack_of_roots | |
 spot::state | Abstract class for states |
  spot::set_state | Set of states deriving from spot::state |
  spot::state_bdd | |
  spot::state_explicit< Label, label_hash > | |
  spot::state_kripke | Concrete class for kripke states |
  spot::state_product | A state for spot::tgba_product |
  spot::state_ta_explicit | |
  spot::state_ta_product | A state for spot::ta_product |
  spot::state_union | A state for spot::tgba_union |
  spot::state_explicit< const ltl::formula *, ltl::formula_ptr_hash > | |
   spot::state_explicit_formula | |
  spot::state_explicit< int, identity_hash< int > > | |
   spot::state_explicit_number | |
  spot::state_explicit< std::string, string_hash > | |
   spot::state_explicit_string | |
 spot::enumerate_cycles::state_info | |
 spot::stats::stats_entry | Structure to store stats about the product |
 spot::tgba_run::step | |
 spot::ltl::succ_iterator | |
 spot::couvreur99_check_shy::successor | |
 spot::ta | A Testing Automaton |
  spot::ta_explicit | |
  spot::ta_product | A lazy product between a Testing automaton and a Kripke structure. (States are computed on the fly.) |
 spot::ta_reachable_iterator | Iterate over all reachable states of a spot::ta |
  spot::ta_reachable_iterator_breadth_first | An implementation of spot::ta_reachable_iterator that browses states breadth first |
  spot::ta_reachable_iterator_depth_first | An implementation of spot::ta_reachable_iterator that browses states depth first |
 spot::ta_statistics | |
 spot::tgba | A Transition-based Generalized Büchi Automaton |
  spot::explicit_graph< State, tgba > | |
   spot::tgba_explicit< State > | |
  spot::fair_kripke | Interface for a Fair Kripke structure |
   spot::kripke | Interface for a Kripke structure |
    spot::kripke_explicit | Kripke Structure |
  spot::sba | A State-based Generalized Büchi Automaton |
   spot::explicit_graph< State, sba > | |
    spot::sba_explicit< State > | |
  spot::taa_tgba | A self-loop Transition-based Alternating Automaton (TAA) which is seen as a TGBA (abstract class, see below) |
   spot::taa_tgba_labelled< label, label_hash > | |
   spot::taa_tgba_labelled< const ltl::formula *, ltl::formula_ptr_hash > | |
    spot::taa_tgba_formula | |
   spot::taa_tgba_labelled< std::string, string_hash > | |
    spot::taa_tgba_string | |
  spot::tgba_bdd_concrete | A concrete spot::tgba implemented using BDDs |
  spot::tgba_kv_complement | Build a complemented automaton |
  spot::tgba_product | A lazy product. (States are computed on the fly.) |
   spot::tgba_product_init | A lazy product with different initial states |
   spot::tgta_product | A lazy product. (States are computed on the fly.) |
  spot::tgba_proxy | A TGBA proxy |
   spot::tgba_mask | A masked TGBA (abstract) |
  spot::tgba_safra_complement | Build a complemented automaton |
  spot::tgba_scc | Wrap a tgba to offer information about strongly connected components |
   spot::future_conditions_collector | Wrap a tgba to offer information about upcoming conditions |
  spot::tgba_sgba_proxy | Change the labeling-mode of spot::tgba on the fly, producing a state-based generalized Büchi automaton |
  spot::tgba_tba_proxy | Degeneralize a spot::tgba on the fly, producing a TBA |
   spot::tgba_sba_proxy | Degeneralize a spot::tgba on the fly, producing an SBA |
  spot::tgba_union | A lazy union. (States are computed on the fly.) |
  spot::tgta | A Transition-based Generalized Testing Automaton (TGTA) |
   spot::tgta_explicit | |
 spot::tgba_bdd_core_data | Core data for a TGBA encoded using BDDs |
 spot::tgba_bdd_factory | Abstract class for spot::tgba_bdd_concrete factories |
  spot::tgba_bdd_concrete_factory | Helper class to build a spot::tgba_bdd_concrete object |
 spot::tgba_reachable_iterator | Iterate over all reachable states of a spot::tgba |
  spot::tgba_reachable_iterator_breadth_first | An implementation of spot::tgba_reachable_iterator that browses states breadth first |
 spot::tgba_reachable_iterator_depth_first | Iterate over all states of an automaton using a DFS |
  spot::tgba_reachable_iterator_depth_first_stack | Iterate over all states of an automaton using a DFS |
 spot::tgba_run | An accepted run, for a tgba |
 spot::tgba_statistics | |
  spot::tgba_sub_statistics | |
 spot::tgba_succ_iterator | Iterate over the successors of a state |
  spot::fair_kripke_succ_iterator | Iterator code for a Fair Kripke structure |
  spot::kripke_succ_iterator | Iterator code for Kripke structure |
   spot::kripke_explicit_succ_iterator | Implement iterator pattern on successor of a state_kripke |
  spot::ta_succ_iterator | Iterate over the successors of a state |
   spot::ta_explicit_succ_iterator | Successor iterators used by spot::ta_explicit |
   spot::ta_succ_iterator_product | Iterate over the successors of a product computed on the fly |
    spot::ta_succ_iterator_product_by_changeset | |
  spot::taa_succ_iterator | |
  spot::tgba_explicit_succ_iterator< State > | |
  spot::tgba_succ_iterator_concrete | |
  spot::tgba_succ_iterator_union | Iterate over the successors of an union computed on the fly |
  spot::tgta_succ_iterator_product | Iterate over the successors of a product computed on the fly |
 spot::tgba_word | An infinite word stored as a lasso |
 spot::time_info | A structure to record elapsed time in clock ticks |
 spot::timer | A timekeeper that accumulate interval of time |
 spot::timer_map | A map of timer, where each timer has a name |
 spot::couvreur99_check_shy::todo_item | |
 spot::state_ta_explicit::transition | Explicit transitions |
 spot::state_explicit< Label, label_hash >::transition | |
 spot::ltl::nfa::transition | Explicit transitions |
 spot::transition | Structure that will store the successors of a state |
 spot::taa_tgba::transition | Explicit transitions |
 spot::ltl::automatop::tripletcmp | Comparison functor used internally by ltl::automatop |
 spot::uf | |
 unary_function | |
  spot::bdd_hash | Hash functor for BDDs |
  spot::fasttgba_state_ptr_hash | |
  spot::identity_hash< T > | A hash function that returns identity |
  spot::ltl::formula_ptr_hash | Hash Function for const formula* |
  spot::ptr_hash< T > | A hash function for pointers |
  spot::saba_state_ptr_hash | Hash Function for saba_state* |
  spot::saba_state_shared_ptr_hash | Hash Function for shared_saba_state (shared_ptr<const saba_state*>) |
  spot::state_ptr_hash | Hash Function for state* |
  spot::state_shared_ptr_hash | Hash Function for shared_state (shared_ptr<const state*>) |
 spot::union_find | |
  spot::setOfDisjointSetsIPC_LRPC | |
  spot::setOfDisjointSetsIPC_LRPC_MS | |
  spot::setOfDisjointSetsIPC_LRPC_MS_Dead | This class propose an union find based on a deadstore. The idea is to used a dedicated map for the storage of dead state but this storage is done in a lazy way. A counter maintain the realsize of the union find structure when a make dead is realized : this is possible with the assumption that make dead is performed on the dfs root of the SCC. So the structure maintain the real size of the structure which is the size of Alive states. Adding a new state only checks if this size is the size of the structure to avoid extra memory allocation. If it is not true this means that there are dead states insides the alive structure. Just pick one a insert it inside the dead store. Otherwise it's a classic insert |
 spot::unique_ptr< T > | Take ownership of a pointer at its construction, and destroy it at the end of the scope |
 spot::unsigned_statistics | |
  spot::ars_statistics | Accepting Run Search statistics |
   spot::acss_statistics | Accepting Cycle Search Space statistics |
    spot::couvreur99_check_result | Compute a counter example from a spot::couvreur99_check_status |
  spot::ec_statistics | Emptiness-check statistics |
   spot::couvreur99_check | An implementation of the Couvreur99 emptiness-check algorithm |
   spot::ta_check | An implementation of the emptiness-check algorithm for a product between a TA and a Kripke structure |
 spot::unsigned_statistics_copy | Comparable statistics |
 spot::ltl::visitor | Formula visitor |
  spot::ltl::clone_visitor | Clone a formula |
   spot::ltl::simplify_f_g_visitor | Replace true U f and false R g by F f and G g |
   spot::ltl::unabbreviate_logic_visitor | Clone and rewrite a formula to remove most of the abbreviated logical operators |
    spot::ltl::unabbreviate_ltl_visitor | Clone and rewrite a formula to remove most of the abbreviated LTL and logical operators |
  spot::ltl::postfix_visitor | Apply an algorithm on each node of an AST, during a postfix traversal |
 spot::weight | Manage for a given automaton a vector of counter indexed by its acceptance condition |
 Type | |
  spot::explicit_graph< State, Type > | |