Removes an item from the list.

@return
true if the list contained the item. False if it didn't,
in which case there's no change.
768732
public synchronized boolean remove(E e) {
        List<E> n = new ArrayList<>(core);
        boolean r = n.remove(e);
        core = n;
        return r;
    }
1371251
public static <T> T removeLast( List<T> list )
    {
        return remove( list, list.size() - 1 );
    }
1080175
public boolean removeOne(Object key, V value) {
        List<V> list = map.get(key);
        if (list == null) {
            return false;
        }
        boolean res = list.remove(value);
        if (list.isEmpty()) {
            // Remove the key also if the value set is now empty
            map.remove(key);
        }
        return res;
    }
336369
public function can_delete() {
        if ($this->get_item_uses_count()) {
            return false;
        }
        if (empty($this->courseid)) {
            if ($this->get_course_uses_count()) {
                return false;
            }
        }
        return true;
    }
27140
public boolean remove() {
        Entry e = flushedEntry;
        if (e == null) {
            clearNioBuffers();
            return false;
        }
        Object msg = e.msg;

        ChannelPromise promise = e.promise;
        int size = e.pendingSize;

        removeEntry(e);

        if (!e.cancelled) {
            // only release message, notify and decrement if it was not canceled before.
            ReferenceCountUtil.safeRelease(msg);
            safeSuccess(promise);
            decrementPendingOutboundBytes(size, false, true);
        }

        // recycle the entry
        e.recycle();

        return true;
    }
1026944
def remove(self, item):
        
        index = self.index(item)
        self.real_list.remove(item)
        self.observer(UpdateType.DELETED, item, index)
493290
public boolean removeBusItinerary(BusItinerary itinerary) {
		final int index = this.itineraries.indexOf(itinerary);
		if (index >= 0) {
			return removeBusItinerary(index);
		}
		return false;
	}
1176965
def remove_item(self, item):
        
        for idx, _item in enumerate(self.items):
            if item == _item:
                del self.items[idx]
                return True
        return False
1053758
function removeItemsFromList(list, itemsToRemove) {
    var result = [];

    _.each(list, function (item) {
        var valid = true;
        for (var i = 0; i < itemsToRemove.length; i++) {

            // if the item match one of the items to remove don't includ it in the result list
            if (item.indexOf(itemsToRemove[i]) === 0) {
                valid = false;
                break;
            }
        }

        if (valid) {
            result.push(item);
        }
    });

    return result;
}
666566
public boolean remove()
    {
        if (_last1.key() == null)
            throw new java.util.NoSuchElementException(
                                                      "remove() without calling next()");

        boolean result = internalRemove();

        return result;
    }
753094
public function removeAll()
    {
        if (!$this->isEmpty()) {
            foreach ($this->getAll() as $key => $val) {
                $this->remove($key);
            }

            return true;
        } else {
            return false;
        }
    }
899808
public boolean removeAll(Collection<T> trans, Collection<I> items) {
		if (trans == null || trans.isEmpty() || items == null || items.isEmpty())
			return false;
		return matrix.removeAll(allTransactions.convert(trans).indices(), allItems.convert(items).indices());
	}
22890
public boolean removeItem(T object) {
        int size = 0;
        for (int i = 0, listsSize = lists.size(); i < listsSize; i++) {
            List<? extends T> list = lists.get(i);
            if (!(list instanceof ObservableList)) {
                Object item = list.get(0);
                if ((object == null) ? (item == null) : object.equals(item)) {
                    lists.remove(i);
                    modCount += 1;
                    listeners.notifyRemoved(this, size, 1);
                    return true;
                }
            }
            size += list.size();
        }
        return false;
    }
759153
public boolean remove()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "remove");

        boolean reply = iterator.remove();

        if (reply)
        {
            size--;
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "remove", "reply=" + reply);
        return reply;
    }
485949
public boolean remove(final int value)
    {
        if (value == MISSING_VALUE)
        {
            final boolean previousContainsMissingValue = this.containsMissingValue;
            containsMissingValue = false;
            return previousContainsMissingValue;
        }

        final int[] values = this.values;
        @DoNotSub final int mask = values.length - 1;
        @DoNotSub int index = Hashing.hash(value, mask);

        while (values[index] != MISSING_VALUE)
        {
            if (values[index] == value)
            {
                values[index] = MISSING_VALUE;
                compactChain(index);
                sizeOfArrayValues--;
                return true;
            }

            index = next(index, mask);
        }

        return false;
    }
1206016
public boolean delete() {
		try {
			con.getRoster().removeEntry(get());
			return true;
		} catch (XMPPException | NotLoggedInException | NoResponseException
				| NotConnectedException e) {
			e.printStackTrace();
		}
		return false;
	}
852490
public void clear()
    {
        if (this.removedItems == null)
        {
            this.removedItems = new FastList(this.size());
        }
        for(int i=0;i < this.size(); i++)
        {
            MithraTransactionalObject result = (MithraTransactionalObject) this.get(i);
            this.addRemovedItem(result);
        }
        super.clear();
    }