Transactional implementation of :func:`Set.remove(item) <hazelcast.proxy.set.Set.remove>`

        :param item: (object), the specified item to be deleted.
        :return: (bool), ``true`` if item is remove successfully, ``false`` otherwise.
355187
def remove(self, item):
        
        check_not_none(item, "item can't be none")
        return self._encode_invoke(transactional_set_remove_codec, item=self._to_data(item))
899193
def delete_item(item)
      Predictor.redis.watch(redis_key(:sets, item)) do
        sets = Predictor.redis.smembers(redis_key(:sets, item))
        Predictor.redis.multi do |multi|
          sets.each do |set|
            multi.srem(redis_key(:items, set), item)
          end

          multi.del redis_key(:sets, item)
        end
      end
    end
682625
def delete(self, item, dry_run=None):
        """"""
        logger.debug('Deleting item. Item: {item} Table: {namespace}'.format(
            item=item,
            namespace=self.namespace
        ))

        if not dry_run:
            self.table.delete_item(Key={'id': item['id']})

        return item
641427
def removeItem( self, item ):
        
        # for nodes and connections, call the prepareToRemove method before 
        # removing
        if ( isinstance( item, XNode ) or 
             isinstance( item, XNodeConnection ) ):
            # make sure this item is ok to remove
            if ( not item.prepareToRemove() ):
                return False
        
        # remove the item using the base class method
        try:
            self._cache.remove(item)
        except KeyError:
            pass
        
        # mark the scene as modified
        self.setModified(True)
        super(XNodeScene, self).removeItem(item)
        
        if not self.signalsBlocked():
            self.itemsRemoved.emit()
        
        return True
371031
def delete_item(name)
      previous = items.size
      items.reject! { |item| item.name == name}
      previous != items.size
    end
241144
public boolean removeItem(T item) {
        int index = mListItems.indexOf(item);
        if (index < 0) return false;
        mListItems.remove(index);
        notifyItemRemoved(index);
        return true;
    }
1188428
public boolean remove(T transaction, I item) {
		return matrix.remove(transactionToIndex(transaction), itemToIndex(item));
	}
216563
def tag_del(self, item, tag):
        
        tags = list(self.item(item, "tags"))
        if tag in tags:
            tags.remove(tag)
            self.item(item, tags=tuple(tags))
493262
def remove(self, item):
        
        for index, child in enumerate(self._root.getchildren()):
            if child is item._root:
                del self[index]
                return item
        raise WSDLParseError("Non existing item in tag '%s'" %
                               self._schema.tag)
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())
1068979
function( item ) {
        $.console.assert(item, "[World.removeItem] item is required");

        var index = $.indexOf(this._items, item );
        if ( index === -1 ) {
            return;
        }

        item.removeHandler('bounds-change', this._delegatedFigureSizes);
        item.removeHandler('clip-change', this._delegatedFigureSizes);
        item.destroy();
        this._items.splice( index, 1 );
        this._figureSizes();
        this._needsDraw = true;
        this._raiseRemoveItem(item);
    }
787335
def removeItem(self, item):
        """"""
        try:
            self.tree.removeItem(item)
        except AttributeError, e:
            raise VersionError('Saved versions are immutable')
1139928
def remove_data_item(self, data_item: DataItem.DataItem, *, safe: bool=False) -> typing.Optional[typing.Sequence]:
        
        # remove data item from any computations
        return self.__cascade_delete(data_item, safe=safe)
1089957
public function remove($item)
    {
        $key = $item instanceof Item ? $item->name : $item;

        if ($this->has($key)) {
            $this->forget($key);
            return true;
        }

        return false;
    }
500000
function(item) {
        var id = item.id || item;

        var removedItem;
        var index = Selectivity.findIndexById(this._data, id);
        if (index > -1) {
            removedItem = this._data[index];
            this._data.splice(index, 1);
        }

        if (this._value[index] !== id) {
            index = this._value.indexOf(id);
        }
        if (index > -1) {
            this._value.splice(index, 1);
        }

        if (removedItem) {
            this.triggerChange({ removed: removedItem });
        }

        if (id === this._highlightedItemId) {
            this._highlightedItemId = null;
        }

        this._updateInputWidth();
    }
887492
def remove(self, item):
        
        check_not_none(item, "item can't be none")
        return self._encode_invoke(transactional_list_remove_codec, item=self._to_data(item))
51951
def remove(self, item):
        
        if item in self:
            super(NGram, self).remove(item)
            del self.length[item]
            for ngram in self.splititem(item):
                del self._grams[ngram][item]