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