DataBuffer (Artisynth API documentation)

java.lang.Object
- maspack.util.DataBuffer

Direct Known Subclasses:

NumericState
```
public class DataBuffer
extends java.lang.Object
```
A general class for storing integer, double, and Object data. It is intended mainly as a convenience utility for storing component state.
DataBuffer maintains three independent buffers for storing integer, double, and Object data. Data is added to each using a put() operation and can be read back using a get() operation. Each buffer has a size and an offset. When data is added using put(), it is added at the end of the buffer and the size is increased. When data is read back using put(), it is read from the current offset location, and the offset is then increased. The offset is not allowed to increase beyond the current size. The put() and get() operations therefore act like insert and remove operations for a queue. However, unlike a queue, the get() operation does not actually remove data; it simply advances the offset. Other set() and peek() operations allow data to be set and read within the buffer without affecting its offset or size.
The methods implementing the various operations (put(), get(), set(), size(), etc.) for each data type take the name of the operation prefaced with a single character identifying the data type:

z
integer

d
double

o
object

For example, the put() and get() operations are zput() and zget() for integers and dput() and dget() for doubles.
As an example, we consider storing and retrieving information about a vector. The store operation might look like this:
```
 
    saveVector (DataBuffer data) {
       data.zput (size);               // store vector size as an integer
       for (int i=0; i<size; i++) {
          data.dout (vector.get(i));   // store vector data as doubles
       }
    }
 
 
```
while the restore operation might look like this:
```
 
    loadVector (DataBuffer data) {
       int size = data.zget ();        // get the vector size
       vector = new VectorNd(size);
       for (int i=0; i<size; i++) {
          vector.set (i, data.dget()); // restore the vector data
       }
    }
 
 
```
For convenience,put() and get() operations are also defined to save and restore aggregate types, such as Vector3d and Matrix3d.
Internally, each buffer is implementing as an array, whose length defines the current buffer capacity. When the size increases beyond the capacity, the array is resized automatically and the capacity is increased. Attempting to move the offset beyond the current size will cause an exception to be thrown. The buffer structure is shown in the following diagram, in which entries marked with 'x' contain actual data.
```
 |x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x| | | | | | | | | | | | | | |
          |                           |                           |
   offset-+                      size-+                  capacity-+
 
```

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class DataBuffer.Offsets

Nested Classes
Modifier and Type	Class and Description
`static class`	`DataBuffer.Offsets`

Constructor Summary

Constructors
Constructor and Description
`DataBuffer()`
`DataBuffer(int zcap, int dcap, int ocap)` Creates a new DataBuffer with specified capacities for its bytes, double, integer, double and Object buffers.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`clear()`
`double[]`	`dbuffer()` Returns the current array used to store the double buffer.
`void`	`dEnsureCapacity(int cap)` Ensures that the double buffer has a specified capacity.
`boolean`	`dequals(DataBuffer data)` Returns true if the double buffer contents of this DataBuffer and another DataBuffer are equal.
`double`	`dget()` Returns the double value at the current double buffer offset, and increases the offset.
`void`	`dget(Matrix3dBase M)` Gets nine doubles starting at the current double buffer offset, places them into a Matrix3dBase, and increases the offset.
`void`	`dget(SymmetricMatrix3d M)` Gets six doubles starting at the current double buffer offset, places them into a SymmetricMatrix3d, and increases the offset.
`void`	`dget(Vector3d vec)` Gets three doubles starting at the current double buffer offset, places them into a Vector3d, and increases the offset.
`void`	`dget(VectorNd vec)` Gets doubles starting at the current double buffer offset, places them into a VectorNd, and increases the offset.
`int`	`doffset()` Returns the current double buffer offset.
`double`	`dpeek()` Returns the double value at the current double buffer offset, but does not increase the offset.
`double`	`dpeek(int i)` Returns the double value at a specified location `i`.
`void`	`dput(double d)` Adds a double to the double buffer, increasing its size.
`void`	`dput(Matrix3dBase M)` Adds nine doubles from a Matrix3dBase to the double buffer, increasing its size.
`void`	`dput(SymmetricMatrix3d M)` Adds six doubles from a SymmetricMatrix3d to the double buffer, increasing its size.
`void`	`dput(Vector3d vec)` Adds three doubles from a Vector3d to the double buffer, increasing its size.
`void`	`dput(VectorNd vec)` Adds doubles from a VectorNd to the double buffer, increasing its size.
`void`	`dset(int i, double d)` Overwrites a value in the double buffer at a specified location `i`.
`void`	`dsetOffset(int off)` Sets the double buffer offset.
`void`	`dsetSize(int size)` Resets the size of the double buffer.
`int`	`dsize()` Returns the amount of data in the double buffer.
`void`	`dskip(int n)` Advances the double buffer offset forward by `n`.
`boolean`	`equals(DataBuffer data)`
`DataBuffer.Offsets`	`getNumericOffsets()`
`DataBuffer.Offsets`	`getNumericSizes()`
`DataBuffer.Offsets`	`getOffsets()`
`DataBuffer.Offsets`	`getSizes()`
`boolean`	`numericEquals(DataBuffer data)`
`java.lang.Object[]`	`obuffer()` Returns the current array used to store the Object buffer.
`void`	`oEnsureCapacity(int cap)` Ensures that the Object buffer has a specified capacity.
`boolean`	`oequals(DataBuffer data)` Returns true if the Object buffer contents of this DataBuffer and another DataBuffer are equal.
`java.lang.Object`	`oget()` Returns the Object value at the current Object buffer offset, and increases the offset.
`int`	`ooffset()` Returns the current Object buffer offset.
`java.lang.Object`	`opeek()` Returns the Object value at the current Object buffer offset, but does not increase the offset.
`java.lang.Object`	`opeek(int i)` Returns the Object value at a specified location `i`.
`void`	`oput(java.lang.Object o)` Adds a Object to the Object buffer, increasing its size.
`void`	`oputs(java.util.Collection<? extends java.lang.Object> objs)` Adds a collection of Objects to the Object buffer, increasing its size.
`void`	`oset(int i, java.lang.Object o)` Overwrites a value in the Object buffer at a specified location `i`.
`void`	`osetOffset(int off)` Sets the Object buffer offset.
`void`	`osetSize(int size)` Resets the size of the Object buffer.
`int`	`osize()` Returns the amount of data in the Object buffer.
`void`	`oskip(int n)` Advances the Object buffer offset forward by `n`.
`void`	`resetOffsets()`
`void`	`set(DataBuffer data)`
`int[]`	`zbuffer()` Returns the current array used to store the integer buffer.
`void`	`zEnsureCapacity(int cap)` Ensures that the integer buffer has a specified capacity.
`boolean`	`zequals(DataBuffer data)` Returns true if the integer buffer contents of this DataBuffer and another DataBuffer are equal.
`int`	`zget()` Returns the integer value at the current integer buffer offset, and increases the offset.
`boolean`	`zgetBool()` Returns the boolean value at the current int buffer offset, and increases the offset.
`int`	`zoffset()` Returns the current integer buffer offset.
`int`	`zpeek()` Returns the integer value at the current integer buffer offset, but does not increase the offset.
`int`	`zpeek(int i)` Returns the integer value at a specified location `i`.
`void`	`zput(int z)` Adds a integer to the integer buffer, increasing its size.
`void`	`zputBool(boolean bool)` Adds a boolean value to the int buffer, increasing its size.
`void`	`zset(int i, int z)` Overwrites a value in the integer buffer at a specified location `i`.
`void`	`zsetOffset(int off)` Sets the integer buffer offset.
`void`	`zsetSize(int size)` Resets the size of the integer buffer.
`int`	`zsize()` Returns the amount of data in the integer buffer.
`void`	`zskip(int n)` Advances the integer buffer offset forward by `n`.

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

- Constructor Detail
  - DataBuffer
```
public DataBuffer()
```
  - DataBuffer
```
public DataBuffer(int zcap,
                  int dcap,
                  int ocap)
```
    Creates a new DataBuffer with specified capacities for its bytes, double, integer, double and Object buffers.
- Method Detail
  - zsize
```
public int zsize()
```
    Returns the amount of data in the integer buffer.
    
    Returns:
    
    amount of data in the integer buffer
  - zput
```
public void zput(int z)
```
    Adds a integer to the integer buffer, increasing its size.
    
    Parameters:
    
    z - integer to add
  - zset
```
public void zset(int i,
                 int z)
```
    Overwrites a value in the integer buffer at a specified location i. If the location is outside the range 0 to zsize()-1, inclusive, an exception is thrown.
    
    Parameters:
    
    i - index at which to overwrite data
    
    z - new data value to set
  - zputBool
```
public void zputBool(boolean bool)
```
    Adds a boolean value to the int buffer, increasing its size.
    
    Parameters:
    
    bool - boolean value to add
  - zgetBool
```
public boolean zgetBool()
```
    Returns the boolean value at the current int buffer offset, and increases the offset. This value is false if the underlying int value is 0, and true otherwise. If the current offset is equal to zsize(), an exception is thrown.
    
    Returns:
    
    boolean value at the current offset
  - zsetSize
```
public void zsetSize(int size)
```
    Resets the size of the integer buffer. If the size is increased, the new space will be padded with zeros. If the size is decreased, the offset will be adjusted to enusre that is does not exceed the size.
    
    Parameters:
    
    size - new size for the integer buffer
  - zget
```
public int zget()
```
    Returns the integer value at the current integer buffer offset, and increases the offset. If the current offset is equal to zsize(), an exception is thrown.
    
    Returns:
    
    integer value at the current offset
  - zpeek
```
public int zpeek()
```
    Returns the integer value at the current integer buffer offset, but does not increase the offset. If the current offset is equal to zsize(), an exception is thrown.
    
    Returns:
    
    integer value at the current offset
  - zpeek
```
public int zpeek(int i)
```
    Returns the integer value at a specified location i. If the location is outside the range 0 to zsize()-1, inclusive, an exception is thrown.
    
    Parameters:
    
    i - index at which to obtain the data
    
    Returns:
    
    integer value at location i
  - zskip
```
public void zskip(int n)
```
    Advances the integer buffer offset forward by n. If this causes the offset to exceed zsize(), an exception is thrown.
    
    Parameters:
    
    n - amount to advance the integer buffer
  - zoffset
```
public int zoffset()
```
    Returns the current integer buffer offset.
    
    Returns:
    
    current integer buffer offset
  - zsetOffset
```
public void zsetOffset(int off)
```
    Sets the integer buffer offset. If the requested offset is outside the range 0 to zsize()-1, inclusive, an exception is thrown.
    
    Parameters:
    
    off - new integer buffer offset
  - zequals
```
public boolean zequals(DataBuffer data)
```
    Returns true if the integer buffer contents of this DataBuffer and another DataBuffer are equal.
    
    Returns:
    
    true if the integer buffers are equal
  - zEnsureCapacity
```
public void zEnsureCapacity(int cap)
```
    Ensures that the integer buffer has a specified capacity. The actualy capacity allocated may exceed this.
    
    Parameters:
    
    cap - request integer buffer capacity
  - zbuffer
```
public int[] zbuffer()
```
    Returns the current array used to store the integer buffer. Note that this array may be changed by any operation that changes the integer buffer's size or capacity.
    
    Returns:
    
    current integer buffer
  - dsize
```
public int dsize()
```
    Returns the amount of data in the double buffer.
    
    Returns:
    
    amount of data in the double buffer
  - dput
```
public void dput(double d)
```
    Adds a double to the double buffer, increasing its size.
    
    Parameters:
    
    d - double to add
  - dput
```
public void dput(Vector3d vec)
```
    Adds three doubles from a Vector3d to the double buffer, increasing its size.
    
    Parameters:
    
    vec - vector to add
  - dput
```
public void dput(Matrix3dBase M)
```
    Adds nine doubles from a Matrix3dBase to the double buffer, increasing its size.
    
    Parameters:
    
    M - matrix to add
  - dput
```
public void dput(SymmetricMatrix3d M)
```
    Adds six doubles from a SymmetricMatrix3d to the double buffer, increasing its size.
    
    Parameters:
    
    M - symmetric matrix to add
  - dput
```
public void dput(VectorNd vec)
```
    Adds doubles from a VectorNd to the double buffer, increasing its size.
    
    Parameters:
    
    vec - vector to add
  - dset
```
public void dset(int i,
                 double d)
```
    Overwrites a value in the double buffer at a specified location i. If the location is outside the range 0 to dsize()-1, inclusive, an exception is thrown.
    
    Parameters:
    
    i - index at which to overwrite data
    
    d - new data value to set
  - dsetSize
```
public void dsetSize(int size)
```
    Resets the size of the double buffer. If the size is increased, the new space will be padded with zeros. If the size is decreased, the offset will be adjusted to enusre that is does not exceed the size.
    
    Parameters:
    
    size - new size for the double buffer
  - dget
```
public double dget()
```
    Returns the double value at the current double buffer offset, and increases the offset. If the current offset is equal to dsize(), an exception is thrown.
    
    Returns:
    
    double value at the current offset
  - dget
```
public void dget(Vector3d vec)
```
    Gets three doubles starting at the current double buffer offset, places them into a Vector3d, and increases the offset. If the buffer does not have three doubles remaining past the offset, an exception is thrown.
    
    Parameters:
    
    vec - returns vector
  - dget
```
public void dget(Matrix3dBase M)
```
    Gets nine doubles starting at the current double buffer offset, places them into a Matrix3dBase, and increases the offset. If the buffer does not have nine doubles remaining past the offset, an exception is thrown.
    
    Parameters:
    
    M - returns the matrix
  - dget
```
public void dget(SymmetricMatrix3d M)
```
    Gets six doubles starting at the current double buffer offset, places them into a SymmetricMatrix3d, and increases the offset. If the buffer does not have six doubles remaining past the offset, an exception is thrown.
    
    Parameters:
    
    M - returns the symmetric matrix
  - dget
```
public void dget(VectorNd vec)
```
    Gets doubles starting at the current double buffer offset, places them into a VectorNd, and increases the offset. If the buffer does not have enough doubles remaining past the offset, an exception is thrown.
    
    Parameters:
    
    vec - returns the vector
  - dpeek
```
public double dpeek()
```
    Returns the double value at the current double buffer offset, but does not increase the offset. If the current offset is equal to dsize(), an exception is thrown.
    
    Returns:
    
    double value at the current offset
  - dpeek
```
public double dpeek(int i)
```
    Returns the double value at a specified location i. If the location is outside the range 0 to dsize()-1, inclusive, an exception is thrown.
    
    Parameters:
    
    i - index at which to obtain the data
    
    Returns:
    
    double value at location i
  - dskip
```
public void dskip(int n)
```
    Advances the double buffer offset forward by n. If this causes the offset to exceed dsize(), an exception is thrown.
    
    Parameters:
    
    n - amount to advance the double buffer
  - doffset
```
public int doffset()
```
    Returns the current double buffer offset.
    
    Returns:
    
    current double buffer offset
  - dsetOffset
```
public void dsetOffset(int off)
```
    Sets the double buffer offset. If the requested offset is outside the range 0 to dsize()-1, inclusive, an exception is thrown.
    
    Parameters:
    
    off - new double buffer offset
  - dequals
```
public boolean dequals(DataBuffer data)
```
    Returns true if the double buffer contents of this DataBuffer and another DataBuffer are equal.
    
    Returns:
    
    true if the double buffers are equal
  - dEnsureCapacity
```
public void dEnsureCapacity(int cap)
```
    Ensures that the double buffer has a specified capacity. The actualy capacity allocated may exceed this.
    
    Parameters:
    
    cap - request double buffer capacity
  - dbuffer
```
public double[] dbuffer()
```
    Returns the current array used to store the double buffer. Note that this array may be changed by any operation that changes the double buffer's size or capacity.
    
    Returns:
    
    current double buffer
  - osize
```
public int osize()
```
    Returns the amount of data in the Object buffer.
    
    Returns:
    
    amount of data in the Object buffer
  - oput
```
public void oput(java.lang.Object o)
```
    Adds a Object to the Object buffer, increasing its size.
    
    Parameters:
    
    o - Object to add
  - oputs
```
public void oputs(java.util.Collection<? extends java.lang.Object> objs)
```
    Adds a collection of Objects to the Object buffer, increasing its size.
    
    Parameters:
    
    objs - Objects to add
  - oset
```
public void oset(int i,
                 java.lang.Object o)
```
    Overwrites a value in the Object buffer at a specified location i. If the location is outside the range 0 to osize()-1, inclusive, an exception is thrown.
    
    Parameters:
    
    i - index at which to overwrite data
    
    o - new data value to set
  - osetSize
```
public void osetSize(int size)
```
    Resets the size of the Object buffer. If the size is increased, the new space will be padded with nulls. If the size is decreased, the offset will be adjusted to enusre that is does not exceed the size.
    
    Parameters:
    
    size - new size for the Object buffer
  - oget
```
public java.lang.Object oget()
```
    Returns the Object value at the current Object buffer offset, and increases the offset. If the current offset is equal to osize(), an exception is thrown.
    
    Returns:
    
    Object value at the current offset
  - opeek
```
public java.lang.Object opeek()
```
    Returns the Object value at the current Object buffer offset, but does not increase the offset. If the current offset is equal to osize(), an exception is thrown.
    
    Returns:
    
    Object value at the current offset
  - opeek
```
public java.lang.Object opeek(int i)
```
    Returns the Object value at a specified location i. If the location is outside the range 0 to osize()-1, inclusive, an exception is thrown.
    
    Parameters:
    
    i - index at which to obtain the data
    
    Returns:
    
    Object value at location i
  - oskip
```
public void oskip(int n)
```
    Advances the Object buffer offset forward by n. If this causes the offset to exceed osize(), an exception is thrown.
    
    Parameters:
    
    n - amount to advance the Object buffer
  - ooffset
```
public int ooffset()
```
    Returns the current Object buffer offset.
    
    Returns:
    
    current Object buffer offset
  - osetOffset
```
public void osetOffset(int off)
```
    Sets the Object buffer offset. If the requested offset is outside the range 0 to osize()-1, inclusive, an exception is thrown.
    
    Parameters:
    
    off - new Object buffer offset
  - oequals
```
public boolean oequals(DataBuffer data)
```
    Returns true if the Object buffer contents of this DataBuffer and another DataBuffer are equal.
    
    Returns:
    
    true if the Object buffers are equal
  - oEnsureCapacity
```
public void oEnsureCapacity(int cap)
```
    Ensures that the Object buffer has a specified capacity. The actualy capacity allocated may exceed this.
    
    Parameters:
    
    cap - request Object buffer capacity
  - obuffer
```
public java.lang.Object[] obuffer()
```
    Returns the current array used to store the Object buffer. Note that this array may be changed by any operation that changes the Object buffer's size or capacity.
    
    Returns:
    
    current Object buffer
  - clear
```
public void clear()
```
  - set
```
public void set(DataBuffer data)
```
  - equals
```
public boolean equals(DataBuffer data)
```
  - numericEquals
```
public boolean numericEquals(DataBuffer data)
```
  - resetOffsets
```
public void resetOffsets()
```
  - getSizes
```
public DataBuffer.Offsets getSizes()
```
  - getNumericSizes
```
public DataBuffer.Offsets getNumericSizes()
```
  - getOffsets
```
public DataBuffer.Offsets getOffsets()
```
  - getNumericOffsets
```
public DataBuffer.Offsets getNumericOffsets()
```

Class DataBuffer

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

DataBuffer

DataBuffer

Method Detail

zsize

zput

zset

zputBool

zgetBool

zsetSize

zget

zpeek

zpeek

zskip

zoffset

zsetOffset

zequals

zEnsureCapacity

zbuffer

dsize

dput

dput

dput

dput

dput

dset

dsetSize

dget

dget

dget

dget

dget

dpeek

dpeek

dskip

doffset

dsetOffset

dequals

dEnsureCapacity

dbuffer

osize

oput

oputs

oset

osetSize

oget

opeek

opeek

oskip

ooffset

osetOffset

oequals

oEnsureCapacity

obuffer

clear

set

equals

numericEquals

resetOffsets

getSizes

getNumericSizes

getOffsets

getNumericOffsets