vendor/symfony/form/FormView.php line 22

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.  * @implements \ArrayAccess<string, FormView>
  20.  * @implements \IteratorAggregate<string, FormView>
  21.  */
  22. class FormView implements \ArrayAccess, \IteratorAggregate, \Countable
  23. {
  24.     /**
  25.      * The variables assigned to this view.
  26.      */
  27.     public $vars = [
  28.         'value' => null,
  29.         'attr' => [],
  30.     ];
  32.     /**
  33.      * The parent view.
  34.      */
  35.     public $parent;
  37.     /**
  38.      * The child views.
  39.      *
  40.      * @var array<string, FormView>
  41.      */
  42.     public $children = [];
  44.     /**
  45.      * Is the form attached to this renderer rendered?
  46.      *
  47.      * Rendering happens when either the widget or the row method was called.
  48.      * Row implicitly includes widget, however certain rendering mechanisms
  49.      * have to skip widget rendering when a row is rendered.
  50.      *
  51.      * @var bool
  52.      */
  53.     private $rendered = false;
  55.     private $methodRendered = false;
  57.     public function __construct(self $parent = null)
  58.     {
  59.         $this->parent = $parent;
  60.     }
  62.     /**
  63.      * Returns whether the view was already rendered.
  64.      *
  65.      * @return bool
  66.      */
  67.     public function isRendered()
  68.     {
  69.         if (true === $this->rendered || 0 === \count($this->children)) {
  70.             return $this->rendered;
  71.         }
  73.         foreach ($this->children as $child) {
  74.             if (!$child->isRendered()) {
  75.                 return false;
  76.             }
  77.         }
  79.         return $this->rendered = true;
  80.     }
  82.     /**
  83.      * Marks the view as rendered.
  84.      *
  85.      * @return $this
  86.      */
  87.     public function setRendered()
  88.     {
  89.         $this->rendered = true;
  91.         return $this;
  92.     }
  94.     /**
  95.      * @return bool
  96.      */
  97.     public function isMethodRendered()
  98.     {
  99.         return $this->methodRendered;
  100.     }
  102.     public function setMethodRendered()
  103.     {
  104.         $this->methodRendered = true;
  105.     }
  107.     /**
  108.      * Returns a child by name (implements \ArrayAccess).
  109.      *
  110.      * @param string $name The child name
  111.      *
  112.      * @return self
  113.      */
  114.     #[\ReturnTypeWillChange]
  115.     public function offsetGet($name)
  116.     {
  117.         return $this->children[$name];
  118.     }
  120.     /**
  121.      * Returns whether the given child exists (implements \ArrayAccess).
  122.      *
  123.      * @param string $name The child name
  124.      *
  125.      * @return bool
  126.      */
  127.     #[\ReturnTypeWillChange]
  128.     public function offsetExists($name)
  129.     {
  130.         return isset($this->children[$name]);
  131.     }
  133.     /**
  134.      * Implements \ArrayAccess.
  135.      *
  136.      * @return void
  137.      *
  138.      * @throws BadMethodCallException always as setting a child by name is not allowed
  139.      */
  140.     #[\ReturnTypeWillChange]
  141.     public function offsetSet($name, $value)
  142.     {
  143.         throw new BadMethodCallException('Not supported.');
  144.     }
  146.     /**
  147.      * Removes a child (implements \ArrayAccess).
  148.      *
  149.      * @param string $name The child name
  150.      *
  151.      * @return void
  152.      */
  153.     #[\ReturnTypeWillChange]
  154.     public function offsetUnset($name)
  155.     {
  156.         unset($this->children[$name]);
  157.     }
  159.     /**
  160.      * Returns an iterator to iterate over children (implements \IteratorAggregate).
  161.      *
  162.      * @return \ArrayIterator<string, FormView>
  163.      */
  164.     #[\ReturnTypeWillChange]
  165.     public function getIterator()
  166.     {
  167.         return new \ArrayIterator($this->children);
  168.     }
  170.     /**
  171.      * Implements \Countable.
  172.      *
  173.      * @return int
  174.      */
  175.     #[\ReturnTypeWillChange]
  176.     public function count()
  177.     {
  178.         return \count($this->children);
  179.     }
  180. }