MemString (BandM metatools API doc)

java.lang.Object
- eu.bandm.tools.d2d2.infra.MemString

All Implemented Interfaces:

Cloneable

Direct Known Subclasses:

MemScanner
```
public class MemString
extends Object
implements Cloneable
```
Any memString is either one pointer (i.e. a position) or two pointers (i.e. a range) into a range of memory filled with character data, i.e. a MemString.CharMem. It supports sequential access and maintains line and column counters as follows:
Line>=0, Column=0 is the first visible character in the line.
Line=0,Column=-1 means pointing to a non-existing char preceding ALL data.
Line>0,Column=-1 means pointing to the LF-char ending the preceding line.

Currently this class is used as a base class for MemScanner.
CHAR_EOTEXT is currently set to 0x0000. It is reserved for "end of data" indication. It must not be contained in any method's arguments! Most methods on this level do NOT test for "end of data", but rely on lower-level access violation in case of overrun.

MemStrings normally behave immutable, but for some methods there are desctructive variants, the names of which end with an "X"

The character "0x0A" is used "hard" for linefeed recognition. For use with windows and Mac systems a LineNumberReader is inserted which does normalization to this character.

Currently only used by Udom2Sax, Def2Doc3, ModuleRegistry, Tasks, Text2Udom, MemScanner, Batch, Rt, Calendaric, Batch

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`MemString.CharMem`
`class`	`MemString.ReadBehindBufferEndException`
`class`	`MemString.Reader` used for `aMemString.new Reader()` to use the memString as sequential character data source, e.g.

Field Summary

Fields
Modifier and Type	Field and Description
`static char`	`CHAR_EOTEXT`
`static char`	`CHAR_NEWLINE`
`protected int`	`colnum`
`protected MemString.CharMem`	`data`
`protected int`	`len`
`protected int`	`linenum`
`protected int`	`start`

Constructor Summary

Constructors
Constructor and Description
`MemString(MemString.CharMem mem)` Creates a MemString pointing to the first character in the whole character data, as given by the charmMem.
`MemString(MemString ms)` Creates a copy of the MemString argument.
`MemString(String id, String data)` Creates a new `MemString.CharMem` store and creates a new MemString pointing to the first character in this data.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`adjustLineNumberX()` destructive variant: after advancement guaranteed not to CROSS a linefeed, (by any method which adds directly to pos and colnum) the fact of pointing TO a linefeed will be reflected in colnum/linenum.
`MemString`	`advance()` returns a memString which points one(1) character position behind the current porision of `this` and adjusts line and column number accordingly.
`MemString`	`advanceBy(int count)`
`void`	`advanceByX_sameLine(int i)` destructive variant: advance position and column number by the argument.
`void`	`advanceX()` destructive variant: modifies `this` to point one(1) character position behind its current position, and adjusts line and column number FIXME test for CHAR_EOTEXT !?!
`int`	`appendAll(StringBuilder sb)`
`String`	`asString()`
`void`	`backwardsX()` destructive variant: modifies `this` to point one(1) character position before its current position and adjusts line and column number Currently only needed by Text2Udom, when parsing the FILE HEADER.
`void`	`backwardsX(int num)` destructive variant: modifies `this` to point given characters position before its current position and adjusts line and column number
`protected void`	`calccolnum()` Count distance to newline character backwards in data.
`void`	`clearLineX()` Writes a blank character to all positions in the data mem from the current position up to the end of the line. Uses `advanceX()`, so see there for exceptions.
`MemString`	`copy()` returns a clone.
`boolean`	`equals(String n)` Currently returns the same result as `isPrefixedBy()`, i.e.
`int`	`get_colnum()`
`MemString.CharMem`	`get_data()`
`int`	`get_len()`
`int`	`get_linenum()`
`int`	`get_start()`
`char`	`getChar()`
`char`	`getChar(int i)`
`Location<String>`	`getFollowLocation()` Returns a location of the position directly after this MemString.
`Location<String>`	`getLocation()` Returns a location with the field value `MemString.CharMem.originalAddress` and the line and column number.
`MemString`	`getNextLine()` Returns a new MemString object pointing to the linefeed character preceding the character data of the follower line. Uses `advanceX()`, so see there for exceptions.
`void`	`getNextLineX()` Desctructive variant of `getNextLine()`: alters `this`. Uses `advanceX()`, so see there for exceptions.
`String`	`getPositionIndication()` Returns a string containing blanks and one single "up-arrow" to indicate the current column optically.
`void`	`initFrom(MemString ms)` Re-sets all values of "this" to the values of the argument.
`boolean`	`isPrefixedBy(String n)` Returns what it says.
`static void`	`main(String[] args)`
`void`	`putChar(char c)` Writes the character argument to the current position.
`String`	`toString()` Returns a string containing a representation of the underlying `MemString.CharMem`, the position, length, line and column number, and the first 10 characters.
`MemString`	`upTo(MemString n)` Returns a new MemString describing the range starting with `this` and ending before the argument.
`void`	`upToX(MemString n)` destructive variant: alters `this` to a region ending before the argument.

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

- Field Detail
  - CHAR_EOTEXT
```
public static final char CHAR_EOTEXT
```
    See Also:
    
    Constant Field Values
  - CHAR_NEWLINE
```
public static final char CHAR_NEWLINE
```
    See Also:
    
    Constant Field Values
  - data
```
protected MemString.CharMem data
```
  - start
```
protected int start
```
  - len
```
protected int len
```
  - linenum
```
protected int linenum
```
  - colnum
```
protected int colnum
```
- Constructor Detail
  - MemString
```
public MemString(MemString.CharMem mem)
```
    Creates a MemString pointing to the first character in the whole character data, as given by the charmMem.
  - MemString
```
public MemString(String id,
                 String data)
```
    Creates a new MemString.CharMem store and creates a new MemString pointing to the first character in this data.
  - MemString
```
public MemString(MemString ms)
```
    Creates a copy of the MemString argument.
- Method Detail
  - asString
```
public String asString()
```
  - appendAll
```
public int appendAll(StringBuilder sb)
```
  - getChar
```
public char getChar()
```
  - getChar
```
public char getChar(int i)
```
  - initFrom
```
public void initFrom(MemString ms)
```
    Re-sets all values of "this" to the values of the argument. This is often a copy of a former state of "this", made by copy()
    Needed in package "../base"
  - toString
```
public String toString()
```
    Returns a string containing a representation of the underlying MemString.CharMem, the position, length, line and column number, and the first 10 characters.
    
    Overrides:
    
    toString in class Object
  - getLocation
```
public Location<String> getLocation()
```
    Returns a location with the field value MemString.CharMem.originalAddress and the line and column number.
    
    attention: these numbers are 1-(one)-based. They are one(1) bigger than the numbers stored internally and described above.
  - getFollowLocation
```
public Location<String> getFollowLocation()
```
    Returns a location of the position directly after this MemString. See getLocation() for caveats.
  - copy
```
public MemString copy()
```
    returns a clone.
  - upTo
```
public MemString upTo(MemString n)
```
    Returns a new MemString describing the range starting with this and ending before the argument.
    
    Throws:
    
    IllegalArgumentException - when the underlying CharMem is not identical, or the argument is "left of" this.
  - upToX
```
public void upToX(MemString n)
```
    destructive variant: alters this to a region ending before the argument.
    
    Throws:
    
    IllegalArgumentException - when the underlying CharMem is not identical, or the argument is "left of" this.
  - equals
```
public boolean equals(String n)
```
    Currently returns the same result as isPrefixedBy(), i.e. does not check maximal length contraints.
  - isPrefixedBy
```
public boolean isPrefixedBy(String n)
```
    Returns what it says.
  - getNextLine
```
public MemString getNextLine()
```
    Returns a new MemString object pointing to the linefeed character preceding the character data of the follower line.
    Uses advanceX(), so see there for exceptions.
  - getNextLineX
```
public void getNextLineX()
```
    Desctructive variant of getNextLine(): alters this.
    Uses advanceX(), so see there for exceptions.
  - clearLineX
```
public void clearLineX()
```
    Writes a blank character to all positions in the data mem from the current position up to the end of the line.
    Uses advanceX(), so see there for exceptions.
  - putChar
```
public void putChar(char c)
```
    Writes the character argument to the current position.
  - advance
```
public MemString advance()
```
    returns a memString which points one(1) character position behind the current porision of this and adjusts line and column number accordingly.
    Uses advanceX(), so see there for exceptions.
  - advanceBy
```
public MemString advanceBy(int count)
```
  - advanceByX_sameLine
```
public void advanceByX_sameLine(int i)
```
    destructive variant: advance position and column number by the argument. Assume that no linefeed is crossed by this advancement. The new position may be a linefeed, which will lead to an adjustment. Currently only needed by MemScanner.
  - adjustLineNumberX
```
public void adjustLineNumberX()
```
    destructive variant: after advancement guaranteed not to CROSS a linefeed, (by any method which adds directly to pos and colnum) the fact of pointing TO a linefeed will be reflected in colnum/linenum.
  - advanceX
```
public void advanceX()
```
    destructive variant: modifies this to point one(1) character position behind its current position, and adjusts line and column number FIXME test for CHAR_EOTEXT !?!
  - calccolnum
```
protected void calccolnum()
```
    Count distance to newline character backwards in data. Only needed by backwardsX()
  - backwardsX
```
public void backwardsX()
```
    destructive variant: modifies this to point one(1) character position before its current position and adjusts line and column number
    Currently only needed by Text2Udom, when parsing the FILE HEADER.
  - backwardsX
```
public void backwardsX(int num)
```
    destructive variant: modifies this to point given characters position before its current position and adjusts line and column number
  - get_len
```
public int get_len()
```
  - get_start
```
public int get_start()
```
  - get_linenum
```
public int get_linenum()
```
  - get_colnum
```
public int get_colnum()
```
  - get_data
```
public MemString.CharMem get_data()
```
  - getPositionIndication
```
public String getPositionIndication()
```
    Returns a string containing blanks and one single "up-arrow" to indicate the current column optically.
  - main
```
public static void main(String[] args)
                 throws IOException
```
    Throws:
    
    IOException

Class MemString

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

CHAR_EOTEXT

CHAR_NEWLINE

data

start

len

linenum

colnum

Constructor Detail

MemString

MemString

MemString

Method Detail

asString

appendAll

getChar

getChar

initFrom

toString

getLocation

getFollowLocation

copy

upTo

upToX

equals

isPrefixedBy

getNextLine

getNextLineX

clearLineX

putChar

advance

advanceBy

advanceByX_sameLine

adjustLineNumberX

advanceX

calccolnum

backwardsX

backwardsX

get_len

get_start

get_linenum

get_colnum

get_data

getPositionIndication

main