vendor/sensio/framework-extra-bundle/src/Configuration/ParamConverter.php line 21

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 Sensio\Bundle\FrameworkExtraBundle\Configuration;
  14. /**
  15.  * The ParamConverter class handles the ParamConverter annotation parts.
  16.  *
  17.  * @author Fabien Potencier <fabien@symfony.com>
  18.  * @Annotation
  19.  */
  20. #[\Attribute(\Attribute::IS_REPEATABLE | \Attribute::TARGET_CLASS | \Attribute::TARGET_METHOD)]
  21. class ParamConverter extends ConfigurationAnnotation
  22. {
  23.     /**
  24.      * The parameter name.
  25.      *
  26.      * @var string
  27.      */
  28.     private $name;
  30.     /**
  31.      * The parameter class.
  32.      *
  33.      * @var string
  34.      */
  35.     private $class;
  37.     /**
  38.      * An array of options.
  39.      *
  40.      * @var array
  41.      */
  42.     private $options = [];
  44.     /**
  45.      * Whether or not the parameter is optional.
  46.      *
  47.      * @var bool
  48.      */
  49.     private $isOptional = false;
  51.     /**
  52.      * Use explicitly named converter instead of iterating by priorities.
  53.      *
  54.      * @var string
  55.      */
  56.     private $converter;
  58.     /**
  59.      * @param array|string $data
  60.      */
  61.     public function __construct(
  62.         $data = [],
  63.         string $class = null,
  64.         array $options = [],
  65.         bool $isOptional = false,
  66.         string $converter = null
  67.     ) {
  68.         $values = [];
  69.         if (\is_string($data)) {
  70.             $values['value'] = $data;
  71.         } else {
  72.             $values = $data;
  73.         }
  74.         $values['class'] = $values['class'] ?? $class;
  75.         $values['options'] = $values['options'] ?? $options;
  76.         $values['isOptional'] = $values['isOptional'] ?? $isOptional;
  77.         $values['converter'] = $values['converter'] ?? $converter;
  78.         parent::__construct($values);
  79.     }
  81.     /**
  82.      * Returns the parameter name.
  83.      *
  84.      * @return string
  85.      */
  86.     public function getName()
  87.     {
  88.         return $this->name;
  89.     }
  91.     /**
  92.      * Sets the parameter name.
  93.      *
  94.      * @param string $name The parameter name
  95.      */
  96.     public function setValue($name)
  97.     {
  98.         $this->setName($name);
  99.     }
  101.     /**
  102.      * Sets the parameter name.
  103.      *
  104.      * @param string $name The parameter name
  105.      */
  106.     public function setName($name)
  107.     {
  108.         $this->name = $name;
  109.     }
  111.     /**
  112.      * Returns the parameter class name.
  113.      *
  114.      * @return string
  115.      */
  116.     public function getClass()
  117.     {
  118.         return $this->class;
  119.     }
  121.     /**
  122.      * Sets the parameter class name.
  123.      *
  124.      * @param string $class The parameter class name
  125.      */
  126.     public function setClass($class)
  127.     {
  128.         $this->class = $class;
  129.     }
  131.     /**
  132.      * Returns an array of options.
  133.      *
  134.      * @return array
  135.      */
  136.     public function getOptions()
  137.     {
  138.         return $this->options;
  139.     }
  141.     /**
  142.      * Sets an array of options.
  143.      *
  144.      * @param array $options An array of options
  145.      */
  146.     public function setOptions($options)
  147.     {
  148.         $this->options = $options;
  149.     }
  151.     /**
  152.      * Sets whether or not the parameter is optional.
  153.      *
  154.      * @param bool $optional Whether the parameter is optional
  155.      */
  156.     public function setIsOptional($optional)
  157.     {
  158.         $this->isOptional = (bool) $optional;
  159.     }
  161.     /**
  162.      * Returns whether or not the parameter is optional.
  163.      *
  164.      * @return bool
  165.      */
  166.     public function isOptional()
  167.     {
  168.         return $this->isOptional;
  169.     }
  171.     /**
  172.      * Get explicit converter name.
  173.      *
  174.      * @return string
  175.      */
  176.     public function getConverter()
  177.     {
  178.         return $this->converter;
  179.     }
  181.     /**
  182.      * Set explicit converter name.
  183.      *
  184.      * @param string $converter
  185.      */
  186.     public function setConverter($converter)
  187.     {
  188.         $this->converter = $converter;
  189.     }
  191.     /**
  192.      * Returns the annotation alias name.
  193.      *
  194.      * @return string
  195.      *
  196.      * @see ConfigurationInterface
  197.      */
  198.     public function getAliasName()
  199.     {
  200.         return 'converters';
  201.     }
  203.     /**
  204.      * Multiple ParamConverters are allowed.
  205.      *
  206.      * @return bool
  207.      *
  208.      * @see ConfigurationInterface
  209.      */
  210.     public function allowArray()
  211.     {
  212.         return true;
  213.     }
  214. }