@see com.ibm.ws.sib.processor.impl.interfaces.DestinationHandler#reset()

If a child destination wants to implement reset, it should override this
method.
439721
public void reset() throws InvalidOperationException
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "reset");

    InvalidOperationException e = new InvalidOperationException(
      nls.getFormattedMessage(
        "OPERATION_IS_INVALID_ERROR_CWSIP0121",
        new Object[] { getName(), getBus() },
      null));

    SibTr.exception(tc, e);
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())    
      SibTr.exit(tc, "reset", e);
      
    throw e;    
  }
91897
public function reset()
    {
        $this->values[self::PROTOCOL_VERSION] = null;
        $this->values[self::SOURCE_ID] = null;
        $this->values[self::DESTINATION_ID] = null;
        $this->values[self::NNAMESPACE] = null;
        $this->values[self::PAYLOAD_TYPE] = null;
        $this->values[self::PAYLOAD_UTF8] = null;
        $this->values[self::PAYLOAD_BINARY] = null;
    }
1103463
void reset()
  {
    _deleteNode = null;
    _deleteIndex = 0;
    _targetNode = null;
    _targetIndex = 0;
    _type = NONE;
    _notFound = true;
  }
864658
public void reset() {
        this.table = this.hashTable.getTable();
        this.length = this.table.length;
        this.entry = null;
        this.row = 0;
    }
851819
@Override
	public final void setJMSDestination(Destination destination) throws JMSException
    {
    	assertDeserializationLevel(MessageSerializationLevel.FULL);
        this.destination = DestinationTools.asRef(destination);
    }
572832
public void reset()
    {
        m_currentValue = null;
        useCurrentValue(false);
        setDerived(false);
        m_notKnown = false;
        setUnknown(m_lastUnknown);
    }
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");
    }
206347
public void reset() {
    checkReadOnly();
    if (state != READY && state != DONE) {
      throw new ResetException();
    }
    state = RESET;
    LIB.mdb_txn_reset(ptr);
  }
1132065
protected void reset() {
		if (this.status == ProcessStatus.STOPPED || this.status == ProcessStatus.COMPLETED) {
			if (this.runOnce) {
				throw new UnsupportedOperationException("This process template can only safely execute once; "
						+ "instantiate a new instance per request");
			}

			this.status = ProcessStatus.RESET;
		}
	}
84810
public void resetLink(String linkName)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "resetLink", linkName);

        try
        {
            DestinationHandler link = linkIndex.findByName(linkName, null);

            checkDestinationHandlerExists(
                                          link != null,
                                          linkName,
                                          messageProcessor.getMessagingEngineBus());

            // Only applicable to BaseDestinationHandlers and their children
            if (link instanceof LinkHandler)
            {
                LinkHandler linkhandler = (LinkHandler) link;

                // Need to ensure that this change is persisted - specifically that the
                // BDH "toBeIgnored" flag is persisted
                LocalTransaction siTran = txManager.createLocalTransaction(true);

                linkhandler.reset();

                // Change our entry in the appropriate index.
                linkIndex.reset(link);

                // Persist the change
                linkhandler.requestUpdate((Transaction) siTran);

                // commit the transaction
                siTran.commit();

                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                    SibTr.debug(tc, "Have reset link " + linkhandler.getName());
            }
            else
            {
                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                    SibTr.debug(tc, "Not a LinkHandler, cannot reset handler for " + link.getName());
            }
        } catch (MessageStoreException e)
        {
            // No FFDC code needed

            SibTr.exception(tc, e);

            //throw e;
        } catch (SIException e)
        {
            // No FFDC code needed

            SibTr.exception(tc, e);

            //handleRollback(siTran);
            //        throw e;
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "resetLink");
    }
730167
public void reset() {

		this.jawrConfigMgrObjectName = null;
		this.debugOverriden = false;
		this.bundleProcessingAtBuildTime = false;
		this.requestURL = null;
		this.stopWatch = null;
		this.interruptProcessingBundle.set(false);
	}
264622
public void reset() {
        synchronized (zsRef) {
            ensureOpen();
            reset(zsRef.address());
            finish = false;
            finished = false;
            off = len = 0;
            bytesRead = bytesWritten = 0;
        }
    }
596121
@Override
    public void reconstitute(int startMode,
                             DestinationDefinition definition,
                             boolean isToBeDeleted,
                             boolean isSystem)
                    throws SIDiscriminatorSyntaxException, MessageStoreException, SIResourceException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc,
                        "reconstitute",
                        new Object[] {
                                      Integer.valueOf(startMode),
                                      definition,
                                      Boolean.valueOf(isToBeDeleted),
                                      Boolean.valueOf(isSystem),
                                      this });

        _remoteSupport.reconstituteAnycastRMEPhaseOne();
        reconstituteLocalQueuePoint(startMode, isSystem);
        _remoteSupport.reconstituteAnycastRMEPhaseTwo(startMode, definition);
        reconstituteMQLink(startMode);
        reconstituteRemoteQueuePoints(startMode, isSystem);

        if (isToBeDeleted)
            setToBeDeleted();

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "reconstitute");
    }
1231341
public void setDestinationFilter(SIBUuid12 destination)
  {
    if (tc.isEntryEnabled())
      SibTr.entry(tc, "setDestinationFilter", destination);

    this._destination = destination;
    this._subscriptionId = null;
    this._consumerDispatcherState = null;
    
    if (tc.isEntryEnabled())
      SibTr.exit(tc, "setDestinationFilter");
  }
1242602
public void reset()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
        { // 306998.15
            Tr.debug(tc, "reset");
        }
        out = null;
        // obs = null;
        count = 0;
        total = 0L;
        limit = -1L;
        length = -1L;
        committed = false;
        _hasWritten = false;
        _hasFlushed = false;
        response = null;
    }
1340792
public static final void reset(){
		instance.reset();
		String junittest = System.getProperty("JUNITTEST");
		if (junittest!=null && junittest.equalsIgnoreCase("true"))
			return;
		StartBuiltInProducers.restartbuiltin();
	}
1216102
public void reset(Channel channel, ByteBuffer message, SocketAddress remoteAddress, boolean cancellable) {

        if (!future.isResetable()) {
            throw new IllegalStateException("Cannot reset message event before future has completed");
        }

        if (channel == null) {
            throw new NullPointerException("channel");
        }
        if (message == null) {
            throw new NullPointerException("message");
        }
        this.channel = channel;
        this.future.reset(channel, cancellable);
        // note: NETTY duplicates original ByteBuffer when converting ChannelBuffer to ByteBuffer
        //       instead, wrap with a non-duplicating ChannelBuffer
        this.message = channelBuf.wrap(message);
        if (remoteAddress != null) {
            this.remoteAddress = remoteAddress;
        } else {
            this.remoteAddress = channel.getRemoteAddress();
        }
    }