Adds a flash message with specified parameters.

@param string $messageType
@param string $message
@param array $parameters
428931
protected function addFlashMessage($messageType, $message, array $parameters = [])
    {
        $this->addFlash(
            'tags.' . $messageType,
            $this->get('translator')->trans(
                $messageType . '.' . $message,
                $parameters,
                'eztags_admin_flash'
            )
        );
    }
1053980
public void setMessagingType( String messagingType ) {

		// Properties are injected on every modification.
		// So, we just want to track changes.

		// We only want to reconfigure the messaging client
		// when the messaging type changes.
		if( ! Objects.equals( this.messagingType, messagingType )) {
			this.messagingType = messagingType;
			this.logger.fine( "Messaging type set to " + this.messagingType );

			// Explicitly require a reconfiguration.
			reconfigure();
		}
	}
1042260
public function addMessage(Message $message)
    {
        $type = $message->getType();
        if (!array_key_exists($type, $this->messages)) {
            $this->messages[$type] = [];
        }

        if ($message->getId() !== null) {
            $this->messages[$type][$message->getId()] = $message;
        } else {
            $this->messages[$type][] = $message;
        }

        return $this;
    }
1209069
public function addMessage($message, $type = null, array $vars = [])
    {
        if ($type) {
            $type = 'success';
        } elseif (false === $type) {
            $type = 'error';
        }
        if (!is_array($this->_session->messages)) {
            $this->_session->messages = [];
        }
        $messages = $this->_session->messages;
        $messages[] = ['message' => $message, 'type' => $type, 'vars' => $vars];
        $this->_session->messages = $messages;
        return $this;
    }
695016
public function flash($type = null, $message = null)
    {
        if (!isset($this->flash)) {
            $this->flash = new Flash($this->session);
        }
        
        if ($type) {
            $this->flash->set($type, $message);
        }
        
        return $this->flash;
    }
1354235
public function addInfoMessage($message, $params = array())
    {
        $message =  $this->trans($message, $params);
        static::$messages[] = array(
            'type' => 'info',
            'bootstrapType' => 'info',
            'message' => $message
        );
    }
712359
protected function notifyFlash($message, $type, $title = null, array $options = [])
    {
        $this->notify()->flash($message, $type, array_merge($options, compact('title')));
    }
734984
protected function addMessage($message, $namespace = FlashMessenger::NAMESPACE_DEFAULT)
    {
        // Load flashMessenger
        if (null === $this->messenger) {
            $this->messenger = $this->getServiceLocator()
                    ->get('ControllerPluginManager')
                    ->get('flashMessenger');
        }

        // Set current namespace
        $this->messenger->setNamespace($namespace);

        // Add messages
        $message = (array) $message;
        foreach ($message as $value) {
            $this->messenger->addMessage($value);
        }
    }
1362875
public function setSystemMessageType($messageType): Envelope
    {
        if (!in_array($messageType, static::getLetterTypeOptions())) {
            throw new InvalidArgumentException(
                sprintf('Property %s is not supported for %s', $messageType, __FUNCTION__)
            );
        }

        $this->data['letterType']['systemMessageType'] = $messageType;

        return $this;
    }
88401
protected function log ($msg = '', $logType = 'debug') {
		if (self::$loggingAndExceptions) {
			\MvcCore\Debug::Log($msg, $logType);
		}
	}
263040
public function setActionMessage($key, $message) {
        if (!isset($message)) {
            unset($this->attributes[ACTION_MESSAGES_KEY][$key]);
        }
        elseif (is_string($message)) {
            $this->attributes[ACTION_MESSAGES_KEY][$key] = $message;
        }
        else throw new IllegalTypeException('Illegal type of parameter $message: '.gettype($message));
    }
310623
public function addMessage($messages, $type = null)
    {
        switch ($type) {
            case 'success':
            case 'green':
                $tag = '<info>%s</info>';
                break;

            case 'warning':
            case 'yellow':
                $tag = '<comment>%s</comment>';
                break;

            case 'info':
            case 'blue':
                $tag = '<option>%s</option>';
                break;

            case 'error':
            case 'danger':
            case 'red':
                $tag = '<error>%s</error>';
                break;

            default:
                $tag = '%s';
                break;
        }

        foreach ((array) $messages as $message) {
            $time = gmdate('Y-m-d H:i:s');

            $this->out(sprintf('[%s] ' . $tag, $time, $message));
        }

        return $this;
    }
194290
public function publish($messageType, Message $message, array $overridenConfig = array())
    {
        if (!$this->isKnownMessageType($messageType)) {
            throw new \InvalidArgumentException(sprintf(
                'Unknown message type "%s". Available are [%s].',
                $messageType,
                implode(',', array_keys($this->messageTypes))
            ));
        }

        $config = $this->messageTypes[$messageType];

        $exchange = isset($overridenConfig['exchange']) ? $overridenConfig['exchange'] : $config['exchange'];
        $connection = isset($overridenConfig['connection']) ? $overridenConfig['connection'] : $config['connection'];
        $routingKey = isset($overridenConfig['routing_key']) ? $overridenConfig['routing_key'] : $config['routing_key'];

        $messagePublisher = $this->factory->getMessagePublisher($exchange, $connection);

        $this->logger->debug('Publish message in {exchange}:{routing_key} (connection {connection})', [
            'exchange' => $exchange,
            'routing_key' => $routingKey,
            'connection' => $connection,
        ]);

        $messagePublisher->publish($message, $routingKey);

        $this->eventDispatcher->dispatch(
            MessagePublishedEvent::NAME,
            new MessagePublishedEvent($messageType, $message, $connection, $exchange, $routingKey)
        );
    }
113742
protected function message($message, $title = '', $type = 'info')
	{
		$this->message = $message;
		$this->title = $title;
		$this->type = $type;
		$this->session->flash($this->namespace, (array) $this);
	}
719310
protected function assertValidMessageType($messageType)
    {
        if (!in_array($messageType, [self::TYPE_PHP, self::TYPE_SAPI], true)) {
            throw new \InvalidArgumentException('MessageType "%s" is not valid', $messageType);
        }
    }
320273
public static function addMessage($message, $type = 'default')
    {
        if (is_array($message)) {
            foreach ($message as $msg) {
                static::addMessage($msg);
            }

            return;
        }

        try {
            $collector = static::getInstance();
        } catch (\UnexpectedValueException $e) {
            return;
        }

        $data = $collector['debug.messages'];

        if ($data === null) {
            $data = [];
        }

        $data[] = [
            'message' => $message,
            'type' => $type,
            'timestamp' => microtime(true),
        ];

        $collector['debug.messages'] = $data;
    }
1341351
protected function message($message = null, array $params = null, $type = 'message')
    {
        return is_array($params) ? strtr(isset($this->$type) ? $this->$type : $message, $params) : $message;
    }