Method to remove period/key object from tree. Entry to delete will be
found by period and key values of given parameter p (not by given object
reference).

@param entry
the entry to remove
@return true if the entry was a member of this tree
426850
public final boolean remove(E entry) {
        TreeEntry<E> e = getEntry(entry);

        if (e == null) {
            return false;
        } else {
            deleteEntry(e);
        }

        return true;
    }
745675
@Override
  public boolean removeIfEquals(K key, V _value) {
    Entry e = lookupEntry(key);
    if (e == null) {
      metrics.peekMiss();
      return false;
    }
    synchronized (e) {
      e.waitForProcessing();
      if (e.isGone()) {
        metrics.peekMiss();
        return false;
      }
      boolean f = e.hasFreshData(clock);
      if (f) {
        if (!e.equalsValue(_value)) {
          return false;
        }
      } else {
        metrics.peekHitNotFresh();
        return false;
      }
      removeEntry(e);
      return f;
    }
  }
1373191
boolean deleteIndexEntry(S userStorable) throws PersistException {
        try {
            return makeIndexEntry(userStorable).tryDelete();
        } catch (PersistException e) {
            Throwable cause = e.getCause();
            if (cause instanceof IllegalArgumentException) {
                // Can be caused by a corrupt master record, which is
                // attempting do assign an illegal value to the index. There's
                // no way to find the old index entry to delete.
                return false;
            }
            throw e;
        }
    }
1254475
public static void removeFromList(final Entry e) {
    e.prev.next = e.next;
    e.next.prev = e.prev;
    e.removedFromList();
  }
370948
public void remove(Entry entry) {
        entry.priority = null;
        cutAndMakeRoot(entry);
        oMinEntry = entry;
        poll();
    }
346492
public int delTemplateEntry(String template,
                                Object entry) {
        int returnCode = NO_EXCEPTION;
        if (!this.disableTemplatesSupport) {
            if (delayOffload) {
                Result result = auxTemplateDependencyTable.removeEntry(template, entry);
                returnCode = result.returnCode;
                if (!result.bExist && returnCode != DISK_EXCEPTION) {
                    returnCode = delValueSetEntry(TEMPLATE_ID_DATA, template, entry);
                }
            } else {
                returnCode = delValueSetEntry(TEMPLATE_ID_DATA, template, entry);
            }
        }
        return returnCode;
    }
1291792
public synchronized void remove(Object key)
	{
		final Object o = map.remove(key);
		if (o != null)
			tree.remove(o);
	}
151827
public int remove(Object key)
  {
    if (key == null)
      key = NULL_KEY;

    int hash = key.hashCode() & _mask;

    synchronized (this) {
      Item prev = null;
      for (Item item = _entries[hash]; item != null; item = item._next) {
        Object itemKey = item._key;
      
        if (itemKey == key || itemKey.equals(key)) {
          int oldValue = item._value;

          if (prev != null)
            prev._next = item._next;
          else
            _entries[hash] = item._next;

          _size--;

          return oldValue;
        }

        prev = item;
      }
    }

    return NULL;
  }
597438
public boolean add(E entry)
	{
		super.add(entry);
		
		if(this.size() > this.maxSize)
		{
			super.removeRange(0, this.size() - maxSize);
		}
		
		return true;
	}
125112
public boolean remove(Tree child) {
		if (Config.META.equals(child.key)) {
			Tree meta = getMeta();
			if (meta != null && meta.parent != null) {
				meta.parent.meta = null;
				return true;
			}
		}
		return remove((test) -> {
			return test.key.equals(child.key);
		}
1163945
public Entry remove(Entry removePointer)
  {
    if (tc.isEntryEnabled())
      SibTr.entry(tc, "remove", new Object[] { removePointer });
    
    Entry removedEntry = null;
    
    //check that the entry to be removed is not null and is in this list
    if(contains(removePointer))
    {         
      //call the internal unsynchronized remove method on the entry to be removed.
      removedEntry = removePointer.remove();
    }
    else //if the entry is not found in this list, throw a runtime exception
    {
      SIErrorException e = new SIErrorException(
        nls.getFormattedMessage(
          "INTERNAL_MESSAGING_ERROR_CWSIP0001",
          new Object[] {
            "com.ibm.ws.sib.processor.utils.linkedlist.LinkedList",
            "1:291:1.3" },
          null));
      
      FFDCFilter.processException(
        e,
        "com.ibm.ws.sib.processor.utils.linkedlist.LinkedList.remove",
        "1:297:1.3",
        this);
        
      SibTr.exception(tc, e);   
      SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0001",
        new Object[] {
          "com.ibm.ws.sib.processor.utils.linkedlist.LinkedList",
          "1:304:1.3" });   

      if (tc.isEntryEnabled())
        SibTr.exit(tc, "remove", e);
      
      throw e;
    }
    
    if (tc.isEntryEnabled())
      SibTr.exit(tc, "remove", removedEntry);
    
    //return the object which was removed
    return removedEntry;
  }
987682
public Result removeEntry(Object dependency, Object entry) {
        Result result = this.htod.getFromResultPool();
        ValueSet valueSet = (ValueSet) dependencyToEntryTable.get(dependency);

        if (valueSet == null) {
            return result;
        }
        result.bExist = HTODDynacache.EXIST;
        valueSet.remove(entry);
        dependencyNotUpdatedTable.remove(dependency);

        if (valueSet.isEmpty()) {
            dependencyToEntryTable.remove(dependency);
            if (this.type == DEP_ID_TABLE) {
                result.returnCode = this.htod.delValueSet(HTODDynacache.DEP_ID_DATA, dependency);
            } else {
                result.returnCode = this.htod.delValueSet(HTODDynacache.TEMPLATE_ID_DATA, dependency);
            }
        }
        return result;
    }
330488
protected void removeEntry(T entry) {
        T prev = entry.getPrev();
        T next = entry.getNext();
        if (prev != null) {
            prev.setNext(next);
        } else {
            head = next;
        }
        if (next != null) {
            next.setPrev(prev);
        } else {
            last = prev;
        }
        size--;
    }
862742
public T remove(final T value) {
		expungeStaleEntries();
		//
		final Entry<T> entry = removeEntry(value);
		if (entry == null) {
			return null;
		}
		final T ret = entry.get();
		return ret;
	}
1321182
@Override
  public V remove(Object o) {
    checkMutable();
    @SuppressWarnings("unchecked")
    final K key = (K) o;
    final int index = binarySearchInArray(key);
    if (index >= 0) {
      return removeArrayEntryAt(index);
    }
    // overflowEntries might be Collections.unmodifiableMap(), so only
    // call remove() if it is non-empty.
    if (overflowEntries.isEmpty()) {
      return null;
    } else {
      return overflowEntries.remove(key);
    }
  }
820498
public boolean remove(K key, V value) {
        Set<V> set = storage.get(key);
        if (set != null) {
            final boolean removed = set.remove(value);
            if (removed && set.isEmpty()) {
                storage.remove(key);
            }
            return removed;
        }
        return false;
    }
300101
public void deleteEntry(GoogleEntry entry, GoogleCalendar calendar) throws IOException {
        dao.events().delete(calendar.getId(), entry.getId()).execute();
    }