<form method="POST">
    <h3>Editing: Router.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

/*
 * This file is part of the Symfony package.
 *
 * (c) Fabien Potencier &lt;fabien@symfony.com&gt;
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Symfony\Component\Routing;

use Psr\Log\LoggerInterface;
use Symfony\Component\Config\ConfigCacheFactory;
use Symfony\Component\Config\ConfigCacheFactoryInterface;
use Symfony\Component\Config\ConfigCacheInterface;
use Symfony\Component\Config\Loader\LoaderInterface;
use Symfony\Component\ExpressionLanguage\ExpressionFunctionProviderInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Routing\Generator\CompiledUrlGenerator;
use Symfony\Component\Routing\Generator\ConfigurableRequirementsInterface;
use Symfony\Component\Routing\Generator\Dumper\CompiledUrlGeneratorDumper;
use Symfony\Component\Routing\Generator\Dumper\GeneratorDumperInterface;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
use Symfony\Component\Routing\Matcher\CompiledUrlMatcher;
use Symfony\Component\Routing\Matcher\Dumper\CompiledUrlMatcherDumper;
use Symfony\Component\Routing\Matcher\Dumper\MatcherDumperInterface;
use Symfony\Component\Routing\Matcher\RequestMatcherInterface;
use Symfony\Component\Routing\Matcher\UrlMatcherInterface;

/**
 * The Router class is an example of the integration of all pieces of the
 * routing system for easier use.
 *
 * @author Fabien Potencier &lt;fabien@symfony.com&gt;
 */
class Router implements RouterInterface, RequestMatcherInterface
{
    /**
     * @var UrlMatcherInterface|null
     */
    protected $matcher;

    /**
     * @var UrlGeneratorInterface|null
     */
    protected $generator;

    /**
     * @var RequestContext
     */
    protected $context;

    /**
     * @var LoaderInterface
     */
    protected $loader;

    /**
     * @var RouteCollection|null
     */
    protected $collection;

    /**
     * @var mixed
     */
    protected $resource;

    /**
     * @var array
     */
    protected $options = [];

    /**
     * @var LoggerInterface|null
     */
    protected $logger;

    /**
     * @var string|null
     */
    protected $defaultLocale;

    /**
     * @var ConfigCacheFactoryInterface|null
     */
    private $configCacheFactory;

    /**
     * @var ExpressionFunctionProviderInterface[]
     */
    private $expressionLanguageProviders = [];

    private static $cache = [];

    /**
     * @param mixed $resource The main resource to load
     */
    public function __construct(LoaderInterface $loader, $resource, array $options = [], ?RequestContext $context = null, ?LoggerInterface $logger = null, ?string $defaultLocale = null)
    {
        $this-&gt;loader = $loader;
        $this-&gt;resource = $resource;
        $this-&gt;logger = $logger;
        $this-&gt;context = $context ?? new RequestContext();
        $this-&gt;setOptions($options);
        $this-&gt;defaultLocale = $defaultLocale;
    }

    /**
     * Sets options.
     *
     * Available options:
     *
     *   * cache_dir:              The cache directory (or null to disable caching)
     *   * debug:                  Whether to enable debugging or not (false by default)
     *   * generator_class:        The name of a UrlGeneratorInterface implementation
     *   * generator_dumper_class: The name of a GeneratorDumperInterface implementation
     *   * matcher_class:          The name of a UrlMatcherInterface implementation
     *   * matcher_dumper_class:   The name of a MatcherDumperInterface implementation
     *   * resource_type:          Type hint for the main resource (optional)
     *   * strict_requirements:    Configure strict requirement checking for generators
     *                             implementing ConfigurableRequirementsInterface (default is true)
     *
     * @throws \InvalidArgumentException When unsupported option is provided
     */
    public function setOptions(array $options)
    {
        $this-&gt;options = [
            'cache_dir' =&gt; null,
            'debug' =&gt; false,
            'generator_class' =&gt; CompiledUrlGenerator::class,
            'generator_dumper_class' =&gt; CompiledUrlGeneratorDumper::class,
            'matcher_class' =&gt; CompiledUrlMatcher::class,
            'matcher_dumper_class' =&gt; CompiledUrlMatcherDumper::class,
            'resource_type' =&gt; null,
            'strict_requirements' =&gt; true,
        ];

        // check option names and live merge, if errors are encountered Exception will be thrown
        $invalid = [];
        foreach ($options as $key =&gt; $value) {
            if (\array_key_exists($key, $this-&gt;options)) {
                $this-&gt;options[$key] = $value;
            } else {
                $invalid[] = $key;
            }
        }

        if ($invalid) {
            throw new \InvalidArgumentException(sprintf('The Router does not support the following options: &quot;%s&quot;.', implode('&quot;, &quot;', $invalid)));
        }
    }

    /**
     * Sets an option.
     *
     * @param mixed $value The value
     *
     * @throws \InvalidArgumentException
     */
    public function setOption(string $key, $value)
    {
        if (!\array_key_exists($key, $this-&gt;options)) {
            throw new \InvalidArgumentException(sprintf('The Router does not support the &quot;%s&quot; option.', $key));
        }

        $this-&gt;options[$key] = $value;
    }

    /**
     * Gets an option value.
     *
     * @return mixed
     *
     * @throws \InvalidArgumentException
     */
    public function getOption(string $key)
    {
        if (!\array_key_exists($key, $this-&gt;options)) {
            throw new \InvalidArgumentException(sprintf('The Router does not support the &quot;%s&quot; option.', $key));
        }

        return $this-&gt;options[$key];
    }

    /**
     * {@inheritdoc}
     */
    public function getRouteCollection()
    {
        if (null === $this-&gt;collection) {
            $this-&gt;collection = $this-&gt;loader-&gt;load($this-&gt;resource, $this-&gt;options['resource_type']);
        }

        return $this-&gt;collection;
    }

    /**
     * {@inheritdoc}
     */
    public function setContext(RequestContext $context)
    {
        $this-&gt;context = $context;

        if (null !== $this-&gt;matcher) {
            $this-&gt;getMatcher()-&gt;setContext($context);
        }
        if (null !== $this-&gt;generator) {
            $this-&gt;getGenerator()-&gt;setContext($context);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function getContext()
    {
        return $this-&gt;context;
    }

    /**
     * Sets the ConfigCache factory to use.
     */
    public function setConfigCacheFactory(ConfigCacheFactoryInterface $configCacheFactory)
    {
        $this-&gt;configCacheFactory = $configCacheFactory;
    }

    /**
     * {@inheritdoc}
     */
    public function generate(string $name, array $parameters = [], int $referenceType = self::ABSOLUTE_PATH)
    {
        return $this-&gt;getGenerator()-&gt;generate($name, $parameters, $referenceType);
    }

    /**
     * {@inheritdoc}
     */
    public function match(string $pathinfo)
    {
        return $this-&gt;getMatcher()-&gt;match($pathinfo);
    }

    /**
     * {@inheritdoc}
     */
    public function matchRequest(Request $request)
    {
        $matcher = $this-&gt;getMatcher();
        if (!$matcher instanceof RequestMatcherInterface) {
            // fallback to the default UrlMatcherInterface
            return $matcher-&gt;match($request-&gt;getPathInfo());
        }

        return $matcher-&gt;matchRequest($request);
    }

    /**
     * Gets the UrlMatcher or RequestMatcher instance associated with this Router.
     *
     * @return UrlMatcherInterface|RequestMatcherInterface
     */
    public function getMatcher()
    {
        if (null !== $this-&gt;matcher) {
            return $this-&gt;matcher;
        }

        if (null === $this-&gt;options['cache_dir']) {
            $routes = $this-&gt;getRouteCollection();
            $compiled = is_a($this-&gt;options['matcher_class'], CompiledUrlMatcher::class, true);
            if ($compiled) {
                $routes = (new CompiledUrlMatcherDumper($routes))-&gt;getCompiledRoutes();
            }
            $this-&gt;matcher = new $this-&gt;options['matcher_class']($routes, $this-&gt;context);
            if (method_exists($this-&gt;matcher, 'addExpressionLanguageProvider')) {
                foreach ($this-&gt;expressionLanguageProviders as $provider) {
                    $this-&gt;matcher-&gt;addExpressionLanguageProvider($provider);
                }
            }

            return $this-&gt;matcher;
        }

        $cache = $this-&gt;getConfigCacheFactory()-&gt;cache($this-&gt;options['cache_dir'].'/url_matching_routes.php',
            function (ConfigCacheInterface $cache) {
                $dumper = $this-&gt;getMatcherDumperInstance();
                if (method_exists($dumper, 'addExpressionLanguageProvider')) {
                    foreach ($this-&gt;expressionLanguageProviders as $provider) {
                        $dumper-&gt;addExpressionLanguageProvider($provider);
                    }
                }

                $cache-&gt;write($dumper-&gt;dump(), $this-&gt;getRouteCollection()-&gt;getResources());
                unset(self::$cache[$cache-&gt;getPath()]);
            }
        );

        return $this-&gt;matcher = new $this-&gt;options['matcher_class'](self::getCompiledRoutes($cache-&gt;getPath()), $this-&gt;context);
    }

    /**
     * Gets the UrlGenerator instance associated with this Router.
     *
     * @return UrlGeneratorInterface
     */
    public function getGenerator()
    {
        if (null !== $this-&gt;generator) {
            return $this-&gt;generator;
        }

        if (null === $this-&gt;options['cache_dir']) {
            $routes = $this-&gt;getRouteCollection();
            $compiled = is_a($this-&gt;options['generator_class'], CompiledUrlGenerator::class, true);
            if ($compiled) {
                $generatorDumper = new CompiledUrlGeneratorDumper($routes);
                $routes = array_merge($generatorDumper-&gt;getCompiledRoutes(), $generatorDumper-&gt;getCompiledAliases());
            }
            $this-&gt;generator = new $this-&gt;options['generator_class']($routes, $this-&gt;context, $this-&gt;logger, $this-&gt;defaultLocale);
        } else {
            $cache = $this-&gt;getConfigCacheFactory()-&gt;cache($this-&gt;options['cache_dir'].'/url_generating_routes.php',
                function (ConfigCacheInterface $cache) {
                    $dumper = $this-&gt;getGeneratorDumperInstance();

                    $cache-&gt;write($dumper-&gt;dump(), $this-&gt;getRouteCollection()-&gt;getResources());
                    unset(self::$cache[$cache-&gt;getPath()]);
                }
            );

            $this-&gt;generator = new $this-&gt;options['generator_class'](self::getCompiledRoutes($cache-&gt;getPath()), $this-&gt;context, $this-&gt;logger, $this-&gt;defaultLocale);
        }

        if ($this-&gt;generator instanceof ConfigurableRequirementsInterface) {
            $this-&gt;generator-&gt;setStrictRequirements($this-&gt;options['strict_requirements']);
        }

        return $this-&gt;generator;
    }

    public function addExpressionLanguageProvider(ExpressionFunctionProviderInterface $provider)
    {
        $this-&gt;expressionLanguageProviders[] = $provider;
    }

    /**
     * @return GeneratorDumperInterface
     */
    protected function getGeneratorDumperInstance()
    {
        return new $this-&gt;options['generator_dumper_class']($this-&gt;getRouteCollection());
    }

    /**
     * @return MatcherDumperInterface
     */
    protected function getMatcherDumperInstance()
    {
        return new $this-&gt;options['matcher_dumper_class']($this-&gt;getRouteCollection());
    }

    /**
     * Provides the ConfigCache factory implementation, falling back to a
     * default implementation if necessary.
     */
    private function getConfigCacheFactory(): ConfigCacheFactoryInterface
    {
        if (null === $this-&gt;configCacheFactory) {
            $this-&gt;configCacheFactory = new ConfigCacheFactory($this-&gt;options['debug']);
        }

        return $this-&gt;configCacheFactory;
    }

    private static function getCompiledRoutes(string $path): array
    {
        if ([] === self::$cache &amp;&amp; \function_exists('opcache_invalidate') &amp;&amp; filter_var(\ini_get('opcache.enable'), \FILTER_VALIDATE_BOOLEAN) &amp;&amp; (!\in_array(\PHP_SAPI, ['cli', 'phpdbg'], true) || filter_var(\ini_get('opcache.enable_cli'), \FILTER_VALIDATE_BOOLEAN))) {
            self::$cache = null;
        }

        if (null === self::$cache) {
            return require $path;
        }

        if (isset(self::$cache[$path])) {
            return self::$cache[$path];
        }

        return self::$cache[$path] = require $path;
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>