1. sfFormFieldSchema.class.php
  2. /**
 * sfFormFieldSchema represents an array of widgets bind to names and values.
 *
 * @package    symfony
 * @subpackage form
 * @author     Fabien Potencier 
 * @version    SVN: $Id: sfFormFieldSchema.class.php 23214 2009-10-20 18:11:23Z Kris.Wallsmith $
 */
  3. class sfFormFieldSchema extends sfFormField implements ArrayAccess, Iterator, Countable
  4. {
  5.   protected
  6.     $count      = 0,
  7.     $fieldNames = array(),
  8.     $fields     = array();
  10.   /**
  11.    * Constructor.
  12.    *
  13.    * @param sfWidgetFormSchema $widget A sfWidget instance
  14.    * @param sfFormField        $parent The sfFormField parent instance (null for the root widget)
  15.    * @param string             $name   The field name
  16.    * @param string             $value  The field value
  17.    * @param sfValidatorError   $error  A sfValidatorError instance
  18.    */
  19.   public function __construct(sfWidgetFormSchema $widget, sfFormField $parent = null, $name, $value, sfValidatorError $error = null)
  20.   {
  21.     parent::__construct($widget, $parent, $name, $value, $error);
  23.     $this->fieldNames = $widget->getPositions();
  24.   }
  26.   /**
  27.    * Renders hidden form fields.
  28.    *
  29.    * @param boolean $recursive False will prevent hidden fields from embedded forms from rendering
  30.    *
  31.    * @return string
  32.    */
  33.   public function renderHiddenFields($recursive = true)
  34.   {
  35.     $output = '';
  37.     foreach ($this->getHiddenFields($recursive) as $field)
  38.     {
  39.       $output .= $field->render();
  40.     }
  42.     return $output;
  43.   }
  45.   /**
  46.    * Returns an array of hidden fields from the current schema.
  47.    *
  48.    * @param boolean $recursive Whether to recur through embedded schemas
  49.    *
  50.    * @return array
  51.    */
  52.   public function getHiddenFields($recursive = true)
  53.   {
  54.     $fields = array();
  56.     foreach ($this as $name => $field)
  57.     {
  58.       if ($field instanceof sfFormFieldSchema && $recursive)
  59.       {
  60.         $fields = array_merge($fields, $field->getHiddenFields($recursive));
  61.       }
  62.       else if ($field->isHidden())
  63.       {
  64.         $fields[] = $field;
  65.       }
  66.     }
  68.     return $fields;
  69.   }
  71.   /**
  72.    * Returns true if the bound field exists (implements the ArrayAccess interface).
  73.    *
  74.    * @param string $name The name of the bound field
  75.    *
  76.    * @return Boolean true if the widget exists, false otherwise
  77.    */
  78.   public function offsetExists($name)
  79.   {
  80.     return isset($this->widget[$name]);
  81.   }
  83.   /**
  84.    * Returns the form field associated with the name (implements the ArrayAccess interface).
  85.    *
  86.    * @param string $name The offset of the value to get
  87.    *
  88.    * @return sfFormField A form field instance
  89.    */
  90.   public function offsetGet($name)
  91.   {
  92.     if (!isset($this->fields[$name]))
  93.     {
  94.       if (null === $widget = $this->widget[$name])
  95.       {
  96.         throw new InvalidArgumentException(sprintf('Widget "%s" does not exist.', $name));
  97.       }
  99.       $error = isset($this->error[$name]) ? $this->error[$name] : null;
  101.       if ($widget instanceof sfWidgetFormSchema)
  102.       {
  103.         $class = 'sfFormFieldSchema';
  105.         if ($error && !$error instanceof sfValidatorErrorSchema)
  106.         {
  107.           $error = new sfValidatorErrorSchema($error->getValidator(), array($error));
  108.         }
  109.       }
  110.       else
  111.       {
  112.         $class = 'sfFormField';
  113.       }
  115.       $this->fields[$name] = new $class($widget, $this, $name, isset($this->value[$name]) ? $this->value[$name] : null, $error);
  116.     }
  118.     return $this->fields[$name];
  119.   }
  121.   /**
  122.    * Throws an exception saying that values cannot be set (implements the ArrayAccess interface).
  123.    *
  124.    * @param string $offset (ignored)
  125.    * @param string $value (ignored)
  126.    *
  127.    * @throws LogicException
  128.    */
  129.   public function offsetSet($offset, $value)
  130.   {
  131.     throw new LogicException('Cannot update form fields (read-only).');
  132.   }
  134.   /**
  135.    * Throws an exception saying that values cannot be unset (implements the ArrayAccess interface).
  136.    *
  137.    * @param string $offset (ignored)
  138.    *
  139.    * @throws LogicException
  140.    */
  141.   public function offsetUnset($offset)
  142.   {
  143.     throw new LogicException('Cannot remove form fields (read-only).');
  144.   }
  146.   /**
  147.    * Resets the field names array to the beginning (implements the Iterator interface).
  148.    */
  149.   public function rewind()
  150.   {
  151.     reset($this->fieldNames);
  152.     $this->count = count($this->fieldNames);
  153.   }
  155.   /**
  156.    * Gets the key associated with the current form field (implements the Iterator interface).
  157.    *
  158.    * @return string The key
  159.    */
  160.   public function key()
  161.   {
  162.     return current($this->fieldNames);
  163.   }
  165.   /**
  166.    * Returns the current form field (implements the Iterator interface).
  167.    *
  168.    * @return mixed The escaped value
  169.    */
  170.   public function current()
  171.   {
  172.     return $this[current($this->fieldNames)];
  173.   }
  175.   /**
  176.    * Moves to the next form field (implements the Iterator interface).
  177.    */
  178.   public function next()
  179.   {
  180.     next($this->fieldNames);
  181.     --$this->count;
  182.   }
  184.   /**
  185.    * Returns true if the current form field is valid (implements the Iterator interface).
  186.    *
  187.    * @return boolean The validity of the current element; true if it is valid
  188.    */
  189.   public function valid()
  190.   {
  191.     return $this->count > 0;
  192.   }
  194.   /**
  195.    * Returns the number of form fields (implements the Countable interface).
  196.    *
  197.    * @return integer The number of embedded form fields
  198.    */
  199.   public function count()
  200.   {
  201.     return count($this->fieldNames);
  202.   }
  203. }
Debug toolbar