Drops a single entry.

@param idx the index.
979402
public void dropByIndex(int idx) {
    SAXRecord entry = realTSindex.get(idx);
    if (null != entry) {
      realTSindex.remove(idx);
      entry.removeIndex(idx);
      if (entry.getIndexes().isEmpty()) {
        records.remove(String.valueOf(entry.getPayload()));
      }
    }
  }
604171
public void discardModel(int index) {
    	this.ensemble[index].resetLearning();
        this.ensembleWeights[index].val = 0;
        this.ensembleAges[index] = 0;
        this.ensembleWindows[index]=new int[(int)this.evaluationSizeOption.getValue()];
    }
158945
def remove(self, idxs):
        
        import utool as ut
        keep_idxs = ut.index_complement(idxs, len(self))
        return self.take(keep_idxs)
251250
void removeIndex(Index idx, boolean preserveData) {
        this.getSchema().getTopology().lock();
        if (!uncommittedRemovedIndexes.contains(idx.getName())) {
            uncommittedRemovedIndexes.add(idx.getName());
            TopologyManager.removeIndex(this.sqlgGraph, idx);
            if (!preserveData) {
                idx.delete(sqlgGraph);
            }
            this.getSchema().getTopology().fire(idx, "", TopologyChangeAction.DELETE);
        }
    }
20203
def pop(self, idx=-1):
        
        if (idx < 0 and -idx > self._len) or (idx >= self._len):
            raise IndexError('pop index out of range')

        pos, idx = self._pos(idx)
        val = self._lists[pos][idx]
        self._delete(pos, idx)

        return val
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);
                        }
                    }
                }
            }
1222208
public XEvent remove(int index) {
		try {
			XEvent result = events.remove(index);
			return result;
		} catch (IOException e) {
			e.printStackTrace();
			return null;
		}
	}
1075137
private void removeLast(HeapEntry<E> entry) {
    indexToEntry.remove(entry.index);
    objectToEntry.remove(entry.object);
  }
437645
@Override
    public void write(int idx) throws IOException {
        try {
            beforeWrite(1);
            out.write(idx);
            afterWrite(1);
        } catch (IOException e) {
            handleIOException(e);
        }
    }
845890
public void remove( int index )
	{
		if( (index < 0) || (index >= size) )
		{
			throw new IndexOutOfBoundsException();
		}

		--size;
		for( int i = index; i < size; ++i )
		{
			array[i] = array[i + 1];
		}

		array[size] = null;
	}
111227
@Override
    public void delete(int index)
    {
        checkNotSealed(null, index);
        slotMap.remove(null, index);
    }
2154
def _drop_indices(self):
        """"""
        self._logger.info('Dropping database indices')
        self._conn.execute(constants.DROP_TEXTNGRAM_INDEX_SQL)
        self._logger.info('Finished dropping database indices')
173175
public void removeExtendedRow(final int idx) {
        DynaFormRow rowToBeRemoved = null;
        if (0 <= idx && idx < extendedRows.size()) {
            rowToBeRemoved = extendedRows.get(idx);
        }

        if (rowToBeRemoved != null) {
            removeRow(extendedRows, rowToBeRemoved, idx);
        }
    }
697927
public Binder drop(int index, int count) {
        return new Binder(this, new Drop(index, Arrays.copyOfRange(type().parameterArray(), index, index + count)));
    }
929497
def pop_state(self, idx=None):
        

        self.state.pop()

        if idx is not None:
            self.str_begin = idx
845160
def drop_index(self, name):
        
        name = self._normalize_identifier(name)
        if not self.has_index(name):
            raise IndexDoesNotExist(name, self._name)

        del self._indexes[name]
1072424
private void removeAllEntries() {
        // A bit unusual, but we want to make sure we do not call this while the index is active.
        Preconditions.checkState(this.closed, "Cannot call removeAllEntries unless the ReadIndex is closed.");
        int count;
        synchronized (this.lock) {
            this.indexEntries.forEach(entry -> {
                if (entry.isDataEntry()) {
                    CacheKey key = getCacheKey(entry);
                    this.cache.remove(key);
                }
            });

            count = this.indexEntries.size();
            this.indexEntries.clear();
        }

        if (count > 0) {
            log.debug("{}: Cleared all cache entries ({}).", this.traceObjectId, count);
        }
    }