1#@!#!123s

: / usr / local / psa / admin / plib / modules / wp-toolkit / vendor / symfony / routing /
Filename : Route.php
back
<?php

/*
 * This file is part of the Symfony package.
 *
 * (c) Fabien Potencier <fabien@symfony.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace WPToolkitDependenciesIsolationPrefix\Symfony\Component\Routing;

/**
 * A Route describes a route and its parameters.
 *
 * @author Fabien Potencier <fabien@symfony.com>
 * @author Tobias Schultze <http://tobion.de>
 */
class Route implements \Serializable
{
    private string $path = '/';
    private string $host = '';
    private array $schemes = [];
    private array $methods = [];
    private array $defaults = [];
    private array $requirements = [];
    private array $options = [];
    private string $condition = '';
    private ?CompiledRoute $compiled = null;
    /**
     * Constructor.
     *
     * Available options:
     *
     *  * compiler_class: A class name able to compile this route instance (RouteCompiler by default)
     *  * utf8:           Whether UTF-8 matching is enforced ot not
     *
     * @param string                    $path         The path pattern to match
     * @param array                     $defaults     An array of default parameter values
     * @param array<string|\Stringable> $requirements An array of requirements for parameters (regexes)
     * @param array                     $options      An array of options
     * @param string|null               $host         The host pattern to match
     * @param string|string[]           $schemes      A required URI scheme or an array of restricted schemes
     * @param string|string[]           $methods      A required HTTP method or an array of restricted methods
     * @param string|null               $condition    A condition that should evaluate to true for the route to match
     */
    public function __construct(string $path, array $defaults = [], array $requirements = [], array $options = [], ?string $host = '', string|array $schemes = [], string|array $methods = [], ?string $condition = '')
    {
        $this->setPath($path);
        $this->addDefaults($defaults);
        $this->addRequirements($requirements);
        $this->setOptions($options);
        $this->setHost($host);
        $this->setSchemes($schemes);
        $this->setMethods($methods);
        $this->setCondition($condition);
    }
    public function __serialize() : array
    {
        return ['path' => $this->path, 'host' => $this->host, 'defaults' => $this->defaults, 'requirements' => $this->requirements, 'options' => $this->options, 'schemes' => $this->schemes, 'methods' => $this->methods, 'condition' => $this->condition, 'compiled' => $this->compiled];
    }
    /**
     * @internal
     */
    public final function serialize() : string
    {
        throw new \BadMethodCallException('Cannot serialize ' . __CLASS__);
    }
    public function __unserialize(array $data) : void
    {
        $this->path = $data['path'];
        $this->host = $data['host'];
        $this->defaults = $data['defaults'];
        $this->requirements = $data['requirements'];
        $this->options = $data['options'];
        $this->schemes = $data['schemes'];
        $this->methods = $data['methods'];
        if (isset($data['condition'])) {
            $this->condition = $data['condition'];
        }
        if (isset($data['compiled'])) {
            $this->compiled = $data['compiled'];
        }
    }
    /**
     * @internal
     */
    public final function unserialize(string $serialized) : void
    {
        $this->__unserialize(\unserialize($serialized));
    }
    public function getPath() : string
    {
        return $this->path;
    }
    /**
     * @return $this
     */
    public function setPath(string $pattern) : static
    {
        $pattern = $this->extractInlineDefaultsAndRequirements($pattern);
        // A pattern must start with a slash and must not have multiple slashes at the beginning because the
        // generated path for this route would be confused with a network path, e.g. '//domain.com/path'.
        $this->path = '/' . \ltrim(\trim($pattern), '/');
        $this->compiled = null;
        return $this;
    }
    public function getHost() : string
    {
        return $this->host;
    }
    /**
     * @return $this
     */
    public function setHost(?string $pattern) : static
    {
        $this->host = $this->extractInlineDefaultsAndRequirements((string) $pattern);
        $this->compiled = null;
        return $this;
    }
    /**
     * Returns the lowercased schemes this route is restricted to.
     * So an empty array means that any scheme is allowed.
     *
     * @return string[]
     */
    public function getSchemes() : array
    {
        return $this->schemes;
    }
    /**
     * Sets the schemes (e.g. 'https') this route is restricted to.
     * So an empty array means that any scheme is allowed.
     *
     * @param string|string[] $schemes The scheme or an array of schemes
     *
     * @return $this
     */
    public function setSchemes(string|array $schemes) : static
    {
        $this->schemes = \array_map('strtolower', (array) $schemes);
        $this->compiled = null;
        return $this;
    }
    /**
     * Checks if a scheme requirement has been set.
     */
    public function hasScheme(string $scheme) : bool
    {
        return \in_array(\strtolower($scheme), $this->schemes, \true);
    }
    /**
     * Returns the uppercased HTTP methods this route is restricted to.
     * So an empty array means that any method is allowed.
     *
     * @return string[]
     */
    public function getMethods() : array
    {
        return $this->methods;
    }
    /**
     * Sets the HTTP methods (e.g. 'POST') this route is restricted to.
     * So an empty array means that any method is allowed.
     *
     * @param string|string[] $methods The method or an array of methods
     *
     * @return $this
     */
    public function setMethods(string|array $methods) : static
    {
        $this->methods = \array_map('strtoupper', (array) $methods);
        $this->compiled = null;
        return $this;
    }
    public function getOptions() : array
    {
        return $this->options;
    }
    /**
     * @return $this
     */
    public function setOptions(array $options) : static
    {
        $this->options = ['compiler_class' => RouteCompiler::class];
        return $this->addOptions($options);
    }
    /**
     * @return $this
     */
    public function addOptions(array $options) : static
    {
        foreach ($options as $name => $option) {
            $this->options[$name] = $option;
        }
        $this->compiled = null;
        return $this;
    }
    /**
     * Sets an option value.
     *
     * @return $this
     */
    public function setOption(string $name, mixed $value) : static
    {
        $this->options[$name] = $value;
        $this->compiled = null;
        return $this;
    }
    /**
     * Returns the option value or null when not found.
     */
    public function getOption(string $name) : mixed
    {
        return $this->options[$name] ?? null;
    }
    public function hasOption(string $name) : bool
    {
        return \array_key_exists($name, $this->options);
    }
    public function getDefaults() : array
    {
        return $this->defaults;
    }
    /**
     * @return $this
     */
    public function setDefaults(array $defaults) : static
    {
        $this->defaults = [];
        return $this->addDefaults($defaults);
    }
    /**
     * @return $this
     */
    public function addDefaults(array $defaults) : static
    {
        if (isset($defaults['_locale']) && $this->isLocalized()) {
            unset($defaults['_locale']);
        }
        foreach ($defaults as $name => $default) {
            $this->defaults[$name] = $default;
        }
        $this->compiled = null;
        return $this;
    }
    public function getDefault(string $name) : mixed
    {
        return $this->defaults[$name] ?? null;
    }
    public function hasDefault(string $name) : bool
    {
        return \array_key_exists($name, $this->defaults);
    }
    /**
     * @return $this
     */
    public function setDefault(string $name, mixed $default) : static
    {
        if ('_locale' === $name && $this->isLocalized()) {
            return $this;
        }
        $this->defaults[$name] = $default;
        $this->compiled = null;
        return $this;
    }
    public function getRequirements() : array
    {
        return $this->requirements;
    }
    /**
     * @return $this
     */
    public function setRequirements(array $requirements) : static
    {
        $this->requirements = [];
        return $this->addRequirements($requirements);
    }
    /**
     * @return $this
     */
    public function addRequirements(array $requirements) : static
    {
        if (isset($requirements['_locale']) && $this->isLocalized()) {
            unset($requirements['_locale']);
        }
        foreach ($requirements as $key => $regex) {
            $this->requirements[$key] = $this->sanitizeRequirement($key, $regex);
        }
        $this->compiled = null;
        return $this;
    }
    public function getRequirement(string $key) : ?string
    {
        return $this->requirements[$key] ?? null;
    }
    public function hasRequirement(string $key) : bool
    {
        return \array_key_exists($key, $this->requirements);
    }
    /**
     * @return $this
     */
    public function setRequirement(string $key, string $regex) : static
    {
        if ('_locale' === $key && $this->isLocalized()) {
            return $this;
        }
        $this->requirements[$key] = $this->sanitizeRequirement($key, $regex);
        $this->compiled = null;
        return $this;
    }
    public function getCondition() : string
    {
        return $this->condition;
    }
    /**
     * @return $this
     */
    public function setCondition(?string $condition) : static
    {
        $this->condition = (string) $condition;
        $this->compiled = null;
        return $this;
    }
    /**
     * Compiles the route.
     *
     * @throws \LogicException If the Route cannot be compiled because the
     *                         path or host pattern is invalid
     *
     * @see RouteCompiler which is responsible for the compilation process
     */
    public function compile() : CompiledRoute
    {
        if (null !== $this->compiled) {
            return $this->compiled;
        }
        $class = $this->getOption('compiler_class');
        return $this->compiled = $class::compile($this);
    }
    private function extractInlineDefaultsAndRequirements(string $pattern) : string
    {
        if (\false === \strpbrk($pattern, '?<')) {
            return $pattern;
        }
        return \preg_replace_callback('#\\{(!?)([\\w\\x80-\\xFF]++)(<.*?>)?(\\?[^\\}]*+)?\\}#', function ($m) {
            if (isset($m[4][0])) {
                $this->setDefault($m[2], '?' !== $m[4] ? \substr($m[4], 1) : null);
            }
            if (isset($m[3][0])) {
                $this->setRequirement($m[2], \substr($m[3], 1, -1));
            }
            return '{' . $m[1] . $m[2] . '}';
        }, $pattern);
    }
    private function sanitizeRequirement(string $key, string $regex) : string
    {
        if ('' !== $regex) {
            if ('^' === $regex[0]) {
                $regex = \substr($regex, 1);
            } elseif (\str_starts_with($regex, '\\A')) {
                $regex = \substr($regex, 2);
            }
        }
        if (\str_ends_with($regex, '$')) {
            $regex = \substr($regex, 0, -1);
        } elseif (\strlen($regex) - 2 === \strpos($regex, '\\z')) {
            $regex = \substr($regex, 0, -2);
        }
        if ('' === $regex) {
            throw new \InvalidArgumentException(\sprintf('Routing requirement for "%s" cannot be empty.', $key));
        }
        return $regex;
    }
    private function isLocalized() : bool
    {
        return isset($this->defaults['_locale']) && isset($this->defaults['_canonical_route']) && ($this->requirements['_locale'] ?? null) === \preg_quote($this->defaults['_locale']);
    }
}