Returns the messages
766750
public function output( $type = null )
	{
		$session = $this->_di->getService( "session" );

        /**
         * Get the messages from the session
         */
		$messages = $session->get( "__flash__" );

		/**
		 * If there are no messages to output -> exit early
		 */
        if ( $messages == null )
        {
        	return;
        }

        /**
         * If a type is specified -> implode and return the type messages
         */
        if ( isset($type) )
        {
            /**
             * Get the messages of the type
             */
        	$messages_type = implode( $messages[$type] );

            /**
             * Clear the type messages in the flash session
             */
        	$messages[$type] = array();

			$session->set( "__flash__", $messages );

    	    return $messages_type;
        }

        /**
         * Create a string with all messages
         */
        $all_messages_str = "";

        foreach ( $messages as $messages_type )
        {
        	$all_messages_str .= implode( $messages_type );
        }

        /**
         * When all the messages have been output -> clear all the messages in the flash session
         */
		$session->set( "__flash__", array() );

        return $all_messages_str;
	}
1167380
public function getMessages()
    {
        return $this->conversation->getMessages($this->user, $this->getPaginationParams(), $this->deleted);
    }
387794
async def get_messages(self, name):
        

        resp = await self.send_command(OPERATIONS.CMD_QUERY_MESSAGES, {'name': name},
                                       MESSAGES.QueryMessagesResponse, timeout=5.0)

        return [states.ServiceMessage.FromDictionary(x) for x in resp]
590696
public List<MType> getMessageList() {
    if (externalMessageList == null) {
      externalMessageList = new MessageExternalList<MType, BType, IType>(this);
    }
    return externalMessageList;
  }
572399
def messages(self):
        ''''''

        # The file contains the fixed-size file header followed by
        # fixed-size message structures, followed by minimal message
        # information (subject, from, to).  Start after the file
        # header and then simply return the message structures in
        # sequence until we have returned the number of messages in
        # this folder, ignoring the minimal message information at the
        # end of the file.

        offset = self.header_length # initial offset
        # how much of the data in this file we expect to use, based on
        # the number of messages in this folder and the index message block size
        maxlen = self.header_length + self.total_messages * MacIndexMessage.LENGTH
        while offset < maxlen:
             yield MacIndexMessage(mm=self.mmap, offset=offset)
             offset += MacIndexMessage.LENGTH
449222
def getMessage(self):
        
        if isinstance(self.msg, numpy.ndarray):
            msg = self.array2string(self.msg)
        else:
            msg = str(self.msg)
        if self.args:
            a2s = self.array2string
            if isinstance(self.args, Dict):
                args = {k: (a2s(v) if isinstance(v, numpy.ndarray) else v)
                        for (k, v) in self.args.items()}
            elif isinstance(self.args, Sequence):
                args = tuple((a2s(a) if isinstance(a, numpy.ndarray) else a)
                             for a in self.args)
            else:
                raise TypeError("Unexpected input '%s' with type '%s'" % (self.args,
                                                                          type(self.args)))
            msg = msg % args
        return msg
874256
private CmsMessages getMessages() {

        if (m_messages == null) {
            if (m_cms != null) {
                m_messages = Messages.get().getBundle(OpenCms.getWorkplaceManager().getWorkplaceLocale(m_cms));
            } else {
                m_messages = Messages.get().getBundle();
            }
        }
        return m_messages;
    }
429888
public function getMessages()
    {
        $results  = $this->getResults();
        $messages = [];

        foreach ($results as $result) {
            /** @noinspection SlowArrayOperationsInLoopInspection */
            $messages = array_replace_recursive($messages, $result->getMessages());
        }

        return $messages;
    }
1217894
protected function getMessages()
    {
        $messages = [];
        foreach ($this->sourcePath as $namespace => $path) {
            $messages = array_merge($this->getMessagesFromSourcePath($path, $namespace), $messages);
        }

        return $messages;
    }
727075
def message(self):
        
        return {
            'user_cookie': self.user_cookie,
            'portfolio_cookie': self.portfolio_cookie,
            'account_list': list(self.account_list),
            'init_cash': self.init_cash,
            'cash': self.cash,
            'history': self.history
        }
1300
def get_callbacks_from_message(self, msg):
        """"""
        callbacks = []
        for key in self._find_matching_keys(msg):
            for callback in self[key]:
                callbacks.append(callback)
        return callbacks
536831
function getCumulativeMessages(timestamp, clientSync) {
    var msgs = [];
    if (lastSync > clientSync) {
        msgs = messages;
    } else {
        var newMsgs = messages.length;
        while (newMsgs > 0 && messages[newMsgs - 1].timestamp > timestamp) {
            newMsgs--;
        }
        for (var i = newMsgs; i < messages.length; i++) {
            msgs.push(messages[i]);
        }
    }

    var data = {};
    data.msgs = msgs;
    data.lastSync = lastSync;

    return data;
}
1069674
public function getMessages()
    {
        $messages = parent::getMessages();

        if ($this->model !== null) {
            foreach ($this->model as $row) {
                foreach ($this->columns as $column) {
                    $messages = array_merge(
                        $messages,
                        $column->getMessages($row)
                    );
                }

                foreach ($this->spanning_columns as $column) {
                    $messages = array_merge(
                        $messages,
                        $column->getMessages($row)
                    );
                }
            }

            foreach ($this->extra_rows as $row) {
                if ($row instanceof SwatTableViewWidgetRow) {
                    $messages = array_merge($messages, $row->getMessages());
                }
            }
        }

        return $messages;
    }
1072693
@Override
    public String getGatherMessages() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "getGatherMessages");

        String gatherMessages = (String) properties.get(GATHER_MESSAGES);

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "getGatherMessages");
        return gatherMessages;
    }
717973
def _get_request_messages(self, request):
        
        data = request.get_data(as_text=True)
        try:
            msg = self.json_decoder.decode(data)
        except Exception:
            raise ParseError("Could not parse request data '{}'".format(data))
        if isinstance(msg, list):
            return msg
        else:
            return [msg]
354087
def get_message(self, more_content):
        '''
        
        '''
        return {
            'status': self.status,
            'content': self.body,
            'headers': self._parse_headers(),
            'more_content': more_content
        }
378187
protected function getUserMessages()
    {
        $messages = [];

        foreach ($this->repository->all() as $field) {
            foreach ($field->getOption('messages') as $rule => $message) {
                $messages[$field->getName().'.'.$rule] = $message;
            }
        }

        return $messages;
    }