{@inheritdoc}

@throws UnsupportedTypeException
559489
public function isEligible(PromotionSubjectInterface $subject, array $configuration): bool
    {
        if (!$subject instanceof OrderInterface) {
            throw new UnsupportedTypeException($subject, OrderInterface::class);
        }

        /** @var OrderItemInterface $item */
        foreach ($subject->getItems() as $item) {
            if ($configuration['product_code'] === $item->getProduct()->getCode()) {
                return true;
            }
        }

        return false;
    }
1047402
public void throwIfUnsupportedScan(Scan scan) {
    if (scan.getFilter() != null) {
      filterAdapter.throwIfUnsupportedFilter(scan, scan.getFilter());
    }

    if (scan.getMaxResultsPerColumnFamily() != UNSET_MAX_RESULTS_PER_COLUMN_FAMILY) {
      throw new UnsupportedOperationException(
          "Limiting of max results per column family is not supported.");
    }
  }
100319
public function getType($key) {
        $types = $this->getSupportedTypes();

        if (isset($types[$key])) {
            return new $types[$key]($this);
        }

        throw new UnsupportedTypeException(sprintf('Unsupported data type %s', $key));
    }
432375
public function resolve(IRequest $request)
    {
        foreach ($this->grantTypes as $grantType) {
            if ($grantType->match($request)) {
                return $grantType;
            }
        }

        throw new UnsupportedGrantTypeException;
    }
640050
@Override
    public boolean supportsResultSetType(int type) throws SQLException
    {
        checkClosed();
        if (type == ResultSet.TYPE_SCROLL_INSENSITIVE)
            return true;
        return false;
    }
817215
public function toEntityFull(ResourceInterface $resource, EntityInterface $entity)
    {
        foreach ($this->mappers as $mapper) {
            if ($mapper->supportsEntity($entity)) {
                $this->configureResourceMapper($mapper);
                $mapper->toEntityFull($resource, $entity);

                return;
            }
        }

        throw new UnsupportedTypeException($resource->type());
    }
1226654
private function initTableTypes()
    {
        $this->tableTypes = [];

        foreach ($this->loadTableTypes() as $type) {
            if (!$type instanceof TableTypeInterface) {
                throw new UnexpectedTypeException($type, TableTypeInterface::class);
            }

            $this->tableTypes[get_class($type)] = $type;
        }
    }
1222820
private function isValidUpdateType(string $updateType): void
    {
        $allowedUpdateType = $this->getAllowedUpdateType();
        if (!\in_array($updateType, $allowedUpdateType, true)) {
            throw new InvalidTypeException(sprintf(
                'updateType must be either "%s".',
                implode(', ', $allowedUpdateType)
            ));
        }
    }
331966
@Override
    public void setMethod(byte[] method) throws UnsupportedMethodException {
        MethodValues val = MethodValues.match(method, 0, method.length);
        if (null == val) {
            throw new UnsupportedMethodException("Illegal method " + GenericUtils.getEnglishString(method));
        }
        setMethod(val);
    }
82548
public boolean isTypeSupportedForSerialization( TreeLogger logger, JClassType classType ) {
        return allSupportedSerializationClass.contains( classType )
                || additionalSupportedTypes.isIncluded( logger, classType.getQualifiedSourceName() );
    }
400713
public function contains($field, $value)
    {
        if (!method_exists($this->expressionBuilder, 'contains')) {
            throw new UnsupportedExpressionTypeException('contains');
        }

        return $this->expressionBuilder->contains($field, $value);
    }
118691
public function serialize($value, array $options=[])
    {
        if (is_resource($value)) {
            throw new UnsupportedParameterException('You cant serialize a resource');
        }

        if ($value === $this->serializeFalseAs) {
            throw new UnsupportedParameterException('You cant serialize '.$this->serializeFalseAs.' cause its internally used to encode false');
        }

        if ($value === false) {
            $value = $this->serializeFalseAs;
        }

        return serialize($value);
    }
1300087
public function validate($value)
        {
            if (!in_array(gettype($value), $this->types)) {
                throw new Exception('Type of value "'.gettype($value)."' is not compatible with ".get_class($this));
            }
        }
601329
public static void unsupportedIfNot(boolean tester, String msg, Object ... args) {
        if (!tester) {
            throw unsupport(msg, args);
        }
    }
721461
public function fill(array $attributes = [])
    {
        $filtered = [];

        foreach ($attributes as $name => $value) {

            // This is done by the parent
            if (in_array($name, ['name', 'constraints'])) {
                continue;
            }

            if (isset(static::$propertyMap[static::class][$name]) ||
                isset(static::$aliases[static::class][$name])) {
                $filtered[$name] = $value;
                continue;
            }

            if (!$value instanceof XType) {
                throw new UnsupportedParameterException("The value of $name has to be instanceof XType");
            }

            $this->set($name, $value);
        }

        return parent::fill($filtered);
    }
254702
protected function checkRestriction(...$values)
    {
        if ($this->mustRestrict()) {
            foreach ($values as $value) {
                if (!$value instanceof $this->type) {
                    throw new UnsupportedTypeException(
                        sprintf(
                            'The value of type "%s" doesn\'t match type restriction "%s"',
                            $this->getValueType($value),
                            $this->type
                        )
                    );
                }
            }
        }
    }
929595
public final void setTypeMap(Map<String, Class<?>> typeMap) throws SQLException 
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            Tr.debug(this, tc, "Set TypeMap to " + typeMap); 
        try{
            sqlConn.setTypeMap(typeMap);
        } catch(SQLFeatureNotSupportedException nse){
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                Tr.debug(this, tc, "supportsGetTypeMap false due to ", nse);
            mcf.supportsGetTypeMap = false;
            throw nse;
        } catch(UnsupportedOperationException uoe){
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                Tr.debug(this, tc, "supportsGetTypeMap false due to ", uoe);
            mcf.supportsGetTypeMap = false;
            throw uoe;
        }
        connectionPropertyChanged = true; 
    }