vendor/symfony/form/FormView.php line 19

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\Form;
  14. use Symfony\Component\Form\Exception\BadMethodCallException;
  16. /**
  17.  * @author Bernhard Schussek <bschussek@gmail.com>
  18.  */
  19. class FormView implements \ArrayAccess, \IteratorAggregate, \Countable
  20. {
  21.     /**
  22.      * The variables assigned to this view.
  23.      */
  24.     public $vars = [
  25.         'value' => null,
  26.         'attr' => [],
  27.     ];
  29.     /**
  30.      * The parent view.
  31.      */
  32.     public $parent;
  34.     /**
  35.      * The child views.
  36.      *
  37.      * @var array<string, FormView>
  38.      */
  39.     public $children = [];
  41.     /**
  42.      * Is the form attached to this renderer rendered?
  43.      *
  44.      * Rendering happens when either the widget or the row method was called.
  45.      * Row implicitly includes widget, however certain rendering mechanisms
  46.      * have to skip widget rendering when a row is rendered.
  47.      *
  48.      * @var bool
  49.      */
  50.     private $rendered = false;
  52.     private $methodRendered = false;
  54.     public function __construct(self $parent = null)
  55.     {
  56.         $this->parent = $parent;
  57.     }
  59.     /**
  60.      * Returns whether the view was already rendered.
  61.      *
  62.      * @return bool Whether this view's widget is rendered
  63.      */
  64.     public function isRendered()
  65.     {
  66.         if (true === $this->rendered || 0 === \count($this->children)) {
  67.             return $this->rendered;
  68.         }
  70.         foreach ($this->children as $child) {
  71.             if (!$child->isRendered()) {
  72.                 return false;
  73.             }
  74.         }
  76.         return $this->rendered = true;
  77.     }
  79.     /**
  80.      * Marks the view as rendered.
  81.      *
  82.      * @return $this
  83.      */
  84.     public function setRendered()
  85.     {
  86.         $this->rendered = true;
  88.         return $this;
  89.     }
  91.     /**
  92.      * @return bool
  93.      */
  94.     public function isMethodRendered()
  95.     {
  96.         return $this->methodRendered;
  97.     }
  99.     public function setMethodRendered()
  100.     {
  101.         $this->methodRendered = true;
  102.     }
  104.     /**
  105.      * Returns a child by name (implements \ArrayAccess).
  106.      *
  107.      * @param string $name The child name
  108.      *
  109.      * @return self The child view
  110.      */
  111.     #[\ReturnTypeWillChange]
  112.     public function offsetGet($name)
  113.     {
  114.         return $this->children[$name];
  115.     }
  117.     /**
  118.      * Returns whether the given child exists (implements \ArrayAccess).
  119.      *
  120.      * @param string $name The child name
  121.      *
  122.      * @return bool Whether the child view exists
  123.      */
  124.     #[\ReturnTypeWillChange]
  125.     public function offsetExists($name)
  126.     {
  127.         return isset($this->children[$name]);
  128.     }
  130.     /**
  131.      * Implements \ArrayAccess.
  132.      *
  133.      * @return void
  134.      *
  135.      * @throws BadMethodCallException always as setting a child by name is not allowed
  136.      */
  137.     #[\ReturnTypeWillChange]
  138.     public function offsetSet($name, $value)
  139.     {
  140.         throw new BadMethodCallException('Not supported.');
  141.     }
  143.     /**
  144.      * Removes a child (implements \ArrayAccess).
  145.      *
  146.      * @param string $name The child name
  147.      *
  148.      * @return void
  149.      */
  150.     #[\ReturnTypeWillChange]
  151.     public function offsetUnset($name)
  152.     {
  153.         unset($this->children[$name]);
  154.     }
  156.     /**
  157.      * Returns an iterator to iterate over children (implements \IteratorAggregate).
  158.      *
  159.      * @return \ArrayIterator<string, FormView> The iterator
  160.      */
  161.     #[\ReturnTypeWillChange]
  162.     public function getIterator()
  163.     {
  164.         return new \ArrayIterator($this->children);
  165.     }
  167.     /**
  168.      * Implements \Countable.
  169.      *
  170.      * @return int The number of children views
  171.      */
  172.     #[\ReturnTypeWillChange]
  173.     public function count()
  174.     {
  175.         return \count($this->children);
  176.     }
  177. }