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

Packages that use Translet.Parser

Package	Description
eu.bandm.music.applications.deutscheLaute
eu.bandm.music.applications.feldproj
eu.bandm.music.applications.tabstaff	Prototypical realization of the »TabStaff+« design for notating Tactile User Interfaces (TUIs) like the »Ableton Push«, as presented by L.Wilde and C.White on Tenor2024 in Zürich.
eu.bandm.music.demoMetric	Code and additional resources for the jnlp/java-web-start demonstration of the MetricSplit algorithm.
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.applications.deutscheLaute

Fields in eu.bandm.music.applications.deutscheLaute declared as Translet.Parser

Modifier and Type	Field	Description
(package private) final Translet.Parser	Dlaute.p_dots	Parser for duration prolongation dots.
(package private) final Translet.Parser	Dlaute.p_duration	Parser for all variants of durations, including "same duration as predecessor."
(package private) final Translet.Parser	Dlaute.p_prolongate	Let the chord vibrate longer than the next event.

Methods in eu.bandm.music.applications.deutscheLaute that return Translet.Parser

Modifier and Type	Method	Description
(package private) Translet.Parser<?>	Dlaute.p_event(Translet.Parser<Tuple2<Integer,Integer>> stopParser)	Stop parser is supplied *dynamically*, because the "timeless" prelude of each file can re-define the character values.

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

Modifier and Type	Method	Description
(package private) Translet.Parser<?>	Dlaute.p_event(Translet.Parser<Tuple2<Integer,Integer>> stopParser)	Stop parser is supplied *dynamically*, because the "timeless" prelude of each file can re-define the character values.

Uses of Translet.Parser in eu.bandm.music.applications.feldproj

Fields in eu.bandm.music.applications.feldproj declared as Translet.Parser

Modifier and Type	Field	Description
protected final Translet.Parser<?>	FeldmanProjection_n.p_piano	Parser for events in the piano.
protected final Translet.Parser<?>	FeldmanProjection_n.p_register	Parser for the register.
protected final Translet.Parser<?>	FeldmanProjection_n.p_string	Parser for events of the string instruments, with modifiers and no multistops.
protected final Translet.Parser<?>	FeldmanProjection_n.p_stringMult	Parser for events of the string instruments with multi-stops and no modifiers.
static final Translet.Parser<Integer>	FeldmanProjection_n.parse_barNumber	Parser for measure numbers.
static final Translet.Parser<Integer>	Generate_1.parse_barNumber	Parser for measure numbers.
protected final Translet.Parser<?>	Generate_1.parse_values	Parser for the value curve "int? "/" int?".

Methods in eu.bandm.music.applications.feldproj that return Translet.Parser

Modifier and Type	Method	Description
protected final Translet.Parser<?>	FeldmanProjection_n.p_event(Translet.Parser<?> parser)	Generic parser for pauses and "hold" events.

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

Modifier and Type	Method	Description
protected final Translet.Parser<?>	FeldmanProjection_n.p_event(Translet.Parser<?> parser)	Generic parser for pauses and "hold" events.

Uses of Translet.Parser in eu.bandm.music.applications.tabstaff

Fields in eu.bandm.music.applications.tabstaff declared as Translet.Parser

Modifier and Type	Field	Description
(package private) final Translet.Parser<?>	Tabstaff.notationHints	Parser for notation control.
(package private) final Translet.Parser<?>	Tabstaff.parser	Parser for events with pauses and holds
(package private) final Translet.Parser<?>	Tabstaff.parserChange	Parser for the hand and/or finger change
(package private) final Translet.Parser<?>	Tabstaff.parserCoord	Parser for the TUI coordinates: row before column.
(package private) final Translet.Parser<?>	Tabstaff.parserFinger	Parser for the finger indication
(package private) final Translet.Parser<?>	Tabstaff.parserHand	Parser for the hand indication

Methods in eu.bandm.music.applications.tabstaff that return Translet.Parser

Modifier and Type	Method	Description
(package private) final Translet.Parser<?>	Tabstaff.pitchLayout(String lang)	Parser for events in the configuration voice.

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

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

Modifier and Type	Field	Description
(package private) static final Translet.Parser<List<Rational>>	DemoMetric2.parser_durations
(package private) static final Translet.Parser<Boolean>	DemoMetric2.parser_snotp
(package private) static final Translet.Parser<List<Boolean>>	DemoMetric2.parser_snotps
(package private) static final Translet.Parser<Tuple3<Rational,Integer,Double>>	DemoMetric2.parser_tempo
(package private) static final Translet.Parser<List<Tuple3<Rational,Integer,Double>>>	DemoMetric2.parser_tempos
(package private) static final Translet.Parser<List<Rational>>	DemoMetric2.parser_timepoints

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

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

Modifier and Type	Field	Description
static final Translet.Parser<Integer>	Color_rgb_8._2HexDigits	Aux parser which accepts two hexadecimal digits, in upper or lower case.
static final Translet.Parser<Rational>	MeasureCollector.durationParser	Parser for positive (non-null) Rational numbersm used as durations.
(package private) final Translet.Parser<M>	MeasureCollector.metricParser	The parser for the metric specificaion.
(package private) final Translet.Parser<MTreeSpec>	MKinds.mtreeparser
final 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.
final Translet.Parser<?>	MetrumSpecs.parseMetrics
static Translet.Parser<MetrumName>	MetrumName.parser	Evident
(package private) final Translet.Parser<?>	MKinds.parser
static Translet.Parser<QualifiedRational>	QualifiedRational.parser	Parsing "1/4" for sound and "p1/4" for pause.
static final Translet.Parser<RationalDuration>	RationalDuration.parser	Evident
(package private) static final Translet.Parser<ScalaNumAbstrPOcts>	ScalaNumAbstrPOcts.parser
static final Translet.Parser<Tempo>	Tempo.parser	Accepts the standard notation as usual in printed sheet music, e.g.
protected static final Translet.Parser<MTreeSpec>	MTreeSpec.parser_alt
protected static final Translet.Parser<MTreeSpec>	MTreeSpec.parser_concat
static final Translet.Parser<MTreeSpec>	MTreeSpec.parser_summand
static final Translet.Parser<MTreeSpec>	MTreeSpec.parser_timed
(package private) final Translet.Parser<OctaveRegister>	RunningOctaveCollector.parserOctaveRegister	Construction parameter: parser for an explicit octave register.
(package private) final Translet.Parser<P>	RunningOctaveCollector.parserPitchClass	Construction parameter: parser for the pitch class.
static final 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	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 only.
static final 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 final 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 final 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 final 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, String sep)	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 final Translet.Parser<Ornament>	Ornament_JSB_klavierbuechlein.membersParser()	Returns a parser accepting the abstract symbols.
static final Translet.Parser<Ornament>	Ornament_JSB_klavierbuechlein.membersParser(String lang)	Returns a parser in the given (human) langauge.
static final Translet.Parser<Ornament>	Ornament_KdF_special.membersParser()
static final Translet.Parser<Ornament>	Ornament_KdF_special.membersParser(String lang)
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.
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.
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 final Translet.Parser<Duration_calendaric>	Duration_calendaric.parser(boolean lowerLimitForInternals, boolean upperLimitForLeading)	Returns a parser for calendaric time.
Translet.Parser<?>	MeasureCollector.parser()	Delivers the complete parser.
static Translet.Parser<MTreeSpec>	MTreeSpec.parser()
static <OCT extends Entity & Comparable<OCT>, PC extends Entity & PitchIndication & Comparable<PC>> Translet.Parser<PitchAndOctave<OCT,PC>>	PitchAndOctave.parser(Translet.Parser<PC> pc, Translet.Parser<OCT> oct)	Deliver a parser which combines both given parsers.
final Translet.Parser<?>	RunningOctaveCollector.parser()	Return the parser.
static Translet.Parser<ScalaNumAbstrPOcts>	ScalaNumAbstrPOcts.parser(@Opt String lang)	Returns a parser which allows selection by name or by numeric formula.
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	Description
static Translet.Parser<OrnamentUsage>	OrnamentUsage.getParser(Translet.Parser<Ornament> oparser, String sep)	Returns a parser for an ornament code with additional accidentals.
static <OCT extends Entity & Comparable<OCT>, PC extends Entity & PitchIndication & Comparable<PC>> Translet.Parser<PitchAndOctave<OCT,PC>>	PitchAndOctave.parser(Translet.Parser<PC> pc, Translet.Parser<OCT> oct)	Deliver a parser which combines both given parsers.

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

Modifier	Constructor	Description
	MeasureCollector(Translet.Parser<M> metricParser, String openSign_duration, @Opt 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.

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

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

Modifier and Type	Field	Description
(package private) final 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	Description
(package private) final Translet.Parser<String>	MaWiRic.asciiLowerCaseChar	Parser for the switch-off events.
final Translet.Parser<?>	Formplan_fuge.divMul	Parser for the time stretch factor.
final Translet.Parser<?>	Formplan_fuge.einsatz_parser	Topmost parser which accepts themes, counterpoints, pauses, and prolongations.
final Translet.Parser<?>	Formplan_fuge.kpEinsatz	Parser for contrapunctal material.
(package private) final Translet.Parser<?>	MaWiCM.parse_all	Parses all combinations: text plus start fade, or start fade only, or end fade, or "nop".
(package private) final Translet.Parser<?>	GraphartScharen.parse_alpha
(package private) final Translet.Parser<?>	MovingForms.parse_alpha	Parser for the transparency, plus an optional interpolation sign, see MovingForms.parse_ipol.
static final 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) final Translet.Parser<?>	GraphartScharen.parse_color
(package private) final 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) final Translet.Parser<?>	GraphartScharen.parse_dist
(package private) final Translet.Parser<?>	MovingForms.parse_form	Parser for the geometric form.
(package private) final Translet.Parser<String>	GraphartScharen.parse_ipol
(package private) final Translet.Parser<String>	MovingForms.parse_ipol	Parser for an interpolation indication.
protected final Translet.Parser<?>	MlWorat.parse_key	Parse German language tonal key indication.
(package private) final Translet.Parser<?>	GraphartScharen.parse_len
(package private) final Translet.Parser<?>	GraphartScharen.parse_num
(package private) final Translet.Parser<?>	MaWiRic.parse_off	Parser for the switch-off events.
(package private) final Translet.Parser<?>	MaWiRic.parse_on	Parser for the switch-on events.
(package private) final Translet.Parser<?>	GraphartScharen.parse_orient
protected final Translet.Parser<?>	MlWorat.parse_pitch	Format for pitch classes is German language pitch, lilypond octave ad lib.
protected final Translet.Parser<?>	MlWorat.parse_pitches	Parse more than one pitch class, joined by "+".
(package private) final Translet.Parser<?>	GraphartScharen.parse_pos	Parser for the position, which is the main parameter of each voice.
(package private) final 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) final Translet.Parser<?>	MovingForms.parse_size	Parser for the size (non-negative integer), plus an optional interpolation sign, see MovingForms.parse_ipol.
(package private) final Translet.Parser<?>	MaWiCM.parse_start	Parses text and coordinates.
(package private) final Translet.Parser<?>	MaWiCM.parse_startFade	Parses start fade symbol.
protected final Translet.Parser<Tuple2<Integer,BigDecimal>>	MlWorat.parse_time	Format for time points is "movement/measure".
(package private) final Translet.Parser<?>	GraphartScharen.parse_width
protected final Translet.Parser<?>	MwHaiku.parseKateg	Parser for character categories
protected final Translet.Parser<?>	MwHaiku.parseRegister	Parser additional text in the param track named MwHaiku.paramname_register.
protected final Translet.Parser<?>	MwHaiku.parseText	Parser for syllable text.
final 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. (Currently all this information is only partially reflected in the graphical rendering!)
final 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. (Currently all this information is only partially reflected in the graphical rendering!)

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

Modifier and Type	Method	Description
(package private) Translet.Parser<?>	Score_cwn.articulationAndOrnamentParser(Map<Event,Artikulation> mapArtic, Map<Event,Ornament> mapOrn)

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

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

Modifier and Type	Class	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.DisjunctionParser<R>	Common superclass for Parsers which accept one of many alternatives.
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 final class	Translet.Recursive<R>	A placeholder which can be embedded 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_I<S>	Storing operator which can store multiple (>1) values per key, preserving the sequential order in the source.
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	Description
(package private) final Translet.Parser<String>	GroupCollector.additionalTextParser	The parser for the additional opening and closing text.
(package private) final Translet.Parser<String>	TendencyCollector.additionalTextParser	Parser for the additional text.
(package private) final Translet.Parser<E>	TendencyCollector.domainParser	Parser for the parameter values.
static final Translet.Parser<String>	TransletLib.doubleQuotedTextParser_noDoubleQuotesContained	Parser which accepts any text which is framed by doublequotes and does not contain doublequotes nor backslashes.
(package private) static final Translet.Parser<String>	Translet.eps	A parser matching an empty character sequecen in the input.
static final Translet.Parser<String>	TransletLib.identifier_javalike	Parser which accepts any text which fulfills the rules for Java identifiers.
(package private) final Translet.Parser<String>	GroupCollector.identParser	The parser for the groups name.
protected final Translet.Parser<A>	Translet.ProductParser.p0	Parser of the 0th subresult.
protected Translet.Parser<A>	Translet.CoTupleParser.p1
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<? extends A>	Translet.LimesParser.p1
protected final Translet.Parser<B>	Translet.ProductParser.p1	Parser of the 1st subresult.
protected Translet.Parser<B>	Translet.CoTupleParser.p2
protected Translet.Parser<? extends A>	Translet.LimesParser.p2
protected final Translet.Parser<C>	Translet.ProductParser.p2	Parser of the 2nd subresult.
protected Translet.Parser<C>	Translet.CoTupleParser.p3
protected Translet.Parser<? extends A>	Translet.LimesParser.p3
protected final Translet.Parser<D>	Translet.ProductParser.p3	Parser of the 3rd subresult.
protected Translet.Parser<D>	Translet.CoTupleParser.p4
protected Translet.Parser<? extends A>	Translet.LimesParser.p4
protected final Translet.Parser<E>	Translet.ProductParser.p4	Parser of the 4th subresult.
protected final Translet.Parser<F>	Translet.ProductParser.p5	Parser of the 5th subresult.
protected final Translet.Parser<G>	Translet.ProductParser.p6	Parser of the 6th subresult.
protected final Translet.Parser<H>	Translet.ProductParser.p7	Parser of the 7th subresult.
static final Translet.Parser<String>	TransletLib.parse_integer_nonNeg	Parser accepting string values "0" or any positive integer, no leading zeros.
static final Translet.Parser<String>	TransletLib.parse_integer_positive	Parser accepting string values of any positive integer, no leading zeros.
static final Translet.Parser<Double>	TransletLib.parseAndPack_double	Parser for floating point numbers (but not in "E" notation or with "_")
static final 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 final 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 final 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 final Translet.Parser<Rational>	TransletLib.parseAndPack_rational_optionalSlash_nonNeg	Parser for rational numbers in slash notation.
static final Translet.Parser<Rational>	TransletLib.parseAndPack_rational_withSlash_nonNeg	Parser for rational numbers in slash notation.
static final Translet.Parser<Rational>	TransletLib.parseAndPack_rational_withSlash_positive	Parser for rational numbers in slash notation.
(package private) final 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.
protected Translet.Parser<D>	Translet.OptionParser.sub	The sub-parser to parse or ski.
protected @Opt Translet.Parser<R>	Translet.Recursive.sub	The parser to call whenever this parser shall become active.
protected Translet.Parser<D>	Translet.RepParser.sub	The repeated sub-parser.
protected Translet.Parser<S>	Translet.StorageWrapper.sub
(package private) final Translet.Parser<R>	TransletLib._TEST.sub	Evident.
protected final 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	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	Description
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<E>	Entity.getParser(String language)	Gets the default parser for this entity, which accepts the name in the given language only.
Translet.Parser<E>	EntityCatalog.getParser()	Get a parser which accepts the names of the entities in the default 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<?>	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<?>	TendencyCollector.getParser()	Returns the parser which realizes the combination of parameters set when constructing this instance.
Translet.Parser<D>	Translet.Parseable.getParser()	Deliver tscore/translet data parser, not specifying a human 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 final Translet.Parser<Boolean>	TransletLib.keywordPlusMinus(String key)	Parser which accepts a particular keyword followed by "+"/"-" for true and false, resp.
static final <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<D>	Translet.OptionParser.stripOpt()
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()
static <T, R> Translet.Parser<T>	TransletLib.toConst(Translet.Parser<R> condition, T result)
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	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 <R, S> void	Translet.disj_testOneBranch(Translet.DisjunctionParser<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.HeadParser<D>	Translet.HEAD(Translet.Parser<D> sub, Translet.Parser<?>... subs)	Factors method to create one head parser.
static <D> Translet.Store_I<D>	Translet.INCSTORE(Map<Event,List<D>> store, Translet.Parser<D> sub)	Factory method for a store with a list of values per key.
static final <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, 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, 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, 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,@Opt String> check_oneLine, @Opt Function3<Comparator<? super T>,T,T,@Opt String> check_twoLines)	Parse all TpTops into some internal numeric format "T" and store them.
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, 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, 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> 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, 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, 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, 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> 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, 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, 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, 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> 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 <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(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, 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, 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, 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, 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, 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, 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 <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, 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, 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, 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 <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, 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, 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, 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> 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(Function<A,R> f, Translet.Parser<A> p1)	Factory method for a singleton sequence, applying the given function to get the 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(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_M<D>	Translet.STORE(Multimap<Event,? super D> store, Translet.Parser<D> sub)	Factory method for a store with multiple values per key.
static <D> Translet.Store_1<D>	Translet.STORE(Map<Event,? super D> store, Translet.Parser<D> sub)	Factory method for a store with single 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, Translet.Parser<R> sub)
static <R> TransletLib._TEST<R>	TransletLib.TEST(Predicate<R> test, String name, 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.
static <T, R> Translet.Parser<T>	TransletLib.toConst(Translet.Parser<R> condition, T result)
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	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.DisjunctionParser<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

Modifier	Constructor	Description
	_TEST(Predicate<R> test, String name, Translet.Parser<R> sub)	Only constructor, called by factory methods.
protected	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.
	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 lenientNesting, boolean sameNameNestingAllowed, boolean sameNameMeansSameSet, boolean openCloseImmediateAllowed, boolean shortcutClose)	Only constructor, setting all configuration parameters.
	HeadParser(Translet.Parser<A> p1, Translet.Parser<?>[] seps)	Only constructor, setting the first and the trailing parsers.
	HeadParser(Translet.Parser<A> p1, List<Translet.Parser<?>> seps)	Only constructor, setting the first and the following 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.
	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.
	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.
	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.
	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.
protected	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.
protected	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.
	StarParser(Translet.Parser<D> sub, Translet.Parser<?> sep, boolean greedy)
protected	StorageWrapper(Translet.Parser<S> sub)
	Store_1(Map<Event,? super S> store, Translet.Parser<S> sub)	Only constructor.
	Store_I(Map<Event,List<S>> store, Translet.Parser<S> sub)
	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.

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

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