Uses of Class
eu.bandm.tscore.base.Translet.Parser
Package
Description
Prototypical realization of the "TabStaff+" design for
notating Tactie User Interfaces (TUIs) like the "Ableton Push",
as presented by L.Wilde and C.White on Tenor2024 in Zürich.
Code and additional resources for the jnlp/java-web-start demonstration of the
MetricSplit algorithm.
All fundamental entities for modeling music.
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).
Top-level data structures, modelling different score formats, combining the
entities defined in lower level packages.
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
Modifier and TypeFieldDescription(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.Modifier and TypeMethodDescription(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.Modifier and TypeMethodDescription(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
Modifier and TypeFieldDescriptionprotected 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?
".Modifier and TypeMethodDescriptionprotected final Translet.Parser<?>
FeldmanProjection_n.p_event
(Translet.Parser<?> parser) Generic parser for pauses and "hold" events.Modifier and TypeMethodDescriptionprotected 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
Modifier and TypeFieldDescription(package private) final Translet.Parser<?>
Tabstaff.microLayout
Parser for events in the configuration voice.(package private) final Translet.Parser
TabstaffAccordic.microLayout
(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
TabstaffAccordic.parser
Parser for events with pauses and prolongation.(package private) final Translet.Parser<?>
Tabstaff.parser_coord
Parser for the TUI coordinates: row before column.(package private) final Translet.Parser<?>
Tabstaff.parser_finger
Parser for the finger indication(package private) final Translet.Parser<?>
Tabstaff.parser_hand
Parser for the hand indication -
Uses of Translet.Parser in eu.bandm.music.demoMetric
Modifier and TypeFieldDescription(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
DemoMetric2.parser_tempos
(package private) static final Translet.Parser<List<Rational>>
DemoMetric2.parser_timepoints
-
Uses of Translet.Parser in eu.bandm.music.entities
Modifier and TypeFieldDescriptionstatic 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
Evidentstatic 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.Modifier and TypeMethodDescriptionprotected 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 final Translet.Parser<ClefUsage>
ClefUsage.fullParser
(String lang) Accepts generic version (seeClefUsage.genericParser(String,String)
) OR the predefined standard clef usages, both in the given language, withClefUsage.default_prefix
.static final Translet.Parser<ClefUsage>
ClefUsage.fullParser
(String lang, String prefix) Accepts generic version (seeClefUsage.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 (seeClefUsage.genericParser(String,String)
) in the given language, withClefUsage.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) Returns a parser for an ornament code with additional accidentals.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 theColor_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 theColor_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>
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.MeasureCollector.parser()
Delivers the complete parser.static Translet.Parser<MTreeSpec>
MTreeSpec.parser()
final Translet.Parser<?>
RunningOctaveCollector.parser()
Return the parser.FunctionalPitchModOctave.upperInitialParser
(String lang) Deliver a parser with upper initial characters, in the given language.Modifier and TypeMethodDescriptionstatic Translet.Parser<OrnamentUsage>
OrnamentUsage.getParser
(Translet.Parser<Ornament> oparser) Returns a parser for an ornament code with additional accidentals.ModifierConstructorDescriptionMeasureCollector
(Translet.Parser<M> metricParser, String openSign_duration, @Opt String closeSign_duration) Initial configuration of a Collector.MKinds
(MessageReceiver<SimpleMessage<eu.bandm.tools.util.xml.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
Modifier and TypeFieldDescription(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
Modifier and TypeFieldDescription(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
Parser which accepts theme and counterpoints.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, seeMovingForms.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 byColor_rgb_8.parser(String)
, plus an optional interpolation sign, seeMovingForms.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 the 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, seeMovingForms.parse_ipol
.(package private) final Translet.Parser<?>
MovingForms.parse_size
Parser for the size (non-negative integer), plus an optional interpolation sign, seeMovingForms.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 categoriesprotected final Translet.Parser<?>
MwHaiku.parseRegister
Parser additional text in the param track namedMwHaiku.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.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. -
Uses of Translet.Parser in eu.bandm.tscore.base
Modifier and TypeClassDescriptionstatic class
Implements a greedy longest prefix match from a collection of strings.static class
Parser for a simple string constant which must appear verbatim, as is.static class
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 aCoTuple
(ORn and PRIORn).static class
Common superclass for Parsers which accept one of many alternatives.static class
Accepts a sequence "A,B,C", where only the middle parsing/processing result is stored as result in theTranslet.State
object, discarding the frame.static class
Accepts a sequence "A,B,..", where only the very first parsing/processing result is stored as result in theTranslet.State
object, discarding all the tail.static class
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
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
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 ofTranslet.ProductParser
which accepts all permutations of sub-parsers.static class
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
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
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
Common superclass forTranslet.StarParser
andTranslet.PlusParser
.static class
Translet.SequParser<R,
A, B, C, D, E, F, G, H> Variant ofTranslet.ProductParser
which accepts a certain sequence of sub-parsers.static class
Repetition parser which allows empty list as result.static class
Common superclass of the storing oeprators.static class
Storing operator which only one(1) value per key.static class
Storing operator which can store multiple (>1) values per key, preserving the sequential order in the source.static class
Storing operator which can store multiple (>1) values per key.static class
Filters the result of its sub-parser by an explicit Java-encoded boolean predicate.Modifier and TypeFieldDescription(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.(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 toInteger
value.static final Translet.Parser<Integer>
TransletLib.parseAndPack_integer_positive
Parser accepting string values of any positive integer, no leading zeros, and converting it toInteger
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 toInteger
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.Modifier and TypeFieldDescriptionprotected 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.Modifier and TypeMethodDescriptionEntity.getParser()
Gets the default parser for this entity, which accepts the name in the default language, as specified byEntityCatalog.getDefaultLanguage()
Gets the default parser for this entity, which accepts the name in the given language.EntityCatalog.getParser()
Get a parser which accepts the names of the entities in the default language.Get a parser which accepts the names of the entities in the given language and returns the possibly found Entity as its value.EventPatternDistributor.getParser()
GroupCollector.getParser()
Get the parser which accepts open group, close group, and singleton add parameter texts, converts these into group events and stores these.TendencyCollector.getParser()
Returns the parser which realizes the combination of parameters set when constructing this instance.Translet.Parseable.getParser()
Deliver tscore/translet data parser, not specifying a human 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, orTranslet.na
, it the index is too large.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.OptionParser.stripOpt()
Translet.Parser.stripOpt()
Returns the first nested parser which is NOT anTranslet.OptionParser
.Translet.Recursive.stripOpt()
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).Modifier and TypeMethodDescriptionprotected 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<eu.bandm.tools.util.xml.XMLDocumentIdentifier>> msg, PrintStream displayStream, CatalogByString cat, List<String> prefs, eu.bandm.tools.location.LocationMap<Object, eu.bandm.tools.util.xml.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<eu.bandm.tools.util.xml.XMLDocumentIdentifier>> msg, Vox v, String trackname, String separator, Translet.Parser<?> parser, Modifiers react) Applies a certainTranslet.Parser
parser to the given parameter track.static <T> void
Util.parseTpTops
(MessageReceiver<SimpleMessage<eu.bandm.tools.util.xml.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.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.Translet.PERM
(Translet.Parser<A> p1, Translet.Parser<B> p2) Factory method for a permutation of two, creating no result.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.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.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.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.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.Translet.SEQU
(Translet.Parser<A> p1, Translet.Parser<B> p2) Factory method for a sequence of two, creating no result.Translet.SEQU
(Translet.Parser<A> p1, Translet.Parser<B> p2, Translet.Parser<C> p3) Factory method for a sequence of three, creating no result.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.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.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.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.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.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 asTranslet.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<eu.bandm.tools.util.xml.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.withSeparator
(Translet.Parser<?> sep) Set the separator which must appear between two non-epsilon-consuming applications of the sub-parsers.Modifier and TypeMethodDescriptionprotected 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, orTranslet.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).ModifierConstructorDescriptionOnly 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<eu.bandm.tools.util.xml.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 methodsSequParser
(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) Only constructor.TendencyCollector
(String[] tendencySymbols, String endSymbol, Translet.Parser<E> domainParser, Translet.Parser<String> additionalTextParser, boolean lastEventIncluded, boolean singletonTendencyAllowed) Only constructor.ModifierConstructorDescriptionHeadParser
(Translet.Parser<A> p1, List<Translet.Parser<?>> seps) Only constructor, setting the first and the following parsers.