Returns generated output of non flash messages.

@param null $type
@param null $format
@return string
768460
public function show($type = null, $format = null)
    {
        $messages = $this->getMessagesForRender($type);

        $this->groupForRender = array();

        $output = '';

        foreach ($messages as $message) {
            if (!$message->isFlash()) {
                if (!is_null($format)) {
                    $message->setFormat($format);
                }

                $output .= $message->render();
            }
        }

        return $output;
    }
753098
protected function buildMessages(array $flashes, $type)
    {
        $messages = '';
        foreach ($flashes as $msg) {
            $messages .= $this->template->wrapMessage($msg);
        }

        return $this->template->wrapMessages($messages, $type);
    }
94079
protected function getMessagesForRender($type = null)
    {
        if (is_null($type)) {
            if (count($this->groupForRender) > 0) {
                $messages = array();

                foreach ($this->groupForRender as $typeToRender) {
                    $messages = array_merge($messages, $this->get($typeToRender)->all());
                }

                return new Collection($messages);
            }

            return $this->all();
        }
        return $this->get($type);
    }
626428
public function flashMessage($message, string $type = 'info'): stdClass
	{
		parent::flashMessage($message, $type);
		return $this->presenter->flashMessage($message, $type);
	}
766206
public function getVerboseOutput($type = 'text')
    {
        switch ($type) {
            case 'text':
                return implode("\n", $this->outputSchedule);
            case 'html':
                return implode('<br>', $this->outputSchedule);
            case 'array':
                return $this->outputSchedule;
            default:
                throw new InvalidArgumentException('Invalid output type');
        }
    }
1163971
public function getDate($format = null)
    {
        if (empty($format)) {
            return $this->get('__date__')->sec;
        }
        
        return date($format, $this->get('__date__')->sec);
    }
335087
public function emailFormat($format = null)
    {
        deprecationWarning('Email::emailFormat() is deprecated. Use Email::setEmailFormat() or Email::getEmailFormat() instead.');

        if ($format === null) {
            return $this->getEmailFormat();
        }

        return $this->setEmailFormat($format);
    }
335538
public function display($type = null) : string
    {
        if (is_null($type)) {
            $type = self::DISPLAY_SHORT;
        }

        if ($type == self::DISPLAY_DURATION) {
            $format = [];

            if ($this->hour) {
                $format[] = Unit::format($this->hour, 'duration/hour');
            }

            if ($this->minute) {
                $format[] = Unit::format($this->minute, 'duration/minute');
            }

            if ($this->second) {
                $format[] = Unit::format($this->second, 'duration/second');
            }

            return Misc::joinUnits($format, 'narrow');
        }

        return Calendar::formatTime($this->toMutable(), $type);
    }
566415
function output($format = null, $quality = null) {
        // Determine quality
        $quality = $quality ? : $this->quality;
        // Determine mimetype
        switch (strtolower($format)) {
            case 'gif':
                $mimetype = 'image/gif';
                break;
            case 'jpeg':
            case 'jpg':
                imageinterlace($this->image, true);
                $mimetype = 'image/jpeg';
                break;
            case 'png':
                $mimetype = 'image/png';
                break;
            default:
                $info = (empty($this->imagestring)) ? getimagesize($this->filename) : getimagesizefromstring($this->imagestring);
                $mimetype = $info['mime'];
                unset($info);
                break;
        }
        // Output the image
        header('Content-Type: ' . $mimetype);
        switch ($mimetype) {
            case 'image/gif':
                imagegif($this->image);
                break;
            case 'image/jpeg':
                imageinterlace($this->image, true);
                imagejpeg($this->image, null, round($quality));
                break;
            case 'image/png':
                imagepng($this->image, null, round(9 * $quality / 100));
                break;
            default:
                throw new Exception('Unsupported image format: ' . $this->filename);
                break;
        }
    }
340232
protected function checkFormat($format, $type = null)
    {
        return !is_null($format) ? $format : $this->getFormat($type);
    }
332630
protected function cleanZendType(?string $type): ?string
    {
        if (!$type || strtolower($type) == 'null') {
            return null;
        }
        if (strtolower($type) == 'array') {
            return 'array';
        }
        if (strpos('\\', $type)) {
            return '\\' . $type;
        }
        return $type;
    }
1160186
public function render_child_type( $type ) {

		$output = null;
		if ( ! empty( $this->child ) ) {
			foreach ( $this->child as $child ) {
				if ( $type === $child->type ) {
					$output .= $child->render();
				}
			}
		}

		return $output;

	}
839036
final public function format($format)
    {
        if(is_null($this->value)) {
            return null;
        } else {
            return $this->value->format($format);
        }
    }
721924
public function getClear($type = null)
    {
        $messages = $this->get($type);
        $this->clear($type);
        return $messages;
    }
1312634
public function format($format = null)
    {
        if (empty($format)) {
            $format = $this->defaultFormat;
        }
        return $this->formatDatetimeObject($format);
    }
564352
public function message($type = null)
    {
        switch ($type) {
            case static::MESSAGE_HTML:
                return $this->_htmlMessage;
            case static::MESSAGE_TEXT:
                return $this->_textMessage;
        }

        return $this->_message;
    }
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;
    }