This function gets called when an indication is received.
194597
def _process_indication(indication, host):
    ''''''

    global RECEIVED_INDICATION_DICT
    COUNTER_LOCK.acquire()
    if host in RECEIVED_INDICATION_DICT:
        RECEIVED_INDICATION_DICT[host] += 1
    else:
        RECEIVED_INDICATION_DICT[host] = 1
    COUNTER_LOCK.release()

    listener.logger.info("Consumed CIM indication #%s: host=%s\n%s",
                         RECEIVED_INDICATION_DICT, host, indication.tomof())
634189
def _event_received(self, ref, data):
        
        match = self._resolve_match_data(ref, data)
        if match:
            if self.flag_to_set:
                self.flag_to_set.set()
            if self.callback:
                self.callback(EventMatch(ref, data, match))
            if self.__forget:
                self.forget()
1084509
def __notify(self):
        
        if self.__callback is not None:
            try:
                self.__callback(
                    self._done_event.data,
                    self._done_event.exception,
                    self.__extra,
                )
            except Exception as ex:
                self._logger.exception("Error calling back method: %s", ex)
1326034
def notify(self, *args, **kwargs):
        ''''''
        for handler in tuple(self.handlers):
            handler(*args, **kwargs)
323227
@Override
    public void indicateProgress(int number, int total) {
        progressIndicatorActive = true;
        String currMsg = lastMessage;
        try {
            updateStatus(currMsg + ' ' + number + " of " + total);
        } finally {
            lastMessage = currMsg;
        }
    }
1054556
function(isLoaded) {
    var self = this;
    var isLoading = !isLoaded;
    var state = self.state;
    var prev = state.loadingStatus;

    isLoading = isLoading || false;
    state.loadingStatus = isLoading;

    self._notifyParentLoadingStatus(prev, !self.isLoaded());
  }
1201430
def _callback(self, ch, method, properties, body):
        """"""

        get_logger().info("Message received! Calling listeners...")

        topic = method.routing_key
        dct = json.loads(body.decode('utf-8'))

        for listener in self.listeners:
            listener(self, topic, dct)
274507
public void onReceive(NotificationRemote remote, NotificationEntry entry,
                          Intent intent, String intentAction) {
        if (DBG) Log.d(TAG, "onReceive - " + entry.ID + ", " + intentAction);
    }
15210
def _message_received(self, message):
        """"""
        with self.lock:
            self._state.receive_message(message)
            for callable in chain(self._on_message_received, self._on_message):
                callable(message)
159958
def notify(self, reading):
        """"""
        # copy list before iterating in case new observers arrive
        for o in list(self._observers):
            o.update(self, reading)
530271
@Override
    public void onReceive(Context context, Intent intent) {
        String messageId = intent.getStringExtra(ID);
        MFPPush.getInstance().changeStatus(messageId, MFPPushNotificationStatus.DISMISSED);
    }
413273
def indication(self, pdu):
        """"""
        if _debug: TCPClient._debug("indication %r", pdu)

        self.request += pdu.pduData
557986
private void notifyMessageReceived(QueueData queueData)
   {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "notifyMessageReceived", queueData);

      long messageLength = queueData.getMessageLength();
      if (trackBytes)
      {
         bytesReceivedSinceLastRequestForMsgs += messageLength;
      }

      // Update the message arrival time
      queueData.updateArrivalTime(approxTimeThread.getApproxTime());

      messagesReceived++;
      currentBytesOnQueue += messageLength;

      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "notifyMessageReceived");
   }
1155363
def listen(cls, event, func):
        """"""
        signal(event).connect(func, sender=cls)
738143
def handle_notification(self, data):
        """"""
        _LOGGER.debug("Received notification from the device..")

        if data[0] == PROP_INFO_RETURN and data[1] == 1:
            _LOGGER.debug("Got status: %s" % codecs.encode(data, 'hex'))
            status = Status.parse(data)
            _LOGGER.debug("Parsed status: %s", status)

            self._raw_mode = status.mode
            self._valve_state = status.valve
            self._target_temperature = status.target_temp

            if status.mode.BOOST:
                self._mode = Mode.Boost
            elif status.mode.AWAY:
                self._mode = Mode.Away
                self._away_end = status.away
            elif status.mode.MANUAL:
                if status.target_temp == EQ3BT_OFF_TEMP:
                    self._mode = Mode.Closed
                elif status.target_temp == EQ3BT_ON_TEMP:
                    self._mode = Mode.Open
                else:
                    self._mode = Mode.Manual
            else:
                self._mode = Mode.Auto

            _LOGGER.debug("Valve state: %s", self._valve_state)
            _LOGGER.debug("Mode:        %s", self.mode_readable)
            _LOGGER.debug("Target temp: %s", self._target_temperature)
            _LOGGER.debug("Away end:    %s", self._away_end)

        elif data[0] == PROP_SCHEDULE_RETURN:
            parsed = self.parse_schedule(data)
            self._schedule[parsed.day] = parsed

        else:
            _LOGGER.debug("Unknown notification %s (%s)", data[0], codecs.encode(data, 'hex'))
839057
def _on_read(self, sender, *args, **kwargs):
        
        data = kwargs.get('data', None)
        self.on_read(data=data)

        self._handle_message(data)
329031
void notifyListener() {
        Node<K, V> node;
        while ((node = pendingNotifications.poll()) != null) {
            listener.onEviction(node.key, node.getValue());
        }
    }