sets the unlock count of the value tick's msg.
@param tick The tick in the stream
777111
public final void incrementUnlockCount(long tick)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "incrementUnlockCount", Long.valueOf(tick));

    _targetStream.setCursor(tick);
    TickRange tickRange = _targetStream.getNext();
    if (tickRange.type == TickRange.Value)
    {
      AIValueTick valueTick = (AIValueTick) tickRange.value;
      if (valueTick != null)
        valueTick.incRMEUnlockCount();
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "incrementUnlockCount", tickRange);
  }
734793
public void set(T value) {
        try {
            lock.writeLock().lock();

            this.value = value;
        } finally {
            lock.writeLock().unlock();
        }
    }
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;
        }
    }
578585
public void tick (long tickStamp)
    {
        if (_nextTime == -1) {
            // First time through
            _nextTime = tickStamp + _initDelay;
        } else if (tickStamp >= _nextTime) {

            // If we're repeating, set the next time to run, otherwise, reset
            if (_repeatDelay != 0L) {
                _nextTime += _repeatDelay;
            } else {
                _nextTime = -1;
                cancel();
            }
            expired();
        }
    }
763023
function(){
      if (this.locked)
      {
        this.locked--;

        if (!this.locked)
        {
          var lockedValue = this.lockedValue_;

          this.lockedValue_ = null;

          if (this.value !== lockedValue)
            this.emit_change(lockedValue);
        }
      }
    }
1228589
public final void setGuaranteedValueStartTick(long value) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "setGuaranteedValueStartTick", Long.valueOf(value));
        getHdr2().setLongField(JsHdr2Access.GUARANTEEDVALUE_SET_STARTTICK, value);
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "setGuaranteedValueStartTick");
    }
899024
public void setTickLabelDecimals(final int DECIMALS) {
        if (null == tickLabelDecimals) {
            _tickLabelDecimals = clamp(0, MAX_NO_OF_DECIMALS, DECIMALS);
            fireTileEvent(REDRAW_EVENT);
        } else {
            tickLabelDecimals.set(DECIMALS);
        }
    }
870062
public void setTimeLimit(int timeLimit) {
	  if (lock == SET) {
		 throw new IllegalStateException("EntryInfo is locked");
	  }
	  expirationTimeFlag = SET;
	  this.timeLimit = timeLimit;
	  if (timeLimit > 0) {
         long ttlmsec = ((long)timeLimit) * 1000;  
		 expirationTime = ttlmsec + System.currentTimeMillis();
	  }
   }
257694
public synchronized void release(int count) {
        used -= count;
        if (used < 0)
            used = 0; // no negative number of ticket!
        if (logger.isDebugEnabled())
            logger.debug("Released " + count + " tickets! (Now " + this.toString() + ")");
        notifyAll();
    }
273108
public void setErrorMessage(String msg) {
        if (msg != null && msg.trim().length() > 0) {
            errorMessage = msg;
        }
    }
1238255
private void setFixedValue(final String value) {
		boolean toBeLogged = false;
		if (log.isDebugEnabled() && (value != null && !value.equals(fixedValue) || fixedValue != null && !fixedValue.equals(value))) {
			toBeLogged = true;
		}
		fixedValue = value;
		currentValue = null;
		if (toBeLogged) {
			log.debug("setFixedValue: " + this);
		}

	}
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;
  }
779179
protected final void tickMedia (AbstractMedia media, long tickStamp)
    {
        if (media._firstTick == 0L) {
            media.willStart(tickStamp);
        }
        media.tick(tickStamp);
    }
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");

    }
256409
public final void setHopCount(int count)
	{
		if (count < 0 || count > 7)
			throw new KNXIllegalArgumentException("hop count out of range [0..7]");
		hopCount = (byte) count;
		logger.info("hop count set to " + count);
	}
362731
public void setAutoLock(String value) {

        m_autoLockResources = Boolean.valueOf(value).booleanValue();
        if (CmsLog.INIT.isInfoEnabled()) {
            CmsLog.INIT.info(
                Messages.get().getBundle().key(
                    m_autoLockResources ? Messages.INIT_AUTO_LOCK_ENABLED_0 : Messages.INIT_AUTO_LOCK_DISABLED_0));
        }
    }
1079827
public void setLockCount(int valueNumber, int lockCount) {
        int index = findIndex(valueNumber);
        if (index < 0) {
            addEntry(index, valueNumber, lockCount);
        } else {
            array[index + 1] = lockCount;
        }
    }