Delete indexing queue.
962836
def delete_queue():
    """"""
    def action(queue):
        queue.delete()
        click.secho('Indexing queue has been deleted.', fg='green')
        return queue
    return action
526706
def delete_index(self, refresh=False, ignore=None):
        """"""
        es = connections.get_connection("default")
        index = self.__class__.search_objects.mapping.index
        doc_type = self.__class__.search_objects.mapping.doc_type
        es.delete(index, doc_type, id=self.pk, refresh=refresh, ignore=ignore)
139309
def delete_index_files(self):
        
        self.clear_cache()
        db_path = self.db.local_db_path()
        if exists(db_path):
            remove(db_path)
234727
def clear(self):
        """"""
        url = "queues/%s/messages" % self.name
        result = self.client.delete(url = url,
                                    body = json.dumps({}),
                                    headers={'Content-Type': 'application/json'})

        return result['body']
689162
def drop_cache(self):
        '''
        
        '''
        del self._cache
        self._cache  = {}
        del self._wqueue
        self._wqueue = set()
        self._cur_size = 0
90977
def _purge_index(self, database_name,
                     collection_name=None, index_name=None):
        
        with self.__index_cache_lock:
            if not database_name in self.__index_cache:
                return

            if collection_name is None:
                del self.__index_cache[database_name]
                return

            if not collection_name in self.__index_cache[database_name]:
                return

            if index_name is None:
                del self.__index_cache[database_name][collection_name]
                return

            if index_name in self.__index_cache[database_name][collection_name]:
                del self.__index_cache[database_name][collection_name][index_name]
676802
def purge(self, connection):
        """"""
        self._checkpid()
        if connection.pid == self.pid:
            idx = connection._pattern_idx
            if connection in self._in_use_connections[idx]:
                self._in_use_connections[idx].remove(connection)
            else:
                self._available_connections[idx].remove(connection)
            connection.disconnect()
552567
def delete index
      current = @first
      index.times do
        current = current.next
      end
      current.previous.next = current.next
      current.next.previous = current.previous
    end
90155
def index_delete(self, index):
        '''
        
        '''
        request = self.session
        url = 'http://%s:%s/%s' % (self.host, self.port, index)
        response = request.delete(url)
        return response
464915
def deinit(self):
        """"""
        # Clean up after ourselves
        self._process.terminate()
        procs.remove(self._process)
        self._mq.remove()
        queues.remove(self._mq)
148498
void cleanUpStaleEntries() {
        for (KeyedRef<K, V> ref = q.poll(); ref != null; ref = q.poll()) {
            map.remove(ref.getKey(), ref); // CONCURRENT remove() operation
        }
    }
1077275
private void removeLastEntry() {
    Entry<E> entry = indexToEntry.remove(size() - 1);
    keyToEntry.remove(entry.key);
  }
867447
def delete(self):
        """"""
        self.conn.delete(self.jid)
        self.reserved = False
1277649
def delete(self, using=None, **kwargs):
        
        return self._get_connection(using).indices.delete(index=self._name, **kwargs)
633779
public void purge() {
        SortedQueue queue = getQueue();
        _eventStore.purge(_writeChannel);
        queue.clear();
        _eventStore.purge(_readChannel);
    }
1208320
def __cleanup(self):
        
# TODO: Test this.
        with self.__class__.__locker:

            while self.__read_buffer_index > 0:
                del self.__buffers[0]
                self.__read_buffer_index -= 1
893454
def delete(self):
        """"""
        self.__class__.objects.filter(pk=self.pk).delete()