Main namespace for Aurelia. More...
Namespaces | |
| namespace | llstack |
Namespace for tools used by generated parsers. | |
| namespace | type_traits |
Type traits. | |
Classes | |
| struct | virtual_box |
| Abstract virtual class for box elements. More... | |
| struct | box |
| Abstract static class for box elements. More... | |
| struct | string_box |
| Wrap a string as a pretty printing box. More... | |
| struct | h_box |
| Horizontal direction tag. More... | |
| struct | v_box |
| Vertical direction tag. More... | |
| struct | hv_box |
| Horizontal or vertical direction tag. More... | |
| struct | virtual_boxList |
| struct | box_list |
| Static abstract class for lists of pretty printing boxes. More... | |
| struct | box_list_end |
| Represents and empty list of boxes. More... | |
| struct | box_list_cons |
| List of boxes. More... | |
| struct | any_box_list |
| Box list wrapping a virtual box list. More... | |
| struct | container_box |
| A container box with directions. More... | |
| struct | any_box |
| Box wrapping a virtual box. More... | |
| struct | space_conf |
| Tuple for space configuration. More... | |
| struct | max |
| Gets a maximum value from two constants at compile-time. More... | |
| struct | box_artifact |
| Provides building operation for boxes. More... | |
| struct | print_space |
| Utility to print out a non null constant of spaces. More... | |
| struct | print_space< 0U > |
| Utility to print out a null number of spaces. More... | |
| struct | vbox_constr |
| struct | hbox_constr |
| struct | hvbox_constr |
| struct | string_box_constr |
| struct | get_tuple< box, vbox_constr > |
| struct | get_tuple< box, hbox_constr > |
| struct | get_tuple< box, hvbox_constr > |
| struct | get_tuple< box, string_box_constr > |
| struct | vbox_term |
| struct | build_type< box, vbox_constr > |
| struct | hbox_term |
| struct | build_type< box, hbox_constr > |
| struct | hvbox_term |
| struct | build_type< box, hvbox_constr > |
| struct | string_box_term |
| struct | build_type< box, string_box_constr > |
| struct | term_model< box > |
| struct | try_member_hash< T, false > |
| struct | try_member_hash< T, true > |
| struct | mhash |
| Functor calling a hash method as member if present, or the std::hash functor otherwise. More... | |
| struct | get_hash |
| struct | get_hash< std::tuple< T...>, N > |
| struct | get_hash< std::tuple< T...>, 0u > |
| struct | list_nil |
| struct | list_cons |
| struct | list_concept |
| List Concept. More... | |
| struct | list_model |
| struct | list_model< list_cons< H, T > > |
| struct | list_model< list_nil > |
| struct | all_elements |
| struct | all_elements< Predicate, T, M, true, whatever > |
| struct | all_elements< Predicate, T, M, false, true > |
| struct | listable_concept |
| struct | listable_model |
| struct | deref_op |
| struct | virt_ptr |
| struct | collector |
| struct | collector< T, true > |
| struct | max_shared_ptr |
| Provides a maximally shared allocated pointer. More... | |
| struct | block_list |
| struct | chunk_alloc |
| struct | pool_allocator |
| struct | constant |
| struct | pattern_model< constant< T > > |
| struct | listable_model< constant< T > > |
| struct | pair_pattern |
| struct | pattern_model< pair_pattern< A, B > > |
| struct | listable_model< pair_pattern< A, B > > |
| struct | pattern_concept |
| struct | pattern_model |
| struct | is_pattern_traits |
| struct | builder< pattern< Constructor, SubPatterns...> > |
| struct | assign_build |
| struct | assign_build< LHS, RHS, N, N > |
| struct | can_match |
| struct | can_match< std::tuple< T, TS...>, std::tuple< U, US...> > |
| struct | can_match< std::tuple<>, std::tuple<> > |
| struct | pattern |
| struct | pattern_model< pattern< Constructor, SubPatterns...> > |
| struct | pattern_generator |
| struct | build_type |
| struct | build_type< list_cons< H, T > > |
| struct | build_type< list_nil > |
| struct | untyped_pattern |
| struct | pattern_model< untyped_pattern< Pool, List > > |
| struct | listable_model< untyped_pattern< Pool, List > > |
| struct | variable |
| struct | pattern_model< variable< T > > |
| struct | listable_model< variable< T > > |
| struct | set |
| struct | rel_set |
| struct | failure |
| struct | strategy_model< choice_strategy< Strat1, Strat2 >, T, false > |
| struct | choice_strategy |
| struct | debug_strategy |
| struct | fail_strategy |
| struct | id_strategy |
| struct | not_strategy |
| struct | only_for_strategy |
| struct | only_for |
| struct | repeat_strategy |
| struct | strategy_model< seq_strategy< Strat1, Strat2 >, T, false > |
| struct | seq_strategy |
| struct | side_effect_strategy_concept |
| struct | default_side_effect_strategy_model |
| struct | side_effect_strategy_model |
| struct | side_effect_strategy |
| struct | where_strategy |
| struct | const_map_strategy |
| struct | filter_strategy |
| struct | map_strategy |
| struct | index_strategy_concept |
| Strategies with one extra integer parameter as index. More... | |
| struct | default_index_strategy_model |
| Default model for index_strategy_concept. More... | |
| struct | index_strategy_model |
| struct | map_index_strategy |
| struct | map_join_strategy |
| struct | map_one_strategy |
| struct | map_some_strategy |
| struct | size_strategy |
| struct | build_strategy |
| struct | build_strategy< untyped_term< Pool > > |
| struct | match_strategy |
| struct | match_strategy< untyped_term< Pool > > |
| struct | reset_strategy |
| struct | scope_strategy |
| struct | is_variable |
| struct | is_variable< variable< T > > |
| struct | strategy_concept |
| Strategy Concept. More... | |
| struct | default_strategy_model |
| struct | strategy_model< S, I, false > |
| struct | strategy_model< S, I, true > |
| struct | strategy_model< std::function< R(ArgType)>, ArgType, false > |
| struct | double_quote_strategy |
| struct | undouble_quote_strategy |
| struct | get_cons_name_strategy |
| struct | all_selector |
| struct | alltd_strategy |
| struct | bottomup_strategy |
| struct | innermost_strategy |
| struct | one_strategy |
| struct | topdown_strategy |
| struct | rc_char |
| struct | buf_stream_iterator |
| struct | buf_stream |
| struct | baf_istream |
| struct | sym_read_entry |
| struct | bad_format |
| struct | is_term_traits |
| struct | is_term_traits< Pool, untyped_term< Pool > > |
| struct | is_term_traits< Pool, untyped_constructor< Pool > > |
| struct | is_term |
| struct | is_pattern |
| struct | untyped_constructor_core |
| struct | untyped_constructor |
| struct | listable_model< untyped_constructor< Pool > > |
| struct | cons_constr |
| struct | get_tuple< list< a >, cons_constr > |
| struct | nil_constr |
| struct | get_tuple< list< a >, nil_constr > |
| struct | list |
| struct | cons_term |
| struct | build_type< list< a >, cons_constr > |
| struct | nil_term |
| struct | build_type< list< a >, nil_constr > |
| struct | term_model< list< a > > |
| struct | untyped_term_core |
| struct | untyped_term |
| struct | listable_model< untyped_term< Pool > > |
| struct | term_concept |
| untyped_term concept More... | |
| struct | term_model |
| struct | get_tuple |
| struct | tuple_all |
| struct | tuple_all< Strat, tuple, size, size > |
| struct | virtual_term_constr |
| struct | pos_of< T, Head, Tail...> |
| struct | pos_of< T, T, Tail...> |
| struct | dispatch_all |
| struct | dispatch_all< Term, VirtualTerm, Strat, Constr, Constrs...> |
| struct | virtual_term |
| struct | ConstrNb |
| struct | ConstrNb< Constr, virtual_term< Term, Constrs...> > |
| struct | term |
| struct | term_model< term< Real, Constrs...> > |
| struct | std_term |
| struct | build_real_type< T, Constr, N, tuple, Head, SubPatterns...> |
| struct | build_real_type< T, Constr, N, tuple > |
Typedefs | |
| typedef string_box | S |
| Alias for building string boxes. | |
|
typedef std::tuple< unsigned, unsigned, unsigned > | box_conf |
| typedef buf_stream_iterator | stream |
Enumerations | |
| enum | Dir { HDir, VDir, HVDir } |
Directions as run-time values. | |
Functions | |
| template<typename ExactBox > | |
| box_list_cons< ExactBox, box_list_end > | append (const box_list_end &, const box< ExactBox > &b) |
| Appends a box at the end of a list. | |
| template<typename B , typename Tail , typename ExactBox > | |
| box_list_cons< B, decltype(append(std::declval < Tail >), std::declval < ExactBox >)))> | append (const box_list_cons< B, Tail > &l, const box< ExactBox > &b) |
| Appends a box at the end of a list. | |
| template<typename ExactBox , typename ExactList > | |
| decltype (append(std::declval< ExactList >(), std::declval< ExactBox >())) operator | |
| Builds a list from boxes. | |
|
ExactBox2 box_list_cons < ExactBox, box_list_cons < ExactBox2, box_list_end > > | operator, (const box< ExactBox > &s, const box< ExactBox2 > &t) |
| template<unsigned VS> | |
| space_conf< VS, 0, 0 > | Vs () |
| Creates a space configuration with vertical specification. | |
| template<unsigned HS> | |
| space_conf< 0, HS, 0 > | Hs () |
| Creates a space configuration with horizontal specification. | |
| template<unsigned IS> | |
| space_conf< 0, 0, IS > | Is () |
| Creates a space configuration with identation specification. | |
| template<unsigned VS1, unsigned HS1, unsigned IS1, unsigned VS2, unsigned HS2, unsigned IS2> | |
| space_conf< max< VS1, VS2 > ::ret, max< HS1, HS2 >::ret, max< IS1, IS2 >::ret > | operator, (const space_conf< VS1, HS1, IS1 > &, const space_conf< VS2, HS2, IS2 > &) |
| Merges two configurations. | |
| template<unsigned VS, unsigned HS, unsigned IS> | |
| box_artifact< h_box, VS, HS, IS > | H (const space_conf< VS, HS, IS > &) |
| Returns a builder for a horizontal box. | |
| box_artifact< h_box, 0, 1, 0 > | H () |
| Returns a builder for a horizontal box. | |
| template<unsigned VS, unsigned HS, unsigned IS> | |
| box_artifact< v_box, VS, HS, IS > | V (const space_conf< VS, HS, IS > &) |
| Returns a builder for a vertical box. | |
| box_artifact< v_box, 0, 0, 0 > | V () |
| Returns a builder for a vertical box. | |
| template<unsigned VS, unsigned HS, unsigned IS> | |
| box_artifact< hv_box, VS, HS, IS > | HV (const space_conf< VS, HS, IS > &) |
| Returns a builder for a horizontal/vertical box. | |
| box_artifact< hv_box, 0, 1, 0 > | HV () |
| Returns a builder for a horizontal/vertical box. | |
| template<typename Stream , unsigned VS, unsigned HS, unsigned IS, typename Head , typename Head2 , typename Tail > | |
| unsigned | box_to_text (Stream &s, unsigned pos, const v_box &, const space_conf< VS, HS, IS > &, const box_list_cons< Head, box_list_cons< Head2, Tail > > &bl) |
| Prints out vertically a list of boxes. | |
| template<typename Stream , unsigned VS, unsigned HS, unsigned IS, typename Head > | |
| unsigned | box_to_text (Stream &s, unsigned pos, const v_box &, const space_conf< VS, HS, IS > &, const box_list_cons< Head, box_list_end > &bl) |
| Prints out vertically a singleton of box. | |
| template<typename Stream , unsigned VS, unsigned HS, unsigned IS> | |
| unsigned | box_to_text (Stream &, unsigned pos, const v_box &, const space_conf< VS, HS, IS > &, const box_list_end &) |
| Prints out vertically an empty list of boxes. | |
| template<typename Stream , unsigned VS, unsigned HS, unsigned IS, typename Head , typename Head2 , typename Tail > | |
| unsigned | box_to_text (Stream &s, unsigned pos, const h_box &, const space_conf< VS, HS, IS > &, const box_list_cons< Head, box_list_cons< Head2, Tail > > &bl) |
| Prints out horizontally a list of boxes. | |
| template<typename Stream , unsigned VS, unsigned HS, unsigned IS, typename Head > | |
| unsigned | box_to_text (Stream &s, unsigned pos, const h_box &, const space_conf< VS, HS, IS > &, const box_list_cons< Head, box_list_end > &bl) |
| Prints out horizontally a singleton of box. | |
| template<typename Stream , unsigned VS, unsigned HS, unsigned IS> | |
| unsigned | box_to_text (Stream &, unsigned pos, const h_box &, const space_conf< VS, HS, IS > &, const box_list_end &) |
| Prints out horizontally an empty list of boxes. | |
| template<typename Stream > | |
| unsigned | box_to_text (Stream &s, unsigned pos, const string_box &str) |
| Prints out a string_box. | |
| template<typename Stream > | |
| unsigned | box_to_text (Stream &s, unsigned pos, const any_box &b) |
| Prints out an any_box. | |
| template<typename Stream , unsigned VS, unsigned HS, unsigned IS, typename Head , typename Tail > | |
| unsigned | box_to_text (Stream &s, unsigned pos, const container_box< v_box, VS, HS, IS, box_list_cons< Head, Tail > > &b) |
| Prints out a vertical box. | |
| template<typename Stream , unsigned VS, unsigned HS, unsigned IS> | |
| unsigned | box_to_text (Stream &s, unsigned pos, const container_box< v_box, VS, HS, IS, box_list_end > &) |
| Prints out an empty vertical box. | |
| template<typename Stream , unsigned VS, unsigned HS, unsigned IS, typename Head , typename Tail > | |
| unsigned | box_to_text (Stream &s, unsigned pos, const container_box< h_box, VS, HS, IS, box_list_cons< Head, Tail > > &b) |
| Prints out a horizontal box. | |
| template<typename Stream , unsigned VS, unsigned HS, unsigned IS> | |
| unsigned | box_to_text (Stream &s, unsigned pos, const container_box< h_box, VS, HS, IS, any_box_list > &b) |
| Prints out a horizontal box. | |
| template<typename Stream , unsigned VS, unsigned HS, unsigned IS> | |
| unsigned | box_to_text (Stream &s, unsigned pos, const container_box< v_box, VS, HS, IS, any_box_list > &b) |
| Prints out a vertical box. | |
| template<typename Stream , unsigned VS, unsigned HS, unsigned IS> | |
| unsigned | box_to_text (Stream &s, unsigned pos, const container_box< h_box, VS, HS, IS, box_list_end > &) |
| Prints out an empty horizontal box. | |
| template<typename Stream , typename ExactBox > | |
| Stream & | operator<< (Stream &s, const box< ExactBox > &b) |
| Prints out a pretty-print box. | |
| template<typename T > | |
| unsigned | hash_addr (T &addr) |
| DEF_MEMBER_WRAPPER (hash) | |
| template<typename H , typename T > | |
| H | head (const list_cons< H, T > &l) |
| template<typename H , typename T > | |
| T | tail (const list_cons< H, T > &l) |
| template<typename H , typename T > | |
| list_cons< H, T > | cons (const H &h, const T &t) |
| void | head (list_nil) |
| list_nil | tail (list_nil) |
| list_nil | cons () |
| DEF_MEMBER_WRAPPER (collect) | |
| template<typename A , typename B > | |
| pair_pattern< A, B > | p (const A &a, const B &b) |
| template<typename T , typename U , typename = decltype(std::declval<T>() = *(std::declval<const U>()))> | |
| std::true_type | has_assign_build_helper (type_traits::try_first, T, U) |
| template<typename T , typename U > | |
| std::false_type | has_assign_build_helper (type_traits::try_second, T, U) |
| template<typename Pool > | |
| void | assign (const list_nil &, const untyped_term< Pool > &) |
| template<typename Pool , typename T , typename M = typename aurelia::list_model<T>::model, typename = typename std::enable_if<!std::is_same<void, typename M::head_t>::value>::type> | |
| void | assign (const T &l, const untyped_term< Pool > &t) |
| list_nil | build (const list_nil &) |
| template<typename T , typename M = typename list_model<T>::model, typename = typename std::enable_if<!std::is_same<void, typename M::head_t>::value>::type> | |
| build_type< T >::type | build (const T &l) |
| template<typename T > | |
| set< T > | carrier (const rel_set< T > &m) |
| template<typename Stream , typename T , typename U > | |
| Stream & | operator<< (Stream &s, const std::pair< T, U > &p) |
| template<typename Stream , typename T , typename U > | |
| Stream & | operator<< (Stream &s, const rel_set< T, U > &m) |
| template<typename Stream , typename T > | |
| Stream & | operator<< (Stream &s, const set< T > &m) |
| template<typename T > | |
| set< T > | top (const rel_set< T > &m) |
| template<typename T > | |
| set< T > | bottom (const rel_set< T > &m) |
| template<typename T , typename U , typename V > | |
| rel_set< T, V > | operator* (const rel_set< T, U > &a, const rel_set< U, V > &b) |
| template<typename T , typename U > | |
| rel_set< T, U > | operator* (const set< T > &a, const set< U > &b) |
| template<typename T , typename U > | |
| set< T > | domain (const rel_set< T, U > &a) |
| template<typename T > | |
| set< T > | operator- (const set< T > &a, const set< T > &b) |
| template<typename T > | |
| set< T > | reachX (const rel_set< T > &G, const set< T > &Start, const set< T > &Excl) |
| template<typename T > | |
| T | common_convertible (T, T) |
| template<typename T , typename U , typename = typename std::enable_if<std::is_convertible<U, T>::value>::type> | |
| T | common_convertible (T, U) |
| template<typename Strat1 , typename Strat2 > | |
| choice_strategy< Strat1, Strat2 > | operator+ (const Strat1 &s1, const Strat2 &s2) |
| Runs s1, then s2 if s1 failed. It fails if none of s1 and s2 succeeded. | |
| debug_strategy | debug (const std::string &s) |
| When evaluated, it prints the input value in the standard error output. It requires the type of input to be printable. | |
| template<typename S > | |
| not_strategy< S > | not_ (const S &s) |
| When evaluated, the strategy fails when s succeeds, and succeeds when s fails. | |
| template<typename S > | |
| repeat_strategy< S > | repeat (const S &s) |
| The strategy calls s until it fails then returns the last suceeding value. The output type of S must be convertible to the input type. | |
| template<typename Strat1 , typename Strat2 > | |
| seq_strategy< Strat1, Strat2 > | operator< (const Strat1 &s1, const Strat2 &s2) |
| The strategy calls s1, then s2 if s1 succeeded. It succeeds if s2 does. | |
| template<typename Kernel > | |
| side_effect_strategy< Kernel > | side_effect (const Kernel &k) |
| Converts a non-const strategy expresion to a const one. | |
| template<typename Strat > | |
| auto | try_ (const Strat &s)-> decltype(s+id) |
| The strategy runs s and suceeds even if s fails. | |
| template<typename S > | |
| where_strategy< S > | where (const S &s) |
| The strategy runs s. On success, it restores the previous value. | |
| template<typename S > | |
| const_map_strategy< S > | const_map (const S &s) |
| Applies the strategy on all elements of the list but without modifying it. | |
| template<typename Out , typename Strat > | |
| filter_strategy< Out, Strat > | filter (const Out &, const Strat &s) |
| template<typename S > | |
| map_strategy< S > | map (const S &s) |
| Applies the strategy on all elements of a list. | |
| template<typename S > | |
| map_index_strategy< S > | map_index (const S &s) |
| Apply the strategy to all elements of a list giving an extra parameter for the position in the list. | |
| template<typename Out , typename Strat > | |
| map_join_strategy< Out, Strat > | map_join (const Out &, const Strat &s) |
| Applies the strategy to all elements of a list, each result should be a list. All the lists are concatenated. | |
| template<typename S > | |
| map_one_strategy< S > | map_one (const S &s) |
| Applies the strategy to elements of a list until one succeeds. | |
| template<typename S > | |
| map_some_strategy< S > | map_some (const S &s) |
| Applies the strategy to at least one element of a list. | |
| template<typename Pool , typename List > | |
| build_strategy < untyped_pattern< Pool, List > > | operator! (const untyped_pattern< Pool, List > &p) |
| The strategy builds the pattern passed as parameter. | |
| template<typename T > | |
| build_strategy< variable< T > > | operator! (const variable< T > &v) |
| The strategy builds the variable passed as parameter. | |
| template<typename Pattern , typename PattermModel = typename pattern_model<Pattern>::model> | |
| build_strategy< Pattern > | operator! (const Pattern &pattern) |
| template<typename Pool , typename List > | |
| match_strategy < untyped_pattern< Pool, List > > | operator~ (const untyped_pattern< Pool, List > &p) |
| The strategy matches the pattern passed as parameter. | |
| template<typename T > | |
| match_strategy< variable< T > > | operator~ (const variable< T > &t) |
| The strategy matches the variable passed as parameter. | |
| template<typename Pool > | |
| match_strategy< untyped_term < Pool > > | operator~ (const untyped_term< Pool > &t) |
| The strategy matches the term passed as parameter. | |
| template<typename Pool > | |
| match_strategy< untyped_term < Pool > > | operator~ (const untyped_constructor< Pool > &t) |
| The strategy matches the term passed as parameter. | |
| template<typename Pattern , typename PattermModel = typename pattern_model<Pattern>::model> | |
| match_strategy< Pattern > | operator~ (const Pattern &pattern) |
| template<typename A , typename B > | |
| tmp tmp aurelia src strategies patterns pair hh build_strategy< pair_pattern < A, B > > | operator! (const pair_pattern< A, B > &p) |
| Builds a pair. | |
| template<typename A , typename B > | |
| match_strategy< pair_pattern < A, B > > | operator~ (const pair_pattern< A, B > &p) |
| Matches a pair. | |
| template<typename T > | |
| reset_strategy< T > | reset (const variable< T > &v) |
| Resets the variable. | |
| template<typename Strat , typename T > | |
| scope_strategy< Strat, variable< T > > | scope (const variable< T > &v, const Strat &s) |
| template<typename Strat , typename L , typename M = typename list_model<L>::model, typename = typename std::enable_if<all_elements<is_variable, L>::value>::type> | |
| scope_strategy< Strat, L > | scope (const L &v, const Strat &s) |
| template<typename Strat > | |
| all_selector< Strat > | all (const Strat &s) |
| Applies the strategy to all the subterms. | |
| template<typename S > | |
| alltd_strategy< S > | alltd (const S &s) |
| Traverses topdown until the strategy succeeds. | |
| template<typename S > | |
| bottomup_strategy< S > | bottomup (const S &s) |
| Apply the strategy bottomup. | |
| template<typename S > | |
| innermost_strategy< S > | innermost (const S &s) |
| Apply the strategy to fixpoint innermost first. | |
| template<typename Strat > | |
| one_strategy< Strat > | one (const Strat &s) |
| Applies the strategy to one subterm. | |
| template<typename S > | |
| topdown_strategy< S > | topdown (const S &s) |
| Apply the strategy topdown. | |
| std::string | stream_range_to_string (stream begin, const stream &end) |
| template<typename Stream > | |
| Stream & | operator<< (Stream &s, const stream &i) |
| baf_istream & | operator>> (baf_istream &s, unsigned int &val) |
| baf_istream & | operator>> (baf_istream &s, int &val) |
| baf_istream & | operator>> (baf_istream &s, std::string &val) |
| unsigned | bit_width (unsigned val) |
| template<typename pool > | |
| untyped_term< pool > * | read_term (sym_read_entry< pool > *read_symbols, int top, baf_istream &st) |
| template<typename pool > | |
| untyped_term< pool > | read_baf (const pool &, std::istream &in) |
| template<typename Stream , typename Pool > | |
| Stream & | operator<< (Stream &s, const untyped_constructor< Pool > &t) |
| template<typename Stream , typename Pool > | |
| void | print (Stream &s, const untyped_term< Pool > &t, bool inlist=false) |
| template<typename Stream , typename Pool > | |
| Stream & | operator<< (Stream &s, const untyped_term< Pool > &t) |
| template<typename T > | |
| bool | diff_no_conv (const T &a, const T &b) |
| template<typename T , typename U > | |
| bool | diff_no_conv (const T &a, const U &b) |
| template<typename Strat , typename T > | |
| untyped_term< T > | all_primitive (const Strat &s, const untyped_term< T > &term) |
| template<typename Strat , typename T , typename... Constrs> | |
| term< T, Constrs...> | all_primitive (const Strat &s, const term< T, Constrs...> &term) |
Variables | |
| const box_list< ExactList > & | l |
| pattern_generator< vbox_constr > | vbox |
| pattern_generator< hbox_constr > | hbox |
| pattern_generator< hvbox_constr > | hvbox |
|
pattern_generator < string_box_constr > | string_box |
| fail_strategy | fail |
| A strategy that always fails for any given input type. | |
| id_strategy | id |
| A strategy that always succeeds for any given input type. | |
| size_strategy | size |
| Returns the size of a list. | |
| double_quote_strategy | double_quote |
| Add double quotes around the input string. | |
| undouble_quote_strategy | undouble_quote |
| Removes double quotes around the input string. Fails if double quotes are not present. | |
| get_cons_name_strategy | get_cons_name |
| Converts a term to the name of its top-level constructor as a string. | |
Main namespace for Aurelia.
| unsigned aurelia::box_to_text | ( | Stream & | s, |
| unsigned | pos, | ||
| const v_box & | , | ||
| const space_conf< VS, HS, IS > & | , | ||
| const box_list_cons< Head, box_list_end > & | bl | ||
| ) |
Prints out vertically a singleton of box.
| s | A stream |
| pos | The current horizontal position |
| bl | The list to print out |
| unsigned aurelia::box_to_text | ( | Stream & | , |
| unsigned | pos, | ||
| const v_box & | , | ||
| const space_conf< VS, HS, IS > & | , | ||
| const box_list_end & | |||
| ) |
Prints out vertically an empty list of boxes.
| s | A stream |
| pos | The current horizontal position |
| unsigned aurelia::box_to_text | ( | Stream & | s, |
| unsigned | pos, | ||
| const h_box & | , | ||
| const space_conf< VS, HS, IS > & | , | ||
| const box_list_cons< Head, box_list_cons< Head2, Tail > > & | bl | ||
| ) |
Prints out horizontally a list of boxes.
| s | A stream |
| pos | The current horizontal position |
| bl | The list to print out |
| unsigned aurelia::box_to_text | ( | Stream & | s, |
| unsigned | pos, | ||
| const h_box & | , | ||
| const space_conf< VS, HS, IS > & | , | ||
| const box_list_cons< Head, box_list_end > & | bl | ||
| ) |
Prints out horizontally a singleton of box.
| s | A stream |
| pos | The current horizontal position |
| bl | The list to print out |
| unsigned aurelia::box_to_text | ( | Stream & | , |
| unsigned | pos, | ||
| const h_box & | , | ||
| const space_conf< VS, HS, IS > & | , | ||
| const box_list_end & | |||
| ) |
Prints out horizontally an empty list of boxes.
| s | A stream |
| pos | The current horizontal position |
| unsigned aurelia::box_to_text | ( | Stream & | s, |
| unsigned | pos, | ||
| const string_box & | str | ||
| ) |
Prints out a string_box.
| s | A stream |
| pos | The current horizontal position |
| str | The string_box to print out |
| unsigned aurelia::box_to_text | ( | Stream & | s, |
| unsigned | pos, | ||
| const any_box & | b | ||
| ) |
| unsigned aurelia::box_to_text | ( | Stream & | s, |
| unsigned | pos, | ||
| const container_box< v_box, VS, HS, IS, box_list_cons< Head, Tail > > & | b | ||
| ) |
Prints out a vertical box.
| s | A stream |
| pos | The current horizontal postion |
| b | The box to print out |
| unsigned aurelia::box_to_text | ( | Stream & | s, |
| unsigned | pos, | ||
| const v_box & | , | ||
| const space_conf< VS, HS, IS > & | , | ||
| const box_list_cons< Head, box_list_cons< Head2, Tail > > & | bl | ||
| ) |
Prints out vertically a list of boxes.
| s | A stream |
| pos | The current horizontal position |
| bl | The list to print out |
| unsigned aurelia::box_to_text | ( | Stream & | s, |
| unsigned | pos, | ||
| const container_box< v_box, VS, HS, IS, box_list_end > & | |||
| ) |
Prints out an empty vertical box.
| s | A stream |
| pos | The current horizontal position |
| unsigned aurelia::box_to_text | ( | Stream & | s, |
| unsigned | pos, | ||
| const container_box< h_box, VS, HS, IS, box_list_cons< Head, Tail > > & | b | ||
| ) |
Prints out a horizontal box.
| s | A stream |
| pos | The current horizontal postion |
| b | The box to print out |
| unsigned aurelia::box_to_text | ( | Stream & | s, |
| unsigned | pos, | ||
| const container_box< h_box, VS, HS, IS, any_box_list > & | b | ||
| ) |
Prints out a horizontal box.
| s | A stream |
| pos | The current horizontal postion |
| b | The box to print out |
| unsigned aurelia::box_to_text | ( | Stream & | s, |
| unsigned | pos, | ||
| const container_box< v_box, VS, HS, IS, any_box_list > & | b | ||
| ) |
Prints out a vertical box.
| s | A stream |
| pos | The current horizontal postion |
| b | The box to print out |
| unsigned aurelia::box_to_text | ( | Stream & | s, |
| unsigned | pos, | ||
| const container_box< h_box, VS, HS, IS, box_list_end > & | |||
| ) |
Prints out an empty horizontal box.
| s | A stream |
| pos | The current horizontal postion |
| T aurelia::common_convertible | ( | T | , |
| T | |||
| ) |
This function is used to find a possible common type to which two types are implicitly convertible.
| Stream& aurelia::operator<< | ( | Stream & | s, |
| const box< ExactBox > & | b | ||
| ) |
Prints out a pretty-print box.
| s | A stream |
| b | The box to print out |