Send a track metadata update announcement to all registered listeners.
195535
private void deliverTrackMetadataUpdate(int player, TrackMetadata metadata) {
        if (!getTrackMetadataListeners().isEmpty()) {
            final TrackMetadataUpdate update = new TrackMetadataUpdate(player, metadata);
            for (final TrackMetadataListener listener : getTrackMetadataListeners()) {
                try {
                    listener.metadataChanged(update);

                } catch (Throwable t) {
                    logger.warn("Problem delivering track metadata update to listener", t);
                }
            }
        }
    }
1239156
protected void notifyChangeListeners() {
        ChangeEvent e = new ChangeEvent(this);
        for (ChangeListener l : changeListeners) {
            l.stateChanged(e);
        }
    }
1223255
def _update_notification(self, message=None):
        """"""
        if message is None:
            message = ''
        message_label = self._parts['notification label']
        message_label.config(text=message)
        self._base.update()
69709
function notify() {
    var args = arguments
    handlers.forEach(function(f){ f.apply(null, args) }) }
387777
private void updateBeatGrid(TrackMetadataUpdate update, BeatGrid beatGrid) {
        hotCache.put(DeckReference.getDeckReference(update.player, 0), beatGrid);  // Main deck
        if (update.metadata.getCueList() != null) {  // Update the cache with any hot cues in this track as well
            for (CueList.Entry entry : update.metadata.getCueList().entries) {
                if (entry.hotCueNumber != 0) {
                    hotCache.put(DeckReference.getDeckReference(update.player, entry.hotCueNumber), beatGrid);
                }
            }
        }
        deliverBeatGridUpdate(update.player, beatGrid);
    }
844759
private void updateMetadata(CdjStatus update, TrackMetadata data) {
        hotCache.put(DeckReference.getDeckReference(update.getDeviceNumber(), 0), data);  // Main deck
        if (data.getCueList() != null) {  // Update the cache with any hot cues in this track as well
            for (CueList.Entry entry : data.getCueList().entries) {
                if (entry.hotCueNumber != 0) {
                    hotCache.put(DeckReference.getDeckReference(update.getDeviceNumber(), entry.hotCueNumber), data);
                }
            }
        }
        deliverTrackMetadataUpdate(update.getDeviceNumber(), data);
    }
730407
private void handleUpdate(final int player) {
        final TrackMetadata metadata = MetadataFinder.getInstance().getLatestMetadataFor(player);
        final WaveformDetail waveformDetail = WaveformFinder.getInstance().getLatestDetailFor(player);
        final BeatGrid beatGrid = BeatGridFinder.getInstance().getLatestBeatGridFor(player);
        if (metadata != null && waveformDetail != null && beatGrid != null) {
            final String signature = computeTrackSignature(metadata.getTitle(), metadata.getArtist(),
                    metadata.getDuration(), waveformDetail, beatGrid);
            if (signature != null) {
                signatures.put(player, signature);
                deliverSignatureUpdate(player, signature);
            }
        }
    }
241399
function addListener(event, callback, meta) {
  event.listeners.push(callback);
  event.meta.set(callback, meta);
}
906219
def run(self, *args, **kwargs):
        
        self.log.debug('Starting EBSAuditor')
        data = self.update_data()

        notices = defaultdict(list)
        for account, issues in data.items():
            for issue in issues:
                for recipient in account.contacts:
                    notices[NotificationContact(type=recipient['type'], value=recipient['value'])].append(issue)

        self.notify(notices)
749140
private void registerListeners() {
    protocol.registerExecuteHandler(this::execute);
    protocol.registerBackupHandler(this::backup);
    protocol.registerRestoreHandler(this::restore);
    protocol.registerCloseHandler(this::close);
    protocol.registerMetadataHandler(this::metadata);
  }
435703
void notifyListenersNetworkReachable() {
        // NOTE: synchronized(listener) causes deadlock with listeners and Replicator.lock.
        final Set<NetworkReachabilityListener> copy = new HashSet<>(listeners);
        for (NetworkReachabilityListener listener : copy) {
            if (listener != null) { listener.networkReachable(); }
        }
    }
31625
function() {
        elemData.sound = soundEditor.find('.kelmu-sound-url').val();
        window.kelmu.data[id].actions.update();
        updateView(true, true);
        notifyModifications();
      }
1269582
public function notify() {
        foreach($this->watchers as $watcher) {
          if ($this->stopNotify === true) {
              break;
          }

          $watcher->update($this);
        }
    }
376659
private void sendHubHeartbeats()
  {
    RackHeartbeat rack = _rack;
    
    UpdateRackHeartbeat updateRack = rack.getUpdate();
    UpdatePodSystem updatePod = getUpdatePodSystem();
    
    long now = CurrentTime.currentTime();
    
    if (! isJoinComplete()) {
      updatePod = null;
    }

    // send hub update to all servers in the rack
    for (ServerHeartbeat rackServer : _rack.getServers()) {
      if (rackServer == null || rackServer == _serverSelf) {
        continue;
      }

      ServerTarget target = createTargetServer(rackServer);
      
      target.hubHeartbeat(getServerSelf().getUpdate(),
                             updateRack,
                             updatePod,
                             now);
    }
  }
41661
private void deliverMediaDetailsUpdate(final MediaDetails details) {
        for (MediaDetailsListener listener : getMediaDetailsListeners()) {
            try {
                listener.detailsAvailable(details);
            } catch (Throwable t) {
                logger.warn("Problem delivering media details response to listener", t);
            }
        }
    }
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);
                            }
                        }
                    });
                }
            }
        }
    }
783001
private void fireUpdate() {
		ActionEvent event = new ActionEvent(this,0,"");
		for (int i=0;i<listeners.size();i++) {
			((ActionListener) listeners.get(i)).actionPerformed(event);
		}
	}