public static string LessThan <T>(IArg <T> arg, T min)
{
if (!arg.HasName)
{
return(string.Format("The value '{0}' is less than '{1}'", arg.Value, min));
}
return(string.Format("The value '{0}' of '{1}' is less than '{2}'", arg.Value, arg.Name.Value, min));
}
public static string LargerThan <T>(IArg <T> arg, T max)
{
if (!arg.HasName)
{
return(string.Format("The value '{0}' is larger than '{1}'", arg.Value, max));
}
return(string.Format("The value '{0}' of '{1}' is larger than '{2}'", arg.Value, arg.Name.Value, max));
}
public static IArg <T> IsLessThan <T>(this IArg <T> arg, Func <T> param) where T : IComparable
{
if (arg.Value.CompareTo(param()) >= 0)
{
arg.Message.SetArgumentOutRange();
}
return(arg);
}
public static IArg <T[]> IsNotEmpty <T>(this IArg <T[]> arg)
{
if (arg.Value == null || arg.Value.Length == 0)
{
arg.Message.Set("Array is empty");
}
return(arg);
}
public static IArg <string> IsNotEmpty(this IArg <string> arg)
{
if (arg.Value == string.Empty)
{
arg.Message.Set("String is empty");
}
return(arg);
}
public static IArg <string> IsNotNullOrWhiteSpace(this IArg <string> arg)
{
if (arg.Value.IsNullOrWhiteSpace())
{
arg.Message.Set("String is null or whitespace");
}
return(arg);
}
public static IArg <string> Length(this IArg <string> arg, int length)
{
if (arg.Value.Length != length)
{
arg.Message.Set("String have wrong length");
}
return(arg);
}
public static IArg <string> Contains(this IArg <string> arg, string value)
{
if (!arg.Value.Contains(value))
{
arg.Message.Set(string.Format("String must contain <{0}>", value));
}
return(arg);
}
public static IArg <string> IsNotNullOrEmpty(this IArg <string> arg)
{
if (string.IsNullOrEmpty(arg.Value))
{
arg.Message.Set("String is null or empty");
}
return(arg);
}
public static IArg <string> EndsWith(this IArg <string> arg, string value)
{
if (!arg.Value.EndsWith(value))
{
arg.Message.Set(string.Format("String must end with <{0}>", value));
}
return(arg);
}
public static IArg <T[]> CountIs <T>(this IArg <T[]> arg, int count)
{
if (arg.Value == null || arg.Value.Length != count)
{
arg.Message.SetArgumentOutRange();
}
return(arg);
}
public static IArg <T> IsNotNull <T>(this IArg <T> arg) where T : class
{
if (arg.Value == null)
{
arg.Message.SetArgumentNull();
}
return(arg);
}
public static IArg <ICollection> IsNotEmpty(this IArg <ICollection> arg)
{
if (arg.Value.Count > 0)
{
arg.Message.Set("Collection is empty");
}
return(arg);
}
public static IArg <Guid> IsNotEmpty(this IArg <Guid> arg)
{
if (Guid.Empty.Equals(arg.Value))
{
arg.Message.Set("Guid is empty");
}
return(arg);
}
public static IArg <TEnum> IsValidValue <TEnum>(this IArg <TEnum> arg)
{
if (!Enum.IsDefined(arg.Value.GetType(), arg.Value))
{
arg.Message.Set("Value is not valid");
}
return(arg);
}
public static IArg <IEnumerable <T> > IsNotEmpty <T>(this IArg <IEnumerable <T> > arg)
{
if (!arg.Value.Any())
{
arg.Message.Set("Collection is empty");
}
return(arg);
}
public static IArg <IEnumerable <T> > Contains <T>(this IArg <IEnumerable <T> > arg, Func <T, bool> predicate)
{
if (!arg.Value.Any(predicate))
{
arg.Message.Set("Collection does not contain required object");
}
return(arg);
}
public static IArg <bool> IsTrue(this IArg <bool> arg)
{
#if !NET35
Contract.Requires(arg != null);
Contract.Ensures(arg != null);
Contract.Ensures(Contract.Result <IArg <bool> >() != null);
#endif
return(IsValid(arg, true));
}
public static IArg <T> IsInRange <T>(this IArg <T> arg, T start, T end) where T : IComparable
{
if (arg.Value.CompareTo(start) < 0 || arg.Value.CompareTo(end) > 0)
{
arg.Message.SetArgumentOutRange();
}
return(arg);
}
private static IArg<bool> IsValid(IArg<bool> arg, bool expected)
{
if (arg.Value != expected)
{
arg.Message.SetArgumentOutRange();
}
return arg;
}
private static IArg <bool> IsValid(IArg <bool> arg, bool expected)
{
if (arg.Value != expected)
{
arg.Message.SetArgumentOutRange();
}
return(arg);
}
public static IArg <long> IsPrime(this IArg <long> arg)
{
if (!MathUtil.IsPrime(arg.Value))
{
arg.Message.Set("Not a prime number");
}
return(arg);
}
public static IArg <int> IsOdd(this IArg <int> arg)
{
if (!MathUtil.IsOdd(arg.Value))
{
arg.Message.SetArgumentOutRange();
}
return(arg);
}
public static IArg <T> WithExceptions <T>(this IArg <T> arg, Action <T, IEnumerable <ErrorInfo> > handleErrorsAction) where T : IComparable
{
if (arg.Errors != null && arg.Errors.Any())
{
handleErrorsAction(arg.Value, arg.Errors);
}
return(arg);
}
public static IArg <long> IsEven(this IArg <long> arg)
{
if (!MathUtil.IsEven(arg.Value))
{
arg.Message.SetArgumentOutRange();
}
return(arg);
}
public static IArg <int> IsNegative(this IArg <int> arg)
{
if (arg.Value >= 0)
{
arg.Message.Set("Is not negative");
}
return(arg);
}
public static IArg <T> IsLessThan <T>(this IArg <T> arg, T param) where T : IComparable
{
#if !NET35
Contract.Requires(arg != null);
Contract.Requires(param != null);
Contract.Ensures(Contract.Result <IArg <T> >() != null);
#endif
return(IsLessThan(arg, () => param));
}
public static IArg <int> IsPositive(this IArg <int> arg)
{
if (arg.Value <= 0)
{
arg.Message.Set("Is not positive");
}
return(arg);
}
public static IArg <T> IsOneOf <T>(this IArg <T> arg, IEnumerable <T> collection)
{
if (!collection.Contains(arg.Value))
{
arg.Message.Set(string.Format("The value of the parameter is not one of {0}", string.Join(", ", collection.Select(x => x.ToString()).ToArray())));
}
return(arg);
}
/// <summary>
/// Is the function true for the argument.
/// </summary>
/// <returns></returns>
public static IArg <T> IsTrue <T>(this IArg <T> arg, Func <T, bool> booleanFunction, string exceptionMessage)
{
if (!booleanFunction(arg.Value))
{
arg.Message.Set(exceptionMessage);
}
return(arg);
}
/// <summary>
/// Is argument not the default value
/// </summary>
/// <returns></returns>
public static IArg <T> IsNotDefault <T>(this IArg <T> arg)
{
if (default(T).Equals(arg.Value))
{
arg.Message.Set("Value cannot be the default value.");
}
return(arg);
}
public Apply()
{
poperateur = TOp.Null;
pargument1 = pargument2 = null;
}
