How to use

DirectBytes

in

net.openhft.lang.io

@NotNull
public final DirectBytes bytes() {
  return new DirectBytes(this, refCount);
}

 final DirectStore store = DirectStore.allocate(128L << 32); // give me 128 GB
final DirectBytes slice = store.createSlice();

// every record has say 128 bytes and a lock at the start so they can be locked individually
for(long l = 0; l < store.size(); l += 128) {
  slice.positionAndSize(l, 128);
  slice.busyLock(0L);
  // change something
  slive.writeLong(4L, l);
  slice.unlock(0L);
}

// when finished with the store
store.free(); // still no GCs.

static void writeUTF1(DirectBytes bytes, @NotNull char[] chars, int strlen) {
  int i;
  ascii:
  {
    for (i = 0; i < strlen; i++) {
      char c = chars[i];
      if (c > 0x007F)
        break ascii;
      NativeBytes.UNSAFE.putByte(bytes.positionAddr + i, (byte) c);
    }
    bytes.skip(i);
    return;
  }
  bytes.skip(i);
  if (i < strlen)
    writeUTF2(bytes, chars, strlen, i);
}

@Override
public T get(long index) {
  T t = acquire();
  Byteable byteable = (Byteable) t;
  DirectBytes bytes = (DirectBytes) byteable.bytes();
  bytes.positionAndSize(index * size, size);
  return t;
}

public void positionAndSize(long offset, long size) {
  if (offset < 0 || size < 0 || offset + size > store.size())
    throw new IllegalArgumentException();
  setStartPositionAddress(store.address() + offset);
  capacityAddr = limitAddr = startAddr + size;
}

  @Override
  public void recycle(T t) {
    if (freeList.size() < MAX_SIZE) {
      assert ((DirectBytes) ((Byteable) t).bytes()).store() == store;
      assert !freeList.contains(t) : "recycling object already recycled";
      freeList.add(t);
    }
  }
}

  @Override
  public ByteBuffer sliceAsByteBuffer(ByteBuffer toReuse) {
    return sliceAsByteBuffer(toReuse, store);
  }
}

  public static void main(String... ignored) throws IOException {
    // this example only works on Linux
    File file = new File("/tmp/shared");
    MappedStore ms = new MappedStore(file, FileChannel.MapMode.READ_WRITE, 64L << 40);
    DirectBytes bytes = ms.bytes();
//        bytes.writeLong(0L, 1234);
    System.out.println("value=" + bytes.readLong(0L));
    long end = System.currentTimeMillis() + 30 * 1000;
    while (end > System.currentTimeMillis()) ;
    ms.free();
  }
}

@Override
public T get(long index) {
  T t = acquire();
  Byteable byteable = (Byteable) t;
  DirectBytes bytes = (DirectBytes) byteable.bytes();
  bytes.positionAndSize(index * size, size);
  return t;
}

public void positionAndSize(long offset, long size) {
  if (offset < 0 || size < 0 || offset + size > store.size())
    throw new IllegalArgumentException();
  setStartPositionAddress(store.address() + offset);
  capacityAddr = limitAddr = startAddr + size;
}

  @Override
  public void recycle(T t) {
    if (freeList.size() < MAX_SIZE) {
      assert ((DirectBytes) ((Byteable) t).bytes()).store() == store;
      assert !freeList.contains(t) : "recycling object already recycled";
      freeList.add(t);
    }
  }
}

  @Override
  public ByteBuffer sliceAsByteBuffer(ByteBuffer toReuse) {
    return sliceAsByteBuffer(toReuse, store);
  }
}

@NotNull
public final DirectBytes bytes(long offset, long length) {
  return new DirectBytes(this, refCount, offset, length);
}

@Override
public void get(long index, T element) {
  if (tClass.isInstance(element)) {
    DirectBytes bytes = (DirectBytes) ((Byteable) element).bytes();
    bytes.positionAndSize(index * size, size);
    return;
  }
  T t = acquire();
  DirectBytes bytes = (DirectBytes) ((Byteable) t).bytes();
  bytes.positionAndSize(index * size, size);
  ((Copyable) element).copyFrom(t);
  recycle(t);
}

static void writeUTF1(DirectBytes bytes, @NotNull char[] chars, int strlen) {
  int i;
  ascii:
  {
    for (i = 0; i < strlen; i++) {
      char c = chars[i];
      if (c > 0x007F)
        break ascii;
      NativeBytes.UNSAFE.putByte(bytes.positionAddr + i, (byte) c);
    }
    bytes.skip(i);
    return;
  }
  bytes.skip(i);
  if (i < strlen)
    writeUTF2(bytes, chars, strlen, i);
}

@NotNull
public final  DirectBytes bytes(long offset, long length) {
  return new DirectBytes(this, refCount, offset, length);
}

@Override
public void get(long index, T element) {
  if (tClass.isInstance(element)) {
    DirectBytes bytes = (DirectBytes) ((Byteable) element).bytes();
    bytes.positionAndSize(index * size, size);
    return;
  }
  T t = acquire();
  DirectBytes bytes = (DirectBytes) ((Byteable) t).bytes();
  bytes.positionAndSize(index * size, size);
  ((Copyable) element).copyFrom(t);
  recycle(t);
}

  static void writeUTF1(DirectBytes bytes, @NotNull CharSequence str, int strlen) {
    int i = 0;
    ascii:
    {
      for (; i < strlen - 3; i += 4) {
        char c0 = str.charAt(i);
        char c1 = str.charAt(i + 1);
        char c2 = str.charAt(i + 2);
        char c3 = str.charAt(i + 3);
        if ((c0 | c1 | c2 | c3) > 0x007F)
          break ascii;
        NativeBytes.UNSAFE.putInt(bytes.positionAddr + i, c0 | (c1 << 8) | (c2 << 16) | (c3 << 24));
      }
      for (; i < strlen; i++) {
        char c = str.charAt(i);
        if (c > 0x007F)
//            if (c + Integer.MIN_VALUE - 1 <= Integer.MIN_VALUE + 0x007F-1)
          break ascii;
        NativeBytes.UNSAFE.putByte(bytes.positionAddr + i, (byte) c);
      }
    }
    bytes.skip(i);
    if (i < strlen)
      writeUTF2(bytes, str, strlen, i);
  }

@NotNull
public DirectBytes bytes(long offset, long length) {
  return new DirectBytes(this, refCount, offset, length);
}

  static void writeUTF1(DirectBytes bytes, @NotNull CharSequence str, int strlen) {
    int i = 0;
    ascii:
    {
      for (; i < strlen - 3; i += 4) {
        char c0 = str.charAt(i);
        char c1 = str.charAt(i + 1);
        char c2 = str.charAt(i + 2);
        char c3 = str.charAt(i + 3);
        if ((c0 | c1 | c2 | c3) > 0x007F)
          break ascii;
        NativeBytes.UNSAFE.putInt(bytes.positionAddr + i, c0 | (c1 << 8) | (c2 << 16) | (c3 << 24));
      }
      for (; i < strlen; i++) {
        char c = str.charAt(i);
        if (c > 0x007F)
//            if (c + Integer.MIN_VALUE - 1 <= Integer.MIN_VALUE + 0x007F-1)
          break ascii;
        NativeBytes.UNSAFE.putByte(bytes.positionAddr + i, (byte) c);
      }
    }
    bytes.skip(i);
    if (i < strlen)
      writeUTF2(bytes, str, strlen, i);
  }