Returns the position of the next free Entry.
@return The position of the next free Entry.
@throws NoFreeEntryException Is thrown when there is no free entry left in
the node.
173026
private int getNextEmptyPosition(){
        int counter;
        for (counter = 0; counter < entries.length; counter++) {
            Entry e = entries[counter];
            if (e.isEmpty()) {
                break;
            }
        }

        if (counter == entries.length) {
            throw new RuntimeException("Entry added to a node which is already full.");
        }

        return counter;
    }
261082
public long getPosition()
   {
      initialize();
      long position = scoreNodes.getPosition() - invalid;
      // scoreNode.getPosition() is one ahead
      // if there is a prefetched node
      if (next != null)
      {
         position--;
      }
      return position;
   }
1123230
static <K, V> Map.Entry<K, V> exportEntry(final OMVRBTreeEntryPosition<K, V> omvrbTreeEntryPosition) {
    return omvrbTreeEntryPosition == null ? null : new OSimpleImmutableEntry<K, V>(omvrbTreeEntryPosition.entry);
  }
1319909
public XEvent next() {
		XEvent result = null;
		try {
			result = list.get(position);
		} catch (IndexOutOfBoundsException e) {
			throw new NoSuchElementException("There is no next event in this trace");
		} finally {
			position++;
		}
		return result;
	}
205741
@Override
    public long position() throws IOException
    {
        if (inflater == null && deflater == null)
        {
            return 0;
        }
        if (inflater != null)
        {
            return inflater.getBytesWritten();
        }
        else
        {
            return deflater.getBytesRead();
        }
    }
1271491
public Object next()
    {
        _current1.reset();
        if (_last1.key() == null)
            findFirst(_dstack);
        else
        {
            findNext(_dstack);
            if (_current1.key() == null)
                _eof = true;
        }

        if (_current1.key() != null)
            _last1.setLocation(_current1);

        return _current1.key();
    }
327054
protected int getFirstFreeInputGateIndex() {

		for (int i = 0; i < this.backwardEdges.size(); i++) {

			if (this.backwardEdges.get(i) == null) {
				return i;
			}
		}

		return this.backwardEdges.size();
	}
1257541
protected int getFreeSpace()
    {
        if (tc.isEntryEnabled())
            Tr.entry(tc, "getFreeSpace", this);

        final int freeBytes = _activeFile.freeBytes();

        if (tc.isEntryEnabled())
            Tr.exit(tc, "getFreeSpace", freeBytes);

        return freeBytes;
    }
947700
public List<Entry> getTopEntries() {
        if (root != null && root.getGroups() != null && root.getGroups().size() == 1) {
            return root.getGroups().get(0).getEntries();
        }
        return new ArrayList<Entry>();
    }
369177
protected OMVRBTreeEntry<K, V> getFirstEntry() {
    OMVRBTreeEntry<K, V> p = root;
    if (p != null) {
      if (p.getSize() > 0)
        pageIndex = 0;

      while (p.getLeft() != null)
        p = p.getLeft();
    }
    return p;
  }
869874
private void seekToRestartPosition(int restartPosition)
    {
        checkPositionIndex(restartPosition, restartCount, "restartPosition");

        // seek data readIndex to the beginning of the restart block
        int offset = restartPositions.getInt(restartPosition * SIZE_OF_INT);
        data.setPosition(offset);

        // clear the entries to assure key is not prefixed
        nextEntry = null;

        // read the entry
        nextEntry = readEntry(data, null);
    }
1349497
static <K, V> Map.Entry<K, V> exportEntry(final OMVRBTreeEntry<K, V> omvrbTreeEntryPosition) {
    return omvrbTreeEntryPosition == null ? null : new OSimpleImmutableEntry<K, V>(omvrbTreeEntryPosition);
  }
75946
@Override
  public int nextStartPosition() throws IOException {
    if (currentStartPosition < minPosition) {
      currentStartPosition = minPosition;
      currentEndPosition = currentStartPosition + 1;
    } else {
      currentStartPosition++;
      currentEndPosition = currentStartPosition + 1;
      if (currentStartPosition > maxPosition) {
        currentStartPosition = NO_MORE_POSITIONS;
        currentEndPosition = NO_MORE_POSITIONS;
      }
    }
    return currentStartPosition;
  }
710979
public Entry getPrevious()
  {
    checkEntryParent();

    Entry entry = null;

    if(!isFirst())
    {
      entry = previous;
    }

    return entry;
  }
1277609
public SimpleEntry next()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
    {
      SibTr.entry(tc, "next", this);
      SibTr.exit(tc, "next", this.next);
    }
    
    return this.next;
  }
680955
public Entry getFirst()
  {
    if (tc.isEntryEnabled())
      SibTr.entry(tc, "getFirst");

    if (tc.isEntryEnabled())
      SibTr.exit(tc, "getFirst", first);

    return first;
  }
834048
public long findPosition(long nOccurrence) {
		updateCount();
		if (nOccurrence <= 0) {
			return RankedBitVector.NOT_FOUND;
		}
		int findPos = (int) (nOccurrence / this.blockSize);
		if (findPos < this.positionArray.length) {
			long pos0 = this.positionArray[findPos];
			long leftOccurrences = nOccurrence - (findPos * this.blockSize);
			if (leftOccurrences == 0) {
				return pos0;
			}
			for (long index = pos0 + 1; index < this.bitVector.size(); index++) {
				if (this.bitVector.getBit(index) == this.bit) {
					leftOccurrences--;
				}
				if (leftOccurrences == 0) {
					return index;
				}
			}
		}
		return RankedBitVector.NOT_FOUND;
	}