reset this alarm's values

@param time
@param latest
@param listener
@param context
173675
void reset(long time,
             long latest,
             AlarmListener listener,
             Object context,
             long index)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(
        tc,
        "reset",
        new Object[] { new Long(time), new Long(latest), listener, context, new Long(index) });
    
    data = listener;
    this.time = time;
    this.latest = latest;
    this.context = context;
    this.index = index;
    //check if this alarm has a group listener
    groupListener = (listener instanceof GroupAlarmListener);
    //flag as not canceled 
    active = true;
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "reset");
  }
103553
public void alarm(final Object context) {
      long sleepInterval = 0;
      do {
         long startWakeUpTime = System.currentTimeMillis();
         try {
            wakeUp(startDaemonTime, startWakeUpTime);
         } catch (Exception ex) {
            com.ibm.ws.ffdc.FFDCFilter.processException(ex, "com.ibm.ws.cache.RealTimeDaemon.alarm", "83", this);
            if (tc.isDebugEnabled())
               Tr.debug(tc, "exception during wakeUp", ex);
         }
         sleepInterval = timeInterval - (System.currentTimeMillis() - startWakeUpTime);
         // keep looping while we are behind... (i.e. execution time is greater than the time interval)
      } while (sleepInterval <= 0);
      
      if (false == stopDaemon){    	  
			Scheduler.createNonDeferrable(sleepInterval, context,
					new Runnable() {
						@Override
						public void run() {
							alarm(context);
						}
					}); 	  
      }      
   }
601490
public void advanceClock(final int offset) {
    this.currentTime += offset;
    final Iterator<Alarm> iter = this.alarmList.iterator();
    while (iter.hasNext()) {
      final Alarm alarm = iter.next();
      if (alarm.getTimestamp() <= this.currentTime) {
        alarm.run();
        iter.remove();
      }
    }
  }
584777
public void onTimerEvent(TimerEvent event, ActivityContextInterface aci) {
		// time to refresh :)
		
		if (getSubscribeRequestTypeCMP() != null) {
			return;
		}

		try {
			DialogActivity da = (DialogActivity) aci.getActivity();
			Request refreshSubscribe = createRefresh(da, getSubscriptionData());
			setSubscribeRequestTypeCMP(SubscribeRequestType.REFRESH);
			da.sendRequest(refreshSubscribe);
		} catch (Exception e) {
			if (tracer.isSevereEnabled()) {
				tracer.severe("Failed to send unSUBSCRIBE for forked dialog.", e);
			}
		}
	}
1351249
@Override
    public void setMaxInactiveInterval(int time) {
        this.maxInactiveTimeSetting = time;
        if (time < 0) {
            this.maxInactiveTime = NO_TIMEOUT;
        } else {
            this.maxInactiveTime = (time * 1000L);
        }
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "max-inactive time: " + this.maxInactiveTimeSetting);
        }
    }
925189
public void alarm(Object alarmContext)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "alarm", alarmContext);

    synchronized (this)
    {
      iAlarmCancelled = true;

      // Did the request message fail
      if (iRequestFailed)
      {
        iRequestFailed = false;

        // Get the reset subscription list.
        SubscriptionMessage message = iBusGroup.generateResetSubscriptionMessage();
        message.setSubscriptionMessageType(SubscriptionMessageType.REQUEST);

        // If there is a reset message to send, then send it.
        LocalTransaction transaction = iProxyHandler.getMessageProcessor().getTXManager().createLocalTransaction(true);

        try
        {
          // Send to the list of all neighbours.
          sendToNeighbour(message, (Transaction) transaction);

          transaction.commit();

        }
        catch (SIException e)
        {
          // No FFDC code needed
          SibTr.exception(tc, e);

          iRequestFailed = true;
        }

        // Kick off a new timer to wait for the proxy response.
        setRequestedProxySubscriptions();

      }
      // Was the request actually sent
      else if (iRequestSent)
      {
        String meName = JsAdminUtils.getMENameByUuidForMessage(iMEUuid.toString());
        if (meName == null)
          meName = iMEUuid.toString();

        SibTr.push(iProxyHandler.getMessageProcessor().getMessagingEngine());
        SibTr.warning(tc, "NO_NEIGHBOUR_REPLY_WARNING_CWSIP0381", new Object[]{meName});
        SibTr.pop();
      }

    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "alarm");
  }
253258
private void reset() {
    size = 0;
    qualifier_index = 0;
    value_index = 0;
    base_time = Long.MIN_VALUE;
    last_timestamp = Long.MIN_VALUE;
  }
872014
public void setListeners(Listener[] listeners) {
        if (listeners != null && listeners.length > 0
                && this.listeners != null && this.listeners.length > 0) {
            Listener[] oldListeners = this.listeners;
            this.listeners = new Listener[oldListeners.length + listeners.length];
            System.arraycopy(oldListeners, 0, this.listeners, 0, oldListeners.length);
            System.arraycopy(listeners, 0, this.listeners, oldListeners.length, listeners.length);
        } else {
            this.listeners = listeners;
        }
    }
349841
function resetClock() {
  for (const key in jasmine.Clock.real) {
    if (jasmine.Clock.real.hasOwnProperty(key)) {
      window[key] = jasmine.Clock.real[key]
    }
  }
}
1282343
public synchronized void restart() {
    Logcat.Listener previousListener = logcat.getListener();
    logcat.stopReading();
    logcat.interrupt();
    logcat = (Logcat) logcat.clone();
    logcat.setListener(previousListener);
    lastNotificationTime = 0;
    tracesToNotify.clear();
    logcat.start();
  }
1322123
public final void setListener( @Nullable final WebSocketListener listener )
  {
    _listener = null == listener ? NullWebSocketListener.LISTENER : listener;
  }
494147
public void removeListener(final StatusListener listener) {
        closeSilently(listener);
        listenersLock.writeLock().lock();
        try {
            listeners.remove(listener);
            int lowest = Level.toLevel(DEFAULT_STATUS_LEVEL, Level.WARN).intLevel();
            for (final StatusListener statusListener : listeners) {
                final int level = statusListener.getStatusLevel().intLevel();
                if (lowest < level) {
                    lowest = level;
                }
            }
            listenersLevel = lowest;
        } finally {
            listenersLock.writeLock().unlock();
        }
    }
1227746
public void alarm(final Object alarmContext) {
        final String methodName = "alarm()";
        synchronized (this) {
            if (!stopping && !this.htod.invalidationBuffer.isDiskClearInProgress()) {
                this.htod.invalidationBuffer.invokeBackgroundInvalidation(HTODInvalidationBuffer.SCAN);
            } else if (stopping) {
                traceDebug(methodName, "cacheName=" + this.cacheName + " abort disk cleanup because of server is stopping.");
            } else {
                if (cleanupFrequency == 0) {
                    sleepTime = calculateSleepTime();
                }
                traceDebug(methodName, "cacheName=" + this.cacheName + " disk clear is in progress - skip disk scan and set alarm sleepTime="
                                       + sleepTime);
                Scheduler.createNonDeferrable(sleepTime, alarmContext, new Runnable() {
                    @Override
                    public void run() {
                        alarm(alarmContext);
                    }
                });
            }
        }
    }
816618
public void reset()
   {
      min.set(Long.MAX_VALUE);
      max.set(0);
      total.set(0);
      times.set(0);
   }
98774
protected final void set(M config) {
        ArrayList<WeakReference<ConfigListener<M,F>>> iterateOver;
        synchronized (this) {
            M old = instance.get();
            if (old == config || (old != null && old.equals(config))) {
                return;
            }

            instance.set(config);
            lastUpdateTimestamp.set(clock.millis());
            listeners.removeIf(ref -> ref.get() == null);
            iterateOver = new ArrayList<>(listeners);
        }
        iterateOver.forEach(ref -> {
            ConfigListener<M,F> listener = ref.get();
            if (listener != null) {
                try {
                    listener.onConfigChange(config);
                } catch (Exception ignore) {
                    // Ignored... TODO: At least log?
                }
            }
        });
    }
130724
public void doAddListener(BaseListener listener)
    {
        if (m_nextListener != null)
            m_nextListener.doAddListener(listener);
        else
            m_nextListener = listener;
    }
1165769
function(time) {
        clearTimeout(this._restartTimeout);
        if (!time) {
            return;
        }
        if (!this._isShuttingDown) {
            this._restartTimeout = setTimeout(_.bind(this._onRestartTimeout, this), time * 1000);
        }
    }