This notification is sent by the base instance (if any) when it is modified
so that we can uninitialize, so that the next time we are used we can honor
the updates to the base instance.
977102
private void baseInstanceModified() {
        ContextServiceImpl[] listeners;

        lock.writeLock().lock();
        try {
            listeners = modificationListeners.toArray(new ContextServiceImpl[modificationListeners.size()]);
            modificationListeners.clear();
            threadContextConfigurations = null;
        } finally {
            lock.writeLock().unlock();
        }

        for (ContextServiceImpl listener : listeners)
            listener.baseInstanceModified();
    }
409298
@Override
    protected void enqueueNotification(final Notification not) {
        final Runnable r = new Runnable() {
            @Override
            public void run() {
                not.lastRun = System.currentTimeMillis();

                final SubscriptionSummary summary = postNotification(not.subscriber, not.mimeType, not.payload);

                if (!summary.isLastPublishSuccessful()) {
                    not.retryCount++;

                    if (not.retryCount <= 5) {
                        retry(not);
                    }
                }

                not.callback.onSummaryInfo(summary);
            }
        };

        exeuctor.execute(r);
    }
863237
@Override
    public void libraryNotification() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            Tr.debug(this, tc, "libraryNotification");
        modified(null, true);
    }
102523
private void onChanged() {
    // If builder is null, this is the case where onChanged is being called
    // from setMessage or clear.
    if (builder != null) {
      message = null;
    }
    if (isClean && parent != null) {
      parent.markDirty();

      // Don't keep dispatching invalidations until build is called again.
      isClean = false;
    }
  }
88603
private void ensureInitialized() {
    if (!mInitialized) {
     lock.lock();
      try {
        if (!mInitialized) {
          mInternalPath = Environment.getDataDirectory();
          mExternalPath = Environment.getExternalStorageDirectory();
          updateStats();
          mInitialized = true;
        }
      } finally {
        lock.unlock();
      }
    }
  }
873983
public void notifyAddOnUninstalled(final AddOn addOn) {
		if (EventQueue.isDispatchThread()) {
			installedAddOnsModel.removeAddOn(addOn);
			if (latestInfo != null) {
				AddOn availableAddOn = latestInfo.getAddOn(addOn.getId());
				if (availableAddOn != null) {
					uninstalledAddOnsModel.addAddOn(latestInfo.getAddOn(addOn.getId()));
				}
			}
		} else {
			EventQueue.invokeLater(new Runnable() {

				@Override
				public void run() {
					notifyAddOnUninstalled(addOn);
				}
			});
		}
	}
701473
private void notifyShutdown()
    {
        if (eventHandler instanceof LifecycleAware)
        {
            try
            {
                ((LifecycleAware) eventHandler).onShutdown();
            }
            catch (final Throwable ex)
            {
                exceptionHandler.handleOnShutdownException(ex);
            }
        }
    }
826554
private void startForegroundIfConfigured() {
        BeaconManager beaconManager = BeaconManager.getInstanceForApplication(
                this.getApplicationContext());
        Notification notification = beaconManager
                .getForegroundServiceNotification();
        int notificationId = beaconManager
                .getForegroundServiceNotificationId();
        if (notification != null &&
                Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
            this.startForeground(notificationId, notification);
        }
    }
1228099
@Override
    protected void enqueueNotification(final Notification not) {
        not.lastRun = System.currentTimeMillis();
        final SubscriptionSummary summary = postNotification(not.subscriber, not.mimeType, not.payload);
        not.callback.onSummaryInfo(summary);
    }
704366
def notify(self, force_notify=None, use_email=None, use_sms=None, **kwargs):
        
        notified = False
        instance = kwargs.get("instance")
        if instance._meta.label_lower == self.model:
            notified = super().notify(
                force_notify=force_notify,
                use_email=use_email,
                use_sms=use_sms,
                **kwargs,
            )
        return notified
1074128
def flush(self):
        
        self._flush_notification.set()
        if self.sender:
            self.sender.start()
875039
public void initalised() throws SIResourceException
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "initalised");
    
    try
    {    
      _lockManager.lockExclusive();

      // Flag that we are in a started state. 
      _started = true;
      
      // If the Neighbour Listener hasn't been created, create it
      if (_proxyListener == null)
        createProxyListener();
     
      // Indicate that reconciling is complete
      _reconciling = false;
      
      _neighbours.resetBusSubscriptionList();
    }      
    finally
    {
      _lockManager.unlockExclusive();
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "initalised"); 
  }
987134
@Override
    public void afterInitialized(BaseComponent comp) {
        super.afterInitialized(comp);
        createLabel("default");
        getEventManager().subscribe(EventUtil.STATUS_EVENT, this);
    }
1034705
function(newProps) {
        if (this.getInitialState) {
            if (this.getInitialProps) {
                newProps = this.getInitialProps(newProps) || {};
            }
            var newState = this.getInitialState(newProps);
            this.replaceState(newState);
            return;
        }

        if (!this.__newProps) {
            updateManager.queueWidgetUpdate(this);
        }

        this.__newProps = newProps;
    }
700091
protected void updateNotify (long sequence) {

		IServiceReference[] refs = null;
		try {
			if(aggregator != null && aggregator.getPlatformServices() != null){
				refs = aggregator.getPlatformServices().getServiceReferences(IOptionsListener.class.getName(),"(name=" + registrationName + ")");	//$NON-NLS-1$ //$NON-NLS-2$
				if (refs != null) {
					for (IServiceReference ref : refs) {
						IOptionsListener listener = (IOptionsListener)aggregator.getPlatformServices().getService(ref);
						if (listener != null) {
							try {
								listener.optionsUpdated(this, sequence);
							} catch (Throwable ignore) {
							} finally {
								aggregator.getPlatformServices().ungetService(ref);
							}
						}
					}
				}
			}
		} catch (PlatformServicesException e) {
			if (log.isLoggable(Level.SEVERE)) {
				log.log(Level.SEVERE, e.getMessage(), e);
			}
		}
	}
661110
public void onNotificationsResumed() {
        isNotificationsPaused = false;

        // If there are notifications during pause
        if (notificationsDuringPause.size() > 0) {

            if (isAppVisible) {
                if (visiblePeer != null && notificationsDuringPause.containsKey(visiblePeer)) {

                    // If there was message from visible chat
                    if (isMobilePlatform) {

                        // Playing sound effects for mobile platforms
                        playEffectIfEnabled();
                    } else {

                        // Don't play sounds in chat on non-mobile platforms
                    }
                } else {

                    // If there are no messages from visible peer
                    if (isMobilePlatform) {

                        // Don't play sounds not from current chat on mobile platforms
                    } else {

                        // Find any suitable peer and if found play sound effect
                        for (Peer p : notificationsDuringPause.keySet()) {

                            if (isNotificationsEnabled(p, notificationsDuringPause.get(p))) {
                                playEffectIfEnabled();
                                break; // Can't do return because we need to make more work later
                            }
                        }
                    }
                }
            } else {

                // Just show out-app notification
                for (Peer p : notificationsDuringPause.keySet()) {

                    if (isNotificationsEnabled(p, notificationsDuringPause.get(p))) {
                        showNotification();
                        break;
                    }
                }
            }

            // Clearing of notifications
            notificationsDuringPause.clear();
        }
    }
942370
void notifyAndClearListeners() {
    if (!canBeCancelled()) {
      return;
    }
    ArrayList<ExecutableListener> tmpListeners;
    synchronized (this) {
      if (listeners == null) {
        return;
      }
      tmpListeners = listeners;
      listeners = null;
    }
    // Deliver events to non-child context listeners before we notify child contexts. We do this
    // to cancel higher level units of work before child units. This allows for a better error
    // handling paradigm where the higher level unit of work knows it is cancelled and so can
    // ignore errors that bubble up as a result of cancellation of lower level units.
    for (int i = 0; i < tmpListeners.size(); i++) {
      if (!(tmpListeners.get(i).listener instanceof ParentListener)) {
        tmpListeners.get(i).deliver();
      }
    }
    for (int i = 0; i < tmpListeners.size(); i++) {
      if (tmpListeners.get(i).listener instanceof ParentListener) {
        tmpListeners.get(i).deliver();
      }
    }
    if (cancellableAncestor != null) {
      cancellableAncestor.removeListener(parentListener);
    }
  }