ByteDataAccess

java.lang.Object
- org.vishia.byteData.ByteDataAccess

Direct Known Subclasses:

ByteDataAccessDbg

Deprecated.
use ByteDataAccessBase for new Algorithm. This is the original code from 2014-01-13, only formally adapted. The ByteDataAccessBase contains the same wideness, but with the concept of prevent using virtual methods and with a given size of head. That is better than the specifyLengthElementHead() as virtual method especially for usage in C.
```
@Deprecated
public abstract class ByteDataAccess
extends java.lang.Object
```
This class is a base class to control the access to binary data. The binary data may typically used or produced from a part of software written in C or C++. There the binary data are struct-constructs. Another example - build of datagram structures.
This class is a base class which should be derived for user's necessities. The methods getInt16(int) etc. are protected. That should prevent erratic free accesses to data at application level. A derived class of this class structures the software for byte data access.

It is able to support several kinds of structured data access:
- Simple C-like struct are adequate mapped with a simple derived class of this class, using the protected commonly access methods like _getLong(int, int) with predefined indexes in special methods like getValueXyz().
- Complex struct with nested struct inside are mapped with one derived class per struct, define one reference per nested struct and overwriting the method assignDataToFixChilds()
- Base struct inside a struct (inheritance in C) can be mapped with extra derived classes for the base struct and usind the assignCasted_i(ByteDataAccess, int)-method.
- A pack of data with several struct may be mapped using the -method. Thereby a parent should be defined, and the structs of the pack are children of this parent. That structs need not be from the same type.
- packs of struct with parent are nestable, it is constructable as a tree of pack of structs. The parent of the pack is the tree node. It is likewise a XML tree. The data may be also transformed to a XML data representation or the data structure may be explained with a XML tree, but they are not XML data straight.
This application possibilities show a capable of development system to access binary data. The other, hand made way was calculate with indices of the byte[idx] specially user programmed. This class helps to make such complex index calculation needlessly. One struct at C level corresponds with one derivated class of ByteDataAccess. But last also a generation of the java code from C/C++-header files containing the structs is able to. So the definition of byte positions are made only on one source. The C/C++ is primary thereby.
children, currentChild, addChild
Children are used to evaluate or write different data structures after a known structure. The children may be from several derived types of this class. With children and children inside children a tree of different data can be built or evaluated. If no child is added yet, the indices have the following values:
- idxCurrentChild = -1.
- idxCurrentChildEnd = index after known (head-) data.
- idxCurrentChild = the index after the last known child or known (head-) data. It is idxCurrentChildEnd from state before.
- idxCurrentChildEnd = -2, because the length of the child is unknown. The -2 is used to mark call of next().
A call of addChild() or its adequate addChildXY() sets the indices to the given current child:
- idxCurrentChild = the index after known (first head-) data, the index of the child.
- idxCurrentChildEnd = idxCurrentChild + specifyLengthElement() if this method returns >=0.
- idxCurrentChildEnd = idxCurrentChild + specifyLengthElementHead() if this method returns >=0.
- idxCurrentChildEnd = -1, because the length of the child is not known yet if both methods return -1.
The length of the current Child may be set while evaluating the child's data. The user should call setLengthElement(int) with the child or #setLengthCurrentChildElement(int) with the parent, respectively with this.
- idxCurrentChild = is still the index of the child.
- idxCurrentChildEnd = idxCurrentChild + given length.
If this methods are not called, but next() or addChild...() is called however, without a known length but this (the parent) knows the rules to determine the length of its possible children, it is possible to do that. The method specifyLengthCurrentChildElement() supplied the number of bytes. But if this method is not overwritten in the inherited class, an exception is thrown.
The UML structure of such an class in a environment may be shown with the followed object model diagram,
<+>---> is a composition, <>---> is a aggregation, <|---- is a inherition.
```
                      +-------------------------------+                 +----------+
                      | ByteDataAccess                |----data-------->| byte[]   |
                      |-------------------------------|                 +----------+
                      |idxBegin:int                   |
                      |idxChild:int                   |<---------------+ a known parent
  +-------------+     |idxEnd:int                     |---parent-------+ setted in addChild()
  | derivated   |     |-------------------------------|
  | user        |---|>|specifyLengthElement()         |
  | classes     |     |specifyLengthElementHead()     |
  +-------------+     |specifyLengthCurrentChild()    |
                      +-------------------------------+
 
```

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`_version_` Deprecated. The version.
`protected boolean`	`bBigEndian` Deprecated. Flag is set or get data in big endian or little endian (if false)
`protected boolean`	`bExpand` Deprecated. True if the `idxEnd` should be increment on adding children.
`(package private) java.lang.String`	`charset` Deprecated. The charset.
`protected byte[]`	`data` Deprecated. The array containing the binary data.
`protected int`	`idxBegin` Deprecated. Index of the beginning of the actual element in data
`protected int`	`idxCurrentChild` Deprecated. Index within the at position of the current child element.
`protected int`	`idxCurrentChildEnd` Deprecated. Index of the currents child end.
`protected int`	`idxEnd` Deprecated. Index of the end of the actual element in data
`protected int`	`idxFirstChild` Deprecated. Index of the first child element, it is after the head.
`static byte`	`kEndOfElements` Deprecated. Definition of the code of end of information, return from next()
`protected static int`	`kIdxElementCode` Deprecated. Index in the data, position of element code
`protected static int`	`kInitializedWithLength` Deprecated. Designation whether a instance is initialized with a local length.
`static byte`	`kNothing` Deprecated. Definition of the code of no information, return from next()
`static byte`	`kText` Deprecated. Aussage: es ist ein String (XML: text()), kein Tag im String
`static byte`	`kUndefined` Deprecated. coding: the value is undefined
`private ByteDataAccess`	`parent` Deprecated. The parent XmlBinCodeElement, necessary only for add() and expand().
`(package private) StringFormatter`	`toStringformatter` Deprecated. Use especially for test, only used in toString().

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`ByteDataAccess()` Deprecated. Constructs a new empty instance.
`protected`	`ByteDataAccess(int sizeHead, int sizeData)` Deprecated. Constructs a new empty instance.

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`protected long`	`_getLong(int idxInChild, int nrofBytesAndSign)` Deprecated. Returns the content of 1 to 8 bytes inside the actual element as a long number, big- or little-endian depending on setBigEndian().
`protected java.lang.String`	`_getString(int idx, int nrofBytes)` Deprecated. sets the content inside the acutal element with the character bytes from the given String.
`protected void`	`_setLong(int idx, int nrofBytes, long val)` Deprecated. sets the content of 1 to 8 bytes inside the actual element as a long number, big- or little-endian depending on setBigEndian().
`protected void`	`_setString(int idx, int nrofBytes, java.lang.String value, java.lang.String sEncoding, boolean preventCtrlChars)` Deprecated. sets the content inside the actual element with the character bytes from the given String.
`boolean`	`addChild(ByteDataAccess child)` Deprecated. adds an child Element after the current child or as first child after head.
`void`	`addChildEmpty(ByteDataAccess child)` Deprecated. Adds a child Element at current end of data to write data.
`void`	`addChildFloat(float value)` Deprecated. Adds a child for 1 integer value without a child instance, and sets the value as integer.
`void`	`addChildInteger(int nrofBytes, long value)` Deprecated. Adds a child for 1 integer value without a child instance, and sets the value as integer.
`void`	`addChildString(java.lang.CharSequence value)` Deprecated. Adds a child with String value.
`void`	`addChildString(java.lang.CharSequence valueCs, java.lang.String sEncoding)` Deprecated. Adds a child with String value.
`void`	`addChildString(java.lang.String value, java.lang.String sEncoding, boolean preventCtrlChars)` Deprecated. Adds a child with String value.
`boolean`	`assertNotExpandable()` Deprecated.
`void`	`assignAsChild(ByteDataAccess parent)` Deprecated. use addChild()
`void`	`assignAtIndex(int idxChildInParent, ByteDataAccess parent)` Deprecated. assigns the element to the given position of the parents data to present a child of the parent.
`void`	`assignAtIndex(int idxChildInParent, int lengthChild, ByteDataAccess parent)` Deprecated. assigns the element to the given position of the parents data to present a child of the parent with a defined length.
`protected void`	`assignCasted_i(ByteDataAccess src, int offsetCastToInput, int lengthDst)` Deprecated. Assigns this element to the same position in data, but it is another view.
`void`	`assignData(byte[] data, int length)` Deprecated. Assigns new data to this element.
`void`	`assignData(byte[] data, int lengthData, int index)` Deprecated. Assigns data without a given length of head.
`void`	`assignData(byte[] dataP, int lengthHead, int lengthData, int index)` Deprecated. Assigns new data to this element at given index in data.
`protected void`	`assignDataToFixChilds()` Deprecated. This method is called inside all assign...() methods.
`protected void`	`assignDowncast_i(ByteDataAccess input)` Deprecated. Older form, see protected method `assignCasted_i(ByteDataAccess, int )` If a cast is possible, it should be programmed in the derivated class.
`void`	`assignEmpty(byte[] data)` Deprecated. Initializes a top level, the data are considered as non initalized.
`void`	`clearData()` Deprecated. Sets all data of this element to 0.
`void`	`clearHead()` Deprecated. Sets all data of the head of this element to 0.
`void`	`copyData(int[] dst)` Deprecated. copies some data to a int[], primarily to debug a content.
`void`	`copyDataFrom(ByteDataAccess src)` Deprecated. Copies the data into a byte[]
`protected void`	`correctCurrentChildEnd(int idxEndNew)` Deprecated. Increments the idxEnd and the idxCurrentChildEnd if a new child is added.
`void`	`detach()` Deprecated. Remove all connections.
`void`	`elementAt(int indexObjectArray)` Deprecated. Counts the idxChild by given index, idxChild is ByteCount from idxBegin
`private void`	`expand(int idxCurrentChildEndNew)` Deprecated. Increments the idxEnd if a new child is added.
`void`	`expandParent()` Deprecated. Expands the end index of the parent, it means the management of the expanse of the data.
`protected char`	`getChar(int idx)` Deprecated. Returns the content of 1 bytes as ASCII inside the actual element.
`double`	`getChildDouble()` Deprecated. Adds a child for 1 double value without a child instance, but returns the value as integer.
`float`	`getChildFloat()` Deprecated. Adds a child for 1 float value without a child instance, but returns the value as integer.
`long`	`getChildInteger(int nrofBytes)` Deprecated. Adds a child for 1 integer value without a child instance, but returns the value as integer.
`java.lang.String`	`getChildString(int nrofBytes)` Deprecated. Adds a child for a String value without a child instance, but returns the value as String.
`byte[]`	`getData()` Deprecated. Returns the data buffer itself.
`protected double`	`getDouble(int idx)` Deprecated.
`protected float`	`getFloat(int idx)` Deprecated. Gets a float value from the content of 4 byte.
`protected float`	`getFloat(int idxBytes, int idxArray, int lengthArray)` Deprecated.
`protected short`	`getInt16(int idx)` Deprecated. Returns the content of 2 bytes as a positive nr between 0..65535 inside the actual element.
`protected int`	`getInt16(int idxBytes, int idxArray, int lengthArray)` Deprecated.
`int`	`getInt32(int idx)` Deprecated. Returns the content of 4 bytes inside the actual element as a integer number between -2147483648 and 2147483647, big- or little-endian depending on setBigEndian().
`protected int`	`getInt32(int idxBytes, int idxArray, int lengthArray)` Deprecated.
`protected long`	`getInt64(int idx)` Deprecated.
`protected byte`	`getInt8(int idx)` Deprecated. Returns the content of 1 bytes as a positive or negative nr between -128..127 inside the actual element.
`protected int`	`getInt8(int idxBytes, int idxArray, int lengthArray)` Deprecated.
`int`	`getLength()` Deprecated. Returns the length of the existing actual element.
`int`	`getLengthCurrentChildElement()` Deprecated. Returns the length of the current child element.
`int`	`getLengthHead()` Deprecated. Returns the length of the head.
`int`	`getLengthTotal()` Deprecated. Returns the length of the data.
`int`	`getMaxNrofBytes()` Deprecated. returns the number number of bytes there are max available from position of the current child
`int`	`getMaxNrofBytesForNextChild()` Deprecated. returns the number number of bytes there are max available from position of a next current child
`int`	`getPositionInBuffer()` Deprecated. Returns the position of the Element data in the assigned buffer.
`int`	`getPositionNextChildInBuffer()` Deprecated. Returns the position of the current child in the assigned buffer.
`protected java.lang.String`	`getString(int idx, int nmax)` Deprecated. Returns a String from the given position inside the actual element .
`protected int`	`getUint16(int idx)` Deprecated. Returns the content of 2 bytes as a positive nr between 0..65535, big-endian inside the actual element.
`protected int`	`getUint16(int idxBytes, int idxArray, int lengthArray)` Deprecated.
`int`	`getUint32(int idx)` Deprecated.
`protected int`	`getUint32(int idxBytes, int idxArray, int lengthArray)` Deprecated.
`protected int`	`getUint8(int idx)` Deprecated. Returns the content of 1 bytes as a positive or negative nr between -128..127 inside the actual element.
`protected int`	`getUint8(int idxBytes, int idxArray, int lengthArray)` Deprecated.
`protected void`	`notifyAddChild()` Deprecated. Notifies, that a child is added.
`void`	`removeChild()` Deprecated. remove the current child to assign another current child instead of the first one.
`void`	`removeChildren()` Deprecated. Remove all children.
`protected void`	`reset(int lengthHead, int lengthData)` Deprecated. Resets the view to the buffer.
`void`	`rewind()` Deprecated. starts the calling loop of next().
`void`	`setBigEndian(boolean val)` Deprecated. Sets the big or little endian mode.
`protected void`	`setDouble(int idx, double value)` Deprecated. Set the content of 8 byte from a double variable.
`protected void`	`setFloat(int idx, float value)` Deprecated. Set the content of 4 byte from a float variable.
`protected void`	`setFloat(int idxBytes, int idxArray, int lengthArray, float val)` Deprecated.
`protected boolean`	`setIdxCurrentChildEnd(int nrofBytes)` Deprecated. sets the idxCurrentChildEnd and idxEnd.
`private void`	`setIdxtoNextCurrentChild()` Deprecated. sets the idxCurrentChild to the known idxCurrentChildEnd.
`protected void`	`setInt16(int idx, int value)` Deprecated. Set the content of 2 bytes from an integer between -32768..32768, or from an integer number between 0..65535.
`protected void`	`setInt16(int idxBytes, int idxArray, int lengthArray, int val)` Deprecated.
`protected void`	`setInt32(int idx, int value)` Deprecated. Set the content of 4 bytes as a integer number between -2147483648 and 2147483647, big- or little-endian depended from setBigEndian().
`protected void`	`setInt32(int idxBytes, int idxArray, int lengthArray, int val)` Deprecated.
`protected void`	`setInt8(int idx, int value)` Deprecated. Set the content of 1 bytes as a positive nr between 0..256.
`protected void`	`setInt8(int idxBytes, int idxArray, int lengthArray, int val)` Deprecated.
`void`	`setLengthElement(int length)` Deprecated. Sets the length of the element in this and all `parent` of this.
`protected int`	`setString(int idx, int nmax, java.lang.String ss)` Deprecated. Sets a String to the the given position inside the actual element .
`protected void`	`setUint16(int idx, int value)` Deprecated. Set the content of 2 bytes as a positive nr between 0..65535, big- or little-endian.
`protected void`	`setUint16(int idxBytes, int idxArray, int lengthArray, int val)` Deprecated.
`protected void`	`setUint32(int idxBytes, int idxArray, int lengthArray, int val)` Deprecated.
`protected void`	`setUint32(int idx, long value)` Deprecated. Set the content of 4 bytes as a positive nr between 0..2pow32-1, big- or little-endian.
`protected void`	`setUint8(int idx, int value)` Deprecated. Set the content of 1 bytes as a positive nr between 0..255, big- or little-endian.
`protected void`	`setUint8(int idxBytes, int idxArray, int lengthArray, int val)` Deprecated.
`protected abstract void`	`specifyEmptyDefaultData()` Deprecated. Sets the elements data to the default empty data.
`protected int`	`specifyLengthCurrentChildElement()` Deprecated. Returns the length of a child element at current position specified in the derivated class.
`protected abstract int`	`specifyLengthElement()` Deprecated. Returns the actual length of the whole data presenting with this instance.
`abstract int`	`specifyLengthElementHead()` Deprecated. Specifies the length of the head data.
`boolean`	`sufficingBytesForNextChild(int nrofBytes)` Deprecated. returns true if the given number of bytes is sufficing in the data from position of next child.
`java.lang.String`	`toString()` Deprecated. This method is especially usefully to debug in eclipse.

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

- Field Detail
  - _version_
```
public static final int _version_
```
    Deprecated.
    The version.
    - 2014-01-12 Hartmut new: Java4C.Inline for C-compilation.
    - 2013-12-08 Hartmut new: ByteDataAccess(int, int) as super constructor with given head and data size. addChild(ByteDataAccess) accepts an initialized not used child. Uses kInitializedWithLength. That is the possibility to work without dynamic linked methods specifyLengthElement() etc. for proper work especially for C usage. The overridden methods specifyEmptyDefaultData(), notifyAddChild() etc. are proper to use in C too with the concept of the dynamic linked methods, but there does not be necessary. It is an optimizing for C. Maybe in future the specifyLengthElement() and specifyLengthElementHead() may be depreciated because the new variant of initialized children is better to use, more simple for usage. But it should be compatible with older versions.
    - 2013-12-08 Hartmut chg: reset(int, int) is protected now and has a second parameter. necessary public?
    - 2012-12-15 Hartmut chg: Some changes are done which cleans up this class. If any problem occurs, the ByteDataAccessOld can be used. It is compatible with the last version before this changes.
      
      The currentChild is not necessary. The only reason to have that association is: changes of size in parent force changes in the current child. But it is contrary: The changes should be done in the child and should affect the indices in all parents which should be known all in the child. If a child is added and it is never used furthermore then an unnecessary dangling reference exists. If the child instance is reused and detach is not called, mistakes are happen.
      the next() and rewind() are removed. It is an unused old concept.
    - 2012-04-07 Hartmut new: #reset(int), some comments.
    - 2012-03-00 Hartmut Note: compare it with java.nio.ByteBuffer. But a ByteBuffer is abstract.
    - 2010-12-20: Hartmut chg: remove the toString-method using StringFormatter, because it is too complex for C-usage. The toString was only able to use for debugging.
    - 2010-02-02: Hartmut new: getChildFloat(), getChildDouble().
    - 2010-01-16: Hartmut chg: setBigEndian in now public. It should be better because the same user data may be interpreted in both versions depending on a parameter.
    - 2005..2009: Hartmut: some changes
    - 2005 Hartmut created
    See Also:
    
    Constant Field Values
  - data
```
protected byte[] data
```
    Deprecated.
    
    The array containing the binary data.
  - idxBegin
```
protected int idxBegin
```
    Deprecated.
    
    Index of the beginning of the actual element in data
  - idxEnd
```
protected int idxEnd
```
    Deprecated.
    
    Index of the end of the actual element in data
  - bExpand
```
protected boolean bExpand
```
    Deprecated.
    
    True if the idxEnd should be increment on adding children. It is to write.
  - idxFirstChild
```
protected int idxFirstChild
```
    Deprecated.
    
    Index of the first child element, it is after the head.
  - idxCurrentChild
```
protected int idxCurrentChild
```
    Deprecated.
    
    Index within the at position of the current child element. If no current child is known, this index is -1.
  - idxCurrentChildEnd
```
protected int idxCurrentChildEnd
```
    Deprecated.
    
    Index of the currents child end. If no current child is known this index is equal idxFirstChild, it is the position after the head. If the length of the current child is not known, this index is <= idxCurrentChild.
  - bBigEndian
```
protected boolean bBigEndian
```
    Deprecated.
    
    Flag is set or get data in big endian or little endian (if false)
  - parent
```
private ByteDataAccess parent
```
    Deprecated.
    
    The parent XmlBinCodeElement, necessary only for add() and expand().
  - charset
```
java.lang.String charset
```
    Deprecated.
    
    The charset.
  - toStringformatter
```
StringFormatter toStringformatter
```
    Deprecated.
    
    Use especially for test, only used in toString().
  - kEndOfElements
```
public static final byte kEndOfElements
```
    Deprecated.
    
    Definition of the code of end of information, return from next()
    
    See Also:
    
    Constant Field Values
  - kNothing
```
public static final byte kNothing
```
    Deprecated.
    
    Definition of the code of no information, return from next()
    
    See Also:
    
    Constant Field Values
  - kText
```
public static final byte kText
```
    Deprecated.
    
    Aussage: es ist ein String (XML: text()), kein Tag im String
    
    See Also:
    
    Constant Field Values
  - kUndefined
```
public static final byte kUndefined
```
    Deprecated.
    
    coding: the value is undefined
    
    See Also:
    
    Constant Field Values
  - kInitializedWithLength
```
protected static final int kInitializedWithLength
```
    Deprecated.
    
    Designation whether a instance is initialized with a local length. See ByteDataAccess(int, int).
    
    See Also:
    
    Constant Field Values
  - kIdxElementCode
```
protected static final int kIdxElementCode
```
    Deprecated.
    
    Index in the data, position of element code
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - ByteDataAccess
```
protected ByteDataAccess()
```
    Deprecated.
    
    Constructs a new empty instance. Use assign() to work with it.
  - ByteDataAccess
```
protected ByteDataAccess(int sizeHead,
                         int sizeData)
```
    Deprecated.
    
    Constructs a new empty instance. Use assign() to work with it.
    Parameters:
    sizeHead - number of bytes for the head. See assignData(byte[], int, int, int).
    
    If negative, especially -1, the overridden method specifyLengthElementHead() is called to get the length of the head. It depends on the definition of the derived class.
    If 0 or >0, it is the length. Then the overridden method is not called, especially for usage in C.
    sizeData - number of significant bytes in data for this child.
    
    If sizeChild is to large in respect to data.length, an exception may be thrown on access.
    If the sizeChild is < 0 (especially -1), it means, it is not known outside. Than the element is initialized with its known head length calling specifyLengthElement().
    If the length is >0, it defines the size of this access. Between the head and this length some children can be added to access that data.
- Method Detail
  - getLengthHead
```
public final int getLengthHead()
```
    Deprecated.
    
    Returns the length of the head. It is specified lastly by specifyLengthElementHead() of the derived class. But this method returns the difference between (idxFirstChild - idxBegin), which is initialized in construction or assignData(byte[], int)-invocations and not changed normally.
  - specifyEmptyDefaultData
```
protected abstract void specifyEmptyDefaultData()
```
    Deprecated.
    Sets the elements data to the default empty data. This method should not called outside of this base class, likewise not in the derived class itself. This method is only called inside this base class itself inside the methods addChild() and assignEmpty(). But only the derived class knows how to set empty data. It must specify that like the followed sample:
```
protected void specifyEmptyDefaultData()
{ data[idxBegin + 0] = 0;
  data[idxBegin + kIdxMid] = 0;
  data[idxBegin + kIdxMin] = kNotAValue;
  data[idxBegin + kIdxMax] = kNotAValue;
}
```
    The default implementation is empty.
  - specifyLengthElementHead
```
public abstract int specifyLengthElementHead()
```
    Deprecated.
    Specifies the length of the head data. This is the index of the first child relative to the start position of the element. This method is called inside this base class itself inside some methods. Outside the method may be called for example to calculate the size of data.
    Only the derived class knows the position of the first child element. It must specify that like the followed sample:
```
protected void specifyLengthElementHead()
{ return kIdxFirstChild;  //kIdxFistChild should be defined as static final int.
}
```
    Returns:
    
    Position of the first child element relative to the start position.
  - specifyLengthElement
```
protected abstract int specifyLengthElement()
                                     throws java.lang.IllegalArgumentException
```
    Deprecated.
    Returns the actual length of the whole data presenting with this instance. This method should be specified in the derived class. The method is called inside this base class in the methods assignAsChild() to calculate the idxEnd.
    The calculation of the whole length of the element should be considered all existing children inside this element. The structure is user-specific. Only some examples may be given here:
    - If all children have a constant length and the number of children is known, the calculation of the length is simple: lengthOfHead + nrofChilds * lengthOfChilds.
    - If the children have a variably length, all children should be checked about its length.
    Returns:
    
    The length of this existing element or -1, if the length is not fix yet.
    
    Throws:
    
    java.lang.IllegalArgumentException - If the data inside are corrupted, the user can throw this exception.
  - notifyAddChild
```
protected void notifyAddChild()
```
    Deprecated.
    
    Notifies, that a child is added. This method may be overload, if the user must take somme actions, count the number of childs or others.
  - specifyLengthCurrentChildElement
```
protected int specifyLengthCurrentChildElement()
                                        throws java.lang.IllegalArgumentException
```
    Deprecated.
    Returns the length of a child element at current position specified in the derivated class. The derivated class must known its possible child elements and must get there length with enquiry of specifyLengthElement() of the current child types. This method is called inside the getLengthCurrentChildElement()-method esspecially called inside the next()-method to increment the index idxChild. This method is not called if setLengthCurrentChildElement() was called after calling next(). The user may precluding the call of this method if he calls setLengthCurrentChildElement in sequence of the followed sample:
```
 int eChildCode = dataCode.next();
 switch(eChildCode)
 { case ...:
   { child.assignAsChild(dataCode);             //the child is known yet!
     dataCode.setLengthCurrentChildElement(child.getLength());
     ....
   }
  If the user always calls setLengthCurrentChildElement in this manner,
 he don't need to overwrite specifyLengthCurrentChildElement.
```
    Returns:
    
    The length of the existing child element at the current position idxChild.
    
    Throws:
    
    java.lang.IllegalArgumentException
  - assignDataToFixChilds
```
protected void assignDataToFixChilds()
                              throws java.lang.IllegalArgumentException
```
    Deprecated.
    This method is called inside all assign...() methods. It should be overridden by a users derivation if any fix childs are present. In the overridden routines the method assignDataAtIndex(byte[], int) should be called for the fix childs. example:
    Throws:
    
    java.lang.IllegalArgumentException
  - setBigEndian
```
public void setBigEndian(boolean val)
```
    Deprecated.
    
    Sets the big or little endian mode. This method is override-able, because a derived class may set the endian of embedded children too.
    
    Parameters:
    
    val - true if big endian, hi byte at lower adress, false if little endian.
  - reset
```
protected final void reset(int lengthHead,
                           int lengthData)
```
    Deprecated.
    Resets the view to the buffer. The data in the buffer may be set newly. Either they are declared as empty, then call
```
 reset(0);  //all data are invalid.
  In that case the head data are initialized calling specifyEmptyDefaultData()
 from the derived class.
 


 Or the data are set newly with any designated content, then call  reset(length);
 with the known length. Then the data can be evaluate by calling addChild(ByteDataAccess).
 or by getting data from the head only if children should ot be used.
 


 See assignEmpty(byte[]), assignData(byte[], int). This routine
 is called there after setting the data reference and the idxBegin. In opposite to the
 newly assignment of data, the data-reference is not changed, the idxBegin
 is not changed and a parent is not changed. It means, a reset can be invoked for any child
 of data without changing the context.
```
    Parameters:
    
    lengthHead - Number of bytes for the head of this element. It may equal lengthData.
    
    lengthData - Number of bytes for this element.
  - assignData
```
public final void assignData(byte[] dataP,
                             int lengthHead,
                             int lengthData,
                             int index)
                      throws java.lang.IllegalArgumentException
```
    Deprecated.
    
    Assigns new data to this element at given index in data. This method is called on addChild(ByteDataAccess).
    The user may overwrite this method and call super.assignData(data, length) inside if some additional actions should be done.
    This method is also usefull to deassign a current data buffer, call assign(null, 0);.
    If the element are using before, its connection to an other parent is dissolved.
    Parameters:
    
    data - The data. The length of data may be greater as the number of the significant bytes.
    lengthHead - number of bytes for the head.
    
    If negative, especially -1, the overridden method specifyLengthElementHead() is called to get the length of the head. It depends on the definition of the derived class.
    If 0 or >0, it is the length. Then the overridden method is not called, especially for usage in C.
    lengthData - absolute Number of significant bytes in data from idx=0.
    
    If length is > data.length, an exception is thrown.
    If the length is <0 (especially -1), it means, it is not known outside. Than the element is initialized with its known head length. The length mustn't not ==0, it is tested. Use -1 also if the head length is 0.
    If the length is >0, it defines the size of this access. Between the head and this length some children can be added to access that data.
    index - Start position in data
    
    Throws:
    
    java.lang.IllegalArgumentException
  - assignData
```
public final void assignData(byte[] data,
                             int lengthData,
                             int index)
                      throws java.lang.IllegalArgumentException
```
    Deprecated.
    
    Assigns data without a given length of head. The length of the head is gotten with call of the overridden method specifyLengthElementHead() of the users class. It calls assignData(byte[], int, int, int) with lengthHead = -1.
    
    Parameters:
    
    data -
    
    lengthData -
    
    index -
    
    Throws:
    
    java.lang.IllegalArgumentException
  - assignData
```
public final void assignData(byte[] data,
                             int length)
                      throws java.lang.IllegalArgumentException
```
    Deprecated.
    
    Assigns new data to this element.
    The user may overwrite this method and call super.assignData(data, length) inside if some additional actions should be done.
    This method is also usefull to deassign a current data buffer, call assign(null, 0);.
    If the element are using before, its connection to an other parent is dissolved.
    
    Parameters:
    
    data - The data. The length of data may be greater as the number of the significant bytes.
    
    length - Number of significant bytes in data. If length is > data.length, an exception may be thrown in any state of the evaluation.
    
    Throws:
    
    java.lang.IllegalArgumentException - if the length is > data.length
  - assignEmpty
```
public final void assignEmpty(byte[] data)
```
    Deprecated.
    Initializes a top level, the data are considered as non initalized. The length of the head should be a constant value, given from method call specifyLengthElementHead(). The child Positions are set to the end of head, no childs are presumed. The head should be filled with data after that calling some methods like setInt32(int, int).
    The children should be added by calling addChild(ByteDataAccess) and filled with data after that.
    If the element are using before, its connection to an other parent is dissolved.
    Example to shown the principle:
```
   ...........the data undefined with defined length.........
   +++++                   Head, the length should be known.
        ####****#####****  Space for children,
 
```
    Parameters:
    
    data - The data. The reference should be initialized, it means the data have a defined maximum of length. But it is not tested here.
    
    Throws:
    
    java.lang.IllegalArgumentException
  - removeChildren
```
public final void removeChildren()
```
    Deprecated.
    
    Remove all children. Let the head unchanged.
    
    Since:
    
    2010-11-16
  - detach
```
public final void detach()
```
    Deprecated.
    
    Remove all connections. Especially for children.
  - assignCasted_i
```
protected final void assignCasted_i(ByteDataAccess src,
                                    int offsetCastToInput,
                                    int lengthDst)
                             throws java.lang.IllegalArgumentException
```
    Deprecated.
    
    Assigns this element to the same position in data, but it is another view. This method should be called inside a assignCasted() method if a inner head structure is known and the conclusion of this structure is possible. At result, both ByteDataAccess instances reference the same data, in different views.
    
    Parameters:
    
    src - The known data access
    
    offsetCastToInput - typical 0 if single inherition is used.
    
    Throws:
    
    java.lang.IllegalArgumentException - if a length of the new type is specified but the byte[]-data are shorter. The length of byte[] is tested.
  - assignDowncast_i
```
protected final void assignDowncast_i(ByteDataAccess input)
                               throws java.lang.IllegalArgumentException
```
    Deprecated.
    
    Older form, see protected method assignCasted_i(ByteDataAccess, int ) If a cast is possible, it should be programmed in the derivated class.
    
    Parameters:
    
    input -
    
    Throws:
    
    java.lang.IllegalArgumentException
  - assignAtIndex
```
public final void assignAtIndex(int idxChildInParent,
                                int lengthChild,
                                ByteDataAccess parent)
                         throws java.lang.IllegalArgumentException
```
    Deprecated.
    
    assigns the element to the given position of the parents data to present a child of the parent with a defined length. The difference to addChild(ByteDataAccess) is: The position is given here directly, it should not be the current child but a free child.
    The data reference is copied, the idxBegin of this element is set to the idxChild given as parameter. All other indices are set calling specifyLengthElementHead(): idxChild and specifyLengthElement(): idxEnd.
    If the element are using before, its connection to an other parent is dissolved.
    
    Parameters:
    
    parent - The parent. It should reference data.
    
    lengthChild - Number of the bytes of the free child.
    
    idxChildInParent - The index of the free child in the data.
    
    Throws:
    
    java.lang.IllegalArgumentException - If the indices are wrong in respect to the data.
  - assignAtIndex
```
public final void assignAtIndex(int idxChildInParent,
                                ByteDataAccess parent)
                         throws java.lang.IllegalArgumentException
```
    Deprecated.
    
    assigns the element to the given position of the parents data to present a child of the parent. The length of the child is limited to TODO the length of head - or not limited.
    
    Parameters:
    
    parent - The parent. It should reference data.
    
    idxChildInParent - The index of the free child in the data.
    
    Throws:
    
    java.lang.IllegalArgumentException - If the indices are wrong in respect to the data.
  - addChild
```
public final boolean addChild(ByteDataAccess child)
                       throws java.lang.IllegalArgumentException
```
    Deprecated.
    adds an child Element after the current child or as first child after head. With the aid of the child Element the data can be read or write structured.
    
    The child instance will be initialized newly. Any old usage of the child instance will be ignored. The child is only a helper to manage indices in the parent, to get data and to manage its own indices while further children were added to itself.
    
    Some children can be added after a parent like following sample:
```
 ByteAccessDerivation child = new ByteAccessDerivation();  //empty and unassigned.
 parent.addChild(child);        //The byte[] data of parent are assigned, index after current child index of parent.
 child.addChild(grandchild);    //By adding a child to this child, also the parent's index is corrected.
 
```
    Parameters:
    
    child - The child will be assigned with the data of this at index after the current child's end-index.
    
    Throws:
    
    java.lang.IllegalArgumentException - if the length of the old current child is not determined yet. Either the method specifyLengthElement() should be overwritten or the method setLengthElement(int) for the child or setLengthCurrentChildElement(int) should be called to prevent this exception.
    
    java.lang.IllegalArgumentException - if the length of the head of the new current child is to far for the data. It means, child.idxEnd > data.length.
  - assignAsChild
```
@Deprecated
public final void assignAsChild(ByteDataAccess parent)
                                      throws java.lang.IllegalArgumentException
```
    Deprecated. use addChild()
    assigns the element to the current child position of parent, to represent the current child of the parent. This method should be used by reading out byte[] data if it is detected, that the content of data matches of this derivated type of ByteDataAccess. next() should be called before. The pattern of using is:
```
 
    int nWhat;    //code of the element
    while( (nWhat = dataElement.next()) != ByteDataAccess.kEndOfElements )
    { switch(nWhat)  //test the first byte of the current element
      { case ByteDataAccess.kText:
        { sText = dataElement.getText();
        } break;
        case code1:
        { code1Element.assignAsChild(dataElement);
          evaluateValue(code1Element);
        } break:
        case code2:
        { code1Element.assignAsChild(dataElement);
          evaluateValue(code1Element);
        } break:
        default: throw new IllegalArgumentException("unknown Element", dataElement);
      }
    }
    
```
    The difference to addChild(ByteDataAccess) is: addChild() is used to writeout to data, addChild() appends the child always after idxEnd, but this method is used to read from data and appends the child at position of the current child.
    The data reference is copied, the idxBegin of this element is set to the idxChild of parent, it is the current child position. All other indices are setted calling specifyLengthElementHead(): idxChild and specifyLengthElement(): idxEnd. The idxChildEnd of parent is setted, so calling next() after this operation increments in data after this new child.
    If the element are using before, its connection to an other parent is dissolved.
    Parameters:
    
    parent - The parent. It should reference data, and a current child position should be set by calling next() before. See sample at next().
    
    Throws:
    
    java.lang.IllegalArgumentException - If the data are wrong. The exception is thrown orginal from specifyLengthElement().
  - removeChild
```
public final void removeChild()
                       throws java.lang.IllegalArgumentException
```
    Deprecated.
    
    remove the current child to assign another current child instead of the first one. This method is usefull if data are tested with several structures. It mustn't be called in expand mode. In expand mode you have to be consider about your children.
    
    Parameters:
    
    child -
    
    Throws:
    
    java.lang.IllegalArgumentException
  - setIdxtoNextCurrentChild
```
private final void setIdxtoNextCurrentChild()
```
    Deprecated.
    sets the idxCurrentChild to the known idxCurrentChildEnd. This method is called while addChild. The state before is:
    - idxCurrentChild is the index of the up to now current Child, or -1 if no child was added before.
    - idxCurrentChildEnd is the actual end index of the current Child, or the index of the first child (after head, may be also 0 if the head has 0 bytes), if no child was added before.
      The state after is:
      idxCurrentChild is set to the idxCurrentChildEnd from state before.
      idxCurrentChildEnd is set to -1, because it is not defined yet.
      If idxCurrentChildEnd >= idxCurrentChild, it means that this operation respectively next() was called before. Than this operation is done already, a second call does nothing.
      The length of the current child should be set after this operation and before this operation respectively the calling operation addChild() will be called a second one. This is done in the calling routines.
  - setIdxCurrentChildEnd
```
protected final boolean setIdxCurrentChildEnd(int nrofBytes)
                                       throws java.lang.IllegalArgumentException
```
    Deprecated.
    sets the idxCurrentChildEnd and idxEnd. There are two modi:
    - Expand data: the idxEnd == idxCurrenChild. In this case the idxEnd will be expanded.
    - Use existing data: idxEnd > idxCurrentChild: In this case the idxEnd should be >= idxCurrentChild + nrofBytes.
    Parameters:
    
    nrofBytes - of the child
    
    Returns:
    
    true if the data are expanded.
    
    Throws:
    
    java.lang.IllegalArgumentException - if there are not enough data. In expanded mode the data.length are to less. In using existing data: idxEnd are to less.
  - addChildEmpty
```
public final void addChildEmpty(ByteDataAccess child)
                         throws java.lang.IllegalArgumentException
```
    Deprecated.
    
    Adds a child Element at current end of data to write data. The child's data are initialized with call of child.specifyEmptyDefaultData().
    
    Parameters:
    
    child - The child will associated to this and should be used to add some content.
    
    Throws:
    
    java.lang.IllegalArgumentException
  - correctCurrentChildEnd
```
protected final void correctCurrentChildEnd(int idxEndNew)
```
    Deprecated.
    
    Increments the idxEnd and the idxCurrentChildEnd if a new child is added. Called only inside method addChild(child) and recursively to correct in all parents.
  - expand
```
private final void expand(int idxCurrentChildEndNew)
```
    Deprecated.
    
    Increments the idxEnd if a new child is added. It is called inside method addChild(child) and recursively to correct in all parents.
  - expandParent
```
public final void expandParent()
                        throws java.lang.IllegalArgumentException
```
    Deprecated.
    
    Expands the end index of the parent, it means the management of the expanse of the data.
    
    Throws:
    
    java.lang.IllegalArgumentException
  - getChildInteger
```
public final long getChildInteger(int nrofBytes)
                           throws java.lang.IllegalArgumentException
```
    Deprecated.
    
    Adds a child for 1 integer value without a child instance, but returns the value as integer.
    
    Parameters:
    
    nrofBytes - of the integer
    
    Returns:
    
    value in long format, cast it to (int) if you read only 4 bytes etc.
    
    Throws:
    
    java.lang.IllegalArgumentException - if not data has not enaught bytes.
  - getChildFloat
```
public final float getChildFloat()
                          throws java.lang.IllegalArgumentException
```
    Deprecated.
    
    Adds a child for 1 float value without a child instance, but returns the value as integer.
    
    Returns:
    
    value in float format
    
    Throws:
    
    java.lang.IllegalArgumentException - if not data has not enaught bytes.
  - getChildDouble
```
public final double getChildDouble()
                            throws java.lang.IllegalArgumentException
```
    Deprecated.
    
    Adds a child for 1 double value without a child instance, but returns the value as integer.
    
    Returns:
    
    value in float format
    
    Throws:
    
    java.lang.IllegalArgumentException - if not data has not enaught bytes.
  - addChildInteger
```
public final void addChildInteger(int nrofBytes,
                                  long value)
                           throws java.lang.IllegalArgumentException
```
    Deprecated.
    
    Adds a child for 1 integer value without a child instance, and sets the value as integer.
    
    Parameters:
    
    nrofBytes - of the integer
    
    Throws:
    
    java.lang.IllegalArgumentException
  - addChildFloat
```
public final void addChildFloat(float value)
                         throws java.lang.IllegalArgumentException
```
    Deprecated.
    
    Adds a child for 1 integer value without a child instance, and sets the value as integer.
    
    Parameters:
    
    nrofBytes - of the integer
    
    Throws:
    
    java.lang.IllegalArgumentException
  - getChildString
```
public final java.lang.String getChildString(int nrofBytes)
                                      throws java.lang.IllegalArgumentException,
                                             java.io.UnsupportedEncodingException
```
    Deprecated.
    
    Adds a child for a String value without a child instance, but returns the value as String.
    
    Parameters:
    
    nrofBytes - of the integer
    
    Returns:
    
    value in long format, cast it to (int) if you read only 4 bytes etc.
    
    Throws:
    
    java.lang.IllegalArgumentException - if not data has not enaught bytes.
    
    java.io.UnsupportedEncodingException
  - addChildString
```
public final void addChildString(java.lang.String value,
                                 java.lang.String sEncoding,
                                 boolean preventCtrlChars)
                          throws java.lang.IllegalArgumentException,
                                 java.io.UnsupportedEncodingException
```
    Deprecated.
    
    Adds a child with String value.
    
    Parameters:
    
    value - String to add
    
    sEncoding - If null then use the standard encoding of the system-environment.
    
    preventCtrlChars - true then values < 0x20 are not set. If the String value contain a control character with code < 0x20, a '?' is written. This behavior guarantees, that byte-values < 0x20 can use to detect no-String elements, see getByteNextChild().
    
    Throws:
    
    java.lang.IllegalArgumentException
    
    java.io.UnsupportedEncodingException
  - addChildString
```
public final void addChildString(java.lang.CharSequence valueCs,
                                 java.lang.String sEncoding)
                          throws java.lang.IllegalArgumentException,
                                 java.io.UnsupportedEncodingException
```
    Deprecated.
    
    Adds a child with String value.
    
    Parameters:
    
    valueCs - String to add, @pjava2c=nonPersistent.
    
    sEncoding - String describes the encoding for translation from UTF16 to bytes.
    
    Throws:
    
    java.lang.IllegalArgumentException - XXX
    
    java.io.UnsupportedEncodingException
  - addChildString
```
public final void addChildString(java.lang.CharSequence value)
                          throws java.lang.IllegalArgumentException
```
    Deprecated.
    
    Adds a child with String value.
    
    Parameters:
    
    value - String to add, @pjava2c=nonPersistent.
    
    Throws:
    
    java.lang.IllegalArgumentException
  - rewind
```
public final void rewind()
```
    Deprecated.
    
    starts the calling loop of next(). The calling of next() after them supplies the first child element.
  - sufficingBytesForNextChild
```
public final boolean sufficingBytesForNextChild(int nrofBytes)
                                         throws java.lang.IllegalArgumentException
```
    Deprecated.
    
    returns true if the given number of bytes is sufficing in the data from position of next child.
    
    Parameters:
    
    nrofBytes - that should fitting in the given data range from current child position to the end of data determines by calling assingData(...) or by calling addChild() with a known size of child or setLengthElement() .
    
    Returns:
    
    true if it is okay, false if the nrofBytes are negative or to large.
    
    Throws:
    
    java.lang.IllegalArgumentException - see getMaxNrofBytesForNextChild()
  - getMaxNrofBytesForNextChild
```
public final int getMaxNrofBytesForNextChild()
                                      throws java.lang.IllegalArgumentException
```
    Deprecated.
    
    returns the number number of bytes there are max available from position of a next current child. , the number of bytes to the end of buffer is returned.
    
    Returns:
    
    nrofBytes that should fitting in the given data range from current child position to the end of data determines by calling assingData(...) or by calling addChild() with a known size of child or setLengthElement() .
    
    Throws:
    
    java.lang.IllegalArgumentException - if the length of the current child is not determined yet. Either the method specifyLengthElement() should be overwritten or the method setLengthElement(int) for the child or setLengthCurrentChildElement(int) should be called to prevent this exception.
  - getMaxNrofBytes
```
public final int getMaxNrofBytes()
```
    Deprecated.
    
    returns the number number of bytes there are max available from position of the current child. , the number of bytes to the end of buffer is returned.
    
    Returns:
    
    nrofBytes that should fitting in the given data range from current child position to the end of data determines by calling assingData(...) or by calling addChild() with a known size of child or setLengthElement() .
  - getLength
```
public final int getLength()
```
    Deprecated.
    
    Returns the length of the existing actual element.
    
    Returns:
    
    The number of bytes of the actual element in the buffer. It is (idxEnd - idxBegin).
  - getLengthTotal
```
public final int getLengthTotal()
```
    Deprecated.
    
    Returns the length of the data.
    
    Returns:
    
    The number of bytes of data in the buffer. It is idxEnd.
  - getData
```
public final byte[] getData()
```
    Deprecated.
    
    Returns the data buffer itself. The actual total length is getted with getLengthTotal().
    
    Returns:
    
    The number of bytes of the data in the buffer.
  - getPositionInBuffer
```
public final int getPositionInBuffer()
```
    Deprecated.
    
    Returns the position of the Element data in the assigned buffer.
    
    Returns:
    
    index of this element in the data buffer.
  - getPositionNextChildInBuffer
```
public final int getPositionNextChildInBuffer()
```
    Deprecated.
    
    Returns the position of the current child in the assigned buffer.
    
    Returns:
    
    index of the current child of this element in the data buffer.
  - getLengthCurrentChildElement
```
public final int getLengthCurrentChildElement()
                                       throws java.lang.IllegalArgumentException
```
    Deprecated.
    
    Returns the length of the current child element. The length may be setted outside by calling setLengthCurrentChildElement() from user level after any calling of next() or after calling getText() if it is a text content. In this case this method returns this length in a simple way.
    If the user don't have called setLengthCurrentChildElement() after the last next(), the users defined specifyLengthCurrentChildElement() is called.
    
    Returns:
    
    the length in bytes of the current child element.
    
    Throws:
    
    java.lang.IllegalArgumentException - if the user has not defined a overloaded methode specifyLengthCurrentChildElement() or this method has thrown the exception because the length is not determinable.
  - setLengthElement
```
public final void setLengthElement(int length)
```
    Deprecated.
    
    Sets the length of the element in this and all parent of this. If the element is a child of any parent, it should be the current child of the parent. The idxEnd and the idxCurrentChildEnd of this and all its parents is set with the (this.idxBegin+length).
    
    This routine is usefully if data are set in a child directly without sub-tree child structure (without using addChild(ByteDataAccess)). It is if the element has data after the head with different length without an own children structure.
    
    Parameters:
    
    length - The length of data of this current (last) child.
  - getString
```
protected final java.lang.String getString(int idx,
                                           int nmax)
```
    Deprecated.
    
    Returns a String from the given position inside the actual element . The bytes are interpreted in the given encoding.
    
    Parameters:
    
    idx - The start position inside the child.
    
    nmax - Maximal number of bytes
    
    Returns:
    
    The String representation of the bytes.
  - setString
```
protected final int setString(int idx,
                              int nmax,
                              java.lang.String ss)
```
    Deprecated.
    
    Sets a String to the the given position inside the actual element . The bytes are interpreted in the given encoding.
    
    Parameters:
    
    idx - The start position inside the child.
    
    nmax - Maximal number of bytes
    
    ss - The String representation of the bytes.
    
    Returns:
    
    Number of written chars.
    
    Throws:
  - _getLong
```
protected final long _getLong(int idxInChild,
                              int nrofBytesAndSign)
```
    Deprecated.
    
    Returns the content of 1 to 8 bytes inside the actual element as a long number, big- or little-endian depending on setBigEndian(). This method is protected because at user level its using is a prone to errors because the idx is free related.
    
    Parameters:
    
    idxInChild - The position of leading byte in the actual element, the data are taken from data[idxBegin+idx].
    
    nrofBytesAndSign - If positiv, than the method returns the unsigned interpretation of the bytes. If negative, than the return value is negative, if the last significant bit of the given number of bytes is set. The value represents the number of bytes to interprete as integer. It may be 1..8 respectively -1...-8.
    
    Returns:
    
    the long value in range adequate nrof bytes.
    
    Since:
    
    2009-09-30: regards negative nrofBytesAndSign. Prior Versions: returns a signed value always.
  - _setLong
```
protected final void _setLong(int idx,
                              int nrofBytes,
                              long val)
```
    Deprecated.
    
    sets the content of 1 to 8 bytes inside the actual element as a long number, big- or little-endian depending on setBigEndian(). This method is protected because at user level its using is a prone to errors because the idx is free related.
    
    Parameters:
    
    idx - the position of leading byte in the actual element, the data are set to data[idxBegin+idx].
    
    nrofBytes - The number of bytes of the value.
    
    val - the long value in range adequate nrof bytes.
  - _getString
```
protected final java.lang.String _getString(int idx,
                                            int nrofBytes)
                                     throws java.io.UnsupportedEncodingException
```
    Deprecated.
    
    sets the content inside the acutal element with the character bytes from the given String. No value < 0x20 is setted. If the String value contain a control character with code < 0x20, a '?' is written. This behavior protected, that bytevalues < 0x20 can use to detect no String elements, see getByteNextChild(). This method is protected because at user level its using is a prone to errors because the idx is free related.
    
    Parameters:
    
    idx - the position in the actual element, the data are set to data[idxBegin+idx].
    
    nrofBytes - The length of the byte[] area to set. If the String value is longer as nrofBytes, it will be truncated. No exception occurs. If the String is shorter as nrofBytes, the rest is filled with 0.
    
    value - The String value.
    
    Returns:
    
    The String which is stored at the designated area.
    
    Throws:
    
    java.io.UnsupportedEncodingException
  - _setString
```
protected final void _setString(int idx,
                                int nrofBytes,
                                java.lang.String value,
                                java.lang.String sEncoding,
                                boolean preventCtrlChars)
                         throws java.io.UnsupportedEncodingException
```
    Deprecated.
    
    sets the content inside the actual element with the character bytes from the given String. This method is protected because at user level its using is a prone to errors because the idx is free related.
    
    Parameters:
    
    idx - the position in the actual element, the data are set to data[idxBegin+idx].
    
    nrofBytes - The length of the byte[] area to set. If the String value is longer as nrofBytes, it will be truncated. No exception occurs. If the String is shorter as nrofBytes, the rest is filled with 0.
    
    value - The String value.
    
    sEncoding - The encoding of the String. null: Use standard encoding.
    
    preventCtrlChars - true then values < 0x20 are not set. If the String value contain a control character with code < 0x20, a '?' is written. This behavior guarantees, that byte-values < 0x20 can use to detect no-String elements, see getByteNextChild().
    
    Throws:
    
    java.io.UnsupportedEncodingException
  - copyData
```
public final void copyData(int[] dst)
```
    Deprecated.
    
    copies some data to a int[], primarily to debug a content.
    
    Parameters:
    
    dst - This array is field, but only from data of the current element between idxBegin and idxEnd
  - clearData
```
public final void clearData()
```
    Deprecated.
    
    Sets all data of this element to 0. Note: The idxEnd should be set to the end of the element. This method is proper to use for a simple element only.
  - clearHead
```
public final void clearHead()
```
    Deprecated.
    
    Sets all data of the head of this element to 0. Note: If the element has not a head, this method does nothing. It sets from idxBegin to exclusively idxFirstChild.
  - getFloat
```
protected final float getFloat(int idx)
```
    Deprecated.
    
    Gets a float value from the content of 4 byte. The float value is red according to the IEEE 754 floating-point "single format" bit layout, preserving Not-a-Number (NaN) values, like converted from java.lang.Float.intBitsToFloat().
  - getDouble
```
protected final double getDouble(int idx)
```
    Deprecated.
  - getInt64
```
protected final long getInt64(int idx)
```
    Deprecated.
  - getInt32
```
public final int getInt32(int idx)
```
    Deprecated.
    
    Returns the content of 4 bytes inside the actual element as a integer number between -2147483648 and 2147483647, big- or little-endian depending on setBigEndian().
    
    Parameters:
    
    idx - the position of leading byte in the actual element, the data are raken from data[idxBegin+idx]. This is not the absolute position in data, idxBegin is added.
    
    Returns:
    
    the integer value in range from -2147483648 and 2147483647
  - getUint32
```
public final int getUint32(int idx)
```
    Deprecated.
  - getUint16
```
protected final int getUint16(int idx)
```
    Deprecated.
    
    Returns the content of 2 bytes as a positive nr between 0..65535, big-endian inside the actual element.
    
    Parameters:
    
    idx - the position of leading byte in the actual element, the data are raken from data[idxBegin+idx]. This is not the absolute position in data, idxBegin is added.
    
    Returns:
    
    the integer value in range from -32768 to 32767
  - getInt16
```
protected final short getInt16(int idx)
```
    Deprecated.
    
    Returns the content of 2 bytes as a positive nr between 0..65535 inside the actual element.
    
    Parameters:
    
    idx - the position of leading byte in the actual element, the data are raken from data[idxBegin+idx]. This is not the absolute position in data, idxBegin is added.
    
    Returns:
    
    the integer value in range from -32768 to 32767
  - getChar
```
protected final char getChar(int idx)
```
    Deprecated.
    
    Returns the content of 1 bytes as ASCII inside the actual element.
    
    Parameters:
    
    idx - the position of char in the actual element, the data are raken from data[idxBegin+idx]. This is not the absolute position in data, idxBegin is added.
    
    Returns:
    
    the ASCII value
  - getInt8
```
protected final byte getInt8(int idx)
```
    Deprecated.
    
    Returns the content of 1 bytes as a positive or negative nr between -128..127 inside the actual element.
    
    Parameters:
    
    idx - the position of leading byte in the actual element, the data are raken from data[idxBegin+idx]. This is not the absolute position in data, idxBegin is added.
    
    Returns:
    
    the integer value in range from -32768 to 32767
  - getUint8
```
protected final int getUint8(int idx)
```
    Deprecated.
    
    Returns the content of 1 bytes as a positive or negative nr between -128..127 inside the actual element.
    
    Parameters:
    
    idx - the position of leading byte in the actual element, the data are raken from data[idxBegin+idx]. This is not the absolute position in data, idxBegin is added.
    
    Returns:
    
    the integer value in range from -32768 to 32767
  - getUint32
```
protected final int getUint32(int idxBytes,
                              int idxArray,
                              int lengthArray)
```
    Deprecated.
  - getInt32
```
protected final int getInt32(int idxBytes,
                             int idxArray,
                             int lengthArray)
```
    Deprecated.
  - getInt16
```
protected final int getInt16(int idxBytes,
                             int idxArray,
                             int lengthArray)
```
    Deprecated.
  - getInt8
```
protected final int getInt8(int idxBytes,
                            int idxArray,
                            int lengthArray)
```
    Deprecated.
  - getUint16
```
protected final int getUint16(int idxBytes,
                              int idxArray,
                              int lengthArray)
```
    Deprecated.
  - getUint8
```
protected final int getUint8(int idxBytes,
                             int idxArray,
                             int lengthArray)
```
    Deprecated.
  - getFloat
```
protected final float getFloat(int idxBytes,
                               int idxArray,
                               int lengthArray)
```
    Deprecated.
  - setFloat
```
protected final void setFloat(int idx,
                              float value)
```
    Deprecated.
    
    Set the content of 4 byte from a float variable. The float value is stored according to the IEEE 754 floating-point "single format" bit layout, preserving Not-a-Number (NaN) values, like converted from java.lang.Float.floatToRawIntBits().
  - setDouble
```
protected final void setDouble(int idx,
                               double value)
```
    Deprecated.
    
    Set the content of 8 byte from a double variable. The double value is stored according to the IEEE 754 floating-point "double format" bit layout, preserving Not-a-Number (NaN) values, like converted from java.lang.Double.doubleToRawLongBits().
  - setInt32
```
protected final void setInt32(int idx,
                              int value)
```
    Deprecated.
    
    Set the content of 4 bytes as a integer number between -2147483648 and 2147483647, big- or little-endian depended from setBigEndian().
    
    Parameters:
    
    idx - The position of leading byte in the current elements data. This is not the absolute position in data, idxBegin is added.
    
    value - The value in range 0..65535. The value is taken modulo 0xffffffff.
  - setInt8
```
protected final void setInt8(int idx,
                             int value)
```
    Deprecated.
    
    Set the content of 1 bytes as a positive nr between 0..256.
    
    Parameters:
    
    idx - The position of leading byte in the current elements data. This is not the absolute position in data, idxBegin is added.
    
    value - The value in range 0..65535. The value is taken modulo 0xffff.
  - setUint8
```
protected final void setUint8(int idx,
                              int value)
```
    Deprecated.
    
    Set the content of 1 bytes as a positive nr between 0..255, big- or little-endian.
    
    Parameters:
    
    idx - The position of leading byte in the current elements data. This is not the absolute position in data, idxBegin is added.
    
    value - The value in range 0..65535. The value is taken modulo 0xff.
  - setUint32
```
protected final void setUint32(int idx,
                               long value)
```
    Deprecated.
    
    Set the content of 4 bytes as a positive nr between 0..2pow32-1, big- or little-endian.
    
    Parameters:
    
    idx - The position of leading byte in the current elements data. This is not the absolute position in data, idxBegin is added.
    
    value - The value as long. The value is taken modulo 0xffffffff.
  - setInt16
```
protected final void setInt16(int idx,
                              int value)
```
    Deprecated.
    
    Set the content of 2 bytes from an integer between -32768..32768, or from an integer number between 0..65535. The value is interpreted from the input parameter with modulo 0x10000. Big- or little-endian.
    
    Parameters:
    
    idx - The position of leading byte in the current elements data. This is not the absolute position in data, idxBegin is added.
    
    value - The value in range 0..65535. The value is taken modulo 0xffff.
  - setUint16
```
protected final void setUint16(int idx,
                               int value)
```
    Deprecated.
    
    Set the content of 2 bytes as a positive nr between 0..65535, big- or little-endian.
    
    Parameters:
    
    idx - The position of leading byte in the current elements data. This is not the absolute position in data, idxBegin is added.
    
    value - The value in range 0..65535. The value is taken modulo 0xffff.
  - setUint32
```
protected final void setUint32(int idxBytes,
                               int idxArray,
                               int lengthArray,
                               int val)
```
    Deprecated.
  - setInt32
```
protected final void setInt32(int idxBytes,
                              int idxArray,
                              int lengthArray,
                              int val)
```
    Deprecated.
  - setInt16
```
protected final void setInt16(int idxBytes,
                              int idxArray,
                              int lengthArray,
                              int val)
```
    Deprecated.
  - setInt8
```
protected final void setInt8(int idxBytes,
                             int idxArray,
                             int lengthArray,
                             int val)
```
    Deprecated.
  - setUint16
```
protected final void setUint16(int idxBytes,
                               int idxArray,
                               int lengthArray,
                               int val)
```
    Deprecated.
  - setUint8
```
protected final void setUint8(int idxBytes,
                              int idxArray,
                              int lengthArray,
                              int val)
```
    Deprecated.
  - setFloat
```
protected final void setFloat(int idxBytes,
                              int idxArray,
                              int lengthArray,
                              float val)
```
    Deprecated.
  - copyDataFrom
```
public final void copyDataFrom(ByteDataAccess src)
                        throws java.lang.IllegalArgumentException
```
    Deprecated.
    
    Copies the data into a byte[]
    
    Throws:
    
    java.lang.IllegalArgumentException
  - elementAt
```
public final void elementAt(int indexObjectArray)
```
    Deprecated.
    
    Counts the idxChild by given index, idxChild is ByteCount from idxBegin
    
    Parameters:
    
    indexObjectArray - Index of Array
  - assertNotExpandable
```
public final boolean assertNotExpandable()
```
    Deprecated.
  - toString
```
public java.lang.String toString()
```
    Deprecated.
    
    This method is especially usefully to debug in eclipse. It shows the first bytes of head, the position of child and the first bytes of the child.
    
    Overrides:
    
    toString in class java.lang.Object

Class ByteDataAccess

children, currentChild, addChild

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

_version_

data

idxBegin

idxEnd

bExpand

idxFirstChild

idxCurrentChild

idxCurrentChildEnd

bBigEndian

parent

charset

toStringformatter

kEndOfElements

kNothing

kText

kUndefined

kInitializedWithLength

kIdxElementCode

Constructor Detail

ByteDataAccess

ByteDataAccess

Method Detail

getLengthHead

specifyEmptyDefaultData

specifyLengthElementHead

specifyLengthElement

notifyAddChild

specifyLengthCurrentChildElement

assignDataToFixChilds

setBigEndian

reset

assignData

assignData

assignData

assignEmpty

removeChildren

detach

assignCasted_i

assignDowncast_i

assignAtIndex

assignAtIndex

addChild

assignAsChild

removeChild

setIdxtoNextCurrentChild

setIdxCurrentChildEnd

addChildEmpty

correctCurrentChildEnd

expand

expandParent

getChildInteger

getChildFloat

getChildDouble

addChildInteger

addChildFloat

getChildString

addChildString

addChildString

addChildString

rewind

sufficingBytesForNextChild

getMaxNrofBytesForNextChild

getMaxNrofBytes

getLength

getLengthTotal

getData

getPositionInBuffer

getPositionNextChildInBuffer

getLengthCurrentChildElement

setLengthElement

getString

setString

_getLong