How to use

position

method

in

org.objectfabric.Buff

private final int remaining() {
  /*
   * TODO: always say 0 the first time to test all interruption sites.
   */
  return _buff.limit() - _buff.position();
}

private final int remaining() {
  /*
   * TODO: always say 0 the first time to test all interruption sites.
   */
  return _buff.limit() - _buff.position();
}

final int remaining() {
  return limit() - position();
}

static int enqueueWritten(Queue<Buff> queue, Buff buff) {
  int position = buff.position();
  buff.reset();
  int marker = buff.position();
  if (position != marker) {
    Buff duplicate = buff.duplicate();
    duplicate.limit(position);
    queue.add(duplicate);
    buff.position(position);
    buff.mark();
  }
  return position - marker;
}

@Override
final void putLeftover(Buff source) {
  int remaining = source.remaining();
  position(position() - remaining);
  putImmutably(source);
  source.position(source.position() + remaining);
  position(position() - remaining);
}

private final void readImpl(Buff buff) {
  if (Debug.ENABLED)
    Debug.assertion(buff.position() >= Buff.getLargestUnsplitable());
  if (buff.remaining() > 0) {
    _reader.setBuff(buff);
    if (_leftoverSize < 0)
      _reader.startRead();
    else {
      buff.position(buff.position() - _leftoverSize);
      buff.putImmutably(_leftover, 0, _leftoverSize);
    }
    if (Debug.ENABLED)
      buff.lock(buff.limit());
    readImpl();
    _leftoverSize = buff.remaining();
    buff.getImmutably(_leftover, 0, _leftoverSize);
    buff.position(buff.limit());
  }
}

final Buff[] finishTick() {
  for (;;) {
    _writer.writeCommand(Writer.COMMAND_TICK);
    if (!interrupted())
      break;
    addBuffer();
  }
  Buff[] buffs = new Buff[_buffs.size()];
  _buffs.copyToFixed(buffs);
  _buffs.clear();
  for (int i = 0; i < buffs.length; i++) {
    buffs[i].limit(buffs[i].position());
    buffs[i].position(0);
    buffs[i].mark();
    if (Debug.ENABLED)
      buffs[i].lock(buffs[i].limit());
  }
  return buffs;
}

void check(boolean write) {
  if (Debug.THREADS)
    ThreadAssert.assertPrivate(this);
  Debug.assertion(getDuplicates() > 0);
  if (write) {
    Debug.assertion(_parent == null);
    IntBox lock = Helper.instance().getLocks().get(this);
    Debug.assertion(lock == null || position() <= lock.Value);
  }
}

private static int writeBuffs(ImmutableWriter writer, Queue<Buff> queue, Buff[] buffs, int room) {
  Buff buff = writer.getBuff();
  int index = 0;
  if (writer.interrupted())
    index = writer.resumeInt();
  else
    room -= enqueueWritten(queue, buff);
  for (; index < buffs.length; index++) {
    if (room == 0) {
      writer.interruptInt(index);
      return 0;
    }
    if (room < buffs[index].remaining()) {
      int split = buffs[index].position() + room;
      Buff duplicate = buffs[index].duplicate();
      duplicate.limit(split);
      queue.add(duplicate);
      buffs[index].position(split);
      writer.interruptInt(index);
      return 0;
    }
    queue.add(buffs[index]);
    room -= buffs[index].remaining();
    if (room < buff.remaining())
      buff.limit(buff.position() + room);
  }
  return room;
}

@SuppressWarnings("unchecked")
private static Buff[] readBuffs(ImmutableReader reader, int length) {
  List<Buff> buffs;
  int remaining = 0;
  if (reader.interrupted()) {
    buffs = (List) reader.resume();
    remaining = reader.resumeInt();
  } else {
    buffs = new List<Buff>();
    remaining = length;
  }
  Buff buff = reader.getBuff();
  if (buff.remaining() > 0) {
    Buff duplicate = buff.duplicate();
    buffs.add(duplicate);
    if (remaining <= duplicate.remaining()) {
      int split = buff.position() + remaining;
      buff.position(split);
      duplicate.limit(split);
      Buff[] array = new Buff[buffs.size()];
      buffs.copyToFixed(array);
      return array;
    }
    buff.position(buff.limit());
    remaining -= duplicate.remaining();
  }
  reader.interruptInt(remaining);
  reader.interrupt(buffs);
  return null;
}

      break;
    if (!_writer.interrupted() && buff.position() == position)
      break;
int position = buff.position();
buff.reset();
buff.limit(position);

@SuppressWarnings("fallthrough")
private final int writeImpl(Queue<Buff> queue, int room) {
  Buff buff = _writer.getBuff();
  buff.limit(Math.min(buff.position() + room, buff.capacity()));

static Buff getOrCreate() {
  ThreadContext context = ThreadContext.get();
  context.Buffs = InstanceCache.getOrCreateList(context.Buffs, _shared);
  Buff buff = null;
  if (context.Buffs.size() != 0)
    buff = context.Buffs.removeLast();
  if (buff == null) {
    int capacity = LENGTH;
    if (Debug.RANDOMIZE_TRANSFER_LENGTHS)
      capacity = getLargestUnsplitable() + Platform.get().randomInt(80000);
    buff = Platform.get().newBuff(capacity, true);
  } else {
    if (Debug.ENABLED)
      Debug.assertion(buff.get() == 0);
    buff.set(1);
  }
  if (Debug.THREADS)
    ThreadAssert.addPrivate(buff);
  buff.position(0);
  buff.limit(buff.capacity());
  buff.mark();
  if (Debug.ENABLED) {
    Debug.assertion(buff._parent == null);
    Helper.instance().toRecycle(buff);
    Debug.assertion(!Helper.instance().getLocks().containsKey(buff));
  }
  // instance._debug_stack = Platform.get().getStackAsString(new Exception());
  return buff;
}

@Override
final void onVisitedResource(Resource resource) {
  super.onVisitedResource(resource);
  if (_added.size() > 0) {
    visitingNewObject(true);
    int map1 = mapIndex1();
    int map2 = mapIndex2();
    mapIndex1(TransactionManager.OBJECTS_VERSIONS_INDEX);
    mapIndex2(snapshot().writes().length);
    for (;;) {
      TObject object = _added.poll();
      if (object == null)
        break;
      if (Debug.ENABLED)
        Debug.assertion(object.resource() == resource);
      visit(object);
    }
    mapIndex1(map1);
    mapIndex2(map2);
    visitingNewObject(false);
  }
  if (_buffs.size() > 1 || _buffs.get(0).position() > 1)
    _clock.onBlock(resource, _versions);
  _versions = null;
}

  Debug.assertion(buff.remaining() == 0);
buff.position(0);
buff.mark();