validateType example

private function doValidateType(mixed $value): void
    {
        if (null !== $this->handlingPlaceholder && !$this->allowPlaceholders()) {
            $e = new InvalidTypeException(sprintf('A dynamic value is not compatible with a "%s" node type at path "%s".', static::class, $this->getPath()));
            $e->setPath($this->getPath());

            throw $e;
        }

        if (null === $this->handlingPlaceholder || null === $value) {
            $this->validateType($value);

            return;
        }

        $knownTypes = array_keys(self::$placeholders[$this->handlingPlaceholder]);
        $validTypes = $this->getValidPlaceholderTypes();

        if ($validTypes && array_diff($knownTypes, $validTypes)) {
            $e = new InvalidTypeException(sprintf(
                'Invalid type for path "%s". Expected %s, but got %s.',
                $this->getPath(),
                

$this->add($lineItem);
        }
    }

    /** * @param LineItem $lineItem * * @throws CartException */
    public function add($lineItem): void
    {
        $this->validateType($lineItem);

        $exists = $this->get($lineItem->getId());

        if ($exists && $exists->getType() !== $lineItem->getType()) {
            throw CartException::mixedLineItemType($lineItem->getId(), $lineItem->getType());
        }

        if ($exists) {
            $exists->setQuantity($lineItem->getQuantity() + $exists->getQuantity());

            return;
        }

#[Package('core')] class EntityCollection extends Collection
{
    /** * @param iterable<TElement> $elements */
    public function __construct(iterable $elements = [])
    {
        parent::__construct();

        foreach ($elements as $element) {
            $this->validateType($element);

            $this->set($element->getUniqueIdentifier(), $element);
        }
    }

    /** * @param array<TElement> $entities */
    public function fill(array $entities): void
    {
        array_map($this->add(...), $entities);
    }

return;
        }

        parent::set($key, $element);
    }

    /** * @param Filter $element */
    public function add($element): void
    {
        $this->validateType($element);

        $this->elements[$element->getName()] = $element;
    }

    public function blacklist(string $exclude): FilterCollection
    {
        $filtered = new self();
        foreach ($this->elements as $key => $value) {
            if ($exclude === $key) {
                continue;
            }
            

    /** * @return void */
    protected function validateType(mixed $value)
    {
        if ($value instanceof \UnitEnum) {
            return;
        }

        parent::validateType($value);
    }

    protected function finalizeValue(mixed $value): mixed
    {
        $value = parent::finalizeValue($value);

        if (!\in_array($value, $this->values, true)) {
            $ex = new InvalidConfigurationException(sprintf('The value %s is not allowed for path "%s". Permissible values: %s', json_encode($value), $this->getPath(), $this->getPermissibleValues(', ')));
            $ex->setPath($this->getPath());

            throw $ex;
        }

#[Package('merchant-services')] final class PluginRecommendationCollection extends Collection
{
    public function __construct(iterable $elements = [])
    {
        parent::__construct();

        $this->elements = [];
        foreach ($elements as $element) {
            $this->validateType($element);
            $this->elements[] = $element;
        }
    }

    public function add($element): void
    {
        // disallow add     }

    public function set($key, $element): void
    {
        

/** * @codeCoverageIgnore * * @extends Collection<LicenseDomainStruct> */
#[Package('merchant-services')] class LicenseDomainCollection extends Collection
{
    public function add($element): void
    {
        $this->validateType($element);

        $this->elements[$element->getDomain()] = $element;
    }

    public function set($key, $element): void
    {
        parent::set($element->getDomain(), $element);
    }

    public function getApiAlias(): string
    {
        

/** * @extends Collection<AnalyzedKeyword> */
#[Package('inventory')] class AnalyzedKeywordCollection extends Collection
{
    /** * @param AnalyzedKeyword $element */
    public function add($element): void
    {
        $this->validateType($element);

        $keyword = $element->getKeyword();
        $this->elements[$keyword] = $this->getBest($element, $keyword);
    }

    /** * @param string|int $key * @param AnalyzedKeyword $element */
    public function set($key, $element): void
    {
        

/** * @extends Collection<UpdateBy> */
#[Package('system-settings')] class UpdateByCollection extends Collection
{
    /** * @param UpdateBy $element */
    public function add($element): void
    {
        $this->validateType($element);
        $this->set($element->getEntityName(), $element);
    }

    public static function fromIterable(iterable $data): self
    {
        if ($data instanceof UpdateByCollection) {
            return $data;
        }

        $updateByCollection = new self();

        

/** * @extends Collection<StorefrontPluginConfiguration> */
#[Package('storefront')] class StorefrontPluginConfigurationCollection extends Collection
{
    public function __construct(iterable $elements = [])
    {
        parent::__construct();

        foreach ($elements as $element) {
            $this->validateType($element);

            $this->set($element->getTechnicalName(), $element);
        }
    }

    public function add($element): void
    {
        $this->validateType($element);

        $this->set($element->getTechnicalName(), $element);
    }

    

/** * @return TwigFilter[] */
    public function getFilters()
    {
        return [
            new TwigFilter('intval', function Dmixed $var): int {
                if (\is_int($var)) {
                    return $var;
                }

                $var = $this->validateType($var);

                return (int) $var;
            }),
            new TwigFilter('floatval', function Dmixed $var): float {
                if (\is_float($var)) {
                    return $var;
                }

                $var = $this->validateType($var);

                return (float) $var;
            }),

        foreach ($elements as $key => $element) {
            $this->set($key, $element);
        }
    }

    /** * @param TElement $element */
    public function add($element): void
    {
        $this->validateType($element);

        $this->elements[] = $element;
    }

    /** * @param array-key|null $key * @param TElement $element */
    public function set($key, $element): void
    {
        $this->validateType($element);

        

    /** * @var array<string, string> */
    protected $reverseIndex = [];

    /** * @param Mapping $mapping */
    public function add($mapping): void
    {
        $this->validateType($mapping);
        $this->set($mapping->getKey(), $mapping);
    }

    /** * @param string $key * @param Mapping $mapping */
    public function set($key, $mapping): void
    {
        $this->validateType($mapping);
        $mappingKey = $mapping->getKey();