private void appendInstance(DirectBytes bytes, V value) {
   bytes.clear();
   if (builder.generatedValueType()) ((BytesMarshallable) value).writeMarshallable(bytes);
   else bytes.writeInstance(vClass, value);
   bytes.flip();
   if (bytes.remaining() > tmpBytes.remaining())
     throw new IllegalArgumentException(
         "Value too large for entry was "
             + bytes.remaining()
             + ", remaining: "
             + tmpBytes.remaining());
   tmpBytes.write(bytes);
 }
    /**
     * @param keyBytes
     * @param value
     * @param hash2
     * @return
     */
    V acquireEntry(DirectBytes keyBytes, V value, int hash2) {
      value = createValueIfNull(value);

      final int pos = nextFree();
      final long offset = entriesOffset + pos * entrySize;
      tmpBytes.storePositionAndSize(bytes, offset, entrySize);
      final long keyLength = keyBytes.remaining();
      tmpBytes.writeStopBit(keyLength);
      tmpBytes.write(keyBytes);
      if (value instanceof Byteable) {
        Byteable byteable = (Byteable) value;
        int length = byteable.maxSize();
        tmpBytes.writeStopBit(length);
        tmpBytes.position(align(tmpBytes.position()));
        if (length > tmpBytes.remaining())
          throw new IllegalStateException(
              "Not enough space left in entry for value, needs "
                  + length
                  + " but only "
                  + tmpBytes.remaining()
                  + " left");
        tmpBytes.zeroOut(tmpBytes.position(), tmpBytes.position() + length);
        byteable.bytes(bytes, offset + tmpBytes.position());
      } else {
        appendInstance(keyBytes, value);
      }
      // add to index if successful.
      hashLookup.put(hash2, pos);
      incrementSize();
      return value;
    }
    public V remove(DirectBytes keyBytes, V value, int hash2) {
      if (hash2 == hashLookup.unsetKey()) hash2 = ~hash2;
      lock();
      try {
        hashLookup.startSearch(hash2);
        while (true) {
          int pos = hashLookup.nextInt();
          if (pos == hashLookup.unsetValue()) {
            return null;

          } else {
            long offset = entriesOffset + pos * builder.entrySize();
            tmpBytes.storePositionAndSize(bytes, offset, builder.entrySize());
            if (!keyEquals(keyBytes, tmpBytes)) continue;
            long keyLength = align(keyBytes.remaining());
            tmpBytes.skip(keyLength);
            V v =
                value == null && builder.removeReturnsNull()
                    ? null
                    : readObjectUsing(value, offset + keyLength);
            hashLookup.remove(hash2, pos);
            freeList.clear(pos);
            if (pos < nextSet) nextSet = pos;
            return v;
          }
        }
      } finally {
        unlock();
      }
    }
    public V acquire(DirectBytes keyBytes, V value, int hash2, boolean create) {
      if (hash2 == hashLookup.unsetKey()) hash2 = ~hash2;
      lock();
      try {
        hashLookup.startSearch(hash2);
        while (true) {
          int pos = hashLookup.nextInt();
          if (pos == hashLookup.unsetValue()) {
            return create ? acquireEntry(keyBytes, value, hash2) : null;

          } else {
            long offset = entriesOffset + pos * builder.entrySize();
            tmpBytes.storePositionAndSize(bytes, offset, builder.entrySize());
            long start0 = System.nanoTime();
            boolean miss = !keyEquals(keyBytes, tmpBytes);
            long time0 = System.nanoTime() - start0;
            if (time0 > 1e6)
              System.out.println("startsWith took " + time0 / 100000 / 10.0 + " ms.");
            if (miss) continue;
            long keyLength =
                align(keyBytes.remaining() + tmpBytes.position()); // includes the stop bit length.
            tmpBytes.position(keyLength);
            return readObjectUsing(value, offset + keyLength);
          }
        }
      } finally {
        unlock();
      }
    }
 private void putEntry(DirectBytes keyBytes, V value, int hash2) {
   int pos = nextFree();
   long offset = entriesOffset + pos * builder.entrySize();
   tmpBytes.storePositionAndSize(bytes, offset, builder.entrySize());
   long keyLength = keyBytes.remaining();
   tmpBytes.writeStopBit(keyLength);
   tmpBytes.write(keyBytes);
   tmpBytes.position(align(tmpBytes.position()));
   appendInstance(keyBytes, value);
   // add to index if successful.
   hashLookup.put(hash2, pos);
 }
 private V acquireEntry(DirectBytes keyBytes, V value, int hash2) {
   int pos = nextFree();
   long offset = entriesOffset + pos * builder.entrySize();
   tmpBytes.storePositionAndSize(bytes, offset, builder.entrySize());
   long keyLength = keyBytes.remaining();
   tmpBytes.writeStopBit(keyLength);
   tmpBytes.write(keyBytes);
   tmpBytes.position(align(tmpBytes.position()));
   tmpBytes.zeroOut(tmpBytes.position(), tmpBytes.limit());
   V v = readObjectUsing(value, offset + tmpBytes.position());
   // add to index if successful.
   hashLookup.put(hash2, pos);
   return v;
 }
    /**
     * implementation for map.put(Key,Value)
     *
     * @param keyBytes
     * @param value
     * @param hash2 a hash code relating to the {@keyBytes} ( not the natural hash of {@keyBytes} )
     * @param replaceIfPresent
     * @return
     */
    V put(final DirectBytes keyBytes, final V value, int hash2, boolean replaceIfPresent) {
      lock();
      try {
        hash2 = hashLookup.startSearch(hash2);
        while (true) {
          final int pos = hashLookup.nextPos();
          if (pos < 0) {
            putEntry(keyBytes, value, hash2);

            return null;

          } else {
            final long offset = entriesOffset + pos * entrySize;
            tmpBytes.storePositionAndSize(bytes, offset, entrySize);
            if (!keyEquals(keyBytes, tmpBytes)) continue;
            final long keyLength = keyBytes.remaining();
            tmpBytes.skip(keyLength);
            if (replaceIfPresent) {
              if (putReturnsNull) {
                appendInstance(keyBytes, value);
                return null;
              }
              long valuePosition = tmpBytes.position();
              tmpBytes.readStopBit();
              final long alignPosition = align(tmpBytes.position());
              tmpBytes.position(alignPosition);
              final V v = readObjectUsing(null, offset + alignPosition);
              tmpBytes.position(valuePosition);
              appendInstance(keyBytes, value);
              return v;

            } else {
              if (putReturnsNull) {
                return null;
              }

              return readObjectUsing(null, offset + keyLength);
            }
          }
        }
      } finally {
        unlock();
      }
    }
    /**
     * implementation for map.replace(Key,Value) and map.replace(Key,Old,New)
     *
     * @param keyBytes the key of the entry to be replaced
     * @param expectedValue the expected value to replaced
     * @param newValue the new value that will only be set if the existing value in the map equals
     *     the {@param expectedValue} or {@param expectedValue} is null
     * @param hash2 a hash code relating to the {@keyBytes} ( not the natural hash of {@keyBytes} )
     * @return null if the value was not replaced, else the value that is replaced is returned
     */
    V replace(
        final DirectBytes keyBytes, final V expectedValue, final V newValue, final int hash2) {
      lock();
      try {

        hashLookup.startSearch(hash2);
        while (true) {

          final int pos = hashLookup.nextPos();

          if (pos < 0) {
            return null;

          } else {

            final long offset = entriesOffset + pos * entrySize;
            tmpBytes.storePositionAndSize(bytes, offset, entrySize);

            if (!keyEquals(keyBytes, tmpBytes)) continue;

            final long keyLength = keyBytes.remaining();
            tmpBytes.skip(keyLength);
            long valuePosition = tmpBytes.position();
            tmpBytes.readStopBit();
            final long alignPosition = align(tmpBytes.position());
            tmpBytes.position(alignPosition);

            final V valueRead = readObjectUsing(null, offset + keyLength);

            if (valueRead == null) return null;

            if (expectedValue == null || expectedValue.equals(valueRead)) {
              tmpBytes.position(valuePosition);
              appendInstance(keyBytes, newValue);
            }

            return valueRead;
          }
        }
      } finally {
        unlock();
      }
    }
    public V put(DirectBytes keyBytes, V value, int hash2, boolean replaceIfPresent) {
      if (hash2 == hashLookup.unsetKey()) hash2 = ~hash2;
      lock();
      try {
        hashLookup.startSearch(hash2);
        while (true) {
          int pos = hashLookup.nextInt();
          if (pos == hashLookup.unsetValue()) {
            putEntry(keyBytes, value, hash2);
            return null;

          } else {
            long offset = entriesOffset + pos * builder.entrySize();
            tmpBytes.storePositionAndSize(bytes, offset, builder.entrySize());
            if (!keyEquals(keyBytes, tmpBytes)) continue;
            long keyLength = keyBytes.remaining();
            tmpBytes.skip(keyLength);
            long alignPosition = align(tmpBytes.position());
            tmpBytes.position(alignPosition);
            if (replaceIfPresent) {
              if (builder.putReturnsNull()) {
                appendInstance(keyBytes, value);
                return null;
              }
              V v = readObjectUsing(null, offset + alignPosition);
              tmpBytes.position(alignPosition);
              appendInstance(keyBytes, value);
              return v;

            } else {
              if (builder.putReturnsNull()) {
                return null;
              }
              return readObjectUsing(null, offset + keyLength);
            }
          }
        }
      } finally {
        unlock();
      }
    }
    /**
     * implementation for map.remove(Key,Value)
     *
     * @param keyBytes the key of the entry to remove
     * @param expectedValue the entry will only be removed if the {@param existingValue} equals null
     *     or the {@param existingValue} equals that of the entry.value
     * @param hash2 a hash code relating to the {@keyBytes} ( not the natural hash of {@keyBytes} )
     * @return
     */
    V remove(final DirectBytes keyBytes, final V expectedValue, int hash2) {
      lock();
      try {
        hash2 = hashLookup.startSearch(hash2);
        while (true) {

          final int pos = hashLookup.nextPos();
          if (pos < 0) {
            return null;

          } else {
            final long offset = entriesOffset + pos * entrySize;
            tmpBytes.storePositionAndSize(bytes, offset, entrySize);
            if (!keyEquals(keyBytes, tmpBytes)) continue;
            final long keyLength =
                align(keyBytes.remaining() + tmpBytes.position()); // includes the stop bit length.
            tmpBytes.position(keyLength);
            V valueRemoved =
                expectedValue == null && removeReturnsNull
                    ? null
                    : readObjectUsing(null, offset + keyLength);

            if (expectedValue != null && !expectedValue.equals(valueRemoved)) return null;

            hashLookup.remove(hash2, pos);
            decrementSize();

            freeList.clear(pos);
            if (pos < nextSet) nextSet = pos;

            return valueRemoved;
          }
        }
      } finally {
        unlock();
      }
    }
    /**
     * used to acquire and object of type V from the map,
     *
     * <p>when {@param create }== true, this method is equivalent to :
     *
     * <pre>
     * Object value = map.get("Key");
     *
     * if ( counter == null ) {
     *    value = new Object();
     *    map.put("Key", value);
     * }
     *
     * return value;
     * </pre>
     *
     * @param keyBytes the key of the entry
     * @param value an object to be reused, null creates a new object.
     * @param hash2 a hash code relating to the {@keyBytes} ( not the natural hash of {@keyBytes} )
     * @param create false - if the {@keyBytes} can not be found null will be returned, true - if
     *     the {@keyBytes} can not be found an value will be acquired
     * @return an entry.value whose entry.key equals {@param keyBytes}
     */
    V acquire(DirectBytes keyBytes, V value, int hash2, boolean create) {
      lock();
      try {
        hash2 = hashLookup.startSearch(hash2);
        while (true) {
          int pos = hashLookup.nextPos();
          if (pos < 0) {
            return create ? acquireEntry(keyBytes, value, hash2) : null;

          } else {
            final long offset = entriesOffset + pos * entrySize;
            tmpBytes.storePositionAndSize(bytes, offset, entrySize);
            final boolean miss;
            if (LOGGER.isLoggable(Level.FINE)) {
              final long start0 = System.nanoTime();
              miss = !keyEquals(keyBytes, tmpBytes);
              final long time0 = System.nanoTime() - start0;
              if (time0 > 1e6) LOGGER.fine("startsWith took " + time0 / 100000 / 10.0 + " ms.");
            } else {
              miss = !keyEquals(keyBytes, tmpBytes);
            }
            if (miss) continue;
            long valueLengthOffset = keyBytes.remaining() + tmpBytes.position();
            tmpBytes.position(valueLengthOffset);
            // skip the value length
            // todo use the value length to limit reading below
            long valueLength = tmpBytes.readStopBit();
            final long valueOffset = align(tmpBytes.position()); // includes the stop bit length.
            tmpBytes.position(valueOffset);
            return readObjectUsing(value, offset + valueOffset);
          }
        }
      } finally {
        unlock();
      }
    }
 private boolean keyEquals(DirectBytes keyBytes, MultiStoreBytes tmpBytes) {
   // check the length is the same.
   long keyLength = tmpBytes.readStopBit();
   return keyLength == keyBytes.remaining() && tmpBytes.startsWith(keyBytes);
 }