1. sfResponse.class.php
  2. /**
 * sfResponse provides methods for manipulating client response information such
 * as headers, cookies and content.
 *
 * @package    symfony
 * @subpackage response
 * @author     Fabien Potencier 
 * @version    SVN: $Id: sfResponse.class.php 14598 2009-01-11 09:32:32Z dwhittle $
 */
  3. abstract class sfResponse implements Serializable
  4. {
  5.   protected
  6.     $options    = array(),
  7.     $dispatcher = null,
  8.     $content    = '';
  10.   /**
  11.    * Class constructor.
  12.    *
  13.    * @see initialize()
  14.    */
  15.   public function __construct(sfEventDispatcher $dispatcher, $options = array())
  16.   {
  17.     $this->initialize($dispatcher, $options);
  18.   }
  20.   /**
  21.    * Initializes this sfResponse.
  22.    *
  23.    * Available options:
  24.    *
  25.    *  * logging: Whether to enable logging or not (false by default)
  26.    *
  27.    * @param  sfEventDispatcher  $dispatcher  An sfEventDispatcher instance
  28.    * @param  array              $options     An array of options
  29.    *
  30.    * @return bool true, if initialization completes successfully, otherwise false
  31.    *
  32.    * @throws <b>sfInitializationException</b> If an error occurs while initializing this sfResponse
  33.    */
  34.   public function initialize(sfEventDispatcher $dispatcher, $options = array())
  35.   {
  36.     $this->dispatcher = $dispatcher;
  37.     $this->options = $options;
  39.     if (!isset($this->options['logging']))
  40.     {
  41.       $this->options['logging'] = false;
  42.     }
  43.   }
  45.   /**
  46.    * Sets the event dispatcher.
  47.    *
  48.    * @param sfEventDispatcher $dispatcher  An sfEventDispatcher instance
  49.    */
  50.   public function setEventDispatcher(sfEventDispatcher $dispatcher)
  51.   {
  52.     $this->dispatcher = $dispatcher;
  53.   }
  55.   /**
  56.    * Sets the response content
  57.    *
  58.    * @param string $content
  59.    */
  60.   public function setContent($content)
  61.   {
  62.     $this->content = $content;
  63.   }
  65.   /**
  66.    * Gets the current response content
  67.    *
  68.    * @return string Content
  69.    */
  70.   public function getContent()
  71.   {
  72.     return $this->content;
  73.   }
  75.   /**
  76.    * Outputs the response content
  77.    */
  78.   public function sendContent()
  79.   {
  80.     $event = $this->dispatcher->filter(new sfEvent($this, 'response.filter_content'), $this->getContent());
  81.     $content = $event->getReturnValue();
  83.     if ($this->options['logging'])
  84.     {
  85.       $this->dispatcher->notify(new sfEvent($this, 'application.log', array(sprintf('Send content (%s o)', strlen($content)))));
  86.     }
  88.     echo $content;
  89.   }
  91.   /**
  92.    * Sends the content.
  93.    */
  94.   public function send()
  95.   {
  96.     $this->sendContent();
  97.   }
  99.   /**
  100.    * Returns the options.
  101.    *
  102.    * @return array The options.
  103.    */
  104.   public function getOptions()
  105.   {
  106.     return $this->options;
  107.   }
  109.   /**
  110.    * Calls methods defined via sfEventDispatcher.
  111.    *
  112.    * @param string $method     The method name
  113.    * @param array  $arguments  The method arguments
  114.    *
  115.    * @return mixed The returned value of the called method
  116.    *
  117.    * @throws <b>sfException</b> If the calls fails
  118.    */
  119.   public function __call($method, $arguments)
  120.   {
  121.     $event = $this->dispatcher->notifyUntil(new sfEvent($this, 'response.method_not_found', array('method' => $method, 'arguments' => $arguments)));
  122.     if (!$event->isProcessed())
  123.     {
  124.       throw new sfException(sprintf('Call to undefined method %s::%s.', get_class($this), $method));
  125.     }
  127.     return $event->getReturnValue();
  128.   }
  130.   /**
  131.    * Serializes the current instance.
  132.    *
  133.    * @return array Objects instance
  134.    */
  135.   public function serialize()
  136.   {
  137.     return serialize($this->content);
  138.   }
  140.   /**
  141.    * Unserializes a sfResponse instance.
  142.    *
  143.    * You need to inject a dispatcher after unserializing a sfResponse instance.
  144.    *
  145.    * @param string $serialized  A serialized sfResponse instance
  146.    *
  147.    */
  148.   public function unserialize($serialized)
  149.   {
  150.     $this->content = unserialize($serialized);
  151.   }
  152. }
Debug toolbar