Remove a handler from the list
@param toRemove The handler to remove. Any handler object that
matches this class will be removed.
@return true if this handler was in the list.
186075
protected static <E extends LogRecordHandler> boolean removeHandler(Class<E> toRemove) {
    boolean rtn = false;
    Iterator<LogRecordHandler> iter = handlers.iterator();
    while(iter.hasNext()){
      if(iter.next().getClass().equals(toRemove)){
        rtn = true;
        iter.remove();
      }
    }
    return rtn;
  }
1019011
@Override
  public <T> T remove(Object objectToRemove, Class<T> entityClass) {
    return remove(objectToRemove, Util.determineCollectionName(entityClass));
  }
134709
@SuppressWarnings("unchecked")
    public boolean removeList(@NonNull ObservableList<? extends T> listToRemove) {
        int size = 0;
        for (int i = 0, listsSize = lists.size(); i < listsSize; i++) {
            List<? extends T> list = lists.get(i);
            if (list == listToRemove) {
                listToRemove.removeOnListChangedCallback(callback);
                lists.remove(i);
                modCount += 1;
                listeners.notifyRemoved(this, size, list.size());
                return true;
            }
            size += list.size();
        }
        return false;
    }
421620
public boolean onMove(int nIDMoveCommand)
    {
        boolean flag = super.onMove(nIDMoveCommand);
        this.selectField(null, DBConstants.SELECT_FIRST_FIELD);
        return flag;
    }
1372189
public boolean remove(Object o) {
        boolean removed = false;
        for (Set<T> s : sets)
            if (s.remove(o))
                removed = true;
        return removed;
    }
89398
public V remove(@NonNull K key) {
        Entry<K, V> toRemove = get(key);
        if (toRemove == null) {
            return null;
        }
        mSize--;
        if (!mIterators.isEmpty()) {
            for (SupportRemove<K, V> iter : mIterators.keySet()) {
                iter.supportRemove(toRemove);
            }
        }

        if (toRemove.mPrevious != null) {
            toRemove.mPrevious.mNext = toRemove.mNext;
        } else {
            mStart = toRemove.mNext;
        }

        if (toRemove.mNext != null) {
            toRemove.mNext.mPrevious = toRemove.mPrevious;
        } else {
            mEnd = toRemove.mPrevious;
        }

        toRemove.mNext = null;
        toRemove.mPrevious = null;
        return toRemove.mValue;
    }
645082
function unmerge(toRemove) {
    var cy = this._private.cy;

    if (!toRemove) {
      return this;
    }

    if (toRemove && string(toRemove)) {
      var selector = toRemove;
      toRemove = cy.mutableElements().filter(selector);
    }

    for (var i = 0; i < toRemove.length; i++) {
      this.unmergeOne(toRemove[i]);
    }

    return this; // chaining
  }
320555
public void delete(boolean forceDelete) throws APIException {
        HttpResponse response = client.delete(getUrl() + "?force=" + forceDelete);
        HttpClientHelpers.throwIfNotOk(response);
    }
496473
public void removeAttachment(IAtomBase toRemove) throws CTKException {

    Map<String, IAtomBase> groups = getRgroups();
    for (String key : groups.keySet()) {

      if (groups.get(key).compare(toRemove)) {
        for (int i = 0; i < attachments.size(); i++) {
          if (attachments.get(i).getLabel().equals(key)) {
            attachments.remove(i);
            break;
          }
        }
      }
    }
  }
1215775
public function removeEntry(MenuEntry $toRemove) {

		foreach($this->entries as $k => $e) {

			if($e === $toRemove) {

				array_splice($this->entries, $k, 1);

				if($toRemove instanceof DynamicMenuEntry) {

					$ndx = array_search($toRemove, $this->dynamicEntries, TRUE);

					if($ndx !== FALSE) {
						array_splice($this->dynamicEntries, $ndx, 1);
					}

				}

				$toRemove = NULL;
				break;
			}
		}
		
		return $this;

	}
576802
public boolean removeHandlerFor(final GVRSceneObject sceneObject) {
        sceneObject.detachComponent(GVRCollider.getComponentType());
        return null != touchHandlers.remove(sceneObject);
    }
403333
public static boolean unregister(IEventHandler who) {
        final Handle handle = Handle.getInstance();
        return handle._unregister(who);
    }
818251
@Override
	public void putHandlerWithView(String url, HandlerDefinition handler) {
		handlerWithViewMappingInfoStorage.put(url, handler);
		removeHandler(url);
	}
866020
protected void removeDependent(Node nodeToRemove) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "removeDependent entry: node to remove: " + nodeToRemove);
        }
        dependents.remove(nodeToRemove);
    }
1251555
function () {
        if (this.active) {
            if (this.handler) {
                this.handler.deactivate();
            }
            this.active = false;
            if(this.map) {
                OpenLayers.Element.removeClass(
                    this.map.viewPortDiv,
                    this.displayClass.replace(/ /g, "") + "Active"
                );
            }
            this.events.triggerEvent("deactivate");
            return true;
        }
        return false;
    }
846230
private final boolean removeHandle(WSJdbcConnection handle) {
        // Find the handle in the list and remove it.

        for (int i = numHandlesInUse; i > 0;)
            if (handle == handlesInUse[--i]) {
                // Once found, the handle is removed by replacing it with the last handle in the
                // list and nulling out the previous entry for the last handle.

                handlesInUse[i] = handlesInUse[--numHandlesInUse];
                handlesInUse[numHandlesInUse] = null;
                return true;
            }

        // The handle wasn't found in the list.

        return false;
    }
58870
public List<RemoveFromList> repairCommand(final RemoveFromList toRepair, final RemoveFromList repairAgainst) {
        if (toRepair.getStartPosition() + toRepair.getRemoveCount() <= repairAgainst.getStartPosition()) {
            return asList(toRepair);
        }
        if (toRepair.getStartPosition() >= repairAgainst.getStartPosition() + repairAgainst.getRemoveCount()) {
            return asList(createRepaired(toRepair, toRepair.getStartPosition() - repairAgainst.getRemoveCount(),
                    toRepair.getRemoveCount()));
        }
        final int startPosition = toRepair.getStartPosition() < repairAgainst.getStartPosition() ? toRepair
                .getStartPosition() : repairAgainst.getStartPosition();

        final int indicesBefore = repairAgainst.getStartPosition() - toRepair.getStartPosition();
        final int indicesAfter = (toRepair.getStartPosition() + toRepair.getRemoveCount())
                - (repairAgainst.getStartPosition() + repairAgainst.getRemoveCount());
        final int indicesBeforeAndAfter = max(indicesBefore, 0) + max(indicesAfter, 0);

        if (indicesBeforeAndAfter == 0) {
            return asList(createRepaired(toRepair, 0, 0));
        }

        final int removeCount = min(indicesBeforeAndAfter, toRepair.getRemoveCount());
        return asList(createRepaired(toRepair, startPosition, removeCount));
    }