Uses of Class
eu.bandm.tscore.base.Translet.Parser

Packages that use Translet.Parser

Package	Description
eu.bandm.music.entities	All fundamental entities for modeling music.
eu.bandm.music.haken	Composition project which translates polyphonic sequences of abstract "hook signs" (="Haken" = "hkn") into scores for different instruments, like Viola, Voice, electronic sound synthesis or abstract graphical movies; see the project documentation (in German).
eu.bandm.music.top	Top-level data structures, modelling different score formats, combining the entities defined in lower level packages.
eu.bandm.tscore.base	Generic and low level data types and transformation algorithms, to be used by very different applications of the tscore framework.

Uses of Translet.Parser in eu.bandm.music.entities

Fields in eu.bandm.music.entities declared as Translet.Parser

Modifier and Type	Field and Description
static Translet.Parser<Integer>	Color_rgb_8._2HexDigits Aux parser which accepts two hexadecimal digits, in upper or lower case.
static Translet.Parser<Rational>	MeasureCollector.durationParser Parser for positive (non-null) Rational numbersm used as durations.
(package private) Translet.Parser<M>	MeasureCollector.metricParser The parser for the metric specificaion.
(package private) Translet.Parser<MTreeSpec>	MKinds.mtreeparser
Translet.Parser<MetrumSpecs.Name>	MetrumSpecs.nameParser
static Translet.Parser<Color_rgb_8>	Color_rgb_8.parse_3_decNumbers Parser for an rgb value by three percent values, separated by comma.
static Translet.Parser<Color_rgb_8>	Color_rgb_8.parse_3_hexNumbers Parser for six adjacent hex digits defining one color by r-g-b.
Translet.Parser<?>	MetrumSpecs.parseMetrics
static Translet.Parser<RationalDuration>	RationalDuration.parser Evident
(package private) Translet.Parser<?>	MKinds.parser
static Translet.Parser<QualifiedRational>	QualifiedRational.parser Parsing "1/4" for sound and "p1/4" for pause.
static Translet.Parser<Tempo>	Tempo.parser Accepts the standard notation as usual in printed sheet music, e.g.
static Translet.Parser<MetrumName>	MetrumName.parser Evident
protected static Translet.Parser<MTreeSpec>	MTreeSpec.parser_alt
protected static Translet.Parser<MTreeSpec>	MTreeSpec.parser_concat
static Translet.Parser<MTreeSpec>	MTreeSpec.parser_summand
static Translet.Parser<MTreeSpec>	MTreeSpec.parser_timed
(package private) Translet.Parser<OctaveRegister>	RunningOctaveCollector.parserOctaveRegister Construction parameter: parser for an explicit octave register.
(package private) Translet.Parser<P>	RunningOctaveCollector.parserPitchClass Construction parameter: parser for the pitch class.
static Translet.Parser<Tempo>	Tempo.prefixed_parser Accepts the standard notation as usual in printed sheet music, e.g.

Methods in eu.bandm.music.entities that return Translet.Parser

Modifier and Type	Method and Description
protected static Translet.Parser<FunctionalPitchModOctave>	FunctionalPitchModOctave._x_upperInitialParser(String lang, boolean upper) Deliver a parser with lower or upper initial characters, in the given language.
static Translet.Parser<ClefUsage>	ClefUsage.fullParser(String lang) Accepts generic version (see ClefUsage.genericParser(String,String)) OR the predefined standard clef usages, both in the given language, with ClefUsage.default_prefix.
static Translet.Parser<ClefUsage>	ClefUsage.fullParser(String lang, String prefix) Accepts generic version (see ClefUsage.genericParser(String,String)) OR the predefined standard clef usages, with given language and prefix.
static Translet.Parser<ClefUsage>	ClefUsage.genericParser(String lang) Accepts only the generic version (see ClefUsage.genericParser(String,String)) in the given language, with ClefUsage.default_prefix.
static Translet.Parser<ClefUsage>	ClefUsage.genericParser(String lang, String prefix) Accepts only the generic format, which is a sequence of the given prefix, the clef name in the given language, the line number where to place the clef (1 is bottom line) and finally optionally "+1"/"+2"/"-1"/"-2" for maximally two additional octaves displacement.
static Translet.Parser<FunctionalKey>	FunctionalKey.getCapitalizationAdjustedParser(String lang, String delim) Delivers a parser which accepts the lower-initial variant of a pitch class followed by the word for minor, and the upper-initial variant for major.
static Translet.Parser<FunctionalKey>	FunctionalKey.getCapitalizationOnlyParser(String lang) Delivers a parser which accepts only the pitch class names and derives the gender/mode from the case of the initial character.
static Translet.Parser<FunctionalKey>	FunctionalKey.getExplicitParser(String lang, String delim) Delivers a parser which accepts the names of the pitch classes (only) as they were defined.
static Translet.Parser<OrnamentUsage>	OrnamentUsage.getParser(Translet.Parser<Ornament> oparser) Returns a parser for an ornament code with additional accidentals.
static Translet.Parser<FunctionalPitchModOctave>	FunctionalPitchModOctave.lowerInitialParser(String lang) Deliver a parser with lower initial characters, in the given language.
static Translet.Parser<Ornament>	Ornament_KdF_special.membersParser()
static Translet.Parser<Ornament>	Ornament_JSB_klavierbuechlein.membersParser() Returns a parser accepting the abstract symbols.
static Translet.Parser<Ornament>	Ornament_KdF_special.membersParser(String lang)
static Translet.Parser<Ornament>	Ornament_JSB_klavierbuechlein.membersParser(String lang) Returns a parser in the given (human) langauge.
static Translet.Parser<Color_rgb_8>	Color_rgb_8.parseHumanNames() Get a parser only for the symbolic names, in the Color_rgb_8.catalog's default language.
static Translet.Parser<Color_rgb_8>	Color_rgb_8.parseHumanNames(String lang) Get a parser only for the symbolic names, in the given language.
Translet.Parser<?>	RunningOctaveCollector.parser() Return the parser.
static Translet.Parser<MTreeSpec>	MTreeSpec.parser()
static Translet.Parser<Color_rgb_8>	Color_rgb_8.parser() Returns a parser which accepts symbolic names in the Color_rgb_8.catalog default language, or three two-digit-hex values for r/g/b, or three comma separated integer values (0..100, interpreted as percentage) for r/g/b.
Translet.Parser<?>	MeasureCollector.parser() Delivers the complete parser.
static Translet.Parser<Duration_calendaric>	Duration_calendaric.parser(boolean lowerLimitForInternals, boolean upperLimitForLeading) Returns a parser for calendaric time.
static Translet.Parser<Color_rgb_8>	Color_rgb_8.parser(String lang) Returns a parser which accepts symbolic names in the given language, or three two-digit-hex values for r/g/b, or three comma separated integer values (0..100, interpreted as percentage) for r/g/b.
static Translet.Parser<FunctionalPitchModOctave>	FunctionalPitchModOctave.upperInitialParser(String lang) Deliver a parser with upper initial characters, in the given language.

Methods in eu.bandm.music.entities with parameters of type Translet.Parser

Modifier and Type	Method and Description
static Translet.Parser<OrnamentUsage>	OrnamentUsage.getParser(Translet.Parser<Ornament> oparser) Returns a parser for an ornament code with additional accidentals.

Constructors in eu.bandm.music.entities with parameters of type Translet.Parser

Constructor and Description
MeasureCollector(Translet.Parser<M> metricParser, String openSign_duration, String closeSign_duration) Initial configuration of a Collector.
MKinds(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msg, boolean redef, Translet.Parser<MTreeSpec> mtreeparser, String separator, String... backends)
RunningOctaveCollector(Translet.Parser<P> parserPitchClass, Translet.Parser<OctaveRegister> parserOctaveRegister, String octDown, String octUp, Function<P,WhiteKeyModOctave> stripAlterations) Only constructor, set all parameters.
RunningOctaveCollector(Translet.Parser<P> parserPitchClass, Translet.Parser<OctaveRegister> parserOctaveRegister, String octDown, String octUp, Function<P,WhiteKeyModOctave> stripAlterations) Only constructor, set all parameters.

Uses of Translet.Parser in eu.bandm.music.haken

Fields in eu.bandm.music.haken declared as Translet.Parser

Modifier and Type	Field and Description
(package private) Translet.Parser<?>	Score_hkn.parser Parser for relwert/haken voices AND pause voices.

Uses of Translet.Parser in eu.bandm.music.top

Fields in eu.bandm.music.top declared as Translet.Parser

Modifier and Type	Field and Description
(package private) Translet.Parser<String>	MaWiRic.asciiLowerCaseChar Parser for the switch-off events.
Translet.Parser<?>	Formplan_fuge.divMul Parser for the time stretch factor.
Translet.Parser<?>	Formplan_fuge.einsatz_parser Parser which accepts theme and counterpoints.
Translet.Parser<?>	Formplan_fuge.kpEinsatz Parser for contrapunctal material.
(package private) Translet.Parser<?>	MaWiCM.parse_all Parses all combinations: text plus start fade, or start fade only, or end fade, or "nop".
(package private) Translet.Parser<?>	GraphartScharen.parse_alpha
(package private) Translet.Parser<?>	MovingForms.parse_alpha Parser for the transparency, plus an optional interpolation sign, see MovingForms.parse_ipol.
static Translet.Parser<BigDecimal>	Score_cwn.parse_barNumber Parser for measure numbers accept a non-negative integer, and maybe a decimal point with a fractional part.
(package private) Translet.Parser<?>	GraphartScharen.parse_color
(package private) Translet.Parser<?>	MovingForms.parse_color Parser for the color, as defined by Color_rgb_8.parser(String), plus an optional interpolation sign, see MovingForms.parse_ipol.
(package private) Translet.Parser<?>	GraphartScharen.parse_dist
(package private) Translet.Parser<?>	MovingForms.parse_form Parser for the geometric form.
(package private) Translet.Parser<String>	GraphartScharen.parse_ipol
(package private) Translet.Parser<String>	MovingForms.parse_ipol Parser for the interpolation indication.
protected Translet.Parser<?>	MlWorat.parse_key Parse German language tonal key indication.
(package private) Translet.Parser<?>	GraphartScharen.parse_len
(package private) Translet.Parser<?>	GraphartScharen.parse_num
(package private) Translet.Parser<?>	MaWiRic.parse_off Parser for the switch-off events.
(package private) Translet.Parser<?>	MaWiRic.parse_on Parser for the switch-on events.
(package private) Translet.Parser<?>	GraphartScharen.parse_orient
protected Translet.Parser<?>	MlWorat.parse_pitch Format for pitch classes is German language pitch, lilypond octave ad lib.
protected Translet.Parser<?>	MlWorat.parse_pitches Parse more than one pitch class, joined by "+".
(package private) Translet.Parser<?>	GraphartScharen.parse_pos Parser for the position, which is the main parameter of each voice.
(package private) Translet.Parser<?>	MovingForms.parse_pos Parser for the main parameter value, which is x-pos and y-pos (both as non-negative integers) plus an optional interpolation sign, see MovingForms.parse_ipol.
(package private) Translet.Parser<?>	MovingForms.parse_size Parser for the size (non-negative integer), plus an optional interpolation sign, see MovingForms.parse_ipol.
(package private) Translet.Parser<?>	MaWiCM.parse_start Parses text and coordinates.
(package private) Translet.Parser<?>	MaWiCM.parse_startFade Parses start fade symbol.
protected Translet.Parser<Tuple2<Integer,BigDecimal>>	MlWorat.parse_time Format for time points is "movement/measure".
(package private) Translet.Parser<?>	GraphartScharen.parse_width
protected Translet.Parser<?>	MwHaiku.parseKateg Parser for character categories
protected Translet.Parser<?>	MwHaiku.parseRegister Parser additional text in the param track named MwHaiku.paramname_register.
protected Translet.Parser<?>	MwHaiku.parseText Parser for syllable text.
Translet.Parser<?>	Formplan_fuge.themenEinsatz Parser which accepts additional modifiers: "u" for inverse, "r" for retrograde, "1/n" or "n/1" for time stretching, and ">" for incompleteness.
Translet.Parser<?>	Formplan_fuge.themenEinsatzForm Parser which accepts capital roman numbers for theme numbers, "D" and "C" for dux and comes, or a combination of both.

Uses of Translet.Parser in eu.bandm.tscore.base

Subclasses of Translet.Parser in eu.bandm.tscore.base

Modifier and Type	Class and Description
static class	Translet._CAT<R> Implements a greedy longest prefix match from a collection of strings.
static class	Translet._CONST<R> Parser for a simple string constant which must appear verbatim, as is.
static class	Translet._REGEX Parser for text input following a regular expression.
static class	Translet.CoTupleParser<A,B,C,D> Common superclass for Parsers which accept one of many alternatives and return a CoTuple (ORn and PRIORn).
static class	Translet.FramedParser<A> Accepts a sequence "A,B,C", where only the middle parsing/processing result is stored as result in the Translet.State object, discarding the frame.
static class	Translet.HeadParser<A> Accepts a sequence "A,B,..", where only the very first parsing/processing result is stored as result in the Translet.State object, discarding all the tail.
static class	Translet.LimesParser<A> Common superclass for Parsers which accept one of many alternatives and return the upper limit of the different result classes (OR1 and PRIOR1).
static class	Translet.OptionParser<D> Option parser, in greedy and non-deterministic variant, with or without default value.
static class	Translet.OrCoTupleParser<A,B,C,D> Realizes disjunction which is nondeterministic and returns a CoTuple.
static class	Translet.OrLimesParser<A> Realizes disjunction which is nondeterministic and returns an upper limit class.
static class	Translet.PermutationParser<R,A,B,C,D,E,F,G,H> Variant of Translet.ProductParser which accepts all permutations of sub-parsers.
static class	Translet.PlusParser<D> Repetition parser which does not allow allow empty list as result.
static class	Translet.PriorCoTupleParser<A,B,C,D> Realizes disjunction which is priorized and returns a CoTuple.
static class	Translet.PriorLimesParser<A> Realizes disjunction which is priorized and returns an upper limit class.
static class	Translet.ProductParser<R,A,B,C,D,E,F,G,H> Common superclass for Parsers which produce a product type as their result.
static class	Translet.Recursive<R> A placeholder which can be formandum into a parser construct, and later be assigned the complete parser as a whole, for recursive use.
static class	Translet.RepParser<D> Common superclass for Translet.StarParser and Translet.PlusParser.
static class	Translet.SequParser<R,A,B,C,D,E,F,G,H> Variant of Translet.ProductParser which accepts a certain sequence of sub-parsers.
static class	Translet.StarParser<D> Repetition parser which allows empty list as result.
static class	Translet.StorageWrapper<S> Common superclass of the storing oeprators.
static class	Translet.Store_1<S> Storing operator which only one(1) value per key.
static class	Translet.Store_M<S> Storing operator which can store multiple (>1) values per key.
static class	TransletLib._TEST<R> Filters the result of its sub-parser by an explicit Java-encoded boolean predicate.

Fields in eu.bandm.tscore.base declared as Translet.Parser

Modifier and Type	Field and Description
(package private) Translet.Parser<String>	TendencyCollector.additionalTextParser Parser for the additional text.
(package private) Translet.Parser<String>	GroupCollector.additionalTextParser The parser for the additional opening and closing text.
(package private) Translet.Parser<E>	TendencyCollector.domainParser Parser for the parameter values.
static Translet.Parser<String>	TransletLib.doubleQuotedTextParser_noDoubleQuotesContained Parser which accepts any text which is framed by doublequotes and does not contain doublequotes.
(package private) static Translet.Parser<String>	Translet.eps A parser matching an empty character sequecen in the input.
static Translet.Parser<String>	TransletLib.identifier_javalike Parser which accepts any text which fulfills the rules for Java identifiers.
(package private) Translet.Parser<String>	GroupCollector.identParser The parser for the groups name.
protected Translet.Parser<A>	Translet.ProductParser.p0 Parser of the 0th subresult.
protected Translet.Parser<A>	Translet.FramedParser.p1 The central parser, result of which will become the result of this.
protected Translet.Parser<A>	Translet.HeadParser.p1 The hear parser, result of which will become the result of this.
protected Translet.Parser<B>	Translet.ProductParser.p1 Parser of the 1st subresult.
protected Translet.Parser<A>	Translet.CoTupleParser.p1
protected Translet.Parser<? extends A>	Translet.LimesParser.p1
protected Translet.Parser<C>	Translet.ProductParser.p2 Parser of the 2nd subresult.
protected Translet.Parser<B>	Translet.CoTupleParser.p2
protected Translet.Parser<? extends A>	Translet.LimesParser.p2
protected Translet.Parser<D>	Translet.ProductParser.p3 Parser of the 3rd subresult.
protected Translet.Parser<C>	Translet.CoTupleParser.p3
protected Translet.Parser<? extends A>	Translet.LimesParser.p3
protected Translet.Parser<E>	Translet.ProductParser.p4 Parser of the 4th subresult.
protected Translet.Parser<D>	Translet.CoTupleParser.p4
protected Translet.Parser<? extends A>	Translet.LimesParser.p4
protected Translet.Parser<F>	Translet.ProductParser.p5 Parser of the 5th subresult.
protected Translet.Parser<G>	Translet.ProductParser.p6 Parser of the 6th subresult.
protected Translet.Parser<H>	Translet.ProductParser.p7 Parser of the 7th subresult.
static Translet.Parser<String>	TransletLib.parse_integer_nonNeg Parser accepting string values "0" or any positive integer, no leading zeros.
static Translet.Parser<String>	TransletLib.parse_integer_positive Parser accepting string values of any positive integer, no leading zeros.
static Translet.Parser<Integer>	TransletLib.parseAndPack_integer_nonNeg Parser accepting string values "0" or any positive integer, no leading zeros, and converting it to Integer value.
static Translet.Parser<Integer>	TransletLib.parseAndPack_integer_positive Parser accepting string values of any positive integer, no leading zeros, and converting it to Integer value.
static Translet.Parser<Integer>	TransletLib.parseAndPack_percent Parser accepting strings representing integer percent values (one or two digits, no leading zeros, or the special values "100" and "0"), and converting it to Integer value.
static Translet.Parser<Rational>	TransletLib.parseAndPack_rational_withSlash_nonNeg Parser for rational numbers in slash notation.
static Translet.Parser<Rational>	TransletLib.parseAndPack_rational_withSlash_positive Parser for rational numbers in slash notation.
(package private) Translet.Parser<R>	Translet.State.parser The translet parser which has consumed to produce this state.
protected @Opt Translet.Parser<?>	Translet.RepParser.sep An optional additional non-terminal parser, which must accept between the repetitions.
protected Translet.Parser<?>	Translet.FramedParser.sep0 The left frame subparser.
protected Translet.Parser<?>	Translet.FramedParser.sep1 The right frame subparser.
(package private) @Opt Translet.Parser<?>	Translet.ProductParser.separator A separator which must be appear between two (non-epsilon) applications of two sub-parsers.
(package private) Translet.Parser<R>	TransletLib._TEST.sub Evident.
protected @Opt Translet.Parser<R>	Translet.Recursive.sub The parser to call whenever this parser shall become active.
protected Translet.Parser<S>	Translet.StorageWrapper.sub
protected Translet.Parser<D>	Translet.RepParser.sub The repeated sub-parser.
protected Translet.Parser<D>	Translet.OptionParser.sub The sub-parser to parse or ski.
protected Translet.Parser<?>[]	Translet.ProductParser.subParsers List of all sub-parsers, needed for name generation and parser loops.

Fields in eu.bandm.tscore.base with type parameters of type Translet.Parser

Modifier and Type	Field and Description
protected List<Translet.Parser<?>>	Translet.Alternative.expected All parsers which have been tested to continue the state.
protected Map<Translet.Parser,Integer>	Translet.FormatPrinter_memo.parser2columns
protected Multimap<Translet.Parser<?>,Translet.State<?>>	Translet.PermutationParser.parser2state Maps all sub-parsers to all states the created during all parsing apptempts.
protected List<Translet.Parser<?>>	Translet.HeadParser.seps List of following parsers, not contributing to result.

Methods in eu.bandm.tscore.base that return Translet.Parser

Modifier and Type	Method and Description
Translet.Parser<E>	EntityCatalog.getParser() Get a parser which accepts the names of the entities in the default language.
Translet.Parser<E>	Entity.getParser() Gets the default parser for this entity, which accepts the name in the default language, as specified by EntityCatalog.getDefaultLanguage()
Translet.Parser<?>	TendencyCollector.getParser() Returns the parser which realizes the combination of parameters set when constructing this instance.
Translet.Parser<?>	EventPatternDistributor.getParser()
Translet.Parser<?>	GroupCollector.getParser() Get the parser which accepts open group, close group, and singleton add parameter texts, converts these into group events and stores these.
Translet.Parser<D>	Translet.Parseable.getParser() Deliver tscore/translet data parser, not specifying a human language.
Translet.Parser<E>	EntityCatalog.getParser(String lang) Get a parser which accepts the names of the entities in the given language and returns the possibly found Entity as its value.
Translet.Parser<E>	Entity.getParser(String language) Gets the default parser for this entity, which accepts the name in the given language.
Translet.Parser<D>	Translet.Parseable.getParser(String language) Deliver tscore/translet data parser, if possible in the specified human language.
protected static Translet.Parser<?>	Translet.getSubOrNa(List<Translet.Parser<?>> subs, int size, int idx) Return the element number "idx" (zero based!) from the list, or Translet.na, it the index is too large.
static <T> @Opt Translet.Parser<T>	TransletLib.makeOR1(@Opt Translet.Parser<? extends T> p1, @Opt Translet.Parser<? extends T> p2) Combine parsers into a OR parser, if necessary.
protected Translet.Parser<?>	Translet.PermutationParser.makerestperm(BitSet tested, int tested1) Construct a new permutation parser from all sub-parsers not yet tested.
static <P> Translet.Parser<P>	Util.parserForName(@Opt String className, String parsername) Delivers the parser object for the members of a particular class.
Translet.Parser<R>	Translet.Parser.stripOpt() Returns the first nested parser which is NOT an Translet.OptionParser.
Translet.Parser<R>	Translet.Recursive.stripOpt()
Translet.Parser<List<D>>	Translet.StarParser.stripOpt()
Translet.Parser<D>	Translet.OptionParser.stripOpt()
protected static Translet.Parser<?>	Translet.wrapSequ(List<Translet.Parser<?>> subs) Wrap a list of parsers into one(1) top-level sequence parser, iff longer than one (>1).

Methods in eu.bandm.tscore.base with parameters of type Translet.Parser

Modifier and Type	Method and Description
protected void	Translet.Alternative.append(Translet.Parser<?> parser) Add a further parser as alternative to continue this state.
protected static Format	Translet.disj_makeName(String operator, boolean full, Map<Translet.Recursive,String> names, Translet.Parser<?> p1, Translet.Parser<?> p2, Translet.Parser<?> p3, Translet.Parser<?> p4) Construct the pretty-print name for a disjunctive parser.
protected static Format	Translet.disj_makeName(String operator, boolean full, Map<Translet.Recursive,String> names, Translet.Parser<?> p1, Translet.Parser<?> p2, Translet.Parser<?> p3, Translet.Parser<?> p4) Construct the pretty-print name for a disjunctive parser.
protected static Format	Translet.disj_makeName(String operator, boolean full, Map<Translet.Recursive,String> names, Translet.Parser<?> p1, Translet.Parser<?> p2, Translet.Parser<?> p3, Translet.Parser<?> p4) Construct the pretty-print name for a disjunctive parser.
protected static Format	Translet.disj_makeName(String operator, boolean full, Map<Translet.Recursive,String> names, Translet.Parser<?> p1, Translet.Parser<?> p2, Translet.Parser<?> p3, Translet.Parser<?> p4) Construct the pretty-print name for a disjunctive parser.
protected static <R,S> void	Translet.disj_testOneBranch(Translet.Parser<S> disj_parser, Translet.Parser<R> parser, List<Translet.Parser<?>> notHit, int index, Translet.State<?> inState, Set<Translet.State<S>> outStates, Set<Translet.Alternative> alternatives) Tests one of the branch-parsers (with the given index) of the disj_parser, with the given start state.
protected static <R,S> void	Translet.disj_testOneBranch(Translet.Parser<S> disj_parser, Translet.Parser<R> parser, List<Translet.Parser<?>> notHit, int index, Translet.State<?> inState, Set<Translet.State<S>> outStates, Set<Translet.Alternative> alternatives) Tests one of the branch-parsers (with the given index) of the disj_parser, with the given start state.
static <R> void	Translet.displayBindings(CatalogByString cat, List<String> prefs, PrintStream ps, int width, boolean full, Object locationtext, Translet.Parser<?> parser, Set<Translet.State<R>> results, @Opt Translet.State<R> selected, @Opt Set<Translet.State<R>> rests, @Opt Set<Translet.Alternative> alts, Modifiers modifiers, boolean showAlts, boolean showRests) Presents all collected prefixes of possible parse trees to the user for error diagnosis.
static <R> void	Translet.displayBindings(CatalogByString cat, List<String> prefs, PrintWriter pw, int width, boolean full, @Opt Object locationtext, Translet.Parser<?> parser, @Opt Set<Translet.State<R>> results, @Opt Translet.State<R> selected, Set<Translet.State<R>> rests, Set<Translet.Alternative> alts, Modifiers modifiers, boolean showAlts, boolean showRests) Show complete parsing situation on a PrintStream, possibly multi-lingual.
protected <R> R	Translet.PermutationParser.findResult_p(Translet.State<?> s, Translet.Parser<R> p) Aux function for casting only: find the result of the application of parser "p" in the (successful) parse tree ending in state "s".
static <D> Translet.FramedParser<D>	Translet.FRAME(Translet.Parser<?> p0, Translet.Parser<D> sub, Translet.Parser<?> p1) Factors method to create one frame parser.
static <D> Translet.FramedParser<D>	Translet.FRAME(Translet.Parser<?> p0, Translet.Parser<D> sub, Translet.Parser<?> p1) Factors method to create one frame parser.
static <D> Translet.FramedParser<D>	Translet.FRAME(Translet.Parser<?> p0, Translet.Parser<D> sub, Translet.Parser<?> p1) Factors method to create one frame parser.
static <D> Translet.HeadParser<D>	Translet.HEAD(Translet.Parser<D> sub, Translet.Parser<?>... subs) Factors method to create one head parser.
static <D> Translet.HeadParser<D>	Translet.HEAD(Translet.Parser<D> sub, Translet.Parser<?>... subs) Factors method to create one head parser.
static <T> @Opt Translet.Parser<T>	TransletLib.makeOR1(@Opt Translet.Parser<? extends T> p1, @Opt Translet.Parser<? extends T> p2) Combine parsers into a OR parser, if necessary.
static <T> @Opt Translet.Parser<T>	TransletLib.makeOR1(@Opt Translet.Parser<? extends T> p1, @Opt Translet.Parser<? extends T> p2) Combine parsers into a OR parser, if necessary.
static <D> Translet.OptionParser<D>	Translet.OPT(boolean greedy, D deflt, Translet.Parser<D> sub) Factory method for an option with the given default value and greediness.
static <D> Translet.OptionParser<D>	Translet.OPT(Translet.Parser<D> sub) Factory method for a non-greey option without default.
static <A> Translet.OrLimesParser<A>	Translet.OR1(Translet.Parser<? extends A> p1, Translet.Parser<? extends A> p2) Factory method for a nondeterministic disjunction returning the limes type.
static <A> Translet.OrLimesParser<A>	Translet.OR1(Translet.Parser<? extends A> p1, Translet.Parser<? extends A> p2) Factory method for a nondeterministic disjunction returning the limes type.
static <A> Translet.OrLimesParser<A>	Translet.OR1(Translet.Parser<? extends A> p1, Translet.Parser<? extends A> p2, Translet.Parser<? extends A> p3) Factory method for a nondeterministic disjunction returning the limes type.
static <A> Translet.OrLimesParser<A>	Translet.OR1(Translet.Parser<? extends A> p1, Translet.Parser<? extends A> p2, Translet.Parser<? extends A> p3) Factory method for a nondeterministic disjunction returning the limes type.
static <A> Translet.OrLimesParser<A>	Translet.OR1(Translet.Parser<? extends A> p1, Translet.Parser<? extends A> p2, Translet.Parser<? extends A> p3) Factory method for a nondeterministic disjunction returning the limes type.
static <A> Translet.OrLimesParser<A>	Translet.OR1(Translet.Parser<? extends A> p1, Translet.Parser<? extends A> p2, Translet.Parser<? extends A> p3, Translet.Parser<? extends A> p4) Factory method for a nondeterministic disjunction returning the limes type.
static <A> Translet.OrLimesParser<A>	Translet.OR1(Translet.Parser<? extends A> p1, Translet.Parser<? extends A> p2, Translet.Parser<? extends A> p3, Translet.Parser<? extends A> p4) Factory method for a nondeterministic disjunction returning the limes type.
static <A> Translet.OrLimesParser<A>	Translet.OR1(Translet.Parser<? extends A> p1, Translet.Parser<? extends A> p2, Translet.Parser<? extends A> p3, Translet.Parser<? extends A> p4) Factory method for a nondeterministic disjunction returning the limes type.
static <A> Translet.OrLimesParser<A>	Translet.OR1(Translet.Parser<? extends A> p1, Translet.Parser<? extends A> p2, Translet.Parser<? extends A> p3, Translet.Parser<? extends A> p4) Factory method for a nondeterministic disjunction returning the limes type.
static <A,B> Translet.OrCoTupleParser<A,B,Object,Object>	Translet.ORn(Translet.Parser<A> p1, Translet.Parser<B> p2) Factory method for a nondeterministic disjunction returning a co-tuple.
static <A,B> Translet.OrCoTupleParser<A,B,Object,Object>	Translet.ORn(Translet.Parser<A> p1, Translet.Parser<B> p2) Factory method for a nondeterministic disjunction returning a co-tuple.
static <A,B,C> Translet.OrCoTupleParser<A,B,C,Object>	Translet.ORn(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3) Factory method for a nondeterministic disjunction returning a co-tuple.
static <A,B,C> Translet.OrCoTupleParser<A,B,C,Object>	Translet.ORn(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3) Factory method for a nondeterministic disjunction returning a co-tuple.
static <A,B,C> Translet.OrCoTupleParser<A,B,C,Object>	Translet.ORn(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3) Factory method for a nondeterministic disjunction returning a co-tuple.
static <A,B,C,D> Translet.OrCoTupleParser<A,B,C,D>	Translet.ORn(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Factory method for a nondeterministic disjunction returning a co-tuple.
static <A,B,C,D> Translet.OrCoTupleParser<A,B,C,D>	Translet.ORn(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Factory method for a nondeterministic disjunction returning a co-tuple.
static <A,B,C,D> Translet.OrCoTupleParser<A,B,C,D>	Translet.ORn(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Factory method for a nondeterministic disjunction returning a co-tuple.
static <A,B,C,D> Translet.OrCoTupleParser<A,B,C,D>	Translet.ORn(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Factory method for a nondeterministic disjunction returning a co-tuple.
static <R> R	Translet.parseAndDiagnosis(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msg, PrintStream displayStream, CatalogByString cat, List<String> prefs, LocationMap<Object,XMLDocumentIdentifier> locationMap, @Opt String paramName, @Opt String voiceName, Event storageKey, String data, Translet.Parser<R> parser, Modifiers modifiers) Central entry point for parsing one(1) text input for one(1) event and one(1) parameter name.
static void	Util.parseParamTrack(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msg, Vox v, String trackname, String separator, Translet.Parser<?> parser, Modifiers react) Applies a certain Translet.Parser parser to the given parameter track.
static <T> void	Util.parseTpTops(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msg, Modifiers modifiers, Part part, Map<TpTop,T> values, SortedMap<T,TpTop> representatives, Translet.Parser<T> parser, @Opt Function3<Comparator<? super T>,T,T,String> check_oneLine, @Opt Function3<Comparator<? super T>,T,T,String> check_twoLines) Parse all TpTops into some internal numeric format "T" and store them.
static <R,A,B> Translet.PermutationParser<R,A,B,Object,Object,Object,Object,Object,Object>	Translet.PERM(BiFunction<A,B,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2) Factory method for a permutation of two, applying the given function to get the result.
static <R,A,B> Translet.PermutationParser<R,A,B,Object,Object,Object,Object,Object,Object>	Translet.PERM(BiFunction<A,B,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2) Factory method for a permutation of two, applying the given function to get the result.
static <R,A,B> Translet.PermutationParser<R,A,B,Object,Object,Object,Object,Object,Object>	Translet.PERM(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2) Factory method for a permutation of two, applying a constructor for the given class to get the result.
static <R,A,B> Translet.PermutationParser<R,A,B,Object,Object,Object,Object,Object,Object>	Translet.PERM(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2) Factory method for a permutation of two, applying a constructor for the given class to get the result.
static <R,A,B,C> Translet.PermutationParser<R,A,B,C,Object,Object,Object,Object,Object>	Translet.PERM(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3) Factory method for a permutation of three, applying a constructor for the given class to get the result.
static <R,A,B,C> Translet.PermutationParser<R,A,B,C,Object,Object,Object,Object,Object>	Translet.PERM(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3) Factory method for a permutation of three, applying a constructor for the given class to get the result.
static <R,A,B,C> Translet.PermutationParser<R,A,B,C,Object,Object,Object,Object,Object>	Translet.PERM(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3) Factory method for a permutation of three, applying a constructor for the given class to get the result.
static <R,A,B,C,D> Translet.PermutationParser<R,A,B,C,D,Object,Object,Object,Object>	Translet.PERM(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Factory method for a permutation of four, applying a constructor for the given class to get the result.
static <R,A,B,C,D> Translet.PermutationParser<R,A,B,C,D,Object,Object,Object,Object>	Translet.PERM(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Factory method for a permutation of four, applying a constructor for the given class to get the result.
static <R,A,B,C,D> Translet.PermutationParser<R,A,B,C,D,Object,Object,Object,Object>	Translet.PERM(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Factory method for a permutation of four, applying a constructor for the given class to get the result.
static <R,A,B,C,D> Translet.PermutationParser<R,A,B,C,D,Object,Object,Object,Object>	Translet.PERM(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Factory method for a permutation of four, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E> Translet.PermutationParser<R,A,B,C,D,E,Object,Object,Object>	Translet.PERM(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5) Factory method for a permutation of five, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E> Translet.PermutationParser<R,A,B,C,D,E,Object,Object,Object>	Translet.PERM(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5) Factory method for a permutation of five, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E> Translet.PermutationParser<R,A,B,C,D,E,Object,Object,Object>	Translet.PERM(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5) Factory method for a permutation of five, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E> Translet.PermutationParser<R,A,B,C,D,E,Object,Object,Object>	Translet.PERM(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5) Factory method for a permutation of five, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E> Translet.PermutationParser<R,A,B,C,D,E,Object,Object,Object>	Translet.PERM(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5) Factory method for a permutation of five, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F> Translet.PermutationParser<R,A,B,C,D,E,F,Object,Object>	Translet.PERM(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6) Factory method for a permutation of six, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F> Translet.PermutationParser<R,A,B,C,D,E,F,Object,Object>	Translet.PERM(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6) Factory method for a permutation of six, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F> Translet.PermutationParser<R,A,B,C,D,E,F,Object,Object>	Translet.PERM(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6) Factory method for a permutation of six, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F> Translet.PermutationParser<R,A,B,C,D,E,F,Object,Object>	Translet.PERM(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6) Factory method for a permutation of six, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F> Translet.PermutationParser<R,A,B,C,D,E,F,Object,Object>	Translet.PERM(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6) Factory method for a permutation of six, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F> Translet.PermutationParser<R,A,B,C,D,E,F,Object,Object>	Translet.PERM(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6) Factory method for a permutation of six, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F,G> Translet.PermutationParser<R,A,B,C,D,E,F,G,Object>	Translet.PERM(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a permutation of seven, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F,G> Translet.PermutationParser<R,A,B,C,D,E,F,G,Object>	Translet.PERM(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a permutation of seven, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F,G> Translet.PermutationParser<R,A,B,C,D,E,F,G,Object>	Translet.PERM(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a permutation of seven, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F,G> Translet.PermutationParser<R,A,B,C,D,E,F,G,Object>	Translet.PERM(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a permutation of seven, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F,G> Translet.PermutationParser<R,A,B,C,D,E,F,G,Object>	Translet.PERM(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a permutation of seven, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F,G> Translet.PermutationParser<R,A,B,C,D,E,F,G,Object>	Translet.PERM(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a permutation of seven, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F,G> Translet.PermutationParser<R,A,B,C,D,E,F,G,Object>	Translet.PERM(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a permutation of seven, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F,G,H> Translet.PermutationParser<R,A,B,C,D,E,F,G,H>	Translet.PERM(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a permutation of eight, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F,G,H> Translet.PermutationParser<R,A,B,C,D,E,F,G,H>	Translet.PERM(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a permutation of eight, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F,G,H> Translet.PermutationParser<R,A,B,C,D,E,F,G,H>	Translet.PERM(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a permutation of eight, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F,G,H> Translet.PermutationParser<R,A,B,C,D,E,F,G,H>	Translet.PERM(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a permutation of eight, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F,G,H> Translet.PermutationParser<R,A,B,C,D,E,F,G,H>	Translet.PERM(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a permutation of eight, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F,G,H> Translet.PermutationParser<R,A,B,C,D,E,F,G,H>	Translet.PERM(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a permutation of eight, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F,G,H> Translet.PermutationParser<R,A,B,C,D,E,F,G,H>	Translet.PERM(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a permutation of eight, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F,G,H> Translet.PermutationParser<R,A,B,C,D,E,F,G,H>	Translet.PERM(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a permutation of eight, applying a constructor for the given class to get the result.
static <R,A,B,C> Translet.PermutationParser<R,A,B,C,Object,Object,Object,Object,Object>	Translet.PERM(Function3<A,B,C,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3) Factory method for a permutation of three, applying the given function to get the result.
static <R,A,B,C> Translet.PermutationParser<R,A,B,C,Object,Object,Object,Object,Object>	Translet.PERM(Function3<A,B,C,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3) Factory method for a permutation of three, applying the given function to get the result.
static <R,A,B,C> Translet.PermutationParser<R,A,B,C,Object,Object,Object,Object,Object>	Translet.PERM(Function3<A,B,C,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3) Factory method for a permutation of three, applying the given function to get the result.
static <R,A,B,C,D> Translet.PermutationParser<R,A,B,C,D,Object,Object,Object,Object>	Translet.PERM(Function4<A,B,C,D,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Factory method for a permutation of four, applying the given function to get the result.
static <R,A,B,C,D> Translet.PermutationParser<R,A,B,C,D,Object,Object,Object,Object>	Translet.PERM(Function4<A,B,C,D,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Factory method for a permutation of four, applying the given function to get the result.
static <R,A,B,C,D> Translet.PermutationParser<R,A,B,C,D,Object,Object,Object,Object>	Translet.PERM(Function4<A,B,C,D,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Factory method for a permutation of four, applying the given function to get the result.
static <R,A,B,C,D> Translet.PermutationParser<R,A,B,C,D,Object,Object,Object,Object>	Translet.PERM(Function4<A,B,C,D,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Factory method for a permutation of four, applying the given function to get the result.
static <R,A,B,C,D,E> Translet.PermutationParser<R,A,B,C,D,E,Object,Object,Object>	Translet.PERM(Function5<A,B,C,D,E,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5) Factory method for a permutation of five, applying the given function to get the result.
static <R,A,B,C,D,E> Translet.PermutationParser<R,A,B,C,D,E,Object,Object,Object>	Translet.PERM(Function5<A,B,C,D,E,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5) Factory method for a permutation of five, applying the given function to get the result.
static <R,A,B,C,D,E> Translet.PermutationParser<R,A,B,C,D,E,Object,Object,Object>	Translet.PERM(Function5<A,B,C,D,E,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5) Factory method for a permutation of five, applying the given function to get the result.
static <R,A,B,C,D,E> Translet.PermutationParser<R,A,B,C,D,E,Object,Object,Object>	Translet.PERM(Function5<A,B,C,D,E,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5) Factory method for a permutation of five, applying the given function to get the result.
static <R,A,B,C,D,E> Translet.PermutationParser<R,A,B,C,D,E,Object,Object,Object>	Translet.PERM(Function5<A,B,C,D,E,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5) Factory method for a permutation of five, applying the given function to get the result.
static <R,A,B,C,D,E,F> Translet.PermutationParser<R,A,B,C,D,E,F,Object,Object>	Translet.PERM(Function6<A,B,C,D,E,F,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6) Factory method for a permutation of six, applying the given function to get the result.
static <R,A,B,C,D,E,F> Translet.PermutationParser<R,A,B,C,D,E,F,Object,Object>	Translet.PERM(Function6<A,B,C,D,E,F,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6) Factory method for a permutation of six, applying the given function to get the result.
static <R,A,B,C,D,E,F> Translet.PermutationParser<R,A,B,C,D,E,F,Object,Object>	Translet.PERM(Function6<A,B,C,D,E,F,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6) Factory method for a permutation of six, applying the given function to get the result.
static <R,A,B,C,D,E,F> Translet.PermutationParser<R,A,B,C,D,E,F,Object,Object>	Translet.PERM(Function6<A,B,C,D,E,F,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6) Factory method for a permutation of six, applying the given function to get the result.
static <R,A,B,C,D,E,F> Translet.PermutationParser<R,A,B,C,D,E,F,Object,Object>	Translet.PERM(Function6<A,B,C,D,E,F,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6) Factory method for a permutation of six, applying the given function to get the result.
static <R,A,B,C,D,E,F> Translet.PermutationParser<R,A,B,C,D,E,F,Object,Object>	Translet.PERM(Function6<A,B,C,D,E,F,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6) Factory method for a permutation of six, applying the given function to get the result.
static <R,A,B,C,D,E,F,G> Translet.PermutationParser<R,A,B,C,D,E,F,G,Object>	Translet.PERM(Function7<A,B,C,D,E,F,G,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a permutation of seven, applying the given function to get the result.
static <R,A,B,C,D,E,F,G> Translet.PermutationParser<R,A,B,C,D,E,F,G,Object>	Translet.PERM(Function7<A,B,C,D,E,F,G,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a permutation of seven, applying the given function to get the result.
static <R,A,B,C,D,E,F,G> Translet.PermutationParser<R,A,B,C,D,E,F,G,Object>	Translet.PERM(Function7<A,B,C,D,E,F,G,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a permutation of seven, applying the given function to get the result.
static <R,A,B,C,D,E,F,G> Translet.PermutationParser<R,A,B,C,D,E,F,G,Object>	Translet.PERM(Function7<A,B,C,D,E,F,G,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a permutation of seven, applying the given function to get the result.
static <R,A,B,C,D,E,F,G> Translet.PermutationParser<R,A,B,C,D,E,F,G,Object>	Translet.PERM(Function7<A,B,C,D,E,F,G,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a permutation of seven, applying the given function to get the result.
static <R,A,B,C,D,E,F,G> Translet.PermutationParser<R,A,B,C,D,E,F,G,Object>	Translet.PERM(Function7<A,B,C,D,E,F,G,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a permutation of seven, applying the given function to get the result.
static <R,A,B,C,D,E,F,G> Translet.PermutationParser<R,A,B,C,D,E,F,G,Object>	Translet.PERM(Function7<A,B,C,D,E,F,G,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a permutation of seven, applying the given function to get the result.
static <R,A,B,C,D,E,F,G,H> Translet.PermutationParser<R,A,B,C,D,E,F,G,H>	Translet.PERM(Function8<A,B,C,D,E,F,G,H,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a permutation of eight, applying the given function to get the result.
static <R,A,B,C,D,E,F,G,H> Translet.PermutationParser<R,A,B,C,D,E,F,G,H>	Translet.PERM(Function8<A,B,C,D,E,F,G,H,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a permutation of eight, applying the given function to get the result.
static <R,A,B,C,D,E,F,G,H> Translet.PermutationParser<R,A,B,C,D,E,F,G,H>	Translet.PERM(Function8<A,B,C,D,E,F,G,H,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a permutation of eight, applying the given function to get the result.
static <R,A,B,C,D,E,F,G,H> Translet.PermutationParser<R,A,B,C,D,E,F,G,H>	Translet.PERM(Function8<A,B,C,D,E,F,G,H,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a permutation of eight, applying the given function to get the result.
static <R,A,B,C,D,E,F,G,H> Translet.PermutationParser<R,A,B,C,D,E,F,G,H>	Translet.PERM(Function8<A,B,C,D,E,F,G,H,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a permutation of eight, applying the given function to get the result.
static <R,A,B,C,D,E,F,G,H> Translet.PermutationParser<R,A,B,C,D,E,F,G,H>	Translet.PERM(Function8<A,B,C,D,E,F,G,H,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a permutation of eight, applying the given function to get the result.
static <R,A,B,C,D,E,F,G,H> Translet.PermutationParser<R,A,B,C,D,E,F,G,H>	Translet.PERM(Function8<A,B,C,D,E,F,G,H,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a permutation of eight, applying the given function to get the result.
static <R,A,B,C,D,E,F,G,H> Translet.PermutationParser<R,A,B,C,D,E,F,G,H>	Translet.PERM(Function8<A,B,C,D,E,F,G,H,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a permutation of eight, applying the given function to get the result.
static <R,A,B> Translet.PermutationParser<R,A,B,Object,Object,Object,Object,Object,Object>	Translet.PERM(Translet.Parser<A> p1, Translet.Parser<B> p2) Factory method for a permutation of two, creating no result.
static <R,A,B> Translet.PermutationParser<R,A,B,Object,Object,Object,Object,Object,Object>	Translet.PERM(Translet.Parser<A> p1, Translet.Parser<B> p2) Factory method for a permutation of two, creating no result.
static <R,A,B,C> Translet.PermutationParser<R,A,B,C,Object,Object,Object,Object,Object>	Translet.PERM(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3) Factory method for a permutation of three, creating no result.
static <R,A,B,C> Translet.PermutationParser<R,A,B,C,Object,Object,Object,Object,Object>	Translet.PERM(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3) Factory method for a permutation of three, creating no result.
static <R,A,B,C> Translet.PermutationParser<R,A,B,C,Object,Object,Object,Object,Object>	Translet.PERM(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3) Factory method for a permutation of three, creating no result.
static <R,A,B,C,D> Translet.PermutationParser<R,A,B,C,D,Object,Object,Object,Object>	Translet.PERM(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Factory method for a permutation of four, creating no result.
static <R,A,B,C,D> Translet.PermutationParser<R,A,B,C,D,Object,Object,Object,Object>	Translet.PERM(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Factory method for a permutation of four, creating no result.
static <R,A,B,C,D> Translet.PermutationParser<R,A,B,C,D,Object,Object,Object,Object>	Translet.PERM(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Factory method for a permutation of four, creating no result.
static <R,A,B,C,D> Translet.PermutationParser<R,A,B,C,D,Object,Object,Object,Object>	Translet.PERM(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Factory method for a permutation of four, creating no result.
static <R,A,B,C,D,E> Translet.PermutationParser<R,A,B,C,D,E,Object,Object,Object>	Translet.PERM(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5) Factory method for a permutation of five, creating no result.
static <R,A,B,C,D,E> Translet.PermutationParser<R,A,B,C,D,E,Object,Object,Object>	Translet.PERM(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5) Factory method for a permutation of five, creating no result.
static <R,A,B,C,D,E> Translet.PermutationParser<R,A,B,C,D,E,Object,Object,Object>	Translet.PERM(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5) Factory method for a permutation of five, creating no result.
static <R,A,B,C,D,E> Translet.PermutationParser<R,A,B,C,D,E,Object,Object,Object>	Translet.PERM(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5) Factory method for a permutation of five, creating no result.
static <R,A,B,C,D,E> Translet.PermutationParser<R,A,B,C,D,E,Object,Object,Object>	Translet.PERM(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5) Factory method for a permutation of five, creating no result.
static <R,A,B,C,D,E,F> Translet.PermutationParser<R,A,B,C,D,E,F,Object,Object>	Translet.PERM(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6) Factory method for a permutation of six, creating no result.
static <R,A,B,C,D,E,F> Translet.PermutationParser<R,A,B,C,D,E,F,Object,Object>	Translet.PERM(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6) Factory method for a permutation of six, creating no result.
static <R,A,B,C,D,E,F> Translet.PermutationParser<R,A,B,C,D,E,F,Object,Object>	Translet.PERM(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6) Factory method for a permutation of six, creating no result.
static <R,A,B,C,D,E,F> Translet.PermutationParser<R,A,B,C,D,E,F,Object,Object>	Translet.PERM(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6) Factory method for a permutation of six, creating no result.
static <R,A,B,C,D,E,F> Translet.PermutationParser<R,A,B,C,D,E,F,Object,Object>	Translet.PERM(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6) Factory method for a permutation of six, creating no result.
static <R,A,B,C,D,E,F> Translet.PermutationParser<R,A,B,C,D,E,F,Object,Object>	Translet.PERM(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6) Factory method for a permutation of six, creating no result.
static <R,A,B,C,D,E,F,G> Translet.PermutationParser<R,A,B,C,D,E,F,G,Object>	Translet.PERM(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a permutation of seven, creating no result.
static <R,A,B,C,D,E,F,G> Translet.PermutationParser<R,A,B,C,D,E,F,G,Object>	Translet.PERM(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a permutation of seven, creating no result.
static <R,A,B,C,D,E,F,G> Translet.PermutationParser<R,A,B,C,D,E,F,G,Object>	Translet.PERM(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a permutation of seven, creating no result.
static <R,A,B,C,D,E,F,G> Translet.PermutationParser<R,A,B,C,D,E,F,G,Object>	Translet.PERM(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a permutation of seven, creating no result.
static <R,A,B,C,D,E,F,G> Translet.PermutationParser<R,A,B,C,D,E,F,G,Object>	Translet.PERM(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a permutation of seven, creating no result.
static <R,A,B,C,D,E,F,G> Translet.PermutationParser<R,A,B,C,D,E,F,G,Object>	Translet.PERM(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a permutation of seven, creating no result.
static <R,A,B,C,D,E,F,G> Translet.PermutationParser<R,A,B,C,D,E,F,G,Object>	Translet.PERM(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a permutation of seven, creating no result.
static <R,A,B,C,D,E,F,G,H> Translet.PermutationParser<R,A,B,C,D,E,F,G,H>	Translet.PERM(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a permutation of eight, creating no result.
static <R,A,B,C,D,E,F,G,H> Translet.PermutationParser<R,A,B,C,D,E,F,G,H>	Translet.PERM(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a permutation of eight, creating no result.
static <R,A,B,C,D,E,F,G,H> Translet.PermutationParser<R,A,B,C,D,E,F,G,H>	Translet.PERM(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a permutation of eight, creating no result.
static <R,A,B,C,D,E,F,G,H> Translet.PermutationParser<R,A,B,C,D,E,F,G,H>	Translet.PERM(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a permutation of eight, creating no result.
static <R,A,B,C,D,E,F,G,H> Translet.PermutationParser<R,A,B,C,D,E,F,G,H>	Translet.PERM(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a permutation of eight, creating no result.
static <R,A,B,C,D,E,F,G,H> Translet.PermutationParser<R,A,B,C,D,E,F,G,H>	Translet.PERM(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a permutation of eight, creating no result.
static <R,A,B,C,D,E,F,G,H> Translet.PermutationParser<R,A,B,C,D,E,F,G,H>	Translet.PERM(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a permutation of eight, creating no result.
static <R,A,B,C,D,E,F,G,H> Translet.PermutationParser<R,A,B,C,D,E,F,G,H>	Translet.PERM(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a permutation of eight, creating no result.
static <D> Translet.PlusParser<D>	Translet.PLUS(boolean greedy, Translet.Parser<D> sub) Factory method for repetitions which may not be empty; greediness set by paraemter.
static <D> Translet.PlusParser<D>	Translet.PLUS(boolean greedy, Translet.Parser<D> sub, @Opt Translet.Parser<?> sep) Factory method for repetitions which may not be empty, need the separator between repetitions and are greedy according to the parameter value.
static <D> Translet.PlusParser<D>	Translet.PLUS(boolean greedy, Translet.Parser<D> sub, @Opt Translet.Parser<?> sep) Factory method for repetitions which may not be empty, need the separator between repetitions and are greedy according to the parameter value.
static <D> Translet.PlusParser<D>	Translet.PLUS(eu.bandm.tscore.base.Translet.NonGreedy nonGreedy, Translet.Parser<D> sub) Factory method for repetitions which may not be empty and parse non-greedily.
static <D> Translet.PlusParser<D>	Translet.PLUS(Translet.Parser<D> sub) Factory method for repetitions which may not be empty and parse greedily.
static <A> Translet.PriorLimesParser<A>	Translet.PRIOR1(Translet.Parser<? extends A> p1, Translet.Parser<? extends A> p2) Factory method for a first-wins disjunction returning the limes type.
static <A> Translet.PriorLimesParser<A>	Translet.PRIOR1(Translet.Parser<? extends A> p1, Translet.Parser<? extends A> p2) Factory method for a first-wins disjunction returning the limes type.
static <A> Translet.PriorLimesParser<A>	Translet.PRIOR1(Translet.Parser<? extends A> p1, Translet.Parser<? extends A> p2, Translet.Parser<? extends A> p3) Factory method for a first-wins disjunction returning the limes type.
static <A> Translet.PriorLimesParser<A>	Translet.PRIOR1(Translet.Parser<? extends A> p1, Translet.Parser<? extends A> p2, Translet.Parser<? extends A> p3) Factory method for a first-wins disjunction returning the limes type.
static <A> Translet.PriorLimesParser<A>	Translet.PRIOR1(Translet.Parser<? extends A> p1, Translet.Parser<? extends A> p2, Translet.Parser<? extends A> p3) Factory method for a first-wins disjunction returning the limes type.
static <A> Translet.PriorLimesParser<A>	Translet.PRIOR1(Translet.Parser<? extends A> p1, Translet.Parser<? extends A> p2, Translet.Parser<? extends A> p3, Translet.Parser<? extends A> p4) Factory method for a first-wins disjunction returning the limes type.
static <A> Translet.PriorLimesParser<A>	Translet.PRIOR1(Translet.Parser<? extends A> p1, Translet.Parser<? extends A> p2, Translet.Parser<? extends A> p3, Translet.Parser<? extends A> p4) Factory method for a first-wins disjunction returning the limes type.
static <A> Translet.PriorLimesParser<A>	Translet.PRIOR1(Translet.Parser<? extends A> p1, Translet.Parser<? extends A> p2, Translet.Parser<? extends A> p3, Translet.Parser<? extends A> p4) Factory method for a first-wins disjunction returning the limes type.
static <A> Translet.PriorLimesParser<A>	Translet.PRIOR1(Translet.Parser<? extends A> p1, Translet.Parser<? extends A> p2, Translet.Parser<? extends A> p3, Translet.Parser<? extends A> p4) Factory method for a first-wins disjunction returning the limes type.
static <A,B> Translet.PriorCoTupleParser<A,B,Object,Object>	Translet.PRIORn(Translet.Parser<A> p1, Translet.Parser<B> p2) Factory method for a first-wins disjunction returning a co-tuple.
static <A,B> Translet.PriorCoTupleParser<A,B,Object,Object>	Translet.PRIORn(Translet.Parser<A> p1, Translet.Parser<B> p2) Factory method for a first-wins disjunction returning a co-tuple.
static <A,B,C> Translet.PriorCoTupleParser<A,B,C,Object>	Translet.PRIORn(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3) Factory method for a first-wins disjunction returning a co-tuple.
static <A,B,C> Translet.PriorCoTupleParser<A,B,C,Object>	Translet.PRIORn(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3) Factory method for a first-wins disjunction returning a co-tuple.
static <A,B,C> Translet.PriorCoTupleParser<A,B,C,Object>	Translet.PRIORn(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3) Factory method for a first-wins disjunction returning a co-tuple.
static <A,B,C,D> Translet.PriorCoTupleParser<A,B,C,D>	Translet.PRIORn(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Factory method for a first-wins disjunction returning a co-tuple.
static <A,B,C,D> Translet.PriorCoTupleParser<A,B,C,D>	Translet.PRIORn(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Factory method for a first-wins disjunction returning a co-tuple.
static <A,B,C,D> Translet.PriorCoTupleParser<A,B,C,D>	Translet.PRIORn(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Factory method for a first-wins disjunction returning a co-tuple.
static <A,B,C,D> Translet.PriorCoTupleParser<A,B,C,D>	Translet.PRIORn(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Factory method for a first-wins disjunction returning a co-tuple.
static <R,A,B> Translet.SequParser<R,A,B,Object,Object,Object,Object,Object,Object>	Translet.SEQU(BiFunction<A,B,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2) Factory method for a sequence of two, applying the given function to get the result.
static <R,A,B> Translet.SequParser<R,A,B,Object,Object,Object,Object,Object,Object>	Translet.SEQU(BiFunction<A,B,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2) Factory method for a sequence of two, applying the given function to get the result.
static <R,A> Translet.SequParser<R,A,Object,Object,Object,Object,Object,Object,Object>	Translet.SEQU(Class<R> cons, Translet.Parser<A> p1) Factory method for a singleton sequence, applying a constructor for the given class to get the result.
static <R,A,B> Translet.SequParser<R,A,B,Object,Object,Object,Object,Object,Object>	Translet.SEQU(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2) Factory method for a sequence of two, applying a constructor for the given class to get the result.
static <R,A,B> Translet.SequParser<R,A,B,Object,Object,Object,Object,Object,Object>	Translet.SEQU(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2) Factory method for a sequence of two, applying a constructor for the given class to get the result.
static <R,A,B,C> Translet.SequParser<R,A,B,C,Object,Object,Object,Object,Object>	Translet.SEQU(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3) Factory method for a sequence of three, applying a constructor for the given class to get the result.
static <R,A,B,C> Translet.SequParser<R,A,B,C,Object,Object,Object,Object,Object>	Translet.SEQU(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3) Factory method for a sequence of three, applying a constructor for the given class to get the result.
static <R,A,B,C> Translet.SequParser<R,A,B,C,Object,Object,Object,Object,Object>	Translet.SEQU(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3) Factory method for a sequence of three, applying a constructor for the given class to get the result.
static <R,A,B,C,D> Translet.SequParser<R,A,B,C,D,Object,Object,Object,Object>	Translet.SEQU(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Factory method for a sequence of four, applying a constructor for the given class to get the result.
static <R,A,B,C,D> Translet.SequParser<R,A,B,C,D,Object,Object,Object,Object>	Translet.SEQU(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Factory method for a sequence of four, applying a constructor for the given class to get the result.
static <R,A,B,C,D> Translet.SequParser<R,A,B,C,D,Object,Object,Object,Object>	Translet.SEQU(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Factory method for a sequence of four, applying a constructor for the given class to get the result.
static <R,A,B,C,D> Translet.SequParser<R,A,B,C,D,Object,Object,Object,Object>	Translet.SEQU(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Factory method for a sequence of four, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E> Translet.SequParser<R,A,B,C,D,E,Object,Object,Object>	Translet.SEQU(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5) Factory method for a sequence of five, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E> Translet.SequParser<R,A,B,C,D,E,Object,Object,Object>	Translet.SEQU(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5) Factory method for a sequence of five, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E> Translet.SequParser<R,A,B,C,D,E,Object,Object,Object>	Translet.SEQU(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5) Factory method for a sequence of five, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E> Translet.SequParser<R,A,B,C,D,E,Object,Object,Object>	Translet.SEQU(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5) Factory method for a sequence of five, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E> Translet.SequParser<R,A,B,C,D,E,Object,Object,Object>	Translet.SEQU(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5) Factory method for a sequence of five, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F> Translet.SequParser<R,A,B,C,D,E,F,Object,Object>	Translet.SEQU(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6) Factory method for a sequence of six, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F> Translet.SequParser<R,A,B,C,D,E,F,Object,Object>	Translet.SEQU(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6) Factory method for a sequence of six, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F> Translet.SequParser<R,A,B,C,D,E,F,Object,Object>	Translet.SEQU(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6) Factory method for a sequence of six, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F> Translet.SequParser<R,A,B,C,D,E,F,Object,Object>	Translet.SEQU(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6) Factory method for a sequence of six, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F> Translet.SequParser<R,A,B,C,D,E,F,Object,Object>	Translet.SEQU(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6) Factory method for a sequence of six, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F> Translet.SequParser<R,A,B,C,D,E,F,Object,Object>	Translet.SEQU(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6) Factory method for a sequence of six, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F,G> Translet.SequParser<R,A,B,C,D,E,F,G,Object>	Translet.SEQU(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a sequence of seven, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F,G> Translet.SequParser<R,A,B,C,D,E,F,G,Object>	Translet.SEQU(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a sequence of seven, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F,G> Translet.SequParser<R,A,B,C,D,E,F,G,Object>	Translet.SEQU(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a sequence of seven, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F,G> Translet.SequParser<R,A,B,C,D,E,F,G,Object>	Translet.SEQU(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a sequence of seven, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F,G> Translet.SequParser<R,A,B,C,D,E,F,G,Object>	Translet.SEQU(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a sequence of seven, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F,G> Translet.SequParser<R,A,B,C,D,E,F,G,Object>	Translet.SEQU(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a sequence of seven, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F,G> Translet.SequParser<R,A,B,C,D,E,F,G,Object>	Translet.SEQU(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a sequence of seven, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F,G,H> Translet.SequParser<R,A,B,C,D,E,F,G,H>	Translet.SEQU(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a sequence of eight, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F,G,H> Translet.SequParser<R,A,B,C,D,E,F,G,H>	Translet.SEQU(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a sequence of eight, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F,G,H> Translet.SequParser<R,A,B,C,D,E,F,G,H>	Translet.SEQU(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a sequence of eight, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F,G,H> Translet.SequParser<R,A,B,C,D,E,F,G,H>	Translet.SEQU(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a sequence of eight, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F,G,H> Translet.SequParser<R,A,B,C,D,E,F,G,H>	Translet.SEQU(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a sequence of eight, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F,G,H> Translet.SequParser<R,A,B,C,D,E,F,G,H>	Translet.SEQU(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a sequence of eight, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F,G,H> Translet.SequParser<R,A,B,C,D,E,F,G,H>	Translet.SEQU(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a sequence of eight, applying a constructor for the given class to get the result.
static <R,A,B,C,D,E,F,G,H> Translet.SequParser<R,A,B,C,D,E,F,G,H>	Translet.SEQU(Class<R> cons, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a sequence of eight, applying a constructor for the given class to get the result.
static <R,A> Translet.SequParser<R,A,Object,Object,Object,Object,Object,Object,Object>	Translet.SEQU(Function<A,R> f, Translet.Parser<A> p1) Factory method for a singleton sequence, applying the given function to get the result.
static <R,A,B,C> Translet.SequParser<R,A,B,C,Object,Object,Object,Object,Object>	Translet.SEQU(Function3<A,B,C,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3) Factory method for a sequence of three, applying the given function to get the result.
static <R,A,B,C> Translet.SequParser<R,A,B,C,Object,Object,Object,Object,Object>	Translet.SEQU(Function3<A,B,C,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3) Factory method for a sequence of three, applying the given function to get the result.
static <R,A,B,C> Translet.SequParser<R,A,B,C,Object,Object,Object,Object,Object>	Translet.SEQU(Function3<A,B,C,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3) Factory method for a sequence of three, applying the given function to get the result.
static <R,A,B,C,D> Translet.SequParser<R,A,B,C,D,Object,Object,Object,Object>	Translet.SEQU(Function4<A,B,C,D,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Factory method for a sequence of four, applying the given function to get the result.
static <R,A,B,C,D> Translet.SequParser<R,A,B,C,D,Object,Object,Object,Object>	Translet.SEQU(Function4<A,B,C,D,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Factory method for a sequence of four, applying the given function to get the result.
static <R,A,B,C,D> Translet.SequParser<R,A,B,C,D,Object,Object,Object,Object>	Translet.SEQU(Function4<A,B,C,D,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Factory method for a sequence of four, applying the given function to get the result.
static <R,A,B,C,D> Translet.SequParser<R,A,B,C,D,Object,Object,Object,Object>	Translet.SEQU(Function4<A,B,C,D,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Factory method for a sequence of four, applying the given function to get the result.
static <R,A,B,C,D,E> Translet.SequParser<R,A,B,C,D,E,Object,Object,Object>	Translet.SEQU(Function5<A,B,C,D,E,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5) Factory method for a sequence of five, applying the given function to get the result.
static <R,A,B,C,D,E> Translet.SequParser<R,A,B,C,D,E,Object,Object,Object>	Translet.SEQU(Function5<A,B,C,D,E,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5) Factory method for a sequence of five, applying the given function to get the result.
static <R,A,B,C,D,E> Translet.SequParser<R,A,B,C,D,E,Object,Object,Object>	Translet.SEQU(Function5<A,B,C,D,E,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5) Factory method for a sequence of five, applying the given function to get the result.
static <R,A,B,C,D,E> Translet.SequParser<R,A,B,C,D,E,Object,Object,Object>	Translet.SEQU(Function5<A,B,C,D,E,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5) Factory method for a sequence of five, applying the given function to get the result.
static <R,A,B,C,D,E> Translet.SequParser<R,A,B,C,D,E,Object,Object,Object>	Translet.SEQU(Function5<A,B,C,D,E,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5) Factory method for a sequence of five, applying the given function to get the result.
static <R,A,B,C,D,E,F> Translet.SequParser<R,A,B,C,D,E,F,Object,Object>	Translet.SEQU(Function6<A,B,C,D,E,F,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6) Factory method for a sequence of six, applying the given function to get the result.
static <R,A,B,C,D,E,F> Translet.SequParser<R,A,B,C,D,E,F,Object,Object>	Translet.SEQU(Function6<A,B,C,D,E,F,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6) Factory method for a sequence of six, applying the given function to get the result.
static <R,A,B,C,D,E,F> Translet.SequParser<R,A,B,C,D,E,F,Object,Object>	Translet.SEQU(Function6<A,B,C,D,E,F,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6) Factory method for a sequence of six, applying the given function to get the result.
static <R,A,B,C,D,E,F> Translet.SequParser<R,A,B,C,D,E,F,Object,Object>	Translet.SEQU(Function6<A,B,C,D,E,F,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6) Factory method for a sequence of six, applying the given function to get the result.
static <R,A,B,C,D,E,F> Translet.SequParser<R,A,B,C,D,E,F,Object,Object>	Translet.SEQU(Function6<A,B,C,D,E,F,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6) Factory method for a sequence of six, applying the given function to get the result.
static <R,A,B,C,D,E,F> Translet.SequParser<R,A,B,C,D,E,F,Object,Object>	Translet.SEQU(Function6<A,B,C,D,E,F,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6) Factory method for a sequence of six, applying the given function to get the result.
static <R,A,B,C,D,E,F,G> Translet.SequParser<R,A,B,C,D,E,F,G,Object>	Translet.SEQU(Function7<A,B,C,D,E,F,G,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a sequence of seven, applying the given function to get the result.
static <R,A,B,C,D,E,F,G> Translet.SequParser<R,A,B,C,D,E,F,G,Object>	Translet.SEQU(Function7<A,B,C,D,E,F,G,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a sequence of seven, applying the given function to get the result.
static <R,A,B,C,D,E,F,G> Translet.SequParser<R,A,B,C,D,E,F,G,Object>	Translet.SEQU(Function7<A,B,C,D,E,F,G,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a sequence of seven, applying the given function to get the result.
static <R,A,B,C,D,E,F,G> Translet.SequParser<R,A,B,C,D,E,F,G,Object>	Translet.SEQU(Function7<A,B,C,D,E,F,G,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a sequence of seven, applying the given function to get the result.
static <R,A,B,C,D,E,F,G> Translet.SequParser<R,A,B,C,D,E,F,G,Object>	Translet.SEQU(Function7<A,B,C,D,E,F,G,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a sequence of seven, applying the given function to get the result.
static <R,A,B,C,D,E,F,G> Translet.SequParser<R,A,B,C,D,E,F,G,Object>	Translet.SEQU(Function7<A,B,C,D,E,F,G,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a sequence of seven, applying the given function to get the result.
static <R,A,B,C,D,E,F,G> Translet.SequParser<R,A,B,C,D,E,F,G,Object>	Translet.SEQU(Function7<A,B,C,D,E,F,G,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a sequence of seven, applying the given function to get the result.
static <R,A,B,C,D,E,F,G,H> Translet.SequParser<R,A,B,C,D,E,F,G,H>	Translet.SEQU(Function8<A,B,C,D,E,F,G,H,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a sequence of eight, applying the given function to get the result.
static <R,A,B,C,D,E,F,G,H> Translet.SequParser<R,A,B,C,D,E,F,G,H>	Translet.SEQU(Function8<A,B,C,D,E,F,G,H,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a sequence of eight, applying the given function to get the result.
static <R,A,B,C,D,E,F,G,H> Translet.SequParser<R,A,B,C,D,E,F,G,H>	Translet.SEQU(Function8<A,B,C,D,E,F,G,H,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a sequence of eight, applying the given function to get the result.
static <R,A,B,C,D,E,F,G,H> Translet.SequParser<R,A,B,C,D,E,F,G,H>	Translet.SEQU(Function8<A,B,C,D,E,F,G,H,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a sequence of eight, applying the given function to get the result.
static <R,A,B,C,D,E,F,G,H> Translet.SequParser<R,A,B,C,D,E,F,G,H>	Translet.SEQU(Function8<A,B,C,D,E,F,G,H,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a sequence of eight, applying the given function to get the result.
static <R,A,B,C,D,E,F,G,H> Translet.SequParser<R,A,B,C,D,E,F,G,H>	Translet.SEQU(Function8<A,B,C,D,E,F,G,H,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a sequence of eight, applying the given function to get the result.
static <R,A,B,C,D,E,F,G,H> Translet.SequParser<R,A,B,C,D,E,F,G,H>	Translet.SEQU(Function8<A,B,C,D,E,F,G,H,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a sequence of eight, applying the given function to get the result.
static <R,A,B,C,D,E,F,G,H> Translet.SequParser<R,A,B,C,D,E,F,G,H>	Translet.SEQU(Function8<A,B,C,D,E,F,G,H,R> f, Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a sequence of eight, applying the given function to get the result.
static <A,B> Translet.SequParser<Object,A,B,Object,Object,Object,Object,Object,Object>	Translet.SEQU(Translet.Parser<A> p1, Translet.Parser<B> p2) Factory method for a sequence of two, creating no result.
static <A,B> Translet.SequParser<Object,A,B,Object,Object,Object,Object,Object,Object>	Translet.SEQU(Translet.Parser<A> p1, Translet.Parser<B> p2) Factory method for a sequence of two, creating no result.
static <A,B,C> Translet.SequParser<Object,A,B,C,Object,Object,Object,Object,Object>	Translet.SEQU(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3) Factory method for a sequence of three, creating no result.
static <A,B,C> Translet.SequParser<Object,A,B,C,Object,Object,Object,Object,Object>	Translet.SEQU(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3) Factory method for a sequence of three, creating no result.
static <A,B,C> Translet.SequParser<Object,A,B,C,Object,Object,Object,Object,Object>	Translet.SEQU(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3) Factory method for a sequence of three, creating no result.
static <A,B,C,D> Translet.SequParser<Object,A,B,C,D,Object,Object,Object,Object>	Translet.SEQU(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Factory method for a sequence of four, creating no result.
static <A,B,C,D> Translet.SequParser<Object,A,B,C,D,Object,Object,Object,Object>	Translet.SEQU(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Factory method for a sequence of four, creating no result.
static <A,B,C,D> Translet.SequParser<Object,A,B,C,D,Object,Object,Object,Object>	Translet.SEQU(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Factory method for a sequence of four, creating no result.
static <A,B,C,D> Translet.SequParser<Object,A,B,C,D,Object,Object,Object,Object>	Translet.SEQU(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Factory method for a sequence of four, creating no result.
static <A,B,C,D,E> Translet.SequParser<Object,A,B,C,D,E,Object,Object,Object>	Translet.SEQU(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5) Factory method for a sequence of five, creating no result.
static <A,B,C,D,E> Translet.SequParser<Object,A,B,C,D,E,Object,Object,Object>	Translet.SEQU(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5) Factory method for a sequence of five, creating no result.
static <A,B,C,D,E> Translet.SequParser<Object,A,B,C,D,E,Object,Object,Object>	Translet.SEQU(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5) Factory method for a sequence of five, creating no result.
static <A,B,C,D,E> Translet.SequParser<Object,A,B,C,D,E,Object,Object,Object>	Translet.SEQU(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5) Factory method for a sequence of five, creating no result.
static <A,B,C,D,E> Translet.SequParser<Object,A,B,C,D,E,Object,Object,Object>	Translet.SEQU(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5) Factory method for a sequence of five, creating no result.
static <A,B,C,D,E,F> Translet.SequParser<Object,A,B,C,D,E,F,Object,Object>	Translet.SEQU(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6) Factory method for a sequence of six, creating no result.
static <A,B,C,D,E,F> Translet.SequParser<Object,A,B,C,D,E,F,Object,Object>	Translet.SEQU(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6) Factory method for a sequence of six, creating no result.
static <A,B,C,D,E,F> Translet.SequParser<Object,A,B,C,D,E,F,Object,Object>	Translet.SEQU(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6) Factory method for a sequence of six, creating no result.
static <A,B,C,D,E,F> Translet.SequParser<Object,A,B,C,D,E,F,Object,Object>	Translet.SEQU(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6) Factory method for a sequence of six, creating no result.
static <A,B,C,D,E,F> Translet.SequParser<Object,A,B,C,D,E,F,Object,Object>	Translet.SEQU(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6) Factory method for a sequence of six, creating no result.
static <A,B,C,D,E,F> Translet.SequParser<Object,A,B,C,D,E,F,Object,Object>	Translet.SEQU(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6) Factory method for a sequence of six, creating no result.
static <A,B,C,D,E,F,G> Translet.SequParser<Object,A,B,C,D,E,F,G,Object>	Translet.SEQU(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a sequence of seven, creating no result.
static <A,B,C,D,E,F,G> Translet.SequParser<Object,A,B,C,D,E,F,G,Object>	Translet.SEQU(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a sequence of seven, creating no result.
static <A,B,C,D,E,F,G> Translet.SequParser<Object,A,B,C,D,E,F,G,Object>	Translet.SEQU(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a sequence of seven, creating no result.
static <A,B,C,D,E,F,G> Translet.SequParser<Object,A,B,C,D,E,F,G,Object>	Translet.SEQU(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a sequence of seven, creating no result.
static <A,B,C,D,E,F,G> Translet.SequParser<Object,A,B,C,D,E,F,G,Object>	Translet.SEQU(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a sequence of seven, creating no result.
static <A,B,C,D,E,F,G> Translet.SequParser<Object,A,B,C,D,E,F,G,Object>	Translet.SEQU(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a sequence of seven, creating no result.
static <A,B,C,D,E,F,G> Translet.SequParser<Object,A,B,C,D,E,F,G,Object>	Translet.SEQU(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7) Factory method for a sequence of seven, creating no result.
static <A,B,C,D,E,F,G,H> Translet.SequParser<Object,A,B,C,D,E,F,G,H>	Translet.SEQU(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a sequence of eight, creating no result.
static <A,B,C,D,E,F,G,H> Translet.SequParser<Object,A,B,C,D,E,F,G,H>	Translet.SEQU(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a sequence of eight, creating no result.
static <A,B,C,D,E,F,G,H> Translet.SequParser<Object,A,B,C,D,E,F,G,H>	Translet.SEQU(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a sequence of eight, creating no result.
static <A,B,C,D,E,F,G,H> Translet.SequParser<Object,A,B,C,D,E,F,G,H>	Translet.SEQU(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a sequence of eight, creating no result.
static <A,B,C,D,E,F,G,H> Translet.SequParser<Object,A,B,C,D,E,F,G,H>	Translet.SEQU(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a sequence of eight, creating no result.
static <A,B,C,D,E,F,G,H> Translet.SequParser<Object,A,B,C,D,E,F,G,H>	Translet.SEQU(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a sequence of eight, creating no result.
static <A,B,C,D,E,F,G,H> Translet.SequParser<Object,A,B,C,D,E,F,G,H>	Translet.SEQU(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a sequence of eight, creating no result.
static <A,B,C,D,E,F,G,H> Translet.SequParser<Object,A,B,C,D,E,F,G,H>	Translet.SEQU(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4, Translet.Parser<E> p5, Translet.Parser<F> p6, Translet.Parser<G> p7, Translet.Parser<H> p8) Factory method for a sequence of eight, creating no result.
void	Translet.Recursive.setSub(Translet.Parser<R> sub) Link this placeholder to the given Parser.
static <D> Translet.StarParser<D>	Translet.STAR(boolean greedy, Translet.Parser<D> sub) Factory method for repetitions which may be empty; greediness set by paraemter.
static <D> Translet.StarParser<D>	Translet.STAR(boolean greedy, Translet.Parser<D> sub, @Opt Translet.Parser<?> sep) Factory method for repetitions which may be empty, need the separator between repetitions and are greedy accroding to the parameer value.
static <D> Translet.StarParser<D>	Translet.STAR(boolean greedy, Translet.Parser<D> sub, @Opt Translet.Parser<?> sep) Factory method for repetitions which may be empty, need the separator between repetitions and are greedy accroding to the parameer value.
static <D> Translet.StarParser<D>	Translet.STAR(eu.bandm.tscore.base.Translet.NonGreedy nonGreedy, Translet.Parser<D> sub) Factory method for repetitions which may be empty and parse non-greedily.
static <D> Translet.StarParser<D>	Translet.STAR(Translet.Parser<D> sub) Factory method for repetitions which may be empty and parse greedily.
static <D> Translet.Store_1<D>	Translet.STORE(Map<Event,? super D> store, Translet.Parser<D> sub) Factory MessageReceiver for a store with single values per key.
static <D> Translet.Store_M<D>	Translet.STORE(Multimap<Event,? super D> store, Translet.Parser<D> sub) Factory MessageReceiver for a store with multiple values per key.
<N,M extends N> Translet.State<N>	Translet.State.succ(Translet.Parser<N> parser, int pos, M result) Return a new State, which is successor of "this", and in which "parser" has delivered "result" and consumed input up to "pos".
<N,M extends N> Translet.State<N>	Translet.State.succ(Translet.Parser<N> parser, M result) Return a new State, which is successor of "this", and in which "parser" has delivered "result", but no input has been consumed.
static <R> TransletLib._TEST<R>	TransletLib.TEST(Predicate<R> test, String name, Translet.Parser<R> sub)
static <R> TransletLib._TEST<R>	TransletLib.TEST(Predicate<R> test, Translet.Parser<R> sub)
static <R> R	Translet.testParse(String data, Translet.Parser<R> parser, boolean verbose, boolean showParser) Same as Translet.testParse(String,Parser,MessageReceiver,boolean,boolean), but sends all error messages to a MessagePrinter to System.err, without localization.
static <R> R	Translet.testParse(String data, Translet.Parser<R> parser, MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msg, boolean verbose, boolean showParser) Test method for a given parser and a given text input.
Translet.ProductParser<R,A,B,C,D,E,F,G,H>	Translet.ProductParser.withSeparator(Translet.Parser<?> sep) Set the separator which must appear between two non-epsilon-consuming applications of the sub-parsers.

Method parameters in eu.bandm.tscore.base with type arguments of type Translet.Parser

Modifier and Type	Method and Description
protected static void	Translet.disj_makeAlternative(Translet.disj_flavour flavour, Translet.State<?> inState, Set<Translet.Alternative> alternatives, List<Translet.Parser<?>> notHit, Set<Translet.Alternative> subAlts) Constructs a new disjunction parser of the given kind with all failed sub-parser, to add this new expression to alternatives.
protected static <R,S> void	Translet.disj_testOneBranch(Translet.Parser<S> disj_parser, Translet.Parser<R> parser, List<Translet.Parser<?>> notHit, int index, Translet.State<?> inState, Set<Translet.State<S>> outStates, Set<Translet.Alternative> alternatives) Tests one of the branch-parsers (with the given index) of the disj_parser, with the given start state.
protected static Translet.Parser<?>	Translet.getSubOrNa(List<Translet.Parser<?>> subs, int size, int idx) Return the element number "idx" (zero based!) from the list, or Translet.na, it the index is too large.
protected static Translet.Parser<?>	Translet.wrapSequ(List<Translet.Parser<?>> subs) Wrap a list of parsers into one(1) top-level sequence parser, iff longer than one (>1).

Constructors in eu.bandm.tscore.base with parameters of type Translet.Parser

Constructor and Description
_TEST(Predicate<R> test, String name, Translet.Parser<R> sub) Only constructor, called by factors mehtods.
Alternative(Translet.State pre, Translet.Parser<?> parser) Set state and a first parser.
CoTupleParser(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Constructor called only by sub-class constructors.
CoTupleParser(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Constructor called only by sub-class constructors.
CoTupleParser(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Constructor called only by sub-class constructors.
CoTupleParser(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Constructor called only by sub-class constructors.
FramedParser(Translet.Parser<?> sep0, Translet.Parser<A> p1, Translet.Parser<?> sep1)
FramedParser(Translet.Parser<?> sep0, Translet.Parser<A> p1, Translet.Parser<?> sep1)
FramedParser(Translet.Parser<?> sep0, Translet.Parser<A> p1, Translet.Parser<?> sep1)
GroupCollector(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> mmsg, @Opt String singletonLeadIn, Map<String,String> open2close, @Opt Translet.Parser<String> identParser, @Opt Translet.Parser<String> additionalTextParser, boolean sameNameNestingAllowed, boolean sameNameMeansSameSet, boolean openCloseImmediateAllowed, boolean shortcutClose) Only constructor, setting all configuration parameters.
GroupCollector(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> mmsg, @Opt String singletonLeadIn, Map<String,String> open2close, @Opt Translet.Parser<String> identParser, @Opt Translet.Parser<String> additionalTextParser, boolean sameNameNestingAllowed, boolean sameNameMeansSameSet, boolean openCloseImmediateAllowed, boolean shortcutClose) Only constructor, setting all configuration parameters.
HeadParser(Translet.Parser<A> p1, List<Translet.Parser<?>> seps) Only constructor, setting the first and the following parsers.
HeadParser(Translet.Parser<A> p1, Translet.Parser<?>[] seps) Only constructor, setting the first and the trailing parsers.
HeadParser(Translet.Parser<A> p1, Translet.Parser<?>[] seps) Only constructor, setting the first and the trailing parsers.
LimesParser(Translet.Parser<? extends A> p1, Translet.Parser<? extends A> p2, Translet.Parser<? extends A> p3, Translet.Parser<? extends A> p4) Constructor called only by sub-classs constructors.
LimesParser(Translet.Parser<? extends A> p1, Translet.Parser<? extends A> p2, Translet.Parser<? extends A> p3, Translet.Parser<? extends A> p4) Constructor called only by sub-classs constructors.
LimesParser(Translet.Parser<? extends A> p1, Translet.Parser<? extends A> p2, Translet.Parser<? extends A> p3, Translet.Parser<? extends A> p4) Constructor called only by sub-classs constructors.
LimesParser(Translet.Parser<? extends A> p1, Translet.Parser<? extends A> p2, Translet.Parser<? extends A> p3, Translet.Parser<? extends A> p4) Constructor called only by sub-classs constructors.
OptionParser(Translet.Parser<D> sub, D deflt, boolean greedy) Constructor called by the factory methods.
OrCoTupleParser(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Constructor called by factory methods.
OrCoTupleParser(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Constructor called by factory methods.
OrCoTupleParser(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Constructor called by factory methods.
OrCoTupleParser(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Constructor called by factory methods.
OrLimesParser(Translet.Parser<? extends A> p1, Translet.Parser<? extends A> p2, Translet.Parser<? extends A> p3, Translet.Parser<? extends A> p4) Constructor called by factory methods.
OrLimesParser(Translet.Parser<? extends A> p1, Translet.Parser<? extends A> p2, Translet.Parser<? extends A> p3, Translet.Parser<? extends A> p4) Constructor called by factory methods.
OrLimesParser(Translet.Parser<? extends A> p1, Translet.Parser<? extends A> p2, Translet.Parser<? extends A> p3, Translet.Parser<? extends A> p4) Constructor called by factory methods.
OrLimesParser(Translet.Parser<? extends A> p1, Translet.Parser<? extends A> p2, Translet.Parser<? extends A> p3, Translet.Parser<? extends A> p4) Constructor called by factory methods.
ParserFormat(Format f, Translet.Parser<?> p)
PermutationParser(int arity, @Opt Object f, @Opt Class<R> cons, Translet.Parser<A> p0, Translet.Parser<B> p1, Translet.Parser<C> p2, Translet.Parser<D> p3, Translet.Parser<E> p4, Translet.Parser<F> p5, Translet.Parser<G> p6, Translet.Parser<H> p7) This constructor is called by the static factory methods and should normally not be called directly.
PermutationParser(int arity, @Opt Object f, @Opt Class<R> cons, Translet.Parser<A> p0, Translet.Parser<B> p1, Translet.Parser<C> p2, Translet.Parser<D> p3, Translet.Parser<E> p4, Translet.Parser<F> p5, Translet.Parser<G> p6, Translet.Parser<H> p7) This constructor is called by the static factory methods and should normally not be called directly.
PermutationParser(int arity, @Opt Object f, @Opt Class<R> cons, Translet.Parser<A> p0, Translet.Parser<B> p1, Translet.Parser<C> p2, Translet.Parser<D> p3, Translet.Parser<E> p4, Translet.Parser<F> p5, Translet.Parser<G> p6, Translet.Parser<H> p7) This constructor is called by the static factory methods and should normally not be called directly.
PermutationParser(int arity, @Opt Object f, @Opt Class<R> cons, Translet.Parser<A> p0, Translet.Parser<B> p1, Translet.Parser<C> p2, Translet.Parser<D> p3, Translet.Parser<E> p4, Translet.Parser<F> p5, Translet.Parser<G> p6, Translet.Parser<H> p7) This constructor is called by the static factory methods and should normally not be called directly.
PermutationParser(int arity, @Opt Object f, @Opt Class<R> cons, Translet.Parser<A> p0, Translet.Parser<B> p1, Translet.Parser<C> p2, Translet.Parser<D> p3, Translet.Parser<E> p4, Translet.Parser<F> p5, Translet.Parser<G> p6, Translet.Parser<H> p7) This constructor is called by the static factory methods and should normally not be called directly.
PermutationParser(int arity, @Opt Object f, @Opt Class<R> cons, Translet.Parser<A> p0, Translet.Parser<B> p1, Translet.Parser<C> p2, Translet.Parser<D> p3, Translet.Parser<E> p4, Translet.Parser<F> p5, Translet.Parser<G> p6, Translet.Parser<H> p7) This constructor is called by the static factory methods and should normally not be called directly.
PermutationParser(int arity, @Opt Object f, @Opt Class<R> cons, Translet.Parser<A> p0, Translet.Parser<B> p1, Translet.Parser<C> p2, Translet.Parser<D> p3, Translet.Parser<E> p4, Translet.Parser<F> p5, Translet.Parser<G> p6, Translet.Parser<H> p7) This constructor is called by the static factory methods and should normally not be called directly.
PermutationParser(int arity, @Opt Object f, @Opt Class<R> cons, Translet.Parser<A> p0, Translet.Parser<B> p1, Translet.Parser<C> p2, Translet.Parser<D> p3, Translet.Parser<E> p4, Translet.Parser<F> p5, Translet.Parser<G> p6, Translet.Parser<H> p7) This constructor is called by the static factory methods and should normally not be called directly.
PlusParser(Translet.Parser<D> sub, Translet.Parser<?> sep, boolean greedy)
PlusParser(Translet.Parser<D> sub, Translet.Parser<?> sep, boolean greedy)
PriorCoTupleParser(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Constructor called by factory methods.
PriorCoTupleParser(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Constructor called by factory methods.
PriorCoTupleParser(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Constructor called by factory methods.
PriorCoTupleParser(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3, Translet.Parser<D> p4) Constructor called by factory methods.
PriorLimesParser(Translet.Parser<? extends A> p1, Translet.Parser<? extends A> p2, Translet.Parser<? extends A> p3, Translet.Parser<? extends A> p4) Constructor called by factory methods.
PriorLimesParser(Translet.Parser<? extends A> p1, Translet.Parser<? extends A> p2, Translet.Parser<? extends A> p3, Translet.Parser<? extends A> p4) Constructor called by factory methods.
PriorLimesParser(Translet.Parser<? extends A> p1, Translet.Parser<? extends A> p2, Translet.Parser<? extends A> p3, Translet.Parser<? extends A> p4) Constructor called by factory methods.
PriorLimesParser(Translet.Parser<? extends A> p1, Translet.Parser<? extends A> p2, Translet.Parser<? extends A> p3, Translet.Parser<? extends A> p4) Constructor called by factory methods.
ProductParser(int arity, @Opt Object f, @Opt Class<R> cons, Translet.Parser<A> p0, @Opt Translet.Parser<B> p1, @Opt Translet.Parser<C> p2, @Opt Translet.Parser<D> p3, @Opt Translet.Parser<E> p4, @Opt Translet.Parser<F> p5, @Opt Translet.Parser<G> p6, @Opt Translet.Parser<H> p7) Only constructor, called by the sub-classes.
ProductParser(int arity, @Opt Object f, @Opt Class<R> cons, Translet.Parser<A> p0, @Opt Translet.Parser<B> p1, @Opt Translet.Parser<C> p2, @Opt Translet.Parser<D> p3, @Opt Translet.Parser<E> p4, @Opt Translet.Parser<F> p5, @Opt Translet.Parser<G> p6, @Opt Translet.Parser<H> p7) Only constructor, called by the sub-classes.
ProductParser(int arity, @Opt Object f, @Opt Class<R> cons, Translet.Parser<A> p0, @Opt Translet.Parser<B> p1, @Opt Translet.Parser<C> p2, @Opt Translet.Parser<D> p3, @Opt Translet.Parser<E> p4, @Opt Translet.Parser<F> p5, @Opt Translet.Parser<G> p6, @Opt Translet.Parser<H> p7) Only constructor, called by the sub-classes.
ProductParser(int arity, @Opt Object f, @Opt Class<R> cons, Translet.Parser<A> p0, @Opt Translet.Parser<B> p1, @Opt Translet.Parser<C> p2, @Opt Translet.Parser<D> p3, @Opt Translet.Parser<E> p4, @Opt Translet.Parser<F> p5, @Opt Translet.Parser<G> p6, @Opt Translet.Parser<H> p7) Only constructor, called by the sub-classes.
ProductParser(int arity, @Opt Object f, @Opt Class<R> cons, Translet.Parser<A> p0, @Opt Translet.Parser<B> p1, @Opt Translet.Parser<C> p2, @Opt Translet.Parser<D> p3, @Opt Translet.Parser<E> p4, @Opt Translet.Parser<F> p5, @Opt Translet.Parser<G> p6, @Opt Translet.Parser<H> p7) Only constructor, called by the sub-classes.
ProductParser(int arity, @Opt Object f, @Opt Class<R> cons, Translet.Parser<A> p0, @Opt Translet.Parser<B> p1, @Opt Translet.Parser<C> p2, @Opt Translet.Parser<D> p3, @Opt Translet.Parser<E> p4, @Opt Translet.Parser<F> p5, @Opt Translet.Parser<G> p6, @Opt Translet.Parser<H> p7) Only constructor, called by the sub-classes.
ProductParser(int arity, @Opt Object f, @Opt Class<R> cons, Translet.Parser<A> p0, @Opt Translet.Parser<B> p1, @Opt Translet.Parser<C> p2, @Opt Translet.Parser<D> p3, @Opt Translet.Parser<E> p4, @Opt Translet.Parser<F> p5, @Opt Translet.Parser<G> p6, @Opt Translet.Parser<H> p7) Only constructor, called by the sub-classes.
ProductParser(int arity, @Opt Object f, @Opt Class<R> cons, Translet.Parser<A> p0, @Opt Translet.Parser<B> p1, @Opt Translet.Parser<C> p2, @Opt Translet.Parser<D> p3, @Opt Translet.Parser<E> p4, @Opt Translet.Parser<F> p5, @Opt Translet.Parser<G> p6, @Opt Translet.Parser<H> p7) Only constructor, called by the sub-classes.
RepParser(Translet.Parser<D> sub, Translet.Parser<?> sep, boolean greedy, boolean isStar) Constructor only called by factory methods
RepParser(Translet.Parser<D> sub, Translet.Parser<?> sep, boolean greedy, boolean isStar) Constructor only called by factory methods
SequParser(int arity, @Opt Object f, @Opt Class<R> cons, Translet.Parser<A> p0, Translet.Parser<B> p1, Translet.Parser<C> p2, Translet.Parser<D> p3, Translet.Parser<E> p4, Translet.Parser<F> p5, Translet.Parser<G> p6, Translet.Parser<H> p7) This constructor is called by the static factory methods and should normally not be called directly.
SequParser(int arity, @Opt Object f, @Opt Class<R> cons, Translet.Parser<A> p0, Translet.Parser<B> p1, Translet.Parser<C> p2, Translet.Parser<D> p3, Translet.Parser<E> p4, Translet.Parser<F> p5, Translet.Parser<G> p6, Translet.Parser<H> p7) This constructor is called by the static factory methods and should normally not be called directly.
SequParser(int arity, @Opt Object f, @Opt Class<R> cons, Translet.Parser<A> p0, Translet.Parser<B> p1, Translet.Parser<C> p2, Translet.Parser<D> p3, Translet.Parser<E> p4, Translet.Parser<F> p5, Translet.Parser<G> p6, Translet.Parser<H> p7) This constructor is called by the static factory methods and should normally not be called directly.
SequParser(int arity, @Opt Object f, @Opt Class<R> cons, Translet.Parser<A> p0, Translet.Parser<B> p1, Translet.Parser<C> p2, Translet.Parser<D> p3, Translet.Parser<E> p4, Translet.Parser<F> p5, Translet.Parser<G> p6, Translet.Parser<H> p7) This constructor is called by the static factory methods and should normally not be called directly.
SequParser(int arity, @Opt Object f, @Opt Class<R> cons, Translet.Parser<A> p0, Translet.Parser<B> p1, Translet.Parser<C> p2, Translet.Parser<D> p3, Translet.Parser<E> p4, Translet.Parser<F> p5, Translet.Parser<G> p6, Translet.Parser<H> p7) This constructor is called by the static factory methods and should normally not be called directly.
SequParser(int arity, @Opt Object f, @Opt Class<R> cons, Translet.Parser<A> p0, Translet.Parser<B> p1, Translet.Parser<C> p2, Translet.Parser<D> p3, Translet.Parser<E> p4, Translet.Parser<F> p5, Translet.Parser<G> p6, Translet.Parser<H> p7) This constructor is called by the static factory methods and should normally not be called directly.
SequParser(int arity, @Opt Object f, @Opt Class<R> cons, Translet.Parser<A> p0, Translet.Parser<B> p1, Translet.Parser<C> p2, Translet.Parser<D> p3, Translet.Parser<E> p4, Translet.Parser<F> p5, Translet.Parser<G> p6, Translet.Parser<H> p7) This constructor is called by the static factory methods and should normally not be called directly.
SequParser(int arity, @Opt Object f, @Opt Class<R> cons, Translet.Parser<A> p0, Translet.Parser<B> p1, Translet.Parser<C> p2, Translet.Parser<D> p3, Translet.Parser<E> p4, Translet.Parser<F> p5, Translet.Parser<G> p6, Translet.Parser<H> p7) This constructor is called by the static factory methods and should normally not be called directly.
StarParser(Translet.Parser<D> sub, Translet.Parser<?> sep, boolean greedy)
StarParser(Translet.Parser<D> sub, Translet.Parser<?> sep, boolean greedy)
StorageWrapper(Translet.Parser<S> sub)
Store_1(Map<Event,? super S> store, Translet.Parser<S> sub) Only constructor.
Store_M(Multimap<Event,? super S> store, Translet.Parser<S> sub)
TendencyCollector(String[] tendencySymbols, String endSymbol, Translet.Parser<E> domainParser, Translet.Parser<String> additionalTextParser, boolean lastEventIncluded, boolean singletonTendencyAllowed) Only constructor.
TendencyCollector(String[] tendencySymbols, String endSymbol, Translet.Parser<E> domainParser, Translet.Parser<String> additionalTextParser, boolean lastEventIncluded, boolean singletonTendencyAllowed) Only constructor.

Constructor parameters in eu.bandm.tscore.base with type arguments of type Translet.Parser

Constructor and Description
HeadParser(Translet.Parser<A> p1, List<Translet.Parser<?>> seps) Only constructor, setting the first and the following parsers.