 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::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::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::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::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 |
 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 | |
 job | |
 job_processor | |
 spot::ltl::language_containment_checker | Check containment between LTL formulae |
 ltlyy::location | Abstract a location |
 neverclaimyy::location | Abstract a location |
 kripkeyy::location | Abstract a location |
 tgbayy::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::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::ltl::multop::paircmp | Comparison functor used internally by ltl::multop |
 kripkeyy::position | Abstract a position |
 ltlyy::position | Abstract a position |
 neverclaimyy::position | Abstract a position |
 tgbayy::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::satsolver | Interface with a SAT solver |
 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::tgba_reachable_iterator_depth_first::stack_item | |
 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::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::taa_tgba::transition | Explicit transitions |
 spot::state_explicit< Label, label_hash >::transition | |
 spot::state_ta_explicit::transition | Explicit transitions |
 spot::ltl::nfa::transition | Explicit transitions |
 spot::ltl::automatop::tripletcmp | Comparison functor used internally by ltl::automatop |
 unary_function | |
  spot::bdd_hash | Hash functor for BDDs |
  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::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 > | |