Notifies registered listeners that the default SRE has changed.

@param previous the previous SRE
@param current the new current default SRE
358987
private static void fireDefaultSREChanged(ISREInstall previous, ISREInstall current) {
		for (final Object listener : SRE_LISTENERS.getListeners()) {
			((ISREInstallChangedListener) listener).defaultSREInstallChanged(previous, current);
		}
	}
1119046
public void addListener(PreInvalidationListener listener) {
    	if (preInvalidationListenerCount == 1 && tc.isDebugEnabled())
    		Tr.debug(tc, "Over-writing current PreInvalidationListener with new one");
        currentPreInvalidationListener = listener;
        preInvalidationListenerCount = 1;
    }
130724
public void doAddListener(BaseListener listener)
    {
        if (m_nextListener != null)
            m_nextListener.doAddListener(listener);
        else
            m_nextListener = listener;
    }
469670
@Override
    public void configurationChanged() {

        HashSet<Param> changedParams = new HashSet();

        // read dynamic parameters
        for (Param param : parameters) {

            if (! param.isStatic()) {

                // preserve current value
                Object oldValue = param.getValue();

                // read new value
                readAndValidateParameter(param);

                // get if parameter value had changed
                if (! ConfigUtil.equalValues(oldValue, param.getValue())) {
                    changedParams.add(param);
                }
            }

        }

        // invoke listeners for all changed parameters
        if (! changedParams.isEmpty()) {

            for (ConfigChangeListener listener : configChangeListeners) {
                listener.configurationChanged(changedParams);
            }

        }

    }
98998
private void resolveRemainingToCurrent()
    {
        for (int i = 0; i < this.size; i++) {
            if (sourceRevisions.get(i) == null) {
                sourceRevisions.set(i, currentRevision);
            }
        }
    }
52339
private void notifyChangeListeners(final Replication.ChangeEvent changeEvent) {
        if (changeListenerNotifyStyle == ChangeListenerNotifyStyle.SYNC) {
            for (ChangeListener changeListener : changeListeners) {
                try {
                    changeListener.changed(changeEvent);
                } catch (Exception e) {
                    Log.e(Log.TAG_SYNC, "Unknown Error in changeListener.changed(changeEvent)", e);
                }
            }
        } else {
            // ASYNC
            synchronized (executor) {
                if (!executor.isShutdown()) {
                    executor.submit(new Runnable() {
                        @Override
                        public void run() {
                            try {
                                for (ChangeListener changeListener : changeListeners)
                                    changeListener.changed(changeEvent);
                            } catch (Exception e) {
                                Log.e(Log.TAG_SYNC, "Exception notifying replication listener: %s", e, this);
                                throw new RuntimeException(e);
                            }
                        }
                    });
                }
            }
        }
    }
1136963
public static void setCurrent(@Nullable String reason)
    {
        if (reason != null)
        {
            if (currentReason == null)
                currentReason = new ThreadLocal<>();
            currentReason.set(reason);
        }
        else if (currentReason != null)
        {
            currentReason.remove();
        }
    }
293296
protected void notifyModified() {
        log.debug("notifyModified - modified: {} update counter: {}", modified.get(), updateCounter.get());
        if (updateCounter.get() == 0) {
            if (modified.get()) {
                // client sent at least one update -> increase version of SO
                updateVersion();
                lastModified = System.currentTimeMillis();
                if (storage == null || !storage.save(this)) {
                    log.warn("Could not store shared object");
                }
            }
            sendUpdates();
            modified.compareAndSet(true, false);
        }
    }
18052
@Override
    public void notifyRCDReceiveExclusiveChange(boolean isReceiveExclusive)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "notifyRCDReceiveExclusiveChange", new Object[] { Boolean.valueOf(isReceiveExclusive) });

        // Only do this for ptp as it does not seem to make sense for p/s
        if (!isPubSub())
        {
            //if this is a RMQ destination then there is no RCD to
            //worry about, so we only need be concerned with the case of a JS
            //q point.
            if (_ptoPRealization != null)
            {
                _ptoPRealization.getRemoteSupport().
                                notifyRCDReceiveExclusiveChange(isReceiveExclusive);
            }

        }
        else
        {
            // sanity check
            // log error
            SIErrorException e =
                            new SIErrorException(
                                            nls.getFormattedMessage(
                                                                    "INTERNAL_MESSAGING_ERROR_CWSIP0001",
                                                                    new Object[] {
                                                                                  "com.ibm.ws.sib.processor.impl.BaseDestinationHandler",
                                                                                  "1:1458:1.700.3.45" },
                                                                    null));
            FFDCFilter.processException(
                                        e,
                                        "com.ibm.ws.sib.processor.impl.BaseDestinationHandler.notifyRCDReceiveExclusiveChange",
                                        "1:1463:1.700.3.45",
                                        this);
            SibTr.exception(tc, e);

            SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0001",
                        new Object[] {
                                      "com.ibm.ws.sib.processor.impl.BaseDestinationHandler",
                                      "1:1470:1.700.3.45" });

            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                SibTr.exit(tc, "notifyRCDReceiveExclusiveChange", e);
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "notifyRCDReceiveExclusiveChange");
    }
796512
private boolean notifyOnRestoreDefaultValuesRequested() {
        boolean result = true;

        for (RestoreDefaultsListener listener : restoreDefaultsListeners) {
            result &= listener.onRestoreDefaultValuesRequested(this);
        }

        return result;
    }
262545
public function onChange(array $previousValues)
    {
       if (isset($this->defaultCallback)) {
           $callback = $this->defaultCallback;
           $this->default = $callback($previousValues);
       }
    }
46812
private void setCurrentForegroundActivity(Activity activity) {
		if (activity != null) {
			currentForegroundApptentiveActivity = new WeakReference<>(activity);
		} else {
			ApptentiveToastNotificationManager manager = ApptentiveToastNotificationManager.getInstance(null, false);
			if (manager != null) {
				manager.cleanUp();
			}
			currentForegroundApptentiveActivity = null;
		}
	}
220910
public void changeState(Class<? extends State> next)
    {
        Check.notNull(next);

        final State from = current;
        if (current != null)
        {
            last = current.getClass();
            current.exit();
        }
        if (!states.containsKey(next))
        {
            final State state = create(next);
            states.put(next, state);
        }
        current = states.get(next);
        current.enter();

        listeners.forEach(l -> l.notifyStateTransition(from != null ? from.getClass() : null, next));
    }
1248082
public void setCurrentValue(final float currentValue) {
        this.currentValue = currentValue;
        initialValue = currentValue;
        targetValue = currentValue;
        transitionInProgress = false;
    }
1334518
@SuppressWarnings("unchecked")
	protected boolean triggerRefreshIfNeeded(final Element e){
		if (refreshAheadNeeded(e.getLastAccessTime(), e.getCreationTime(), e.getExpirationTime())){
			// to apply a simple and not strict concurrency locking
			final long signature = Thread.currentThread().getId() * 1000000L + (System.currentTimeMillis() % 1000000L);
			if (e.getVersion() == 1){	// 1 is the default value of version field
				e.setVersion(signature);
				if (e.getVersion() == signature){	// double check
					threadPool.execute(new Runnable(){
						public void run(){
							if (e.getVersion() == signature){	// triple check
								try{
									V newValue = getDirectly((K)e.getObjectKey());
									if (newValue == null){
										cache.remove(e.getObjectKey());
									}else{
										cache.put(new Element((K)e.getObjectKey(), newValue));
									}
								}catch(Exception ex){
									logger.warn("Failed to update the value associated with specified key '{}' in cache '{}'", e.getObjectKey(), cache.getName(), ex);
								}
							}
						}
					});
					return true;
				}
			}
		}
		return false;
	}
1196691
protected void onOrientationChanged(int lastOrientation, int currentOrientation) {
        if (controller != null) {
            controller.onOrientationChanged(
                    parseOrientation(lastOrientation),
                    parseOrientation(currentOrientation));
        }
    }
1022922
public boolean hasChanged() {
        Object currentValue = getValue();
        return value == null || currentValue == null ? value != currentValue : !value.equals(currentValue);
    }