protected boolean removeEntry(WeakEntry o, boolean userModification) {

    WeakEntry[] copyOfEntries = entries;
    int index = (o.hash & 0x7FFFFFFF) % copyOfEntries.length;
    for (WeakEntry e = copyOfEntries[index], prev = null; e != null; prev = e, e = e.next) {
      if (e == o) {
        // if this method was called as a result of a user action,
        // increment the modification count
        // this method is also called by our cleanup code and
        // that code should not cause a concurrent modification
        // exception
        if (userModification) {
          modCount++;
        }
        if (prev != null) {
          prev.next = e.next;
        } else {
          copyOfEntries[index] = e.next;
        }
        count--;
        e.value = null;
        e.next = null;
        return true;
      }
    }
    return false;
  }
    public void remove() {
      if (lastReturned == null) {
        throw new IllegalStateException();
      }
      if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
      }

      WeakEntry[] copyOfEntries = IdentityWeakHashMap.this.entries;
      int index = (lastReturned.hash & 0x7FFFFFFF) % copyOfEntries.length;
      for (WeakEntry e = copyOfEntries[index], prev = null; e != null; prev = e, e = e.next) {
        if (e == lastReturned) {
          modCount++;
          expectedModCount++;
          if (prev == null) {
            copyOfEntries[index] = e.next;
          } else {
            prev.next = e.next;
          }
          count--;
          lastReturned = null;
          return;
        }
      }
      throw new ConcurrentModificationException();
    }
 /**
  * INTERNAL: Re-builds the internal array of Entry's with a larger capacity. This method is called
  * automatically when the number of objects in this IdentityWeakHashMap exceeds its current
  * threshold.
  */
 private void rehash() {
   int oldCapacity = entries.length;
   WeakEntry[] oldEntries = entries;
   int newCapacity = (oldCapacity * 2) + 1;
   WeakEntry[] newEntries = new WeakEntry[newCapacity];
   modCount++;
   threshold = (int) (newCapacity * loadFactor);
   entries = newEntries;
   for (int i = oldCapacity; i-- > 0; ) {
     for (WeakEntry old = oldEntries[i]; old != null; ) {
       WeakEntry e = old;
       old = old.next;
       int index = (e.hash & 0x7FFFFFFF) % newCapacity;
       e.next = newEntries[index];
       newEntries[index] = e;
     }
   }
 }
 /**
  * Removes the mapping (key and its corresponding value) from this <tt>IdentityWeakHashMap</tt>,
  * if present.
  *
  * @param key key whose mapping is to be removed from the map.
  * @return the previous object for key or <tt>null</tt> if this <tt>IdentityWeakHashMap</tt> did
  *     not have one.
  */
 public V remove(Object key) {
   if (key == null) return null;
   cleanUp();
   WeakEntry[] copyOfEntries = entries;
   int hash = System.identityHashCode(key);
   int index = (hash & 0x7FFFFFFF) % copyOfEntries.length;
   for (WeakEntry e = copyOfEntries[index], prev = null; e != null; prev = e, e = e.next) {
     if (e.key.get() == key) {
       if (prev != null) {
         prev.next = e.next;
       } else {
         copyOfEntries[index] = e.next;
       }
       count--;
       return (V) e.value.get();
     }
   }
   return null;
 }
    protected Object clone(ReferenceQueue refQueue) {
      WeakEntry current = this;
      WeakEntry root =
          new WeakEntry(current.hash, current.key.get(), current.value.get(), null, refQueue);
      WeakEntry currentClone = root;

      while (current.next != null) {
        currentClone.next =
            new WeakEntry(
                current.next.hash,
                current.next.key.get(),
                current.next.value.get(),
                null,
                refQueue);
        current = current.next;
        currentClone = currentClone.next;
      }

      return root;
    }