*
@return String that resents the current object
979069
public function toString()
    {
        $authorization = array();
        $authorization['code'] = $this->code;
        $authorization['reference'] = $this->reference;
        return "Authorization: " . implode(' - ', $authorization);
    }
105050
public function toString()
	{
		$this->_generateBaseString();
		$this->_addName();
		$this->_addType();
		$this->_addRestriction();
		$this->_addDefault();

		return $this->_asString;
	}
183821
public String getVertexString() {
        if (tail() != null) {
            return "" + tail().index + "-" + head().index;
        } else {
            return "?-" + head().index;
        }
    }
301670
public function toString()
    {
        $parts = [];

        if ($this->operand) {
            $parts[] = (string)$this->operand;
        }

        if ($this->constraint) {
            $parts[] = (string)$this->constraint;
        }

        return implode(' ', $parts);
    }
1093914
protected function getTemplateStrings()
    {
        $default = 'Expected {{actual}} to have a{{deep}}property {{key}}';
        $negated = 'Expected {{actual}} to not have a{{deep}}property {{key}}';

        if ($this->getValue() && $this->isActualValueSet()) {
            $default = 'Expected {{actual}} to have a{{deep}}property {{key}} of {{value}}, but got {{actualValue}}';
            $negated = 'Expected {{actual}} to not have a{{deep}}property {{key}} of {{value}}';
        }

        $deep = ' ';
        if ($this->isDeep()) {
            $deep = ' deep ';
        }

        return str_replace('{{deep}}', $deep, [$default, $negated]);
    }
389488
public function asString()
    {
        $display = function ($lines, $length, $loop = 0) use (&$display) {
            $output = '';
            foreach ($lines as $line) {
                $line = is_a($line, 'Deflection\Element\AbstractElement') ? $line->getElement() : $line;
                if (is_array($line)) {
                    $output .= $display($line, $length, $loop+1);
                } else {
                    $size = mb_strlen($line)+($length*$loop);
                    $output .= str_pad($line, $size, ' ', STR_PAD_LEFT)."\n";
                }
            }
            return $output;
        };
        return !$this->class ?: "<?php\n".$display($this->class->getElement(), $this->tab);
    }
197695
public function __tostring()
    {
        ob_start();
        $close = $this->_opened;
        $this->open();
        if (!in_array('start', $this->options)) {
            $this->content();
        }
        if (!$this->hasOption('start') || $close) {
            $this->close();
        }

        return ob_get_clean();
    }
1111062
public function toString()
    {
        $string = '';
        $methods = $this->getIterator();
        foreach ($methods as $method) {
            $string .= $method->toString();
        }

        return $string;
    }
920853
public function str()
	{
		$str = '';
		foreach ($this->attributes as $name => $value) {
			$str .= $this->getAttribStr($name);
		}
		return $str;
	}
698571
function() {
		var str = this.trim();
		str = this.charAt(0).toUpperCase() + this.slice(1);
		if (!str.match(/[?!\.]$/)) str = str+'.';
		return str;
	}
1316022
public function asString()
    {
        return sprintf(
            '%s%s%s',
            $this->isObjectType ? '\\' : '',
            $this->propType !== null ? $this->propType : 'mixed',
            str_repeat('[]', $this->arrayDepth)
        );
    }
922615
public function getDereferenced()
    {
        if ($this->dereferenced_field) {
            return $this->dereferenced_field;
        }
        $f = preg_replace('/_id$/', '', $this->short_name);
        if ($f != $this->short_name) {
            return $f;
        }

        $f = $this->short_name.'_text';
        if ($this->owner->hasElement($f)) {
            return $f;
        }

        $f = $this->_unique($this->owner->elements, $f);
        $this->dereferenced_field = $f;

        return $f;
    }
938210
protected function getDeleteString(): string
    {
        $statement = '';

        $delete = $this->builder->isDelete();
        if (!$delete && !$this->isDeleteTableFrom()) {
            return $statement;
        }

        if (\is_array($delete)) {
            $statement .= implode(', ', $delete);
        }

        if ($statement || $this->isDeleteTableFrom()) {
            $statement = 'DELETE ' . $statement;
            $statement = trim($statement);
        }

        return $statement;
    }
754286
public function toString()
    {
        if ($this->hidden) {
            return '';
        }
        
        return trim($this->getName() .
            (!empty($this->version) && !$this->version->hidden ? ' ' . $this->getVersion() : '')) .
            (!empty($this->edition) ? ' ' . $this->edition : '');
    }
1006909
protected function _cleanCurrent() {
        if($this->_current) {
            $current = $this->_current;
            $this->_current = null;
            return $this->formatTemplate($current.'End', []);
        }
        return '';
    }
250052
public static function getIgnoredClassesRegex(): string
    {
        if (self::$ignoredClassesRegex !== '') {
            return self::$ignoredClassesRegex;
        }

        $ignoredClassesConfiguration = self::$ignoredClassesFallback;
        $ignoredClasses = [];

        if (self::$objectManager instanceof ObjectManagerInterface) {
            $configurationManager = self::$objectManager->get(ConfigurationManager::class);
            if ($configurationManager instanceof ConfigurationManager) {
                $ignoredClassesFromSettings = $configurationManager->getConfiguration('Settings', 'Neos.Flow.error.debugger.ignoredClasses');
                if (is_array($ignoredClassesFromSettings)) {
                    $ignoredClassesConfiguration = Arrays::arrayMergeRecursiveOverrule($ignoredClassesConfiguration, $ignoredClassesFromSettings);
                }
            }
        }

        foreach ($ignoredClassesConfiguration as $classNamePattern => $active) {
            if ($active === true) {
                $ignoredClasses[] = $classNamePattern;
            }
        }

        self::$ignoredClassesRegex = sprintf('/^%s$/xs', implode('$|^', $ignoredClasses));

        return self::$ignoredClassesRegex;
    }
1092611
protected function toString(): string
    {
        $normalized = sprintf('%s%s', $this->prefix, implode(DIRECTORY_SEPARATOR, $this->stack));

        return trim($normalized);
    }