Check to see if the all the properties in the model are valid
 @return true if the model is valid
435522
def valid?
      return false if @id.nil?
      return false if @name.nil?
      authenticator_validator = EnumAttributeValidator.new('String', ["local", "ldap"])
      return false unless authenticator_validator.valid?(@authenticator)
      return true
    end
33485
public boolean isValid() {
        boolean valid = false;
        try {
            validate();
            valid = true;
        } catch(Exception e) {
            // File is not valid if exception thrown parsing.
            valid = false;
        }
    
        return valid;
    }
531428
def is_valid(self):
        

        if not self:
            return True

        if self.left and self.data[self.axis] < self.left.data[self.axis]:
            return False

        if self.right and self.data[self.axis] > self.right.data[self.axis]:
            return False

        return all(c.is_valid() for c, _ in self.children) or self.is_leaf
517839
@JsonIgnore
    public boolean isValid() {
        if (kty == null) {
            return false;
        }

        if (keyOps != null) {
            final Set<JsonWebKeyOperation> set = new HashSet<JsonWebKeyOperation>(JsonWebKeyOperation.ALL_OPERATIONS);
            for (int i = 0; i < keyOps.size(); i++) {
                if (!set.contains(keyOps.get(i))) {
                    return false;
                }
            }
        }

        if (JsonWebKeyType.OCT.equals(kty)) {
            return isValidOctet();
        } else if (JsonWebKeyType.RSA.equals(kty)) {
            return isValidRsa();
        } else if (JsonWebKeyType.RSA_HSM.equals(kty)) {
            return isValidRsaHsm();
        } else if (JsonWebKeyType.EC.equals(kty)) {
            return isValidEc();
        } else if (JsonWebKeyType.EC_HSM.equals(kty)) {
            return isValidEcHsm();
        }

        return false;
    }
1351372
public boolean isValid() {
        for (ValidationResult result : results) {
            for (ValidationMessage<Origin> message : result.getMessages()) {
                if (Severity.ERROR.equals(message.getSeverity())) {
                    return false;
                }
            }
        }
        return true;
    }
1288023
public boolean isValid() {
        switch (htmlTag) {
            case A :
                return (hasAttr(HtmlAttr.NAME) || hasAttr(HtmlAttr.ID) || (hasAttr(HtmlAttr.HREF) && hasContent()));
            case BR :
                return (!hasContent() && (!hasAttrs() || hasAttr(HtmlAttr.CLEAR)));
            case IFRAME :
                return (hasAttr(HtmlAttr.SRC) && !hasContent());
            case HR :
            case INPUT:
                return (!hasContent());
            case IMG :
                return (hasAttr(HtmlAttr.SRC) && hasAttr(HtmlAttr.ALT) && !hasContent());
            case LINK :
                return (hasAttr(HtmlAttr.HREF) && !hasContent());
            case META :
                return (hasAttr(HtmlAttr.CONTENT) && !hasContent());
            case SCRIPT :
                return ((hasAttr(HtmlAttr.TYPE) && hasAttr(HtmlAttr.SRC) && !hasContent()) ||
                        (hasAttr(HtmlAttr.TYPE) && hasContent()));
            default :
                return hasContent();
        }
    }
453956
public boolean isValid() {

        boolean valid = true;

        switch (shapeType) {

            case POLYLINE_MARKERS:
                valid = ((PolylineMarkers) shape).isValid();
                break;
            case POLYGON_MARKERS:
                valid = ((PolygonMarkers) shape).isValid();
                break;
            case MULTI_POLYLINE_MARKERS:
                valid = ((MultiPolylineMarkers) shape).isValid();
                break;
            case MULTI_POLYGON_MARKERS:
                valid = ((MultiPolygonMarkers) shape).isValid();
                break;
            case COLLECTION:
                @SuppressWarnings("unchecked")
                List<GoogleMapShape> shapeList = (List<GoogleMapShape>) shape;
                for (GoogleMapShape shapeListItem : shapeList) {
                    valid = shapeListItem.isValid();
                    if (!valid) {
                        break;
                    }
                }
                break;
            default:
        }

        return valid;
    }
793784
def is_valid(self):
        
        self.errors = []

        for field in self.get_all_field_names_declared_by_user():
            getattr(type(self), field).is_valid(self, type(self), field)
            field_errors = getattr(type(self), field).errors(self)
            self.errors.extend(field_errors)

        return len(self.errors) == 0
503890
@JSFProperty(defaultValue = "true", tagExcluded = true)
    public boolean isValid()
    {
        Object value = getStateHelper().get(PropertyKeys.valid);
        if (value != null)
        {
            return (Boolean) value;        
        }
        return true; 
    }
799689
def is_valid(self):
        
        self._errors = []
        for field in self.fields:
            try:
                field.validate(self)
            except FieldValidationError, e:
                self._errors.extend(e.errors)
        self.validate()
        return not bool(self._errors)
867896
public function valid(): bool
    {
        $key = key($this->collection);

        return $key !== null && $key !== false;
    }
1337577
public boolean isValid() {
    boolean result = true;

    // The username attribute will always be required.
    result = (this.getUsername() != null);

    if (result == true && this.requiredTokenAttributes != null) {
      for (String attr : this.requiredTokenAttributes) {
        if (this.get(attr) == null) {
          result = false;
          break;
        }
      }
    }

    return result;
  }
373799
public boolean valid()
    {
        boolean valid = true;
        if (tc.isEntryEnabled())
            Tr.entry(tc, "valid", this);
        if (_status == STATUS_INVALID)
            valid = false;
        if (tc.isEntryEnabled())
            Tr.exit(tc, "valid", new Boolean(valid));
        return valid;
    }
153670
def valid?
      object_type_validator = EnumAttributeValidator.new('String', ["ITEM", "DISCOUNT", "CATEGORY", "PLACEHOLDER"])
      return false unless object_type_validator.valid?(@object_type)
      placeholder_type_validator = EnumAttributeValidator.new('String', ["ALL_ITEMS", "DISCOUNTS_CATEGORY", "REWARDS_FINDER"])
      return false unless placeholder_type_validator.valid?(@placeholder_type)
      return true
    end
1187340
public boolean isValidProperty(String strProperty)
    {
        if (m_rgstrValidParams != null)
        {
            for (int i = 0; i < m_rgstrValidParams.length; i++)
            {
                if (m_rgstrValidParams[i].equalsIgnoreCase(strProperty))
                { // Valid property
                    if (m_strCurrentProperty != strProperty)
                    {
                        return true;    // Valid property
                    }
                }
            }
        }
        return false;   // Not a valid property
    }
83864
public function isValid() {

		if(!isset($this->valid)) {
            $this->valid = $this->applyValidators(
                $this->applyModifiers($this->getValue())
            );
		}

		return $this->valid;

	}
529852
public function valid()
    {

        $allowedValues = $this->getTypeAllowableValues();
        if (!in_array($this->container['type'], $allowedValues)) {
            return false;
        }
        return true;
    }