public static TResult SelectConstantByCount <T, TResult>(
[NotNull, InstantHandle] this IEnumerable <T> source,
[CanBeNull] TResult noneConstant = default,
[CanBeNull] TResult oneConstant = default,
[CanBeNull] TResult manyConstant = default)
{
if (source == null)
{
throw Exceptions.ArgumentNull(nameof(source));
}
var list = source.ToList();
if (!list.Any())
{
return(noneConstant);
}
if (list.Count == 1)
{
return(oneConstant);
}
return(manyConstant);
}
public static bool All <T>(
[InstantHandle, NotNull] this IEnumerable <T> source,
[InstantHandle, NotNull] Func <T, int, bool> predicate)
{
if (source == null)
{
throw Exceptions.ArgumentNull(nameof(source));
}
if (predicate == null)
{
throw Exceptions.ArgumentNull(nameof(predicate));
}
var i = 0;
foreach (var elem in source)
{
var passed = predicate.Invoke(elem, i);
if (!passed)
{
return(false);
}
i++;
}
return(true);
}
public static IEnumerable <T> Tap <T>(
[NotNull] this IEnumerable <T> source,
[NotNull, InstantHandle] Action <T, int> routine,
[CanBeNull, InstantHandle] Func <T, int, bool> predicate = null) where T : class
{
if (source == null)
{
throw Exceptions.ArgumentNull(nameof(source));
}
if (routine == null)
{
throw Exceptions.ArgumentNull(nameof(routine));
}
var i = 0;
foreach (var element in source)
{
if (predicate == null || predicate.Invoke(element, i))
{
routine.Invoke(element, i);
}
yield return(element);
i++;
}
}
public static TResult SelectByCount <T, TResult>(
[NotNull, InstantHandle] this IEnumerable <T> source,
[CanBeNull, InstantHandle] Func <TResult> none = null,
[CanBeNull, InstantHandle] Func <T, TResult> one = null,
[CanBeNull, InstantHandle] Func <ICollection <T>, TResult> many = null)
{
if (source == null)
{
throw Exceptions.ArgumentNull(nameof(source));
}
none = none ?? (() => default);
one = one ?? (_ => default);
many = many ?? (_ => default);
var list = source.ToList();
if (!list.Any())
{
return(none.Invoke());
}
if (list.Count == 1)
{
return(one.Invoke(list.Single()));
}
return(many.Invoke(list));
}
public static bool Any <T>(
[NotNull, InstantHandle] this IEnumerable <T> source,
[NotNull, InstantHandle] Func <T, int, bool> predicate)
{
if (source == null)
{
throw Exceptions.ArgumentNull(nameof(source));
}
if (predicate == null)
{
throw Exceptions.ArgumentNull(nameof(predicate));
}
var i = 0;
foreach (var item in source)
{
var result = predicate.Invoke(item, i);
if (result)
{
return(true);
}
i++;
}
return(false);
}
public static void HandleByCount <T>(
[NotNull, InstantHandle] this IEnumerable <T> source,
[CanBeNull, InstantHandle] Action noItemsHandler = null,
[CanBeNull, InstantHandle] Action <T> singleItemHandler = null,
[CanBeNull, InstantHandle] Action <ICollection <T> > manyItemsHandler = null)
{
if (source == null)
{
throw Exceptions.ArgumentNull(nameof(source));
}
var list = source.ToList();
if (!list.Any())
{
noItemsHandler?.Invoke();
}
else if (list.Count == 1)
{
singleItemHandler?.Invoke(list.Single());
}
else
{
manyItemsHandler?.Invoke(list);
}
}
public static T Random <T>([NotNull, InstantHandle] this IEnumerable <T> source)
{
if (source == null)
{
throw Exceptions.ArgumentNull(nameof(source));
}
var result = source.OrderBy(_ => Guid.NewGuid()).FirstOrDefault();
return(result);
}
public static bool IsEqualityOperator([NotNull] this MethodInfo methodInfo)
{
if (methodInfo == null)
{
throw Exceptions.ArgumentNull(nameof(methodInfo));
}
var result = methodInfo.IsSpecialName && methodInfo.Name.Equals(EqualityOperatorName);
return(result);
}
public static IReadOnlyCollection <T> ToReadOnlyCollection <T>([NotNull, InstantHandle] this IEnumerable <T> source)
{
if (source == null)
{
throw Exceptions.ArgumentNull(nameof(source));
}
var list = source.ToList();
var result = new ReadOnlyCollection <T>(list);
return(result);
}
internal T this[int index]
{
get
{
if (index >= mCount)
{
throw Exceptions.ArgumentNull(Parameter.Index);
}
return(mSource[index]);
}
}
/// <summary>
/// Throws an exception if the value is incompatible with this option.
/// </summary>
/// <param name="value">The value to check.</param>
public void CheckValue(object value)
{
if (value is null)
{
throw Exceptions.ArgumentNull(nameof(value));
}
if (!ValueType.IsAssignableFrom(value.GetType()))
{
throw Exceptions.Argument(nameof(value), "Value is incompatible with type {0}.", ValueType);
}
OnCheckValue(value);
}
public static object GetDefaultValue([NotNull] this Type type)
{
if (type == null)
{
throw Exceptions.ArgumentNull(nameof(type));
}
var result = typeof(TypeExt)
.GetMethod(nameof(GetDefaultValueImpl), BindingFlags.Static | BindingFlags.NonPublic)
.MakeGenericMethod(type)
.Invoke(null, Array.Empty <object>());
return(result);
}
public static IEnumerable <T> NotNull <T>(this IEnumerable <T> source)
{
if (source == null)
{
throw Exceptions.ArgumentNull(nameof(source));
}
foreach (var elem in source)
{
if (elem != null)
{
yield return(elem);
}
}
}
[ExcludeFromCodeCoverage] // Can't reach 100% in RELEASE config, but this code is trusted and the alternatives are tested.
public static IEnumerable <T> ToListWhenDebugging <T>([NotNull] this IEnumerable <T> source)
{
if (source == null)
{
throw Exceptions.ArgumentNull(nameof(source));
}
if (Debugger.IsAttached)
{
return(source.ToList());
}
else
{
return(source);
}
}
public static IOrderedEnumerable <TElement> ThenPrioritize <TElement>(
[NotNull] this IOrderedEnumerable <TElement> source,
[NotNull] Func <TElement, bool> predicate)
{
if (source == null)
{
throw Exceptions.ArgumentNull(nameof(source));
}
if (predicate == null)
{
throw Exceptions.ArgumentNull(nameof(predicate));
}
var result = source.ThenByDescending(predicate);
return(result);
}
public static IEnumerable <T> ToCircularEnumerable <T>(
[NotNull, ItemCanBeNull, InstantHandle] this IEnumerable <T> source)
{
if (source == null)
{
throw Exceptions.ArgumentNull(nameof(source));
}
var enumerable = source.ToList();
while (true)
{
foreach (var elem in enumerable)
{
yield return(elem);
}
}
}
public static T FirstCoalesce <T>(
[NotNull, InstantHandle] this IEnumerable <T> source,
[NotNull, ItemNotNull, InstantHandle] params Func <T, bool>[] predicates)
{
if (source == null)
{
throw Exceptions.ArgumentNull(nameof(source));
}
var matches = new List <Tuple <int, T> >();
foreach (var elem in source)
{
var i = 0;
foreach (var predicate in predicates)
{
if (predicate == null)
{
throw new ArgumentException("One of the passed predicates was null.").WithSource();
}
var match = predicate.Invoke(elem);
if (match)
{
if (i == 0)
{
return(elem);
}
else
{
matches.Add(new Tuple <int, T>(i, elem));
}
}
i++;
}
}
var tuple = matches.OrderBy(m => m.Item1).First();
return(tuple.Item2);
}
public static IEnumerable <T> Flatten <T>(
[NotNull, InstantHandle] this IEnumerable <T> parents,
[NotNull, InstantHandle] Func <T, T> getChild)
{
if (parents == null)
{
throw Exceptions.ArgumentNull(nameof(parents));
}
if (getChild == null)
{
throw Exceptions.ArgumentNull(nameof(getChild));
}
foreach (var parent in parents)
{
var flatParent = FlattenImpl(parent, getChild);
foreach (var child in flatParent)
{
yield return(child);
}
}
}
public IOrderedEnumerable <TSource> CreateOrderedEnumerable <TKey>(Func <TSource, TKey> keySelector, IComparer <TKey> comparer, bool descending)
{
if (keySelector == null)
{
throw Exceptions.ArgumentNull(Parameter.KeySelector);
}
Func <TSource, CompositeKey <TCompositeKey, TKey> > compositeKeySelector = (x => new CompositeKey <TCompositeKey, TKey>(mKeySelector(x), keySelector(x)));
IComparer <CompositeKey <TCompositeKey, TKey> > compositeComparer;
if (descending)
{
compositeComparer = new CompositeKey <TCompositeKey, TKey> .Comparer(mComparer, new DescendingComparer <TKey>(comparer));
}
else
{
compositeComparer = new CompositeKey <TCompositeKey, TKey> .Comparer(mComparer, comparer ?? Comparer <TKey> .Default);
}
return(new OrderedEnumerable <TSource, CompositeKey <TCompositeKey, TKey> >(mSource, compositeKeySelector, compositeComparer));
}
public static T Single <T>(
[NotNull, InstantHandle] this IEnumerable <T> source,
[NotNull, InstantHandle] Func <T, bool> predicate,
[CanBeNull] Exception noneError = null,
[CanBeNull] Exception manyError = null)
{
if (source == null)
{
throw Exceptions.ArgumentNull(nameof(source));
}
var elems = source.Take(2).ToList();
if (elems.Count == 0)
{
throw noneError ?? Exceptions.ErrorNoMatch();
}
if (elems.Count == 2)
{
throw manyError ?? Exceptions.ErrorMoreThanOneMatch();
}
return(elems.Single());
}
public static IEnumerable <T> OrderByDependency <T, TKey>(
[NotNull, InstantHandle] this IEnumerable <T> source,
[NotNull] Func <T, TKey> referenceKey,
[NotNull] Func <T, IEnumerable <TKey> > dependents,
IEqualityComparer <TKey> keyComparer = null)
{
if (source == null)
{
throw Exceptions.ArgumentNull(nameof(source));
}
if (referenceKey == null)
{
throw Exceptions.ArgumentNull(nameof(referenceKey));
}
if (dependents == null)
{
throw Exceptions.ArgumentNull(nameof(dependents));
}
var clone = new List <T>(source);
if (!clone.Any())
{
yield break;
}
var dependencyGraph = new Dictionary <T, ICollection <TKey> >();
// keyComparer ??= EqualityComparer<TKey>.Default;
keyComparer = keyComparer ?? EqualityComparer <TKey> .Default;
TKey GetReferenceKey(T instance)
{
if (instance == null)
{
throw new ArgumentException("Source contains null elements.", nameof(source));
}
return(referenceKey.Invoke(instance));
}
do
{
var elem = clone[0];
if (!dependencyGraph.ContainsKey(elem))
{
dependencyGraph[elem] = dependents.Invoke(elem).ToList();
}
var dependsOn = dependencyGraph[elem];
if (!dependsOn.Any())
{
yield return(elem);
clone.RemoveAt(0);
}
else
{
var stillExisting = clone.Skip(1).Where(c => dependsOn.Contains(GetReferenceKey(c), keyComparer)).ToList();
if (stillExisting.Any())
{
// TODO: Sub-optimal
var circular = false;
foreach (var lookup in stillExisting)
{
// if it not yet put in the dependency graph, put it at the back of the list
if (!dependencyGraph.ContainsKey(lookup))
{
break;
}
var key = GetReferenceKey(elem);
var matches = dependencyGraph.Where(g => g.Value.Contains(key, keyComparer)).ToList();
if (matches.Any())
{
foreach (var match in matches)
{
var we = dependencyGraph[elem];
var matchKey = referenceKey.Invoke(match.Key);
if (we.Contains(matchKey, keyComparer))
{
circular = true;
}
}
}
}
if (circular)
{
throw new InvalidOperationException("Circular order dependencies detected.");
}
clone.Add(elem);
clone.RemoveAt(0);
}
else
{
yield return(clone[0]);
clone.RemoveAt(0);
}
}
} while (clone.Any());
}
