Updates the states in the primary AlarmDecoder object based on
        the LRR message provided.

        :param message: LRR message object
        :type message: :py:class:`~alarmdecoder.messages.LRRMessage`
344312
def update(self, message):
        
        # Firmware version < 2.2a.8.6
        if message.version == 1:
            if message.event_type == 'ALARM_PANIC':
                self._alarmdecoder._update_panic_status(True)
                
            elif message.event_type == 'CANCEL':
                self._alarmdecoder._update_panic_status(False)

        # Firmware version >= 2.2a.8.6
        elif message.version == 2:
            source = message.event_source
            if source == LRR_EVENT_TYPE.CID:
                self._handle_cid_message(message)
            elif source == LRR_EVENT_TYPE.DSC:
                self._handle_dsc_message(message)
            elif source == LRR_EVENT_TYPE.ADEMCO:
                self._handle_ademco_message(message)
            elif source == LRR_EVENT_TYPE.ALARMDECODER:
                self._handle_alarmdecoder_message(message)
            elif source == LRR_EVENT_TYPE.UNKNOWN:
                self._handle_unknown_message(message)
            else:
                pass
696545
def update(self, signals):
        
        if self._sfd < 0:
            _err_closed()
        mask = sigset_t()
        sigemptyset(mask)
        if signals is not None:
            for signal in signals:
                sigaddset(mask, signal)
        # flags are ignored when sfd is not -1
        _signalfd(self._sfd, mask, 0)
        self._signals = frozenset(signals)
1148514
protected void dispatchMessage (Message message)
    {
        _messagesIn++; // count 'em up!

        // we dispatch to a message dispatcher that is specialized for the particular class of
        // message that we received
        MessageDispatcher disp = _disps.get(message.getClass());
        if (disp == null) {
            log.warning("No dispatcher for message", "msg", message);
            return;
        }

        // otherwise pass the message on to the dispatcher
        disp.dispatch(this, message);
    }
399300
async def SetStatusMessage(self, message):
        '''
        
        '''
        # map input types to rpc msg
        _params = dict()
        msg = dict(type='MigrationMaster',
                   request='SetStatusMessage',
                   version=1,
                   params=_params)
        _params['message'] = message
        reply = await self.rpc(msg)
        return reply
1340015
def _status_message_received(self, msg):
        
        if msg.cmd2 == 0x00 or msg.cmd2 == 0x01:
            self._update_subscribers(0x00)
        elif msg.cmd2 == 0x02 or msg.cmd2 == 0x03:
            self._update_subscribers(0xff)
        else:
            raise ValueError
478928
def messageReceived(self, message):
        
        i = message.index(b'')
        assert i > 0
        (routingInfo, msgId, payload) = (
            message[:i - 1], message[i - 1], message[i + 1:])
        msgParts = payload[0:]
        self._routingInfo[msgId] = routingInfo
        self.gotMessage(msgId, *msgParts)
528923
def _load_initial_message(self, message=None):
        ''''''
        if message is None:
            message = Message(verify=False)
        if isinstance(message, Mapping):
            message = Message.load_message(message)
        self.message = message
477631
public void updateLastSeenUniqueIds(VoltMessage message)
    {
        long sequenceWithUniqueId = Long.MIN_VALUE;

        boolean commandLog = (message instanceof TransactionInfoBaseMessage &&
                (((TransactionInfoBaseMessage)message).isForReplay()));

        boolean sentinel = message instanceof MultiPartitionParticipantMessage;

        // if replay
        if (commandLog || sentinel) {
            sequenceWithUniqueId = ((TransactionInfoBaseMessage)message).getUniqueId();
            // Update last seen and last polled txnId for replicas
            m_replaySequencer.updateLastSeenUniqueId(sequenceWithUniqueId,
                    (TransactionInfoBaseMessage) message);
            m_replaySequencer.updateLastPolledUniqueId(sequenceWithUniqueId,
                    (TransactionInfoBaseMessage) message);
        }
    }
745179
def message(self, message: types.Message):
        
        setattr(self, 'from_chat_id', message.chat.id)
        setattr(self, 'message_id', message.message_id)
        return self
115964
public void updateLowestMessagePriority(short messagePriority)
   {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "updateLowestMessagePriority", messagePriority);
      
      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Current state = " + state);
      
      if (state == ResourceState.JOINED)
      {
         joinedResource.updateLowestMessagePriority(messagePriority);
      }
      else
      {
         super.updateLowestMessagePriority(messagePriority);
      }
      
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "updateLowestMessagePriority");
   }
1319425
def update_alarm(self, alarm, criteria=None, disabled=False,
            label=None, name=None, metadata=None):
        
        return self._alarm_manager.update(alarm, criteria=criteria,
                disabled=disabled, label=label, name=name, metadata=metadata)
936455
def on_message(self, message):
        
        if message.address != self._address:
            return
        if isinstance(message, velbus.ChannelNamePart1Message) or isinstance(message, velbus.ChannelNamePart1Message2):
            self._process_channel_name_message(1, message)
        elif isinstance(message, velbus.ChannelNamePart2Message) or isinstance(message, velbus.ChannelNamePart2Message2):
            self._process_channel_name_message(2, message)
        elif isinstance(message, velbus.ChannelNamePart3Message) or isinstance(message, velbus.ChannelNamePart3Message2):
            self._process_channel_name_message(3, message)
        elif isinstance(message, velbus.ModuleTypeMessage):
            self._process_module_type_message(message)
        else:
            self._on_message(message)
1062222
function setMessagesRead(state, { threadID }) {
  return state.updateIn([threadID, 'messages'], messages => {
    return messages.map(msg => msg.set('isRead', true))
  })
}
1010234
def set_alarm_mode(self, mode):
        
        values = {"desired_state": {"alarm_mode": mode}}
        response = self.api_interface.set_device_state(self, values)
        self._update_state_from_response(response)
25636
async def _on_message(self, update):
        """"""

        name = update['service']
        message_obj = update['payload']

        if name not in self.services:
            return

        with self._state_lock:
            self.services[name].post_message(message_obj['level'], message_obj['message'])
969265
def transition(self, state, message=""):
        
        with self.changes_squashed:
            initial_state = self.state.value
            if self.state_set.transition_allowed(
                    initial_state=initial_state, target_state=state):
                self.log.debug(
                    "%s: Transitioning from %s to %s",
                    self.mri, initial_state, state)
                if state == ss.DISABLED:
                    alarm = Alarm.invalid("Disabled")
                elif state == ss.FAULT:
                    alarm = Alarm.major(message)
                else:
                    alarm = Alarm()
                self.update_health(self, HealthInfo(alarm))
                self.state.set_value(state)
                self.state.set_alarm(alarm)
                for child, writeable in self._children_writeable[state].items():
                    if isinstance(child, AttributeModel):
                        child.meta.set_writeable(writeable)
                    elif isinstance(child, MethodModel):
                        child.set_writeable(writeable)
            else:
                raise TypeError("Cannot transition from %s to %s" %
                                (initial_state, state))
564865
public void onMessage(MutateRowsResponse message) {
    for (Entry entry : message.getEntriesList()) {
      int index = (int) entry.getIndex();

      // Sanity check to make sure that the index returned from the server is valid.
      if (index >= mapToOriginalIndex.length || index < 0) {
        messageIsInvalid = true;
        break;
      }

      // Set the result.
      results[mapToOriginalIndex[index]] = entry.getStatus();
    }
  }