Lower level messaging function used by User and Channel
503343
async def message(self, recipient: str, text: str, notice: bool=False) -> None:
        
        await self._send(cc.PRIVMSG if not notice else cc.NOTICE, recipient, rest=text)
143529
function (ortc, channel, message) {
        if (ortc != null && subscribedChannels[channel] && subscribedChannels[channel].isSubscribed && subscribedChannels[channel].onMessageCallback != null) {
            subscribedChannels[channel].onMessageCallback(ortc, channel, message);
        }
    }
1209990
def notify_user(self, msg, level="info", rate_limit=5, title=None, icon=None):
        
        module_name = self._module.module_full_name
        if isinstance(msg, Composite):
            msg = msg.text()
        if title is None:
            title = "py3status: {}".format(module_name)
        elif isinstance(title, Composite):
            title = title.text()
        # force unicode for python2 str
        if self._is_python_2:
            if isinstance(msg, str):
                msg = msg.decode("utf-8")
            if isinstance(title, str):
                title = title.decode("utf-8")
        if msg:
            self._py3_wrapper.notify_user(
                msg=msg,
                level=level,
                rate_limit=rate_limit,
                module_name=module_name,
                title=title,
                icon=icon,
            )
382289
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, "Joined resource:", joinedResource);

      if (joinedResource != null)
      {
         joinedResource.updateLowestMessagePriority(messagePriority);
      }
      else
      {
         super.updateLowestMessagePriority(messagePriority);
      }

      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "updateLowestMessagePriority");
   }
1028851
def on_message(self, websocket, msg):
        '''
        '''
        if msg:
            lines = []
            for li in msg.split('\n'):
                li = li.strip()
                if li:
                    lines.append(li)
            msg = ' '.join(lines)
            if msg:
                return self.pubsub.publish(self.channel, msg)
635770
async def message(self, target, message):
        
        hostmask = self._format_user_mask(self.nickname)
        # Leeway.
        chunklen = protocol.MESSAGE_LENGTH_LIMIT - len(
            '{hostmask} PRIVMSG {target} :'.format(hostmask=hostmask, target=target)) - 25

        for line in message.replace('\r', '').split('\n'):
            for chunk in chunkify(line, chunklen):
                # Some IRC servers respond with "412 Bot :No text to send" on empty messages.
                await self.rawmsg('PRIVMSG', target, chunk or ' ')
616935
function (event) {
        var $target = $(event.currentTarget),
            nick,
            members = this.model.get('members'),
            member;

        event.stopPropagation();

        // Check this current element for a nick before resorting to the main message
        // (eg. inline nicks has the nick on its own element within the message)
        nick = $target.data('nick');
        if (!nick) {
            nick = $target.parent('.msg').data('message').nick;
        }

        // Make sure this nick is still in the channel
        member = members ? members.getByNick(nick) : null;
        if (!member) {
            return;
        }

        _kiwi.global.events.emit('nick:select', {
            target: $target,
            member: member,
            network: this.model.get('network'),
            source: 'message',
            $event: event
        })
        .then(_.bind(this.openUserMenuForNick, this, $target, member));
    }
1368598
function Message (params) {
  var self = this
  if (!(self instanceof Message)) return new Message(params)

  var message = params['chat_message'] || params
  var header = message['header']
  var body = message['body'] || { }
  var media = body['media']
  var type = body['type']

  self.identifier = message['id']
  self.messageIdentifier = message['chat_message_id']
  self.pagination = params['iter_token']
  self.messageKind = constants.messageKindFromString(type)
  self.created = new Date(+message['timestamp'])

  if (self.messageKind === null) {
    debug('invalid MessageKind (%s %j)', type, params)
  } else if (self.messageKind === constants.MessageKind.Text.value) {
    self.text = body['text']
  } else if (media) {
    self.mediaIdentifier = media['media_id']
    self.mediaSize = {
      'width': media['width'] | 0,
      'height': media['height'] | 0
    }
    self.mediaIV = media['iv']
    self.mediaKey = media['key']
    self.mediaType = media['media_type']

    if (self.mediaType) {
      self.mediaType = 'UNSPECIFIED'
    } else if (self.mediaType !== 'VIDEO') {
      debug('new message type (%s)', self.mediaType)
    }
  }

  self.conversationIdentifier = header['conv_id']

  self.recipients = header['to']
  self.sender = header['from']

  self.index = message['seq_num'] | 0
  self.savedState = message['saved_state']
  self.type = message['type']

  if (self.type !== 'chat_message') {
    debug('unknown chat message type (%s %j)', self.type, params)
  }
}
333506
def showMessage(self, level, message):
        
        self.uiFeedbackLBL.setText(message)
        self.uiLoggerEDIT.log(level, message)
378392
def im_messages_others(self, room_id, **kwargs):
        """"""
        return self.__call_api_get('im.messages.others', roomId=room_id, kwargs=kwargs)
1313388
def message_user(self, username, domain, subject, message):
        """"""
        jid = '%s@%s' % (username, domain)
        if self.api_version <= (14, 7):
            # TODO: it's unclear when send_message was introduced
            command = 'send_message_chat'
            args = domain, '%s@%s' % (username, domain), message
        else:
            command = 'send_message'
            args = 'chat', domain, jid, subject, message

        code, out, err = self.ctl(command, *args)
        if code != 0:
            raise BackendError(code)
293306
@Deprecated
  public static void reportMessage(final String message, final String level, final Map<String, String> params) {
    ensureInit(new Runnable() {
      @Override
      public void run() {
        notifier.log(message, params != null ? Collections.<String, Object>unmodifiableMap(params) : null, Level.lookupByName(level));
      }
    });
  }
663243
def on_message(self, *args, accept_query=False, matcher=None, **kwargs):
        

        if accept_query:
            def new_matcher(msg: Message):
                ret = True
                if matcher:
                    ret = matcher(msg)
                    if ret is None or ret is False:
                        return ret
                if msg.recipient is not self and not isinstance(msg.sender, User):
                    return False
                return ret
        else:
            kwargs.setdefault("channel", self.name)
            new_matcher = matcher
        return self.client.on_message(*args, matcher=new_matcher, **kwargs)
582232
protected function emitMessage($message, $level=Chatty::INFO)
    {
        foreach ($this->chattyListeners as $listener) {
            call_user_func($listener, $message, $level);
        }
    }
822836
function notifyAboutCallState(type) {
    var self = this;
    var messageTo;

    if (currentDialog.type === 3) {
        messageTo = QB.chat.helpers.getRecipientId(currentDialog.occupants_ids, currentUser.id);
    } else {
        messageTo = currentDialog.xmpp_room_jid;
    }

    QB.chat.send(messageTo, {
        type: currentDialogType(),
        extension: {
            notification_type: type,
            dialog_id: currentDialog._id
        }
    });
}
20021
def message_channel(self, message):
        
        self.log(None, message)
        super(BaseBot, self).message_channel(message)
1146065
def emit_message(self, message, log_level):
        """"""
        self.log(message)
        if log_level == logging.ERROR:
            if self._error_msg_callback:
                self._error_msg_callback(message)
                return

        if log_level == logging.WARNING:
            if self._warning_msg_callback:
                self._warning_msg_callback(message)
                return

        if log_level == logging.INFO:
            if self._info_msg_callback:
                self._info_msg_callback(message)
                return

        if self._msg_callback:
            self._msg_callback(message)