Skip to content

Commit

Permalink
Readonly structs (#126)
Browse files Browse the repository at this point in the history 
* Make the base structs readonly so they don't get copied on the stack

* Add 'in' modifier
  • Loading branch information
@ndrwrbgs @danielwertheim
ndrwrbgs authored and danielwertheim committed Dec 9, 2019
1 parent d201604 commit 8b1a26e
Show file tree
Hide file tree
Showing 12 changed files with 126 additions and 126 deletions.
62 changes: 31 additions & 31 deletions src/projects/EnsureThat/EnsureThatCollectionExtensions.cs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -7,97 +7,97 @@ namespace EnsureThat
{
public static class EnsureThatCollectionExtensions
{
public static void HasItems<T>(this Param<T> param) where T : class, ICollection
public static void HasItems<T>(this in Param<T> param) where T : class, ICollection
=> Ensure.Collection.HasItems(param.Value, param.Name, param.OptsFn);

public static void HasItems<T>(this Param<Collection<T>> param)
public static void HasItems<T>(this in Param<Collection<T>> param)
=> Ensure.Collection.HasItems(param.Value, param.Name, param.OptsFn);

public static void HasItems<T>(this Param<ICollection<T>> param)
public static void HasItems<T>(this in Param<ICollection<T>> param)
=> Ensure.Collection.HasItems(param.Value, param.Name, param.OptsFn);

public static void HasItems<T>(this Param<T[]> param)
public static void HasItems<T>(this in Param<T[]> param)
=> Ensure.Collection.HasItems(param.Value, param.Name, param.OptsFn);

public static void HasItems<T>(this Param<List<T>> param)
public static void HasItems<T>(this in Param<List<T>> param)
=> Ensure.Collection.HasItems(param.Value, param.Name, param.OptsFn);

public static void HasItems<T>(this Param<IList<T>> param)
public static void HasItems<T>(this in Param<IList<T>> param)
=> Ensure.Collection.HasItems(param.Value, param.Name, param.OptsFn);

public static void HasItems<T>(this Param<HashSet<T>> param)
public static void HasItems<T>(this in Param<HashSet<T>> param)
=> Ensure.Collection.HasItems(param.Value, param.Name, param.OptsFn);

public static void HasItems<T>(this Param<ISet<T>> param)
public static void HasItems<T>(this in Param<ISet<T>> param)
=> Ensure.Collection.HasItems(param.Value, param.Name, param.OptsFn);

public static void HasItems<TKey, TValue>(this Param<Dictionary<TKey, TValue>> param)
public static void HasItems<TKey, TValue>(this in Param<Dictionary<TKey, TValue>> param)
=> Ensure.Collection.HasItems(param.Value, param.Name, param.OptsFn);

public static void HasItems<TKey, TValue>(this Param<IDictionary<TKey, TValue>> param)
public static void HasItems<TKey, TValue>(this in Param<IDictionary<TKey, TValue>> param)
=> Ensure.Collection.HasItems(param.Value, param.Name, param.OptsFn);

public static void HasItems<T>(this Param<IReadOnlyCollection<T>> param)
public static void HasItems<T>(this in Param<IReadOnlyCollection<T>> param)
=> Ensure.Collection.HasItems(param.Value, param.Name, param.OptsFn);

public static void HasItems<T>(this Param<IReadOnlyList<T>> param)
public static void HasItems<T>(this in Param<IReadOnlyList<T>> param)
=> Ensure.Collection.HasItems(param.Value, param.Name, param.OptsFn);

public static void SizeIs<T>(this Param<T[]> param, int expected)
public static void SizeIs<T>(this in Param<T[]> param, int expected)
=> Ensure.Collection.SizeIs(param.Value, expected, param.Name, param.OptsFn);

public static void SizeIs<T>(this Param<T[]> param, long expected)
public static void SizeIs<T>(this in Param<T[]> param, long expected)
=> Ensure.Collection.SizeIs(param.Value, expected, param.Name, param.OptsFn);

public static void SizeIs<T>(this Param<T> param, int expected) where T : class, ICollection
public static void SizeIs<T>(this in Param<T> param, int expected) where T : class, ICollection
=> Ensure.Collection.SizeIs(param.Value, expected, param.Name, param.OptsFn);

public static void SizeIs<T>(this Param<T> param, long expected) where T : class, ICollection
public static void SizeIs<T>(this in Param<T> param, long expected) where T : class, ICollection
=> Ensure.Collection.SizeIs(param.Value, expected, param.Name, param.OptsFn);

public static void SizeIs<T>(this Param<ICollection<T>> param, int expected)
public static void SizeIs<T>(this in Param<ICollection<T>> param, int expected)
=> Ensure.Collection.SizeIs(param.Value, expected, param.Name, param.OptsFn);

public static void SizeIs<T>(this Param<ICollection<T>> param, long expected)
public static void SizeIs<T>(this in Param<ICollection<T>> param, long expected)
=> Ensure.Collection.SizeIs(param.Value, expected, param.Name, param.OptsFn);

public static void SizeIs<T>(this Param<IList<T>> param, int expected)
public static void SizeIs<T>(this in Param<IList<T>> param, int expected)
=> Ensure.Collection.SizeIs(param.Value, expected, param.Name, param.OptsFn);

public static void SizeIs<T>(this Param<IList<T>> param, long expected)
public static void SizeIs<T>(this in Param<IList<T>> param, long expected)
=> Ensure.Collection.SizeIs(param.Value, expected, param.Name, param.OptsFn);

public static void SizeIs<TKey, TValue>(this Param<IDictionary<TKey, TValue>> param, int expected)
public static void SizeIs<TKey, TValue>(this in Param<IDictionary<TKey, TValue>> param, int expected)
=> Ensure.Collection.SizeIs(param.Value, expected, param.Name, param.OptsFn);

public static void SizeIs<TKey, TValue>(this Param<IDictionary<TKey, TValue>> param, long expected)
public static void SizeIs<TKey, TValue>(this in Param<IDictionary<TKey, TValue>> param, long expected)
=> Ensure.Collection.SizeIs(param.Value, expected, param.Name, param.OptsFn);

public static void ContainsKey<TKey, TValue>(this Param<IDictionary<TKey, TValue>> param, TKey key)
public static void ContainsKey<TKey, TValue>(this in Param<IDictionary<TKey, TValue>> param, TKey key)
=> Ensure.Collection.ContainsKey(param.Value, key, param.Name, param.OptsFn);

public static void ContainsKey<TKey, TValue>(this Param<Dictionary<TKey, TValue>> param, TKey key)
public static void ContainsKey<TKey, TValue>(this in Param<Dictionary<TKey, TValue>> param, TKey key)
=> Ensure.Collection.ContainsKey(param.Value, key, param.Name, param.OptsFn);

public static void HasAny<T>(this Param<IList<T>> param, Func<T, bool> predicate)
public static void HasAny<T>(this in Param<IList<T>> param, Func<T, bool> predicate)
=> Ensure.Collection.HasAny(param.Value, predicate, param.Name, param.OptsFn);

public static void HasAny<T>(this Param<List<T>> param, Func<T, bool> predicate)
public static void HasAny<T>(this in Param<List<T>> param, Func<T, bool> predicate)
=> Ensure.Collection.HasAny(param.Value, predicate, param.Name, param.OptsFn);

public static void HasAny<T>(this Param<ICollection<T>> param, Func<T, bool> predicate)
public static void HasAny<T>(this in Param<ICollection<T>> param, Func<T, bool> predicate)
=> Ensure.Collection.HasAny(param.Value, predicate, param.Name, param.OptsFn);

public static void HasAny<T>(this Param<Collection<T>> param, Func<T, bool> predicate)
public static void HasAny<T>(this in Param<Collection<T>> param, Func<T, bool> predicate)
=> Ensure.Collection.HasAny(param.Value, predicate, param.Name, param.OptsFn);

public static void HasAny<TKey, TValue>(this Param<IDictionary<TKey, TValue>> param, Func<KeyValuePair<TKey, TValue>, bool> predicate)
public static void HasAny<TKey, TValue>(this in Param<IDictionary<TKey, TValue>> param, Func<KeyValuePair<TKey, TValue>, bool> predicate)
=> Ensure.Collection.HasAny(param.Value, predicate, param.Name, param.OptsFn);

public static void HasAny<TKey, TValue>(this Param<Dictionary<TKey, TValue>> param, Func<KeyValuePair<TKey, TValue>, bool> predicate)
public static void HasAny<TKey, TValue>(this in Param<Dictionary<TKey, TValue>> param, Func<KeyValuePair<TKey, TValue>, bool> predicate)
=> Ensure.Collection.HasAny(param.Value, predicate, param.Name, param.OptsFn);

public static void HasAny<T>(this Param<T[]> param, Func<T, bool> predicate)
public static void HasAny<T>(this in Param<T[]> param, Func<T, bool> predicate)
=> Ensure.Collection.HasAny(param.Value, predicate, param.Name, param.OptsFn);
}
}
14 changes: 7 additions & 7 deletions src/projects/EnsureThat/EnsureThatComparableDateTimeExtensions.cs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -4,25 +4,25 @@ namespace EnsureThat
{
public static class EnsureThatComparableDateTimeExtensions
{
public static void Is(this Param<DateTime> param, DateTime expected)
public static void Is(this in Param<DateTime> param, DateTime expected)
=> Ensure.Comparable.Is(param.Value, expected, param.Name, param.OptsFn);

public static void IsNot(this Param<DateTime> param, DateTime expected)
public static void IsNot(this in Param<DateTime> param, DateTime expected)
=> Ensure.Comparable.IsNot(param.Value, expected, param.Name, param.OptsFn);

public static void IsLt(this Param<DateTime> param, DateTime limit)
public static void IsLt(this in Param<DateTime> param, DateTime limit)
=> Ensure.Comparable.IsLt(param.Value, limit, param.Name, param.OptsFn);

public static void IsLte(this Param<DateTime> param, DateTime limit)
public static void IsLte(this in Param<DateTime> param, DateTime limit)
=> Ensure.Comparable.IsLte(param.Value, limit, param.Name, param.OptsFn);

public static void IsGt(this Param<DateTime> param, DateTime limit)
public static void IsGt(this in Param<DateTime> param, DateTime limit)
=> Ensure.Comparable.IsGt(param.Value, limit, param.Name, param.OptsFn);

public static void IsGte(this Param<DateTime> param, DateTime limit)
public static void IsGte(this in Param<DateTime> param, DateTime limit)
=> Ensure.Comparable.IsGte(param.Value, limit, param.Name, param.OptsFn);

public static void IsInRange(this Param<DateTime> param, DateTime min, DateTime max)
public static void IsInRange(this in Param<DateTime> param, DateTime min, DateTime max)
=> Ensure.Comparable.IsInRange(param.Value, min, max, param.Name, param.OptsFn);
}
}
14 changes: 7 additions & 7 deletions src/projects/EnsureThat/EnsureThatComparableDecimalExtensions.cs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2,25 +2,25 @@
{
public static class EnsureThatComparableDecimalExtensions
{
public static void Is(this Param<decimal> param, decimal expected)
public static void Is(this in Param<decimal> param, decimal expected)
=> Ensure.Comparable.Is(param.Value, expected, param.Name, param.OptsFn);

public static void IsNot(this Param<decimal> param, decimal expected)
public static void IsNot(this in Param<decimal> param, decimal expected)
=> Ensure.Comparable.IsNot(param.Value, expected, param.Name, param.OptsFn);

public static void IsLt(this Param<decimal> param, decimal limit)
public static void IsLt(this in Param<decimal> param, decimal limit)
=> Ensure.Comparable.IsLt(param.Value, limit, param.Name, param.OptsFn);

public static void IsLte(this Param<decimal> param, decimal limit)
public static void IsLte(this in Param<decimal> param, decimal limit)
=> Ensure.Comparable.IsLte(param.Value, limit, param.Name, param.OptsFn);

public static void IsGt(this Param<decimal> param, decimal limit)
public static void IsGt(this in Param<decimal> param, decimal limit)
=> Ensure.Comparable.IsGt(param.Value, limit, param.Name, param.OptsFn);

public static void IsGte(this Param<decimal> param, decimal limit)
public static void IsGte(this in Param<decimal> param, decimal limit)
=> Ensure.Comparable.IsGte(param.Value, limit, param.Name, param.OptsFn);

public static void IsInRange(this Param<decimal> param, decimal min, decimal max)
public static void IsInRange(this in Param<decimal> param, decimal min, decimal max)
=> Ensure.Comparable.IsInRange(param.Value, min, max, param.Name, param.OptsFn);
}
}
14 changes: 7 additions & 7 deletions src/projects/EnsureThat/EnsureThatComparableDoubleExtensions.cs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2,25 +2,25 @@
{
public static class EnsureThatComparableDoubleExtensions
{
public static void Is(this Param<double> param, double expected)
public static void Is(this in Param<double> param, double expected)
=> Ensure.Comparable.Is(param.Value, expected, param.Name, param.OptsFn);

public static void IsNot(this Param<double> param, double expected)
public static void IsNot(this in Param<double> param, double expected)
=> Ensure.Comparable.IsNot(param.Value, expected, param.Name, param.OptsFn);

public static void IsLt(this Param<double> param, double limit)
public static void IsLt(this in Param<double> param, double limit)
=> Ensure.Comparable.IsLt(param.Value, limit, param.Name, param.OptsFn);

public static void IsLte(this Param<double> param, double limit)
public static void IsLte(this in Param<double> param, double limit)
=> Ensure.Comparable.IsLte(param.Value, limit, param.Name, param.OptsFn);

public static void IsGt(this Param<double> param, double limit)
public static void IsGt(this in Param<double> param, double limit)
=> Ensure.Comparable.IsGt(param.Value, limit, param.Name, param.OptsFn);

public static void IsGte(this Param<double> param, double limit)
public static void IsGte(this in Param<double> param, double limit)
=> Ensure.Comparable.IsGte(param.Value, limit, param.Name, param.OptsFn);

public static void IsInRange(this Param<double> param, double min, double max)
public static void IsInRange(this in Param<double> param, double min, double max)
=> Ensure.Comparable.IsInRange(param.Value, min, max, param.Name, param.OptsFn);
}
}
28 changes: 14 additions & 14 deletions src/projects/EnsureThat/EnsureThatComparableExtensions.cs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -5,46 +5,46 @@ namespace EnsureThat
{
public static class EnsureThatComparableExtensions
{
public static void Is<T>(this Param<T> param, T expected) where T : IComparable<T>
public static void Is<T>(this in Param<T> param, T expected) where T : IComparable<T>
=> Ensure.Comparable.Is(param.Value, expected, param.Name, param.OptsFn);

public static void Is<T>(this Param<T> param, T expected, IComparer<T> comparer) where T : IComparable<T>
public static void Is<T>(this in Param<T> param, T expected, IComparer<T> comparer) where T : IComparable<T>
=> Ensure.Comparable.Is(param.Value, expected, comparer, param.Name, param.OptsFn);

public static void IsNot<T>(this Param<T> param, T expected) where T : IComparable<T>
public static void IsNot<T>(this in Param<T> param, T expected) where T : IComparable<T>
=> Ensure.Comparable.IsNot(param.Value, expected, param.Name, param.OptsFn);

public static void IsNot<T>(this Param<T> param, T expected, IComparer<T> comparer) where T : IComparable<T>
public static void IsNot<T>(this in Param<T> param, T expected, IComparer<T> comparer) where T : IComparable<T>
=> Ensure.Comparable.IsNot(param.Value, expected, comparer, param.Name, param.OptsFn);

public static void IsLt<T>(this Param<T> param, T limit) where T : IComparable<T>
public static void IsLt<T>(this in Param<T> param, T limit) where T : IComparable<T>
=> Ensure.Comparable.IsLt(param.Value, limit, param.Name, param.OptsFn);

public static void IsLt<T>(this Param<T> param, T limit, IComparer<T> comparer) where T : IComparable<T>
public static void IsLt<T>(this in Param<T> param, T limit, IComparer<T> comparer) where T : IComparable<T>
=> Ensure.Comparable.IsLt(param.Value, limit, comparer, param.Name, param.OptsFn);

public static void IsLte<T>(this Param<T> param, T limit) where T : IComparable<T>
public static void IsLte<T>(this in Param<T> param, T limit) where T : IComparable<T>
=> Ensure.Comparable.IsLte(param.Value, limit, param.Name, param.OptsFn);

public static void IsLte<T>(this Param<T> param, T limit, IComparer<T> comparer) where T : IComparable<T>
public static void IsLte<T>(this in Param<T> param, T limit, IComparer<T> comparer) where T : IComparable<T>
=> Ensure.Comparable.IsLte(param.Value, limit, comparer, param.Name, param.OptsFn);

public static void IsGt<T>(this Param<T> param, T limit) where T : IComparable<T>
public static void IsGt<T>(this in Param<T> param, T limit) where T : IComparable<T>
=> Ensure.Comparable.IsGt(param.Value, limit, param.Name, param.OptsFn);

public static void IsGt<T>(this Param<T> param, T limit, IComparer<T> comparer) where T : IComparable<T>
public static void IsGt<T>(this in Param<T> param, T limit, IComparer<T> comparer) where T : IComparable<T>
=> Ensure.Comparable.IsGt(param.Value, limit, comparer, param.Name, param.OptsFn);

public static void IsGte<T>(this Param<T> param, T limit) where T : IComparable<T>
public static void IsGte<T>(this in Param<T> param, T limit) where T : IComparable<T>
=> Ensure.Comparable.IsGte(param.Value, limit, param.Name, param.OptsFn);

public static void IsGte<T>(this Param<T> param, T limit, IComparer<T> comparer) where T : IComparable<T>
public static void IsGte<T>(this in Param<T> param, T limit, IComparer<T> comparer) where T : IComparable<T>
=> Ensure.Comparable.IsGte(param.Value, limit, comparer, param.Name, param.OptsFn);

public static void IsInRange<T>(this Param<T> param, T min, T max) where T : IComparable<T>
public static void IsInRange<T>(this in Param<T> param, T min, T max) where T : IComparable<T>
=> Ensure.Comparable.IsInRange(param.Value, min, max, param.Name, param.OptsFn);

public static void IsInRange<T>(this Param<T> param, T min, T max, IComparer<T> comparer) where T : IComparable<T>
public static void IsInRange<T>(this in Param<T> param, T min, T max, IComparer<T> comparer) where T : IComparable<T>
=> Ensure.Comparable.IsInRange(param.Value, min, max, comparer, param.Name, param.OptsFn);
}
}
14 changes: 7 additions & 7 deletions src/projects/EnsureThat/EnsureThatComparableIntExtensions.cs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2,25 +2,25 @@
{
public static class EnsureThatComparableIntExtensions
{
public static void Is(this Param<int> param, int expected)
public static void Is(this in Param<int> param, int expected)
=> Ensure.Comparable.Is(param.Value, expected, param.Name, param.OptsFn);

public static void IsNot(this Param<int> param, int expected)
public static void IsNot(this in Param<int> param, int expected)
=> Ensure.Comparable.IsNot(param.Value, expected, param.Name, param.OptsFn);

public static void IsLt(this Param<int> param, int limit)
public static void IsLt(this in Param<int> param, int limit)
=> Ensure.Comparable.IsLt(param.Value, limit, param.Name, param.OptsFn);

public static void IsLte(this Param<int> param, int limit)
public static void IsLte(this in Param<int> param, int limit)
=> Ensure.Comparable.IsLte(param.Value, limit, param.Name, param.OptsFn);

public static void IsGt(this Param<int> param, int limit)
public static void IsGt(this in Param<int> param, int limit)
=> Ensure.Comparable.IsGt(param.Value, limit, param.Name, param.OptsFn);

public static void IsGte(this Param<int> param, int limit)
public static void IsGte(this in Param<int> param, int limit)
=> Ensure.Comparable.IsGte(param.Value, limit, param.Name, param.OptsFn);

public static void IsInRange(this Param<int> param, int min, int max)
public static void IsInRange(this in Param<int> param, int min, int max)
=> Ensure.Comparable.IsInRange(param.Value, min, max, param.Name, param.OptsFn);
}
}
Loading

0 comments on commit 8b1a26e

Please sign in to comment.