Remove all occurrence of the parameter.
        :param item: Value to delete from the WeakList.
965058
def remove_all(self, item):
        # type: (Any) -> None
        
        item = self.ref(item)
        while list.__contains__(self, item):
            list.remove(self, item)
143377
function destroyItem(item) {
			var checkbox = item.checkbox;

			// pull out from the array
			//erase(allItems, item);

			// destroy SVG elements
			each(['legendItem', 'legendLine', 'legendSymbol'], function (key) {
				if (item[key]) {
					item[key].destroy();
				}
			});

			if (checkbox) {
				discardElement(item.checkbox);
			}


		}
753580
public boolean removeItem (T item)
    {
        int index = _items.indexOf(item);
        if (index == -1) {
            return false;
        }
        _items.remove(index);
        removeItem(index);
        return true;
    }
1295148
def delete(self, item_id):
        
        try:
            response = self._request("tasks/delete/{id}".format(id=item_id))

            if response.status_code == 200:
                return True

        except sandboxapi.SandboxError:
            pass

        return False
1280873
public void remove(ItemState item)
   {
      if (item.isNode())
      {
         remove(item.getData().getQPath());
      }
      else 
      {
         removeProperty(item, -1);
      }
   }
849668
public void removeItem(JQMListItem item) {
        if (item != null) {
            items.remove(item);
            list.remove(item);
        }
    }
397426
public function removeItem(Item $item)
    {
        if ($this->items->contains($item)) {
            $this->items->removeElement($item);
            $item->removeLabel($this);
        }

        return $this;
    }
204993
def remove(self, item):
        '''

        '''
        match = self.match(item)
        if match is None:
            raise clique.error.CollectionError(
                'Item not present in collection.'
            )

        index = int(match.group('index'))
        try:
            self.indexes.remove(index)
        except KeyError:
            raise clique.error.CollectionError(
                'Item not present in collection.'
            )
444178
def delete(self, symbol):
        
        logger.info("Deleting data item: %r from %r" % (symbol, self._arctic_lib.get_name()))
        # None is the magic sentinel value that indicates an item has been deleted.
        sentinel = self.write(symbol, None, prune_previous_version=False, metadata={'deleted': True})
        self._prune_previous_versions(symbol, 0)

        # If there aren't any other versions, then we don't need the sentinel empty value
        # so delete the sentinel version altogether
        snapped_version = self._versions.find_one({'symbol': symbol,
                                                   'metadata.deleted': {'$ne': True}})
        if not snapped_version:
            self._delete_version(symbol, sentinel.version)
        assert not self.has_symbol(symbol)
590450
def delete(self, item, dry_run=None):
        """"""
        logger.debug('Deleting item. Item: {item} Path: {data_file}'.format(
            item=item,
            data_file=self.data_file
        ))

        items = load_file(self.data_file)
        items = remove_item(self.namespace, self.version, item, items)
        save_file(self.data_file, items, dry_run=dry_run)

        return item
265169
def remove(self, item):
        
        self.items.pop(item)
        self._remove_dep(item)
        self.order = None
        self.changed(code_changed=True)
1199554
def remove(self, item):
        
        if item not in self.__dict__[self.ATTRIBUTES].keys():
            raise AttributeError('%s does not exist' % item)
        delattr(self, item)
918227
def delete_list_item(self, item_id):
        

        url = self.build_url(self._endpoints.get('get_item_by_id').format(item_id=item_id))

        response = self.con.delete(url)

        return bool(response)
961378
def delete(self, layer, items):
        
        # Use edit to get the layer obj containing item
        items = _listify(items)  # make items a list if it's not
        layer_obj = self.edit(layer, dict.fromkeys(items), delete=True)
        for k in items:
            if k in layer_obj.layer:
                layer_obj.delete(k)
            else:
                raise AttributeError('item %s missing from layer %s' %
                                     (k, layer))
1276355
def unselect_item(self, item):
        
        self.queue_draw_item(item)
        if item.model in self._selection:
            with self._suppress_selection_events():
                self._selection.remove(item.model)
            self.emit('selection-changed', self._get_selected_items())
724026
def removeItem(self, index):
        """"""
        self._stim.removeComponent(index.row(), index.column())
25998
function removeItem(itemName) {
  // TODO: Only remove used items
  if (data[itemName]) {
    data[itemName] = null;
  }
  if (localExists() && getItem(itemName)) {
    try {
      // Clear session storage
      window.sessionStorage.removeItem(itemName);
    } catch (error) {
      _logger2.default.warn({
        description: 'Error removing item from session storage', error: error,
        obj: 'storage', func: 'removeItem'
      });
    }
  }
}