static int sliceShiftFromSize(long sizeIncrement) {

//TODO optimize this method with bitcount operation

sizeIncrement = DataIO.nextPowTwo(sizeIncrement);

for(int i=0;i<32;i++){

if((1L<<i)==sizeIncrement){

return i;

}

}

throw new AssertionError("Could not find sliceShift");

}

static boolean isEmptyFile(String fileName) {

if(fileName==null || fileName.length()==0)

return true;

File f = new File(fileName);

return !f.exists() || f.length()==0;

}

/**

public boolean fileLoad(){

return false;

}

public static abstract class VolumeFactory{

public abstract Volume makeVolume(String file, boolean readOnly, boolean fileLockDisabled,

int sliceShift, long initSize, boolean fixedSize);

public Volume makeVolume(String file, boolean readOnly){

return makeVolume(file,readOnly,false);

}

public Volume makeVolume(String file, boolean readOnly, boolean fileLockDisable){

return makeVolume(file,readOnly,fileLockDisable,CC.VOLUME_PAGE_SHIFT, 0, false);

}

}

private static final byte[] CLEAR = new byte[1024];

protected static final Logger LOG = Logger.getLogger(Volume.class.getName());

/**

public static final VolumeFactory UNSAFE_VOL_FACTORY = new VolumeFactory() {

@Override

public Volume makeVolume(String file, boolean readOnly, boolean fileLockDisabled, int sliceShift, long initSize, boolean fixedSize) {

String packageName = Volume.class.getPackage().getName();

Class clazz;

try {

clazz = Class.forName(packageName+".UnsafeStuff$UnsafeVolume");

} catch (ClassNotFoundException e) {

clazz = null;

}

if(clazz!=null){

try {

return (Volume) clazz.getConstructor(long.class, int.class, long.class)

.newInstance(0L, sliceShift, initSize);

} catch (Exception e) {

LOG.log(Level.WARNING, "Could not invoke UnsafeVolume constructor. " +

"Falling back to DirectByteBuffer",e);

}

}

return MemoryVol.FACTORY.makeVolume(file, readOnly, fileLockDisabled, sliceShift, initSize, fixedSize);

}

};

protected volatile boolean closed;

public boolean isClosed(){

return closed;

}

//uncomment to get stack trace on Volume leak warning

@Override protected void finalize(){

if(CC.ASSERT){

if(!closed

&& !(this instanceof ByteArrayVol)

&& !(this instanceof SingleByteArrayVol)){

LOG.log(Level.WARNING, "Open Volume was GCed, possible file handle leak."

);

}

}

}

/**

abstract public void ensureAvailable(final long offset);

public abstract void truncate(long size);

abstract public void putLong(final long offset, final long value);

abstract public void putInt(long offset, int value);

abstract public void putByte(final long offset, final byte value);

abstract public void putData(final long offset, final byte[] src, int srcPos, int srcSize);

abstract public void putData(final long offset, final ByteBuffer buf);

public void putDataOverlap(final long offset, final byte[] src, int srcPos, int srcSize){

putData(offset,src,srcPos,srcSize);

}

abstract public long getLong(final long offset);

abstract public int getInt(long offset);

abstract public byte getByte(final long offset);

abstract public DataInput getDataInput(final long offset, final int size);

public DataInput getDataInputOverlap(final long offset, final int size){

return getDataInput(offset,size);

}

abstract public void getData(long offset, byte[] bytes, int bytesPos, int size);

abstract public void close();

abstract public void sync();

/**

abstract public int sliceSize();

public void deleteFile(){

File f = getFile();

if(f!=null && f.isFile() && !f.delete()){

LOG.warning("Could not delete file: "+f);

}

}

public abstract boolean isSliced();

public abstract long length();

public void putUnsignedShort(final long offset, final int value){

putByte(offset, (byte) (value>>8));

putByte(offset+1, (byte) (value));

}

public int getUnsignedShort(long offset) {

return (( (getByte(offset) & 0xff) << 8) |

( (getByte(offset+1) & 0xff)));

}

public int getUnsignedByte(long offset) {

return getByte(offset) & 0xff;

}

public void putUnsignedByte(long offset, int b) {

putByte(offset, (byte) (b & 0xff));

}

public int putLongPackBidi(long offset, long value) {

putUnsignedByte(offset++, (((int) value & 0x7F)) | 0x80);

value >>>= 7;

int counter = 2;

//$DELAY$

while ((value & ~0x7FL) != 0) {

putUnsignedByte(offset++, (((int) value & 0x7F)));

value >>>= 7;

//$DELAY$

counter++;

}

//$DELAY$

putUnsignedByte(offset, (byte) value | 0x80);

return counter;

}

public long getLongPackBidi(long offset){

//$DELAY$

long b = getUnsignedByte(offset++); //TODO this could be inside loop, change all implementations

if(CC.ASSERT && (b&0x80)==0)

throw new DBException.DataCorruption();

long result = (b & 0x7F) ;

int shift = 7;

do {

//$DELAY$

b = getUnsignedByte(offset++);

result |= (b & 0x7F) << shift;

if(CC.ASSERT && shift>64)

throw new DBException.DataCorruption();

shift += 7;

}while((b & 0x80) == 0);

//$DELAY$

return (((long)(shift/7))<<60) | result;

}

public long getLongPackBidiReverse(long offset){

//$DELAY$

long b = getUnsignedByte(--offset);

if(CC.ASSERT && (b&0x80)==0)

throw new DBException.DataCorruption();

long result = (b & 0x7F) ;

int counter = 1;

do {

//$DELAY$

b = getUnsignedByte(--offset);

result = (b & 0x7F) | (result<<7);

if(CC.ASSERT && counter>8)

throw new DBException.DataCorruption();

counter++;

}while((b & 0x80) == 0);

//$DELAY$

return (((long)counter)<<60) | result;

}

public long getSixLong(long pos) {

return

((long) (getByte(pos++) & 0xff) << 40) |

((long) (getByte(pos++) & 0xff) << 32) |

((long) (getByte(pos++) & 0xff) << 24) |

((long) (getByte(pos++) & 0xff) << 16) |

((long) (getByte(pos++) & 0xff) << 8) |

((long) (getByte(pos) & 0xff));

}

public void putSixLong(long pos, long value) {

if(CC.ASSERT && (value>>>48!=0))

throw new DBException.DataCorruption();

putByte(pos++, (byte) (0xff & (value >> 40)));

putByte(pos++, (byte) (0xff & (value >> 32)));

putByte(pos++, (byte) (0xff & (value >> 24)));

putByte(pos++, (byte) (0xff & (value >> 16)));

putByte(pos++, (byte) (0xff & (value >> 8)));

putByte(pos, (byte) (0xff & (value)));

}

/**

public int putPackedLong(long pos, long value){

//$DELAY$

int ret = 0;

int shift = 63-Long.numberOfLeadingZeros(value);

shift -= shift%7; // round down to nearest multiple of 7

while(shift!=0){

putByte(pos + (ret++), (byte) (((value >>> shift) & 0x7F) | 0x80));

//$DELAY$

shift-=7;

}

putByte(pos+(ret++),(byte) (value & 0x7F));

return ret;

}

/**

public long getPackedLong(long position){

long ret = 0;

long pos2 = 0;

byte v;

do{

v = getByte(position+(pos2++));

ret = (ret<<7 ) | (v & 0x7F);

}while(v<0);

return (pos2<<60) | ret;

}

/** returns underlying file if it exists */

abstract public File getFile();

/** return true if this Volume holds exclusive lock over its file */

abstract public boolean getFileLocked();

/**

public void transferInto(long inputOffset, Volume target, long targetOffset, long size) {

//TODO size>Integer.MAX_VALUE

byte[] data = new byte[(int) size];

try {

getDataInput(inputOffset, (int) size).readFully(data);

}catch(IOException e){

throw new DBException.VolumeIOError(e);

}

target.putData(targetOffset,data,0, (int) size);

}

/**

public abstract void clear(long startOffset, long endOffset);

/**

public void copyEntireVolumeTo(Volume to) {

final long volSize = length();

final long bufSize = 1L<<CC.VOLUME_PAGE_SHIFT;

to.ensureAvailable(volSize);

for(long offset=0;offset<volSize;offset+=bufSize){

long size = Math.min(volSize,offset+bufSize)-offset;

if(CC.ASSERT && (size<0))

throw new AssertionError();

transferInto(offset,to,offset, size);

}

}

/**

public long hash(long off, long len, long seed){

if (len < 0) {

throw new IllegalArgumentException("lengths must be >= 0");

}

long bufLen = length();

if(off<0 || off>=bufLen || off+len<0 || off+len>bufLen){

throw new IndexOutOfBoundsException();

}

final long end = off + len;

long h64;

if (len >= 32) {

final long limit = end - 32;

long v1 = seed + PRIME64_1 + PRIME64_2;

long v2 = seed + PRIME64_2;

long v3 = seed + 0;

long v4 = seed - PRIME64_1;

do {

v1 += Long.reverseBytes(getLong(off)) * PRIME64_2;

v1 = rotateLeft(v1, 31);

v1 *= PRIME64_1;

off += 8;

v2 += Long.reverseBytes(getLong(off)) * PRIME64_2;

v2 = rotateLeft(v2, 31);

v2 *= PRIME64_1;

off += 8;

v3 += Long.reverseBytes(getLong(off)) * PRIME64_2;

v3 = rotateLeft(v3, 31);

v3 *= PRIME64_1;

off += 8;

v4 += Long.reverseBytes(getLong(off)) * PRIME64_2;

v4 = rotateLeft(v4, 31);

v4 *= PRIME64_1;

off += 8;

} while (off <= limit);

h64 = rotateLeft(v1, 1) + rotateLeft(v2, 7) + rotateLeft(v3, 12) + rotateLeft(v4, 18);

v1 *= PRIME64_2; v1 = rotateLeft(v1, 31); v1 *= PRIME64_1; h64 ^= v1;

h64 = h64 * PRIME64_1 + PRIME64_4;

v2 *= PRIME64_2; v2 = rotateLeft(v2, 31); v2 *= PRIME64_1; h64 ^= v2;

h64 = h64 * PRIME64_1 + PRIME64_4;

v3 *= PRIME64_2; v3 = rotateLeft(v3, 31); v3 *= PRIME64_1; h64 ^= v3;

h64 = h64 * PRIME64_1 + PRIME64_4;

v4 *= PRIME64_2; v4 = rotateLeft(v4, 31); v4 *= PRIME64_1; h64 ^= v4;

h64 = h64 * PRIME64_1 + PRIME64_4;

} else {

h64 = seed + PRIME64_5;

}

h64 += len;

while (off <= end - 8) {

long k1 = Long.reverseBytes(getLong(off));

k1 *= PRIME64_2; k1 = rotateLeft(k1, 31); k1 *= PRIME64_1; h64 ^= k1;

h64 = rotateLeft(h64, 27) * PRIME64_1 + PRIME64_4;

off += 8;

}

if (off <= end - 4) {

h64 ^= (Integer.reverseBytes(getInt(off)) & 0xFFFFFFFFL) * PRIME64_1;

h64 = rotateLeft(h64, 23) * PRIME64_2 + PRIME64_3;

off += 4;

}

while (off < end) {

h64 ^= (getByte(off) & 0xFF) * PRIME64_5;

h64 = rotateLeft(h64, 11) * PRIME64_1;

++off;

}

h64 ^= h64 >>> 33;

h64 *= PRIME64_2;

h64 ^= h64 >>> 29;

h64 *= PRIME64_3;

h64 ^= h64 >>> 32;

return h64;

}

/**

abstract static public class ByteBufferVol extends Volume{

protected final boolean cleanerHackEnabled;

protected final ReentrantLock growLock = new ReentrantLock(CC.FAIR_LOCKS);

protected final int sliceShift;

protected final int sliceSizeModMask;

protected final int sliceSize;

protected volatile ByteBuffer[] slices = new ByteBuffer[0];

protected final boolean readOnly;

protected ByteBufferVol(boolean readOnly, int sliceShift, boolean cleanerHackEnabled) {

this.readOnly = readOnly;

this.sliceShift = sliceShift;

this.cleanerHackEnabled = cleanerHackEnabled;

this.sliceSize = 1<< sliceShift;

this.sliceSizeModMask = sliceSize -1;

}

protected final ByteBuffer getSlice(long offset){

ByteBuffer[] slices = this.slices;

int pos = (int)(offset >>> sliceShift);

if(pos>=slices.length)

throw new DBException.VolumeEOF("Get/Set beyong file size. Requested offset: "+offset+", volume size: "+length());

return slices[pos];

}

@Override public final void putLong(final long offset, final long value) {

if(CC.VOLUME_PRINT_STACK_AT_OFFSET!=0 && CC.VOLUME_PRINT_STACK_AT_OFFSET>=offset && CC.VOLUME_PRINT_STACK_AT_OFFSET <= offset+8){

new IOException("VOL STACK:").printStackTrace();

}

getSlice(offset).putLong((int) (offset & sliceSizeModMask), value);

}

@Override public final void putInt(final long offset, final int value) {

if(CC.VOLUME_PRINT_STACK_AT_OFFSET!=0 && CC.VOLUME_PRINT_STACK_AT_OFFSET>=offset && CC.VOLUME_PRINT_STACK_AT_OFFSET <= offset+4){

new IOException("VOL STACK:").printStackTrace();

}

getSlice(offset).putInt((int) (offset & sliceSizeModMask), value);

}

@Override public final void putByte(final long offset, final byte value) {

if(CC.VOLUME_PRINT_STACK_AT_OFFSET!=0 && CC.VOLUME_PRINT_STACK_AT_OFFSET>=offset && CC.VOLUME_PRINT_STACK_AT_OFFSET <= offset+1){

new IOException("VOL STACK:").printStackTrace();

}

getSlice(offset).put((int) (offset & sliceSizeModMask), value);

}

@Override public void putData(final long offset, final byte[] src, int srcPos, int srcSize){

if(CC.VOLUME_PRINT_STACK_AT_OFFSET!=0 && CC.VOLUME_PRINT_STACK_AT_OFFSET>=offset && CC.VOLUME_PRINT_STACK_AT_OFFSET <= offset+srcSize){

new IOException("VOL STACK:").printStackTrace();

}

final ByteBuffer b1 = getSlice(offset).duplicate();

final int bufPos = (int) (offset& sliceSizeModMask);

b1.position(bufPos);

b1.put(src, srcPos, srcSize);

}

@Override public final void putData(final long offset, final ByteBuffer buf) {

if(CC.VOLUME_PRINT_STACK_AT_OFFSET!=0 && CC.VOLUME_PRINT_STACK_AT_OFFSET>=offset && CC.VOLUME_PRINT_STACK_AT_OFFSET <= offset+buf.remaining()){

new IOException("VOL STACK:").printStackTrace();

}

final ByteBuffer b1 = getSlice(offset).duplicate();

final int bufPos = (int) (offset& sliceSizeModMask);

//no overlap, so just write the value

b1.position(bufPos);

b1.put(buf);

}

@Override

public void transferInto(long inputOffset, Volume target, long targetOffset, long size) {

final ByteBuffer b1 =getSlice(inputOffset).duplicate();

final int bufPos = (int) (inputOffset& sliceSizeModMask);

b1.position(bufPos);

//TODO size>Integer.MAX_VALUE

b1.limit((int) (bufPos+size));

target.putData(targetOffset, b1);

}

@Override public void getData(final long offset, final byte[] src, int srcPos, int srcSize){

final ByteBuffer b1 = getSlice(offset).duplicate();

final int bufPos = (int) (offset& sliceSizeModMask);

b1.position(bufPos);

b1.get(src, srcPos, srcSize);

}

@Override final public long getLong(long offset) {

return getSlice(offset).getLong((int) (offset & sliceSizeModMask));

}

@Override final public int getInt(long offset) {

return getSlice(offset).getInt((int) (offset & sliceSizeModMask));

}

@Override public final byte getByte(long offset) {

return getSlice(offset).get((int) (offset & sliceSizeModMask));

}

@Override

public final DataIO.DataInputByteBuffer getDataInput(long offset, int size) {

return new DataIO.DataInputByteBuffer(getSlice(offset), (int) (offset& sliceSizeModMask));

}

@Override

public void putDataOverlap(long offset, byte[] data, int pos, int len) {

boolean overlap = (offset>>>sliceShift != (offset+len)>>>sliceShift);

if(overlap){

while(len>0){

ByteBuffer b = getSlice(offset).duplicate();

b.position((int) (offset&sliceSizeModMask));

int toPut = Math.min(len,sliceSize - b.position());

b.limit(b.position()+toPut);

b.put(data, pos, toPut);

pos+=toPut;

len-=toPut;

offset+=toPut;

}

}else{

putData(offset,data,pos,len);

}

}

@Override

public DataInput getDataInputOverlap(long offset, int size) {

boolean overlap = (offset>>>sliceShift != (offset+size)>>>sliceShift);

if(overlap){

byte[] bb = new byte[size];

final int origLen = size;

while(size>0){

ByteBuffer b = getSlice(offset).duplicate();

b.position((int) (offset&sliceSizeModMask));

int toPut = Math.min(size,sliceSize - b.position());

b.limit(b.position()+toPut);

b.get(bb,origLen-size,toPut);

size -=toPut;

offset+=toPut;

}

return new DataIO.DataInputByteArray(bb);

}else{

//return mapped buffer

return getDataInput(offset,size);

}

}

@Override

public void putUnsignedShort(long offset, int value) {

final ByteBuffer b = getSlice(offset);

int bpos = (int) (offset & sliceSizeModMask);

b.put(bpos++, (byte) (value >> 8));

b.put(bpos, (byte) (value));

}

@Override

public int getUnsignedShort(long offset) {

final ByteBuffer b = getSlice(offset);

int bpos = (int) (offset & sliceSizeModMask);

return (( (b.get(bpos++) & 0xff) << 8) |

( (b.get(bpos) & 0xff)));

}

@Override

public int getUnsignedByte(long offset) {

final ByteBuffer b = getSlice(offset);

int bpos = (int) (offset & sliceSizeModMask);

return b.get(bpos) & 0xff;

}

@Override

public void putUnsignedByte(long offset, int byt) {

final ByteBuffer b = getSlice(offset);

int bpos = (int) (offset & sliceSizeModMask);

b.put(bpos, toByte(byt));

}

protected static byte toByte(int byt) {

return (byte) (byt & 0xff);

}

protected static byte toByte(long l) {

return (byte) (l & 0xff);

}

@Override

public int putLongPackBidi(long offset, long value) {

final ByteBuffer b = getSlice(offset);

int bpos = (int) (offset & sliceSizeModMask);

b.put(bpos++, toByte((value & 0x7F) | 0x80));

value >>>= 7;

int counter = 2;

//$DELAY$

while ((value & ~0x7FL) != 0) {

b.put(bpos++, toByte(value & 0x7F));

value >>>= 7;

//$DELAY$

counter++;

}

//$DELAY$

b.put(bpos, toByte(value | 0x80));

return counter;

}

@Override

public long getLongPackBidi(long offset) {

final ByteBuffer bb = getSlice(offset);

int bpos = (int) (offset & sliceSizeModMask);

//$DELAY$

long b = bb.get(bpos++) & 0xffL; //TODO this could be inside loop, change all implementations

if(CC.ASSERT && (b&0x80)==0)

throw new DBException.DataCorruption();

long result = (b & 0x7F) ;

int shift = 7;

do {

//$DELAY$

b = bb.get(bpos++) & 0xffL;

result |= (b & 0x7F) << shift;

if(CC.ASSERT && shift>64)

throw new DBException.DataCorruption();

shift += 7;

}while((b & 0x80) == 0);

//$DELAY$

return (((long)(shift/7))<<60) | result;

}

@Override

public long getLongPackBidiReverse(long offset) {

final ByteBuffer bb = getSlice(offset);

int bpos = (int) (offset & sliceSizeModMask);

//$DELAY$

long b = bb.get(--bpos) & 0xffL;

if(CC.ASSERT && (b&0x80)==0)

throw new DBException.DataCorruption();

long result = (b & 0x7F) ;

int counter = 1;

do {

//$DELAY$

b = bb.get(--bpos) & 0xffL;

result = (b & 0x7F) | (result<<7);

if(CC.ASSERT && counter>8)

throw new DBException.DataCorruption();

counter++;

}while((b & 0x80) == 0);

//$DELAY$

return (((long)counter)<<60) | result;

}

@Override

public long getSixLong(long pos) {

final ByteBuffer bb = getSlice(pos);

int bpos = (int) (pos & sliceSizeModMask);

return

((long) (bb.get(bpos++) & 0xff) << 40) |

((long) (bb.get(bpos++) & 0xff) << 32) |

((long) (bb.get(bpos++) & 0xff) << 24) |

((long) (bb.get(bpos++) & 0xff) << 16) |

((long) (bb.get(bpos++) & 0xff) << 8) |

((long) (bb.get(bpos) & 0xff));

}

@Override

public void putSixLong(long pos, long value) {

final ByteBuffer b = getSlice(pos);

int bpos = (int) (pos & sliceSizeModMask);

if(CC.ASSERT && (value >>>48!=0))

throw new DBException.DataCorruption();

b.put(bpos++, (byte) (0xff & (value >> 40)));

b.put(bpos++, (byte) (0xff & (value >> 32)));

b.put(bpos++, (byte) (0xff & (value >> 24)));

b.put(bpos++, (byte) (0xff & (value >> 16)));

b.put(bpos++, (byte) (0xff & (value >> 8)));

b.put(bpos, (byte) (0xff & (value)));

}

@Override

public int putPackedLong(long pos, long value) {

final ByteBuffer b = getSlice(pos);

int bpos = (int) (pos & sliceSizeModMask);

//$DELAY$

int ret = 0;

int shift = 63-Long.numberOfLeadingZeros(value);

shift -= shift%7; // round down to nearest multiple of 7

while(shift!=0){

b.put(bpos + (ret++), (byte) (((value >>> shift) & 0x7F) | 0x80));

//$DELAY$

shift-=7;

}

b.put(bpos +(ret++),(byte) (value & 0x7F));

return ret;

}

@Override

public long getPackedLong(long position) {

final ByteBuffer b = getSlice(position);

int bpos = (int) (position & sliceSizeModMask);

long ret = 0;

int pos2 = 0;

byte v;

do{

v = b.get(bpos +(pos2++));

ret = (ret<<7 ) | (v & 0x7F);

}while(v<0);

return (((long)pos2)<<60) | ret;

}

@Override

public void clear(long startOffset, long endOffset) {

if(CC.ASSERT && (startOffset >>> sliceShift) != ((endOffset-1) >>> sliceShift))

throw new AssertionError();

ByteBuffer buf = getSlice(startOffset);

int start = (int) (startOffset&sliceSizeModMask);

int end = (int) (endOffset&sliceSizeModMask);

int pos = start;

while(pos<end){

buf = buf.duplicate();

buf.position(pos);

buf.put(CLEAR, 0, Math.min(CLEAR.length, end-pos));

pos+=CLEAR.length;

}

}

@Override

public boolean isSliced(){

return true;

}

@Override

public int sliceSize() {

return sliceSize;

}

/**

protected static boolean unmap(MappedByteBuffer b){

try{

if(unmapHackSupported){

// need to dispose old direct buffer, see bug

// http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4724038

Method cleanerMethod = b.getClass().getMethod("cleaner", new Class[0]);

cleanerMethod.setAccessible(true);

if(cleanerMethod!=null){

Object cleaner = cleanerMethod.invoke(b);

if(cleaner!=null){

Method clearMethod = cleaner.getClass().getMethod("clean", new Class[0]);

if(clearMethod!=null) {

clearMethod.invoke(cleaner);

return true;

}

}else{

//cleaner is null, try fallback method for readonly buffers

Method attMethod = b.getClass().getMethod("attachment", new Class[0]);

attMethod.setAccessible(true);

Object att = attMethod.invoke(b);

return att instanceof MappedByteBuffer &&

unmap((MappedByteBuffer) att);

}

}

}

}catch(Exception e){

unmapHackSupported = false;

LOG.log(Level.WARNING, "Unmap failed", e);

}

return false;

}

private static boolean unmapHackSupported = true;

static{

try{

unmapHackSupported =

SerializerPojo.DEFAULT_CLASS_LOADER.run("sun.nio.ch.DirectBuffer")!=null;

}catch(Exception e){

unmapHackSupported = false;

}

}

// Workaround for https://github.com/jankotek/MapDB/issues/326

// File locking after .close() on Windows.

private static boolean windowsWorkaround = System.getProperty("os.name").toLowerCase().startsWith("win");

}

/**

abstract static public class ByteBufferVolSingle extends Volume{

protected final boolean cleanerHackEnabled;

protected ByteBuffer buffer;

protected final boolean readOnly;

protected final long maxSize;

protected ByteBufferVolSingle(boolean readOnly, long maxSize, boolean cleanerHackEnabled) {

//TODO assert size

this.readOnly = readOnly;

this.maxSize = maxSize;

this.cleanerHackEnabled = cleanerHackEnabled;

}

@Override

public void ensureAvailable(long offset) {

//TODO throw error if too big

}

@Override public final void putLong(final long offset, final long value) {

if(CC.VOLUME_PRINT_STACK_AT_OFFSET!=0 && CC.VOLUME_PRINT_STACK_AT_OFFSET>=offset && CC.VOLUME_PRINT_STACK_AT_OFFSET <= offset+8){

new IOException("VOL STACK:").printStackTrace();

}

buffer.putLong((int) offset, value);

}

@Override public final void putInt(final long offset, final int value) {

if(CC.VOLUME_PRINT_STACK_AT_OFFSET!=0 && CC.VOLUME_PRINT_STACK_AT_OFFSET>=offset && CC.VOLUME_PRINT_STACK_AT_OFFSET <= offset+4){

new IOException("VOL STACK:").printStackTrace();

}

buffer.putInt((int) (offset), value);

}

@Override public final void putByte(final long offset, final byte value) {

if(CC.VOLUME_PRINT_STACK_AT_OFFSET!=0 && CC.VOLUME_PRINT_STACK_AT_OFFSET>=offset && CC.VOLUME_PRINT_STACK_AT_OFFSET <= offset+1){

new IOException("VOL STACK:").printStackTrace();

}

buffer.put((int) offset, value);

}