Empty the list and reset all indexes.
165760
public function clear()
    {
        $this->list = null;
        if (is_array($this->secondary_indexes)) {
            foreach ($this->secondary_indexes as $index) {
                $index->clear();
            }
        }
    }
556943
public function removeAll()
    {
        $this->removed_objects = array_values($this->objects);
        $this->objects = array();
        $this->objects_by_index = array();
        $this->current_index = 0;
    }
911441
def _clean_index(self):
        ""
        for idx_name, idx_def in self.index_defs.items():
            if idx_def['type'] == 'lazy':
                self.build_index(idx_name)
        for index_name, values in self.indexes.items():
            for value in values:
                if not isinstance(values[value], set):
                    values[value] = set(values[value])
770755
def reset_all(self, suppress_logging=False):
        
        pool_names = list(self.pools)
        for name in pool_names:
            self.reset(name, suppress_logging)
948743
private void reset() {
		for (DietzfelbingerHash hashfunction : this.hashfunctions) {
			hashfunction.nextHashFunction();
		}

		int sizeTables = 1 << this.hashSize;
		for (List<Entry<T>> table : this.tables) {
			table.clear();
			for (int j = 0; j < sizeTables; j++) {
				table.add(null);
			}
		}

		this.stash.clear();
		this.stashSize = 0;

		for (Entry<T> entry : this.elements) {
			fileElement(entry, false);
		}
	}
1146689
def clear(self):
        """"""
        self.sampler.clear()
        self.samples_list = self._comm.gather(self.sampler.samples, root=0)
        if hasattr(self.sampler, 'weights'):
            self.weights_list = self._comm.gather(self.sampler.weights, root=0)
        else:
            self.weights_list = None
49282
def clear(self):
        """"""
        self._points = _np.empty( (self.prealloc,self.dim) )
        self._slice_for_run_nr = []
        self.memleft = self.prealloc
532303
def clear(self):
        ''''''
        self._size = 0
        self._level = 1
        self._head = Node('HEAD', None,
                          [None]*SKIPLIST_MAXLEVEL,
                          [1]*SKIPLIST_MAXLEVEL)
964580
def clean_indexes(self):
        
        self.sort()
        for index, item in enumerate(self):
            item.index = index + 1
653412
def clear(self):
        ""
        if isinstance(self.data, np.ndarray):
            data = self.data[:, :0]
        elif util.pd and isinstance(self.data, util.pd.DataFrame):
            data = self.data.iloc[:0]
        elif isinstance(self.data, dict):
            data = {k: v[:0] for k, v in self.data.items()}
        with util.disable_constant(self):
            self.data = data
        self.send(data)
1312419
def clear(self):
        """"""
        if len(self.list):
            self._LOG.debug("List cleared.")
        self.list.clear()
32856
public void clearIndex(Index index) {
    BulkIndexer.delete(esClient, IndexType.main(index, index.getName()), esClient.prepareSearch(index).setQuery(matchAllQuery()));
  }
1335042
public void reset() {
        targetFile = null;
        title = null;
        defaultTitle = null;
        inTitleElement = false;
        termStack.clear();
        topicIdStack.clear();
        indexTermSpecList.clear();
        indexSeeSpecList.clear();
        indexSeeAlsoSpecList.clear();
        indexSortAsSpecList.clear();
        topicSpecList.clear();
        indexTermList.clear();
        processRoleStack.clear();
        processRoleLevel = 0;
        titleMap.clear();
    }
45671
def clean(self, *args, **kwargs):
        """"""
        for key in list(self.store.keys()):
            self.unset(key)
576096
@Override
    public void clear() {

        _tailLock.lock();
        try {

            _headLock.lock();
            try {
                _indexes[HEAD_OFFSET] = 0;
                _indexes[TAIL_OFFSET] = 0;
                _size.set(0);
            } finally {
                _headLock.unlock();
            }
        } finally {
            _tailLock.unlock();
        }
    }
61045
public function clear(): void
    {
        $list = $this->dataRepository->getList()
                ->filterBy('key', $this->keyPrefix, 'startWith');
        foreach ($list as $item) {
            $this->dataRepository->delete($item->key);
        };
    }
544864
def clear(self):
        """"""
        for root, dirs, files in os.walk(self._root_dir, topdown=False):
            for file in files:
                os.unlink(os.path.join(root, file))
            os.rmdir(root)
        # Get the root dir back and re-initialise to start again
        root_dir = os.path.abspath(
            os.path.join(self._root_dir, os.pardir))
        self.__init__(root_dir)