1. sfRequest.class.php
  2. /**
 * sfRequest provides methods for manipulating client request information such
 * as attributes, and parameters. It is also possible to manipulate the
 * request method originally sent by the user.
 *
 * @package    symfony
 * @subpackage request
 * @author     Fabien Potencier 
 * @author     Sean Kerr 
 * @version    SVN: $Id: sfRequest.class.php 23810 2009-11-12 11:07:44Z Kris.Wallsmith $
 */
  3. abstract class sfRequest implements ArrayAccess
  4. {
  5.   const GET    = 'GET';
  6.   const POST   = 'POST';
  7.   const PUT    = 'PUT';
  8.   const DELETE = 'DELETE';
  9.   const HEAD   = 'HEAD';
  11.   protected
  12.     $dispatcher      = null,
  13.     $content         = null,
  14.     $method          = null,
  15.     $options         = array(),
  16.     $parameterHolder = null,
  17.     $attributeHolder = null;
  19.   /**
  20.    * Class constructor.
  21.    *
  22.    * @see initialize()
  23.    */
  24.   public function __construct(sfEventDispatcher $dispatcher, $parameters = array(), $attributes = array(), $options = array())
  25.   {
  26.     $this->initialize($dispatcher, $parameters, $attributes, $options);
  27.   }
  29.   /**
  30.    * Initializes this sfRequest.
  31.    *
  32.    * Available options:
  33.    *
  34.    *  * logging: Whether to enable logging or not (false by default)
  35.    *
  36.    * @param  sfEventDispatcher $dispatcher  An sfEventDispatcher instance
  37.    * @param  array             $parameters  An associative array of initialization parameters
  38.    * @param  array             $attributes  An associative array of initialization attributes
  39.    * @param  array             $options     An associative array of options
  40.    *
  41.    * @return bool true, if initialization completes successfully, otherwise false
  42.    *
  43.    * @throws <b>sfInitializationException</b> If an error occurs while initializing this sfRequest
  44.    */
  45.   public function initialize(sfEventDispatcher $dispatcher, $parameters = array(), $attributes = array(), $options = array())
  46.   {
  47.     $this->dispatcher = $dispatcher;
  49.     $this->options = $options;
  51.     if (!isset($this->options['logging']))
  52.     {
  53.       $this->options['logging'] = false;
  54.     }
  56.     // initialize parameter and attribute holders
  57.     $this->parameterHolder = new sfParameterHolder();
  58.     $this->attributeHolder = new sfParameterHolder();
  60.     $this->parameterHolder->add($parameters);
  61.     $this->attributeHolder->add($attributes);
  62.   }
  64.   /**
  65.    * Returns the options.
  66.    *
  67.    * @return array The options.
  68.    */
  69.   public function getOptions()
  70.   {
  71.     return $this->options;
  72.   }
  74.   /**
  75.    * Extracts parameter values from the request.
  76.    *
  77.    * @param  array $names  An indexed array of parameter names to extract
  78.    *
  79.    * @return array An associative array of parameters and their values. If
  80.    *               a specified parameter doesn't exist an empty string will
  81.    *               be returned for its value
  82.    */
  83.   public function extractParameters($names)
  84.   {
  85.     $array = array();
  87.     $parameters = $this->parameterHolder->getAll();
  88.     foreach ($parameters as $key => $value)
  89.     {
  90.       if (in_array($key, $names))
  91.       {
  92.         $array[$key] = $value;
  93.       }
  94.     }
  96.     return $array;
  97.   }
  99.   /**
  100.    * Gets the request method.
  101.    *
  102.    * @return string The request method
  103.    */
  104.   public function getMethod()
  105.   {
  106.     return $this->method;
  107.   }
  109.   /**
  110.    * Sets the request method.
  111.    *
  112.    * @param string $method  The request method
  113.    *
  114.    * @throws <b>sfException</b> - If the specified request method is invalid
  115.    */
  116.   public function setMethod($method)
  117.   {
  118.     if (!in_array(strtoupper($method), array(self::GET, self::POST, self::PUT, self::DELETE, self::HEAD)))
  119.     {
  120.       throw new sfException(sprintf('Invalid request method: %s.', $method));
  121.     }
  123.     $this->method = strtoupper($method);
  124.   }
  126.   /**
  127.    * Returns true if the request parameter exists (implements the ArrayAccess interface).
  128.    *
  129.    * @param  string $name The name of the request parameter
  130.    *
  131.    * @return Boolean true if the request parameter exists, false otherwise
  132.    */
  133.   public function offsetExists($name)
  134.   {
  135.     return $this->hasParameter($name);
  136.   }
  138.   /**
  139.    * Returns the request parameter associated with the name (implements the ArrayAccess interface).
  140.    *
  141.    * @param  string $name  The offset of the value to get
  142.    *
  143.    * @return mixed The request parameter if exists, null otherwise
  144.    */
  145.   public function offsetGet($name)
  146.   {
  147.     return $this->getParameter($name, false);
  148.   }
  150.   /**
  151.    * Sets the request parameter associated with the offset (implements the ArrayAccess interface).
  152.    *
  153.    * @param string $offset The parameter name
  154.    * @param string $value The parameter value
  155.    */
  156.   public function offsetSet($offset, $value)
  157.   {
  158.     $this->setParameter($offset, $value);
  159.   }
  161.   /**
  162.    * Removes a request parameter.
  163.    *
  164.    * @param string $offset The parameter name
  165.    */
  166.   public function offsetUnset($offset)
  167.   {
  168.     $this->getParameterHolder()->remove($offset);
  169.   }
  171.   /**
  172.    * Retrieves the parameters for the current request.
  173.    *
  174.    * @return sfParameterHolder The parameter holder
  175.    */
  176.   public function getParameterHolder()
  177.   {
  178.     return $this->parameterHolder;
  179.   }
  181.   /**
  182.    * Retrieves the attributes holder.
  183.    *
  184.    * @return sfParameterHolder The attribute holder
  185.    */
  186.   public function getAttributeHolder()
  187.   {
  188.     return $this->attributeHolder;
  189.   }
  191.   /**
  192.    * Retrieves an attribute from the current request.
  193.    *
  194.    * @param  string $name     Attribute name
  195.    * @param  string $default  Default attribute value
  196.    *
  197.    * @return mixed An attribute value
  198.    */
  199.   public function getAttribute($name, $default = null)
  200.   {
  201.     return $this->attributeHolder->get($name, $default);
  202.   }
  204.   /**
  205.    * Indicates whether or not an attribute exist for the current request.
  206.    *
  207.    * @param  string $name  Attribute name
  208.    *
  209.    * @return bool true, if the attribute exists otherwise false
  210.    */
  211.   public function hasAttribute($name)
  212.   {
  213.     return $this->attributeHolder->has($name);
  214.   }
  216.   /**
  217.    * Sets an attribute for the request.
  218.    *
  219.    * @param string $name   Attribute name
  220.    * @param string $value  Value for the attribute
  221.    *
  222.    */
  223.   public function setAttribute($name, $value)
  224.   {
  225.     $this->attributeHolder->set($name, $value);
  226.   }
  228.   /**
  229.    * Retrieves a paramater for the current request.
  230.    *
  231.    * @param string $name     Parameter name
  232.    * @param string $default  Parameter default value
  233.    *
  234.    */
  235.   public function getParameter($name, $default = null)
  236.   {
  237.     return $this->parameterHolder->get($name, $default);
  238.   }
  240.   /**
  241.    * Indicates whether or not a parameter exist for the current request.
  242.    *
  243.    * @param  string $name  Parameter name
  244.    *
  245.    * @return bool true, if the paramater exists otherwise false
  246.    */
  247.   public function hasParameter($name)
  248.   {
  249.     return $this->parameterHolder->has($name);
  250.   }
  252.   /**
  253.    * Sets a parameter for the current request.
  254.    *
  255.    * @param string $name   Parameter name
  256.    * @param string $value  Parameter value
  257.    *
  258.    */
  259.   public function setParameter($name, $value)
  260.   {
  261.     $this->parameterHolder->set($name, $value);
  262.   }
  264.   /**
  265.    * Returns the content of the current request.
  266.    *
  267.    * @return string|Boolean The content or false if none is available
  268.    */
  269.   public function getContent()
  270.   {
  271.     if (null === $this->content)
  272.     {
  273.       if (0 === strlen(trim($this->content = file_get_contents('php://input'))))
  274.       {
  275.         $this->content = false;
  276.       }
  277.     }
  279.     return $this->content;
  280.   }
  282.   /**
  283.    * Calls methods defined via sfEventDispatcher.
  284.    *
  285.    * @param  string $method     The method name
  286.    * @param  array  $arguments  The method arguments
  287.    *
  288.    * @return mixed The returned value of the called method
  289.    *
  290.    * @throws <b>sfException</b> if call fails
  291.    */
  292.   public function __call($method, $arguments)
  293.   {
  294.     $event = $this->dispatcher->notifyUntil(new sfEvent($this, 'request.method_not_found', array('method' => $method, 'arguments' => $arguments)));
  295.     if (!$event->isProcessed())
  296.     {
  297.       throw new sfException(sprintf('Call to undefined method %s::%s.', get_class($this), $method));
  298.     }
  300.     return $event->getReturnValue();
  301.   }
  303.   public function __clone()
  304.   {
  305.     $this->parameterHolder = clone $this->parameterHolder;
  306.     $this->attributeHolder = clone $this->attributeHolder;
  307.   }
  308. }
Debug toolbar