Volume (mapdb 2.0-beta12 API)

java.lang.Object
- org.mapdb.Volume

All Implemented Interfaces:

Closeable, AutoCloseable

Direct Known Subclasses:

Volume.ByteArrayVol, Volume.ByteBufferVol, Volume.ByteBufferVolSingle, Volume.FileChannelVol, Volume.RandomAccessFileVol, Volume.ReadOnly, Volume.SingleByteArrayVol
```
public abstract class Volume
extends Object
implements Closeable
```
MapDB abstraction over raw storage (file, disk partition, memory etc...).
Implementations needs to be thread safe (especially 'ensureAvailable') operation. However updates do not have to be atomic, it is clients responsibility to ensure two threads are not writing/reading into the same location.

Author:

Jan Kotek

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`Volume.ByteArrayVol`
`static class`	`Volume.ByteBufferVol` Abstract Volume over bunch of ByteBuffers It leaves ByteBufferVol details (allocation, disposal) on subclasses.
`static class`	`Volume.ByteBufferVolSingle` Abstract Volume over single ByteBuffer, maximal size is 2GB (32bit limit).
`static class`	`Volume.FileChannelVol` Volume which uses FileChannel.
`static class`	`Volume.MappedFileVol`
`static class`	`Volume.MappedFileVolSingle`
`static class`	`Volume.MemoryVol`
`static class`	`Volume.MemoryVolSingle`
`static class`	`Volume.RandomAccessFileVol`
`static class`	`Volume.ReadOnly`
`static class`	`Volume.SingleByteArrayVol` Volume backed by on-heap byte[] with maximal fixed size 2GB.
`static class`	`Volume.VolumeFactory`

Field Summary

Fields
Modifier and Type	Field and Description
`protected boolean`	`closed`
`protected static Logger`	`LOG`
`static Volume.VolumeFactory`	`UNSAFE_VOL_FACTORY` If `sun.misc.Unsafe` is available it will use Volume based on Unsafe.

Constructor Summary

Constructors
Constructor and Description

Volume()

Constructors
Constructor and Description
`Volume()`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`assertZeroes(long startOffset, long endOffset)` Check that all bytes between given offsets are zero.
`abstract void`	`clear(long startOffset, long endOffset)` Set all bytes between `startOffset` and `endOffset` to zero.
`void`	`clearOverlap(long startOffset, long endOffset)`
`abstract void`	`close()`
`void`	`copyEntireVolumeTo(Volume to)` Copy content of this volume to another.
`void`	`deleteFile()`
`abstract void`	`ensureAvailable(long offset)` Check space allocated by Volume is bigger or equal to given offset.
`boolean`	`fileLoad()` If underlying storage is memory-mapped-file, this method will try to load and precache all file data into disk cache.
`protected void`	`finalize()`
`abstract byte`	`getByte(long offset)`
`abstract void`	`getData(long offset, byte[] bytes, int bytesPos, int size)`
`abstract DataInput`	`getDataInput(long offset, int size)`
`DataInput`	`getDataInputOverlap(long offset, int size)`
`abstract File`	`getFile()` returns underlying file if it exists
`abstract boolean`	`getFileLocked()` return true if this Volume holds exclusive lock over its file
`abstract int`	`getInt(long offset)`
`abstract long`	`getLong(long offset)`
`long`	`getLongPackBidi(long offset)`
`long`	`getLongPackBidiReverse(long offset, long limitOffset)`
`long`	`getPackedLong(long position)` Unpack long value from the Volume.
`long`	`getSixLong(long pos)`
`int`	`getUnsignedByte(long offset)`
`int`	`getUnsignedShort(long offset)`
`long`	`hash(long off, long len, long seed)` Calculates XXHash64 from this Volume content.
`boolean`	`isClosed()`
`abstract boolean`	`isSliced()`
`abstract long`	`length()`
`abstract void`	`putByte(long offset, byte value)`
`abstract void`	`putData(long offset, byte[] src, int srcPos, int srcSize)`
`abstract void`	`putData(long offset, ByteBuffer buf)`
`void`	`putDataOverlap(long offset, byte[] src, int srcPos, int srcSize)`
`abstract void`	`putInt(long offset, int value)`
`abstract void`	`putLong(long offset, long value)`
`int`	`putLongPackBidi(long offset, long value)`
`int`	`putPackedLong(long pos, long value)` Put packed long at given position.
`void`	`putSixLong(long pos, long value)`
`void`	`putUnsignedByte(long offset, int b)`
`void`	`putUnsignedShort(long offset, int value)`
`abstract int`	`sliceSize()`
`abstract void`	`sync()`
`void`	`transferInto(long inputOffset, Volume target, long targetOffset, long size)` Transfers data from this Volume into target volume.
`abstract void`	`truncate(long size)`
`static void`	`volumeTransfer(long size, Volume from, Volume to)` transfer data from one volume to second.

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

- Field Detail
  - LOG
```
protected static final Logger LOG
```
  - UNSAFE_VOL_FACTORY
```
public static final Volume.VolumeFactory UNSAFE_VOL_FACTORY
```
    If sun.misc.Unsafe is available it will use Volume based on Unsafe. If Unsafe is not available for some reason (Android), use DirectByteBuffer instead.
  - closed
```
protected volatile boolean closed
```
- Constructor Detail
  - Volume
```
public Volume()
```
- Method Detail
  - fileLoad
```
public boolean fileLoad()
```
    If underlying storage is memory-mapped-file, this method will try to load and precache all file data into disk cache. Most likely it will call MappedByteBuffer.load(), but could also read content of entire file etc This method will not pin data into memory, they might be removed at any time.
    
    Returns:
    true if this method did something, false if underlying storage does not support loading
  - assertZeroes
```
public void assertZeroes(long startOffset,
                long endOffset)
                  throws DBException.DataCorruption
```
    Check that all bytes between given offsets are zero. This might cross 1MB boundaries
    
    Parameters:
    startOffset -
    endOffset -
    
    Throws:
    
    DBException.DataCorruption - if some byte is not zero
  - isClosed
```
public boolean isClosed()
```
  - finalize
```
protected void finalize()
```
    Overrides:
    
    finalize in class Object
  - ensureAvailable
```
public abstract void ensureAvailable(long offset)
```
    Check space allocated by Volume is bigger or equal to given offset. So it is safe to write into smaller offsets.
    
    Parameters:
    offset -
  - truncate
```
public abstract void truncate(long size)
```
  - putLong
```
public abstract void putLong(long offset,
           long value)
```
  - putInt
```
public abstract void putInt(long offset,
          int value)
```
  - putByte
```
public abstract void putByte(long offset,
           byte value)
```
  - putData
```
public abstract void putData(long offset,
           byte[] src,
           int srcPos,
           int srcSize)
```
  - putData
```
public abstract void putData(long offset,
           ByteBuffer buf)
```
  - putDataOverlap
```
public void putDataOverlap(long offset,
                  byte[] src,
                  int srcPos,
                  int srcSize)
```
  - getLong
```
public abstract long getLong(long offset)
```
  - getInt
```
public abstract int getInt(long offset)
```
  - getByte
```
public abstract byte getByte(long offset)
```
  - getDataInput
```
public abstract DataInput getDataInput(long offset,
                     int size)
```
  - getDataInputOverlap
```
public DataInput getDataInputOverlap(long offset,
                            int size)
```
  - getData
```
public abstract void getData(long offset,
           byte[] bytes,
           int bytesPos,
           int size)
```
  - close
```
public abstract void close()
```
    Specified by:
    
    close in interface Closeable
    
    Specified by:
    
    close in interface AutoCloseable
  - sync
```
public abstract void sync()
```
  - sliceSize
```
public abstract int sliceSize()
```
    Returns:
    slice size or -1 if not sliced
  - deleteFile
```
public void deleteFile()
```
  - isSliced
```
public abstract boolean isSliced()
```
  - length
```
public abstract long length()
```
  - putUnsignedShort
```
public void putUnsignedShort(long offset,
                    int value)
```
  - getUnsignedShort
```
public int getUnsignedShort(long offset)
```
  - getUnsignedByte
```
public int getUnsignedByte(long offset)
```
  - putUnsignedByte
```
public void putUnsignedByte(long offset,
                   int b)
```
  - putLongPackBidi
```
public int putLongPackBidi(long offset,
                  long value)
```
  - getLongPackBidi
```
public long getLongPackBidi(long offset)
```
  - getLongPackBidiReverse
```
public long getLongPackBidiReverse(long offset,
                          long limitOffset)
```
  - getSixLong
```
public long getSixLong(long pos)
```
  - putSixLong
```
public void putSixLong(long pos,
              long value)
```
  - putPackedLong
```
public int putPackedLong(long pos,
                long value)
```
    Put packed long at given position.
    
    Parameters:
    value - to be written
    
    Returns:
    number of bytes consumed by packed value
  - getPackedLong
```
public long getPackedLong(long position)
```
    Unpack long value from the Volume. Highest 4 bits reused to indicate number of bytes read from Volume. One can use result & DataIO.PACK_LONG_RESULT_MASK to remove size;
    
    Parameters:
    position - to read value from
    
    Returns:
    The long value, minus highest byte
  - getFile
```
public abstract File getFile()
```
    returns underlying file if it exists
  - getFileLocked
```
public abstract boolean getFileLocked()
```
    return true if this Volume holds exclusive lock over its file
  - transferInto
```
public void transferInto(long inputOffset,
                Volume target,
                long targetOffset,
                long size)
```
    Transfers data from this Volume into target volume. If its possible, the implementation should override this method to enable direct memory transfer. Caller must respect slice boundaries. ie it is not possible to transfer data which cross slice boundaries.
    
    Parameters:
    inputOffset - offset inside this Volume, ie data will be read from this offset
    target - Volume to copy data into
    targetOffset - position in target volume where data will be copied into
    size - size of data to copy
  - clear
```
public abstract void clear(long startOffset,
         long endOffset)
```
    Set all bytes between startOffset and endOffset to zero. Area between offsets must be ready for write once clear finishes.
  - clearOverlap
```
public void clearOverlap(long startOffset,
                long endOffset)
```
  - copyEntireVolumeTo
```
public void copyEntireVolumeTo(Volume to)
```
    Copy content of this volume to another. Target volume might grow, but is never shrank. Target is also not synced
  - hash
```
public long hash(long off,
        long len,
        long seed)
```
    Calculates XXHash64 from this Volume content.
    This code comes from LZ4-Java created by Adrien Grand.
    
    Parameters:
    off - offset to start calculation from
    len - length of data to calculate hash
    seed - hash seed
    
    Returns:
    XXHash.
  - volumeTransfer
```
public static void volumeTransfer(long size,
                  Volume from,
                  Volume to)
```
    transfer data from one volume to second. Second volume will be expanded if needed

Class Volume

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LOG

UNSAFE_VOL_FACTORY

closed

Constructor Detail

Volume

Method Detail

fileLoad

assertZeroes

isClosed

finalize

ensureAvailable

truncate

putLong

putInt

putByte

putData

putData

putDataOverlap

getLong

getInt

getByte

getDataInput

getDataInputOverlap

getData

close

sync

sliceSize

deleteFile

isSliced

length

putUnsignedShort

getUnsignedShort

getUnsignedByte

putUnsignedByte

putLongPackBidi

getLongPackBidi

getLongPackBidiReverse

getSixLong

putSixLong

putPackedLong

getPackedLong

getFile

getFileLocked

transferInto

clear

clearOverlap

copyEntireVolumeTo

hash

volumeTransfer