Used to reset the row, ready for Result data to be written into the
byte[] buffer by an external routine.
421898
public void resetRow(int rowsize) {

        if (out != null) {
            out.reset(rowsize);

            buf = out.getBuffer();
        }

        super.reset();
    }
934903
private void reset()
    {
        int count = 0;
        for (int i = 0; i < tableLength; i++)
        {
            long t = tableAt(i);
            count += Long.bitCount(t & ONE_MASK);
            tableAt(i, (t >>> 1) & RESET_MASK);
        }
        size = (size >>> 1) - (count >>> 2);
    }
241371
public function reset()
    {
        if (null !== $this->_dataReader) {
            $this->_dataReader->close();
        }
        $this->_dataReader = null;
        $this->_batch = null;
        $this->_value = null;
        $this->_key = null;
    }
1330573
public void reset()
    {
        this.bufferSize = 0;
        this.bufferPos = 0;
        this.bufferSizeAfterLimit = 0;
        this.currentLimit = Integer.MAX_VALUE;
        this.lastTag = 0;
        this.packedLimit = 0;
        this.sizeLimit = DEFAULT_SIZE_LIMIT;
        resetSizeCounter();
    }
254707
public void reset() {
    n_ = 0;
    combinedBufferItemCapacity_ = 2 * Math.min(DoublesSketch.MIN_K, k_); //the min is important
    combinedBuffer_ = new Object[combinedBufferItemCapacity_];
    baseBufferCount_ = 0;
    bitPattern_ = 0;
    minValue_ = null;
    maxValue_ = null;
  }
467298
@Override
    public void reset() throws JMSException {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "reset");

        // After reset has been called, the message body is immutable (the only way of changing it is to
        // call clearBody and start again). If we're in Write Mode, we need to convert the writeStream
        // to a byte array and switch into read mode. If we're in Read Mode, we must have already done this,
        // so we don't want to do it again
        if (!isBodyReadOnly()) {

            // If the producer won't modify the payload after set,skip the
            // encoding of the write stream because encoding is not needed
            if (!producerWontModifyPayloadAfterSet) {
                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                    SibTr.debug(this, tc, "Body is writeable & producer might modify the payload, so encode the write stream");

                // Convert the stream in which the message was being assembled to a byte array
                dataBuffer = _writeBytes.toByteArray();

                // store the content in the JS msg
                lastEncoding = integerEncoding | floatEncoding;
                jsBytesMsg.setBytes(_exportBody(lastEncoding));
                bodySetInJsMsg = true;

                // Throw away the write stream
                writeStream = null;
                _writeBytes = null;
            }

            dataStart = 0; // start from the first byte in the buffer

            // The message is now read only
            setBodyReadOnly();
        }

        // For some odd reason, after receiving an 'empty' message the dataBuffer
        // is null rather than pointing to an empty array. This will compensate
        // hopefully without any side effects - SXA #58832
        if (dataBuffer == null)
            dataBuffer = new byte[0];

        // Create a Byte array input stream for the readxxx methods to operate on. We have to create a new
        // stream each time (rather than call the stream's read method), as the stream may have a position
        // marked in it that isn't at the start.
        _readBytes = new ByteArrayInputStream(dataBuffer);
        readStream = new DataInputStream(_readBytes);

        // Jump over any header that might be present in the dataBuffer
        // JBK - I don't think we will ever have dataStart!=0 in JS, but I'm
        // leaving the capability here until I understand better.
        try {
            readStream.skip(dataStart);
        } catch (IOException e) {
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "reset");
    }
881328
public void reset()
  {
    m_flushedStartDoc = false;
    m_foundFirstElement = false;
    m_outputStream = null;
    clearParameters();
    m_result = null;
    m_resultContentHandler = null;
    m_resultDeclHandler = null;
    m_resultDTDHandler = null;
    m_resultLexicalHandler = null;
    m_serializer = null;
    m_systemID = null;
    m_URIResolver = null;
    m_outputFormat = new OutputProperties(Method.XML);
  }
980645
protected HeaderRow resetHeaderDefaultRow() {
        getHeader().removeRow(getHeader().getDefaultRow());
        final HeaderRow newHeaderRow = getHeader().appendRow();
        getHeader().setDefaultRow(newHeaderRow);
        return newHeaderRow;
    }
321486
function onResultStreamData(chunk)
  {
    // unsubscribe from the result stream's 'data' and 'close' events
    resultStream.removeListener('data', onResultStreamData);
    resultStream.removeListener('close', onResultStreamClose);

    // get all the rows in the chunk that overlap with the requested window,
    // and use the resulting array as the new row buffer
    var chunkStart = chunk.getStartIndex();
    var chunkEnd = chunk.getEndIndex();
    rowBuffer = chunk.getRows().slice(
        Math.max(chunkStart, start) - chunkStart,
        Math.min(chunkEnd, end) + 1 - chunkStart);

    // reset the row index
    rowIndex = 0;

    // process the row buffer
    processRowBuffer();
  }
1284397
public void reset() {
        synchronized (zsRef) {
            ensureOpen();
            reset(zsRef.address());
            buf = defaultBuf;
            finished = false;
            needDict = false;
            off = len = 0;
            bytesRead = bytesWritten = 0;
        }
    }
1368948
protected function resetOutput()
    {
        if ($this->baseResponse instanceof GlobalEnvironmentInterface) {
            $this->baseResponse = $this->baseResponse->revive();
        }
        
        // Clear output buffer
        if (isset($this->baseResponse) && $this->baseResponse->getBody() instanceof OutputBufferStream) {
            $this->baseResponse = $this->baseResponse->withBody(clone $this->baseResponse->getBody());
        }
    }
429015
public void resetBuffer()
    {
        if (isCommitted())
            throw new IllegalStateException("Committed");
        
        ((HttpOutputStream)_httpResponse.getOutputStream()).resetBuffer();
        if (_writer!=null) _writer.reset();
    }
1235277
function(err)
  {
    // if we have a result stream, stop listening to events on it
    if (resultStream)
    {
      resultStream.removeListener('data', onResultStreamData);
      resultStream.removeListener('close', onResultStreamClose);
    }

    // we're done, so time to clean up
    rowBuffer = null;
    rowIndex = 0;
    resultStream = null;
    numResultStreamInterrupts = 0;

    if (err)
    {
      emitError(err);
    }
    else
    {
      self.push(null);
    }
  }
766037
@Override
  public void reset () throws IOException
  {
    _ensureOpen ();
    if (m_nMarkedChar < 0)
      throw new IOException (m_nMarkedChar == INVALIDATED ? "Mark invalid" : "Stream not marked");
    m_nNextCharIndex = m_nMarkedChar;
    m_bSkipLF = m_bMarkedSkipLF;
  }
538018
private void bufferRows1() throws IOException {
		BinaryRow copy = key1.copy();
		buffer1.reset();
		do {
			buffer1.add(row1);
		} while (nextRow1() && keyComparator.compare(key1, copy) == 0);
		buffer1.complete();
	}
206347
public void reset() {
    checkReadOnly();
    if (state != READY && state != DONE) {
      throw new ResetException();
    }
    state = RESET;
    LIB.mdb_txn_reset(ptr);
  }
739958
public function reset()
    { 
        $this->setPosition(0);
        $this->setOnWriteDataMode(false);
        $this->setDataBuffer(null);
        $this->setResource(null);
    }