Validates the basic target properties.
@param targetProperties the properties
@throws TargetException if an error occurred during the validation
762075
static void validate( Map<String,String> targetProperties ) throws TargetException {

		checkProperty( API_URL, targetProperties );
		checkProperty( IMAGE_NAME, targetProperties );
		checkProperty( TENANT_NAME, targetProperties );
		checkProperty( FLAVOR_NAME, targetProperties );
		checkProperty( SECURITY_GROUP, targetProperties );
		checkProperty( KEY_PAIR, targetProperties );
		checkProperty( USER, targetProperties );
		checkProperty( PASSWORD, targetProperties );
	}
238754
protected void validateProperties(final Object entity, final EntityDataModel edm)
            throws ODataException {
        final Type type = edm.getType(entity.getClass());
        // No validation needed if it is not a structured type
        if (!(type instanceof StructuredType)) {
            return;
        }

        visitProperties(edm, (StructuredType) type, property -> {
            Object value = getPropertyValue(property, entity);
            if (value == null) {
                if (!property.isNullable()) {
                    throw new ODataBadRequestException("The property '" + property.getName() +
                            "' is required to be non-empty in an entity of type: " + type.getFullyQualifiedName());
                }
            } else if (!(property instanceof NavigationProperty)) {
                // Validate contained properties, but not if the property is a navigation property.
                // Navigation properties in a request are only links, they don't contain the entity that the
                // navigation property points to itself.
                validateProperties(value, edm);
            }
        });
    }
858928
def validate(self):
        """"""
        if not (isinstance(self.target_class, set) and
                all(isinstance(x, six.string_types) for x in self.target_class)):
            raise TypeError(u'Expected set of string target_class, got: {} {}'.format(
                type(self.target_class).__name__, self.target_class))

        for cls in self.target_class:
            validate_safe_string(cls)
1369530
public void setTargetLocations(java.util.Collection<TargetLocation> targetLocations) {
        if (targetLocations == null) {
            this.targetLocations = null;
            return;
        }

        this.targetLocations = new com.amazonaws.internal.SdkInternalList<TargetLocation>(targetLocations);
    }
659348
public void setTargets(Collection<IPermissionTarget> targets) {

        // clear out any existing targets
        targetMap.clear();

        // add each target to the internal map and index it by the target key
        for (IPermissionTarget target : targets) {
            targetMap.put(target.getKey(), target);
        }
    }
897416
public void setValidUpgradeTarget(java.util.Collection<UpgradeTarget> validUpgradeTarget) {
        if (validUpgradeTarget == null) {
            this.validUpgradeTarget = null;
            return;
        }

        this.validUpgradeTarget = new java.util.ArrayList<UpgradeTarget>(validUpgradeTarget);
    }
812285
def validate_target(self, target):
        """"""

        archs = target.split('/')

        for arch in archs:
            if not arch in self.archs:
                return False

        return True
1295865
private function _validateTargeting()
    {
        $exts = $this->_ac->acinfo()->extensions();
        // if target information extension is not present
        if (!$exts->has(Extension::OID_TARGET_INFORMATION)) {
            return;
        }
        $ext = $exts->get(Extension::OID_TARGET_INFORMATION);
        if ($ext instanceof TargetInformationExtension &&
             !$this->_hasMatchingTarget($ext->targets())) {
            throw new ACValidationException(
                "Attribute certificate doesn't have a matching target.");
        }
    }
1345690
private void checkInvalidClassProperty(String className, String propertyName) {
        if (className != null && propertyName != null) {
            boolean isInvalidCombination = walkInvalidList(className, propertyName, invalidClassProperty);
            if (isInvalidCombination) {
                Tr.error(tc, "DYNA0050E", new Object[] { "'" + propertyName + "'", "'" + className + "'" });
                Tr.error(tc, "dynacache.configerror" /* DYNA0022E */
                         , new Object[] { filename });
            }
        }
    }
523045
protected void validateNamespace(final SqlValidatorNamespace namespace,
		RelDataType targetRowType) {
		namespace.validate(targetRowType);
		if (namespace.getNode() != null) {
			setValidatedNodeType(namespace.getNode(), namespace.getType());
		}
	}
557952
public void setTargetIds(java.util.Collection<String> targetIds) {
        if (targetIds == null) {
            this.targetIds = null;
            return;
        }

        this.targetIds = new com.amazonaws.internal.SdkInternalList<String>(targetIds);
    }
480603
public function validate()
    {
        if (!$this->translations) {
            throw new MappingException(sprintf('No translations specified for %s', $this->name));
        }

        if (!$this->targetEntity) {
            throw new MappingException(sprintf('No translations targetEntity specified for %s', $this->name));
        }
    }
551895
public void setTargetSignificance(String targetSignificance) {

        if (TraceComponent.isAnyTracingEnabled() && TRACE.isDebugEnabled()) {
            SibTr.debug(this, TRACE, "setTargetSignificance", targetSignificance);
        }
        _targetSignificance = targetSignificance;

    }
860971
public void setProperties(Map<String, Object> properties)
    {
        if (this.getTask() != null)
            this.getTask().setProperties(properties);
    }
704956
public static Report validate(final Properties props, final List<Property> properties) {
        final Report report = new Report();
        validate(props, report, properties, null);
        return report;
    }
1181349
public void setProtectedTargets(String... targets) {
        handler.setProtectedTargets(Arrays.copyOf(targets, targets.length));
    }
68577
protected function addMixedTypeValidators($targetClassName, GenericObjectValidator $validator)
    {
        foreach ($this->reflectionService->getClassPropertyNames($targetClassName) as $property) {
            /*
             * If the property already is already bound to an object validator,
             * there is no need to do further checks.
             */
            if ($this->propertyHasObjectValidator($validator, $property)) {
                continue;
            }

            if ($this->propertyIsMixedType($targetClassName, $property)) {
                /*
                 * The property is mixed, a validator with the `mixedTypes`
                 * option is added, to delegate the validator resolving to
                 * later (when the property is actually filled).
                 */
                $objectValidator = $this->createValidator(MixedTypeValidator::class);

                $validator->addPropertyValidator($property, $objectValidator);
            }
        }
    }