public static ArgBase <Guid> IsNotEmpty(this ArgBase <Guid> arg)
{
if (arg.Value.Equals(Guid.Empty))
{
arg.ThrowArgument("Guid is empty");
}
return(arg);
}
public static ArgBase <T> IsEqualTo <T>(this ArgBase <T> arg, object obj)
{
if (!arg.Value.Equals(obj))
{
throw new NotExpectedException <object>(arg.Value, obj, arg.Name);
}
return(arg);
}
public static void IsValidDhGParameter(this ArgBase <BigInteger> arg, BigInteger prime)
{
var item = arg.Value;
if (item.CompareTo(BigInteger.One) == -1 || prime.Subtract(BigInteger.One).CompareTo(item) == -1)
{
throw new OutOfRangeException <BigInteger>(item, BigInteger.One, prime.Subtract(BigInteger.One), "item");
}
}
public static ArgBase <T> IsLessThan <T>(this ArgBase <T> arg, T param) where T : IComparable
{
if (arg.Value.CompareTo(param) >= 0)
{
arg.ThrowLessThenExpected(param);
}
return(arg);
}
public static ArgBase <T> Is <T, TType>(this ArgBase <T> arg)
{
if (!(arg.Value is TType))
{
arg.ThrowArgument($"Value is not <{typeof(TType).Name}>");
}
return(arg);
}
public static ArgBase <int> IsPositive(this ArgBase <int> arg)
{
if (arg.Value <= 0)
{
arg.ThrowPositiveValueExpected();
}
return(arg);
}
public static ArgBase <int> IsOdd(this ArgBase <int> arg)
{
if (!MathUtil.IsOdd(arg.Value))
{
arg.ThrowOddValueExpected();
}
return(arg);
}
public static ArgBase <long> IsPrime(this ArgBase <long> arg)
{
if (!MathUtil.IsPrime(arg.Value))
{
arg.ThrowPrimeValueExpected();
}
return(arg);
}
public static ArgBase <bool> IsTrue(this ArgBase <bool> arg)
{
if (!arg.Value)
{
arg.ThrowNotEqual(true);
}
return(arg);
}
public static ArgBase <int> IsNegative(this ArgBase <int> arg)
{
if (arg.Value >= 0)
{
arg.ThrowNegativeValueExpected();
}
return(arg);
}
public static ArgBase <T> IsLessThan <T>(this ArgBase <T> arg, Func <T> fun) where T : IComparable
{
if (fun == null)
{
throw new ArgumentNullException(nameof(fun));
}
return(IsLessThan(arg, fun()));
}
public static ArgBase <T> IsGreaterThanOrEqualTo <T>(this ArgBase <T> arg, T param) where T : IComparable
{
if (arg.Value.CompareTo(param) < 0)
{
arg.ThrowGreaterThenExpected(param);
}
return(arg);
}
public static ArgBase <T> IsInRange <T>(this ArgBase <T> arg, T start, T end) where T : IComparable
{
if (arg.Value.CompareTo(start) < 0 || arg.Value.CompareTo(end) > 0)
{
arg.ThrowArgumentOutRange(start, end);
}
return(arg);
}
public static ArgBase <List <T> > Contains <T>(this ArgBase <List <T> > args, T item)
{
if (args.Value.IndexOf(item) == -1)
{
throw new ArgumentException("Item didn't contains in the list");
}
return(args);
}
public static ArgBase <TEnum> IsValidValue <TEnum>(this ArgBase <TEnum> arg)
{
if (!Enum.IsDefined(arg.Value.GetType(), arg.Value))
{
arg.ThrowArgument("Value is not valid");
}
return(arg);
}
public static ArgBase <T> IsLessThanOrEqualTo <T>(this ArgBase <T> arg, Func <T> param) where T : IComparable
{
if (param == null)
{
throw new ArgumentNullException(nameof(param));
}
return(IsLessThanOrEqualTo(arg, param()));
}
public static ArgBase <bool> IsFalse(this ArgBase <bool> arg)
{
if (arg.Value)
{
arg.ThrowNotEqual(false);
}
return(arg);
}
public static void IsValidDhPublicKey(this ArgBase <BigInteger> arg, BigInteger prime)
{
var key = arg.Value;
if (key.CompareTo(BigInteger.Two.Pow(2048 - 64)) == -1 || prime.Subtract(BigInteger.Two.Pow(2048 - 64)).CompareTo(key) == -1)
{
throw new OutOfRangeException <BigInteger>(key, BigInteger.Two.Pow(2048 - 64), prime.Subtract(BigInteger.Two.Pow(2048 - 64)), "item");
}
}
/// <summary>
/// Is the function true for the argument.
/// </summary>
/// <returns></returns>
public static ArgBase <T> IsTrue <T>(this ArgBase <T> arg, Func <T, bool> booleanFunction, string exceptionMessage)
{
if (!booleanFunction(arg.Value))
{
arg.ThrowArgument(exceptionMessage);
}
return(arg);
}
public static ArgBase <T> IsEqual <T>(this ArgBase <T> arg, T param) where T : IComparable
{
if (arg.Value.CompareTo(param) != 0)
{
arg.ThrowNotEqual(param);
}
return(arg);
}
public static ArgBase <T> IsNotNull <T>(this ArgBase <T> arg) where T : class
{
if (arg.Value == null)
{
arg.ThrowArgumentNull();
}
return(arg);
}
public static ArgBase <T> IsOneOf <T>(this ArgBase <T> arg, IReadOnlyList <T> collection)
{
if (!collection.Contains(arg.Value))
{
arg.ThrowArgument(
$"The value of the parameter is not one of {string.Join(", ", collection.Select(x => x.ToString()).ToArray())}");
}
return(arg);
}
/// <summary>
/// Is argument instance of type
/// </summary>
/// <returns></returns>
public static ArgBase <T> Is <T>(this ArgBase <T> arg, Type type)
{
var isType = type.GetTypeInfo().IsInstanceOfType(arg.Value);
if (!isType)
{
arg.ThrowArgument($"Value is not <{type.Name}>");
}
return(arg);
}
public static ArgBase <string> IsNotEmpty(this ArgBase <string> arg)
{
Guard.That(arg.Value).IsNotNull();
if (arg.Value == string.Empty)
{
arg.ThrowArgument("String is empty");
}
return(arg);
}
public static ArgBase <string> IsNotNullOrEmpty(this ArgBase <string> arg)
{
Guard.That(arg.Value).IsNotNull();
if (string.IsNullOrEmpty(arg.Value))
{
arg.ThrowArgument("String is null or empty");
}
return(arg);
}
public static ArgBase <T[]> IsNotEmpty <T>(this ArgBase <T[]> arg)
{
arg.IsNotNull();
if (arg.Value.Length == 0)
{
arg.ThrowArgument("Array is empty");
}
return(arg);
}
/// <summary>
/// Is argument instance of type
/// </summary>
/// <returns></returns>
public static ArgBase <T?> IsNotNull <T>(this ArgBase <T?> arg) where T : struct
{
var value = arg.Value;
if (!value.HasValue)
{
arg.ThrowArgumentNull();
}
return(arg);
}
public static ArgBase <T[]> CountIs <T>(this ArgBase <T[]> arg, int count)
{
arg.IsNotNull();
if (arg.Value.Length != count)
{
throw new NotExpectedException <int>(arg.Value.Length, count, arg.Name);
}
return(arg);
}
public static ArgBase <IEnumerable <T> > Contains <T>(this ArgBase <IEnumerable <T> > arg, T expectedValue)
{
arg.IsNotNull();
if (!arg.Value.Contains(expectedValue))
{
arg.ThrowArgument("Collection does not contain required object");
}
return(arg);
}
public static ArgBase <TEnum> HasFlagSet <TEnum>(this ArgBase <TEnum> arg, TEnum flagValue)
{
var value = arg.Value as Enum;
var flagEnumValue = flagValue as Enum;
if (flagEnumValue != null && !value?.HasFlag(flagEnumValue) == true)
{
arg.ThrowArgument("Value does not have flag set");
}
return(arg);
}
