2010-02-17 13:53:31 +00:00
|
|
|
<?php
|
|
|
|
|
|
|
|
/*
|
2011-01-15 13:29:43 +00:00
|
|
|
* This file is part of the Symfony package.
|
2010-02-17 13:53:31 +00:00
|
|
|
*
|
2011-03-06 11:40:06 +00:00
|
|
|
* (c) Fabien Potencier <fabien@symfony.com>
|
2010-02-17 13:53:31 +00:00
|
|
|
*
|
2011-01-15 13:29:43 +00:00
|
|
|
* For the full copyright and license information, please view the LICENSE
|
|
|
|
* file that was distributed with this source code.
|
2010-02-17 13:53:31 +00:00
|
|
|
*/
|
|
|
|
|
2011-01-15 13:29:43 +00:00
|
|
|
namespace Symfony\Component\Routing;
|
|
|
|
|
2010-02-17 13:53:31 +00:00
|
|
|
/**
|
|
|
|
* A Route describes a route and its parameters.
|
|
|
|
*
|
2011-03-06 11:40:06 +00:00
|
|
|
* @author Fabien Potencier <fabien@symfony.com>
|
2012-11-13 22:39:53 +00:00
|
|
|
* @author Tobias Schultze <http://tobion.de>
|
2011-06-14 14:35:32 +01:00
|
|
|
*
|
|
|
|
* @api
|
2010-02-17 13:53:31 +00:00
|
|
|
*/
|
2012-07-04 21:40:53 +01:00
|
|
|
class Route implements \Serializable
|
2010-02-17 13:53:31 +00:00
|
|
|
{
|
2012-11-12 15:14:50 +00:00
|
|
|
/**
|
|
|
|
* @var string
|
|
|
|
*/
|
2013-01-14 16:36:16 +00:00
|
|
|
private $path = '/';
|
2012-11-12 15:14:50 +00:00
|
|
|
|
2012-11-13 23:25:56 +00:00
|
|
|
/**
|
|
|
|
* @var string
|
|
|
|
*/
|
2013-01-21 16:57:28 +00:00
|
|
|
private $host = '';
|
2012-11-13 23:25:56 +00:00
|
|
|
|
2012-11-13 22:39:53 +00:00
|
|
|
/**
|
|
|
|
* @var array
|
|
|
|
*/
|
|
|
|
private $schemes = array();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @var array
|
|
|
|
*/
|
|
|
|
private $methods = array();
|
|
|
|
|
|
|
|
/**
|
2012-11-12 15:14:50 +00:00
|
|
|
* @var array
|
|
|
|
*/
|
|
|
|
private $defaults = array();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @var array
|
|
|
|
*/
|
|
|
|
private $requirements = array();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @var array
|
|
|
|
*/
|
|
|
|
private $options = array();
|
|
|
|
|
|
|
|
/**
|
2013-08-23 15:06:02 +01:00
|
|
|
* @var null|CompiledRoute
|
2012-11-12 15:14:50 +00:00
|
|
|
*/
|
2011-03-23 18:24:18 +00:00
|
|
|
private $compiled;
|
2012-11-12 15:14:50 +00:00
|
|
|
|
2013-09-04 08:25:51 +01:00
|
|
|
private $condition;
|
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
/**
|
|
|
|
* Constructor.
|
|
|
|
*
|
|
|
|
* Available options:
|
|
|
|
*
|
2011-04-25 11:03:41 +01:00
|
|
|
* * compiler_class: A class name able to compile this route instance (RouteCompiler by default)
|
2010-05-06 12:25:53 +01:00
|
|
|
*
|
2013-01-14 16:36:16 +00:00
|
|
|
* @param string $path The path pattern to match
|
2013-01-14 16:14:02 +00:00
|
|
|
* @param array $defaults An array of default parameter values
|
|
|
|
* @param array $requirements An array of requirements for parameters (regexes)
|
|
|
|
* @param array $options An array of options
|
2013-01-21 16:57:28 +00:00
|
|
|
* @param string $host The host pattern to match
|
2013-01-14 16:14:02 +00:00
|
|
|
* @param string|array $schemes A required URI scheme or an array of restricted schemes
|
|
|
|
* @param string|array $methods A required HTTP method or an array of restricted methods
|
2013-09-04 08:25:51 +01:00
|
|
|
* @param string $condition A condition that should evaluate to true for the route to match
|
2011-06-14 14:35:32 +01:00
|
|
|
*
|
|
|
|
* @api
|
2010-05-06 12:25:53 +01:00
|
|
|
*/
|
2013-09-04 08:25:51 +01:00
|
|
|
public function __construct($path, array $defaults = array(), array $requirements = array(), array $options = array(), $host = '', $schemes = array(), $methods = array(), $condition = null)
|
2010-02-17 13:53:31 +00:00
|
|
|
{
|
2013-01-14 16:36:16 +00:00
|
|
|
$this->setPath($path);
|
2010-05-06 12:25:53 +01:00
|
|
|
$this->setDefaults($defaults);
|
|
|
|
$this->setRequirements($requirements);
|
|
|
|
$this->setOptions($options);
|
2013-01-21 16:57:28 +00:00
|
|
|
$this->setHost($host);
|
2012-11-13 22:39:53 +00:00
|
|
|
// The conditions make sure that an initial empty $schemes/$methods does not override the corresponding requirement.
|
|
|
|
// They can be removed when the BC layer is removed.
|
|
|
|
if ($schemes) {
|
|
|
|
$this->setSchemes($schemes);
|
|
|
|
}
|
|
|
|
if ($methods) {
|
|
|
|
$this->setMethods($methods);
|
|
|
|
}
|
2013-09-04 08:25:51 +01:00
|
|
|
$this->setCondition($condition);
|
2010-02-17 13:53:31 +00:00
|
|
|
}
|
|
|
|
|
2012-07-04 21:40:53 +01:00
|
|
|
public function serialize()
|
|
|
|
{
|
|
|
|
return serialize(array(
|
2013-01-14 16:36:16 +00:00
|
|
|
'path' => $this->path,
|
2013-01-21 16:57:28 +00:00
|
|
|
'host' => $this->host,
|
2013-01-14 16:14:02 +00:00
|
|
|
'defaults' => $this->defaults,
|
2012-07-04 21:40:53 +01:00
|
|
|
'requirements' => $this->requirements,
|
2013-01-14 16:14:02 +00:00
|
|
|
'options' => $this->options,
|
|
|
|
'schemes' => $this->schemes,
|
|
|
|
'methods' => $this->methods,
|
2013-09-04 08:25:51 +01:00
|
|
|
'condition' => $this->condition,
|
2012-07-04 21:40:53 +01:00
|
|
|
));
|
|
|
|
}
|
|
|
|
|
|
|
|
public function unserialize($data)
|
|
|
|
{
|
|
|
|
$data = unserialize($data);
|
2013-01-14 16:36:16 +00:00
|
|
|
$this->path = $data['path'];
|
2013-01-21 16:57:28 +00:00
|
|
|
$this->host = $data['host'];
|
2012-07-19 15:39:03 +01:00
|
|
|
$this->defaults = $data['defaults'];
|
2012-07-04 21:40:53 +01:00
|
|
|
$this->requirements = $data['requirements'];
|
|
|
|
$this->options = $data['options'];
|
2012-11-13 22:39:53 +00:00
|
|
|
$this->schemes = $data['schemes'];
|
|
|
|
$this->methods = $data['methods'];
|
2013-09-04 08:25:51 +01:00
|
|
|
$this->condition = $data['condition'];
|
2012-07-04 21:40:53 +01:00
|
|
|
}
|
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
/**
|
2012-11-12 17:00:02 +00:00
|
|
|
* Returns the pattern for the path.
|
2010-05-06 12:25:53 +01:00
|
|
|
*
|
|
|
|
* @return string The pattern
|
2013-01-14 16:36:16 +00:00
|
|
|
*
|
2013-01-15 17:01:40 +00:00
|
|
|
* @deprecated Deprecated in 2.2, to be removed in 3.0. Use getPath instead.
|
2010-05-06 12:25:53 +01:00
|
|
|
*/
|
|
|
|
public function getPattern()
|
2010-02-17 13:53:31 +00:00
|
|
|
{
|
2013-01-14 16:36:16 +00:00
|
|
|
return $this->path;
|
2010-05-06 12:25:53 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2012-11-12 17:00:02 +00:00
|
|
|
* Sets the pattern for the path.
|
2010-05-06 12:25:53 +01:00
|
|
|
*
|
|
|
|
* This method implements a fluent interface.
|
|
|
|
*
|
2013-01-15 17:01:40 +00:00
|
|
|
* @param string $pattern The path pattern
|
2010-05-06 12:25:53 +01:00
|
|
|
*
|
|
|
|
* @return Route The current Route instance
|
2013-01-14 16:36:16 +00:00
|
|
|
*
|
|
|
|
* @deprecated Deprecated in 2.2, to be removed in 3.0. Use setPath instead.
|
2010-05-06 12:25:53 +01:00
|
|
|
*/
|
|
|
|
public function setPattern($pattern)
|
2013-01-14 16:36:16 +00:00
|
|
|
{
|
|
|
|
return $this->setPath($pattern);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns the pattern for the path.
|
|
|
|
*
|
|
|
|
* @return string The path pattern
|
|
|
|
*/
|
|
|
|
public function getPath()
|
|
|
|
{
|
|
|
|
return $this->path;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Sets the pattern for the path.
|
|
|
|
*
|
|
|
|
* This method implements a fluent interface.
|
|
|
|
*
|
2013-01-15 17:01:40 +00:00
|
|
|
* @param string $pattern The path pattern
|
2013-01-14 16:36:16 +00:00
|
|
|
*
|
|
|
|
* @return Route The current Route instance
|
|
|
|
*/
|
2013-01-15 17:01:40 +00:00
|
|
|
public function setPath($pattern)
|
2010-05-06 12:25:53 +01:00
|
|
|
{
|
2012-10-06 00:20:12 +01:00
|
|
|
// 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'.
|
2013-04-02 10:39:57 +01:00
|
|
|
$this->path = '/'.ltrim(trim($pattern), '/');
|
2012-04-01 11:32:28 +01:00
|
|
|
$this->compiled = null;
|
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
return $this;
|
|
|
|
}
|
2010-02-17 13:53:31 +00:00
|
|
|
|
2012-11-05 19:53:57 +00:00
|
|
|
/**
|
2013-01-21 16:57:28 +00:00
|
|
|
* Returns the pattern for the host.
|
2012-11-05 19:53:57 +00:00
|
|
|
*
|
2013-01-21 16:57:28 +00:00
|
|
|
* @return string The host pattern
|
2012-11-05 19:53:57 +00:00
|
|
|
*/
|
2013-01-21 16:57:28 +00:00
|
|
|
public function getHost()
|
2012-04-14 18:13:54 +01:00
|
|
|
{
|
2013-01-21 16:57:28 +00:00
|
|
|
return $this->host;
|
2012-04-14 18:13:54 +01:00
|
|
|
}
|
|
|
|
|
2012-11-05 19:53:57 +00:00
|
|
|
/**
|
2013-01-21 16:57:28 +00:00
|
|
|
* Sets the pattern for the host.
|
2013-01-15 17:01:40 +00:00
|
|
|
*
|
|
|
|
* This method implements a fluent interface.
|
2012-11-05 19:53:57 +00:00
|
|
|
*
|
2013-01-21 16:57:28 +00:00
|
|
|
* @param string $pattern The host pattern
|
2012-12-14 10:40:56 +00:00
|
|
|
*
|
|
|
|
* @return Route The current Route instance
|
2012-11-05 19:53:57 +00:00
|
|
|
*/
|
2013-01-21 16:57:28 +00:00
|
|
|
public function setHost($pattern)
|
2012-04-14 18:13:54 +01:00
|
|
|
{
|
2013-01-21 16:57:28 +00:00
|
|
|
$this->host = (string) $pattern;
|
2012-11-19 00:12:13 +00:00
|
|
|
$this->compiled = null;
|
2012-04-14 18:13:54 +01:00
|
|
|
|
|
|
|
return $this;
|
|
|
|
}
|
|
|
|
|
2012-11-13 22:39:53 +00:00
|
|
|
/**
|
|
|
|
* Returns the lowercased schemes this route is restricted to.
|
|
|
|
* So an empty array means that any scheme is allowed.
|
|
|
|
*
|
|
|
|
* @return array The schemes
|
|
|
|
*/
|
|
|
|
public function getSchemes()
|
|
|
|
{
|
|
|
|
return $this->schemes;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Sets the schemes (e.g. 'https') this route is restricted to.
|
|
|
|
* So an empty array means that any scheme is allowed.
|
|
|
|
*
|
|
|
|
* This method implements a fluent interface.
|
|
|
|
*
|
|
|
|
* @param string|array $schemes The scheme or an array of schemes
|
|
|
|
*
|
|
|
|
* @return Route The current Route instance
|
|
|
|
*/
|
|
|
|
public function setSchemes($schemes)
|
|
|
|
{
|
|
|
|
$this->schemes = array_map('strtolower', (array) $schemes);
|
|
|
|
|
|
|
|
// this is to keep BC and will be removed in a future version
|
|
|
|
if ($this->schemes) {
|
|
|
|
$this->requirements['_scheme'] = implode('|', $this->schemes);
|
|
|
|
} else {
|
|
|
|
unset($this->requirements['_scheme']);
|
|
|
|
}
|
|
|
|
|
|
|
|
$this->compiled = null;
|
|
|
|
|
|
|
|
return $this;
|
|
|
|
}
|
|
|
|
|
2013-11-22 23:07:07 +00:00
|
|
|
/**
|
|
|
|
* Checks if a scheme requirement has been set.
|
|
|
|
*
|
|
|
|
* @param string $scheme
|
|
|
|
*
|
2014-04-16 11:36:34 +01:00
|
|
|
* @return bool true if the scheme requirement exists, otherwise false
|
2013-11-22 23:07:07 +00:00
|
|
|
*/
|
|
|
|
public function hasScheme($scheme)
|
|
|
|
{
|
|
|
|
$scheme = strtolower($scheme);
|
|
|
|
foreach ($this->schemes as $requiredScheme) {
|
|
|
|
if ($scheme === $requiredScheme) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2012-11-13 22:39:53 +00:00
|
|
|
/**
|
|
|
|
* Returns the uppercased HTTP methods this route is restricted to.
|
|
|
|
* So an empty array means that any method is allowed.
|
|
|
|
*
|
|
|
|
* @return array The schemes
|
|
|
|
*/
|
|
|
|
public function getMethods()
|
|
|
|
{
|
|
|
|
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.
|
|
|
|
*
|
|
|
|
* This method implements a fluent interface.
|
|
|
|
*
|
|
|
|
* @param string|array $methods The method or an array of methods
|
|
|
|
*
|
|
|
|
* @return Route The current Route instance
|
|
|
|
*/
|
|
|
|
public function setMethods($methods)
|
|
|
|
{
|
|
|
|
$this->methods = array_map('strtoupper', (array) $methods);
|
|
|
|
|
|
|
|
// this is to keep BC and will be removed in a future version
|
|
|
|
if ($this->methods) {
|
|
|
|
$this->requirements['_method'] = implode('|', $this->methods);
|
|
|
|
} else {
|
|
|
|
unset($this->requirements['_method']);
|
|
|
|
}
|
|
|
|
|
2012-11-19 00:12:13 +00:00
|
|
|
$this->compiled = null;
|
2012-04-14 18:13:54 +01:00
|
|
|
|
|
|
|
return $this;
|
|
|
|
}
|
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
/**
|
|
|
|
* Returns the options.
|
|
|
|
*
|
|
|
|
* @return array The options
|
|
|
|
*/
|
|
|
|
public function getOptions()
|
|
|
|
{
|
|
|
|
return $this->options;
|
2010-02-17 13:53:31 +00:00
|
|
|
}
|
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
/**
|
|
|
|
* Sets the options.
|
|
|
|
*
|
|
|
|
* This method implements a fluent interface.
|
|
|
|
*
|
2010-07-01 19:17:03 +01:00
|
|
|
* @param array $options The options
|
2010-05-06 12:25:53 +01:00
|
|
|
*
|
|
|
|
* @return Route The current Route instance
|
|
|
|
*/
|
|
|
|
public function setOptions(array $options)
|
2010-02-17 13:53:31 +00:00
|
|
|
{
|
2012-04-04 02:35:48 +01:00
|
|
|
$this->options = array(
|
2011-05-13 17:17:57 +01:00
|
|
|
'compiler_class' => 'Symfony\\Component\\Routing\\RouteCompiler',
|
2012-04-04 02:35:48 +01:00
|
|
|
);
|
|
|
|
|
|
|
|
return $this->addOptions($options);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Adds options.
|
|
|
|
*
|
|
|
|
* This method implements a fluent interface.
|
|
|
|
*
|
|
|
|
* @param array $options The options
|
|
|
|
*
|
|
|
|
* @return Route The current Route instance
|
|
|
|
*/
|
|
|
|
public function addOptions(array $options)
|
|
|
|
{
|
|
|
|
foreach ($options as $name => $option) {
|
2012-11-12 16:54:27 +00:00
|
|
|
$this->options[$name] = $option;
|
2012-04-04 02:35:48 +01:00
|
|
|
}
|
2012-04-01 11:32:28 +01:00
|
|
|
$this->compiled = null;
|
2010-05-06 12:25:53 +01:00
|
|
|
|
|
|
|
return $this;
|
2010-02-17 13:53:31 +00:00
|
|
|
}
|
|
|
|
|
2011-05-13 17:17:57 +01:00
|
|
|
/**
|
|
|
|
* Sets an option value.
|
|
|
|
*
|
|
|
|
* This method implements a fluent interface.
|
|
|
|
*
|
|
|
|
* @param string $name An option name
|
|
|
|
* @param mixed $value The option value
|
|
|
|
*
|
|
|
|
* @return Route The current Route instance
|
2011-06-14 14:35:32 +01:00
|
|
|
*
|
|
|
|
* @api
|
2011-05-13 17:17:57 +01:00
|
|
|
*/
|
|
|
|
public function setOption($name, $value)
|
|
|
|
{
|
|
|
|
$this->options[$name] = $value;
|
2012-04-01 11:32:28 +01:00
|
|
|
$this->compiled = null;
|
2011-05-13 17:17:57 +01:00
|
|
|
|
|
|
|
return $this;
|
|
|
|
}
|
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
/**
|
|
|
|
* Get an option value.
|
|
|
|
*
|
|
|
|
* @param string $name An option name
|
|
|
|
*
|
2012-09-04 05:31:46 +01:00
|
|
|
* @return mixed The option value or null when not given
|
2010-05-06 12:25:53 +01:00
|
|
|
*/
|
|
|
|
public function getOption($name)
|
|
|
|
{
|
|
|
|
return isset($this->options[$name]) ? $this->options[$name] : null;
|
|
|
|
}
|
|
|
|
|
2012-11-23 05:22:12 +00:00
|
|
|
/**
|
2013-04-21 14:23:54 +01:00
|
|
|
* Checks if an option has been set
|
2012-11-23 05:22:12 +00:00
|
|
|
*
|
|
|
|
* @param string $name An option name
|
|
|
|
*
|
2014-04-16 11:30:19 +01:00
|
|
|
* @return bool true if the option is set, false otherwise
|
2012-11-23 05:22:12 +00:00
|
|
|
*/
|
|
|
|
public function hasOption($name)
|
|
|
|
{
|
|
|
|
return array_key_exists($name, $this->options);
|
|
|
|
}
|
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
/**
|
|
|
|
* Returns the defaults.
|
|
|
|
*
|
|
|
|
* @return array The defaults
|
|
|
|
*/
|
|
|
|
public function getDefaults()
|
|
|
|
{
|
|
|
|
return $this->defaults;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Sets the defaults.
|
|
|
|
*
|
|
|
|
* This method implements a fluent interface.
|
|
|
|
*
|
2010-07-01 19:17:03 +01:00
|
|
|
* @param array $defaults The defaults
|
2010-05-06 12:25:53 +01:00
|
|
|
*
|
|
|
|
* @return Route The current Route instance
|
|
|
|
*/
|
|
|
|
public function setDefaults(array $defaults)
|
|
|
|
{
|
2011-07-17 16:29:41 +01:00
|
|
|
$this->defaults = array();
|
2011-10-23 10:56:23 +01:00
|
|
|
|
|
|
|
return $this->addDefaults($defaults);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Adds defaults.
|
|
|
|
*
|
|
|
|
* This method implements a fluent interface.
|
|
|
|
*
|
|
|
|
* @param array $defaults The defaults
|
|
|
|
*
|
|
|
|
* @return Route The current Route instance
|
|
|
|
*/
|
|
|
|
public function addDefaults(array $defaults)
|
|
|
|
{
|
2011-07-17 16:29:41 +01:00
|
|
|
foreach ($defaults as $name => $default) {
|
2012-11-12 16:54:27 +00:00
|
|
|
$this->defaults[$name] = $default;
|
2011-07-17 16:29:41 +01:00
|
|
|
}
|
2012-04-01 11:32:28 +01:00
|
|
|
$this->compiled = null;
|
2010-05-06 12:25:53 +01:00
|
|
|
|
|
|
|
return $this;
|
|
|
|
}
|
2010-02-17 13:53:31 +00:00
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
/**
|
2010-08-09 14:05:54 +01:00
|
|
|
* Gets a default value.
|
2010-05-06 12:25:53 +01:00
|
|
|
*
|
|
|
|
* @param string $name A variable name
|
|
|
|
*
|
2012-09-04 05:31:46 +01:00
|
|
|
* @return mixed The default value or null when not given
|
2010-05-06 12:25:53 +01:00
|
|
|
*/
|
|
|
|
public function getDefault($name)
|
2010-02-17 13:53:31 +00:00
|
|
|
{
|
2010-05-06 12:25:53 +01:00
|
|
|
return isset($this->defaults[$name]) ? $this->defaults[$name] : null;
|
2010-02-17 13:53:31 +00:00
|
|
|
}
|
|
|
|
|
2011-04-15 11:04:48 +01:00
|
|
|
/**
|
|
|
|
* Checks if a default value is set for the given variable.
|
|
|
|
*
|
|
|
|
* @param string $name A variable name
|
|
|
|
*
|
2014-04-16 11:30:19 +01:00
|
|
|
* @return bool true if the default value is set, false otherwise
|
2011-04-15 11:04:48 +01:00
|
|
|
*/
|
|
|
|
public function hasDefault($name)
|
|
|
|
{
|
|
|
|
return array_key_exists($name, $this->defaults);
|
|
|
|
}
|
|
|
|
|
2010-08-09 14:05:54 +01:00
|
|
|
/**
|
|
|
|
* Sets a default value.
|
|
|
|
*
|
|
|
|
* @param string $name A variable name
|
|
|
|
* @param mixed $default The default value
|
2011-05-13 17:40:40 +01:00
|
|
|
*
|
|
|
|
* @return Route The current Route instance
|
2011-06-14 14:35:32 +01:00
|
|
|
*
|
|
|
|
* @api
|
2010-08-09 14:05:54 +01:00
|
|
|
*/
|
|
|
|
public function setDefault($name, $default)
|
|
|
|
{
|
2012-11-12 16:54:27 +00:00
|
|
|
$this->defaults[$name] = $default;
|
2012-04-01 11:32:28 +01:00
|
|
|
$this->compiled = null;
|
2011-05-13 17:40:40 +01:00
|
|
|
|
|
|
|
return $this;
|
2010-08-09 14:05:54 +01:00
|
|
|
}
|
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
/**
|
|
|
|
* Returns the requirements.
|
|
|
|
*
|
|
|
|
* @return array The requirements
|
|
|
|
*/
|
|
|
|
public function getRequirements()
|
|
|
|
{
|
|
|
|
return $this->requirements;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Sets the requirements.
|
|
|
|
*
|
|
|
|
* This method implements a fluent interface.
|
|
|
|
*
|
2010-07-01 19:17:03 +01:00
|
|
|
* @param array $requirements The requirements
|
2010-05-06 12:25:53 +01:00
|
|
|
*
|
|
|
|
* @return Route The current Route instance
|
|
|
|
*/
|
|
|
|
public function setRequirements(array $requirements)
|
|
|
|
{
|
|
|
|
$this->requirements = array();
|
2011-10-23 10:56:23 +01:00
|
|
|
|
|
|
|
return $this->addRequirements($requirements);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Adds requirements.
|
|
|
|
*
|
|
|
|
* This method implements a fluent interface.
|
|
|
|
*
|
|
|
|
* @param array $requirements The requirements
|
|
|
|
*
|
|
|
|
* @return Route The current Route instance
|
|
|
|
*/
|
|
|
|
public function addRequirements(array $requirements)
|
|
|
|
{
|
2010-05-07 15:09:11 +01:00
|
|
|
foreach ($requirements as $key => $regex) {
|
2010-11-30 13:00:36 +00:00
|
|
|
$this->requirements[$key] = $this->sanitizeRequirement($key, $regex);
|
2010-05-06 12:25:53 +01:00
|
|
|
}
|
2012-04-01 11:32:28 +01:00
|
|
|
$this->compiled = null;
|
2010-05-06 12:25:53 +01:00
|
|
|
|
|
|
|
return $this;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns the requirement for the given key.
|
|
|
|
*
|
2011-04-23 16:05:44 +01:00
|
|
|
* @param string $key The key
|
2011-12-13 07:50:54 +00:00
|
|
|
*
|
2012-09-04 05:31:46 +01:00
|
|
|
* @return string|null The regex or null when not given
|
2010-05-06 12:25:53 +01:00
|
|
|
*/
|
|
|
|
public function getRequirement($key)
|
|
|
|
{
|
|
|
|
return isset($this->requirements[$key]) ? $this->requirements[$key] : null;
|
|
|
|
}
|
|
|
|
|
2012-11-23 05:22:12 +00:00
|
|
|
/**
|
|
|
|
* Checks if a requirement is set for the given key.
|
|
|
|
*
|
2012-12-14 22:27:02 +00:00
|
|
|
* @param string $key A variable name
|
2012-11-23 05:22:12 +00:00
|
|
|
*
|
2014-04-16 11:30:19 +01:00
|
|
|
* @return bool true if a requirement is specified, false otherwise
|
2012-11-23 05:22:12 +00:00
|
|
|
*/
|
|
|
|
public function hasRequirement($key)
|
|
|
|
{
|
|
|
|
return array_key_exists($key, $this->requirements);
|
|
|
|
}
|
|
|
|
|
2010-11-30 13:00:36 +00:00
|
|
|
/**
|
|
|
|
* Sets a requirement for the given key.
|
|
|
|
*
|
2012-05-15 21:19:31 +01:00
|
|
|
* @param string $key The key
|
2011-04-23 16:05:44 +01:00
|
|
|
* @param string $regex The regex
|
2011-05-13 17:40:40 +01:00
|
|
|
*
|
|
|
|
* @return Route The current Route instance
|
2011-06-14 14:35:32 +01:00
|
|
|
*
|
|
|
|
* @api
|
2010-11-30 13:00:36 +00:00
|
|
|
*/
|
|
|
|
public function setRequirement($key, $regex)
|
|
|
|
{
|
2011-05-13 17:40:40 +01:00
|
|
|
$this->requirements[$key] = $this->sanitizeRequirement($key, $regex);
|
2012-04-01 11:32:28 +01:00
|
|
|
$this->compiled = null;
|
2011-05-13 17:40:40 +01:00
|
|
|
|
|
|
|
return $this;
|
2010-11-30 13:00:36 +00:00
|
|
|
}
|
|
|
|
|
2013-09-04 08:25:51 +01:00
|
|
|
/**
|
|
|
|
* Returns the condition.
|
|
|
|
*
|
|
|
|
* @return string The condition
|
|
|
|
*/
|
|
|
|
public function getCondition()
|
|
|
|
{
|
|
|
|
return $this->condition;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Sets the condition.
|
|
|
|
*
|
|
|
|
* This method implements a fluent interface.
|
|
|
|
*
|
|
|
|
* @param string $condition The condition
|
|
|
|
*
|
|
|
|
* @return Route The current Route instance
|
|
|
|
*/
|
|
|
|
public function setCondition($condition)
|
|
|
|
{
|
|
|
|
$this->condition = (string) $condition;
|
|
|
|
$this->compiled = null;
|
|
|
|
|
|
|
|
return $this;
|
|
|
|
}
|
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
/**
|
|
|
|
* Compiles the route.
|
|
|
|
*
|
|
|
|
* @return CompiledRoute A CompiledRoute instance
|
2012-09-04 05:31:46 +01:00
|
|
|
*
|
2012-12-27 03:11:08 +00:00
|
|
|
* @throws \LogicException If the Route cannot be compiled because the
|
2013-01-21 16:57:28 +00:00
|
|
|
* path or host pattern is invalid
|
2012-12-27 03:11:08 +00:00
|
|
|
*
|
2012-09-04 05:31:46 +01:00
|
|
|
* @see RouteCompiler which is responsible for the compilation process
|
2010-05-06 12:25:53 +01:00
|
|
|
*/
|
|
|
|
public function compile()
|
|
|
|
{
|
2010-05-07 15:09:11 +01:00
|
|
|
if (null !== $this->compiled) {
|
2010-05-06 12:25:53 +01:00
|
|
|
return $this->compiled;
|
|
|
|
}
|
|
|
|
|
|
|
|
$class = $this->getOption('compiler_class');
|
|
|
|
|
2012-12-27 03:11:08 +00:00
|
|
|
return $this->compiled = $class::compile($this);
|
2010-05-06 12:25:53 +01:00
|
|
|
}
|
2010-11-30 13:00:36 +00:00
|
|
|
|
2011-03-23 18:24:18 +00:00
|
|
|
private function sanitizeRequirement($key, $regex)
|
2010-11-30 13:00:36 +00:00
|
|
|
{
|
2012-04-01 11:32:28 +01:00
|
|
|
if (!is_string($regex)) {
|
2012-09-04 05:31:46 +01:00
|
|
|
throw new \InvalidArgumentException(sprintf('Routing requirement for "%s" must be a string.', $key));
|
2010-11-30 13:00:36 +00:00
|
|
|
}
|
|
|
|
|
2012-09-04 05:31:46 +01:00
|
|
|
if ('' !== $regex && '^' === $regex[0]) {
|
|
|
|
$regex = (string) substr($regex, 1); // returns false for a single character
|
2010-11-30 13:00:36 +00:00
|
|
|
}
|
|
|
|
|
2012-04-01 11:32:28 +01:00
|
|
|
if ('$' === substr($regex, -1)) {
|
2010-11-30 13:00:36 +00:00
|
|
|
$regex = substr($regex, 0, -1);
|
|
|
|
}
|
|
|
|
|
2012-09-04 05:31:46 +01:00
|
|
|
if ('' === $regex) {
|
|
|
|
throw new \InvalidArgumentException(sprintf('Routing requirement for "%s" cannot be empty.', $key));
|
|
|
|
}
|
|
|
|
|
2012-11-13 22:39:53 +00:00
|
|
|
// this is to keep BC and will be removed in a future version
|
|
|
|
if ('_scheme' === $key) {
|
|
|
|
$this->setSchemes(explode('|', $regex));
|
|
|
|
} elseif ('_method' === $key) {
|
|
|
|
$this->setMethods(explode('|', $regex));
|
|
|
|
}
|
|
|
|
|
2010-11-30 13:00:36 +00:00
|
|
|
return $regex;
|
|
|
|
}
|
2010-02-17 13:53:31 +00:00
|
|
|
}
|