@desc Returns string representation of throwable

@return array
164444
public function getIdentityString() {
		if (!is_array($this->throwableArray)) {
			$renderer = new \n2n\log4php\renderer\RendererException();
			
			$this->throwableArray = explode("\n", $renderer->render($this->throwable));
		}
		
		return $this->throwableArray;
	}
1296851
public String throwableToString() {
        StringBuilder sb = new StringBuilder("Exception:  ");
        if (throwable != null)
            sb.append(throwable.toString());
        else
            sb.append("null");
        sb.append("\n");
        return sb.toString();
    }
1093928
public function getExceptionBacktrace(\Throwable $e)
    {
        $backtrace[] = [
            'line' => $e->getLine(),
            'file' => $e->getFile(),
            'code' => $e->getCode(),
            'message' => $e->getMessage(),
        ];

        if ($e->getPrevious()) {
            return array_merge(
                $backtrace,
                $this->getExceptionBacktrace($e->getPrevious())
            );
        }

        return $backtrace;
    }
63784
public function getDirtyAttributes()
    {
        $values = array();
        foreach (array_keys(get_object_vars($this)) as $key) {
            if (in_array($key, $this->_dirtyAttr)) {
                $values[$key] = $this->$key;
            } elseif ($this->$key instanceof ArrayObject) {
                foreach ($this->$key as $sub) {
                    if (($sub instanceof DirtyAware) && $sub->isDirty()) {
                        if (!array_key_exists($key, $values)) {
                            $values[$key] = new $this->$key;
                        }
                        $values[$key]->append($sub);
                    }
                }
            }
        }
        return $values;
    }
70630
public function excuse() {
        $fields = [];
        $values = [];
        $valuePlace = [];
        foreach ($this->data as $field => $value) {
            $fields[] = $field;
            $values[] = $value;
            $valuePlace[] = "?";
        }
        $fields = implode(' , ', $fields);
        $valuePlace = implode(' , ', $valuePlace);
        $sql = str_replace(['%INSERT%',
                            '%TABLE%',
                            '%FIELD%',
                            '%DATA%',
                            '%COMMENT%'], [$this->replace ? 'REPLACE' : 'INSERT',
                                           $this->table,
                                           $fields,
                                           $valuePlace,
                                           $this->comment], $this->insertSql);
        $connection = Pool::get(Connection::class);
        try {
            $connection->execute($sql, $values);
            $id = $connection->getLastInsID();
            Pool::release($connection);
            return $id;
        } catch (\RuntimeException $e) {
            Pool::release($connection);
            throw $e;
        } catch (\Error $e) {
            Pool::release($connection);
            throw $e;
        }

    }
852743
public function getParsedExceptions()
    {
        $parsedExceptions = [];

        $exceptions = $this->getExceptionLinesFromLogFile();
        foreach ($exceptions as $exception) {
            $parsedExceptions[] = str_replace('\\\\', '\\', $exception);
        }

        return $parsedExceptions;
    }
1340824
public function toArray()
    {
        return [
            'field' => $this->getRawProperty('field'),
            'from-field' => $this->getRawProperty('fromField'),
            'to-field' => $this->getRawProperty('toField'),
            'is-deleted' => $this->isDeleted,
            'is-added' => $this->isAdded,
        ];
    }
553335
protected function exceptionArray()
    {
        $exceptionArray = [$this->exceptionObject()];
        $previous = $this->previous;
        while ($previous) {
            $exceptionArray[] = $previous->exceptionObject();
            $previous = $previous->previous;
        }

        return $this->cleanupObj($exceptionArray, false);
    }
389585
public function getTypeAllowableValues()
  {
    return [
      self::TYPE_HOME,
      self::TYPE_WORK,
      self::TYPE_MOBILE,
      self::TYPE_OTHER,
      self::TYPE_NULL,
    ];
  }
902189
protected function getSeverityString()
    {
        static $error_types = array(
            E_WARNING => 'Warning',
            E_NOTICE => 'Notice',
            E_USER_ERROR => 'User Fatal Error',
            E_USER_WARNING => 'User Warning',
            E_USER_NOTICE => 'User Notice',
            E_STRICT => 'Forward Compatibility Notice'
        );

        $out = null;
        if (isset($error_types[$this->severity])) {
            $out = $error_types[$this->severity];
        }

        return $out;
    }
515858
public function getDescription( $throwException = TRUE )
	{
		$tags	= $this->getMetaTags( TRUE );
		if( isset( $tags['description'] ) )
			return $tags['description'];
		if( isset( $tags['dc.description'] ) )
			return $tags['dc.description'];
		if( $throwException )
			throw new RuntimeException( 'No Description Meta Tag set.' );
		return "";
	}
543020
function toString()
    {
        $modes = array();
        $levels = array(E_USER_NOTICE  => 'notice',
                        E_USER_WARNING => 'warning',
                        E_USER_ERROR   => 'error');
        if ($this->mode & PEAR_ERROR_CALLBACK) {
            if (is_array($this->callback)) {
                $callback = (is_object($this->callback[0]) ?
                    strtolower(get_class($this->callback[0])) :
                    $this->callback[0]) . '::' .
                    $this->callback[1];
            } else {
                $callback = $this->callback;
            }
            return sprintf('[%s: message="%s" code=%d mode=callback '.
                           'callback=%s prefix="%s" info="%s"]',
                           strtolower(get_class($this)), $this->message, $this->code,
                           $callback, $this->error_message_prefix,
                           $this->userinfo);
        }
        if ($this->mode & PEAR_ERROR_PRINT) {
            $modes[] = 'print';
        }
        if ($this->mode & PEAR_ERROR_TRIGGER) {
            $modes[] = 'trigger';
        }
        if ($this->mode & PEAR_ERROR_DIE) {
            $modes[] = 'die';
        }
        if ($this->mode & PEAR_ERROR_RETURN) {
            $modes[] = 'return';
        }
        return sprintf('[%s: message="%s" code=%d mode=%s level=%s '.
                       'prefix="%s" info="%s"]',
                       strtolower(get_class($this)), $this->message, $this->code,
                       implode("|", $modes), $levels[$this->level],
                       $this->error_message_prefix,
                       $this->userinfo);
    }
17450
protected static function formatDebugDumps () {
		$dumps = '';
		$lastDump = FALSE;
		$app = static::$app ?: (static::$app = & \MvcCore\Application::GetInstance());
		$appRoot = $app->GetRequest()->GetAppRoot();
		foreach (self::$dumps as $values) {
			list($dumpResult, $lastDumpLocal) = self::formatDebugDump($values, $appRoot);
			$dumps .= $dumpResult;
			if ($lastDumpLocal) $lastDump = $lastDumpLocal;
		}
		return [$dumps, $lastDump];
	}
961593
static function asArray(Exception $e)
    {
        return [
            'exception'   => get_class($e),
            'code'        => $e->getCode(),
            'message'     => $e->getMessage(),
            'file'        => $e->getFile(),
            'line'        => $e->getLine(),
            'hash'        => self::hash($e),
            'status_code' => self::statusCode($e)
        ];
    }
1057258
public function getStringifiedArray(): array
    {
        $ret = [];
        foreach ($this->headers as $header => $value) {
            if (is_array($value)) {
                $value = implode(", ", $value);
            }
            $ret[] = "$header: $value";
        }
        return $ret;
    }
726445
public function getSourceCodePath()
    {
        if ($this->path === null) {
            $path = [];
            $current = $this;
            while ($current && !$current instanceof FileDescriptor) {
                $parent = $current->getContaining();
                if (!$parent) {
                    throw new \Exception("parent cannot be null");
                }
                array_unshift($path, $current->getIndex());
                // field number in definition:descriptor.proto
                $name = $this->getClassShortName($current);
                $pname = $this->getClassShortName($parent);
                if (isset(self::$pathMap[$name])) {
                    if (is_int(self::$pathMap[$name])) {
                        $fieldNumber = self::$pathMap[$name];
                    } else {
                        if (isset(self::$pathMap[$name][$pname])) {
                            $fieldNumber = self::$pathMap[$name][$pname];
                        } else {
                            throw new \Exception("unimplemented situation $name $pname");
                        }
                    }
                } else {
                    throw new \Exception("unimplemented situation $name $pname");
                }
                array_unshift($path, $fieldNumber);
                $current = $parent;
            }
            $this->path = $path;
        } else {
            $path = $this->path;
        }
        return $path;
    }
44764
private static function serializeThrowableObject($throwable): string
    {
        $message = \sprintf(
            '[GraphQL] %s: %s[%d] (caught throwable) at %s line %s.',
            \get_class($throwable),
            $throwable->getMessage(),
            $throwable->getCode(),
            $throwable->getFile(),
            $throwable->getLine()
        );

        return $message;
    }