@param string $message
@param array  $options

@return mixed
971308
protected function encodeMessage($message, array $options = [])
    {
        $resolver = new OptionsResolver();
        $this->encoder->setDefaultOptions($resolver);
        $options = $resolver->resolve($options);

        return $this->encoder->encode($message, $this->compressor, $options);
    }
1141255
private function labeledMessage($label, $message, $options = 0)
    {
        if (isset($this->stdErr)) {
            $this->stdErr->writeln('<options=reverse>' . strtoupper($label) . '</> ' . $message, $options);
        }
    }
332317
public function getOutput($input, array $options = array())
    {
        $this->log(sprintf('Getting output from file (%s)', $input));

        return $this->getGenerator()->getOutput($input, $options);
    }
1042863
private function triggerError(string $message, int $options): bool
    {
        if ($options & STREAM_REPORT_ERRORS) {
            trigger_error($message, E_USER_WARNING);
        }

        return false;
    }
488531
public function startWrite($message, array $options = null) {
		return $this->startEvent($message, ProfileInterface::TYPE_WRITE, $options);
	}
569880
public function write($message, $params = [])
    {
        $options = $this->getMergedWriteParams($params);

        echo $this->getMessagePrefix($options)
            , $this->getDecoratedMessage($message, $options)
            , $this->getReset();

        return $this;
    }
23576
private function formatMessage(&$message)
    {
        if ($this->extraMessage) {
            $message = array_merge($message, $this->extraMessage->toArray());
        }

        foreach ($this->options as $option => $value) {
            Arr::set($message, $option, $value);
        }
    }
750560
protected function translateMessage($message, array $parameters = array())
    {
        return $this->translator->trans($message, $parameters, $this->transDomain);
    }
243191
public function writeLn($message = '', $options = 0)
    {
        $this->write($message, $options);
        $this->write(PHP_EOL);

        return $this;
    }
887337
public function notifyIn($room, $message, array $options = [])
    {
        // Don't do any request.
        if ($this->getOption('pretend', $options)) {
            return $this;
        }

        // Construct POST data.
        $json = [
            'message'        => $message,
            'message_format' => 'html',
            'color'          => $this->getOption('color', $options),
            'notify'         => $this->getOption('notify', $options),
        ];

        // Get the room settings
        $room = $this->getRoom($room);

        // Set authentication
        $query = ['auth_token' => $room->token()];

        // Build URI.
        $uri = $this->getRoomNotificationUrl($room);

        // Make request.
        $this->client->post($uri, compact('json', 'query'));

        // Allow chaining.
        return $this;
    }
1175819
public function outVerbose($message, $options = array())
    {
        
        common_Logger::i($message);
        if (isset($this->parameters['verbose']) && $this->parameters['verbose'] === true) {
        	$this->out($message, $options);
        }
        
    }
998829
public function message($message, $options = null) {
		$options = $this->_mergeOptions($options);

		$this->set($message, $options);

		$this->_assertSessionStackSize($options);
	}
1039640
public function exception(\Exception $e, array $options = [])
    {
        $message = $this->createExceptionMessages($e);
        return $this->message($message);
    }
1120136
public function get($method, array $params, array $options = array())
    {
        $this->parseOptions($options);

        $params = array_merge($params, $this->apiKeys);

        $response = $this->httpAdapter->getContent(
            sprintf(self::API_ENDPOINT, $this->scheme, $this->outputFormat, $method .'?'. http_build_query($params)),
            $this->headers
        );

        return $this->responseHandler($response);
    }
1119850
public static function EncryptMessage ($message, $key, $options = []) {
		$options = static::_AdjustOptions($options);
		return openssl_encrypt($message, $options['method'], $key, $options['openssl_options'], $options['iv']);
	}
335266
public function checkMessages(array $options = [])
    {
        $start = array_key_exists('start', $options) ? $options['start'] : 0;
        $end = array_key_exists('end', $options) ? $options['end'] : 25;

        $rawMessages = $this->plivo->get_messages([
            'offset' => $start,
            'limit'  => $end,
        ]);

        $incomingMessages = [];

        foreach ($rawMessages['objects'] as $rawMessage) {
            $incomingMessage = $this->createIncomingMessage();
            $this->processReceive($incomingMessage, $rawMessage);
            $incomingMessages[] = $incomingMessage;
        }

        return $incomingMessages;
    }
601107
public function publish(array $message, array $options = [])
    {
        $mergedOptions = $this->mergeOptions($options);

        if (isset($options['message_deduplication_id'])) {
            $mergedOptions['message_deduplication_id'] = $options['message_deduplication_id'];
        }

        if (isset($options['message_group_id'])) {
            $mergedOptions['message_group_id'] = $options['message_group_id'];
        }

        $options = $mergedOptions;

        $publishStart = microtime(true);

        // ensures that the SQS Queue and SNS Topic exist
        if (!$this->queueExists()) {
            $this->create();
        }

        if ($options['push_notifications']) {

            if (!$this->topicExists()) {
                $this->create();
            }

            $message    = [
                'default' => $this->getNameWithPrefix(),
                'sqs'     => json_encode($message),
                'http'    => $this->getNameWithPrefix(),
                'https'   => $this->getNameWithPrefix(),
            ];

            $result = $this->sns->publish([
                'TopicArn'         => $this->topicArn,
                'Subject'          => $this->getName(),
                'Message'          => json_encode($message),
                'MessageStructure' => 'json'
            ]);

            $context = [
                'TopicArn'           => $this->topicArn,
                'MessageId'          => $result->get('MessageId'),
                'push_notifications' => $options['push_notifications'],
                'publish_time'       => microtime(true) - $publishStart
            ];
            $this->log(200,"Message published to SNS", $context);

            return $result->get('MessageId');
        }

        $arguments = [
            'QueueUrl'      => $this->queueUrl,
            'MessageBody'   => json_encode($message),
            'DelaySeconds'  => $options['message_delay']
        ];

        if ($this->isQueueFIFO()) {
            if (isset($options['message_deduplication_id'])) {
                // Always use user supplied dedup id
                $arguments['MessageDeduplicationId'] = $options['message_deduplication_id'];
            } elseif ($options['content_based_deduplication'] !== true) {
                // If none is supplied and option "content_based_deduplication" is not set, generate default
                $arguments['MessageDeduplicationId'] = hash('sha256', json_encode($message));
            }

            $arguments['MessageGroupId'] = $this->getNameWithPrefix();
            if (isset($options['message_group_id'])) {
                $arguments['MessageGroupId'] = $options['message_group_id'];
            }
        }

        $result = $this->sqs->sendMessage($arguments);

        $context = [
            'QueueUrl'              => $this->queueUrl,
            'MessageId'             => $result->get('MessageId'),
            'push_notifications'    => $options['push_notifications'],
            'fifo'                  => $options['fifo']
        ];

        if ($this->isQueueFIFO()) {
            if (isset($arguments['MessageDeduplicationId'])) {
                $context['message_deduplication_id'] = $arguments['MessageDeduplicationId'];
            }
            $context['message_group_id'] = $arguments['MessageGroupId'];
        }

        $this->log(200,"Message published to SQS", $context);

        return $result->get('MessageId');
    }