Removes the all the given Object.

@param toRemove
the to remove
@return the list the removed Objects.
184489
public List<T> removeAll(final List<T> toRemove)
	{
		final List<T> removedList = new ArrayList<>();
		for (final T t : toRemove)
		{
			final int index = data.indexOf(t);
			if (index != -1)
			{
				removedList.add(data.remove(index));
			}
		}
		fireTableDataChanged();
		return removedList;
	}
556943
public function removeAll()
    {
        $this->removed_objects = array_values($this->objects);
        $this->objects = array();
        $this->objects_by_index = array();
        $this->current_index = 0;
    }
182615
@Override
    public List<Object> removeAttribute(final String name) {
        List<Object> removedValues = null;

        for (final IAdditionalDescriptors additionalDescriptors : this.delegateDescriptors) {
            final List<Object> values = additionalDescriptors.removeAttribute(name);
            if (values != null) {
                if (removedValues == null) {
                    removedValues = new ArrayList<>(values);
                } else {
                    removedValues.addAll(values);
                }
            }
        }

        return removedValues;
    }
541213
public V remove(Object key) {
        List<V> res = map.remove(key);
        if (res == null) {
            return null;
        }
        assert (!res.isEmpty());
        return res.iterator().next();
    }
380591
public List<T> removeAll(final int[] selectedRows)
	{
		final List<T> removedList = new ArrayList<>();
		final int lastIndex = selectedRows.length - 1;
		for (int i = lastIndex; -1 < i; i--)
		{
			final int selectedRow = selectedRows[i];
			final T row = removeAt(selectedRow);
			removedList.add(row);
		}
		fireTableDataChanged();
		return removedList;
	}
570534
public java.util.List<CreateVolumePermission> getRemove() {
        if (remove == null) {
            remove = new com.amazonaws.internal.SdkInternalList<CreateVolumePermission>();
        }
        return remove;
    }
262567
@Override
    public List<ENTRY> removeAll(Collection<ENTRY> entries) throws MultiException, InvalidStateException {
        final List<ENTRY> removedEntries = new ArrayList<>();
        ExceptionStack exceptionStack = null;
        registryLock.writeLock().lock();
        try {
            for (ENTRY entry : entries) {

                // shutdown check is needed because this is not a atomic transaction.
                if (shutdownInitiated) {
                    throw new InvalidStateException("Entry removal canceled because registry is shutting down!");
                }

                try {
                    if (contains(entry)) {
                        removedEntries.add(remove(entry));
                    }
                } catch (CouldNotPerformException ex) {
                    exceptionStack = MultiException.push(this, ex, exceptionStack);
                }
            }
            MultiException.checkAndThrow(() -> "Could not remove all entries!", exceptionStack);
        } finally {
            registryLock.writeLock().unlock();
        }
        return removedEntries;
    }
732172
@Override
	public List<MemorySegment> dispose() {
		this.freeMemory.addAll(this.sortBuffer);
		this.sortBuffer.clear();
		return this.freeMemory;
	}
679461
public List<RemoveFromList> repairCommand(final RemoveFromList toRepair, final AddToList repairAgainst) {
        return repairAddOrReplace(toRepair, repairAgainst.getPosition());
    }
287614
function getRemoveIndexes ( modelsToRemove, models ) {
        var indexes = {},
            toRemove = modelsToRemove || [];

        if( !_.isArray( toRemove ) ) toRemove = [toRemove];

        models = models.slice() || [];

        _.each( toRemove, function ( model ) {
            var index = _.indexOf( models, model );
            if ( index !== -1 ) {
                indexes[model.cid] = index;
                models.splice( index, 1 );
            }
        } );

        return indexes;
    }
831480
public synchronized ArrayList<V> removeAll(@Nullable Predicate<K> predicate) {
    ArrayList<V> oldValues = new ArrayList<>();
    Iterator<LinkedHashMap.Entry<K, V>> iterator = mMap.entrySet().iterator();
    while (iterator.hasNext()) {
      LinkedHashMap.Entry<K, V> entry = iterator.next();
      if (predicate == null || predicate.apply(entry.getKey())) {
        oldValues.add(entry.getValue());
        mSizeInBytes -= getValueSizeInBytes(entry.getValue());
        iterator.remove();
      }
    }
    return oldValues;
  }
24599
public java.util.List<DeleteFleetSuccessItem> getSuccessfulFleetDeletions() {
        if (successfulFleetDeletions == null) {
            successfulFleetDeletions = new com.amazonaws.internal.SdkInternalList<DeleteFleetSuccessItem>();
        }
        return successfulFleetDeletions;
    }
1132733
public List<HierarchicalProperty> removeList(HierarchicalProperty request)
   {
      HierarchicalProperty remove = request.getChild(new QName("DAV:", "remove"));
      HierarchicalProperty prop = remove.getChild(new QName("DAV:", "prop"));
      List<HierarchicalProperty> removeList = prop.getChildren();
      return removeList;
   }
156900
@SuppressWarnings("unchecked")
    public static <E, T extends E> Collection<E> removeAll(Collection<E> c, T... array){
        for(T obj: array)
            c.remove(obj);
        return c;
    }
509194
@Programmatic
    public List<SomeAuditedObject> delete(final SomeAuditedObject object) {
        repositoryService.remove(object);
        transactionService.flushTransaction();
        return listAll();
    }
225867
public void removeAll(Object object) {
		for (Entry<Integer, List<EventQueueEntry>> e : queue.entrySet()) {
			List<EventQueueEntry> entries = e.getValue();
			
			List<EventQueueEntry> toRemove = new LinkedList<>();
			synchronized (entries) {
				for (EventQueueEntry entry : entries) {
					if (entry.getObject() == object) {
						toRemove.add(entry);
					}
				}
				
				entries.removeAll(toRemove);
				
				// TODO: can we safely remove `entries` if it's empty here?
			}
		}
		
		log.debug(
				"Removed {} from notification queue for {}",
				object, eventType);
	}
379484
public boolean removeAll() throws IOException
  {
    if (isDirectory() && ! isLink()) {
      String []list = list();

      for (int i = 0; i < list.length; i++) {
        PathImpl subpath = lookup(list[i]);
        subpath.removeAll();
      }
    }

    return remove();
  }