This returns length of the unprocessed bufferred part of the sequence, in characters (not bytes).

Its result must not be cached by the client code, because sequenceManager can change (e.g. when reading from standard input, it may be CharSequenceMa

This calls field.get(this) once per field; then it caches the result. @return (cached) result of field.get(this)

Its already-processed parts get discarded (and therefore its indexes change) on call to advance(int). It gets reassigned on calls to swap(), therefo

It searches for an arbitrary pattern. Use this instead with patterns that should only match once or a few times, and that may be located anywhere in

@return output buffer. It gets automatically flushed on calls to advance(int) and swap(). It may get reassigned on calls to swap() and write(int), th

@param optional if true, then this uses "--"+this.name() as the parameter name; otherwise it uses this.name()

@return Application-specific value of the field; null if not known. Used by filters etc. Subclasses should chain their implementation with parent's i

@return Non-null string name only for instances of FieldNonSingleton; null for instances of FieldSingleton.

It writes (sub)sequence of output, its first lengthToWrite characters (if any), and it clears the respective subsequence in output. It may set this.

@param advanceFromLastStart @param run @TODO remove all parameters? @return Whether it read and appended at least 1 character.

This flushes and closes the output stream.

This pre-fetches more characters (if any needed) into this.sequence, so that sequence contains at least maxLengthToBuffer characters. If the input f

Maximum matcheable length, a maximum of maxMatchLength() across all Filter(s) applicable by given run. Only valid once set.

Process given filter(s). Return the last value of pastMatcheable - i.e. the last non-negative value from processAndCheck() of the filter(s). If there

It reads from inputReader and appends to this.input until the total appended length becomes equal to lengthToRead, or until all contents is read. It

Register a list of choices. A commandline value will be matched against toString() of those choices, and a matched choice will be used. Since Run#get(

It rewinds the input. Used mostly when reading application-specific Field<XXX> values. Only used at the beginning of the current stage before genera

Get a StringBuffer for the given sequence, that gets generated before or after the main stream (depending on sequence.beforeMain). These streams are k

This 1. saves the output of the previous stage 2. reloads the output of the previous stage as in input of the new stage 2. 'rewinds' the input to s

This is null or not, depending on the implementation (subclass).

Advance the input buffer, write and clear output buffer. @param advanceFromLastStart Must be positive. @return Whether it read and appended at least 1

@return True if all character(s) were loaded from the file. It may be false even though though there are no more characters in the file - that would

@return true If and only if this is called before FilterBackslashQuote - i.e. return true only in FilterComments.

Put any custom Field entries into run.appFields() as appropriate for version indicated by version().

@return Regular expression pattern, which - will be used with | (pattern to preserve string literals) - works with Pattern.COMMENTS (i.e. whitespaces

@return a new instance on each call, and a mutable one. If implemented in 1st level subclass, then 2nd level and deeper subclasses can override this

@return a new instance on each call, and a mutable one. If implemented in 1st level subclass, then 2nd level and deeper subclasses can override this

It must not depend on end of file (\z). The longest possible match should be not longer than maxMatchLength(). It' not called before #initialise(App,

I don't use Pattern.MULTILINE, because I only register a match starting exactly at my given index, not any further in the input.

It processes the input, available through run.sequenceManager().input(), filtering it, writing/modifying any accepted parts to run.sequenceManager().

This detects whether any subsequence starting right from given index is to be removed or not; if yes, then how long it is. @param index Where to start

This gets Reflections object, which scans the classes in your implementation. Run.process(String[]) uses it to locate custom subclasses of Field clas

@return a new instance on each call, and a mutable one. If implemented in 1st level subclass, then 2nd level and deeper subclasses can override this

@return a new instance on each call, and a mutable one. If implemented in 1st level subclass, then 2nd level and deeper subclasses can override this

@return Replacement pattern that has back-references to groups captured by pattern returned from pattern(), e.g. "$1".

It saves the final output. It also prepends/appends any entries from streams() in their appropriate order.

@return Whether this filters scans the input only, without transforming/deleting/adding anything to the output. Filter.process(App,Run,int) returns a

It writes a completely processed (sub)sequence of the output. To be used by client (Run).

@param fileName It must not be cached between stages of processing, since its length may change. @TODO remove all parameters?

Not public - not to be subclassed outside the package.

Non-public. We only allow two direct subclasses - FieldSingleton and FieldNonSingleton, which both enforce contract of equals(Object) and hashCode().

The name needs to be unique among an actual subclass of FieldNonSingleton.

@param dbs Array of Db that this will work for. @param filtersMatrix Matrix, with array(s) of Filter(s) in the same order as respective Db objects in

@param String givenVersion must not start with 0 (unless it's the only 0 in front of a decimal dot), otherwise if another Version instance is created