Remove a range of count consecutive ids starting at id first
        from all the ranges in the set.
481658
def remove(self, first, count):
        

        # Avoid trivialities
        if first < 0 or count < 1:
            return

        new_range = []
        last = first + count - 1
        for r in self.__range:
            if first <= r.last and r.first <= last:
                # There is an overlap
                if r.first < first:
                    new_range.append(IdRange(r.first, first-r.first))
                if last < r.last:
                    new_range.append(IdRange(last+1, r.last-last))
            else:
                # No overlap, range is kept
                new_range.append(r)

        self.__range = new_range
433524
@Deprecated
  public void remove(final int rangeStart, final int rangeEnd) {
    if (rangeStart >= 0) {
      remove((long) rangeStart, (long) rangeEnd);
    }
    // rangeStart being -ve and rangeEnd being positive is not expected)
    // so assume both -ve
    remove(rangeStart & 0xFFFFFFFFL, rangeEnd & 0xFFFFFFFFL);
  }
981133
public function remove(Horde_Imap_Client_Ids $ids)
    {
        /* For sequence numbers, we need to reindex anytime we have an index
         * that appears equal to or after a previously seen index. If an IMAP
         * server is smart, it will expunge in reverse order instead. */
        if ($ids->sequence) {
            $remove = $ids->ids;
        } else {
            $ids->sort();
            $remove = array_reverse(array_keys($this->lookup($ids)));
        }

        if (empty($remove)) {
            return;
        }

        $this->sort();

        if (count($remove) == count($this->_ids) &&
            !array_diff($remove, array_keys($this->_ids))) {
            $this->_ids = array();
            return;
        }

        /* Find the minimum sequence number to remove. We know entries before
         * this are untouched so no need to process them multiple times. */
        $first = min($remove);
        $edit = $newids = array();
        foreach (array_keys($this->_ids) as $i => $seq) {
            if ($seq >= $first) {
                $i += (($seq == $first) ? 0 : 1);
                $newids = array_slice($this->_ids, 0, $i, true);
                $edit = array_slice($this->_ids, $i + (($seq == $first) ? 0 : 1), null, true);
                break;
            }
        }

        if (!empty($edit)) {
            foreach ($remove as $val) {
                $found = false;
                $tmp = array();

                foreach (array_keys($edit) as $i => $seq) {
                    if ($found) {
                        $tmp[$seq - 1] = $edit[$seq];
                    } elseif ($seq >= $val) {
                        $tmp = array_slice($edit, 0, ($seq == $val) ? $i : $i + 1, true);
                        $found = true;
                    }
                }

                $edit = $tmp;
            }
        }

        $this->_ids = $newids + $edit;
    }
940104
def trim(self):
        """"""
        for key, value in list(iteritems(self.counters)):
            if value.empty():
                del self.counters[key]
885344
def remove_by(keys, original):
    """"""
    for i in [
            original[index]
            for index, needed in enumerate(keys) if not needed
    ]:
        original.remove(i)
4435
def remove_tracks(self, track_indices):
        
        if isinstance(track_indices, int):
            track_indices = [track_indices]
        self.tracks = [track for idx, track in enumerate(self.tracks)
                       if idx not in track_indices]
745201
private T doRemove(int index) {
        keys[index]   = 0;
        states[index] = REMOVED;
        final Object previous = values[index];
        values[index] = missingEntries;
        --size;
        ++count;
        return (T)previous;
    }
628322
private void removeAt(int i) {
        Object[] array = queue;
        int n = size - 1;
        if (n == i) // removed last element
            array[i] = null;
        else {
            E moved = (E) array[n];
            array[n] = null;
            Comparator<? super E> cmp = comparator;
            if (cmp == null)
                siftDownComparable(i, moved, array, n);
            else
                siftDownUsingComparator(i, moved, array, n, cmp);
            if (array[i] == moved) {
                if (cmp == null)
                    siftUpComparable(i, moved, array);
                else
                    siftUpUsingComparator(i, moved, array, cmp);
            }
        }
        size = n;
    }
910339
def delete_all(self, criteria: Q = None):
        """"""
        if criteria:
            # Delete the object from the dictionary and return the deletion count
            items = self._filter(criteria, self.conn['data'][self.schema_name])

            # Delete all the matching identifiers
            with self.conn['lock']:
                for identifier in items:
                    self.conn['data'][self.schema_name].pop(identifier, None)

            return len(items)
        else:
            with self.conn['lock']:
                if self.schema_name in self.conn['data']:
                    del self.conn['data'][self.schema_name]
321600
function removeRange(from, to) {
      var pos = from ? from.nextSibling : self.container.firstChild;
      while (pos != to) {
        var temp = pos.nextSibling;
        removeElement(pos);
        pos = temp;
      }
    }
293677
function removeUnnecessaryCodeInNextToRange(range) {
  if (domUtils.getNodeName(range.startContainer.nextSibling) === 'CODE'
        && domUtils.getTextLength(range.startContainer.nextSibling) === 0
  ) {
    $(range.startContainer.nextSibling).remove();
  }
}
1218343
function remove(seq, index) { var result
        result = copy(seq)
        result.splice(index, 1)
        return result
    }
960194
def _exclusion_indices_for_range(self, start_idx, end_idx):
        
        itree = self._minute_exclusion_tree
        if itree.overlaps(start_idx, end_idx):
            ranges = []
            intervals = itree[start_idx:end_idx]
            for interval in intervals:
                ranges.append(interval.data)
            return sorted(ranges)
        else:
            return None
1085204
def skip(self, count):
        '''
        
        '''
        skipped = 0
        for _ in range(count):
            if self.mutate():
                skipped += 1
            else:
                break
        return skipped
1056947
function (id) {
                var dynamicIds = this._dynamicIds;
                if (dynamicIds) {
                    var index = arrayUtils.indexOf(dynamicIds, id);
                    if (index != -1) {
                        idMgr.releaseId(id);
                        if (dynamicIds.length == 1) {
                            this._dynamicIds = null;
                        } else {
                            arrayUtils.removeAt(dynamicIds, index);
                        }
                    }
                }
            }
831442
function(start_index, count) {

		if (count <= 0) Lava.t("Invalid item count supplied for removeRange");
		if (start_index + count >= this._count + 1) Lava.t("Index is out of range");

		var removed_uids = this._data_uids.splice(start_index, count),
			removed_values = this._data_values.splice(start_index, count),
			removed_names = this._data_names.splice(start_index, count);

		this._setLength(this._count - count);

		this._fire('items_removed', {
			uids: removed_uids,
			values: removed_values,
			names: removed_names
		});

		this._fire('collection_changed');

		return removed_values;

	}
1073255
def remove(self, bw):
        
        try:
            self.__ranges.remove(bw)
        except KeyError:
            if not bw.oneshot:
                raise