StringPart

java.lang.Object
- org.vishia.util.StringPart

All Implemented Interfaces:

java.lang.CharSequence, java.lang.Comparable<java.lang.CharSequence>, java.lang.Iterable<StringPart>

Direct Known Subclasses:

StringPartScan
```
public class StringPart
extends java.lang.Object
implements java.lang.CharSequence, java.lang.Comparable<java.lang.CharSequence>, java.lang.Iterable<StringPart>
```
The StringPart class represents a flexible valid part of a character string which's spread is changeable. It may be seen as an alternative to the standard String for the capability to build a String.substring(int).
- 1. The substring or Part of the String can be build with some operations, seek(CharSequence, int), lento(CharSequence) etc.
- 2. This class represents a Part of the String which is able to change.
- 3. The operation to build a Part does not build an independent String, but refers inside the given String.
- 4. The Part is able to build from any CharSequence, especially from a StringBuilder or from any char[]-Array.
Calculation time and memory effect:
The 3. minute affects the calculation time for extensive using of parts of a String. The String.substring(int) method of standard Java till Version 6 builds a substring using and references the stored parent String. It was a cheap operation in calculation time.

In Java version 7 this behavior was changed. Up to version 7 a substring builds an new buffer for the substring in the heap. The advantage is: If a long String exists firstly, then some substrings are build, and the firstly long String is not used anymore, the memory of the long String can garbaged now. The application does not need yet memory for the originally long String, only the typical short substrings are stored in the heap. For applications, which builds some short substrings from a long parent String, it saves memory.

But if substrings are need extensively from one long String, to search somewhat etc, The creation of new memory for any substring may be an expensive operation. This class works with the given String, builds parts of the string with indices, and does not need memory for any sub part.

Multithreading, persistence of Strings:
A StringPart depends of its parent CharSequence. That CharSequence maybe a String, which is persistent. But that CharSequence maybe a StringBuilder or any other volatile storage. Changing the CharSequence my disturb operations of the StringPart. Therefore the parent CharSequence should be notice. Is it changed?

If a Part should be stored persistently, one can use a toString() method of any returned CharSequence for example getCurrentPart().toString(). This builds a persistent String which can be stored and used independent of all others.

But if the Part of String is used in the same thread, not stored, and another thread does not disturb the content of the StringPart's parent CharSequence (which may be usual), the waiver to build a persistent String may save a little bit of calculation time. A method which accepts a CharSequence as parameter should not store that in suggestion of persistence. For example StringBuilder.append(CharSequence) uses a non-persistent character sequence and adds it to its own buffer.

Access as CharSequence:
This class is a CharSequence. The sequence of chars is represented by the getCurrentPart(). The method length() returns the length of the current part. The method charAt(int) returns the characters from beginLast. The method subSequence(int, int) builds a StringPart.Part which refers the sub sequence inside the content.

Principles of operation:
The StringPart class is associated to any CharSequence. Additionally 4 Parameters determine the actual part of the String and the limits of changing of the actual part. The followed image is used to explain the spread of a part:
```
 abcdefghijklmnopqrstuvwxyz  Sample of the whole associated String
 =====================     The === indicates the maximal part
   -----------             The --- indicates the valid part before some operation
         +++++             The +++ indicates the valid part after some operation
 
```
The actual part of the string is changeable, without building a new substring. So some operations of seeking and scanning are offered.

Types of Methods:
- assign: assigns a new parent string: assign(CharSequence), like constructor
- seek: changes the start position of the actual (current) string part, do not change the end of the actual part, from there, seek changes the length. Seek returns this, so concatenation of method calls is possible.
  - setParttoMax(): Sets the current part of the String to the whole String. For new search operations.
  - seekPos(int), seekPosBack(int): Sets the current part begin forward, for example seek(1) to skip over one character
  - seek(char, int), seek(CharSequence, int): Searches a character or a CharSequence, sets the begin of the current part to it.
  - seekAnyChar(CharSequence), seekBackToAnyChar(CharSequence): Searches any of some given characters.
  - seek(CharSequence, int), seekBackward(CharSequence): Searches any of some given characters.
  - seekAnyString(CharSequence[], int[]): Searches any of some given character sequences.
  - seekNoWhitespace(), seekNoWhitespaceOrComments(): skip over all white spaces, maybe over comments
  - seekNoChar(CharSequence) skip over all given characters
  - seekBegin() Expands the spread starting from the most left position (the maximal part)
- lento: changes the end of the actual string part.
  - lento(int): set a length of the valid part
  - lento(char), lento(CharSequence, int): length till a end character or end string
  - lentoAnyChar(CharSequence, int), lentoAnyString(CharSequence[], int): length till one of some given end characters or Strings
  - lentoAnyCharOutsideQuotion(CharSequence, int): regards CharSequence in quotation as non-applying.
  - #lentoAnyNonEscapedChar(CharSequence, int): regards characters after a special char as non-applying.
  - #lentoAnyStringWithIndent(CharSequence[], CharSequence, int, StringBuilder): regards indentation typically for source files.
  - #lentoIdentifier(), #lentoIdentifier(CharSequence, CharSequence): accepts identifier
- firstlineMaxpart(), nextlineMaxpart(): line processing. Each line can be individually evaluated or scanned.
- get: Gets an content without changing.
  - #getCurrentPart(): The valid part as CharSequence, use toString() to transform to a persistent String.
  - #getCurrent(int): Requested number of chars from start of the current part, for tests and debugging.
  - #getLastPart(): Last valid part before the last seek or scan.
- indexOf: search any one in the valid part.
  - indexEndOfQuotation(char, char, int, int) etc.
- See StringPartScan for further scan functions.
- See StringPartAppend, StringPartFromFileLines for complete processing.
- See StringFunctions for basic operations.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`(package private) class`	`StringPart.Iter`
`static class`	`StringPart.Part` This class presents a part of the parent CharSequence of this class.

Field Summary

Fields
Modifier and Type	Field and Description
`protected int`	`absPos0` The absolute position of character in the input file of content[0] It is used for `StringPartFromFileLines` or adequate reader.
`protected boolean`	`bCurrentOk` false if current scanning is not match
`protected int`	`begiMin` The most left possible start position.
`protected int`	`begin` The actual start position of the valid part.
`protected int`	`beginLast` Borders of the last part before calling of scan__(), seek__(), lento__().
`protected boolean`	`bFound` True if the last operation of lento__(), seek etc. has found anything.
`protected int`	`bitMode` Some mode bits.
`protected boolean`	`bStartScan` If true, than all idxLastScanned... are set to 0, it is after `#scanOk()` or after `#scanStart`
`protected java.lang.CharSequence`	`content` The referenced string.
`protected int`	`end` The actual exclusive end position of the valid part.
`protected int`	`endLast` Borders of the last part before calling of scan__(), seek__(), lento__().
`protected int`	`endMax` The most right possible exclusive end position.
`static int`	`mSeekBack` Flag to force seeking backward from the end position.
`private static int`	`mSeekBackward_` Flag bit to force seeking backward.
`static int`	`mSeekCheck` If this bit is set on seek, the position remains if the seek is not successfully (if `found()` returns false).
`static int`	`mSeekEnd` Flag to force setting the start position after the seeking string.
`static int`	`mSeekToLeft` Flag to force seeking backward from the start position.
`private static int`	`mSeekToLeft_` Flag bit to force seeking left from start (Backward).
`protected static int`	`mSkipOverCommentInsideText_mode` Bit in mode.
`protected static int`	`mSkipOverCommentToEol_mode` Bit in mode.
`protected static int`	`mSkipOverWhitespace_mode` Bit in mode.
`private int[]`	`posRewind` Strategy for buffer shifting: `begiMin` should be existing always.
`protected static java.lang.String`	`sCheckNewline`
`protected static java.lang.String`	`sCheckWhitespaces`
`(package private) java.lang.String`	`sCommentEnd` The string defined the end of comment inside a text.
`(package private) java.lang.String`	`sCommentStart` The string defined the start of comment inside a text.
`(package private) java.lang.String`	`sCommentToEol` The string defined the start of comment to end of line
`static int`	`seekBack`
`static int`	`seekEnd`
`static int`	`seekNormal` Flag to force seeking forward.
`static int`	`seekToLeft`
`(package private) java.lang.String`	`sFile` The file from which the StringPart was build.
`static java.lang.String`	`sVersion` Version, history and license.

Constructor Summary

Constructors
Constructor and Description
`StringPart()` Creates a new empty StringPart without an associated String.
`StringPart(java.lang.CharSequence src)` Creates a new StringPart, with the given content from a String.
`StringPart(java.lang.CharSequence src, int start, int end)` Builds a StringPart which uses the designated part of the given src.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`protected char`	`absCharAt(int index)`
`protected java.lang.String`	`absSubString(int from, int to)` Returns a String from absolute range.
`StringPart`	`assign(java.lang.CharSequence src)` Sets the content to the given string, forgets the old content.
`StringPart`	`assign(StringPart src)` Sets the StringPart with the same String object as the given StringPart, forgets the old content.
`StringPart`	`assignFromEnd(StringPart src)` Sets the content of the StringPart , forgets the old content.
`StringPart`	`assignReplaceEnv(java.lang.StringBuilder input)` Sets the content to the given string, forgets the old content.
`char`	`charAt(int index)` This method returns the characters of the current part.
`boolean`	`checkCharAt(int pos, java.lang.String chars)` Checks whether the char at pos in the current part is one of chars.
`void`	`clean()` Cleans the instance.
`void`	`close()` Deprecated.
`int`	`compareTo(java.lang.CharSequence str2)` Compares the current part with the given str2
`java.lang.String`	`contentTillSpaceEndOrQuotation(java.lang.String sQuotationStartEnd, char escapeChar)` Sets the current part either to the whole quotation if it it starts with the quotation char, or sets it till the first space, or till end if the space is not found.
`java.lang.String`	`debugString()` Returns a debug information of the content of the StringPart.
`boolean`	`equals(java.lang.CharSequence sCmp)` Compares the Part of string with the given string
`StringPart`	`firstlineMaxpart()` Sets the current and the maximal part from position 0 to the first end line character.
`boolean`	`found()` Returns true, if the last called seek__(), lento__() or skipWhitespaceAndComment() operation founds the requested condition.
`StringPart`	`fromEnd()` Sets the start of the part to the exclusively end, set the end to the end of the content.
`java.lang.CharSequence`	`getCharSequenceRange(long from, long to)` Returns the current CharSequence between both given absolute positions.
`java.lang.CharSequence`	`getCurrent()` Gets the chars from current Position.
`java.lang.CharSequence`	`getCurrent(int nChars)` Gets the next chars from current Position.
`char`	`getCurrentChar()` Gets the next char at current Position.
`int`	`getCurrentColumn()` Gets the current position in line (column of the text).
`StringPart.Part`	`getCurrentPart()` Returns the actual part of the string.
`java.lang.CharSequence`	`getCurrentPart(int maxLength)` Returns the actual part of the string.
`long`	`getCurrentPosition()` Gets the current position, useable for rewind.
`java.lang.String`	`getInputfile()` This method may be overridden to return the file which is used to build this Stringpart.
`java.lang.CharSequence`	`getLastPart()` Returns the last part of the string before any seek or scan operation.
`int`	`getLenCurrent()`
`int`	`getLineAndColumn(int[] column)` Get the Line number and the column of the begin position.
`StringPart.Part`	`getPart(int fromPos, int nrofChars)` Retrurn the part from start to end independent of the current positions.
`int`	`indexEndOfQuotation(char cEndQuotion, char transcriptChar, int fromWhere, int maxToTest)` Searches the end of a quoted string.
`int`	`indexEndOfQuotation(char cEndQuotion, java.lang.String sInnerQuotionChars, char transcriptChar, int fromWhere, int maxToTest)` Searches the end of a quoted string.
`int`	`indexEndOfQuotion(char cEndQuotion, int fromWhere, int maxToTest)` Searches the end of a quoted string.
`int`	`indexOf(char ch)` Returns the position of the char within the part, returns -1 if the char is not found in the part.
`int`	`indexOf(char ch, int fromIndex)` Returns the position of the char within the part, started inside the part with fromIndex, returns -1 if the char is not found in the part started from 'fromIndex'.
`int`	`indexOf(java.lang.CharSequence sCmp)` Returns the position of the string within the part.
`int`	`indexOf(java.lang.CharSequence sCmp, int fromIndex, int maxToTest)` Returns the position of the string within the part.
`int`	`indexOfAnyChar(java.lang.CharSequence sChars)` Returns the position of one of the chars in sChars within the part, returns -1 if the char is not found in the actual part.
`int`	`indexOfAnyChar(java.lang.CharSequence sChars, int fromWhere, int maxToTest)` Searches any char contained in sChars in the current part Example: The given string in the current part is abc end:zxy The calling is indexOfAnyChar("xyz", 0, 20); The result is 8 because the character 'z' is found first as the end char.
`int`	`indexOfAnyChar(java.lang.CharSequence sChars, int fromWhere, int maxToTest, char transcriptChar, char quotationStartChar, char quotationEndChar)` Returns the position of one of the chars in sChars within the part, started inside the part with fromIndex, returns -1 if the char is not found in the part started from 'fromIndex'.
`int`	`indexOfAnyCharOutsideQuotation(java.lang.CharSequence sChars, java.lang.String sPossibleQuotChars, char transliterationChar, int fromWhere, int maxToTest)` Searches any char contained in sChars in the current part but skip over quotations while testing.
`int`	`indexOfAnyCharOutsideQuotion(java.lang.CharSequence sChars, int fromWhere, int maxToTest)` Searches any char contained in sChars in the current part but skip over quotations while testing.
`int`	`indexOfAnyString(java.lang.CharSequence[] listStrings, int fromWhere, int maxToTest, int[] nrofFoundString, java.lang.String[] foundString)` Returns the position of one of the chars in sChars within the part, started inside the part with fromIndex, returns -1 if the char is not found in the part started from 'fromIndex'.
`int`	`indexOfNoChar(java.lang.CharSequence sChars)` Returns the position of the first char other than the chars in sChars within the part, returns -1 if all chars inside the parts are chars given by sChars.
`int`	`indexOfNoChar(java.lang.CharSequence sChars, int fromWhere)` Returns the position of the first char other than the chars in sChars within the part, started inside the part with fromIndex, returns -1 if all chars inside the parts started from 'fromIndex' are chars given by sChars.
`java.util.Iterator<StringPart>`	`iterator()`
`int`	`lastIndexOfAnyChar(java.lang.CharSequence sChars, int fromWhere, int maxToTest)` Returns the last position of one of the chars in sChars within the part of actual part from (fromIndex) to (fromIndex+maxToTest) or returs -1 if the char is not found in this part.
`StringPart`	`len0end()` Sets the length to the end of the maximal part if the length is 0.
`StringPart`	`lenBacktoNoChar(java.lang.CharSequence sChars)` Posits the end of the part before all of the chars given in the parameter string.
`StringPart`	`lenBacktoNoWhiteSpaces()` Trims all trailing whitespaces within the part.
`int`	`length()`
`int`	`lengthMaxPart()` Returns the lenght of the maximal part from current position.
`StringPart`	`lento(char cc)` Sets the end position of the part of string to exclusively the char cc.
`StringPart`	`lento(java.lang.CharSequence ss)` Sets the endposition of the part of string to exclusively the given string.
`StringPart`	`lento(java.lang.CharSequence ss, int mode)` Sets the endposition of the part of string to exclusively the given string.
`StringPart`	`lento(int len)` Deprecated. use lenToPos, more clarify, especially for JZcmd
`StringPart`	`lentoAnyChar(java.lang.CharSequence sChars)` Sets the length of the current part to any char content in sChars (terminate chars).
`StringPart`	`lentoAnyChar(java.lang.CharSequence sChars, int maxToTest)` Sets the length of the current part to any char content in sChars (terminate chars).
`StringPart`	`lentoAnyChar(java.lang.CharSequence sChars, int maxToTest, int mode)` Sets the length of the current part to any char content in sChars (terminate chars).
`StringPart`	`lentoAnyCharOutsideQuotation(java.lang.CharSequence sChars, java.lang.String sCharQuot, char cSubscribe, int maxToTest)`
`StringPart`	`lentoAnyCharOutsideQuotion(java.lang.CharSequence sChars, int maxToTest)` Sets the length of the current part to any char content in sChars (terminate chars), but skip over quotions while testing.
`StringPart`	`lentoAnyNonEscapedChar(java.lang.CharSequence sCharsEnd, int maxToTest)` Sets the len to the first position of any given char, but not if the char is escaped.
`StringPart`	`lentoAnyString(java.lang.CharSequence[] strings, int maxToTest)` Sets the length of the current part to any terminate string given in sString.
`StringPart`	`lentoAnyString(java.lang.CharSequence[] strings, int maxToTest, int mode)` Sets the length of the current part to any terminate string given in sString.
`void`	`lentoAnyStringWithIndent(java.lang.CharSequence[] strings, java.lang.CharSequence sIndentChars, int maxToTest, java.lang.StringBuilder buffer)` Sets the length of the current part to any terminate string given in sString.
`StringPart`	`lentoIdentifier()` Sets the endposition of the part of string to the end of the identifier which is beginning on start.
`StringPart`	`lentoIdentifier(java.lang.CharSequence additionalStartChars, java.lang.CharSequence additionalChars)` Sets the endposition of the part of string to the end of the identifier which is beginning on start.
`StringPart`	`lentoLineEnd()` Sets the length of the current part to the end of the current line.
`StringPart`	`lentoNonEscapedString(java.lang.CharSequence sEnd, int maxToTest)` Sets the length of the valid part to the first position of the given String, but not if the String is escaped.
`StringPart`	`lentoNumber(boolean bHex, int[] dst, java.lang.String separatorChars)` Sets the end position of the part of string to the end of the number which is beginning on start.
`StringPart`	`lentoPos(int len)` Sets the endposition of the part of string to the given chars after start.
`StringPart`	`lentoQuotionEnd(char sEndQuotion, int maxToTest)` Sets the length of the current part to the end of the quotion.
`StringPart`	`line()` Sets the current Part from the current position to exactly one line.
`StringPart`	`nextlineMaxpart()` Sets the current and the maximal part from the current end to the next line end character.
`static java.lang.CharSequence`	`replace(java.lang.CharSequence src, java.lang.CharSequence[] placeholder, java.lang.CharSequence[] value, java.lang.StringBuilder dstArg)` Replaces up to 20 placeholder with a given content.
`StringPartScan`	`scan()` This routine provides the this-pointer as StringPartScan in a concatenation of StringPartBase-invocations.
`StringPart`	`seek(char cSeek, int mode)` Searchs the given character inside the valid part, posits the begin of the part to the begin of the searched char.
`StringPart`	`seek(java.lang.CharSequence sSeek)` Searchs the given String inside the valid part, posits the begin of the part to the begin of the searched string.
`StringPart`	`seek(java.lang.CharSequence sSeek, int mode)` Common seek operation with several modes in flags.
`StringPart`	`seek(int nr)` Deprecated. use `seekPos(int)`
`StringPart`	`seekAfterNewline()`
`StringPart`	`seekAnyChar(java.lang.CharSequence chars)` Seeks to one of the characters contained in chars, starting from the begin of the current part.
`StringPart`	`seekAnyString(java.lang.CharSequence[] strings, int[] nrofFoundString)` Searchs the given CharSequence inside the valid part, posits the begin of the part to the begin of the searched string.
`StringPart`	`seekBackToAnyChar(java.lang.CharSequence chars)` Seeks back from the current end to one of the characters contained in chars, starting from the end of the current part.
`StringPart`	`seekBackward(java.lang.CharSequence sSeek)` Seeks back form the current end to the end of the given String starting from the end of the current part.
`StringPart`	`seekBegin()` Displaces the begin of the part to the leftest possible begin.
`StringPart`	`seekCheck(java.lang.CharSequence sSeek)` Seeks to the given CharSequence, result is left side of the string.
`StringPart`	`seekCheckEnd(java.lang.CharSequence sSeek)` Seeks to the given CharSequence, start position is after the string.
`StringPart`	`seekEnd(java.lang.CharSequence sSeek)` Seeks to the given CharSequence, start position is after the string.
`StringPart`	`seekNextLine()` Seeks to the next non-empty line.
`StringPart`	`seekNoChar(java.lang.CharSequence sChars)` Posits the start of the part after all of the chars given in the parameter string.
`StringPart`	`seekNoWhitespace()` Displaces the start of the part to the first char it is no whitespace.
`StringPart`	`seekNoWhitespaceOrComments()` Displaces the begin of the part to the first char it is no whitespace or comment.
`StringPart`	`seekPos(int nr)` Sets the begin of the current part relative to the given number of character.
`StringPart`	`seekPosBack(int nr)` Sets the begin of the current part backward from end.
`StringPart`	`setBeginMaxPart()` Sets the start of the maximal part to the actual start of the valid part.
`StringPart`	`setCurrentMaxPart()` Sets the range of the maximal part to the currentvalid part.
`protected void`	`setCurrentPartTo(StringPart.Part dst)` Sets the actual part of the given Part as destination.
`void`	`setCurrentPosition(long pos)` Sets the current position at a fix position inside the maxPart.
`boolean`	`setIgnoreComment(boolean bSet)` Set the mode of ignoring comments.
`boolean`	`setIgnoreComment(java.lang.String sStart, java.lang.String sEnd)` Set the character string of inline commentmode of ignoring comments.
`boolean`	`setIgnoreEndlineComment(boolean bSet)` Set the mode of ignoring comments to end of line.
`boolean`	`setIgnoreEndlineComment(java.lang.String sStart)` Set the character string introducing the comments to end of line.
`boolean`	`setIgnoreWhitespaces(boolean bSet)` Set the mode of ignoring whitespaces.
`void`	`setInputfile(java.lang.String file)` Sets the input file for information `getInputfile()`
`StringPart`	`setLengthMax()` Sets the length to the end of the maximal part.
`StringPart`	`setParttoMax()` Sets the full range of available text.
`protected StringPart`	`skipWhitespaceAndComment()` Deprecated. see `seekNoWhitespaceOrComments()`
`boolean`	`startsWith(java.lang.CharSequence sCmp)` compares the Part of string with the given string.
`java.lang.CharSequence`	`subSequence(int from, int to)` Returns a volatile CharSequence from the range inside the current part.
`StringPart.Part`	`substring(int pos, int posendP)` Gets a substring inside the maximal part pos position of start relative to maxPart posend exclusive position of end.
`private static void`	`throwIllegalArgumentException(java.lang.String msg, int value)`
`private void`	`throwIndexOutOfBoundsException(java.lang.String sMsg)` Central mehtod to invoke excpetion, usefull to set a breakpoint in debug or to add some standard informations.
`private static void`	`throwSubSeqFaulty(int from, int to)`
`java.lang.String`	`toString()`
`StringPart`	`trim()` Trims all leading and trailing whitespaces within the part.
`(package private) StringPart`	`trimComment()` Trims a java- or C-style line-comment from end of part and all leading and trailing whitespaces.
`StringPart`	`trimWhiteSpaces()` Increments the begin of the current part over maybe found whitespaces and decrements the end of the current part over maybe found whitespaces.
`int`	`XXXindexOf(java.lang.CharSequence sCmp)` Returns the position of the string within the part.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.lang.CharSequence
chars, codePoints

Methods inherited from interface java.lang.Iterable
forEach, spliterator

- Field Detail
  - sVersion
```
public static final java.lang.String sVersion
```
    Version, history and license.
    - 2023-04-30 Hartmut new: contentTillSpaceEndOrQuotation(String, char)
    - 2022-06-06 Hartmut chg: Now implements Closeable is removed. This is faulty, because nothing is open. The close() operarion does not close, it cleans only. Some unnecessary warnings were created because the Closeable property. The close() operation is now designated as deprecated, use instead
    - 2022-04-30 Hartmut new: getCharSequenceRange(long, long)
    - 2022-01-20 Hartmut new some enhancements indexOfAnyCharOutsideQuotation(CharSequence, String, char, int, int) etc. But this routines should use the capability of StringFunctions.indexOfAnyCharOutsideQuotation(CharSequence, int, int, CharSequence, CharSequence, CharSequence, char, int[]) etc. TODO test and refactoring. The operations are new and not yet tested. But the definitions (heads) are proper.
    - 2021-06-28 Hartmut new now it is an Iterable. The Iterator StringPart.Iter returns this but with the next selected line. It is to evaluate a file line per line. It uses the existing routines firstlineMaxpart() and nextlineMaxpart() which are proper to use. The lines can be evaluated with operations of StringPart. This is used well in JZtxtcmd in a for(element: container) loop.
    - 2021-03-14 Hartmut new lentoNumber(boolean, int[], String)
    - 2019-06-07 Hartmut some formally changes: mSeekToLeft etc: all bits are named with leading 'm' for mask.
    - 2019-05-15 Hartmut seekCheck(CharSequence): A seek("xyz") shifts the actual position to the end if the seek String is not found. This is the programmed behavior since 20 years, but it seems to be inconsequent. It may be better to remain the position, because found() can be checked. This routine is not changed. But the new routine seekCheck(CharSequence) and a flag mSeekCheck is introduced instead.
    - 2019-04-24 Hartmut Some gardening because this sources are copied and adapted to C-sharp too: StringPart.Part is a static class now, with outer reference. It is more clearly. Csharp does not know the concept of non static inner classes
    - 2019-04-24 Hartmut new setCurrentMaxPart(), obvious necessary while test (independent of Csharp!).
    - 2019-01-22 Hartmut There were some mistakes with the position with longer files and smaller buffer in StringPartFromFileLines.
    - 2019-02-10 Hartmut Change of StringPart.Part: possibility of set, because there is a persistent instance possible for setCurrentPartTo(Part). It is because C-usage. This routines are used in the C-version for the Simulink Sfunction DataStruct...Inspc.
    - 2018-12-22 Hartmut bugfix: Bug: The position in StringPart.Part were related to the current content. If the content was shifted in StringPartFromFileLines.readnextContentFromFile(int) the text referred with a StringPart.Part were become faulty, it has referred the same position but the text was shifted in content.
      Fix: New element absPos0 contains the character position in the read file in StringPartFromFileLines, it is incremented there. The StringPart.Part.absPos0 contains a final value on creation. The difference between both absPos0 is the difference to refer the correct characters. If the content is shifted out, a IndexOutOfBoundsException is thrown on access of #content, with them the situation is detected. A StringPart.Part is only intended for immediate use. Therefore a shifting of content should be acceptable, but not a greater shifting. Comment added on Part and some usages like getLastPart() and StringPartScan.getLastScannedString().
    - 2017-07-02 Hartmut new: getCurrentPart(int) invoked with -1 returns the whole current part.
    - 2016-09-04 Hartmut chg: seekPosBack(int) instead new method seekBack, better name, there was a name clash in Java2C-translation with constant definition seekBack.
    - 2016-09-04 Hartmut chg: checkCharAt(int, String) should be written with only one return statement for Java2C as define inline.
    - 2016-09-04 Hartmut adapt: using of Java4C.InThCxtRet
    - 2016-08-28 Hartmut new: firstlineMaxpart(), nextlineMaxpart() as new and important mechanism for line to line scanning.
    - 2016-08-28 Hartmut chg: setParttoMax() returns this.
    - 2016-08-28 Hartmut new: checkCharAt(int, String) as replacement or additional to charAt(int) and comparison, without exception.
    - 2016-08-28 Hartmut chg: lentoPos(int) instead lento(int) because it is ambiguous with lento(char) especially for JZtxtcmdExecuter interpretation.
    - 2016-08-28 Hartmut chg: lento(CharSequence) instead String argument. May changes CharSequence instead String without changing the implementation. It has worked with a CharSequence already.
    - 2016-08-28 Hartmut new: seekPos(int) instead seek(int) but it seeks backward from end with negative number. Sets found() instead exception.
    - 2016-05-22 Hartmut chg: now translated to C with some changes.
    - 2015-02-28 Hartmut chg: seekBackward(CharSequence) instead seekBack because name clash in Java2C, C-translated code with seekBack
    - 2015-02-28 Hartmut new: lentoLineEnd(), seekBackward(CharSequence), seekBackToAnyChar(CharSequence) more simple for calling in a JZcmd script.
    - 2014-09-05 Hartmut new: Twice methods indexOf(CharSequence) and indexOf(CharSequence). The methods are the same in Java. But in C the handling of reference is different. In Java2C translation a StringJc does not base on CharSequence because it is a simple reference to char[] and a length only. CharSequence needs ObjectJc and virtual methods.
    - 2014-05-23 Hartmut new: getLineAndColumn(int[]) instead getLineCt() because it determines the column in one function instead extra call off getCurrentColumn(). It is faster.
    - 2014-05-22 Hartmut new: #setInputfile(CharSequence), getInputfile()
    - 2014-05-10 Hartmut new: line()
    - 2014-01-12 Hartmut new: setParttoMax() usefully for new view to content.
    - 2013-12-29 Hartmut bugfix in Part#Part(int, int)
    - 2013-10-26 Hartmut chg: Does not use substring yet, some gardening, renaming.
    - 2013-09-07 Hartmut new: StringPartScan#getCircumScriptionToAnyChar(CharSequence) the #getCircumScriptionToAnyChar(CharSequence) does not work correctly (it has a bug). Use the new one.
    - 2013-01-20 Hartmut TODO: The content should be a CharSequence. Then the instance of content may be a StringBuilder. All content.substring should be replaced by content.subsequence(). The content.indexof-Method should be implemented here. Advantage: A derived class can use the content as StringBuilder and it can shift the string by operating with large contents. Note that a origin position should be used then. This class can contain and regard a origin position, which is =0 in this class. See StringPartFromFileLines. That class doesn't regard a less buffer yet, but it should do so.
    - 2013-01-19 Hartmut new: getPart(int, int)
    - 2012-02-19 Hartmut new: assignReplaceEnv(StringBuilder)
    - 2011-10-10 Hartmut new: #scanFloatNumber(boolean). It should be possible to scan a float with clearing the buffer. Using in ZbnfParser.
    - 1011-07-18 Hartmut bugfix: some checks of length in #scanFloatNumber(). If the String contains only the number digits, an IndexOutOfBounds-exception was thrown because the end of the String was reached.
    - 2009-03-16 Hartmut new: scanStart() returns this, not void. Useable in concatenation.
    - 2007-05-08 JcHartmut change: seekAnyChar(CharSequence,int[]) renamed to seekAnyString(CharSequence,int[]) because it was an erroneous identifier.
    - 2007-05-08 JcHartmut new: lastIndexOfAnyChar(CharSequence,int,int)
    - 2007-05-08 JcHartmut new: lentoAnyChar(CharSequence, int, int) it should programmed consequently for all indexOf and lento methods.
    - 2007-04-00 JcHartmut some changes, not noted.
    - 2004-01-00 JcHartmut initial revision The idea of such functionality was created in th 1990th in C++ language.
    Copyright/Copyleft: For this source the LGPL Lesser General Public License, published by the Free Software Foundation is valid. It means:
    1. You can use this source without any restriction for any desired purpose.
    2. You can redistribute copies of this source to everybody.
    3. Every user of this source, also the user of redistribute copies with or without payment, must accept this license for further using.
    4. But the LPGL ist not appropriate for a whole software product, if this source is only a part of them. It means, the user must publish this part of source, but don't need to publish the whole source of the own product.
    5. You can study and modify (improve) this source for own using or for redistribution, but you have to license the modified sources likewise under this LGPL Lesser General Public License. You mustn't delete this Copyright/Copyleft inscription in this source file.
    If you are intent to use this sources without publishing its usage, you can get a second license subscribing a special contract with the author.
    See Also:
    
    Constant Field Values
  - begin
```
protected int begin
```
    The actual start position of the valid part.
  - end
```
protected int end
```
    The actual exclusive end position of the valid part.
  - begiMin
```
protected int begiMin
```
    The most left possible start position. We speak about the 'maximal Part': The actual valid part can not exceed the borders startMin and endMax of the maximal part after any operation. The content of the associated string outside the maximal part is unconsidered. The atrributes startMin and endMax are not set by any operations except for the constructors and the set()-methods.
    Set to 0 if constructed from a string, determined by the actual start if constructed from a StringPart.
    In the explanation of the methods the following notation is used as samples:
```
abcdefghijklmnopqrstuvwxyz  Sample of the whole associated String
  =====================     The === indicates the maximal part
    -----------             The --- indicates the valid part before operation
               ++++++++     The +++ indicates the valid part after operation
      
```
  - endMax
```
protected int endMax
```
    The most right possible exclusive end position. See explanation on startMin.
    Set to content.length() if constructed from a string, determined by the actual end if constructed from a StringPart. It is checked by assert whether endMax <= content.length().
  - absPos0
```
protected int absPos0
```
    The absolute position of character in the input file of content[0] It is used for StringPartFromFileLines or adequate reader.
  - posRewind
```
private int[] posRewind
```
    Strategy for buffer shifting: begiMin should be existing always. Any of this rewind positions should be existing. But the user must not forgot to remove the rewind positions. TODO
  - content
```
protected java.lang.CharSequence content
```
    The referenced string. It is a CharSequence for enhanced using.
  - bCurrentOk
```
protected boolean bCurrentOk
```
    false if current scanning is not match
  - bStartScan
```
protected boolean bStartScan
```
    If true, than all idxLastScanned... are set to 0, it is after #scanOk() or after #scanStart
  - beginLast
```
protected int beginLast
```
    Borders of the last part before calling of scan__(), seek__(), lento__(). If there are different to the current part, the call of restoreLastPart use this values. scanOk() sets the startLast-variable to the actual start or rewinds the actual start ot startLast.
  - endLast
```
protected int endLast
```
    Borders of the last part before calling of scan__(), seek__(), lento__(). If there are different to the current part, the call of restoreLastPart use this values. scanOk() sets the startLast-variable to the actual start or rewinds the actual start ot startLast.
  - bFound
```
protected boolean bFound
```
    True if the last operation of lento__(), seek etc. has found anything. See found().
  - mSeekEnd
```
public static final int mSeekEnd
```
    Flag to force setting the start position after the seeking string. See description on seek(CharSequence, int).
    
    See Also:
    
    Constant Field Values
  - seekEnd
```
public static final int seekEnd
```
    See Also:
    
    Constant Field Values
  - mSeekCheck
```
public static final int mSeekCheck
```
    If this bit is set on seek, the position remains if the seek is not successfully (if found() returns false).
    
    See Also:
    
    Constant Field Values
  - mSeekBackward_
```
private static final int mSeekBackward_
```
    Flag bit to force seeking backward. This value is contens impilicit in the mSeekBackFromStart or ~End, using to detect internal the backward mode.
    
    See Also:
    
    Constant Field Values
  - mSeekToLeft_
```
private static final int mSeekToLeft_
```
    Flag bit to force seeking left from start (Backward). This value is contens impilicit in the seekBackFromStart using to detect internal the seekBackFromStart-mode.
    
    See Also:
    
    Constant Field Values
  - mSeekToLeft
```
public static final int mSeekToLeft
```
    Flag to force seeking backward from the start position. See description on seek(CharSequence).
    
    See Also:
    
    Constant Field Values
  - seekToLeft
```
public static final int seekToLeft
```
    See Also:
    
    Constant Field Values
  - mSeekBack
```
public static final int mSeekBack
```
    Flag to force seeking backward from the end position. See description on seek(CharSequence).
    
    See Also:
    
    Constant Field Values
  - seekBack
```
public static final int seekBack
```
    See Also:
    
    Constant Field Values
  - seekNormal
```
public static final int seekNormal
```
    Flag to force seeking forward. See description on seek(CharSequence).
    
    See Also:
    
    Constant Field Values
  - bitMode
```
protected int bitMode
```
    Some mode bits. See all static final int xxx_mode.
  - mSkipOverWhitespace_mode
```
protected static final int mSkipOverWhitespace_mode
```
    Bit in mode. If this bit ist set, all whitespace are overreaded before calling any scan method.
    
    See Also:
    
    Constant Field Values
  - mSkipOverCommentInsideText_mode
```
protected static final int mSkipOverCommentInsideText_mode
```
    Bit in mode. If this bit ist set, all comments are overreaded before calling any scan method.
    
    See Also:
    
    Constant Field Values
  - mSkipOverCommentToEol_mode
```
protected static final int mSkipOverCommentToEol_mode
```
    Bit in mode. If this bit ist set, all comments are overreaded before calling any scan method.
    
    See Also:
    
    Constant Field Values
  - sCheckWhitespaces
```
protected static final java.lang.String sCheckWhitespaces
```
    See Also:
    
    Constant Field Values
  - sCheckNewline
```
protected static final java.lang.String sCheckNewline
```
    See Also:
    
    Constant Field Values
  - sFile
```
java.lang.String sFile
```
    The file from which the StringPart was build. See getInputfile() and setInputFile.
  - sCommentStart
```
java.lang.String sCommentStart
```
    The string defined the start of comment inside a text.
  - sCommentEnd
```
java.lang.String sCommentEnd
```
    The string defined the end of comment inside a text.
  - sCommentToEol
```
java.lang.String sCommentToEol
```
    The string defined the start of comment to end of line
- Constructor Detail
  - StringPart
```
public StringPart()
```
    Creates a new empty StringPart without an associated String. See method set() to assign a String.
  - StringPart
```
public StringPart(java.lang.CharSequence src)
```
    Creates a new StringPart, with the given content from a String. Initialy the whole string is valid and determines the maximal part. Constructs with a given CharSequence, especially with a given String.
    
    Parameters:
    
    src - Any CharSequence or String
  - StringPart
```
public StringPart(java.lang.CharSequence src,
                  int start,
                  int end)
```
    Builds a StringPart which uses the designated part of the given src. Creates a new StringPart with the same String as the given StringPart. The maximal part of the new StringPart are determined from the actual valid part of the src. The actual valid part is equal to the maximal one.
    example:
```
abcdefghijklmnopqrstuvwxyz  The associated String
    ----------------        The valid part of src
    ================        The maximal part and initial the valid part of this
    +++++   ++++            Possible valid parts of this after some operations
       ++++      +++        Possible also
  +++++           ++++ +++  Never valid parts of this after operations because they exceeds the borders of maximal part.
      
```
    Parameters:
    
    src - It will be referenced.
    
    start - The beginMin and begin value for the StringPart.
    
    end - The end and endMax value for the StringPart.
- Method Detail
  - setInputfile
```
public void setInputfile(java.lang.String file)
```
    Sets the input file for information getInputfile()
    
    Parameters:
    
    file -
  - assign
```
public final StringPart assign(java.lang.CharSequence src)
```
    Sets the content to the given string, forgets the old content. Initialy the whole string is valid.
    
    Parameters:
    
    content - The content.
    
    Returns:
    
    this to concatenate some operations, like part.set(src).seek(sKey).lento(';').len0end();
  - assignReplaceEnv
```
public final StringPart assignReplaceEnv(java.lang.StringBuilder input)
```
    Sets the content to the given string, forgets the old content. All Place-holder for System environment variable are replaced firstly. A place holder for a environment variable is written like "$(name)" or "$name" like in a unix shell. The replacement is done in the content. Initially the whole string is valid. TODO designate input as persistent.
    
    Parameters:
    
    input - The content initially maybe with place holders for environment variable, they will be replaced. For java2c-usage the content should not be changed after them, because the String is referred there originally.
    
    Returns:
    
    this refers the content.
  - assign
```
public final StringPart assign(StringPart src)
```
    Sets the StringPart with the same String object as the given StringPart, forgets the old content. The borders of the new StringPart (the maximal part) are determined from the actual valid part of the src. The actual valid part is equal to this limits. If the src is the same instance as this (calling with 'this'), than the effect is the same. The maximal Part is determined from the unchanged actual part.
    example:
```
abcdefghijklmnopqrstuvwxyz  The associated String
    ----------------        The valid part of src
    ================        The maximal part and initial the valid part of this
    +++++   ++++            Possible valid parts of this after some operations
       ++++      +++        Possible also
  +++++           ++++ +++  Never valid parts of this after operations because they exceeds the borders of maximal part.
      
```
    Parameters:
    
    src - The given StringPart.
    
    Returns:
    
    this to concat some operations, like part.set(src).seek(sKey).lento(';').len0end();
  - assignFromEnd
```
public final StringPart assignFromEnd(StringPart src)
```
    Sets the content of the StringPart , forgets the old content. The same string like in src is associated. Initialy the part from the end of the src-part to the maximal end of src is valid. The valid part and the maximal part is set in this same way.
    example:
```
abcdefghijklmnopqrstuvwxyz  The associated String
  =====================     The maximal part of src
    ------                  The valid part of src
          =============     The maximal and initialy the valid part of this
      
```
    Parameters:
    
    src - The source of the operation.
    
    Returns:
    
    this to concat some operations, like part.set(src).seek(sKey).lento(';').len0end();
  - setIgnoreComment
```
public final boolean setIgnoreComment(boolean bSet)
```
    Set the mode of ignoring comments. If it is set, comments are always ignored on every scan operation. On scan, the current position is set first after a comment if the current position began with a comment. This mode may or should be combinded with setIgnoreWhitespace.
    The string introduces and finishes a comment is setted by calling setIgnoreComment(String sStart, String sEnd). The default value is "/ *" and "* /" like in java-programming.
    
    Parameters:
    
    bSet - If true than ignore, if false than comments are normal input to parse.
    
    Returns:
    
    The last definition of this feature.
  - setIgnoreComment
```
public final boolean setIgnoreComment(java.lang.String sStart,
                                      java.lang.String sEnd)
```
    Set the character string of inline commentmode of ignoring comments. After this call, comments are always ignored on every scan operation. On scan, the current position is set first after a comment if the current position began with a comment. This mode may or should be combinded with setIgnoreWhitespace.
    
    Parameters:
    
    sStart - Start character string of a inline comment
    
    sEnd - End character string of a inline comment
    
    Returns:
    
    The last definition of the feature setIgnoreComment(boolean).
  - setIgnoreEndlineComment
```
public final boolean setIgnoreEndlineComment(boolean bSet)
```
    Set the mode of ignoring comments to end of line. If it is set, end-line-comments are always ignored on every scan operation. On scan, the current position is set first after a comment if the current position began with a comment. This mode may or should be combinded with setIgnoreWhitespace.
    The string introduces a endofline-comment is setted by calling setEndlineCommentString(). The default value is "//" like in java-programming.
    
    Parameters:
    
    bSet - If true than ignore, if false than comments are normal input to parse.
    
    Returns:
    
    The last definition of the feature setIgnoreComment(boolean).
  - setIgnoreEndlineComment
```
public final boolean setIgnoreEndlineComment(java.lang.String sStart)
```
    Set the character string introducing the comments to end of line. After this call, endline-comments are always ignored on every scan operation. On scan, the current position is set first after a comment if the current position began with a comment. This mode may or should be combinded with setIgnoreWhitespace.
    
    Parameters:
    
    sStart - String introducing end line comment
    
    Returns:
    
    The last definition of this feature.
  - setIgnoreWhitespaces
```
public final boolean setIgnoreWhitespaces(boolean bSet)
```
    Set the mode of ignoring whitespaces. If it is set, whitespaces are always ignored on every scan operation. On scan, the current position is set first after a comment if the current position began with a comment. This mode may or should be combinded with setIgnoreWhitespace.
    The chars accepted as whitespace are setted by calling setWhiteSpaceCharacters(). The default value is sCheckWhitespaces like in java-programming.
    
    Parameters:
    
    bSet - If true than ignore, if false than comments are normal input to parse.
    
    Returns:
    
    The last definition of this feature.
  - setBeginMaxPart
```
public final StringPart setBeginMaxPart()
```
    Sets the start of the maximal part to the actual start of the valid part. See also seekBegin(), that is the opposite operation.
    example:
```
abcdefghijklmnopqrstuvwxyz  The associated string
================        The maximal part before operation
     ------             The actual part
     ===========        The maximal part after operation
  
```
    Parameters:
    
    src - The given StringPart.
    
    Returns:
    
    this to concatenate some operations, like part.set(src).seek(sKey).lento(';').len0end();
  - setCurrentMaxPart
```
public final StringPart setCurrentMaxPart()
```
    Sets the range of the maximal part to the currentvalid part.
    example:
```
abcdefghijklmnopqrstuvwxyz  The associated string
      ================      The maximal part before operation
         ------             The actual part
         ======             The maximal part after operation
```
    Parameters:
    
    src - The given StringPart.
    
    Returns:
    
    this to concatenate some operations, like part.set(src).seek(sKey).lento(';').len0end();
  - setParttoMax
```
public final StringPart setParttoMax()
```
    Sets the full range of available text. begin is set to 0, end is set to the length() of the content.
  - fromEnd
```
public final StringPart fromEnd()
```
    Sets the start of the part to the exclusively end, set the end to the end of the content.
    example:
```
  abcdefghijklmnopqrstuvwxyz  The associated String
  =================         The maximal part
       -----              The valid part before
            +++++         The valid part after.
    
```
    Returns:
    
    this to concatenate some operations, like part.set(src).seek(sKey).lento(';').len0end();
  - charAt
```
public final char charAt(int index)
```
    This method returns the characters of the current part.
    
    Specified by:
    
    charAt in interface java.lang.CharSequence
    
    See Also:
    
    CharSequence.charAt(int)
  - checkCharAt
```
public final boolean checkCharAt(int pos,
                                 java.lang.String chars)
```
    Checks whether the char at pos in the current part is one of chars.
    
    Parameters:
    
    pos -
    
    chars -
    
    Returns:
  - subSequence
```
public final java.lang.CharSequence subSequence(int from,
                                                int to)
```
    Returns a volatile CharSequence from the range inside the current part. If it is not possible an IllegalArgumentException is thrown. The difference to #subString(int, int) is: It is not persistent. This method should only used if the CharSequence is processed in the thread immediately for example by adding to another StringBuilder etc. The returned instance should not be saved for later usage. For C usage: The returned instance is located in the Thread Context. It should be freed with releaseUserBuffer_ThreadContextFw(...)<(code>. The Java2C-translator does that automatically.
    Specified by: subSequence in interface java.lang.CharSequence See Also: CharSequence.subSequence(int, int)
  throwSubSeqFaulty private static final void throwSubSeqFaulty(int from, int to) length public final int length() Specified by: length in interface java.lang.CharSequence getLenCurrent public final int getLenCurrent() lengthMaxPart public final int lengthMaxPart() Returns the lenght of the maximal part from current position. Returns also 0 if no string is valid. Returns: number of chars from current position to end of maximal part. lento @Deprecated public final StringPart lento(int len) Deprecated. use lenToPos, more clarify, especially for JZcmd Sets the endposition of the part of string to the given chars after start. Parameters: len - The new length. It must be positive. Returns: this to concat some operations. Throws: java.lang.IndexOutOfBoundsException - if the len is negativ or greater than the position endMax. lentoPos public final StringPart lentoPos(int len) throws java.lang.IndexOutOfBoundsException Sets the endposition of the part of string to the given chars after start. Parameters: len - The new length. It must be positive. Returns: this to concatenate some operations. Throws: java.lang.IndexOutOfBoundsException - if the len is negativ or greater than the position endMax. lento public final StringPart lento(char cc) Sets the end position of the part of string to exclusively the char cc. If the char cc is not found, the end position is set to start position, so the part of string is empty. It is possible to call set0end() to set the end of the part to the maximal end if the char is not found. That is useful by selecting a part to a separating char such ',' but the separator is not also the terminating char of the last part. example: abcdefghijklmnopqrstuvwxyz The associated String ================= The maximal part of src ----- The valid part of src before calling the method + after calling lento('w') the end is set to start position, the length() is 0, because the 'w' is outside. ++++++++++ calling set0end() is possible and produce this result. Parameters: cc - char to determine the exclusively end char. Returns: this to concatenate some operations, usage example part.set(src).seek(sKey).lento(';').len0end(); Hint: use found() to detect whether the end string is found. if the end String is not found, the current part has length ==0 lento public final StringPart lento(java.lang.CharSequence ss) Sets the endposition of the part of string to exclusively the given string. If the string is not found, the end position is set to start position, so the part of string is emtpy. It is possible to call set0end() to set the end of the part to the maximal end if the char is not found. That is useful by selecting a part to a separating char such ',' but the separator is not also the terminating char of the last part, example see lento(char cc) Parameters: ss - string to determine the exclusively end char. Returns: this to concatenate some operations, usage example part.set(src).seek(sKey).lento(';').len0end(); Hint: use found() to detect whether the end string is found. if the end String is not found, the current part has length ==0 lento public final StringPart lento(java.lang.CharSequence ss, int mode) Sets the endposition of the part of string to exclusively the given string. If the string is not found, the end position is set to start position, so the part of string is emtpy. It is possible to call set0end() to set the end of the part to the maximal end if the char is not found. That is useful by selecting a part to a separating char such ',' but the separator is not also the terminating char of the last part, example see lento(char cc) Parameters: ss - string to determine the exclusively end char. mode - Mode of seeking the end, seekEnd or 0 is possible. Returns: this to concatenate some operations, usage example part.set(src).seek(sKey).lento(';').len0end(); Hint: use found() to detect whether the end string is found. if the end String is not found, the current part has length ==0 lentoIdentifier public final StringPart lentoIdentifier() Sets the endposition of the part of string to the end of the identifier which is beginning on start. If the part starts not with a identifier char, the end is set to the start position. example: abcd this is a part uvwxyz The associated String ===================== The border of valid parts of src ------- The valid part of the src before calling the method +++ after calling lentoIdentifier(). The start position is not effected. That's why the identifier-part is only "his". Returns: this to concat some operations, like part.set(src).seek(sKey).lento(';').len0end(); lentoIdentifier public final StringPart lentoIdentifier(java.lang.CharSequence additionalStartChars, java.lang.CharSequence additionalChars) Sets the endposition of the part of string to the end of the identifier which is beginning on start. If the part starts not with a identifier char, the end is set to the start position. Parameters: additionalChars - CharSequence of additinal chars there are also accept as identifier chars. See Also: lentoIdentifier(). lentoNumber public final StringPart lentoNumber(boolean bHex, int[] dst, java.lang.String separatorChars) Sets the end position of the part of string to the end of the number which is beginning on start. If the part starts not with an admissible char, the end is set to the start position and this.bFound is set to false. If a number is found, maybe consist only as separatorChars, this.bFound is set to true. It may be recommended using this routine if a number character is really expected. Example: " 1'234'456.235" is parsed correctly as 1234456 with separatorChars=" '". The dot is not parsed. Example: to parse an expected number with sign, test firstly the sign (before number). int[] nr = int[1]; char cc = sp.getCurrentChar(); if(cc == '-') { bNeg = true; } sp.lentoNumber(false, nr, null); if(bNeg) { nr[0] = -nr[0]; } sp.fromEnd() Parameters: bHex - also parse a..f and A..F, build a hexa number dst - either null or int[1] as destination for the parsed number. Note: The length of the number for fractional part can be detected with separtorChars=null and getLenCurrent() separatorChars - CharSequence of additional chars there are also accept inside a number contentTillSpaceEndOrQuotation public final java.lang.String contentTillSpaceEndOrQuotation(java.lang.String sQuotationStartEnd, char escapeChar) Sets the current part either to the whole quotation if it it starts with the quotation char, or sets it till the first space, or till end if the space is not found. The return value is the String inside the quotation, or the current part. This operation helps to read a String either in quotation or till space, as it is usual for example in command line arguments, or also for configuration values. The quotation can be dismissed if the string is bundled up to the space character Parameters: sQuotationStartEnd - Two chars String for the quotation, usual "\"\"" or for example "<>" escapeChar - that character which subscribes the end quotation char itself, usual the backslash Returns: String between quotation or the current part. lentoAnyNonEscapedChar public final StringPart lentoAnyNonEscapedChar(java.lang.CharSequence sCharsEnd, int maxToTest) Sets the len to the first position of any given char, but not if the char is escaped. 'Escaped' means, a \ is disposed before the char. Example: lentoAnyNonEscapedChar("\"") ends not at a \", but at ". it detects the string "this is a \"quotion\"!". This method doesn't any things, if the last scanning call isn't match. Invoking of scanOk() before guarantees that the method works. Parameters: sCharsEnd - Assembling of chars determine the end of the part. lentoNonEscapedString public final StringPart lentoNonEscapedString(java.lang.CharSequence sEnd, int maxToTest) Sets the length of the valid part to the first position of the given String, but not if the String is escaped. 'Escaped' means, a \ is disposed before the char. Example: lentoNonEscapedString(" This method doesn't any things, if the last scanning call isn't match. Invoking of scanOk() before guarantees that the method works. Parameters: sCharsEnd - Assembling of chars determine the end of the part. line public final StringPart line() Sets the current Part from the current position to exactly one line. The start position of the current part will be set backward to the start of the line or to the start of the maximal part. The end position of the current part will be set to the end of the one line or the end of the maximal part independent from the end of the current part before. The functionality of #found() is not influenced. It may be the return value from a seek before. Returns: this firstlineMaxpart public final StringPart firstlineMaxpart() Sets the current and the maximal part from position 0 to the first end line character. If a line end character was not found - the last line without line end - the end is set to the last end. The line end character is either \r or \n. Because the maximal part is set to the line, anything inside the line can be selected as current part. The nextlineMaxpart() works properly nevertheless. Returns: this. nextlineMaxpart public final StringPart nextlineMaxpart() Sets the current and the maximal part from the current end to the next line end character. If the current end before refers a line end character itself, it is seek after it firstly. That is the standard behavior to read lines. If the current end before does not refer a line end character, the next line end character is searched firstly. That behavior is important if the current part of the last line was set anywhere inside the line. If a line end character was not found - the last line without line end - the end is set to the last end. The line end character is either \r or \n or a sequence of \r\n or \n\r Returns: this. Use found() to check whether a next line was found. seek @Deprecated public final StringPart seek(int nr) Deprecated. use seekPos(int) Displaces the start of the part for some chars to left or to right. If the seek operation would exceeds the maximal part borders, a StringIndexOutOfBoundsException is thrown. example:abcdefghijklmnopqrstuvwxyz The associated String ================= The maximal part ----- The valid part before +++++++ The valid part after calling seek(-2). +++ The valid part after calling seek(2). + The valid part after calling seek(5). The start is set to end, the lenght() is 0. ++++++++++++ The valid part after calling seek(-5). Parameters: nr - of positions to displace. Negative: Displace to left. Returns: this to concat some operations, like part.set(src).seek(sKey).lento(';').len0end(); seekPos public final StringPart seekPos(int nr) Sets the begin of the current part relative to the given number of character. If the range is outside, this routine sets found() to false and does not change the position. If the range is valid, found() returns true. Example: seek(3): abcdefghijklmnopqrstuvwxyz The associated String ---------- The valid part before +++++++ The valid part after Example: seek(-3): abcdefghijklmnopqrstuvwxyz The associated String ---------- The valid part before +++++++++++++ The valid part after Parameters: nr - >0 then shift the current part's begin to right maximal to end nr < 0 then shift the current part's begin to left maximal to begiMin Returns: this See Also: #seek(int), in opposite this method does not throw an excetion but do nothing and sets {@link #found()} to false. seekPosBack public final StringPart seekPosBack(int nr) Sets the begin of the current part backward from end. If the range is outside, this routine sets found() to false and does not change the position. If the range is valid, found() returns true. Example: seekBack(5): abcdefghijklmnopqrstuvwxyz The associated String ---------- The valid part before +++++ The valid part after Parameters: nr - >=0 the number of character from end for the new begin. Returns: this seekNoWhitespace public final StringPart seekNoWhitespace() Displaces the start of the part to the first char it is no whitespace. If the current char at seek position is not a whitespace, the method has no effect. If only whitespaces are founded to the end of actual part, the position is set to this end. example:abcdefghijklmnopqrstuvwxyz The associated String ================= The maximal part ---------- The valid part before +++++++ The valid part after, if 'defg' are whitespaces ++++++++++ The valid part after is the same as before, if no whitespace at current position . The valid part after is emtpy, if only whitespaces re found. Returns: this to concatenate some operations, usage example part.set(src).seek(sKey).lento(';').len0end(); Hint: use found() to detect whether the end string is found. if the end String is not found, the current part has length ==0 seekAfterNewline public final StringPart seekAfterNewline() skipWhitespaceAndComment @Deprecated protected final StringPart skipWhitespaceAndComment() Deprecated. see seekNoWhitespaceOrComments() See setIgnoreWhitespaces(boolean), setIgnoreComment(boolean) seekNoWhitespaceOrComments public final StringPart seekNoWhitespaceOrComments() Displaces the begin of the part to the first char it is no whitespace or comment. If the current char at seek position is not a whitespace or not the beginning of a comment, the method has no effect. If only whitespaces and comments are found to the end of actual part, the position is set to its end. example:abcdefghijklmnopqrstuvwxyz The associated String ================= The maximal part ---------- The valid part before +++++++ The valid part after, if 'defg' are whitespaces ++++++++++ The valid part after is the same as before, if no whitespace at current position . The valid part after is emtpy, if only whitespaces re found. Returns: this to concat some operations, like part.set(src).seek(sKey).lento(';').len0end(); found public final boolean found() Returns true, if the last called seek__(), lento__() or skipWhitespaceAndComment() operation founds the requested condition. This methods posits the current Part in a appropriate manner if the seek or lento-conditions were not prosperous. In this kinds this method returns false. Returns: true if the last seek__(), lento__() or skipWhitespaceAndComment() operation matches the condition. seekBegin public final StringPart seekBegin() Displaces the begin of the part to the leftest possible begin. example: abcdefghijklmnopqrstuvwxyz The associated String ================= The maximal part ----- The valid part before ++++++++++++ The valid part after calling seekBegin(). Returns: this to concat some operations, like part.set(src).seek(sKey).lento(';').len0end(); seek public final StringPart seek(java.lang.CharSequence sSeek, int mode) Common seek operation with several modes in flags. The end of the part is not affected. If the string is not found, depending on mSeekCheck the begin is unchanged or it is positioned on the actual end (mSeekCheck not set). Then the length()-method supplies 0. Methods such fromEnd() are not interacted from the result of the searching. The rule is: seek()-methods only shifts the begin position. example:that is a liststring and his part The associated String ============================= The maximal part ---------------------- The valid part before +++++++++++++++++ The valid part after seek("is",StringPartBase.seekNormal). +++++++++++++++ The valid part after seek("is",StringPartBase.seekEnd). ++ The valid part after seek("is",StringPartBase.back). . The valid part after seek("is",StringPartBase.back + StringPartBase.seekEnd). +++++++++++++++++++++++ The valid part after seek("is",StringPartBase.seekToLeft). +++++++++++++++++++++ The valid part after seek("is",StringPartBase.seekToLeft + StringPartBase.seekEnd). ++++++++++++++++++++++++++ The valid part after seek("xx",StringPartBase.seekToLeft). . The valid part after seek("xx",StringPartBase.seekNormal) or seek("xx",StringPartBase.back). Parameters: sSeek - The string to search for. mode - Mode of seeking, use ones of mSeekCheck, seekBack, seekToLeft, seekNormal, added with seekEnd. Returns: this to concatenate some operations, usage example part.set(src).seek(sKey).lento(';').len0end(); Hint: use found() to detect whether the end string is found. if the end String is not found, the current part has length ==0 seekBackward public final StringPart seekBackward(java.lang.CharSequence sSeek) Seeks back form the current end to the end of the given String starting from the end of the current part. If the String was found, the start of the current part is changed to the end of the found String. Sets found() to false if the String is not contained in the current part. Then the current part is not changed. Parameters: sSeek - The string to seek backward. Returns: seekAnyChar public final StringPart seekAnyChar(java.lang.CharSequence chars) Seeks to one of the characters contained in chars, starting from the begin of the current part. If a character was found, the start of the current part is changed to that character. Sets found() to false if a character of chars is not contained in the current part. Then the current part is not changed. Parameters: sSeek - The string to seek backward. Returns: this to concatenate some operations, usage example part.set(src).seek(sKey).lento(';').len0end(); Hint: use found() to detect whether the end string is found. if the end String is not found, the current part has length ==0 seekBackToAnyChar public final StringPart seekBackToAnyChar(java.lang.CharSequence chars) Seeks back from the current end to one of the characters contained in chars, starting from the end of the current part. If a character was found, the start of the current part is changed to that character. Sets found() to false if a character of chars is not contained in the current part. Then the current part is not changed. Parameters: sSeek - The string to seek backward. Returns: this to concatenate some operations, usage example part.set(src).seek(sKey).lento(';').len0end(); Hint: use found() to detect whether the end string is found. if the end String is not found, the current part has length ==0 seek public final StringPart seek(java.lang.CharSequence sSeek) Searchs the given String inside the valid part, posits the begin of the part to the begin of the searched string. The end of the part is not affected. If the string is not found, the begin is posit on the actual end. The length()-method supplies 0. Methods such fromEnd() are not interacted from the result of the searching. The rule is: seek()-methods only shifts the begin position. example:that is a liststring and his part The associated String ============================= The maximal part ---------------------- The valid part before +++++++++++++++++ The valid part after seek("is",StringPartBase.seekNormal). +++++++++++++++ The valid part after seek("is",StringPartBase.seekEnd). ++ The valid part after seek("is",StringPartBase.back). . The valid part after seek("is",StringPartBase.back + StringPartBase.seekEnd). +++++++++++++++++++++++ The valid part after seek("is",StringPartBase.seekToLeft). +++++++++++++++++++++ The valid part after seek("is",StringPartBase.seekToLeft + StringPartBase.seekEnd). ++++++++++++++++++++++++++ The valid part after seek("xx",StringPartBase.seekToLeft). . The valid part after seek("xx",StringPartBase.seekNormal) or seek("xx",StringPartBase.back). This operation calls seek(CharSequence, int) with flag seekNormal. Use seekCheck(CharSequence) or seek(CharSequence, int) with mSeekCheck. Parameters: sSeek - Returns: this to concatenate some operations, usage example part.set(src).seek(sKey).lento(';').len0end(); Hint: use found() to detect whether the end string is found. if the end String is not found, the current part has length ==0 seekCheck public final StringPart seekCheck(java.lang.CharSequence sSeek) Seeks to the given CharSequence, result is left side of the string. If the string is not found, the current part remains (in opposite to seek(CharSequence) which sets the current position to the end) Parameters: sSeek - Returns: seekEnd public final StringPart seekEnd(java.lang.CharSequence sSeek) Seeks to the given CharSequence, start position is after the string. If not found, seek to end. Use found() to check whether it is found. Parameters: sSeek - Returns: this seekCheckEnd public final StringPart seekCheckEnd(java.lang.CharSequence sSeek) Seeks to the given CharSequence, start position is after the string. If not found, remain the begin position.. Use found() to check whether it is found. Parameters: sSeek - Returns: this seekAnyString public final StringPart seekAnyString(java.lang.CharSequence[] strings, int[] nrofFoundString) Searchs the given CharSequence inside the valid part, posits the begin of the part to the begin of the searched string. The end of the part is not affected. If the string is not found, the begin is posit to the actual end. The length()-method supplies 0. Methods such fromEnd() are not interacted from the result of the searching. The rule is: seek()-methods only shifts the begin position. see seek(CharSequence sSeek, int mode) Parameters: strings - List of CharSequence contains the strings to search. nrofFoundString - If given, [0] is set with the number of the found CharSequence in listStrings, count from 0. This array reference may be null, then unused. Returns: this. seek public final StringPart seek(char cSeek, int mode) Searchs the given character inside the valid part, posits the begin of the part to the begin of the searched char. The end of the part is not affected. If the string is not found, the begin is posit on the actual end or, if mode contents seekBack, the begin of the maximal part. In this cases isFound() returns false and a call of restoreLastPart() restores the old parts. The length()-method supplies 0. Methods such fromEnd() are not interacted from the result of the searching. The rule is: seek()-methods only shifts the begin position. The examples are adequate to seek(CharSequence, int mode); Parameters: cSeek - The character to search for. mode - Mode of seeking, use ones of back, seekToLeft, seekNormal, added with seekEnd. Returns: this to concatenate some operations, usage example part.set(src).seek(sKey).lento(';').len0end(); Hint: use found() to detect whether the end string is found. if the end String is not found, the current part has length ==0 seekNoChar public final StringPart seekNoChar(java.lang.CharSequence sChars) Posits the start of the part after all of the chars given in the parameter string. The end of the part is not affected. sample: seekNoChar("123") result is: 12312312312abcd12312efghij123123 before: ========================== after: =================== Parameters: sChars - CharSequence with the chars to overread. Returns: this to concatenate some operations, usage example part.set(src).seek(sKey).lento(';').len0end(); Hint: use found() to detect whether the end string is found. if the end String is not found, the current part has length ==0 seekNextLine public final StringPart seekNextLine() Seeks to the next non-empty line. Returns: this indexOfAnyChar public final int indexOfAnyChar(java.lang.CharSequence sChars, int fromWhere, int maxToTest) Searches any char contained in sChars in the current part Example: The given string in the current part is abc end:zxy The calling is indexOfAnyChar("xyz", 0, 20); The result is 8 because the character 'z' is found first as the end char. Parameters: fromWhere - Offset after begin to begin search. It may be 0 often. sChars - Some chars to search in sq If sChars contains a EOT character (code 03, #cEndOfText) then the search stops at this character or it is continued to the end of the range in sq. Then the length of the text range is returned if another character in sChars is not found. It means: The end of the text range is adequate to an EOT-character. Note that EOT is not unicode, but it is an ASCII control character. maxToTest - number of character to test from fromWhere. If maxToTest is greater then the length of the current part, only the whole current part is tested. Especially Integer.MAXVALUE and beu used. Returns: -1 if no character from sChars was found in the current part. 0.. Position of the found character inside the current part, but >= fromWhere indexOfAnyChar public final int indexOfAnyChar(java.lang.CharSequence sChars, int fromWhere, int maxToTest, char transcriptChar, char quotationStartChar, char quotationEndChar) Returns the position of one of the chars in sChars within the part, started inside the part with fromIndex, returns -1 if the char is not found in the part started from 'fromIndex'. It may regard transcription characters and it regard quotation. A transcription character is a pair of characters with the transcriptionChar, usual '\' followed by any special char. This pair of characters are not regarded while search the end of the text part, and the transcription will be resolved in the result (dst) String. The end of the string is determined by any of the given chars. But a char directly after the transcription char is not detected as an end char. Example: scanTranscriptionToAnyChar(dst, ">?", '\\', '\"', '\"') does not end at a char > after an \ and does not end inside the quotation. If the following string is given: a text -\>arrow, "quotation>" till > ...following then the last '>' is detected as the end character. The first one is a transcription, the second one is inside a quotation. The meaning of the transcription characters is defined in the routine StringFunctions#convertTranscription(CharSequence, char): Every char after the transcriptChar is accepted. But the known transcription chars \n, \r, \t, \f, \b are converted to their control-char- equivalence. The \s and \e mean begin and end of text, coded with ASCII-STX and ETX = 0x2 and 0x3. The actual part is tested for this, after this operation the actual part begins after the gotten chars! Parameters: sChars - contains some chars to find. If it contains the char with code #cEndOfText then the number of chars till the end of this text are returned if no char was found. If a char with code of #cEndOfText is found in this string, it is the end of this search process too. fromIndex - begin of search within the part. maxToTest - maximal numbers of chars to test. It may be Integer.MAX_VALUE. transcriptChar - any char which is the transcription designation char, especially '\\'. Set to 0 if no transcription should be regarded. quotationStartChar - any char which is the begin char of a quotation. Set to 0 if no quotation should be regarded. quotationEndChar - the adequate end char Returns: position of first founded char inside the actual part, but not greater than maxToTest, if no chars is found unitl maxToTest, but -1 if the end is reached. lastIndexOfAnyChar public final int lastIndexOfAnyChar(java.lang.CharSequence sChars, int fromWhere, int maxToTest) Returns the last position of one of the chars in sChars within the part of actual part from (fromIndex) to (fromIndex+maxToTest) or returs -1 if the char is not found in this part. Parameters: sChars - contents some chars to find. The char with code fromIndex - begin of search within the part. maxToTest - maximal numbers of chars to test. It may be Integer.MAX_VALUE. Returns: position of first founded char inside the actual part, but not greater than maxToTest. if no chars is found unitl maxToTest, but -1 if the end is reached. indexOfAnyString public final int indexOfAnyString(java.lang.CharSequence[] listStrings, int fromWhere, int maxToTest, int[] nrofFoundString, java.lang.String[] foundString) Returns the position of one of the chars in sChars within the part, started inside the part with fromIndex, returns -1 if the char is not found in the part started from 'fromIndex'. Parameters: listStrings - contains some Strings to find. fromWhere - begin of search within the part. maxToTest - maximal numbers of chars to test. It may be Integer.MAX_VALUE. nrofFoundString - If given, [0] is set with the number of the found CharSequence in listStrings, count from 0. This array reference may be null, then unused. foundString - If given, [0] is set with the found CharSequence. This array reference may be null. Returns: position of first founded char inside the actual part, but not greater than maxToTest, if no chars is found until maxToTest, but -1 if the end is reached. indexOfAnyCharOutsideQuotion public final int indexOfAnyCharOutsideQuotion(java.lang.CharSequence sChars, int fromWhere, int maxToTest) Searches any char contained in sChars in the current part but skip over quotations while testing. Example: The given string in the current part is abc "yxz" end:zxy The calling is lentoAnyCharOutsideQuotion("xyz", 20); The result is 14 because the character 'z' is found first as the end char, but outside the quoted string "xyz". Parameters: sChars - One of this chars is a endchar. It may be null: means, every chars is a endchar. fromWhere - Offset after begin to begin search. It may be 0 often. maxToTest - number of character to test from fromWhere. If maxToTest is greater then the length of the current part, only the whole current part is tested. Especially Integer.MAXVALUE and beu used. Returns: -1 if no character from sChars was found in the current part. 0.. Position of the found character inside the current part, but >= fromWhere indexOfAnyCharOutsideQuotation public final int indexOfAnyCharOutsideQuotation(java.lang.CharSequence sChars, java.lang.String sPossibleQuotChars, char transliterationChar, int fromWhere, int maxToTest) Searches any char contained in sChars in the current part but skip over quotations while testing. Example: The given string in the current part is abc "yxz" end:zxy The calling is lentoAnyCharOutsideQuotion("xyz", 20); The result is 14 because the character 'z' is found first as the end char, but outside the quoted string "xyz". Parameters: sChars - One of this chars is a endchar. It may be null: means, every chars is a endchar. sPossibleQuotChars - this defines pares of quotation character. Typically "\"\"" or also "\"\"''" or "\"\"''<>". The char on even position is the start char of a quotation and the following is the end char of that quotation, which is the same on the typical "quotation" But not on <quotation>. transliterationChar - this is a only one character which defines that the following character is not to test. Typical for \" for replacement of a simple quotation mark. fromWhere - Offset after begin to begin search. It may be 0 often. maxToTest - number of character to test from fromWhere. If maxToTest is greater then the length of the current part, only the whole current part is tested. Especially Integer.MAXVALUE and beu used. Returns: -1 if no character from sChars was found in the current part. 0.. Position of the found character inside the current part, but >= fromWhere indexEndOfQuotion public final int indexEndOfQuotion(char cEndQuotion, int fromWhere, int maxToTest) Searches the end of a quoted string. In Generally, a backslash skips over the next char and does not test it as end of the quotion. Parameters: cEndQuotion - The character which is the end of the quoted text, the end-quote-character. fromWhere - Offset after begin to begin search. It may be 0 if the quotion starts at begin, it is the position of the left quotion mark. maxToTest - Limit for searching, offset from begin. It may be Integer.MAX_INT Returns: -1 if no end of quotion is found, else the position of the char after the quotion, at least 2 because a quotion has up to 2 chars, the quotion marks itself. indexEndOfQuotation public final int indexEndOfQuotation(char cEndQuotion, char transcriptChar, int fromWhere, int maxToTest) Searches the end of a quoted string. In Generally, a backslash skips over the next char and does not test it as end of the quotion. Parameters: cEndQuotion - The character which is the end of the quoted text, the end-quote-character. transcriptChar - The character which prevents end-of-quote detection if the quote-end-character follows. fromWhere - Offset after begin to begin search. It may be 0 if the quotion starts at begin, it is the position of the left quotion mark. maxToTest - Limit for searching, offset from begin. It may be Integer.MAX_INT Returns: -1 if no end of quotion is found, else the position of the char after the quotion, at least 2 because a quotion has up to 2 chars, the quotion marks itself. indexEndOfQuotation public final int indexEndOfQuotation(char cEndQuotion, java.lang.String sInnerQuotionChars, char transcriptChar, int fromWhere, int maxToTest) Searches the end of a quoted string. In Generally, a backslash skips over the next char and does not test it as end of the quotion. Parameters: cEndQuotion - The character which is the end of the quoted text, the end-quote-character. transcriptChar - The character which prevents end-of-quote detection if the quote-end-character follows. fromWhere - Offset after begin to begin search. It may be 0 if the quotion starts at begin, it is the position of the left quotion mark. maxToTest - Limit for searching, offset from begin. It may be Integer.MAX_INT Returns: -1 if no end of quotion is found, else the position of the char after the quotion, at least 2 because a quotion has up to 2 chars, the quotion marks itself. indexOfAnyChar public final int indexOfAnyChar(java.lang.CharSequence sChars) Returns the position of one of the chars in sChars within the part, returns -1 if the char is not found in the actual part. Parameters: sChars - contents some chars to find. Returns: position of first founded char inside the actual part or -1 if not found. indexOfNoChar public final int indexOfNoChar(java.lang.CharSequence sChars, int fromWhere) Returns the position of the first char other than the chars in sChars within the part, started inside the part with fromIndex, returns -1 if all chars inside the parts started from 'fromIndex' are chars given by sChars. Parameters: sChars - contents the chars to overread. fromIndex - begin of search within the part. Returns: position of first foreign char inside the actual part or -1 if not found. indexOfNoChar public final int indexOfNoChar(java.lang.CharSequence sChars) Returns the position of the first char other than the chars in sChars within the part, returns -1 if all chars inside the parts are chars given by sChars. Parameters: sChars - contents the chars to overread. Returns: position of first foreign char inside the actual part or -1 if not found. lentoAnyChar public final StringPart lentoAnyChar(java.lang.CharSequence sChars, int maxToTest) Sets the length of the current part to any char content in sChars (terminate chars). If a terminate char is not found, the length of the current part is set to 0. The same result occurs, if a terminate char is found at begin of the current part. If the difference of this behavior is important, use instead indexOfAnyChar() and test the return value, if it is < 0. Parameters: sChars - Some chars searched as terminate char for the actual part. maxToTest - Maximum of chars to test. If the endchar isn't find inside this number of chars, the actual length is set to 0. mode - Possible values are StringPartBase.seekBack or StringPartBase.seekNormal = 0. Returns: This itself. lentoAnyChar public final StringPart lentoAnyChar(java.lang.CharSequence sChars, int maxToTest, int mode) Sets the length of the current part to any char content in sChars (terminate chars). If a terminate char is not found, the length of the current part is set to 0. The same result occurs, if a terminate char is found at begin of the current part. If the difference of this behavior is important, use instead indexOfAnyChar() and test the return value, if it is < 0. Parameters: sChars - Some chars searched as terminate char for the actual part. maxToTest - Maximum of chars to test. If the endchar isn't find inside this number of chars, the actual length is set to 0. mode - Possible values are mSeekBack or #,seekNormal = 0. Returns: This itself. lentoAnyString public final StringPart lentoAnyString(java.lang.CharSequence[] strings, int maxToTest) Sets the length of the current part to any terminate string given in sString. If a terminate string is not found, the length of the current part is set to 0. The same result occurs, if a terminate string is found at begin of the current part. If the difference of this behavior is important, use instead indexOfAnyChar() and test the return value, if it is < 0. Parameters: sString - The first char is the separator. maxToTest - Maximum of chars to test. If the endchar isn't find inside this number of chars, the actual length is set to 0. Returns: This itself. lentoAnyString public final StringPart lentoAnyString(java.lang.CharSequence[] strings, int maxToTest, int mode) Sets the length of the current part to any terminate string given in sString. If a terminate string is not found, the length of the current part is set to 0. The same result occurs, if a terminate string is found at begin of the current part. If the difference of this behavior is important, use instead indexOfAnyChar() and test the return value, if it is < 0. Parameters: sString - The first char is the separator. maxToTest - Maximum of chars to test. If the endchar isn't find inside this number of chars, the actual length is set to 0. mode - possible values are StrinPart.seekNormal or StringPartBase.seekEnd. StringPartBase.seekEnd: the found string is inclusive. Returns: This itself. lentoAnyStringWithIndent public final void lentoAnyStringWithIndent(java.lang.CharSequence[] strings, java.lang.CharSequence sIndentChars, int maxToTest, java.lang.StringBuilder buffer) Sets the length of the current part to any terminate string given in sString. If a terminate string is not found, the length of the current part is set to 0. The same result occurs, if a terminate string is found at begin of the current part. If the difference of this behavior is important, use instead indexOfAnyChar() and test the return value, if it is < 0. This method consideres the indent of the first line. In followed lines all chars are skipped if there are inclose in sIndentChars until the column position of the first line. If another char not inclosed in sIndentChars is found, than it is the beginning of this line. If the last char in sIndentChars is a space " ", additional all spaces and tabs '\t' will be skipped. This method is helpfull to convert indented text into a string without the indents, at example: . /** This is a comment . * continued in a next line with indent. . but it is able that the user doesn't respect the indentation . also with to large indentation, . * *The second asterix should not be skipped. From this text passage the result is: .This is a comment .continued in a next line with indent. .but it is able that the user doesn't respect the indentation .also with to large indentation, .*The second asterix should not be skipped. Using the result it is possible to detect paragraph formatting in wikipedia style (see vishia.xml.ConvertWikistyleTextToXml.java) Parameters: strings - List of type CharSequence, containing the possible end strings. iIndentChars - possible chars inside a skipped indentation. If the last char is space (" "), also spaces after the indentation of the first line are skipped. maxToTest - Maximum of chars to test. If the endchar isn't find inside this number of chars, the actual length is set to 0. buffer - The buffer where the found String is stored. The stored String has no indentations. Since: 2007, 2010-0508 changed param buffer, because better useable in C (java2c) lentoAnyCharOutsideQuotion public final StringPart lentoAnyCharOutsideQuotion(java.lang.CharSequence sChars, int maxToTest) Sets the length of the current part to any char content in sChars (terminate chars), but skip over quotions while testing. Example: The given string is abc "yxz" ende:zxy The calling is lentoAnyCharOutsideQuotion("xyz", 20); The result current part is abc "yxz" ende: because the char 'z' is found first as the end char, but outside the quoted string "xyz". If a terminate char is not found, the length of the current part is set to 0. The same result occurs, if a terminate char is found at begin of the current part. If the difference of this behavior is important, use instead indexOfAnyChar() and test the return value, if it is < 0. Parameters: sChars - Some chars searched as terminate char for the actual part. maxToTest - Maximum of chars to test. If the endchar isn't find inside this number of chars, the actual length is set to 0. Returns: This itself. lentoAnyCharOutsideQuotation public final StringPart lentoAnyCharOutsideQuotation(java.lang.CharSequence sChars, java.lang.String sCharQuot, char cSubscribe, int maxToTest) lentoQuotionEnd public final StringPart lentoQuotionEnd(char sEndQuotion, int maxToTest) Sets the length of the current part to the end of the quotion. It is not tested here, whether or not the actual part starts with a left quotion mark. In Generally, a backslash skips over the next char and does not test it as end of the quotion. Parameters: sEndQuotion - The char determine the end of quotion, it may be at example " or ' or >. maxToTest - Maximum of chars to test. If the endchar isn't find inside this number of chars, the actual length is set to 0. Returns: This itself. lentoLineEnd public final StringPart lentoLineEnd() Sets the length of the current part to the end of the current line. Note The current part is empty if the position is on end of a line yet. Returns: this to concatenate some operations, usage example part.set(src).seek(sKey).lento(';').len0end(); Hint: use found() to detect whether the end string is found. if the end String is not found, the current part has length ==0 trimWhiteSpaces public final StringPart trimWhiteSpaces() Increments the begin of the current part over maybe found whitespaces and decrements the end of the current part over maybe found whitespaces. The found() returns false if the current part has no content. The getCurrentPart() returns an empty String if the current part has no content The method invokes seekNoWhitespace() and lenBacktoNoChar(CharSequence) with sCheckWhitespaces. Returns: this to concatenate. lentoAnyChar public final StringPart lentoAnyChar(java.lang.CharSequence sChars) Sets the length of the current part to any char content in sChars (terminate chars). If a terminate char is not found, the length of the current part is set to 0. The same result occurs, if a terminate char is found at begin of the current part. If the difference of this behavior is important, use instead indexOfAnyChar() and test the return value, if it is < 0. Parameters: sChars - Some chars searched as terminate char for the actual part. Returns: This itself. len0end public final StringPart len0end() Sets the length to the end of the maximal part if the length is 0. This method could be called at example if a end char is not detected and for that reason the part is valid to the end. Returns: this to concatenate some operations, like part.set(src).seek(sKey).lento(';').len0end(); setLengthMax public final StringPart setLengthMax() Sets the length to the end of the maximal part. lenBacktoNoChar public final StringPart lenBacktoNoChar(java.lang.CharSequence sChars) Posits the end of the part before all of the chars given in the parameter string. The start of the part is not affected. sample: lentoBacktoNoChar("123") result is: 1231231231abcd12312efghij123123123klmnopq before: ========================== after: ===================== Parameters: sChars - CharSequence with the chars to overread. Returns: this to concatenate some operations, usage example part.set(src).seek(sKey).lento(';').len0end(); Hint: use found() to detect whether the end string is found. if the end String is not found, the current part has length ==0 lenBacktoNoWhiteSpaces public final StringPart lenBacktoNoWhiteSpaces() Trims all trailing whitespaces within the part. Returns: this to concatenate some operations, usage example part.set(src).seek(sKey).lento(';').len0end(); Hint: use found() to detect whether the end string is found. if the end String is not found, the current part has length ==0 trim public final StringPart trim() Trims all leading and trailing whitespaces within the part. A Comment begins with "//". Returns: this to concat some operations, like part.set(src).seek(sKey).lento(';').len0end(); trimComment final StringPart trimComment() Trims a java- or C-style line-comment from end of part and all leading and trailing whitespaces. A Comment begins with "//". Returns: this to concat some operations, like part.set(src).seek(sKey).lento(';').len0end(); compareTo public final int compareTo(java.lang.CharSequence str2) Compares the current part with the given str2 Specified by: compareTo in interface java.lang.Comparable<java.lang.CharSequence> See Also: Comparable.compareTo(java.lang.Object) indexOf public final int indexOf(char ch) Returns the position of the char within the part, returns -1 if the char is not found in the part. The methode is likely String.indexOf(). Parameters: ch - character to find. Returns: position of the char within the part or -1 if not found within the part. Throws: The - method throws no IndexOutOfBoundaryException. It is the same behavior like String.indexOf(char, int fromEnd). indexOf public final int indexOf(char ch, int fromIndex) Returns the position of the char within the part, started inside the part with fromIndex, returns -1 if the char is not found in the part started from 'fromIndex'. The method is likely String.indexOf(). Parameters: ch - character to find. fromIndex - start of search within the part. Returns: position of the char within the part or -1 if not found within the part. Throws: The - method throws no IndexOutOfBoundaryException. If the value of fromIndex is negative or greater than the end position, -1 is returned (means: not found). It is the same behavior like String.indexOf(char, int fromEnd). indexOf public final int indexOf(java.lang.CharSequence sCmp) Returns the position of the string within the part. Returns -1 if the string is not found in the part. Example: indexOf("abc") returns 6, indexOf("fgh") returns -1 abcdefgabcdefghijk part: ============= Parameters: sCmp - string to find Returns: position of the string within the part or -1 if not found within the part. XXXindexOf public final int XXXindexOf(java.lang.CharSequence sCmp) Returns the position of the string within the part. Returns -1 if the string is not found in the part. Example: indexOf("abc") returns 6, indexOf("fgh") returns -1 abcdefgabcdefghijk part: ============= Parameters: sCmp - string to find Returns: position of the string within the part or -1 if not found within the part. indexOf public final int indexOf(java.lang.CharSequence sCmp, int fromIndex, int maxToTest) Returns the position of the string within the part. Returns -1 if the string is not found in the part. Example: indexOf("abc") returns 6, indexOf("fgh") returns -1 abcdefgabcdefghijk part: ============= Parameters: sCmp - string to find Returns: position of the string within the part or -1 if not found within the part. equals public final boolean equals(java.lang.CharSequence sCmp) Compares the Part of string with the given string startsWith public final boolean startsWith(java.lang.CharSequence sCmp) compares the Part of string with the given string. new since 2008-09: if sCmp contains a cEndOfText char (coded with \e), the end of text is tested. Parameters: sCmp - The text to compare. scan public StringPartScan scan() This routine provides the this-pointer as StringPartScan in a concatenation of StringPartBase-invocations. Returns: this Throws: java.lang.ClassCastException - if the instance is not a StringPartScan. That is an internal software error. getCurrentPosition public final long getCurrentPosition() Gets the current position, useable for rewind. This method is overwritten if derived classes uses partial content. It is the absolute position of the processed String. setCurrentPosition public final void setCurrentPosition(long pos) Sets the current position at a fix position inside the maxPart. TODO what is with rewind etc? see old StringScan. Idea: the max Part is never enlargeable to left, only made smaller to rihht. Thats why the left border of maxPart is useable for shift left the content by reading the next content from file, if the buffer is limited, larger than necessarry for a whole file's content. But all pos values should be relativ. getCurrentPos must return a relativ value, if shiftness is used. this method shuld use a relativ value. old:, useable for rewind. This method may be overwritten if derived classes uses partial content. Parameters: pos - the absolute position getCharSequenceRange public final java.lang.CharSequence getCharSequenceRange(long from, long to) Returns the current CharSequence between both given absolute positions. If meanwhile the current content is shifted, so that from or to is outside the current content, the best possible content is returned, started from current content. Usual this operation should be called near to usage without reading and shifting furthermore content. This is meaningful if StringPartFromFileLines is used. Parameters: from - absolute position from beginning of reading the file content. to - absolute position of exclusively end, if -1 then the current position. Returns: CharSequence related to the current puffer. It should be immediately processed. Since: 2022-04-30, a little bit more simple as using StringPart.Part. substring public final StringPart.Part substring(int pos, int posendP) Gets a substring inside the maximal part pos position of start relative to maxPart posend exclusive position of end. If 0 or negativ, it counts from end backward. getCurrent public final java.lang.CharSequence getCurrent(int nChars) Gets the next chars from current Position. This method don't consider the spread of the actutal and maximal part. Parameters: nChars - number of chars to return. If the number of chars available in string is less than the required number, only the available string is returned. getCurrent public final java.lang.CharSequence getCurrent() Gets the chars from current Position. getCurrentChar public final char getCurrentChar() Gets the next char at current Position. getLineAndColumn public int getLineAndColumn(int[] column) Get the Line number and the column of the begin position. Note: it returns null in this class, may be overridden. Parameters: column - if given, it should be an int[1]. Then the column is written into. The leftest position is 1 Returns: line of the begin position if given, starting with 1 for the first line. This basic implementation returns 0 for the line and left the column unchanged. getCurrentColumn public final int getCurrentColumn() Gets the current position in line (column of the text). It is the number of chars from the last '\n' or from beginning to the actual char. Returns: Position of the actual char from begin of line, leftest position is 0. getInputfile public final java.lang.String getInputfile() This method may be overridden to return the file which is used to build this Stringpart. Returns: null in this implementation, no file available. getCurrentPart public final StringPart.Part getCurrentPart() Returns the actual part of the string. setCurrentPartTo protected final void setCurrentPartTo(StringPart.Part dst) Sets the actual part of the given Part as destination. The Part references the substring inside content. The content can be gotten as String from dst with StringPart.Part.toString() Note: renaming 1019-05-26 from setCurrentPart(...). getLastPart public final java.lang.CharSequence getLastPart() Returns the last part of the string before any seek or scan operation. getCurrentPart public final java.lang.CharSequence getCurrentPart(int maxLength) Returns the actual part of the string. Parameters: maxLength - if <0 (especially -1) then use the given length without limitation. elsewhere it is a limitation of characters, maybe necessary if a buffer or space to display is limited. 0 : take 0 characters. getPart public final StringPart.Part getPart(int fromPos, int nrofChars) Retrurn the part from start to end independent of the current positions. This method is proper to get an older part for example to log a text afterwards the text is processed. Store the getCurrentPosition() and #getLen() and apply it here! Note that it is possible that an older part of string is not available furthermore if a less buffer is used and the string in the buffer was shifted out. Then this method may be overridden and returns an error hint. Parameters: fromPos - The start position for the returned content. It must be a valid position. nrofChars - The number of characters. It must be >= 0. If the content is shorter, that shorter part is returned without error. For example getPart(myPos, Integer.MAXINT) returns all the content till its end. Returns: A CharSequence. Note that the returned value should be processed immediately in the same thread. before other routines are invoked from this class. It should not stored as a reference and used later. The CharSequence may be changed later. If it is necessary, invoke toString() with this returned value. absCharAt protected final char absCharAt(int index) absSubString protected final java.lang.String absSubString(int from, int to) Returns a String from absolute range. Parameters: from - The absolute position. to - The absolute end. Returns: A valid String or an IllegalArgumentException is occurred toString public java.lang.String toString() Specified by: toString in interface java.lang.CharSequence Overrides: toString in class java.lang.Object debugString public final java.lang.String debugString() Returns a debug information of the content of the StringPart. This information is structured in the followed way: "CONTENT_FROM_BEGIN<<<34,45>>>CONTENT_PART<<<" whereat CONTENT_FROM_BEGIN are the first 20 chars of the whole content 34 in this sample is the start position 45 in this sample is the exclusively end position CONTENT_PART are the first 20 chars from start position throwIndexOutOfBoundsException private final void throwIndexOutOfBoundsException(java.lang.String sMsg) throws java.lang.IndexOutOfBoundsException Central mehtod to invoke excpetion, usefull to set a breakpoint in debug or to add some standard informations. Parameters: sMsg - Throws: java.lang.IndexOutOfBoundsException throwIllegalArgumentException private static final void throwIllegalArgumentException(java.lang.String msg, int value) clean public void clean() Cleans the instance. This routine should be called if the StringPart is no more used, but it may be kept because it is part of any other class data or running routine. The associated String is released. It can be recycled by garbage collector. close @Deprecated public void close() Deprecated. The idea offering close() here comes from the following: Closes the work. This routine should be called if the StringPart is no more used, but it may be kept because it is part of class data or part of a statement block which runs. The associated String is released. It can be recycled by garbage collector. If this method is overridden, it should used to close a associated file which is opened for this String processing. The overridden method should call super->close() too. But this is bad, more simple: If the derived class imolements Closeable, that is ok and not related to this class. On end of close this clean() should be called, simple! Note: if only this class is instantiated and the instance will be garbaged, close is not necessary. A warning or error "Resource leak" can be switched off. Therefore the interface Closeable is not used here. replace public static java.lang.CharSequence replace(java.lang.CharSequence src, java.lang.CharSequence[] placeholder, java.lang.CharSequence[] value, java.lang.StringBuilder dstArg) Replaces up to 20 placeholder with a given content. The method creates a StringBuilder with buffer and a StringPart locally. Parameters: src - The source String, it may be a line. placeholder - An array of strings, any string of them may be found in the src. value - An array of strings appropriate to the placeholder. Any found placeholder will be substitute with that string. dst - A given StringBuilder-instance maybe with a start content. If null, then a StringBuilder will be created here Returns: dst if given, src will be appended to it, or a created StringBuilder with result. TODO don't create a StringBuilder but return src if src does not contain anything to replace. Since: 2016-11: returns a CharSequence instead String, it is more optimized, does not need an extra maybe unnecessary buffer. For older usages you should add toString() after the result of this routine to preserve compatibility. iterator public java.util.Iterator<StringPart> iterator() Specified by: iterator in interface java.lang.Iterable<StringPart>

Class StringPart

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.CharSequence

Methods inherited from interface java.lang.Iterable

Field Detail

sVersion

begin

end

begiMin

endMax

absPos0

posRewind

content

bCurrentOk

bStartScan

beginLast

endLast

bFound

mSeekEnd

seekEnd

mSeekCheck

mSeekBackward_

mSeekToLeft_

mSeekToLeft

seekToLeft

mSeekBack

seekBack

seekNormal

bitMode

mSkipOverWhitespace_mode

mSkipOverCommentInsideText_mode

mSkipOverCommentToEol_mode

sCheckWhitespaces

sCheckNewline

sFile

sCommentStart

sCommentEnd

sCommentToEol

Constructor Detail

StringPart

StringPart

StringPart

Method Detail

setInputfile

assign

assignReplaceEnv

assign

assignFromEnd

setIgnoreComment

setIgnoreComment

setIgnoreEndlineComment

setIgnoreEndlineComment

setIgnoreWhitespaces

setBeginMaxPart

setCurrentMaxPart

setParttoMax

fromEnd

charAt

checkCharAt

subSequence

throwSubSeqFaulty

length

getLenCurrent

lengthMaxPart

lento

lentoPos

lento

lento

lento

lentoIdentifier

lentoIdentifier

lentoNumber

contentTillSpaceEndOrQuotation

lentoAnyNonEscapedChar

lentoNonEscapedString

line