/*
Called when the receiveExclusive value has changed
358452
public final void notifyReceiveExclusiveChange(boolean newValue)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.entry(tc, "notifyReceiveExclusiveChange", new Boolean(newValue));
    boolean notifyConsumers = true;
    synchronized (consumerPoints)
    {
      _cardinalityOne = newValue;
      _cardinalityChange = true;

      if (consumerPoints.size() == 0)
      {
        notifyConsumers = false;
      }
      // since we have set cardinalityChange to true, we will not allow any more consumers till we have
      // finished processing the cardinality change
    }

    // if there were consumers, we tell the CD to close all consumers.
    if (notifyConsumers)
      super.closeAllConsumersForReceiveExclusive();
    else
    {
      // all consumers are gone so finish processing the cardinality change
      // NOTE: this causes us to flush the stream.
      // Any outstanding transactions will rollback
      try
      {
        cardinalityChangeConsumersDetached();
      }
      catch(SIResourceException e)
      {
        // Exception shouldn't occur so FFDC and rethrow as runtime exception
        FFDCFilter.processException(
          e,
          "com.ibm.ws.sib.processor.impl.RemoteConsumerDispatcher.notifyReceiveExclusiveChange",
          "1:203:1.75",
          this);

        SIErrorException e2 =
          new SIErrorException(
            nls.getFormattedMessage(
              "INTERNAL_MESSAGING_ERROR_CWSIP0002",
              new Object[] { "com.ibm.ws.sib.processor.impl.RemoteConsumerDispatcher.notifyReceiveExclusiveChange",
                             "1:211:1.75",
                             e },
              null));

        SibTr.exception(tc, e);
        SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0002",
          new Object[] {
            "com.ibm.ws.sib.processor.impl.RemoteConsumerDispatcher.notifyReceiveExclusiveChange",
            "1:219:1.75",
            e });
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "notifyReceiveExclusiveChange", e2);
        throw e2;
      }
    }
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "notifyReceiveExclusiveChange");
  }
869292
@Override
    public void changed(ChangeEvent event) {
        // forget cached IDs (Should be executed in workExecutor)
        final long lastSeqPushed = (isPull() || replicationInternal.lastSequence == null) ? -1L :
                Long.valueOf(replicationInternal.lastSequence);
        if (lastSeqPushed >= 0 && lastSeqPushed != _lastSequencePushed) {
            db.runAsync(new AsyncTask() {
                @Override
                public void run(Database database) {
                    synchronized (_lockPendingDocIDs) {
                        _lastSequencePushed = lastSeqPushed;
                        _pendingDocIDs = null;
                    }
                }
            });
        }

        for (ChangeListener changeListener : changeListeners) {
            try {
                changeListener.changed(event);
            } catch (Exception e) {
                Log.e(Log.TAG_SYNC, "Exception calling changeListener.changed", e);
            }
        }
    }
1148666
public void valueHasChanged(DCache cache, Object id, long expirationTime, int inactivity) {  // CPF-Inactivity
        //final String methodName = "valueHasChanged()";
        if (expirationTime <= 0 && inactivity <=0 ) { // CPF-Inactivity
            throw new IllegalArgumentException("expirationTime or inactivity must be positive");
        }
        if ( UNIT_TEST_INACTIVITY ) {
            System.out.println(" valueHasChanged() - entry");
            System.out.println(" expirationTime="+expirationTime);
            System.out.println(" inactivity="+inactivity);
        }
        // CPF-Inactivity
        //-----------------------------------------------------------
        // Force an expriationTime if we have an inactivity timer
        //-----------------------------------------------------------
        boolean isInactivityTimeOut = false;
        if ( inactivity > 0 ) {
            // For 7.0, use QuickApproxTime.getRef.getApproxTime()
            long adjustedExpirationTime = System.currentTimeMillis() + ( inactivity * 1000 );
            if ( adjustedExpirationTime < expirationTime ||
                 expirationTime <= 0 ) {
                expirationTime = adjustedExpirationTime;
                isInactivityTimeOut = true;
            }
        }
        ExpirationMetaData expirationMetaData = (ExpirationMetaData)cacheInstancesTable.get(cache);
        // Just make sure expirationMetaData is NOT NULL in case of an internal-error condition
        if (expirationMetaData == null) {
            return;
        }
        synchronized (expirationMetaData) {
            InvalidationTask it = (InvalidationTask) expirationMetaData.expirationTable.get(id);
            if (it == null) {
                it = (InvalidationTask) taskPool.remove();
                it.id = id;
                expirationMetaData.expirationTable.put(id, it);
            } else {
                expirationMetaData.timeLimitHeap.delete(it);
            }
            it.expirationTime = expirationTime;
            it.isInactivityTimeOut = isInactivityTimeOut;
            expirationMetaData.timeLimitHeap.insert(it);
            //ccount++;
            //traceDebug(methodName, "cacheName=" + cache.getCacheName() + " id=" + id + " expirationTableSize=" + expirationMetaData.expirationTable.size() + " timeLimitHeapSize=" + expirationMetaData.timeLimitHeap.size() + " count=" + ccount);
        }
    }
807293
public void valueChanged(ListSelectionEvent e)
    {
        if (e.getFirstIndex() == e.getLastIndex())
            if (e.getFirstIndex() > 0)  // Column 0 is the form button
                this.clickColumn(e.getFirstIndex());
        JTable control = (JTable)m_gridScreen.getControl();
        control.clearSelection(); // Column selections not allowed
    }
7489
private void updateValue(Value value) {
    while (true) {
      Value current = currentValue.get();
      if (value.isNewerThan(current)) {
        if (currentValue.compareAndSet(current, value)) {
          if (current == null || !Objects.equals(current.value(), value.value())) {
            eventListeners.forEach(listener -> listener.event(new ValueDelegateEvent<>(ValueDelegateEvent.Type.UPDATE, decode(value.value()))));
          }
          break;
        }
      } else {
        break;
      }
    }
  }
670732
public void valueChanged(ListSelectionEvent lse) {
        if (!lse.getValueIsAdjusting()) {
            removeListSelectionListener(this);

            // remember everything selected as a result of this action
            HashSet<Integer> newSelections = new HashSet<>();
            int size = getModel().getSize();
            for (int i = 0; i < size; i++) {
                if (getSelectionModel().isSelectedIndex(i)) {
                    newSelections.add(i);
                }
            }

            // turn on everything that was previously selected
            Iterator<Integer> it = selectionCache.iterator();
            while (it.hasNext()) {
                int index = it.next();
                getSelectionModel().addSelectionInterval(index, index);
            }

            // add or remove the delta
            it = newSelections.iterator();
            while (it.hasNext()) {
                Integer nextInt = it.next();
                int index = nextInt;
                if (selectionCache.contains(nextInt)) {
                    getSelectionModel().removeSelectionInterval(index, index);
                } else {
                    getSelectionModel().addSelectionInterval(index, index);
                }
            }

            // save selections for next time
            selectionCache.clear();
            for (int i = 0; i < size; i++) {
                if (getSelectionModel().isSelectedIndex(i)) {
                    selectionCache.add(i);
                }
            }

            addListSelectionListener(this);

        }
    }
739905
function updateReceiver(receiverSignature, raddec) {
  let tr = document.getElementById(receiverSignature);
  let tds = tr.getElementsByTagName('td');
  tds[2].textContent = new Date(raddec.timestamp).toLocaleTimeString();

  updateVisibility(tr, [ tds[0].textContent ]);
}
350433
public void observeApplyRequestValues(@Observes @Before @ApplyRequestValues PhaseEvent event) {
        log.debug("After Apply Request Values event");
        performObservation(event, PhaseIdType.APPLY_REQUEST_VALUES);
    }
503355
def on_checked_changed(self, value):
        
        #: Since iOS decides to call this like 100 times for each defer it
        d = self.declaration
        with self.widget.setValue.suppressed():
            d.progress = int(value)
1371490
public void propertyChange(PropertyChangeEvent evt) {
		originalValue = getValue();
		if (deliverValueChangeEvents) {
			mediatedValueHolder.setValue(originalValue);
			updateDirtyState();
		}
	}
1070557
private void fireOnDeclareExchange(ChannelEvent e) {
        List<EventListener> listeners = changes.getListenerList(AMQP);
        for (EventListener listener : listeners) {
            ChannelListener amqpListener = (ChannelListener)listener;
            amqpListener.onDeclareExchange(e);
        }
    }
646410
@AfterBatch
  public void afterDeliver()
  {
    SegmentStream nodeStream = _nodeStream;
    
    if (nodeStream != null) {
      if (_isBlobDirty) {
        _isBlobDirty = false;

        // nodeStream.flush(null);
        nodeStream.fsync(Result.ignore());
      }
      else {
        nodeStream.flush(Result.ignore());
      }
    }
    
    /*
    if (blobWriter != null) {
      try {
        blobWriter.flushSegment();
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
    */
  }
894922
@ViewChanged
	public synchronized void onViewChangeEvent(ViewChangedEvent event) {
		
		if (logger.isDebugEnabled()) {
			logger.debug("onViewChangeEvent : pre[" + event.isPre() + "] : event local address[" + event.getCache().getLocalAddress() + "]");
		}
		
		final List<Address> oldView = currentView;
		currentView = new ArrayList<Address>(event.getNewView().getMembers());
		final Address localAddress = getLocalAddress();
		
		//just a precaution, it can be null!
		if (oldView != null) {
			final Cache jbossCache = mobicentsCache.getJBossCache();
			final Configuration config = jbossCache.getConfiguration();		

			final boolean isBuddyReplicationEnabled = config.getBuddyReplicationConfig() != null && config.getBuddyReplicationConfig().isEnabled();
			// recover stuff from lost members
			Runnable runnable = new Runnable() {
				public void run() {
					for (Address oldMember : oldView) {
						if (!currentView.contains(oldMember)) {
							if (logger.isDebugEnabled()) {
								logger.debug("onViewChangeEvent : processing lost member " + oldMember);
							}
							for (FailOverListener localListener : failOverListeners) {
								ClientLocalListenerElector localListenerElector = localListener.getElector();
								if (localListenerElector != null && !isBuddyReplicationEnabled) {
									// going to use the local listener elector instead, which gives results based on data
									performTakeOver(localListener,oldMember,localAddress, true, isBuddyReplicationEnabled);
								}
								else {
									
									List<Address> electionView = getElectionView(oldMember);
									if(electionView!=null && elector.elect(electionView).equals(localAddress))
									{
										performTakeOver(localListener, oldMember, localAddress, false, isBuddyReplicationEnabled);
									}
									
									cleanAfterTakeOver(localListener, oldMember);
								}
							}
						}
					}
				}
			};
			Thread t = new Thread(runnable);
			t.start();
		}
		
	}
735261
protected void onSelectionChanged(int selStart, int selEnd) {
        if(mInputView == null)
            return;

        if(mInputView instanceof InternalEditText)
            ((InternalEditText)mInputView).superOnSelectionChanged(selStart, selEnd);
        else if(mInputView instanceof InternalAutoCompleteTextView)
            ((InternalAutoCompleteTextView)mInputView).superOnSelectionChanged(selStart, selEnd);
        else
            ((InternalMultiAutoCompleteTextView)mInputView).superOnSelectionChanged(selStart, selEnd);

        if(mOnSelectionChangedListener != null)
            mOnSelectionChangedListener.onSelectionChanged(this, selStart, selEnd);
    }
682852
void onChange(String value) {

        m_changed = true;
        m_save.setEnabled(true);
        m_saveAndExit.setEnabled(true);
    }
149656
def OnContentChange(self, event):
        """"""

        self.ignore_changes = True
        self.SetValue(u"" if event.text is None else event.text)

        self.ignore_changes = False

        event.Skip()
304712
public void onValueChange(ValueChangeEvent<String> event) {

        cancelQuickFilterTimer();
        if (event.getSource() == m_sortSelectBox) {
            // depending on the sort value the tab may or may not have the quick filter ability
            if (hasQuickFilter()) {
                if (m_quickSearch == null) {
                    createQuickBox();
                }
            } else {
                removeQuickBox();
            }
            getTabHandler().onSort(event.getValue(), hasQuickFilter() ? m_quickSearch.getFormValueAsString() : null);
        }
        if ((event.getSource() == m_quickSearch)) {
            if (hasQuickFilter()) {

                if ((CmsStringUtil.isEmptyOrWhitespaceOnly(event.getValue()) || (event.getValue().length() >= 3))) {
                    // only act if filter length is at least 3 characters or empty
                    if ((m_lastQuickSearchValue == null) || !m_lastQuickSearchValue.equals(event.getValue())) {
                        scheduleQuickFilterTimer();
                    }
                    m_lastQuickSearchValue = event.getValue();
                }
            } else {
                checkQuickSearchStatus();
            }
        }
    }