Removes all snapshots from this list
333127
public void removeSnapshots() {
        VersionList versionToRemove = new VersionList();

        // collect Versions to be removed
        for (Version ver : this) {
            if (ver.isSnapshot()) {
                versionToRemove.add(ver);
            }
        }

        // remove them
        this.removeAll(versionToRemove);
    }
1016552
private void deleteBackups() {
        File[] storeDirList = ReadOnlyUtils.getVersionDirs(storeDir, 0L, getCurrentVersionId());
        if(storeDirList != null && storeDirList.length > (numBackups + 1)) {
            // delete ALL old directories asynchronously
            File[] extraBackups = ReadOnlyUtils.findKthVersionedDir(storeDirList,
                                                                    0,
                                                                    storeDirList.length
                                                                            - (numBackups + 1) - 1);
            if(extraBackups != null) {
                for(File backUpFile: extraBackups) {
                    deleteAsync(backUpFile);
                }
            }
        }
    }
953282
public void removeAll() {
        int size = size();
        if (size == 0) {
            return;
        }
        for (int i = 0, listSize = lists.size(); i < listSize; i++) {
            List<? extends T> list = lists.get(i);
            if (list instanceof ObservableList) {
                ((ObservableList) list).removeOnListChangedCallback(callback);
            }
        }
        lists.clear();
        modCount += 1;
        listeners.notifyRemoved(this, 0, size);
    }
282098
public void clearAllSubscriptions() {
        SubscriptionTreeCollector subsCollector = new SubscriptionTreeCollector();
        bfsVisit(subscriptions, subsCollector);
        
        List<Subscription> allSubscriptions = subsCollector.getResult();
        for (Subscription subscription : allSubscriptions) {
            removeSubscription(subscription.getTopic(), subscription.getClientId());
        }
    }
1033218
def clear_pictures(self):
        """"""

        blocks = [b for b in self.metadata_blocks if b.code != Picture.code]
        self.metadata_blocks = blocks
424485
def delete_list_items(list_, item_list, copy=False):
    
    """
    if copy:
        list_ = list_[:]
    for item in item_list:
        list_.remove(item)
    return list_
742767
def clear_dir(self):
        """"""
        for snapshot in output_utils.get_filenames(self.output_dir):
            if snapshot.endswith('.pkl'):
                os.remove(snapshot)
253783
def clear(self):
        
        for variable in self._project.variables.list(all=True):
            variable.delete()
1161602
public void removeAll() {
        for(Iterator<Map.Entry<MetricName, Metric>> it = metrics.entrySet().iterator(); it.hasNext();) {
            Map.Entry<MetricName, Metric> entry = it.next();
            Metric metric = entry.getValue();
            if(metric != null) {
                onMetricRemoved(entry.getKey(), metric);
            }
            it.remove();
        }
    }
119855
def detach_all(self):
        
        self.detach_all_classes()
        self.objects.clear()
        self.index.clear()
        self._keepalive[:] = []
1192979
def clear(self):
        
        for f in [x['content'] for x in self.metadata.values()]:
            os.remove(f)

        self.metadata = {}
        self._flush()
832874
def remove(self, toRemove):
        '''
            
        '''
        list.remove(self, toRemove)
        self.uids.remove(toRemove.uid)
1034962
def clear_data(self):
        '''
         '''
        if self.forest.verbose > 1:
            print('clearing up stuff')
        self.S = None
        self.Uy = None
        self.U = None
1192507
def clear(self):
        """"""
        self._len = 0
        del self._maxes[:]
        del self._lists[:]
        del self._keys[:]
        del self._index[:]
965838
def cleanup_snapshots(droplet, size) # rubocop:disable Metrics/AbcSize
      return unless size > keep

      warning_size(droplet.id, droplet.name, size)

      logger.debug "Cleaning up snapshots for droplet id: #{droplet.id} name: #{droplet.name}."

      api.cleanup_snapshots(droplet, size - keep - 1)
    rescue => e
      raise SnapshotCleanupError, e.message, e.backtrace
    end
1118485
public function removeAll()
    {
        $portableElements = $this->getAll();
        foreach ($portableElements as $identifier => $versions) {
            $this->removeAllVersions($identifier);
        }
    }
1148691
def delete(options = {})
      options = options.merge(db_cluster_snapshot_identifier: @snapshot_id)
      resp = @client.delete_db_cluster_snapshot(options)
      DBClusterSnapshot.new(
        cluster_id: resp.data.db_cluster_snapshot.db_cluster_identifier,
        snapshot_id: resp.data.db_cluster_snapshot.db_cluster_snapshot_identifier,
        data: resp.data.db_cluster_snapshot,
        client: @client
      )
    end