Checks if all fields are valid.<p>

@return true, if all data are ok.
424212
@SuppressWarnings("unchecked")
    protected boolean isValid() {

        boolean res = true;

        res = res & m_description.isValid();
        res = res & m_name.isValid();
        if (!res) {
            return res;
        }
        for (I_CmsEditableGroupRow row : m_ouResources.getRows()) {
            if (!((AbstractField<String>)row.getComponent()).isValid()) {
                return false;
            }
        }
        return true;
    }
1298004
protected function checkRequiredFields()
    {
        if (empty($this->toAddresses)) {
            return false;
        }
        if (empty($this->subject)) {
            return false;
        }

        if (empty($this->plainMessage) && empty($this->htmlMessage) && empty($this->attachments)) {
            return false;
        }

        return true;
    }
204439
public boolean validate() {

        if (m_end >= m_length) {
            m_end = m_length - 1;
        }

        return ((m_start >= 0) && (m_end >= 0) && (m_start <= m_end) && (m_length > 0));
    }
1257875
protected boolean validate(boolean validateEmptyFields) {
        boolean isValid = false;
        String value = dataType == PASSWORD ? getText() : getText().trim();
        if (!validateEmptyFields && value.isEmpty()) {
            return true;
        }

        switch (dataType) {
            case TEXT_NAME:
            case NUMBER:
            case PASSWORD:
            case NON_EMPTY_USERNAME:
                isValid = !value.isEmpty();
                break;
            case EMAIL:
                isValid = value.matches(EMAIL_REGEX);
                break;
            case USERNAME:
                isValid = value.matches(USERNAME_REGEX) && value.length() >= 1 && value.length() <= 15;
                break;
            case USERNAME_OR_EMAIL:
                final boolean validEmail = value.matches(EMAIL_REGEX);
                final boolean validUsername = value.matches(USERNAME_REGEX) && value.length() >= 1 && value.length() <= 15;
                isValid = validEmail || validUsername;
                break;
            case MOBILE_PHONE:
            case PHONE_NUMBER:
                isValid = value.matches(PHONE_NUMBER_REGEX);
                break;
            case MFA_CODE:
                isValid = value.matches(CODE_REGEX);
                break;
        }

        Log.v(TAG, "Field validation results: Is valid? " + isValid);
        return isValid;
    }
871748
private boolean validateParameters() {

        boolean allOk = true;

        StringBuffer validationErrors = new StringBuffer(32);
        CmsMessages messages = Messages.get().getBundle(getLocale());

        // check resource parameter presence
        if (CmsStringUtil.isEmptyOrWhitespaceOnly(getParamResource()) || !getCms().existsResource(getParamResource())) {
            allOk = false;
            validationErrors.append(messages.key(Messages.GUI_PROP_CHANGE_VALIDATE_VFS_RESOURCE_0)).append("<br>");
        }

        // check selected property name
        if (CmsStringUtil.isEmptyOrWhitespaceOnly(getParamPropertyName())) {
            allOk = false;
            validationErrors.append(messages.key(Messages.GUI_PROP_CHANGE_VALIDATE_SELECT_PROPERTY_0)).append("<br>");
        }

        // check old property value to look up
        if (CmsStringUtil.isEmptyOrWhitespaceOnly(getParamOldValue())) {
            allOk = false;
            validationErrors.append(messages.key(Messages.GUI_PROP_CHANGE_VALIDATE_OLD_PROP_VALUE_0)).append("<br>");
        } else {
            try {
                // check if there is a place holder in the expression pattern
                // remove it here, because otherwise this is no valid expression pattern
                String oldValue = getParamOldValue();
                if (oldValue.contains(CmsStringUtil.PLACEHOLDER_START)
                    && oldValue.contains(CmsStringUtil.PLACEHOLDER_END)) {
                    oldValue = oldValue.replace(CmsStringUtil.PLACEHOLDER_START, "");
                    oldValue = oldValue.replace(CmsStringUtil.PLACEHOLDER_END, "");
                }
                // compile regular expression pattern
                Pattern.compile(oldValue);
            } catch (PatternSyntaxException e) {
                allOk = false;
                validationErrors.append(messages.key(Messages.GUI_PROP_CHANGE_VALIDATE_OLD_PROP_PATTERN_0)).append(
                    "<br>");
            }
        }

        // check new property value
        if (CmsStringUtil.isEmptyOrWhitespaceOnly(getParamNewValue())) {
            // if no new value was given, set it to the delete value
            setParamNewValue(CmsProperty.DELETE_VALUE);
        }

        setErrorMessage(validationErrors.toString());
        setValidationErrors(!allOk);
        return allOk;
    }
857671
public function is_valid() {
        $ret = false;

        if (is_null($this->division) === false && is_null($this->datafileURI) === false &&
            is_null($this->subscribe) === false && is_null($this->profileUpdate) === false &&
            is_null($this->listLoadName) === false && is_null($this->loadMode) === false &&
            is_null($this->headers) === false && is_null($this->maxErrors) === false &&
            is_null($this->errorType) === false
        ) {
            $ret = true;
        }

        return $ret;
    }
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;
    }
607029
public function isValid()
    {
        $result = true;
        $fields = $this->getFields();
        // Check each element for validators, validate them and return the result.
        foreach ($fields as $field) {
            if ($field->validate() == false) {
                $result = false;
            }
        }
        return $result;
    }
1082766
public function valid()
    {
        if (isset($this->buffer[$this->position])) {
            return (bool) $this->buffer[$this->position];
        }
        $this->ensurePosition();
        return $this->resultSet->valid();
    }
347840
private void validateData( )
	{
        boolean isValid = ( m_queryTextField != null &&
            getQueryText() != null && getQueryText().trim().length() > 0 );

        if( isValid )
            setMessage( DEFAULT_MESSAGE );
        else
            setMessage( "Requires input value.", ERROR );

		setPageComplete( isValid );
	}
701601
public function isValid()
    {
        $value = $this->field->getValue();

        // field is empty and its not required. It's thus valid.
        if ($value == '' && $this->required == false) {
            return true;
        }

        $parsedDate = date_parse($value);

        if ($parsedDate['warning_count'] == 0 &&
            $parsedDate['error_count'] == 0 &&
            isset($parsedDate['year']) &&
            isset($parsedDate['month'])
        ) {
            return true;
        }

        return false;
    }
442175
private boolean checkField(EditText editText) {
        boolean valid = true;
        if (TextUtils.isEmpty(editText.getText())) {
            editText.startAnimation(mWiggle);
            editText.requestFocus();
            valid = false;
        }
        return valid;
    }
1228052
boolean checkValidation() {

        boolean result;
        if (m_changedEntityIds.isEmpty()) {
            result = true;
        } else if (m_saveButton.isEnabled()) {
            result = true;
        } else {
            result = false;
            CmsNotification.get().send(Type.ERROR, m_saveButton.getDisabledReason());
        }
        return result;
    }
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;
    }
176089
public boolean isNull()
    {   // Return true if all non null fields have data in them
        int fieldCount = this.getFieldCount();  // BaseField Count
        for (int fieldSeq = DBConstants.MAIN_FIELD; fieldSeq < fieldCount+DBConstants.MAIN_FIELD; fieldSeq++)
        {
            BaseField field = this.getField(fieldSeq);
            if ((!field.isNullable()) && (field.isNull()))
                return true;            // This field can't be null!!!
        }
        return false;   // All fields okay
    }
1210039
public boolean isValid() {

        boolean valid = true;
        for (Component comp : this) {
            if (comp instanceof TextField) {
                valid = valid && ((TextField)comp).isValid();
            }
        }
        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