CollectionUtilities
using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Text;
namespace Org.BouncyCastle.Utilities.Collections
{
public abstract class CollectionUtilities
{
public static void CollectMatches<T>(ICollection<T> matches, ISelector<T> selector, IEnumerable<IStore<T>> stores)
{
if (matches == null)
throw new ArgumentNullException("matches");
if (stores != null) {
foreach (IStore<T> store in stores) {
if (store != null) {
foreach (T item in store.EnumerateMatches(selector)) {
matches.Add(item);
}
}
}
}
}
public static IStore<T> CreateStore<T>(IEnumerable<T> contents)
{
return new StoreImpl<T>(contents);
}
public static T GetFirstOrNull<T>(IEnumerable<T> e) where T : class
{
if (e != null) {
using (IEnumerator<T> enumerator = e.GetEnumerator()) {
if (enumerator.MoveNext())
return enumerator.Current;
}
}
return null;
}
public static T GetValueOrKey<T>(IDictionary<T, T> d, T k)
{
if (!d.TryGetValue(k, out T value))
return k;
return value;
}
public static V GetValueOrNull<K, V>(IDictionary<K, V> d, K k) where V : class
{
if (!d.TryGetValue(k, out V value))
return null;
return value;
}
public static bool IsNullOrEmpty<T>(ICollection<T> c)
{
if (c != null)
return c.Count < 1;
return true;
}
public static TResult[] Map<T, TResult>(T[] ts, Func<T, TResult> f)
{
int num = ts.Length;
TResult[] array = new TResult[num];
for (int i = 0; i < num; i++) {
array[i] = f(ts[i]);
}
return array;
}
public static TResult[] Map<T, TResult>(IReadOnlyCollection<T> c, Func<T, TResult> f)
{
int count = c.Count;
int num = 0;
TResult[] array = new TResult[count];
foreach (T item in (IEnumerable<T>)c) {
array[num++] = f(item);
}
if (num != count)
throw new InvalidOperationException();
return array;
}
public static IEnumerable<T> Proxy<T>(IEnumerable<T> e)
{
return new EnumerableProxy<T>(e);
}
public static ICollection<T> ReadOnly<T>(ICollection<T> c)
{
return new ReadOnlyCollectionProxy<T>(c);
}
public static IDictionary<K, V> ReadOnly<K, V>(IDictionary<K, V> d)
{
return new ReadOnlyDictionaryProxy<K, V>(d);
}
public static IList<T> ReadOnly<T>(IList<T> l)
{
return new ReadOnlyListProxy<T>(l);
}
public static ISet<T> ReadOnly<T>(ISet<T> s)
{
return new ReadOnlySetProxy<T>(s);
}
public static bool Remove<K, V>(IDictionary<K, V> d, K k, out V v)
{
if (!d.TryGetValue(k, out v))
return false;
if (!d.Remove(k))
throw new InvalidOperationException();
return true;
}
public static T RequireNext<T>(IEnumerator<T> e)
{
if (!e.MoveNext())
throw new InvalidOperationException();
return e.Current;
}
[IteratorStateMachine(typeof(<Select>d__15<, >))]
public static IEnumerable<TResult> Select<TSource, TResult>(IEnumerable<TSource> source, Func<TSource, TResult> selector)
{
<Select>d__15<TSource, TResult> <Select>d__ = new <Select>d__15<TSource, TResult>(-2);
<Select>d__.<>3__source = source;
<Select>d__.<>3__selector = selector;
return <Select>d__;
}
public static T[] ToArray<T>(IReadOnlyCollection<T> c)
{
int count = c.Count;
int num = 0;
T[] array = new T[count];
foreach (T item in (IEnumerable<T>)c) {
array[num++] = item;
}
if (num != count)
throw new InvalidOperationException();
return array;
}
public static string ToString<T>(IEnumerable<T> c)
{
IEnumerator<T> enumerator = c.GetEnumerator();
if (!enumerator.MoveNext())
return "[]";
StringBuilder stringBuilder = new StringBuilder("[");
stringBuilder.Append(enumerator.Current);
while (enumerator.MoveNext()) {
stringBuilder.Append(", ");
stringBuilder.Append(enumerator.Current);
}
stringBuilder.Append(']');
return stringBuilder.ToString();
}
public static bool TryAdd<K, V>(IDictionary<K, V> d, K k, V v)
{
return d.TryAdd(k, v);
}
}
}