 |
Vcsn
2.4
Be Rational
|
|
Vcsn
2.4
Be Rational
|
| ►Nboost | |
| Crange_difference< vcsn::detail::safe_filtered< Range, Filter > > | |
| ►Nstd | STL namespace |
| Chash< boost::dynamic_bitset< B, A > > | |
| Chash< map< Key, Value, Compare, Alloc > > | |
| Chash< pair< T1, T2 > > | |
| Chash< set< T, Compare, Alloc > > | |
| Chash< std::array< Value, Size > > | |
| Chash< std::tuple< Elements... > > | |
| Chash< unordered_set< Key, Hash, KeyEqual, Alloc > > | |
| Chash< vcsn::detail::index_t_impl< Tag > > | Hash indexes |
| Chash< vcsn::empty_t > | |
| Chash< vcsn::signature > | |
| Chash< vcsn::symbol > | |
| Chash< vector< T, Alloc > > | |
| Cis_integral< vcsn::detail::index_t_impl< Tag > > | Define index as an integral |
| ►Nvcsn | |
| ►Nast | |
| Cast_node | |
| Cautomaton | |
| Ccontext | |
| Ccontext_parser | Parser of snames |
| Ccontext_printer | |
| Ccontext_visitor | |
| Cexpansionset | |
| Cexpressionset | |
| Cgenset | Represents the "alphabets", or "generator set" |
| Cletterset | Support for letterset<GenSet> |
| Cnullableset | |
| Coneset | |
| Cother | |
| Cpolynomialset | |
| Csignature_printer | |
| Ctuple | |
| Ctupleset | |
| Cweightset | |
| Cwordset | Support for wordset<GenSet> |
| ►Nctx | |
| ►Ndetail | |
| ►Ndot | Implementation details of the dot parser |
| Cdriver | State and public interface for Dot parsing |
| ►Cparser | A Bison parser |
| Cbasic_symbol | A complete symbol |
| Cby_state | Type access provider for state based symbols |
| Cby_type | Type access provider for token (enum) based symbols |
| Cstack_symbol_type | "Internal" symbol: element of the stack |
| Csyntax_error | Syntax errors thrown from user actions |
| Ctoken | Tokens |
| Cunion_type | An auxiliary type to compute the largest semantic type |
| Cpaths_t | |
| Cslice | Present a slice of the top of a stack |
| Cstack | |
| Cvariant | A char[S] buffer to store and retrieve objects |
| ►Ca_star_impl | A Star implementation of lightest automaton |
| Cprofile | |
| Cand_ | And condition on several typenames |
| Cand_< F1 > | |
| Cand_< F1, F... > | |
| Cand_<> | |
| Cautomaton_decorator | Aggregate an automaton, and forward calls to it |
| Cb_impl | |
| Cbackslashify_output_filter | Backslash backslashes |
| Cbounded_lag_checker | |
| Ccompose_automaton_impl | Build the (accessible part of the) composition |
| Ccomposed_type | Build the (accessible part of the) composition |
| Cconcat | |
| Cconcat< index_sequence< I1... >, index_sequence< I2... > > | |
| Cconcat_index_sequence | |
| Cconcat_index_sequence< index_sequence< I1... >, index_sequence< I2... > > | |
| Cconcat_tupleset | |
| Cconcat_tupleset< weightset_mixin< tupleset_impl< T1... > >, weightset_mixin< tupleset_impl< T2... > > > | |
| Ccontext_t_of_impl | |
| Ccontext_t_of_impl< std::shared_ptr< ValueSet >, void_t< typename ValueSet::context_t > > | |
| Ccontext_t_of_impl< ValueSet *, void_t< typename ValueSet::context_t > > | |
| Ccontext_t_of_impl< ValueSet, void_t< typename ValueSet::context_t > > | |
| Ccopier | Copy an automaton |
| Ccycle_identity_impl | Whether all the paths between any two states have the same weight (i.e., for all s0, s1, any two paths p0, p1 between s0 and s1 have the same weight w_{s0,s1}) |
| Cdaut_impl | Format an automaton into Daut |
| Cdelay_automaton_impl | An automaton whose states may be qualified by delays and/or prefixes |
| ►Cdelgado_profiler | Compute a state profile for state-elimination based on the Delgado-Morais heuristic |
| Cstate_profile | |
| Cderived_term_algo | Specify a variety of derived-term construction |
| Cderived_term_automaton_impl | Compute the derived-term automaton from an expression |
| Cderived_term_automaton_members | Additional members when the labelset is letterized |
| Cderived_term_automaton_members< ExpSet, false > | Additional members when the labelset is not letterized |
| Cdetect | |
| Cdetect< T, Op, void_t< Op< T > > > | |
| Cdeterminized_automaton_impl | The subset construction automaton from another |
| ►Cdijkstra_impl | Dijkstra implementation of lightest automaton |
| Cprofile | |
| Cdot_impl | Format an automaton into Dot |
| Cdown_caster | A functor that captures the current location (to report errors), and provides "cast" |
| Cefsmer | Print automaton to EFSM format, based on FSM format |
| ►Cenumerater | Compute the shortest words accepted by an automaton |
| Cprofile_less | |
| Cepsilon_profile | This is used by some epsilon removal algorithms |
| Cepsilon_remover | This class contains the core of the proper algorithm |
| Cepsilon_remover< Aut, false > | |
| Cepsilon_remover_distance | This class contains the core of the proper algorithm |
| Cepsilon_remover_distance< Aut, false > | |
| Cepsilon_remover_separate | This class contains the core of the proper algorithm |
| Cepsilon_remover_separate< Aut, false > | |
| Ceval_if | |
| Ceval_if_c | Test if (c) then F1 else F2 and get the value |
| ►Cevaluator | Evaluate a word on an automaton |
| Clabeled_weight | |
| Cexpression_automaton_impl | An incremental automaton whose states are expressions |
| Cf2_impl | |
| Cfado_impl | Format an automaton into FAdo |
| Cfilter_automaton_impl | Hide some states of an automaton |
| Cfocus_automaton_impl | Read-write on an automaton, that hides all tapes but one |
| Cfull_context_t_of_impl | |
| Cfull_context_t_of_impl< insplit_automaton< Aut > > | |
| Cgenset_labelset | This class has no modeling purpose, it only serves to factor code common to letterset and wordset |
| Cgrail_impl | Print an automaton in Fado format |
| Chidden_label_type | |
| Chidden_label_type< Aut, index_sequence< I... > > | |
| Cif_ | |
| Cif_c | |
| Cif_c< false, T1, T2 > | |
| Cindex_sequence | |
| Cindex_sequence_difference | Get the list containing all the elements of I1 (contiguous sequence from 0 to N) not present in I2 (arbitrary sequence, sorted) |
| Cindex_sequence_difference< index_sequence< I1_1, I1... >, index_sequence< I1_1, I2... > > | |
| Cindex_sequence_difference< index_sequence< I1_1, I1... >, index_sequence< I2_1, I2... > > | |
| Cindex_sequence_difference< index_sequence< I1_1, I1... >, index_sequence<> > | |
| Cindex_sequence_difference< index_sequence<>, index_sequence<> > | |
| Cindex_t_impl | Lightweight state/transition handle (or index) |
| Cinsplit_automaton_impl | Insplit automaton decorator |
| Cint_range | |
| Cint_range< off, index_sequence< I... > > | |
| Cis_acyclic_impl | Detect circuits |
| Cis_ambiguous_impl | Whether an automaton is ambiguous |
| Cis_division_ring | |
| Cis_division_ring< polynomialset< Context, Kind > > | |
| Cis_division_ring< z > | |
| Cis_multitape | Whether a ValueSet, or a context, is multitape |
| Cis_multitape< context< LabelSet, WeightSet > > | |
| Cis_multitape< expressionset< Context > > | |
| Cis_multitape< tupleset< ValueSet... > > | |
| Cis_special_t | Needed for GCC 5 and 6 that refuse deduced return type for transitions() when using a lambda |
| Cis_valid_impl | |
| Cis_valid_impl< Aut, false > | |
| Cjoin_impl | A structure that implements the computation of join(V1, V2) |
| Cjoin_impl< b, expressionset< Context > > | |
| Cjoin_impl< context< LS1, WS1 >, context< LS2, WS2 > > | The join of two contexts |
| Cjoin_impl< expansionset< expressionset< Ctx1 > >, expansionset< expressionset< Ctx2 > > > | The join of two expansionsets |
| Cjoin_impl< expressionset< Ctx1 >, expressionset< Ctx2 > > | The join of two expressionsets |
| Cjoin_impl< letterset< GenSet >, letterset< GenSet > > | |
| Cjoin_impl< letterset< GenSet >, wordset< GenSet > > | The join with another labelset |
| Cjoin_impl< letterset< GenSet1 >, expressionset< Ctx2 > > | Join of a letterset and an expressionset |
| Cjoin_impl< nullableset< letterset< GenSet > >, wordset< GenSet > > | |
| Cjoin_impl< nullableset< LS1 >, LS2 > | The join with another labelset |
| Cjoin_impl< nullableset< LS1 >, nullableset< LS2 > > | The join with another labelset |
| Cjoin_impl< oneset, LS, std::enable_if_t< LS::has_one()> > | oneset v LS -> LS if LS::has_one |
| Cjoin_impl< oneset, LS, std::enable_if_t<!LS::has_one()> > | oneset v LS -> nullableset<LS> if !LS::has_one |
| Cjoin_impl< oneset, oneset > | |
| Cjoin_impl< polynomialset< Ctx1, Kind1 >, polynomialset< Ctx2, Kind2 > > | |
| Cjoin_impl< polynomialset< Ctx1, Kind1 >, WS2 > | |
| Cjoin_impl< q, expressionset< Context > > | |
| Cjoin_impl< r, expressionset< Context > > | |
| Cjoin_impl< rat::identities, rat::identities > | |
| Cjoin_impl< tupleset< VS1... >, tupleset< VS2... > > | Join between two tuplesets, of the same size |
| Cjoin_impl< tupleset< VS1... >, VS2 > | Join between a tupleset, and a non tuple |
| Cjoin_impl< wordset< GenSet >, wordset< GenSet > > | |
| Cjoin_impl< z, expressionset< Context > > | |
| Cjoin_impl< zmin, expressionset< Context > > | |
| Cjoin_impl_simple | |
| Cjoin_impl_simple< WeightSet, expressionset< Context > > | |
| Clabel_t_of_impl | |
| Clabel_t_of_impl< std::shared_ptr< ValueSet >, void_t< typename ValueSet::label_t > > | |
| Clabel_t_of_impl< ValueSet *, void_t< typename ValueSet::label_t > > | |
| Clabel_t_of_impl< ValueSet, void_t< typename ValueSet::label_t > > | |
| Clabelset_t_of_impl | |
| Clabelset_t_of_impl< std::shared_ptr< ValueSet >, void_t< typename ValueSet::labelset_t > > | |
| Clabelset_t_of_impl< ValueSet *, void_t< typename ValueSet::labelset_t > > | |
| Clabelset_t_of_impl< ValueSet, void_t< typename ValueSet::labelset_t > > | |
| Clabelset_types_impl | A traits so that tupleset may define types that may exist |
| Clabelset_types_impl< decltype(pass{std::declval< ValueSets >().genset()...}, void()), ValueSets... > | Specialization for tuples of labelsets |
| Claw_traits | The LAW from a LAL |
| Claw_traits< expressionset< Ctx > > | Conversion to a wordset: identity |
| Claw_traits< letterset< GenSet > > | Conversion for letterset<GenSet> to a super wordset |
| Claw_traits< nullableset< LabelSet > > | Conversion for nullable<LabelSet> to a super wordset |
| Claw_traits< oneset > | Conversion to a wordset: identity |
| Claw_traits< tupleset< LabelSets... > > | Conversion to wordset |
| Claw_traits< wordset< GenSet > > | |
| Clazy_proper_automaton_impl | Build a "lazy proper" automaton from the input with nullable labels |
| Clazy_proper_automaton_impl< Aut, false > | Specialization for automata with non nullable context |
| Clazy_tuple_automaton | Decorator implementing the laziness for an algorithm |
| Cleft_reductioner | |
| Cletterized_traits | A traits to compute the letterized context |
| Cletterized_traits< letterset< GenSet > > | Conversion to letterized |
| Cletterized_traits< nullableset< LabelSet > > | Conversion to letterized |
| Cletterized_traits< tupleset< LabelSets... > > | Conversion to letterized |
| Cletterized_traits< wordset< GenSet > > | Conversion to letterized |
| Cletterizer | From an automaton, the corresponding automaton with a non-word labelset |
| Clifter_impl | Helper structure for a lift of several tapes |
| Clifter_impl< Context, vcsn::detail::index_sequence<> > | Lift all the label tapes to the weights |
| ►Clightest_impl | The lightest algorithm computes the paths between pre and post with the smallest weight possible |
| Cprofile_less | |
| Clog_impl | |
| Cmake_index_range | A static range |
| Cmake_index_range_impl | A static range |
| Cmake_index_range_impl< S, 0 > | |
| Cmake_index_range_impl< S,-1U > | |
| Cmake_index_sequence | |
| Cmake_index_sequence< 0 > | |
| Cmake_index_sequence< 1 > | |
| Cmin_plus_impl | |
| Cminimizer | |
| Cminimizer< Aut, moore_tag > | |
| ►Cminimizer< Aut, signature_tag > | |
| Csignature_equal_to | |
| Csignature_hasher | |
| Cstate_output_for_label_t | |
| ►Cminimizer< Aut, weighted_tag > | |
| Cclassset | Dealing with class numbers |
| Csignature_equal_to | |
| Csignature_hasher | |
| ►Cmutable_automaton_impl | Bidirectional automata |
| Cstate_tag | Lightweight state handle (or index) |
| Cstored_state_t | Data stored for each state |
| Ctransition_tag | Lightweight transition handle (or index) |
| ►Cnaive_profiler | Compute a state profile for state-elimination based on connectivity |
| Cstate_profile | The state profile is the product of the number of (strictly) incoming transitions with the number of (strictly) outgoing ones, and whether it has loops |
| Cname_automaton_impl | An incremental automaton whose states are names |
| Cnmin_impl | |
| Cnullable_helper | Add support for an empty word to a LabelSet that does not provide such special label to this end |
| Cnullable_helper< letterset< GenSet > > | Add support for an empty word to a letterset thanks to the one() of its genset |
| Cnullableset_traits | The smallest nullableset which includes LabelSet |
| Cnullableset_traits< expressionset< Ctx > > | Conversion to a nullableset: identity |
| Cnullableset_traits< letterset< GenSet > > | Conversion for letterset<GenSet> to a nullableset |
| Cnullableset_traits< nullableset< LabelSet > > | Conversion for nullable<LabelSet> to a nullableset: id |
| Cnullableset_traits< oneset > | Conversion to a nullableset: identity |
| Cnullableset_traits< tupleset< LabelSets... >, std::enable_if_t< tupleset< LabelSets... >::has_one()> > | Conversion to a nullableset: all the labelsets support one |
| Cnullableset_traits< tupleset< LabelSets... >, std::enable_if_t<!tupleset< LabelSets... >::has_one()> > | Conversion to a nullableset: not all the labelsets support one |
| Cnullableset_traits< wordset< GenSet > > | Wordset is already a nullableset |
| Coptional_container | Enables or not the presence of a container in a class |
| Coptional_container< Container, true > | |
| Cor_ | Or condition on several typenames |
| Cor_< F1 > | |
| Cor_< F1, F... > | |
| Cor_<> | |
| Corigins_t_of_impl | From an (input) automaton type, compute its origin_t type |
| Corigins_t_of_impl< partition_automaton< Aut > > | |
| Corigins_t_of_impl< transpose_automaton< Aut > > | |
| Cpair_automaton_impl | The pair automaton is used by several algorithms for synchronizing words |
| Cpartial_identity_context | |
| Cpartition_automaton_impl | An automaton wrapper whose states form a partition of the state set of another automaton |
| Cpartition_automaton_t_impl | From an (input) automaton type, compute the right decorator for its partition_automaton |
| Cpartition_automaton_t_impl< partition_automaton< Aut > > | |
| Cpartition_automaton_t_impl< transpose_automaton< Aut > > | |
| Cpass | Ignore its arguments |
| Cpermutation_automaton_impl | An automaton isomorphic to another one |
| ►Cpolynomialset_impl | Linear combination of labels: map labels to weights |
| Cnorm_ | In the general case, normalize by the first (non null) weight |
| Cnorm_< polynomialset< Ctx, Knd >, Dummy > | Compute the left GCD of weights which are polynomials |
| Cnorm_< z, Dummy > | For Z, take the GCD, with the sign of the first value |
| Cpolystate_automaton_impl | An automaton whose state names are polynomials of states |
| Cprinter | Factor common bits in automaton formatting |
| Cproduct_automaton_impl | Build the (accessible part of the) product |
| Cproject_labelset_impl | The type of the resulting apparent LabelSet when keeping only tape Tape |
| Cproject_labelset_impl< Tape, expressionset< Context > > | Case of multitape expressionsets |
| Cproject_labelset_impl< Tape, tupleset< LabelSets... > > | Case of tuplesets |
| Cproper_traits | From a labelset, its non-nullable labelset |
| Cproper_traits< nullableset< LabelSet > > | |
| Cproper_traits< tupleset< LabelSet > > | Transform a tupleset of one element to a tupleset of the proper version |
| Cproperer | Spontaneous transition elimination |
| ►Cq_impl | |
| Cvalue_t | |
| Cqmp_impl | |
| Cquotienter | Apply a quotient onto an automaton: fuse equivalent states |
| Cr_impl | |
| Crandom_expression_impl | Class random expression generator |
| Crandom_weight | Generic declaration of the class which is specialized in each weightset |
| Crandom_weight< b, RandomGenerator > | Random generation |
| Crandom_weight< f2, RandomGenerator > | Random generation |
| Crandom_weight< log, RandomGenerator > | |
| Crandom_weight< nmin, RandomGenerator > | |
| Crandom_weight< q, RandomGenerator > | Random generation |
| Crandom_weight< qmp, RandomGenerator > | Random generation |
| Crandom_weight< r, RandomGenerator > | |
| Crandom_weight< rmin, RandomGenerator > | |
| Crandom_weight< z, RandomGenerator > | Random generation |
| Crandom_weight< zmin, RandomGenerator > | |
| Crandom_weight_base | Abstract class for random weight generation |
| Crank | Number of tapes |
| Crank< tupleset< LabelSet... > > | |
| Creal_context_impl | When we copy a focus automaton, we create another focus automaton |
| Creal_context_impl< automaton_decorator< Aut > > | Be recursive on automaton wrappers |
| Creal_context_impl< focus_automaton< Tape, Aut > > | |
| Cres_label_t_of_impl | |
| Cres_label_t_of_impl< insplit_automaton< Aut > > | |
| Cres_labelset_t_of_impl | |
| Cres_labelset_t_of_impl< insplit_automaton< Aut > > | |
| Creverse_postorder_impl | Get all states in reverse postorder using depth first search |
| Crmin_impl | |
| Csafe_filtered | |
| Cscc_automaton_impl | An automaton decorator that maps states to their scc-number |
| Cscc_impl | Class template for strongly-connected-components computations |
| Cscc_impl< Aut, auto_tag > | By default, use Tarjan iterative |
| Cscc_impl< Aut, dijkstra_tag > | Compute the strongly connected components using Dijkstra's algorithm |
| Cscc_impl< Aut, kosaraju_tag > | Compute the strongly connected components using Kosaraju's algorithm |
| ►Cscc_impl< Aut, tarjan_iterative_tag > | Tarjan's algorithm to find all strongly connected components: iterative implementation |
| Cstep_t | Step of one state contain infomation next successor and end iterator(output transitions or successors of this state) |
| Cscc_impl< Aut, tarjan_recursive_tag > | Tarjan's algorithm to find all strongly connected components: recursive implementation |
| Cselect | |
| Cselect< q > | |
| Cselect< r > | |
| Cselect< z > | |
| Csorter | A function to sort an automaton |
| Cstandard_operations | Implementation of left- and right- multiplication of an automaton by a weight |
| ►Cstar_height_visitor | |
| Cvisit_tuple | |
| Cvisit_tuple< false, Dummy > | |
| Cstate_bimap | A bidirectional map from state names to state numbers |
| Cstate_bimap< StateNameset, Stateset, false > | A bidirectional map from state names to state numbers |
| Cstate_bimap< StateNameset, Stateset, true > | A bidirectional map from state names to state numbers |
| Cstate_eliminator | Eliminate states in an automaton |
| Cstate_t_of_impl | |
| Cstate_t_of_impl< std::shared_ptr< ValueSet >, void_t< typename ValueSet::state_t > > | |
| Cstate_t_of_impl< ValueSet *, void_t< typename ValueSet::state_t > > | |
| Cstate_t_of_impl< ValueSet, void_t< typename ValueSet::state_t > > | |
| Csynchronize_checker | |
| Csynchronized_automaton_impl | An automaton whose states may be qualified by delays and/or prefixes |
| Csynchronizer | |
| Ctikzer | Format automaton to TikZ format |
| Ctransition_less | Compare transitions of an automaton |
| ►Ctransition_map | Cache the outgoing transitions of an automaton as efficient maps label -> vector<(weight, dst)> |
| Ctransition_ | Outgoing signature: weight, destination |
| Ctransition_< bool, false, Dummy > | Boolean outgoing signature: destination |
| Ctransition_< bool, true, Dummy > | Boolean outgoing signature: destination, transition identifier |
| Ctransition_< Weight, true, Dummy > | Weighted outgoing signature: weight, destination, transition identifier |
| Ctransition_t_of_impl | |
| Ctransition_t_of_impl< std::shared_ptr< ValueSet >, void_t< typename ValueSet::transition_t > > | |
| Ctransition_t_of_impl< ValueSet *, void_t< typename ValueSet::transition_t > > | |
| Ctransition_t_of_impl< ValueSet, void_t< typename ValueSet::transition_t > > | |
| ►Ctranspose_automaton_impl | Read-write view on an automaton, that transposes everything |
| Cfresh_impl_ | The transpose of a fresh non-transposed automaton |
| Cfresh_impl_< transpose_automaton< Fresh > > | The transpose of a fresh transposed automaton: the fresh type |
| ►Ctranspose_impl | A visitor to create a transposed expression, |
| Cvisit_tuple | |
| Ctrie_builder | Build a trie automaton (prefix-tree-like automaton) |
| Ctuple_automata_impl | Build the (accessible part of the) Cartesian product of automata |
| Ctuple_automaton_impl | An automaton whose states are tuples of states of automata |
| Ctuple_printer | |
| Ctuple_printer< Tuple, 1 > | |
| Ctupleset_impl | A ValueSet which is a Cartesian product of ValueSets |
| Cuniversal_impl | Functor for universal |
| Cvoider | |
| Cweight_t_of_impl | |
| Cweight_t_of_impl< std::shared_ptr< ValueSet >, void_t< typename ValueSet::weight_t > > | |
| Cweight_t_of_impl< ValueSet *, void_t< typename ValueSet::weight_t > > | |
| Cweight_t_of_impl< ValueSet, void_t< typename ValueSet::weight_t > > | |
| Cweightset_t_of_impl | |
| Cweightset_t_of_impl< std::shared_ptr< ValueSet >, void_t< typename ValueSet::weightset_t > > | |
| Cweightset_t_of_impl< ValueSet *, void_t< typename ValueSet::weightset_t > > | |
| Cweightset_t_of_impl< ValueSet, void_t< typename ValueSet::weightset_t > > | |
| Cwelement_label | Storage for a label |
| Cwelement_label< empty_t > | Storage for a label in the case of the empty labelset |
| Cwelement_weight | Storage for a non-null weight |
| Cwelement_weight< bool > | Storage for a non-null single-bit weight: don't actually store anything |
| ►Cwet_bitset | Weighted set: labels are non-negative integers, weights are bools |
| Citerator_impl | Iterator |
| Cwet_kind_impl | Wet_impl<Key, Value>: map |
| Cwet_kind_impl< char, bool > | Wet_impl<char, bool>: bitsets |
| Cwet_kind_impl< Key, bool > | Wet_impl<Key, bool>: set |
| Cwet_map | Weighted set: general, ordered, case |
| ►Cwet_set | Weighted set: weights are bools |
| Citerator_impl | Iterator |
| Cwet_unordered_map | Weighted set: general, unordered, case |
| Cword_synchronizer | |
| ►Cworded_automaton | |
| Cworded_labelset | |
| Cworded_labelset< tupleset< LabelSet... > > | |
| ►Cyen_impl | Yen implementation of the K lightest automaton algorithm |
| Cprofile | |
| Cz_impl | |
| Czmin_impl | |
| ►Ndyn | |
| ►Ndetail | |
| Cexpansion_tag | Tag for expansion/expansionset |
| Cexpression_tag | Tag for expression/expressionset |
| Clabel_tag | Tag for label/labelset |
| Cpolynomial_tag | Tag for polynomial/polynomialset |
| CRegistry | |
| Cweight_tag | Tag for weight/weightset |
| ►Cautomaton | A dyn automaton |
| Cbase | Abstract wrapped typed automaton |
| Cmodel | A wrapped typed automaton |
| ►Ccontext | Template-less root for contexts |
| Cbase | Abstract wrapped type |
| Cmodel | A wrapped type |
| Cjit_error | An exception suited for our compilation errors |
| ►Cvalue_impl | A dyn Value/ValueSet |
| Cbase | Abstract wrapped typed Value/ValueSet |
| Cmodel | A wrapped typed Value/ValueSet |
| ►Nrat | |
| Catom | |
| Cbraced_expression | An expression that "remembers" whether it was in parentheses |
| Cconst_visitor | |
| Cconstant | |
| ►Cconstant_term_visitor | A functor to compute the constant term of an expression |
| Cvisit_tuple | |
| Cvisit_tuple< false, Dummy > | |
| ►Ccopy_impl | Functor to copy/convert a rational expression |
| Cvisit_tuple | |
| ►Cderivation_visitor | Functor to compute the derivation of an expression |
| Cvisit_tuple | |
| Cvisit_tuple< false, Dummy > | |
| ►Cdot_printer | Pretty-printer for rational expressions |
| Cvisit_tuple | |
| Cdriver | State and public interface for rational expression parsing |
| Cexp | The abstract, non-parameterized, root for all rational expression node types |
| ►Cexpansionset | |
| Ctuple_impl | Denormalize a pack of one-tape expansions |
| Cvalue_t | An expansion |
| ►Cexpressionset_impl | A typed expression set |
| Cas_tupleset_impl | |
| Cas_tupleset_impl< detail::index_sequence< I... > > | |
| Ctuple_of_label | Turn a tuple of expressions that are labels into a multi-tape label |
| ►Chash | |
| Cvisit_tuple | |
| Cidentities | An expressionset can implement several different sets of identities on expressions |
| ►Cinductive_visitor | Build an automaton by induction from an expression |
| Cvisit_tuple | |
| Cvisit_tuple< false, Dummy > | |
| ►Cinfo | Gather information of the number of the different node types |
| Cvisit_tuple | |
| Cinner | An inner node |
| Cleaf | The root from which to derive the final node types |
| ►Cless | A functor to check whether one rational expression is (strictly) less than another one |
| Cvisit_tuple | |
| Clocation | Abstract a location |
| Cnode | The abstract parameterized, root for all rational expression types |
| ►Cparser | A Bison parser |
| Cbasic_symbol | A complete symbol |
| Cby_state | Type access provider for state based symbols |
| Cby_type | Type access provider for token (enum) based symbols |
| Cstack_symbol_type | "Internal" symbol: element of the stack |
| Csyntax_error | Syntax errors thrown from user actions |
| Ctoken | Tokens |
| Cunion_type | An auxiliary type to compute the largest semantic type |
| ►Cpartial_identity_impl | Functor to partial_identity/convert a rational expression |
| Cvisit_tuple | |
| Cposition | Abstract a position |
| ►Cprinter | Pretty-printer for rational expressions |
| Cvisit_tuple | |
| ►Cproject_impl | Functor to project a rational expression |
| Cvisit_tuple | |
| ►Csizer | Functor to compute the size of a rational expression |
| Cvisit_tuple | |
| Cslice | Present a slice of the top of a stack |
| Csplit_visitor | Break a rational expression into a polynomial |
| Cstack | |
| Cstandard_visitor | Build a standard automaton from an expression |
| Cstar_normal_form_visitor | |
| Cthompson_visitor | Build a Thompson automaton from an expression |
| ►Cto_expansion_visitor | Functor to compute the expansion of an expression |
| Cvisit_tuple | |
| Cvisit_tuple< false, Dummy > | |
| ►Ctuple | Implementation of nodes of tuple of rational expressions |
| Cvalues_t_impl | |
| Cvalues_t_impl< detail::index_sequence< I... > > | |
| Ctuple< Context, false > | |
| Cunary | |
| Cvariadic | An inner node with multiple children |
| Cvariant | A char[S] buffer to store and retrieve objects |
| Cweight_node | An inner node implementing a weight |
| Czpc_visitor | Build a ZPC automaton from an expression |
| Ca_star_tag | A-Star implementation (from vcsn/algos/a-star.hh) |
| Cany | Whether some of the values evaluate as true |
| Care_composable | Whether two contexts are composable |
| ►Care_isomorphicer | |
| Cfull_response | A datum specifying if two given automata are isomorphic, and why if they are not |
| Care_labelsets_composable | Whether two labelsets are composable |
| Care_labelsets_composable< tupleset< LS1, LS2 >, tupleset< LS2, LS3 > > | |
| Cas_pair | |
| Cas_tuple | |
| Cauto_tag | Tag to request the most appropriate version of an algorithm |
| Cautomaton_editor | Abstract Builder (the design pattern) for automata |
| Cautomatonset | |
| Cbellman_ford_tag | Bellman-Ford implementation (from vcsn/algos/bellman-ford.hh) |
| Cboolean_tag | Request the Boolean specialization for determinization (B and F2) |
| Cbrzozowski_tag | Request for Brzozowski implementation of minimize (B and free) |
| Cchar_letters | Represent alphabets whose "letters" are plain chars |
| Ccontainer_filter_range | |
| Ccontainer_range | Restrict the interface of a container to begin/end |
| Ccontext | |
| ►Ccross_sequences | Provide a range that allows to iterate over the cross product of the provided ranges |
| Ccross_iterator | Composite iterator |
| Cdeterministic_tag | Tag for operations on deterministic automata |
| Cdijkstra_tag | Dijkstra implementation |
| Cdiscrete_chooser | Random selector on container, using discrete distribution |
| Cdyn_vector_vnamer | The vname of a vector of dyn:: objects (e.g., automaton, expression, ...) is the tuple of their vnames |
| Cedit_automaton | Concrete Builder (the design pattern) for automata |
| Cempty_t | Empty labels, for LAO |
| Cequal_to | This is useful to make hashes with labels or weights as keys without using non-default constructors; to be used along with vcsn::hash |
| ►Cfile_library | Manage search paths |
| Cnot_found | Exception thrown when a file cannot be located |
| Cformat | An input/output format for valuesets |
| Cgeneral_tag | Tag for operations on all automata |
| Cgetarg | A mapping from strings to Values |
| Chash | This is useful to make hashes with labels or weights as keys without using non-default constructors; to be used along with vcsn::equal_to |
| Chopcroft_tag | Request for Hopcroft implementation of minimize (B and free) |
| Cintegral_constant | A simple placeholder for integral constants |
| Ciomanipulator | Defines the operator() for the classes get_type, set_type and swap_type |
| Cis_lal | |
| Cis_lan | |
| Cis_lao | |
| Cis_lar | |
| Cis_lat | |
| Cis_law | |
| Cis_tropical | |
| Cis_tropical< nmin > | |
| Cis_tropical< rmin > | |
| Cis_tropical< zmin > | |
| Ckosaraju_tag | Request the Kosaraju's algorithm to compute the SCCs |
| Clabels_are_expressions | |
| Clabels_are_letters | |
| Clabels_are_nullable | |
| Clabels_are_one | |
| Clabels_are_tuples | |
| Clabels_are_words | |
| Clazy_automaton_editor | Build an automaton with unknown context |
| Cless | Functor to compare Values of ValueSets |
| Cless_equal | Functor to compare Values of ValueSets |
| Cletterset | Implementation of labels are letters |
| CMilitaryOrder | Military strict order predicate |
| Cmoore_tag | Request for Moore implementation of minimize (B and free) |
| Cnullableset | Implementation of labels are nullables (letter or empty) |
| Coneset | Implementation of labels are ones: there is a single instance of label |
| ►Cpath | Paths in filesystems, i.e., file names |
| Cinvalid_path | Exception thrown on invalid path |
| Cpossibly_labeled_transition_tuple | Transition on non-empty label |
| Cpossibly_labeled_transition_tuple< State, empty_t > | Transition on empty label |
| Crandom_selector | Random selector on container, using uniform distribution |
| ►Cset_alphabet | A set of letters of type L |
| Chas_range | Whether the genset supports the range concept: whether we can use '++' on letters |
| Chas_range< Letter, decltype((++std::declval< Letter & >(), void()))> | |
| Csignature | Signature of a function call |
| Csignature_tag | Request for Moore implementation of minimize (B) |
| Csnamer | |
| Csnamer< bool > | |
| Csnamer< boost::optional< unsigned > > | |
| Csnamer< const std::set< std::pair< std::string, std::string > > > | |
| Csnamer< const std::string > | |
| Csnamer< const std::vector< unsigned > > | |
| Csnamer< float > | |
| Csnamer< int > | |
| Csnamer< std::integral_constant< T, Value > > | |
| Csnamer< std::istream > | |
| Csnamer< std::ostream > | |
| Csnamer< std::shared_ptr< T > > | |
| Csnamer< std::tuple< Args... > > | The sname of a tuple is the tuple of the snames |
| Csnamer< unsigned > | |
| Csnamer< vcsn::direction > | |
| Csnamer< vcsn::rat::identities > | |
| Csparse_map | Sparse Map implementation |
| Csparse_set | Sparse Set implementation |
| Cstandard_tag | Tag for operations on standard automata |
| Cstateset | State labelset |
| Cstring_letters | Represent alphabets whose "letters" are strings |
| Ctarjan_iterative_tag | Request the Tarjan's algorithm to compute the SCCs, implemented with explicit stack handling |
| Ctarjan_recursive_tag | Request the Tarjan's algorithm to compute the SCCs, implemented with recursion |
| Cto | An exponent, or range of exponents |
| Ctransition_tuple | Transition with label and non Boolean weight |
| Ctransition_tuple< State, Label, bool > | Transition with label and Boolean weight |
| Cvnamer | |
| Cvnamer< bool > | |
| Cvnamer< boost::optional< unsigned > > | |
| Cvnamer< const std::set< std::pair< std::string, std::string > > > | |
| Cvnamer< const std::string > | |
| Cvnamer< const std::vector< dyn::automaton > > | Vector<dyn::automaton> -> std::tuple<automaton_t, ...> |
| Cvnamer< const std::vector< dyn::context > > | Vector<dyn::context> -> std::tuple<context_t, ...> |
| Cvnamer< const std::vector< dyn::expansion > > | Vector<dyn::expansion> -> std::tuple<expansion_t, ...> |
| Cvnamer< const std::vector< dyn::expression > > | Vector<dyn::expression> -> std::tuple<expression_t, ...> |
| Cvnamer< const std::vector< dyn::label > > | Vector<dyn::label> -> std::tuple<label_t, ...> |
| Cvnamer< const std::vector< dyn::polynomial > > | Vector<dyn::polynomial> -> std::tuple<polynomial_t, ...> |
| Cvnamer< const std::vector< dyn::weight > > | Vector<dyn::weight> -> std::tuple<weight_t, ...> |
| Cvnamer< const std::vector< unsigned > > | |
| Cvnamer< float > | |
| Cvnamer< int > | |
| Cvnamer< integral_constant > | |
| Cvnamer< std::integral_constant< T, Value > > | |
| Cvnamer< std::istream > | |
| Cvnamer< std::ostream > | |
| Cvnamer< unsigned > | |
| Cvnamer< vcsn::direction > | |
| Cvnamer< vcsn::rat::identities > | |
| Cweighted_tag | Request for the weighted version of an algorithm |
| Cweightset_mixin | Provide a variadic mul on top of a binary mul(), and one() |
| Cwelement | Storage for a label and a non-null weight |
| Cwordset | Implementation of labels are words |
| ►Cxalloc | Allocate slots in std::ostreams |
| Cget_type | Handle the data to get from the xalloced place |
| Cset_type | Handle the data to put in the xalloced place |
| Cswap_type | Swap the data stored in the stream for a given one |
| Cyen_tag | Yen implementation |
| ►Czip_sequences | |
| Czip_iterator | Composite iterator |
| ►Czip_sequences_padded | |
| Czip_iterator | |
| ►Czipped_maps | |
| Citerator | Composite iterator |
| CConcat | |
| CFlexLexer | |
| Cis_integral | |
| CL | |
| Cmultichar_output_filter | |
| Ctype | |
| CyyFlexLexer |
1.8.10 
