Notify this observer that data has arrived
765075
def notify(self, data):
        """"""
        LOG.debug('notify received: %s', data)
        self._notify_count += 1
        if self._cancelled:
            LOG.debug('notify skipping due to `cancelled`')
            return self
        if self._once_done and self._once:
            LOG.debug('notify skipping due to `once`')
            return self
        with self._lock:
            try:
                # notify next consumer immediately
                self._waitables.get_nowait().put_nowait(data)
                LOG.debug('found a consumer, notifying')
            except queue.Empty:
                # store the notification
                try:
                    self._notifications.put_nowait(data)
                    LOG.debug('no consumers, queueing data')
                except queue.Full:
                    LOG.warning('notification queue full - discarding new data')

        # callbacks are sent straight away
        # bombproofing should be handled by individual callbacks
        for callback in self._callbacks:
            LOG.debug('callback: %s', callback)
            callback(data)
        self._once_done = True
        return self
86275
private void notifyCreation(final RepositoryObject object, final Map<String, Object> data) {

		for (final ExternalChangeListener listener : externalChangeListeners) {
			listener.onCreate(object, data);
		}
	}
88094
def data_received(self, data):
        """"""
        self.buffer += data.decode()
        self.log.debug('Received %d bytes from AVR: %s', len(self.buffer), self.buffer)
        self._assemble_buffer()
732662
def on_message(self, started_waiting):
        
        watcher = self.settings.watcher
        if started_waiting:
            watcher.start_waiting()
        else:
            watcher.done_waiting()
1098294
def _notify_receiver(self, receiver, params, doc):
        """"""
        verb = VMAP[doc['op']]
        ns = doc['ns']
        notification_id = Id(ns + 'Notification:' + str(ObjectId()) + '@' + params['authority'])
        object_id = Id(ns + ':' + str(doc['o']['_id']) + '@' + params['authority'])
        try:
            getattr(receiver, '_'.join([verb, params['obj_name_plural']]))(notification_id, [object_id])
        except AttributeError:
            pass
        return notification_id
207101
void observe(FolderObserver observer) {
    synchronized (idleMutex) {
      this.observer = observer;
      pushedData = new PushedData();
      idleAcknowledged.set(false);
    }
  }
329031
void notifyListener() {
        Node<K, V> node;
        while ((node = pendingNotifications.poll()) != null) {
            listener.onEviction(node.key, node.getValue());
        }
    }
922139
def dataReceived(self, data):
        
        self.connection._iobuf.write(data)
        self.connection.handle_read()
425466
def notify():
    """"""
    a = TpPd(pd=0x3)
    b = MessageType(mesType=0x3e)  # 00111110
    c = NotificationIndicator()
    packet = a / b / c
    return packet
614416
def notify_update(self):
    """"""
    with self._lock:
      for event in self._update_events:
        event.set()
      self._update_events.clear()
1080965
public function notify()
    {
        if (0 < count($this->observers)) {
            foreach ($this->observers as $observer) {
                /** @var \Liip\Drupal\Modules\EventManager\EventObserverInterface $observer */
                $observer->update($this);
            }
        }
    }
268081
def _notifyDone(self):
        '''
        
        '''
        if self.notified:
            return

        self.doneevent.set()

        for buid in self.mybldgbuids:
            del self.allbldgbuids[buid]

        self.notified = True
414696
def data_received(self, data):
        """"""
        if self._on_data:
            self._on_data(data)
            return
        self._queued_data.append(data)
961783
def ready(self, count):
        """"""
        self.ready_count = count
        self.send(nsq.ready(count))
459712
final public function notify()
  {
    $observers = array_values($this->_observers);
    foreach ($observers as $observer) {
      switch (false) {
        case is_array($observer):
        case isset($observer[0]):
        case isset($observer[1]):
        case is_string($observer[0]):
          break;
        default:
          Loader::loadClass($observer[0]);
          break;
      }

      if (!is_callable($observer)) {
        continue;
      }

      call_user_func($observer, $this);
    }

    return $this;
  }
471151
function notify(\pq\Gateway\Row $row = null, $event = null, array &$where = null) {
		foreach ($this->observers as $observer) {
			$observer->update($this, $row, $event, $where);
		}
	}
71726
def received_message(self, address, data):
        """"""
        self.value_cache.set(address, data)
        if self.notify:
            self.notify(address, data)

        try:
            listeners = self.address_listeners[address]
        except KeyError:
            listeners = []

        for listener in listeners:
            listener(address, data)