Vcsn  2.4
Be Rational
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
registries.hh File Reference
#include <vector>
#include <vcsn/algos/fwd.hh>
#include <vcsn/dyn/fwd.hh>
#include <vcsn/dyn/name.hh>
#include <vcsn/dyn/types.hh>
#include <vcsn/misc/export.hh>
#include <vcsn/misc/fwd.hh>
Include dependency graph for registries.hh:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Namespaces

 vcsn
 
 vcsn::dyn
 
 vcsn::dyn::detail
 

Macros

#define REGISTRY_DECLARE(Name, Signature)
 

Typedefs

using vcsn::dyn::detail::accessible_t = auto(const automaton &aut) -> automaton
 
using vcsn::dyn::detail::add_t = auto(const automaton &lhs, const automaton &rhs, const std::string &algo) -> automaton
 
using vcsn::dyn::detail::add_expansion_t = auto(const expansion &lhs, const expansion &rhs) -> expansion
 
using vcsn::dyn::detail::add_expression_t = auto(const expression &lhs, const expression &rhs) -> expression
 
using vcsn::dyn::detail::add_polynomial_t = auto(const polynomial &lhs, const polynomial &rhs) -> polynomial
 
using vcsn::dyn::detail::add_weight_t = auto(const weight &lhs, const weight &rhs) -> weight
 
using vcsn::dyn::detail::ambiguous_word_t = auto(const automaton &aut) -> label
 
using vcsn::dyn::detail::are_equivalent_t = auto(const automaton &aut1, const automaton &aut2) -> bool
 
using vcsn::dyn::detail::are_equivalent_expression_t = auto(const expression &r1, const expression &r2) -> bool
 
using vcsn::dyn::detail::are_isomorphic_t = auto(const automaton &aut1, const automaton &aut2) -> bool
 
using vcsn::dyn::detail::cerny_t = auto(const context &ctx, unsigned num_states) -> automaton
 
using vcsn::dyn::detail::coaccessible_t = auto(const automaton &aut) -> automaton
 
using vcsn::dyn::detail::codeterminize_t = auto(const automaton &aut, const std::string &algo) -> automaton
 
using vcsn::dyn::detail::cominimize_t = auto(const automaton &aut, const std::string &algo) -> automaton
 
using vcsn::dyn::detail::complement_t = auto(const automaton &aut) -> automaton
 
using vcsn::dyn::detail::complement_expansion_t = auto(const expansion &xpn) -> expansion
 
using vcsn::dyn::detail::complement_expression_t = auto(const expression &exp) -> expression
 
using vcsn::dyn::detail::complete_t = auto(const automaton &aut) -> automaton
 
using vcsn::dyn::detail::component_t = auto(const automaton &aut, unsigned num) -> automaton
 
using vcsn::dyn::detail::compose_t = auto(const automaton &lhs, const automaton &rhs, bool lazy) -> automaton
 
using vcsn::dyn::detail::compose_expansion_t = auto(const expansion &lhs, const expansion &rhs) -> expansion
 
using vcsn::dyn::detail::compose_expression_t = auto(const expression &lhs, const expression &rhs) -> expression
 
using vcsn::dyn::detail::compose_polynomial_t = auto(const polynomial &lhs, const polynomial &rhs) -> polynomial
 
using vcsn::dyn::detail::concatenate_expression_t = auto(const expression &lhs, const expression &rhs) -> expression
 
using vcsn::dyn::detail::condense_t = auto(const automaton &aut) -> automaton
 
using vcsn::dyn::detail::conjugate_t = auto(const automaton &a) -> automaton
 
using vcsn::dyn::detail::conjunction_t = auto(const std::vector< automaton > &as, bool lazy) -> automaton
 
using vcsn::dyn::detail::conjunction_expansion_t = auto(const expansion &lhs, const expansion &rhs) -> expansion
 
using vcsn::dyn::detail::conjunction_expression_t = auto(const expression &lhs, const expression &rhs) -> expression
 
using vcsn::dyn::detail::conjunction_polynomial_t = auto(const polynomial &lhs, const polynomial &rhs) -> polynomial
 
using vcsn::dyn::detail::conjunction_repeated_t = auto(const automaton &aut, unsigned n) -> automaton
 
using vcsn::dyn::detail::constant_term_t = auto(const expression &exp) -> weight
 
using vcsn::dyn::detail::context_of_t = auto(const automaton &aut) -> context
 
using vcsn::dyn::detail::context_of_expansion_t = auto(const expansion &exp) -> context
 
using vcsn::dyn::detail::context_of_expression_t = auto(const expression &exp) -> context
 
using vcsn::dyn::detail::context_of_polynomial_t = auto(const polynomial &poly) -> context
 
using vcsn::dyn::detail::copy_t = auto(const automaton &aut) -> automaton
 
using vcsn::dyn::detail::copy_convert_t = auto(const automaton &aut, const context &ctx) -> automaton
 
using vcsn::dyn::detail::copy_expression_t = auto(const expression &exp, const context &ctx, identities ids) -> expression
 
using vcsn::dyn::detail::costandard_t = auto(const automaton &aut) -> automaton
 
using vcsn::dyn::detail::cotrie_t = auto(const polynomial &poly) -> automaton
 
using vcsn::dyn::detail::cotrie_stream_t = auto(const context &ctx, std::istream &is, const std::string &format) -> automaton
 
using vcsn::dyn::detail::de_bruijn_t = auto(const dyn::context &ctx, unsigned n) -> automaton
 
using vcsn::dyn::detail::delay_automaton_t = auto(const automaton &aut) -> automaton
 
using vcsn::dyn::detail::derivation_t = auto(const expression &exp, const label &lbl, bool breaking) -> polynomial
 
using vcsn::dyn::detail::derived_term_t = auto(const expression &exp, const std::string &algo) -> automaton
 
using vcsn::dyn::detail::determinize_t = auto(const automaton &aut, const std::string &algo) -> automaton
 
using vcsn::dyn::detail::difference_t = auto(const automaton &lhs, const automaton &rhs) -> automaton
 
using vcsn::dyn::detail::difference_expression_t = auto(const expression &lhs, const expression &rhs) -> expression
 
using vcsn::dyn::detail::divkbaseb_t = auto(const context &ctx, unsigned divisor, unsigned base) -> automaton
 
using vcsn::dyn::detail::double_ring_t = auto(const context &ctx, unsigned n, const std::vector< unsigned > &finals) -> automaton
 
using vcsn::dyn::detail::eliminate_state_t = auto(const automaton &aut, int state) -> automaton
 
using vcsn::dyn::detail::eval_polynomial_t = auto(const automaton &aut, const polynomial &poly) -> weight
 
using vcsn::dyn::detail::evaluate_t = auto(const automaton &aut, const label &lbl) -> weight
 
using vcsn::dyn::detail::expand_t = auto(const expression &exp) -> expression
 
using vcsn::dyn::detail::expression_one_t = auto(const context &ctx, identities ids) -> expression
 
using vcsn::dyn::detail::expression_zero_t = auto(const context &ctx, identities ids) -> expression
 
using vcsn::dyn::detail::factor_t = auto(const automaton &aut) -> automaton
 
using vcsn::dyn::detail::filter_t = auto(const automaton &aut, const std::vector< unsigned > &states) -> automaton
 
using vcsn::dyn::detail::focus_t = auto(const automaton &aut, integral_constant) -> automaton
 
using vcsn::dyn::detail::has_bounded_lag_t = auto(const automaton &aut) -> bool
 
using vcsn::dyn::detail::has_lightening_cycle_t = auto(const automaton &aut) -> bool
 
using vcsn::dyn::detail::has_twins_property_t = auto(const automaton &aut) -> bool
 
using vcsn::dyn::detail::identities_of_t = auto(const expression &exp) -> identities
 
using vcsn::dyn::detail::inductive_t = auto(const expression &exp, const std::string &algo) -> automaton
 
using vcsn::dyn::detail::infiltrate_t = auto(const std::vector< automaton > &as) -> automaton
 
using vcsn::dyn::detail::infiltrate_expression_t = auto(const expression &lhs, const expression &rhs) -> expression
 
using vcsn::dyn::detail::info_t = auto(const automaton &aut, std::ostream &out, unsigned details) -> std::ostream &
 
using vcsn::dyn::detail::info_expression_t = auto(const expression &exp, std::ostream &o) -> std::ostream &
 
using vcsn::dyn::detail::insplit_t = auto(const automaton &aut, bool lazy) -> automaton
 
using vcsn::dyn::detail::is_accessible_t = auto(const automaton &aut) -> bool
 
using vcsn::dyn::detail::is_ambiguous_t = auto(const automaton &aut) -> bool
 
using vcsn::dyn::detail::is_coaccessible_t = auto(const automaton &aut) -> bool
 
using vcsn::dyn::detail::is_codeterministic_t = auto(const automaton &aut) -> bool
 
using vcsn::dyn::detail::is_complete_t = auto(const automaton &aut) -> bool
 
using vcsn::dyn::detail::is_costandard_t = auto(const automaton &aut) -> bool
 
using vcsn::dyn::detail::is_cycle_ambiguous_t = auto(const automaton &aut) -> bool
 
using vcsn::dyn::detail::is_deterministic_t = auto(const automaton &aut) -> bool
 
using vcsn::dyn::detail::is_empty_t = auto(const automaton &aut) -> bool
 
using vcsn::dyn::detail::is_eps_acyclic_t = auto(const automaton &aut) -> bool
 
using vcsn::dyn::detail::is_functional_t = auto(const automaton &aut) -> bool
 
using vcsn::dyn::detail::is_letterized_t = auto(const automaton &aut) -> bool
 
using vcsn::dyn::detail::is_normalized_t = auto(const automaton &aut) -> bool
 
using vcsn::dyn::detail::is_out_sorted_t = auto(const automaton &aut) -> bool
 
using vcsn::dyn::detail::is_partial_identity_t = auto(const automaton &aut) -> bool
 
using vcsn::dyn::detail::is_proper_t = auto(const automaton &aut) -> bool
 
using vcsn::dyn::detail::is_realtime_t = auto(const automaton &aut) -> bool
 
using vcsn::dyn::detail::is_standard_t = auto(const automaton &aut) -> bool
 
using vcsn::dyn::detail::is_synchronized_t = auto(const automaton &aut) -> bool
 
using vcsn::dyn::detail::is_synchronized_by_t = auto(const automaton &aut, const label &word) -> bool
 
using vcsn::dyn::detail::is_synchronizing_t = auto(const automaton &aut) -> bool
 
using vcsn::dyn::detail::is_trim_t = auto(const automaton &aut) -> bool
 
using vcsn::dyn::detail::is_useless_t = auto(const automaton &aut) -> bool
 
using vcsn::dyn::detail::is_valid_t = auto(const automaton &aut) -> bool
 
using vcsn::dyn::detail::is_valid_expression_t = auto(const expression &exp) -> bool
 
using vcsn::dyn::detail::join_t = auto(const context &c1, const context &c2) -> context
 
using vcsn::dyn::detail::ladybird_t = auto(const dyn::context &ctx, unsigned n) -> automaton
 
using vcsn::dyn::detail::ldivide_t = auto(const automaton &aut1, const automaton &aut2) -> automaton
 
using vcsn::dyn::detail::ldivide_expansion_t = auto(const expansion &lhs, const expansion &rhs) -> expansion
 
using vcsn::dyn::detail::ldivide_expression_t = auto(const expression &lhs, const expression &rhs) -> expression
 
using vcsn::dyn::detail::ldivide_label_t = auto(const label &lhs, const label &rhs) -> label
 
using vcsn::dyn::detail::ldivide_polynomial_t = auto(const polynomial &lhs, const polynomial &rhs) -> polynomial
 
using vcsn::dyn::detail::ldivide_weight_t = auto(const weight &lhs, const weight &rhs) -> weight
 
using vcsn::dyn::detail::less_than_expression_t = auto(const expression &lhs, const expression &rhs) -> bool
 
using vcsn::dyn::detail::letterize_t = auto(const automaton &aut) -> automaton
 
using vcsn::dyn::detail::levenshtein_t = auto(const dyn::context &ctx) -> automaton
 
using vcsn::dyn::detail::lgcd_polynomial_t = auto(const polynomial &lhs, const polynomial &rhs) -> polynomial
 
using vcsn::dyn::detail::lift_automaton_t = auto(const automaton &aut, identities ids, integral_constant) -> automaton
 
using vcsn::dyn::detail::lift_expression_t = auto(const expression &exp) -> expression
 
using vcsn::dyn::detail::lightest_t = auto(const automaton &aut, unsigned num, const std::string &algo) -> polynomial
 
using vcsn::dyn::detail::lightest_automaton_t = auto(const automaton &aut, unsigned k, const std::string &algo) -> automaton
 
using vcsn::dyn::detail::list_polynomial_t = auto(const polynomial &polynomial, std::ostream &o) -> std::ostream &
 
using vcsn::dyn::detail::lweight_t = auto(const weight &weight, const automaton &aut, const std::string &algo) -> automaton
 
using vcsn::dyn::detail::lweight_expansion_t = auto(const weight &weight, const expansion &exp) -> expansion
 
using vcsn::dyn::detail::lweight_expression_t = auto(const weight &weight, const expression &exp) -> expression
 
using vcsn::dyn::detail::lweight_polynomial_t = auto(const weight &weight, const polynomial &poly) -> polynomial
 
using vcsn::dyn::detail::make_automaton_editor_t = auto(const context &ctx) -> automaton_editor *
 
using vcsn::dyn::detail::make_context_t = auto(const std::string &name) -> context
 
using vcsn::dyn::detail::make_word_context_t = auto(const context &ctx) -> context
 
using vcsn::dyn::detail::minimize_t = auto(const automaton &aut, const std::string &algo) -> automaton
 
using vcsn::dyn::detail::multiply_t = auto(const automaton &lhs, const automaton &rhs, const std::string &algo) -> automaton
 
using vcsn::dyn::detail::multiply_expression_t = auto(const expression &lhs, const expression &rhs) -> expression
 
using vcsn::dyn::detail::multiply_expression_repeated_t = auto(const expression &re, int min, int max) -> expression
 
using vcsn::dyn::detail::multiply_label_t = auto(const label &lhs, const label &rhs) -> label
 
using vcsn::dyn::detail::multiply_label_repeated_t = auto(const label &re, int exp) -> label
 
using vcsn::dyn::detail::multiply_polynomial_t = auto(const polynomial &lhs, const polynomial &rhs) -> polynomial
 
using vcsn::dyn::detail::multiply_repeated_t = auto(const automaton &a, int min, int max, const std::string &algo) -> automaton
 
using vcsn::dyn::detail::multiply_weight_t = auto(const weight &lhs, const weight &rhs) -> weight
 
using vcsn::dyn::detail::multiply_weight_repeated_t = auto(const weight &wgt, int min, int max) -> weight
 
using vcsn::dyn::detail::normalize_t = auto(const automaton &aut) -> automaton
 
using vcsn::dyn::detail::num_components_t = auto(const automaton &aut) -> std::size_t
 
using vcsn::dyn::detail::num_tapes_t = auto(const context &ctx) -> size_t
 
using vcsn::dyn::detail::pair_t = auto(const automaton &aut, bool keep_initials) -> automaton
 
using vcsn::dyn::detail::partial_identity_t = auto(const automaton &aut) -> automaton
 
using vcsn::dyn::detail::partial_identity_expression_t = auto(const expression &exp) -> expression
 
using vcsn::dyn::detail::prefix_t = auto(const automaton &aut) -> automaton
 
using vcsn::dyn::detail::print_t = auto(const automaton &aut, std::ostream &o, const std::string &fmt) -> std::ostream &
 
using vcsn::dyn::detail::print_context_t = auto(const context &ctx, std::ostream &o, const std::string &fmt) -> std::ostream &
 
using vcsn::dyn::detail::print_expansion_t = auto(const expansion &expansion, std::ostream &o, const std::string &fmt) -> std::ostream &
 
using vcsn::dyn::detail::print_expression_t = auto(const expression &exp, std::ostream &o, const std::string &fmt) -> std::ostream &
 
using vcsn::dyn::detail::print_label_t = auto(const label &label, std::ostream &o, const std::string &fmt) -> std::ostream &
 
using vcsn::dyn::detail::print_polynomial_t = auto(const polynomial &polynomial, std::ostream &o, const std::string &fmt) -> std::ostream &
 
using vcsn::dyn::detail::print_weight_t = auto(const weight &weight, std::ostream &o, const std::string &fmt) -> std::ostream &
 
using vcsn::dyn::detail::project_t = auto(const automaton &aut, integral_constant) -> automaton
 
using vcsn::dyn::detail::project_context_t = auto(const context &ctx, integral_constant) -> context
 
using vcsn::dyn::detail::project_expansion_t = auto(const expansion &exp, integral_constant) -> expansion
 
using vcsn::dyn::detail::project_expression_t = auto(const expression &exp, integral_constant) -> expression
 
using vcsn::dyn::detail::project_label_t = auto(const label &lbl, integral_constant) -> label
 
using vcsn::dyn::detail::project_polynomial_t = auto(const polynomial &poly, integral_constant) -> polynomial
 
using vcsn::dyn::detail::proper_t = auto(const automaton &aut, direction dir, bool prune, const std::string &algo) -> automaton
 
using vcsn::dyn::detail::push_weights_t = auto(const automaton &aut) -> automaton
 
using vcsn::dyn::detail::quotkbaseb_t = auto(const context &ctx, unsigned divisor, unsigned base) -> automaton
 
using vcsn::dyn::detail::random_automaton_t = auto(const context &ctx, unsigned num_states, float density, unsigned num_initial, unsigned num_final, boost::optional< unsigned > max_labels, float loop_chance, const std::string &weights) -> automaton
 
using vcsn::dyn::detail::random_automaton_deterministic_t = auto(const context &ctx, unsigned num_states) -> automaton
 
using vcsn::dyn::detail::random_expression_t = auto(const context &ctx, const std::string &param, identities ids) -> expression
 
using vcsn::dyn::detail::random_weight_t = auto(const context &ctx, const std::string &param) -> weight
 
using vcsn::dyn::detail::rdivide_t = auto(const automaton &aut1, const automaton &aut2) -> automaton
 
using vcsn::dyn::detail::rdivide_expression_t = auto(const expression &lhs, const expression &rhs) -> expression
 
using vcsn::dyn::detail::rdivide_label_t = auto(const label &lhs, const label &rhs) -> label
 
using vcsn::dyn::detail::rdivide_weight_t = auto(const weight &lhs, const weight &rhs) -> weight
 
using vcsn::dyn::detail::read_label_t = auto(const context &ctx, std::istream &is, bool quoted) -> label
 
using vcsn::dyn::detail::read_polynomial_t = auto(const context &ctx, std::istream &is) -> polynomial
 
using vcsn::dyn::detail::read_weight_t = auto(const context &ctx, std::istream &is) -> weight
 
using vcsn::dyn::detail::realtime_t = auto(const automaton &aut) -> automaton
 
using vcsn::dyn::detail::reduce_t = auto(const automaton &aut) -> automaton
 
using vcsn::dyn::detail::rweight_t = auto(const automaton &aut, const weight &weight, const std::string &algo) -> automaton
 
using vcsn::dyn::detail::rweight_expansion_t = auto(const expansion &exp, const weight &weight) -> expansion
 
using vcsn::dyn::detail::rweight_expression_t = auto(const expression &exp, const weight &weight) -> expression
 
using vcsn::dyn::detail::rweight_polynomial_t = auto(const polynomial &poly, const weight &weight) -> polynomial
 
using vcsn::dyn::detail::scc_t = auto(const automaton &aut, const std::string &algo) -> automaton
 
using vcsn::dyn::detail::shortest_t = auto(const automaton &aut, boost::optional< unsigned > num, boost::optional< unsigned > len) -> polynomial
 
using vcsn::dyn::detail::shuffle_t = auto(const std::vector< automaton > &as) -> automaton
 
using vcsn::dyn::detail::shuffle_expression_t = auto(const expression &lhs, const expression &rhs) -> expression
 
using vcsn::dyn::detail::sort_t = auto(const automaton &aut) -> automaton
 
using vcsn::dyn::detail::split_t = auto(const expression &exp) -> polynomial
 
using vcsn::dyn::detail::split_polynomial_t = auto(const polynomial &poly) -> polynomial
 
using vcsn::dyn::detail::standard_t = auto(const automaton &aut) -> automaton
 
using vcsn::dyn::detail::standard_expression_t = auto(const expression &exp) -> automaton
 
using vcsn::dyn::detail::star_t = auto(const automaton &a, const std::string &algo) -> automaton
 
using vcsn::dyn::detail::star_height_t = auto(const expression &exp) -> unsigned
 
using vcsn::dyn::detail::star_normal_form_t = auto(const expression &exp) -> expression
 
using vcsn::dyn::detail::strip_t = auto(const automaton &aut) -> automaton
 
using vcsn::dyn::detail::subword_t = auto(const automaton &aut) -> automaton
 
using vcsn::dyn::detail::suffix_t = auto(const automaton &aut) -> automaton
 
using vcsn::dyn::detail::synchronize_t = auto(const automaton &aut) -> automaton
 
using vcsn::dyn::detail::synchronizing_word_t = auto(const automaton &aut, const std::string &algo) -> label
 
using vcsn::dyn::detail::thompson_t = auto(const expression &exp) -> automaton
 
using vcsn::dyn::detail::to_expansion_t = auto(const expression &exp) -> expansion
 
using vcsn::dyn::detail::to_expression_t = auto(const automaton &aut, identities ids, const std::string &algo) -> expression
 
using vcsn::dyn::detail::to_expression_class_t = auto(const context &ctx, identities ids, const letter_class_t &letters, bool accept) -> expression
 
using vcsn::dyn::detail::to_expression_label_t = auto(const context &ctx, identities ids, const label &lbl) -> expression
 
using vcsn::dyn::detail::transpose_t = auto(automaton &aut) -> automaton
 
using vcsn::dyn::detail::transpose_expression_t = auto(const expression &exp) -> expression
 
using vcsn::dyn::detail::transposition_expression_t = auto(const expression &exp) -> expression
 
using vcsn::dyn::detail::trie_t = auto(const polynomial &poly) -> automaton
 
using vcsn::dyn::detail::trie_stream_t = auto(const context &ctx, std::istream &is, const std::string &format) -> automaton
 
using vcsn::dyn::detail::trim_t = auto(const automaton &aut) -> automaton
 
using vcsn::dyn::detail::tuple_t = auto(const std::vector< automaton > &as) -> automaton
 
using vcsn::dyn::detail::tuple_context_t = auto(const std::vector< context > &cs) -> context
 
using vcsn::dyn::detail::tuple_expansion_t = auto(const std::vector< expansion > &es) -> expansion
 
using vcsn::dyn::detail::tuple_expression_t = auto(const std::vector< expression > &es) -> expression
 
using vcsn::dyn::detail::tuple_polynomial_t = auto(const std::vector< polynomial > &ps) -> polynomial
 
using vcsn::dyn::detail::u_t = auto(const context &ctx, unsigned n) -> automaton
 
using vcsn::dyn::detail::universal_t = auto(const automaton &aut) -> automaton
 
using vcsn::dyn::detail::weight_one_t = auto(const context &ctx) -> weight
 
using vcsn::dyn::detail::weight_series_t = auto(const automaton &aut) -> weight
 
using vcsn::dyn::detail::weight_zero_t = auto(const context &ctx) -> weight
 
using vcsn::dyn::detail::zpc_t = auto(const expression &exp, const std::string &algo) -> automaton
 

Functions

bool vcsn::dyn::detail::accessible_register (const signature &sig, accessible_t fn)
 
bool vcsn::dyn::detail::add_register (const signature &sig, add_t fn)
 
bool vcsn::dyn::detail::add_expansion_register (const signature &sig, add_expansion_t fn)
 
bool vcsn::dyn::detail::add_expression_register (const signature &sig, add_expression_t fn)
 
bool vcsn::dyn::detail::add_polynomial_register (const signature &sig, add_polynomial_t fn)
 
bool vcsn::dyn::detail::add_weight_register (const signature &sig, add_weight_t fn)
 
bool vcsn::dyn::detail::ambiguous_word_register (const signature &sig, ambiguous_word_t fn)
 
bool vcsn::dyn::detail::are_equivalent_register (const signature &sig, are_equivalent_t fn)
 
bool vcsn::dyn::detail::are_equivalent_expression_register (const signature &sig, are_equivalent_expression_t fn)
 
bool vcsn::dyn::detail::are_isomorphic_register (const signature &sig, are_isomorphic_t fn)
 
bool vcsn::dyn::detail::cerny_register (const signature &sig, cerny_t fn)
 
bool vcsn::dyn::detail::coaccessible_register (const signature &sig, coaccessible_t fn)
 
bool vcsn::dyn::detail::codeterminize_register (const signature &sig, codeterminize_t fn)
 
bool vcsn::dyn::detail::cominimize_register (const signature &sig, cominimize_t fn)
 
bool vcsn::dyn::detail::complement_register (const signature &sig, complement_t fn)
 
bool vcsn::dyn::detail::complement_expansion_register (const signature &sig, complement_expansion_t fn)
 
bool vcsn::dyn::detail::complement_expression_register (const signature &sig, complement_expression_t fn)
 
bool vcsn::dyn::detail::complete_register (const signature &sig, complete_t fn)
 
bool vcsn::dyn::detail::component_register (const signature &sig, component_t fn)
 
bool vcsn::dyn::detail::compose_register (const signature &sig, compose_t fn)
 
bool vcsn::dyn::detail::compose_expansion_register (const signature &sig, compose_expansion_t fn)
 
bool vcsn::dyn::detail::compose_expression_register (const signature &sig, compose_expression_t fn)
 
bool vcsn::dyn::detail::compose_polynomial_register (const signature &sig, compose_polynomial_t fn)
 
bool vcsn::dyn::detail::concatenate_expression_register (const signature &sig, concatenate_expression_t fn)
 
bool vcsn::dyn::detail::condense_register (const signature &sig, condense_t fn)
 
bool vcsn::dyn::detail::conjugate_register (const signature &sig, conjugate_t fn)
 
bool vcsn::dyn::detail::conjunction_register (const signature &sig, conjunction_t fn)
 
bool vcsn::dyn::detail::conjunction_expansion_register (const signature &sig, conjunction_expansion_t fn)
 
bool vcsn::dyn::detail::conjunction_expression_register (const signature &sig, conjunction_expression_t fn)
 
bool vcsn::dyn::detail::conjunction_polynomial_register (const signature &sig, conjunction_polynomial_t fn)
 
bool vcsn::dyn::detail::conjunction_repeated_register (const signature &sig, conjunction_repeated_t fn)
 
bool vcsn::dyn::detail::constant_term_register (const signature &sig, constant_term_t fn)
 
bool vcsn::dyn::detail::context_of_register (const signature &sig, context_of_t fn)
 
bool vcsn::dyn::detail::context_of_expansion_register (const signature &sig, context_of_expansion_t fn)
 
bool vcsn::dyn::detail::context_of_expression_register (const signature &sig, context_of_expression_t fn)
 
bool vcsn::dyn::detail::context_of_polynomial_register (const signature &sig, context_of_polynomial_t fn)
 
bool vcsn::dyn::detail::copy_register (const signature &sig, copy_t fn)
 
bool vcsn::dyn::detail::copy_convert_register (const signature &sig, copy_convert_t fn)
 
bool vcsn::dyn::detail::copy_expression_register (const signature &sig, copy_expression_t fn)
 
bool vcsn::dyn::detail::costandard_register (const signature &sig, costandard_t fn)
 
bool vcsn::dyn::detail::cotrie_register (const signature &sig, cotrie_t fn)
 
bool vcsn::dyn::detail::cotrie_stream_register (const signature &sig, cotrie_stream_t fn)
 
bool vcsn::dyn::detail::de_bruijn_register (const signature &sig, de_bruijn_t fn)
 
bool vcsn::dyn::detail::delay_automaton_register (const signature &sig, delay_automaton_t fn)
 
bool vcsn::dyn::detail::derivation_register (const signature &sig, derivation_t fn)
 
bool vcsn::dyn::detail::derived_term_register (const signature &sig, derived_term_t fn)
 
bool vcsn::dyn::detail::determinize_register (const signature &sig, determinize_t fn)
 
bool vcsn::dyn::detail::difference_register (const signature &sig, difference_t fn)
 
bool vcsn::dyn::detail::difference_expression_register (const signature &sig, difference_expression_t fn)
 
bool vcsn::dyn::detail::divkbaseb_register (const signature &sig, divkbaseb_t fn)
 
bool vcsn::dyn::detail::double_ring_register (const signature &sig, double_ring_t fn)
 
bool vcsn::dyn::detail::eliminate_state_register (const signature &sig, eliminate_state_t fn)
 
bool vcsn::dyn::detail::eval_polynomial_register (const signature &sig, eval_polynomial_t fn)
 
bool vcsn::dyn::detail::evaluate_register (const signature &sig, evaluate_t fn)
 
bool vcsn::dyn::detail::expand_register (const signature &sig, expand_t fn)
 
bool vcsn::dyn::detail::expression_one_register (const signature &sig, expression_one_t fn)
 
bool vcsn::dyn::detail::expression_zero_register (const signature &sig, expression_zero_t fn)
 
bool vcsn::dyn::detail::factor_register (const signature &sig, factor_t fn)
 
bool vcsn::dyn::detail::filter_register (const signature &sig, filter_t fn)
 
bool vcsn::dyn::detail::focus_register (const signature &sig, focus_t fn)
 
bool vcsn::dyn::detail::has_bounded_lag_register (const signature &sig, has_bounded_lag_t fn)
 
bool vcsn::dyn::detail::has_lightening_cycle_register (const signature &sig, has_lightening_cycle_t fn)
 
bool vcsn::dyn::detail::has_twins_property_register (const signature &sig, has_twins_property_t fn)
 
bool vcsn::dyn::detail::identities_of_register (const signature &sig, identities_of_t fn)
 
bool vcsn::dyn::detail::inductive_register (const signature &sig, inductive_t fn)
 
bool vcsn::dyn::detail::infiltrate_register (const signature &sig, infiltrate_t fn)
 
bool vcsn::dyn::detail::infiltrate_expression_register (const signature &sig, infiltrate_expression_t fn)
 
bool vcsn::dyn::detail::info_register (const signature &sig, info_t fn)
 
bool vcsn::dyn::detail::info_expression_register (const signature &sig, info_expression_t fn)
 
bool vcsn::dyn::detail::insplit_register (const signature &sig, insplit_t fn)
 
bool vcsn::dyn::detail::is_accessible_register (const signature &sig, is_accessible_t fn)
 
bool vcsn::dyn::detail::is_ambiguous_register (const signature &sig, is_ambiguous_t fn)
 
bool vcsn::dyn::detail::is_coaccessible_register (const signature &sig, is_coaccessible_t fn)
 
bool vcsn::dyn::detail::is_codeterministic_register (const signature &sig, is_codeterministic_t fn)
 
bool vcsn::dyn::detail::is_complete_register (const signature &sig, is_complete_t fn)
 
bool vcsn::dyn::detail::is_costandard_register (const signature &sig, is_costandard_t fn)
 
bool vcsn::dyn::detail::is_cycle_ambiguous_register (const signature &sig, is_cycle_ambiguous_t fn)
 
bool vcsn::dyn::detail::is_deterministic_register (const signature &sig, is_deterministic_t fn)
 
bool vcsn::dyn::detail::is_empty_register (const signature &sig, is_empty_t fn)
 
bool vcsn::dyn::detail::is_eps_acyclic_register (const signature &sig, is_eps_acyclic_t fn)
 
bool vcsn::dyn::detail::is_functional_register (const signature &sig, is_functional_t fn)
 
bool vcsn::dyn::detail::is_letterized_register (const signature &sig, is_letterized_t fn)
 
bool vcsn::dyn::detail::is_normalized_register (const signature &sig, is_normalized_t fn)
 
bool vcsn::dyn::detail::is_out_sorted_register (const signature &sig, is_out_sorted_t fn)
 
bool vcsn::dyn::detail::is_partial_identity_register (const signature &sig, is_partial_identity_t fn)
 
bool vcsn::dyn::detail::is_proper_register (const signature &sig, is_proper_t fn)
 
bool vcsn::dyn::detail::is_realtime_register (const signature &sig, is_realtime_t fn)
 
bool vcsn::dyn::detail::is_standard_register (const signature &sig, is_standard_t fn)
 
bool vcsn::dyn::detail::is_synchronized_register (const signature &sig, is_synchronized_t fn)
 
bool vcsn::dyn::detail::is_synchronized_by_register (const signature &sig, is_synchronized_by_t fn)
 
bool vcsn::dyn::detail::is_synchronizing_register (const signature &sig, is_synchronizing_t fn)
 
bool vcsn::dyn::detail::is_trim_register (const signature &sig, is_trim_t fn)
 
bool vcsn::dyn::detail::is_useless_register (const signature &sig, is_useless_t fn)
 
bool vcsn::dyn::detail::is_valid_register (const signature &sig, is_valid_t fn)
 
bool vcsn::dyn::detail::is_valid_expression_register (const signature &sig, is_valid_expression_t fn)
 
bool vcsn::dyn::detail::join_register (const signature &sig, join_t fn)
 
bool vcsn::dyn::detail::ladybird_register (const signature &sig, ladybird_t fn)
 
bool vcsn::dyn::detail::ldivide_register (const signature &sig, ldivide_t fn)
 
bool vcsn::dyn::detail::ldivide_expansion_register (const signature &sig, ldivide_expansion_t fn)
 
bool vcsn::dyn::detail::ldivide_expression_register (const signature &sig, ldivide_expression_t fn)
 
bool vcsn::dyn::detail::ldivide_label_register (const signature &sig, ldivide_label_t fn)
 
bool vcsn::dyn::detail::ldivide_polynomial_register (const signature &sig, ldivide_polynomial_t fn)
 
bool vcsn::dyn::detail::ldivide_weight_register (const signature &sig, ldivide_weight_t fn)
 
bool vcsn::dyn::detail::less_than_expression_register (const signature &sig, less_than_expression_t fn)
 
bool vcsn::dyn::detail::letterize_register (const signature &sig, letterize_t fn)
 
bool vcsn::dyn::detail::levenshtein_register (const signature &sig, levenshtein_t fn)
 
bool vcsn::dyn::detail::lgcd_polynomial_register (const signature &sig, lgcd_polynomial_t fn)
 
bool vcsn::dyn::detail::lift_automaton_register (const signature &sig, lift_automaton_t fn)
 
bool vcsn::dyn::detail::lift_expression_register (const signature &sig, lift_expression_t fn)
 
bool vcsn::dyn::detail::lightest_register (const signature &sig, lightest_t fn)
 
bool vcsn::dyn::detail::lightest_automaton_register (const signature &sig, lightest_automaton_t fn)
 
bool vcsn::dyn::detail::list_polynomial_register (const signature &sig, list_polynomial_t fn)
 
bool vcsn::dyn::detail::lweight_register (const signature &sig, lweight_t fn)
 
bool vcsn::dyn::detail::lweight_expansion_register (const signature &sig, lweight_expansion_t fn)
 
bool vcsn::dyn::detail::lweight_expression_register (const signature &sig, lweight_expression_t fn)
 
bool vcsn::dyn::detail::lweight_polynomial_register (const signature &sig, lweight_polynomial_t fn)
 
bool vcsn::dyn::detail::make_automaton_editor_register (const signature &sig, make_automaton_editor_t fn)
 
bool vcsn::dyn::detail::make_context_register (const signature &sig, make_context_t fn)
 
bool vcsn::dyn::detail::make_word_context_register (const signature &sig, make_word_context_t fn)
 
bool vcsn::dyn::detail::minimize_register (const signature &sig, minimize_t fn)
 
bool vcsn::dyn::detail::multiply_register (const signature &sig, multiply_t fn)
 
bool vcsn::dyn::detail::multiply_expression_register (const signature &sig, multiply_expression_t fn)
 
bool vcsn::dyn::detail::multiply_expression_repeated_register (const signature &sig, multiply_expression_repeated_t fn)
 
bool vcsn::dyn::detail::multiply_label_register (const signature &sig, multiply_label_t fn)
 
bool vcsn::dyn::detail::multiply_label_repeated_register (const signature &sig, multiply_label_repeated_t fn)
 
bool vcsn::dyn::detail::multiply_polynomial_register (const signature &sig, multiply_polynomial_t fn)
 
bool vcsn::dyn::detail::multiply_repeated_register (const signature &sig, multiply_repeated_t fn)
 
bool vcsn::dyn::detail::multiply_weight_register (const signature &sig, multiply_weight_t fn)
 
bool vcsn::dyn::detail::multiply_weight_repeated_register (const signature &sig, multiply_weight_repeated_t fn)
 
bool vcsn::dyn::detail::normalize_register (const signature &sig, normalize_t fn)
 
bool vcsn::dyn::detail::num_components_register (const signature &sig, num_components_t fn)
 
bool vcsn::dyn::detail::num_tapes_register (const signature &sig, num_tapes_t fn)
 
bool vcsn::dyn::detail::pair_register (const signature &sig, pair_t fn)
 
bool vcsn::dyn::detail::partial_identity_register (const signature &sig, partial_identity_t fn)
 
bool vcsn::dyn::detail::partial_identity_expression_register (const signature &sig, partial_identity_expression_t fn)
 
bool vcsn::dyn::detail::prefix_register (const signature &sig, prefix_t fn)
 
bool vcsn::dyn::detail::print_register (const signature &sig, print_t fn)
 
bool vcsn::dyn::detail::print_context_register (const signature &sig, print_context_t fn)
 
bool vcsn::dyn::detail::print_expansion_register (const signature &sig, print_expansion_t fn)
 
bool vcsn::dyn::detail::print_expression_register (const signature &sig, print_expression_t fn)
 
bool vcsn::dyn::detail::print_label_register (const signature &sig, print_label_t fn)
 
bool vcsn::dyn::detail::print_polynomial_register (const signature &sig, print_polynomial_t fn)
 
bool vcsn::dyn::detail::print_weight_register (const signature &sig, print_weight_t fn)
 
bool vcsn::dyn::detail::project_register (const signature &sig, project_t fn)
 
bool vcsn::dyn::detail::project_context_register (const signature &sig, project_context_t fn)
 
bool vcsn::dyn::detail::project_expansion_register (const signature &sig, project_expansion_t fn)
 
bool vcsn::dyn::detail::project_expression_register (const signature &sig, project_expression_t fn)
 
bool vcsn::dyn::detail::project_label_register (const signature &sig, project_label_t fn)
 
bool vcsn::dyn::detail::project_polynomial_register (const signature &sig, project_polynomial_t fn)
 
bool vcsn::dyn::detail::proper_register (const signature &sig, proper_t fn)
 
bool vcsn::dyn::detail::push_weights_register (const signature &sig, push_weights_t fn)
 
bool vcsn::dyn::detail::quotkbaseb_register (const signature &sig, quotkbaseb_t fn)
 
bool vcsn::dyn::detail::random_automaton_register (const signature &sig, random_automaton_t fn)
 
bool vcsn::dyn::detail::random_automaton_deterministic_register (const signature &sig, random_automaton_deterministic_t fn)
 
bool vcsn::dyn::detail::random_expression_register (const signature &sig, random_expression_t fn)
 
bool vcsn::dyn::detail::random_weight_register (const signature &sig, random_weight_t fn)
 
bool vcsn::dyn::detail::rdivide_register (const signature &sig, rdivide_t fn)
 
bool vcsn::dyn::detail::rdivide_expression_register (const signature &sig, rdivide_expression_t fn)
 
bool vcsn::dyn::detail::rdivide_label_register (const signature &sig, rdivide_label_t fn)
 
bool vcsn::dyn::detail::rdivide_weight_register (const signature &sig, rdivide_weight_t fn)
 
bool vcsn::dyn::detail::read_label_register (const signature &sig, read_label_t fn)
 
bool vcsn::dyn::detail::read_polynomial_register (const signature &sig, read_polynomial_t fn)
 
bool vcsn::dyn::detail::read_weight_register (const signature &sig, read_weight_t fn)
 
bool vcsn::dyn::detail::realtime_register (const signature &sig, realtime_t fn)
 
bool vcsn::dyn::detail::reduce_register (const signature &sig, reduce_t fn)
 
bool vcsn::dyn::detail::rweight_register (const signature &sig, rweight_t fn)
 
bool vcsn::dyn::detail::rweight_expansion_register (const signature &sig, rweight_expansion_t fn)
 
bool vcsn::dyn::detail::rweight_expression_register (const signature &sig, rweight_expression_t fn)
 
bool vcsn::dyn::detail::rweight_polynomial_register (const signature &sig, rweight_polynomial_t fn)
 
bool vcsn::dyn::detail::scc_register (const signature &sig, scc_t fn)
 
bool vcsn::dyn::detail::shortest_register (const signature &sig, shortest_t fn)
 
bool vcsn::dyn::detail::shuffle_register (const signature &sig, shuffle_t fn)
 
bool vcsn::dyn::detail::shuffle_expression_register (const signature &sig, shuffle_expression_t fn)
 
bool vcsn::dyn::detail::sort_register (const signature &sig, sort_t fn)
 
bool vcsn::dyn::detail::split_register (const signature &sig, split_t fn)
 
bool vcsn::dyn::detail::split_polynomial_register (const signature &sig, split_polynomial_t fn)
 
bool vcsn::dyn::detail::standard_register (const signature &sig, standard_t fn)
 
bool vcsn::dyn::detail::standard_expression_register (const signature &sig, standard_expression_t fn)
 
bool vcsn::dyn::detail::star_register (const signature &sig, star_t fn)
 
bool vcsn::dyn::detail::star_height_register (const signature &sig, star_height_t fn)
 
bool vcsn::dyn::detail::star_normal_form_register (const signature &sig, star_normal_form_t fn)
 
bool vcsn::dyn::detail::strip_register (const signature &sig, strip_t fn)
 
bool vcsn::dyn::detail::subword_register (const signature &sig, subword_t fn)
 
bool vcsn::dyn::detail::suffix_register (const signature &sig, suffix_t fn)
 
bool vcsn::dyn::detail::synchronize_register (const signature &sig, synchronize_t fn)
 
bool vcsn::dyn::detail::synchronizing_word_register (const signature &sig, synchronizing_word_t fn)
 
bool vcsn::dyn::detail::thompson_register (const signature &sig, thompson_t fn)
 
bool vcsn::dyn::detail::to_expansion_register (const signature &sig, to_expansion_t fn)
 
bool vcsn::dyn::detail::to_expression_register (const signature &sig, to_expression_t fn)
 
bool vcsn::dyn::detail::to_expression_class_register (const signature &sig, to_expression_class_t fn)
 
bool vcsn::dyn::detail::to_expression_label_register (const signature &sig, to_expression_label_t fn)
 
bool vcsn::dyn::detail::transpose_register (const signature &sig, transpose_t fn)
 
bool vcsn::dyn::detail::transpose_expression_register (const signature &sig, transpose_expression_t fn)
 
bool vcsn::dyn::detail::transposition_expression_register (const signature &sig, transposition_expression_t fn)
 
bool vcsn::dyn::detail::trie_register (const signature &sig, trie_t fn)
 
bool vcsn::dyn::detail::trie_stream_register (const signature &sig, trie_stream_t fn)
 
bool vcsn::dyn::detail::trim_register (const signature &sig, trim_t fn)
 
bool vcsn::dyn::detail::tuple_register (const signature &sig, tuple_t fn)
 
bool vcsn::dyn::detail::tuple_context_register (const signature &sig, tuple_context_t fn)
 
bool vcsn::dyn::detail::tuple_expansion_register (const signature &sig, tuple_expansion_t fn)
 
bool vcsn::dyn::detail::tuple_expression_register (const signature &sig, tuple_expression_t fn)
 
bool vcsn::dyn::detail::tuple_polynomial_register (const signature &sig, tuple_polynomial_t fn)
 
bool vcsn::dyn::detail::u_register (const signature &sig, u_t fn)
 
bool vcsn::dyn::detail::universal_register (const signature &sig, universal_t fn)
 
bool vcsn::dyn::detail::weight_one_register (const signature &sig, weight_one_t fn)
 
bool vcsn::dyn::detail::weight_series_register (const signature &sig, weight_series_t fn)
 
bool vcsn::dyn::detail::weight_zero_register (const signature &sig, weight_zero_t fn)
 
bool vcsn::dyn::detail::zpc_register (const signature &sig, zpc_t fn)
 

Macro Definition Documentation

#define REGISTRY_DECLARE (   Name,
  Signature 
)
Value:
using Name ## _t = auto Signature; \
LIBVCSN_API \
bool Name ## _register(const signature& sig, Name ## _t fn)

Definition at line 21 of file registries.hh.