protected override IScalarValidationErrors ValidateScalars(IScalarValidationErrors result) { for (int i = 0; i < _columnMappings.Length; i++) { var scalar = _columnMappings[i]; var column = scalar.Value; if (column == IGNORE) { continue; } if (column == null) { result = result.Add(new ScalarValidationError(UserMessages.PasteAppendWindow_InputRequired, scalar)); continue; } for (int j = 0; j < i; j++) { if (column == _columnMappings[j].Value) { result = result.Add(new ScalarValidationError(UserMessages.PasteAppendWindow_DuplicateValueNotAllowed, scalar)); continue; } } } return(result); }
internal void UpdateAsyncErrors(ScalarAsyncValidator scalarAsyncValidator) { var sourceScalars = scalarAsyncValidator.SourceScalars; _asyncErrors = Remove(_asyncErrors, x => x.Source.SetEquals(sourceScalars)); _asyncErrors = Merge(_asyncErrors, scalarAsyncValidator.Results); }
private static IScalarValidationErrors Merge(IScalarValidationErrors result, IScalarValidationErrors errors, int count) { for (int i = 0; i < count; i++) { result = result.Add(errors[i]); } return(result); }
protected override IScalarValidationErrors ValidateScalars(IScalarValidationErrors result) { if (_password.GetValue() != _passwordConfirmation.GetValue()) { result = result.Add(new ScalarValidationError("Passwords do not match.", _password.Union(_passwordConfirmation).Seal())); } return(result.Seal()); }
private static IScalarValidationErrors TryAdd(IScalarValidationErrors result, ScalarValidationError error) { if (error != null) { result = result.Add(error); } return(result); }
public static IScalarValidationErrors Validate(IScalarValidationErrors result, Scalar <INamedTypeSymbol> resourceType, Scalar <IPropertySymbol> resourceProperty) { if (resourceType.Value != null && resourceProperty.Value == null) { result = result.Add(new ScalarValidationError(UserMessages.MessageView_ValueIsRequired, resourceProperty)); } return(result); }
public static IScalarValidationErrors Validate(IScalarValidationErrors result, Scalar <INamedTypeSymbol> resourceType, Scalar <IPropertySymbol> resourceProperty, Scalar <string> message) { result = Validate(result, resourceType, resourceProperty); if (resourceType.Value == null && string.IsNullOrWhiteSpace(message.Value)) { result = result.Add(new ScalarValidationError(UserMessages.MessageView_ValueIsRequired, message)); } return(result); }
/// <summary> /// Combines two <see cref="IScalarValidationErrors"/>. /// </summary> /// <param name="source">The source <see cref="IScalarValidationErrors"/>.</param> /// <param name="other">The other <see cref="IScalarValidationErrors"/>.</param> /// <returns>The result <see cref="IScalarValidationErrors"/>.</returns> public static IScalarValidationErrors Add(this IScalarValidationErrors source, IScalarValidationErrors other) { other.VerifyNotNull(nameof(other)); for (int i = 0; i < other.Count; i++) { source = source.Add(other.VerifyNotNull(i, nameof(other))); } return(source); }
internal void ExitEdit() { Debug.Assert(!Presenter.ScalarContainer.IsEditing); _snapshot = null; _flushingErrors = null; Validate(false); _asyncErrors = ScalarValidationErrors.Empty; foreach (var asyncValidator in AsyncValidators) { asyncValidator.Reset(); } }
private void Validate(bool showAll) { if (showAll) { ShowAll(); } ClearErrors(); var errors = _inputManager.PerformValidateScalars(); for (int i = 0; i < errors.Count; i++) { _errors = _errors.Add(errors[i]); } _errors = _errors.Seal(); }
/// <summary> /// Creates a collection of scalar validation errors. /// </summary> /// <param name="values">The scalar validation errors.</param> /// <returns>The collection of scalar validation errors.</returns> public static IScalarValidationErrors New(params ScalarValidationError[] values) { values.VerifyNotNull(nameof(values)); if (values.Length == 0) { return(Empty); } IScalarValidationErrors result = values.VerifyNotNull(0, nameof(values)); for (int i = 1; i < values.Length; i++) { result = result.Add(values.VerifyNotNull(i, nameof(values))); } return(result); }
internal override IScalarValidationErrors Validate(IScalarValidationErrors result) { Debug.Assert(result != null); if (_validators == null) { return(result); } for (int i = 0; i < _validators.Count; i++) { var validator = _validators[i]; var message = validator(GetValue()); if (!string.IsNullOrEmpty(message)) { result = result.Add(new ScalarValidationError(message, this)); } } return(result); }
private static IScalarValidationErrors Remove(IScalarValidationErrors errors, Predicate <ScalarValidationError> predicate) { var result = errors; for (int i = 0; i < errors.Count; i++) { var error = errors[i]; if (predicate(error)) { if (result == errors) { result = Merge(ScalarValidationErrors.Empty, errors, i); } } else { if (result != errors) { result = result.Add(error); } } } return(result); }
/// <summary> /// Performs custom scalar data validation, typically cross multiple <see cref="Scalar{T}"/> objects. /// </summary> /// <param name="existingErrors">The existing validation errors.</param> /// <returns>Validation errors contains both existing errors and custom scalar data validation errors.</returns> /// <remarks>The default implementation returns <paramref name="existingErrors"/> directly.</remarks> protected virtual IScalarValidationErrors ValidateScalars(IScalarValidationErrors existingErrors) { return(existingErrors); }
internal abstract IScalarValidationErrors Validate(IScalarValidationErrors result);
protected override IScalarValidationErrors ValidateScalars(IScalarValidationErrors result) { result = TryAdd(result, Validate(_shouldCreateKey, _keyTypeName)); result = TryAdd(result, Validate(_shouldCreateRef, _refTypeName)); return(result); }
protected override IScalarValidationErrors ValidateScalars(IScalarValidationErrors result) { return(MessageView.Validate(result, _resourceType, _resourceProperty)); }
/// <summary> /// Sets the async validation errors. /// </summary> /// <param name="value">The validation errors.</param> public void SetAsyncErrors(IScalarValidationErrors value) { _asyncErrors = value.Seal(); InvalidateView(); }
private void ClearErrors() { _errors = ScalarValidationErrors.Empty; }
private void UpdateAsyncErrors(IScalars changedScalars) { _asyncErrors = Remove(_asyncErrors, x => x.Source.Overlaps(changedScalars)); }
private static IScalarValidationErrors Merge(IScalarValidationErrors result, IScalarValidationErrors errors) { return(Merge(result, errors, errors.Count)); }