Callback from JSRemoteConsumerPoint that the given tick in the stream should be changed to the completed state.
@param tick
333034
public final void expiredRequest(long tick)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "expiredRequest", Long.valueOf(tick));
    expiredRequest(tick, false);
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "expiredRequest");
  }
1000296
public void frameFinished(MapPosition framePosition) {
        synchronized (this.allowSwap) {
            this.lmMapPosition = framePosition;
            this.lmBitmap.release();
            this.allowSwap.enable();
        }
    }
908884
public void handleNewCandlestick(final BitfinexCandlestickSymbol currencyPair, final BitfinexCandle tick) {
		updateChannelHeartbeat(currencyPair);
		candleCallbacks.handleEvent(currencyPair, tick);
	}
23080
private void updateStreamState(StreamState state) {
        this.state = state;
        if (StreamState.CLOSED.equals(state)) {
            setCloseTime(System.currentTimeMillis());
            muxLink.closeStream(this);
        }
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "current stream state for stream " + this.myID + " : " + this.state);
        }
    }
745630
public void tick() {
	log.trace("Tick {}", cycles);

	cycles++;

	// check for robots up for unblocking
	for (BlockedEntry entry : blockedCollection) {
	    if (entry.getTimeout() >= cycles) {
		entry.getSync().release();
	    }
	}
    }
781213
public void setTickMarkRingVisible(final boolean VISIBLE) {
        if (null == tickMarkRingVisible) {
            _tickMarkRingVisible = VISIBLE;
            fireUpdateEvent(REDRAW_EVENT);
        } else {
            tickMarkRingVisible.set(VISIBLE);
        }
    }
349064
public void init (Pathable pable, long tickstamp)
    {
        _sx = pable.getX();
        _sy = pable.getY();
        // change the duration to a real stop time
        if (_duration == -1L) {
            _stopTime = Long.MAX_VALUE;
        } else {
            _stopTime = tickstamp + _duration;
        }
        _nextMove = tickstamp;
    }
1236414
public void handleNewTick(final BitfinexTickerSymbol currencyPair, final BitfinexTick tick) {
		updateChannelHeartbeat(currencyPair);
		tickerCallbacks.handleEvent(currencyPair, tick);
	}
118251
public void setMinuteTickMarkColor(final Color COLOR) {
        if (null == minuteTickMarkColor) {
            _minuteTickMarkColor = COLOR;
            fireUpdateEvent(REDRAW_EVENT);
        } else {
            minuteTickMarkColor.set(COLOR);
        }
    }
610398
private void changeUnknownToCompleted(long startTick, long endTick)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(
        tc,
        "changeUnknownToCompleted",
        new Object[] { Long.valueOf(startTick), Long.valueOf(endTick)});

    // position the cursor
    stream.setCursor(startTick);
    TickRange r1 = stream.getNext();
    TickRange r2 = r1;
    TickRange writeRange = null;
    java.util.ArrayList list = new ArrayList(5); // arbitrary size. this code is not on the usual processing path.
    // contains the latest range of completed ticks to be written
    while (r1.startstamp <= endTick)
    {
      if (r1.type == TickRange.Unknown)
      { // can include req in writeRange
        writeRange =
          startOrIncludeInWriteRange(writeRange, startTick, endTick, r1);
      }
      else
      {
        // cannot include req in the writeRange
        if (writeRange != null)
        {
          list.add(writeRange);
          writeRange = null;
        }
      }
      r2 = r1;
      r1 = stream.getNext();
      if (r1 == r2) // reached end of stream
        break; // break out of while loop
    } // end while (r1.startstamp <= endTick[i])
    if (writeRange != null)
    {
      list.add(writeRange);
      writeRange = null;
    }
    doWriteCompletedRanges(list);
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "changeUnknownToCompleted");
  }
1054411
public AIRequestedTick updateRequestToValue(
    long tick,
    AIMessageItem msgItem,
    boolean valueDelivered,
    SendDispatcher sendDispatcher)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(
        tc,
        "updateRequestToValue",
        new Object[] { Long.valueOf(tick), msgItem, Boolean.valueOf(valueDelivered)});

    AIRequestedTick rt = null;
    _targetStream.setCursor(tick);
    TickRange tickRange = _targetStream.getNext();
    if (tickRange.type == TickRange.Requested)
    {
      rt = (AIRequestedTick) tickRange.value;
      RemoteDispatchableKey ck = rt.getRemoteDispatchableKey();

      // The tick keeps the in-memory Java reference of the message object if valueDelivered=false,
      //      the constructor takes the reference to extract reliability and priority
      // Re-enter the ck as part of the V/U's state, just in case ordered
      //      delivery applies to consumer cardinality other than one
      AIValueTick valueTick =
        new AIValueTick(
          tick,
          msgItem,
          valueDelivered,
          ck,
          rt.getOriginalTimeout(),
          rt.getIssueTime(),
          msgItem.getMessage().getRedeliveredCount().intValue());
      TickRange valueRange = new TickRange(TickRange.Value, tick, tick);
      valueRange.value = valueTick;
      valueRange.valuestamp = tick;

      _targetStream.writeRange(valueRange);

      if (rt.getTimeout() > 0L || rt.getTimeout() == _mp.getCustomProperties().get_infinite_timeout())
      {
        if (rt.isSlowed())
        {
          _slowedGetTOM.removeTimeoutEntry(rt);
        }
        else
        {
          _eagerGetTOM.removeTimeoutEntry(rt);
        }
      }
    }
    else if (tickRange.type == TickRange.Accepted)
    {
      sendDispatcher.sendAccept(tick);
    }
    else if (tickRange.type == TickRange.Rejected)
    {
      AIRejectedRange rr = (AIRejectedRange)tickRange.value;
      sendDispatcher.sendReject(tick, tick, rr.unlockCount, rr.recovery);
    }
    else if (tickRange.type == TickRange.Completed)
    {
      sendDispatcher.sendCompleted(tick, tick);
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "updateRequestToValue", rt);

    return rt;
  }
452966
@Override
    public void tick(long now) {
        if (now - this.lastM3UAMessageTime >= this.aspFactoryImpl.m3UAManagementImpl.getHeartbeatTime()) {
            this.lastM3UAMessageTime = now;
            this.heartBeatAckMissed++;

            this.aspFactoryImpl.write(HEART_BEAT);
        }

        if (this.heartBeatAckMissed > HEART_BEAT_ACK_MISSED_ALLOWED) {
            logger.warn(String
                    .format("HEART_BEAT ACK missed %d is greater than configured %d for AspFactory %s. Underlying Association will be stopped and started again",
                            this.heartBeatAckMissed, HEART_BEAT_ACK_MISSED_ALLOWED, this.aspFactoryImpl.getName()));
            try {
                this.aspFactoryImpl.transportManagement.stopAssociation(this.aspFactoryImpl.associationName);
            } catch (Exception e) {
                logger.warn(String.format("Error while trying to stop underlying Association for AspFactpry=%s",
                        this.aspFactoryImpl.getName()), e);
            }

            try {
                this.aspFactoryImpl.transportManagement.startAssociation(this.aspFactoryImpl.associationName);
            } catch (Exception e) {
                logger.error(String.format("Error while trying to start underlying Association for AspFactpry=%s",
                        this.aspFactoryImpl.getName()), e);
            }

            // finally cancel
            this.cancel();
        }
    }
478064
public void tick() {
        final long count = uncounted.sumThenReset();
        final double instantRate = count / interval;
        if (initialized) {
            rate += (alpha * (instantRate - rate));
        } else {
            rate = instantRate;
            initialized = true;
        }
    }
627083
private void writeSilenceInternal(TickRange tr, boolean forced)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "writeSilenceInternal", new Object[] { tr, Boolean.valueOf(forced) });

        List msgList = null;

        // Take lock on target stream and hold it until messages have been
        // added to batch by deliverOrderedMessages 
        synchronized (this)
        {
            // We are only allowed to remove a message from the stream and replace 
            // it with Silence if it has not yet been added to a Batch to be delivered
            // We know that this can't happen asynchronously once we hold the targetStream lock
            // and the nextCompletedPrefix tells us the last message in the current batch 
            if (!forced || tr.valuestamp > this.nextCompletedPrefix)
            {

                synchronized (oststream)
                {
                    // Get the completedPrefix 
                    long completedPrefix = oststream.getCompletedPrefix();

                    // check if all ticks in Silence msg are already acked as if
                    // so they will be changed to Completed anyway and we don't need
                    // to do it now
                    if (tr.endstamp > completedPrefix)
                    {
                        if (forced == false)
                            oststream.writeRange(tr);
                        else
                            oststream.writeCompletedRangeForced(tr);

                        // Get updated completedPrefix
                        completedPrefix = oststream.getCompletedPrefix();

                    }

                    // The completedPrefix may have advanced when the Silence message
                    // was writen to the stream or both
                    if ((completedPrefix + 1) > doubtHorizon)
                    {
                        // advance the doubt horizon
                        doubtHorizon = completedPrefix + 1;

                        // now call the method which trys to advance the doubtHorizon
                        // from it's current setting by moving over any ticks in Completed 
                        // state and sending Values messages until it reaches a tick in
                        // Unknown or Requested
                        msgList = advanceDoubtHorizon(null);
                    }

                    if ((doubtHorizon - 1) > unknownHorizon)
                        unknownHorizon = doubtHorizon - 1;

                    // the message was writen to the stream
                    // see if this message created a gap
                    if (tr.endstamp > unknownHorizon)
                    {
                        // check if gap created
                        if (tr.startstamp > (unknownHorizon + 1))
                        {
                            handleNewGap(unknownHorizon + 1, tr.startstamp - 1);
                        }
                        unknownHorizon = tr.endstamp;
                    }

                    // Reset the health state
                    if (lastNackTick >= 0)
                    {
                        if (tr.startstamp <= lastNackTick && tr.endstamp >= lastNackTick)
                        {
                            getControlAdapter().getHealthState().updateHealth(HealthStateListener.MSG_LOST_ERROR_STATE,
                                                                              HealthState.GREEN);
                            lastNackTick = -1;
                        }
                    }

                    // If the stream is blocked, see if we have a silence for the blocking tick
                    if (isStreamBlocked())
                    {
                        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                            SibTr.debug(tc, "Stream is blocked on tick: " + linkBlockingTick + ", see if we can unblock it");
                        if (tr.endstamp >= linkBlockingTick)
                        {
                            if (tr.startstamp <= linkBlockingTick)
                            {
                                // The stream is no longer blocked
                                setStreamIsBlocked(false, DestinationHandler.OUTPUT_HANDLER_FOUND, null, null);
                            }
                        }
                    } // eof isStreamBlocked()
                } // end sync ( release the oststream lock )

                // Deliver messages outside of synchronise 
                // We do this because deliverOrderedMessages takes the 
                // BatchHandler lock and the BatchHandler callbacks require
                // the stream lock to update the completedPrefix. If we call
                // the BatchHandler when we hold the stream lock it could cause
                // a deadlock
                if (msgList != null)
                {
                    // Call the Input or Output Handler to deliver the messages
                    try
                    {
                        deliverer.deliverOrderedMessages(msgList, this, priority, reliability);
                    } catch (SINotPossibleInCurrentConfigurationException e)
                    {
                        // No FFDC code needed
                        SibTr.exception(tc, e);

                        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                            SibTr.debug(tc, "writeSilenceInternal", "GDException");

                        // Dont rethrow the exception. The GD protocols will handle the resend of
                        // the message
                    } catch (SIException e)
                    {
                        // FFDC
                        FFDCFilter.processException(
                                                    e,
                                                    "com.ibm.ws.sib.processor.gd.GuaranteedTargetStream.writeSilenceInternal",
                                                    "1:960:1.110",
                                                    this);

                        SibTr.exception(tc, e);
                        SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0002",
                                    new Object[] {
                                                  "com.ibm.ws.sib.processor.gd.GuaranteedTargetStream",
                                                  "1:967:1.110",
                                                  e });

                        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                            SibTr.exit(tc, "writeSilenceInternal", "GDException");

                        throw new SIErrorException(
                                        nls.getFormattedMessage(
                                                                "INTERNAL_MESSAGING_ERROR_CWSIP0002",
                                                                new Object[] {
                                                                              "com.ibm.ws.sib.processor.gd.GuaranteedTargetStream",
                                                                              "1:977:1.110",
                                                                              e },
                                                                null),
                                        e);
                    }
                }

            } // else can't remove as already in batch 
        } // end sync - release lock on target stream

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "writeSilenceInternal");
    }
686817
public void setMajorTickMarkType(final TickMarkType TYPE) {
        if (null == majorTickMarkType) {
            _majorTickMarkType = null == TYPE ? TickMarkType.LINE : TYPE;
            fireUpdateEvent(REDRAW_EVENT);
        } else {
            majorTickMarkType.set(TYPE);
        }
    }
728059
public final void cancelRequest(long tick)
  {
    Long objTick = Long.valueOf(tick);

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "cancelRequest", objTick);

    ArrayList<AORequestedTick> satisfiedTicks = null;
    
    try
    {
      this.lock();
      try
      {
        // it is possible that this event occurs after this object is closed.
        // it is safe to ignore it since we must have already transitioned the tick to its final state
        if (closed)
        {
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "cancelRequest");
  
          return;
        }
        AORequestedTick requestedTick =
          (AORequestedTick) tableOfRequests.get(objTick);
        
        if (requestedTick != null)
        {
          boolean transitionOccured = cancelRequestInternal(requestedTick, false);
        
          // If we expired the request and have more then process those
          // requests now
          if (transitionOccured && !listOfRequests.isEmpty())
            satisfiedTicks = processQueuedMsgs(null);
        }
  
      }
      finally
      {
        this.unlock();
      }
    }
    catch(SINotPossibleInCurrentConfigurationException e)
    {
      // No FFDC code needed
      notifyException(e);
    }
    
    if (satisfiedTicks != null)
    {
      // inform parent about satisfied ticks - outside lock
      int length = satisfiedTicks.size();
      for (int i = 0; i < length; i++)
      {
        AORequestedTick aotick = (AORequestedTick) satisfiedTicks.get(i);
        parent.satisfiedRequest(aotick.tick, aotick.getMessage());
      }
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "cancelRequest");
  }
233947
@Override
    public void writeSilenceForced(long tick)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "writeSilenceForced", Long.valueOf(tick));

        TickRange tr = null;
        synchronized (oststream) //see defect 289889
        {
            oststream.setCursor(tick);

            // Get the TickRange containing this tick 
            tr = oststream.getNext();
        }

        writeSilenceInternal(tr, true);

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "writeSilenceForced");

    }