1. sfValidatorErrorSchema.class.php
  2. /**
 * sfValidatorErrorSchema represents a validation schema error.
 *
 * @package    symfony
 * @subpackage validator
 * @author     Fabien Potencier 
 * @version    SVN: $Id: sfValidatorErrorSchema.class.php 22446 2009-09-26 07:55:47Z fabien $
 */
  3. class sfValidatorErrorSchema extends sfValidatorError implements ArrayAccess, Iterator, Countable
  4. {
  5.   protected
  6.     $errors       = array(),
  7.     $globalErrors = array(),
  8.     $namedErrors  = array(),
  9.     $count        = 0;
  11.   /**
  12.    * Constructor.
  13.    *
  14.    * @param sfValidatorBase $validator  An sfValidatorBase instance
  15.    * @param array           $errors     An array of errors
  16.    */
  17.   public function __construct(sfValidatorBase $validator, $errors = array())
  18.   {
  19.     $this->validator = $validator;
  20.     $this->arguments = array();
  22.     // override default exception message and code
  23.     $this->code    = '';
  24.     $this->message = '';
  26.     $this->addErrors($errors);
  27.   }
  29.   /**
  30.    * Adds an error.
  31.    *
  32.    * This method merges sfValidatorErrorSchema errors with the current instance.
  33.    *
  34.    * @param sfValidatorError $error  An sfValidatorError instance
  35.    * @param string           $name   The error name
  36.    *
  37.    * @return sfValidatorErrorSchema The current error schema instance
  38.    */
  39.   public function addError(sfValidatorError $error, $name = null)
  40.   {
  41.     if (null === $name || is_integer($name))
  42.     {
  43.       if ($error instanceof sfValidatorErrorSchema)
  44.       {
  45.         $this->addErrors($error);
  46.       }
  47.       else
  48.       {
  49.         $this->globalErrors[] = $error;
  50.         $this->errors[] = $error;
  51.       }
  52.     }
  53.     else
  54.     {
  55.       if (!isset($this->namedErrors[$name]) && !$error instanceof sfValidatorErrorSchema)
  56.       {
  57.         $this->namedErrors[$name] = $error;
  58.         $this->errors[$name] = $error;
  59.       }
  60.       else
  61.       {
  62.         if (!isset($this->namedErrors[$name]))
  63.         {
  64.           $this->namedErrors[$name] = new sfValidatorErrorSchema($error->getValidator());
  65.           $this->errors[$name] = new sfValidatorErrorSchema($error->getValidator());
  66.         }
  67.         else if (!$this->namedErrors[$name] instanceof sfValidatorErrorSchema)
  68.         {
  69.           $current = $this->namedErrors[$name];
  70.           $this->namedErrors[$name] = new sfValidatorErrorSchema($current->getValidator());
  71.           $this->errors[$name] = new sfValidatorErrorSchema($current->getValidator());
  73.           $method = $current instanceof sfValidatorErrorSchema ? 'addErrors' : 'addError';
  74.           $this->namedErrors[$name]->$method($current);
  75.           $this->errors[$name]->$method($current);
  76.         }
  78.         $method = $error instanceof sfValidatorErrorSchema ? 'addErrors' : 'addError';
  79.         $this->namedErrors[$name]->$method($error);
  80.         $this->errors[$name]->$method($error);
  81.       }
  82.     }
  84.     $this->updateCode();
  85.     $this->updateMessage();
  87.     return $this;
  88.   }
  90.   /**
  91.    * Adds an array of errors.
  92.    *
  93.    * @param array $errors  An array of sfValidatorError instances
  94.    *
  95.    * @return sfValidatorErrorSchema The current error schema instance
  96.    */
  97.   public function addErrors($errors)
  98.   {
  99.     if ($errors instanceof sfValidatorErrorSchema)
  100.     {
  101.       foreach ($errors->getGlobalErrors() as $error)
  102.       {
  103.         $this->addError($error);
  104.       }
  106.       foreach ($errors->getNamedErrors() as $name => $error)
  107.       {
  108.         $this->addError($error, (string) $name);
  109.       }
  110.     }
  111.     else
  112.     {
  113.       foreach ($errors as $name => $error)
  114.       {
  115.         $this->addError($error, $name);
  116.       }
  117.     }
  119.     return $this;
  120.   }
  122.   /**
  123.    * Gets an array of all errors
  124.    *
  125.    * @return array An array of sfValidatorError instances
  126.    */
  127.   public function getErrors()
  128.   {
  129.     return $this->errors;
  130.   }
  132.   /**
  133.    * Gets an array of all named errors
  134.    *
  135.    * @return array An array of sfValidatorError instances
  136.    */
  137.   public function getNamedErrors()
  138.   {
  139.     return $this->namedErrors;
  140.   }
  142.   /**
  143.    * Gets an array of all global errors
  144.    *
  145.    * @return array An array of sfValidatorError instances
  146.    */
  147.   public function getGlobalErrors()
  148.   {
  149.     return $this->globalErrors;
  150.   }
  152.   /**
  153.    * @see sfValidatorError
  154.    */
  155.   public function getValue()
  156.   {
  157.     return null;
  158.   }
  160.   /**
  161.    * @see sfValidatorError
  162.    */
  163.   public function getArguments($raw = false)
  164.   {
  165.     return array();
  166.   }
  168.   /**
  169.    * @see sfValidatorError
  170.    */
  171.   public function getMessageFormat()
  172.   {
  173.     return '';
  174.   }
  176.   /**
  177.    * Returns the number of errors (implements the Countable interface).
  178.    *
  179.    * @return int The number of array
  180.    */
  181.   public function count()
  182.   {
  183.     return count($this->errors);
  184.   }
  186.   /**
  187.    * Reset the error array to the beginning (implements the Iterator interface).
  188.    */
  189.   public function rewind()
  190.   {
  191.     reset($this->errors);
  193.     $this->count = count($this->errors);
  194.   }
  196.   /**
  197.    * Get the key associated with the current error (implements the Iterator interface).
  198.    *
  199.    * @return string The key
  200.    */
  201.   public function key()
  202.   {
  203.     return key($this->errors);
  204.   }
  206.   /**
  207.    * Returns the current error (implements the Iterator interface).
  208.    *
  209.    * @return mixed The escaped value
  210.    */
  211.   public function current()
  212.   {
  213.     return current($this->errors);
  214.   }
  216.   /**
  217.    * Moves to the next error (implements the Iterator interface).
  218.    */
  219.   public function next()
  220.   {
  221.     next($this->errors);
  223.     --$this->count;
  224.   }
  226.   /**
  227.    * Returns true if the current error is valid (implements the Iterator interface).
  228.    *
  229.    * @return boolean The validity of the current element; true if it is valid
  230.    */
  231.   public function valid()
  232.   {
  233.     return $this->count > 0;
  234.   }
  236.   /**
  237.    * Returns true if the error exists (implements the ArrayAccess interface).
  238.    *
  239.    * @param  string $name  The name of the error
  240.    *
  241.    * @return bool true if the error exists, false otherwise
  242.    */
  243.   public function offsetExists($name)
  244.   {
  245.     return isset($this->errors[$name]);
  246.   }
  248.   /**
  249.    * Returns the error associated with the name (implements the ArrayAccess interface).
  250.    *
  251.    * @param  string $name  The offset of the value to get
  252.    *
  253.    * @return sfValidatorError A sfValidatorError instance
  254.    */
  255.   public function offsetGet($name)
  256.   {
  257.     return isset($this->errors[$name]) ? $this->errors[$name] : null;
  258.   }
  260.   /**
  261.    * Throws an exception saying that values cannot be set (implements the ArrayAccess interface).
  262.    *
  263.    * @param string $offset  (ignored)
  264.    * @param string $value   (ignored)
  265.    *
  266.    * @throws LogicException
  267.    */
  268.   public function offsetSet($offset, $value)
  269.   {
  270.     throw new LogicException('Unable update an error.');
  271.   }
  273.   /**
  274.    * Impossible to call because this is an exception!
  275.    *
  276.    * @param string $offset  (ignored)
  277.    */
  278.   public function offsetUnset($offset)
  279.   {
  280.   }
  282.   /**
  283.    * Updates the exception error code according to the current errors.
  284.    */
  285.   protected function updateCode()
  286.   {
  287.     $this->code = implode(' ', array_merge(
  288.       array_map(create_function('$e', 'return $e->getCode();'), $this->globalErrors),
  289.       array_map(create_function('$n,$e', 'return $n.\' [\'.$e->getCode().\']\';'), array_keys($this->namedErrors), array_values($this->namedErrors))
  290.     ));
  291.   }
  293.   /**
  294.    * Updates the exception error message according to the current errors.
  295.    */
  296.   protected function updateMessage()
  297.   {
  298.     $this->message = implode(' ', array_merge(
  299.       array_map(create_function('$e', 'return $e->getMessage();'), $this->globalErrors),
  300.       array_map(create_function('$n,$e', 'return $n.\' [\'.$e->getMessage().\']\';'), array_keys($this->namedErrors), array_values($this->namedErrors))
  301.     ));
  302.   }
  304.   /**
  305.    * Serializes the current instance.
  306.    *
  307.    * @return string The instance as a serialized string
  308.    */
  309.   public function serialize()
  310.   {
  311.     return serialize(array($this->validator, $this->arguments, $this->code, $this->message, $this->errors, $this->globalErrors, $this->namedErrors));
  312.   }
  314.   /**
  315.    * Unserializes a sfValidatorError instance.
  316.    *
  317.    * @param string $serialized  A serialized sfValidatorError instance
  318.    *
  319.    */
  320.   public function unserialize($serialized)
  321.   {
  322.     list($this->validator, $this->arguments, $this->code, $this->message, $this->errors, $this->globalErrors, $this->namedErrors) = unserialize($serialized);
  323.   }
  324. }
Debug toolbar