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));
}
