Sets whether subscribers should be notified when the configuration changes.

@param notify true if subscribers should be notified, false otherwise
176327
public void setNotifyConfig(boolean notify) {
        addField(ConfigureNodeFields.notify_config, FormField.Type.bool);
        setAnswer(ConfigureNodeFields.notify_config.getFieldName(), notify);
    }
1195860
@Override
    protected void notifyDispatcher() {
        if (threads != null) {
            synchronized (threads) {
                threads.notifyAll();
                for (Thread thread : threads) {
                    ((DispatcherThread) thread).setChanged(true);
                }
            }
        }
    }
21310
@SuppressLint("SetTextI18n")
	public void setNotifications(Integer notifications) {

		if ((notifications != null) && (notifications > 0)) {
			setVisibility(VISIBLE);
			if (notifications > maximum) {
				this.setText(maximum + "+");
			} else {
				this.setText(notifications.toString());
			}
		} else {
			setVisibility(GONE);
		}
	}
984126
public void setChanged() {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "setChanged");
    changed = true;
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "setChanged");
  }
1210094
public void notifyAOHReceiveExclusiveChange(boolean newValue)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(
        tc,
        "notifyAOHReceiveExclusiveChange",
        new Object[] { Boolean.valueOf(newValue) });
    
    // only need to do this for queues, not for durable subscriptions
    if (_anycastOutputHandler != null)
      _anycastOutputHandler.notifyReceiveExclusiveChange(newValue); 
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "notifyAOHReceiveExclusiveChange");
         
  }
1373843
public void setNotifyRetract(boolean notify)  {
        addField(ConfigureNodeFields.notify_retract, FormField.Type.bool);
        setAnswer(ConfigureNodeFields.notify_retract.getFieldName(), notify);
    }
911221
@InterfaceAudience.Private
    protected void revisionAdded(DocumentChange change, boolean notify) {
        if (change.getRevisionId() != null) {
            String revID = change.getWinningRevisionID();
            if (revID == null)
                return;  // current revision didn't change

            if (currentRevision != null && !revID.equals(currentRevision.getId())) {
                RevisionInternal rev = change.getWinningRevisionIfKnown();
                if (rev == null)
                    forgetCurrentRevision();
                else if (rev.isDeleted())
                    currentRevision = null;
                else
                    currentRevision = new SavedRevision(this, rev);
            }
        } else {
            // Document was purged!
            currentRevision = null;
        }

        if (notify) {
            for (ChangeListener listener : changeListeners)
                listener.changed(new ChangeEvent(this, change));
        }
    }

    @InterfaceAudience.Private
    protected void forgetCurrentRevision() {
        currentRevision = null;
    }
}
391818
public void addNotfication(Notification notification) {
        Object source = notification.getSource();
        NotificationRecord nr;
        if (source instanceof ObjectName) {
            nr = new NotificationRecord(notification, (ObjectName) source);
        } else {
            nr = new NotificationRecord(notification, (source != null) ? source.toString() : null);
        }
        addNotficationRecord(nr);
    }
1192105
void notifyObservers(ApptentiveNotification notification) {
		boolean hasLostReferences = false;

		// create a temporary list of observers to avoid concurrent modification errors
		List<ApptentiveNotificationObserver> temp = new ArrayList<>(observers.size());
		for (int i = 0; i < observers.size(); ++i) {
			ApptentiveNotificationObserver observer = observers.get(i);
			ObserverWeakReference observerRef = ObjectUtils.as(observer, ObserverWeakReference.class);
			if (observerRef == null || !observerRef.isReferenceLost()) {
				temp.add(observer);
			} else {
				hasLostReferences = true;
			}
		}

		// notify observers
		for (int i = 0; i < temp.size(); ++i) {
			try {
				temp.get(i).onReceiveNotification(notification);
			} catch (Exception e) {
				ApptentiveLog.e(e, "Exception while posting notification: %s", notification);
				logException(e); // TODO: add more context info
			}
		}

		// clean lost references
		if (hasLostReferences) {
			for (int i = observers.size() - 1; i >= 0; --i) {
				final ObserverWeakReference observerRef = ObjectUtils.as(observers.get(i), ObserverWeakReference.class);
				if (observerRef != null && observerRef.isReferenceLost()) {
					observers.remove(i);
				}
			}
		}
	}
1138565
def _notify_change(self):
        
        d = self.declaration
        self._notify_count -= 1
        if self._notify_count == 0:
            #: Tell the UI we made changes
            self.adapter.notifyDataSetChanged(now=True)
            self.get_context().timed_call(
                500, self._queue_pending_calls)
472624
def prepare_notification(self, *, subscribers=None, instance=None,
                             loop=None, notify_external=True):
        """"""
        # merge callbacks added to the class level with those added to the
        # instance, giving the formers precedence while preserving overall
        # order
        self_subscribers = self.subscribers.copy()
        # add in callbacks declared in the main class body and marked with
        # @handler
        if (instance is not None and self.name and
            isinstance(instance.__class__, SignalAndHandlerInitMeta)):
            class_handlers = type(instance)._get_class_handlers(
                self.name, instance)
            for ch in class_handlers:
                # eventual methods are ephemeral and normally the following
                # condition would always be True for methods but the dict used
                # has logic to take that into account
                if ch not in self_subscribers:
                    self_subscribers.append(ch)
        # add in the other instance level callbacks added at runtime
        if subscribers is not None:
            for el in subscribers:
                # eventual methods are ephemeral and normally the following
                # condition would always be True for methods but the dict used
                # has logic to take that into account
                if el not in self_subscribers:
                    self_subscribers.append(el)
        loop = loop or self.loop
        # maybe do a round of external publishing
        if notify_external and self.external_signaller is not None:
            self_subscribers.append(partial(self.ext_publish, instance, loop))
        if self._fnotify is None:
            fnotify = None
        else:
            if instance is None:
                fnotify = self._fnotify
            else:
                fnotify = types.MethodType(self._fnotify, instance)
        validator = self._fvalidation
        if validator is not None and instance is not None:
            validator = types.MethodType(validator, instance)
        return Executor(self_subscribers, owner=self,
                        concurrent=SignalOptions.EXEC_CONCURRENT in self.flags,
                        loop=loop, exec_wrapper=fnotify,
                        fvalidation=validator)
820380
public void onConfigurationChanged() {
        final Collection<PropertyWidget<?>> widgets = getWidgets();

        if (logger.isDebugEnabled()) {
            final StringBuilder sb = new StringBuilder();
            sb.append("id=");
            sb.append(System.identityHashCode(this));
            sb.append(" - onConfigurationChanged() - notifying widgets:");
            sb.append(widgets.size());
            for (final PropertyWidget<?> widget : widgets) {
                final String propertyName = widget.getPropertyDescriptor().getName();
                final String propertyWidgetClassName = widget.getClass().getSimpleName();
                sb.append("\n - ");
                sb.append(propertyName);
                sb.append(": ");
                sb.append(propertyWidgetClassName);
            }

            logger.debug(sb.toString());
        }

        for (final PropertyWidget<?> widget : widgets) {
            @SuppressWarnings("unchecked") final PropertyWidget<Object> objectWidget = (PropertyWidget<Object>) widget;
            final ConfiguredPropertyDescriptor propertyDescriptor = objectWidget.getPropertyDescriptor();
            final Object value = _componentBuilder.getConfiguredProperty(propertyDescriptor);
            objectWidget.onValueTouched(value);
        }
    }
1080965
public function notify()
    {
        if (0 < count($this->observers)) {
            foreach ($this->observers as $observer) {
                /** @var \Liip\Drupal\Modules\EventManager\EventObserverInterface $observer */
                $observer->update($this);
            }
        }
    }
185033
@Override
	public void init(final Configuration c)
	{
		// check if we have a current model which emits change notifications
		if (model instanceof ChangeNotifier) {
			final ChangeNotifier notifier = (ChangeNotifier) model;
			notifier.removeChangeListener(cl);
		}
		final DatapointModel<?> m = c.getDatapointModel();
		if (m instanceof ChangeNotifier) {
			model = m;
			final ChangeNotifier notifier = (ChangeNotifier) m;
			notifier.addChangeListener(cl);
		}
		if (m != null)
			createReferences(m);
	}
405069
public static void notifyChange(Context context, Uri uri, ContentObserver observer) {
        ContentResolver resolver = context.getContentResolver();
        resolver.notifyChange(uri, observer);
    }
79394
public void setCommerceNotificationTemplateService(
		com.liferay.commerce.notification.service.CommerceNotificationTemplateService commerceNotificationTemplateService) {
		this.commerceNotificationTemplateService = commerceNotificationTemplateService;
	}
636421
@Override
    public void notifyLayerChanged(FeatureProvider provider,
                                   Integer layerRefreshOld,
                                   Integer layerRefreshNew,
                                   Integer layerDisplayOld,
                                   Integer layerDisplayNew)
    {
        if (provider.hasFeature(Refreshable.class))
        {
            final Refreshable refreshable = provider.getFeature(Refreshable.class);
            getLayer(layerRefreshOld).remove(refreshable);
            getLayer(layerRefreshNew).add(refreshable);
            indexs.add(layerRefreshNew);
        }
    }