{@inheritdoc}

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

        if (null === $address = $subject->getShippingAddress()) {
            return false;
        }

        $country = $this->countryRepository->findOneBy(['code' => $address->getCountryCode()]);

        if (!$country instanceof CountryInterface) {
            return false;
        }

        return $country->getCode() === $configuration['country'];
    }
383422
public function isEligible(PromotionSubjectInterface $subject, array $configuration): bool
    {
        if (!$subject instanceof OrderInterface) {
            throw new UnsupportedTypeException($subject, OrderInterface::class);
        }

        $channelCode = $subject->getChannel()->getCode();
        if (!isset($configuration[$channelCode])) {
            return false;
        }

        return $this->itemTotalRuleChecker->isEligible($subject, $configuration[$channelCode]);
    }
602976
@Override
    public void setTypeMap(Map<String,Class<?>> map) throws SQLException
    {
        checkClosed();
        throw SQLError.noSupport();
    }
72687
@Override
	public OUTPUT newInstance(INPUT input, INPUT... inputs) throws FAILURE {
		
		StringBuilder builder = new StringBuilder()
		.append(getClass().getName())
		.append(".newInstance(Input, Input...) is unsupported.");
		
		throw new UnsupportedOperationException(builder.toString());
	}
158159
public function isValid($value)
    {
        if (version_compare(VersionNumberUtility::getCurrentTypo3Version(), '7.6.0', '<')) {
            throw new UnsupportedVersionException(
                'The validator "' . self::class . '" cannot be used in TYPO3 versions anterior to `7.6.0`.',
                1506281412
            );
        }

        $value = (string)$value;

        if (false === $this->getIconRegistry()->isRegistered($value)) {
            $errorMessage = $this->translateErrorMessage('validator.icon_exists.not_valid', 'configuration_object', [$value]);
            $this->addError($errorMessage, 1506272737);
        }
    }
105542
@Override
  public <T, U> BindingBuilder<T> provider(Key<U> parent, Method m)
  {
    throw new UnsupportedOperationException(getClass().getName());
  }
59732
public static function UnsupportedMediaType($body = NULL, \Exception $previous = NULL) {
    return self::code(415, $body, $previous);
  }
262003
function typeIsSupported(type) {
  if (!(type && includes(Object.keys(SUPPORTED_TYPES), type))) {
    logError(`${type} nativeParam is not supported`);
    return false;
  }

  return true;
}
1277009
private void checkType(BtrpOperand e) {
        if (!(e instanceof BtrpNumber)) {
            throw new UnsupportedOperationException(e + " must be a '" + prettyType() + "' instead of a '" + e.prettyType() + "'");
        }
    }
969735
public function convert(Validation $validation, $format, array $keyTitles = [], array $customMessages = [])
    {

        if (!in_array($format, $this->supportedFormats)) {
            throw new UnsupportedParameterException(static::class . ' only supports MessageBag');
        }

        $messages = new MessageBag;

        if (!count($validation)) {
            return $messages;
        }

        foreach ($validation as $key=>$rules) {
            foreach ($rules as $ruleName=>$parameters) {
                $message = $this->getMessage($key, $ruleName, $rules, $keyTitles, $customMessages);
                $messages->add($key, $message);
            }
        }

        return $messages;

    }
1355357
public function getMetaClass($type)
    {
        if (!isset($this->supportedFiles[$type])) {
            throw new UnsupportedTypeException($type, array_keys($this->supportedFiles));
        }

        return $this->supportedFiles[$type];
    }
464424
public function serialize($value, array $options = [])
    {

        if (!is_object($value) && !is_array($value)) {
            return $value;
        }

        if (is_array($value) || $value instanceof Serializable) {
            return serialize($value);
        }

        if (!$value instanceof Identifiable) {
            throw new UnsupportedParameterException("Cannot serialize value of type " . Type::of($value));
        }

        if($pointer = $this->entityManager->pointer($value)) {
            return $this->serialize($pointer);
        };

        throw new UnsupportedParameterException("Cannot serialize value of type " . Type::of($value));

    }
107421
private function throwUnlessCorrectType($property, $value)
    {
        $typeUsedToBe = $this->getTypeUsedToBe($property);

        if ($typeUsedToBe !== "null") {
            $typeWantsToBe = $this->getTypeWantsToBe($value);

            if ($typeUsedToBe !== $typeWantsToBe) {
                throw new Exception();
            }
        }
    }
1279506
public function execute(Server $server)
    {
        if (isset($this->options['collation']) && ! \MongoDB\server_supports_feature($server, self::$wireVersionForCollation)) {
            throw UnsupportedException::collationNotSupported();
        }

        if (isset($this->options['readConcern']) && ! \MongoDB\server_supports_feature($server, self::$wireVersionForReadConcern)) {
            throw UnsupportedException::readConcernNotSupported();
        }

        $cursor = $server->executeQuery($this->databaseName . '.' . $this->collectionName, new Query($this->filter, $this->createQueryOptions()), $this->createExecuteOptions());

        if (isset($this->options['typeMap'])) {
            $cursor->setTypeMap($this->options['typeMap']);
        }

        return $cursor;
    }
822395
private void throwCannotInstanciateUnsupported(EJBBinding binding,
                                                   JavaColonNamespace jndiType,
                                                   String lookupName,
                                                   String messageId) throws NameNotFoundException {
        J2EEName j2eeName = getJ2EEName(binding);
        String jndiName = jndiType.toString() + "/" + lookupName;
        String msgTxt = Tr.formatMessage(tc, messageId,
                                         binding.interfaceName,
                                         j2eeName.getComponent(),
                                         j2eeName.getModule(),
                                         j2eeName.getApplication(),
                                         jndiName);
        throw (new NameNotFoundException(msgTxt));
    }
839039
protected function accepts($mimetype)
    {
        if (strtolower($this->request->getContentType()) != strtolower($mimetype)) {
            throw new UnsupportedMediaTypeException('No matching method for content type "'.$this->request->getContentType().'"');
        }

        return true;
    }
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;
        }
    }