1095 lines
43 KiB
C#
1095 lines
43 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using Nerd_STF.Mathematics;
|
|
|
|
namespace Nerd_STF.Lists
|
|
{
|
|
[Serializable]
|
|
public class List<T> : IEnumerable, IEnumerable<T>
|
|
{
|
|
public static List<T> Empty => new();
|
|
|
|
internal T[] array;
|
|
|
|
public int this[T item]
|
|
{
|
|
get => FindIndex(item);
|
|
set => Insert(value, item);
|
|
}
|
|
public T this[int index]
|
|
{
|
|
get => array[index];
|
|
set => array[index] = value;
|
|
}
|
|
|
|
public List<T> Duplicate => new(array);
|
|
public bool IsEmpty => array == Array.Empty<T>();
|
|
public bool IsNull => array == null;
|
|
public bool IsNullOrEmpty => IsNull || IsEmpty;
|
|
public int Length => array.Length;
|
|
|
|
public List() => array = Array.Empty<T>();
|
|
public List(params T[] items) => array = items;
|
|
public List(int length) => array = new T[length];
|
|
public List(int length, T itemAll)
|
|
{
|
|
array = new T[length];
|
|
for (int i = 0; i < array.Length; i++) array[i] = itemAll;
|
|
}
|
|
public List(IEnumerable items)
|
|
{
|
|
int length = 0;
|
|
foreach (object _ in items) length++;
|
|
array = new T[length];
|
|
|
|
AddRange(items);
|
|
}
|
|
public List(IEnumerable<T> items)
|
|
{
|
|
int length = 0;
|
|
foreach (object _ in items) length++;
|
|
if (length == 0) array = Array.Empty<T>();
|
|
|
|
AddRange(items);
|
|
}
|
|
public List(List<T> list) => array = list.array;
|
|
|
|
public void Add() => Add(default);
|
|
public void Add(T item)
|
|
{
|
|
if (array == null || array == Array.Empty<T>()) array = new T[1] { item };
|
|
else
|
|
{
|
|
T[] old = array;
|
|
array = new T[old.Length + 1];
|
|
for (int i = 0; i < old.Length; i++) array[i] = old[i];
|
|
array[old.Length] = item;
|
|
}
|
|
}
|
|
public void AddRange(IEnumerable items) { foreach (T t in items) Add(t); }
|
|
public void AddRange(IEnumerable<T> items) { foreach (T t in items) Add(t); }
|
|
public void AddRange(List<T> items) { foreach (T t in items) Add(t); }
|
|
public void AddRange(params T[] items) { foreach (T t in items) Add(t); }
|
|
public bool Any(Predicate<T> predicate)
|
|
{
|
|
foreach (T t in array) if (predicate.Invoke(t)) return true;
|
|
return false;
|
|
}
|
|
public bool Any(T match)
|
|
{
|
|
foreach (T t in array) if (t.Equals(match)) return true;
|
|
return false;
|
|
}
|
|
public void Clear(bool resetSize = false)
|
|
{
|
|
if (resetSize) array = Array.Empty<T>();
|
|
else { for (int i = 0; i < array.Length; i++) array[i] = default; }
|
|
}
|
|
public bool Contains(Predicate<T> predicate)
|
|
{
|
|
foreach (T t in array) if (predicate.Invoke(t)) return true;
|
|
return false;
|
|
}
|
|
public bool Contains(T match)
|
|
{
|
|
foreach (T t in array) if (t.Equals(match)) return true;
|
|
return false;
|
|
}
|
|
public int Count()
|
|
{
|
|
int r = 0;
|
|
foreach (T _ in array) r++;
|
|
return r;
|
|
}
|
|
public int Count(Predicate<T> predicate)
|
|
{
|
|
if (!Contains(predicate)) return 0;
|
|
int r = 0;
|
|
foreach (T t in array) if (predicate.Invoke(t)) r++;
|
|
return r;
|
|
}
|
|
public int Count(T match)
|
|
{
|
|
if (!Contains(match)) return 0;
|
|
int r = 0;
|
|
foreach (T t in array) if (t.Equals(match)) r++;
|
|
return r;
|
|
}
|
|
public void Fill(T item) { for (int i = 0; i < Length; i++) array[i] = item; }
|
|
public T Find(Predicate<T> predicate)
|
|
{
|
|
foreach (T t in array) if (predicate.Invoke(t)) return t;
|
|
throw new Exception("Parameter " + nameof(predicate) + " does not exist in the list.");
|
|
}
|
|
public T Find(T match)
|
|
{
|
|
foreach (T t in array) if (t.Equals(match)) return t;
|
|
throw new Exception("Parameter " + nameof(match) + " does not exist in the list.");
|
|
}
|
|
public T Find(Predicate<T> predicate, int start)
|
|
{
|
|
for (int i = start; i < array.Length; i++) if (predicate.Invoke(array[i])) return array[i];
|
|
throw new Exception("Parameter " + nameof(predicate) + " does not exist in the list.");
|
|
}
|
|
public T Find(T match, int start)
|
|
{
|
|
for (int i = start; i < array.Length; i++) if (array[i].Equals(match)) return array[i];
|
|
throw new Exception("Parameter " + nameof(match) + " does not exist in the list.");
|
|
}
|
|
public T Find(Predicate<T> predicate, int start, int max)
|
|
{
|
|
for (int i = start; i <= max; i++) if (predicate.Invoke(array[i])) return array[i];
|
|
throw new Exception("Parameter " + nameof(predicate) + " does not exist in the list.");
|
|
}
|
|
public T Find(T match, int start, int max)
|
|
{
|
|
for (int i = start; i <= max; i++) if (array[i].Equals(match)) return array[i];
|
|
throw new Exception("Parameter " + nameof(match) + " does not exist in the list.");
|
|
}
|
|
public T FindOrDefault(Predicate<T> predicate)
|
|
{
|
|
foreach (T t in array) if (predicate.Invoke(t)) return t;
|
|
return default;
|
|
}
|
|
public T FindOrDefault(T match)
|
|
{
|
|
foreach (T t in array) if (t.Equals(match)) return t;
|
|
return default;
|
|
}
|
|
public T FindOrDefault(Predicate<T> predicate, int start)
|
|
{
|
|
for (int i = start; i < array.Length; i++) if (predicate.Invoke(array[i])) return array[i];
|
|
return default;
|
|
}
|
|
public T FindOrDefault(T match, int start)
|
|
{
|
|
for (int i = start; i < array.Length; i++) if (array[i].Equals(match)) return array[i];
|
|
return default;
|
|
}
|
|
public T FindOrDefault(Predicate<T> predicate, int start, int max)
|
|
{
|
|
for (int i = start; i <= max; i++) if (predicate.Invoke(array[i])) return array[i];
|
|
return default;
|
|
}
|
|
public T FindOrDefault(T match, int start, int max)
|
|
{
|
|
for (int i = start; i <= max; i++) if (array[i].Equals(match)) return array[i];
|
|
return default;
|
|
}
|
|
public List<T> FindAll(Predicate<T> predicate)
|
|
{
|
|
List<T> r = new();
|
|
foreach (T t in array) if (predicate.Invoke(t)) r.Add(t);
|
|
return r;
|
|
}
|
|
public List<T> FindAll(T match)
|
|
{
|
|
List<T> r = new();
|
|
foreach (T t in array) if (t.Equals(match)) r.Add(t);
|
|
return r;
|
|
}
|
|
public List<T> FindAll(Predicate<T> predicate, int start)
|
|
{
|
|
List<T> r = new();
|
|
for (int i = start; i < array.Length; i++) if (predicate.Invoke(array[i])) r.Add(array[i]);
|
|
return r;
|
|
}
|
|
public List<T> FindAll(T match, int start)
|
|
{
|
|
List<T> r = new();
|
|
for (int i = start; i < array.Length; i++) if (array[i].Equals(match)) r.Add(array[i]);
|
|
return r;
|
|
}
|
|
public List<T> FindAll(Predicate<T> predicate, int start, int max)
|
|
{
|
|
List<T> r = new();
|
|
for (int i = start; i <= max; i++) if (predicate.Invoke(array[i])) r.Add(array[i]);
|
|
return r;
|
|
}
|
|
public List<T> FindAll(T match, int start, int max)
|
|
{
|
|
List<T> r = new();
|
|
for (int i = start; i <= max; i++) if (array[i].Equals(match)) r.Add(array[i]);
|
|
return r;
|
|
}
|
|
public T FindLast(Predicate<T> predicate)
|
|
{
|
|
for (int i = array.Length - 1; i >= 0; i--) if (predicate.Invoke(array[i])) return array[i];
|
|
throw new Exception("Parameter " + nameof(predicate) + " does not exist in the list.");
|
|
}
|
|
public T FindLast(T match)
|
|
{
|
|
for (int i = array.Length - 1; i >= 0; i--) if (array[i].Equals(match)) return array[i];
|
|
throw new Exception("Parameter " + nameof(match) + " does not exist in the list.");
|
|
}
|
|
public T FindLast(Predicate<T> predicate, int start)
|
|
{
|
|
for (int i = array.Length - 1; i >= start; i--) if (predicate.Invoke(array[i])) return array[i];
|
|
throw new Exception("Parameter " + nameof(predicate) + " does not exist in the list.");
|
|
}
|
|
public T FindLast(T match, int start)
|
|
{
|
|
for (int i = array.Length - 1; i >= start; i--) if (array[i].Equals(match)) return array[i];
|
|
throw new Exception("Parameter " + nameof(match) + " does not exist in the list.");
|
|
}
|
|
public T FindLast(Predicate<T> predicate, int start, int max)
|
|
{
|
|
for (int i = max; i >= start; i--) if (predicate.Invoke(array[i])) return array[i];
|
|
throw new Exception("Parameter " + nameof(predicate) + " does not exist in the list.");
|
|
}
|
|
public T FindLast(T match, int start, int max)
|
|
{
|
|
for (int i = max; i >= start; i--) if (array[i].Equals(match)) return array[i];
|
|
throw new Exception("Parameter " + nameof(match) + " does not exist in the list.");
|
|
}
|
|
public T FindLastOrDefault(Predicate<T> predicate)
|
|
{
|
|
for (int i = array.Length - 1; i >= 0; i--) if (predicate.Invoke(array[i])) return array[i];
|
|
return default;
|
|
}
|
|
public T FindLastOrDefault(T match)
|
|
{
|
|
for (int i = array.Length - 1; i >= 0; i--) if (array[i].Equals(match)) return array[i];
|
|
return default;
|
|
}
|
|
public T FindLastOrDefault(Predicate<T> predicate, int start)
|
|
{
|
|
for (int i = array.Length - 1; i >= start; i--) if (predicate.Invoke(array[i])) return array[i];
|
|
return default;
|
|
}
|
|
public T FindLastOrDefault(T match, int start)
|
|
{
|
|
for (int i = array.Length - 1; i >= start; i--) if (array[i].Equals(match)) return array[i];
|
|
return default;
|
|
}
|
|
public T FindLastOrDefault(Predicate<T> predicate, int start, int max)
|
|
{
|
|
for (int i = max; i >= start; i--) if (predicate.Invoke(array[i])) return array[i];
|
|
return default;
|
|
}
|
|
public T FindLastOrDefault(T match, int start, int max)
|
|
{
|
|
for (int i = max; i >= start; i--) if (array[i].Equals(match)) return array[i];
|
|
return default;
|
|
}
|
|
public int FindIndex(Predicate<T> predicate)
|
|
{
|
|
for (int i = 0; i < array.Length; i++) if (predicate.Invoke(array[i])) return i;
|
|
return -1;
|
|
}
|
|
public int FindIndex(T match)
|
|
{
|
|
for (int i = 0; i < array.Length; i++) if (array[i].Equals(match)) return i;
|
|
return -1;
|
|
}
|
|
public int FindIndex(Predicate<T> predicate, int start)
|
|
{
|
|
for (int i = start; i < array.Length; i++) if (predicate.Invoke(array[i])) return i;
|
|
return -1;
|
|
}
|
|
public int FindIndex(T match, int start)
|
|
{
|
|
for (int i = start; i < array.Length; i++) if (array[i].Equals(match)) return i;
|
|
return -1;
|
|
}
|
|
public int FindIndex(Predicate<T> predicate, int start, int max)
|
|
{
|
|
for (int i = start; i <= max; i++) if (predicate.Invoke(array[i])) return i;
|
|
return -1;
|
|
}
|
|
public int FindIndex(T match, int start, int max)
|
|
{
|
|
for (int i = start; i <= max; i++) if (array[i].Equals(match)) return i;
|
|
return -1;
|
|
}
|
|
public List<int> FindAllIndex()
|
|
{
|
|
List<int> ret = new();
|
|
for (int i = 0; i < array.Length; i++) ret.Add(i);
|
|
return ret;
|
|
}
|
|
public List<int> FindAllIndex(Predicate<T> predicate)
|
|
{
|
|
List<int> r = new();
|
|
for (int i = 0; i < array.Length; i++) if (predicate.Invoke(array[i])) r.Add(i);
|
|
return r;
|
|
}
|
|
public List<int> FindAllIndex(T match)
|
|
{
|
|
List<int> r = new();
|
|
for (int i = 0; i < array.Length; i++) if (array[i].Equals(match)) r.Add(i);
|
|
return r;
|
|
}
|
|
public List<int> FindAllIndex(int start)
|
|
{
|
|
List<int> ret = new();
|
|
for (int i = start; i < array.Length; i++) ret.Add(i);
|
|
return ret;
|
|
}
|
|
public List<int> FindAllIndex(Predicate<T> predicate, int start)
|
|
{
|
|
List<int> r = new();
|
|
for (int i = start; i < array.Length; i++) if (predicate.Invoke(array[i])) r.Add(i);
|
|
return r;
|
|
}
|
|
public List<int> FindAllIndex(T match, int start)
|
|
{
|
|
List<int> r = new();
|
|
for (int i = start; i < array.Length; i++) if (array[i].Equals(match)) r.Add(i);
|
|
return r;
|
|
}
|
|
public List<int> FindAllIndex(int start, int max)
|
|
{
|
|
List<int> ret = new();
|
|
for (int i = start; i <= max; i++) ret.Add(i);
|
|
return ret;
|
|
}
|
|
public List<int> FindAllIndex(Predicate<T> predicate, int start, int max)
|
|
{
|
|
List<int> r = new();
|
|
for (int i = start; i <= max; i++) if (predicate.Invoke(array[i])) r.Add(i);
|
|
return r;
|
|
}
|
|
public List<int> FindAllIndex(T match, int start, int max)
|
|
{
|
|
List<int> r = new();
|
|
for (int i = start; i <= max; i++) if (array[i].Equals(match)) r.Add(i);
|
|
return r;
|
|
}
|
|
public int FindLastIndex(Predicate<T> predicate)
|
|
{
|
|
for (int i = array.Length - 1; i >= 0; i--) if (predicate.Invoke(array[i])) return i;
|
|
return -1;
|
|
}
|
|
public int FindLastIndex(T match)
|
|
{
|
|
for (int i = array.Length - 1; i >= 0; i--) if (array[i].Equals(match)) return i;
|
|
return -1;
|
|
}
|
|
public int FindLastIndex(Predicate<T> predicate, int start)
|
|
{
|
|
for (int i = array.Length - 1; i >= start; i--) if (predicate.Invoke(array[i])) return i;
|
|
return -1;
|
|
}
|
|
public int FindLastIndex(T match, int start)
|
|
{
|
|
for (int i = array.Length - 1; i >= start; i--) if (array[i].Equals(match)) return i;
|
|
return -1;
|
|
}
|
|
public int FindLastIndex(Predicate<T> predicate, int start, int max)
|
|
{
|
|
for (int i = max; i >= start; i--) if (predicate.Invoke(array[i])) return i;
|
|
return -1;
|
|
}
|
|
public int FindLastIndex(T match, int start, int max)
|
|
{
|
|
for (int i = max; i >= start; i--) if (array[i].Equals(match)) return i;
|
|
return -1;
|
|
}
|
|
public IEnumerator GetEnumerator() => array.GetEnumerator();
|
|
IEnumerator<T> IEnumerable<T>.GetEnumerator() => (IEnumerator<T>)array.GetEnumerator();
|
|
public List<T> GetRange(int start, int max)
|
|
{
|
|
List<T> r = new();
|
|
for (int i = start; i <= max; i++) r.Add(array[i]);
|
|
return r;
|
|
}
|
|
public void Insert(int index, T item)
|
|
{
|
|
T[] old = array;
|
|
array = new T[old.Length + 1];
|
|
for (int i = 0; i < index; i++) array[i] = old[i];
|
|
array[index] = item;
|
|
for (int i = index + 1; i < array.Length; i++) array[i] = old[i - 1];
|
|
}
|
|
public void InsertRange(int index, IEnumerable<T> items)
|
|
{
|
|
List<T> list = new(items);
|
|
|
|
T[] old = array;
|
|
array = new T[old.Length + list.Length];
|
|
for (int i = 0; i < index; i++) array[i] = old[i];
|
|
for (int i = 0; i < list.Length; i++) array[index + i] = list[i];
|
|
for (int i = index + list.Length; i < array.Length; i++) array[i] = old[i - list.Length];
|
|
}
|
|
public bool MatchesAll(Predicate<T> predicate) => FindAll(predicate).array == array;
|
|
public bool MatchesAll(T match) => FindAll(match).array == array;
|
|
public void Randomize()
|
|
{
|
|
List<T> newL = new();
|
|
List<int> possibleIndexes = FindAllIndex();
|
|
for (int i = 0; i < possibleIndexes.Length; i++)
|
|
{
|
|
int index = possibleIndexes[new Random().Next(0, possibleIndexes.Length)];
|
|
newL.Add(array[index]);
|
|
possibleIndexes.Remove(x => x == index);
|
|
}
|
|
array = newL.ToArray();
|
|
}
|
|
public void Remove(Predicate<T> predicate) => Remove(FindIndex(predicate));
|
|
public void Remove(T item) => Remove(FindIndex(item));
|
|
public void Remove(int index)
|
|
{
|
|
List<T> newList = new();
|
|
for (int i = 0; i < array.Length; i++) if (i != index) newList.Add(array[i]);
|
|
array = newList.array;
|
|
}
|
|
public void RemoveAll(Predicate<T> predicate) { foreach (int i in FindAllIndex(predicate)) Remove(i); }
|
|
public void RemoveAll(T match) { foreach (int i in FindAllIndex(match)) Remove(i); }
|
|
public void RemoveLast(Predicate<T> predicate) => Remove(FindLastIndex(predicate));
|
|
public void RemoveLast(T item) => Remove(FindLastIndex(item));
|
|
public void RemoveRange(int index, int max)
|
|
{
|
|
List<T> newList = new();
|
|
for (int i = 0; i < array.Length; i++) if (i < index || i > max) newList.Add(array[i]);
|
|
array = newList.array;
|
|
}
|
|
public void Reverse()
|
|
{
|
|
T[] old = array;
|
|
array = new T[old.Length];
|
|
|
|
for (int i = old.Length - 1; i >= 0; i--) array[i] = old[i];
|
|
}
|
|
public void Shuffle() => Randomize();
|
|
public T[] ToArray() => array;
|
|
public ReadOnlyList<T> ToReadOnly() { return new ReadOnlyList<T>(array); }
|
|
public ReadOnlyCollection<T> ToSystemReadOnly() { return new ReadOnlyCollection<T>(array); }
|
|
public System.Collections.Generic.List<T> ToSystemList() { return new System.Collections.Generic.List<T>(array); }
|
|
|
|
public override bool Equals(object obj) => base.Equals(obj);
|
|
public bool Equals(T[] other)
|
|
{
|
|
bool returned = true;
|
|
if (Length == other.Length)
|
|
{
|
|
for (int i = 0; i < Length; i++)
|
|
{
|
|
returned &= array[i].Equals(other[i]);
|
|
}
|
|
}
|
|
return returned;
|
|
}
|
|
public bool Equals(List<T> list)
|
|
{
|
|
if (Length != list.Length) return false;
|
|
bool equal = true;
|
|
for (int i = 0; i < Length; i++) equal &= array[i].Equals(list[i]);
|
|
return equal;
|
|
}
|
|
public bool Equals(IEnumerable<T> list) => Equals(new List<T>(list));
|
|
public override int GetHashCode() => base.GetHashCode();
|
|
public override string ToString() => ToString(false);
|
|
public string ToString(bool showAll = false)
|
|
{
|
|
string ret = "List of " + Length + " Elements (" + typeof(T).ToString() + ")";
|
|
if (showAll) for (int i = 0; i < Length; i++) ret += "\n" + i + ": " + array[i];
|
|
return ret;
|
|
}
|
|
|
|
public static List<T> operator +(List<T> a, T b)
|
|
{
|
|
a.Add(b);
|
|
return a;
|
|
}
|
|
public static List<T> operator +(List<T> a, IEnumerable<T> b)
|
|
{
|
|
a.AddRange(b);
|
|
return a;
|
|
}
|
|
public static List<T> operator +(List<T> a, List<T> b)
|
|
{
|
|
a.AddRange(b);
|
|
return a;
|
|
}
|
|
public static List<T> operator +(List<T> a, T[] b)
|
|
{
|
|
a.AddRange(b);
|
|
return a;
|
|
}
|
|
public static List<T> operator -(List<T> a, int remove)
|
|
{
|
|
List<T> returned = new(a.Length - remove);
|
|
for (int i = 0; i < returned.Length; i++)
|
|
{
|
|
returned[i] = a[i];
|
|
}
|
|
return returned;
|
|
}
|
|
public static List<T> operator -(List<T> a, int[] removes)
|
|
{
|
|
foreach (int remove in removes)
|
|
{
|
|
a.Remove(remove);
|
|
}
|
|
return a;
|
|
}
|
|
public static List<T> operator -(List<T> a, List<int> removes)
|
|
{
|
|
foreach (int remove in removes)
|
|
{
|
|
a.Remove(remove);
|
|
}
|
|
return a;
|
|
}
|
|
public static List<T> operator -(List<T> a, T b)
|
|
{
|
|
a.Remove(b);
|
|
return a;
|
|
}
|
|
public static bool operator ==(List<T> a, List<T> b) => a.Equals(b);
|
|
public static bool operator ==(List<T> a, T[] b)
|
|
{
|
|
return a.Equals(b);
|
|
}
|
|
public static bool operator ==(T[] a, List<T> b)
|
|
{
|
|
return b.Equals(a);
|
|
}
|
|
public static bool operator !=(List<T> a, List<T> b) => !a.Equals(b);
|
|
public static bool operator !=(List<T> a, T[] b)
|
|
{
|
|
return !a.Equals(b);
|
|
}
|
|
public static bool operator !=(T[] a, List<T> b)
|
|
{
|
|
return !b.Equals(a);
|
|
}
|
|
}
|
|
|
|
[Serializable]
|
|
[Obsolete("This class will be removed or heavily modified in a future release.")]
|
|
public class Matrix<T>
|
|
{
|
|
internal List<List<T>> lists;
|
|
|
|
public Vector2 Length => new(lists[0].Length, lists.Length);
|
|
public int LengthX => lists[0].Length;
|
|
public int LengthY => lists.Length;
|
|
|
|
public static Matrix<T> Empty => new() { lists = List<List<T>>.Empty };
|
|
|
|
public Matrix() => lists = new List<List<T>>(1, new List<T>(1, default));
|
|
public Matrix(int lengthX, int lengthY)
|
|
{
|
|
if (lengthX < 1) throw new ArgumentOutOfRangeException(nameof(lengthX), "Do not include a length of less than 1");
|
|
if (lengthY < 1) throw new ArgumentOutOfRangeException(nameof(lengthY), "Do not include a width of less than 1");
|
|
lists = new List<List<T>>(lengthY, new List<T>(lengthX));
|
|
}
|
|
public Matrix(int lengthX, int lengthY, T inputAll)
|
|
{
|
|
if (lengthX < 1) throw new ArgumentOutOfRangeException(nameof(lengthX), "Do not include a length of less than 1");
|
|
if (lengthY < 1) throw new ArgumentOutOfRangeException(nameof(lengthY), "Do not include a width of less than 1");
|
|
lists = new List<List<T>>(lengthY, new List<T>(lengthX, inputAll));
|
|
}
|
|
public T this[int indexX, int indexY]
|
|
{
|
|
get => Get(indexX, indexY);
|
|
set => Set(indexX, indexY, value);
|
|
}
|
|
|
|
public void Add(Matrix<T> input, DirectionType addDir)
|
|
{
|
|
if (addDir == DirectionType.y)
|
|
{
|
|
foreach (List<T> list in input.lists) AddY(list);
|
|
return;
|
|
}
|
|
|
|
foreach (List<T> list in input.lists) AddX(list);
|
|
}
|
|
public void AddX() { foreach (List<T> list in lists) list.Add(); }
|
|
public void AddX(T input) { foreach (List<T> list in lists) list.Add(input); }
|
|
public void AddX(T[] input) { foreach (T t in input) AddX(t); }
|
|
public void AddX(List<T> input) { foreach (T t in input) AddX(t); }
|
|
public void AddY() => lists.Add(new List<T>(lists[0].Length));
|
|
public void AddY(T input) => lists.Add(new List<T>(lists[0].Length, input));
|
|
public void AddY(T[] input)
|
|
{
|
|
if (input.Length > lists[0].Length) throw new OverflowException();
|
|
lists.Add(new List<T>(input));
|
|
}
|
|
public void AddY(List<T> input)
|
|
{
|
|
if (input.Length > lists[0].Length) throw new OverflowException();
|
|
lists.Add(input);
|
|
}
|
|
public bool Check(int placeX, int placeY) => lists[placeY][placeX] != null;
|
|
public bool Compare(T input)
|
|
{
|
|
foreach (List<T> list in lists) if (list.Contains(input)) return true;
|
|
|
|
return false;
|
|
}
|
|
public void Convert(T input) { for (int i = 0; i < lists.Length; i++) lists[i] = new(input); }
|
|
public void Convert(T[] input) { for (int i = 0; i < lists.Length; i++) lists[i] = new(input); }
|
|
public void Convert(List<T> input) { for (int i = 0; i < lists.Length; i++) lists[i] = input; }
|
|
public void Convert(Matrix<T> input) => lists = input.lists;
|
|
public int Count()
|
|
{
|
|
int returned = 0;
|
|
|
|
foreach (List<T> list in lists) returned += list.Count();
|
|
|
|
return returned;
|
|
}
|
|
public int Count(DirectionType type)
|
|
{
|
|
if (type == DirectionType.y) return LengthY;
|
|
return LengthX;
|
|
}
|
|
public Vector2 CountXY() => Length;
|
|
public T Get(int placeX, int placeY) => lists[placeY][placeX];
|
|
public void Get(int placeX, int placeY, out T output) => output = Get(placeX, placeY);
|
|
public List<T> GetAll()
|
|
{
|
|
List<T> returned = new();
|
|
|
|
foreach (List<T> list in lists) returned.AddRange(list);
|
|
|
|
return returned;
|
|
}
|
|
public void GetAll(out List<T> output)
|
|
{
|
|
List<T> returned = new();
|
|
|
|
foreach (List<T> list in lists) returned.AddRange(list);
|
|
|
|
output = returned;
|
|
}
|
|
public IEnumerator GetEnumerator() { foreach (List<T> list in lists) foreach (T t in list) yield return t; }
|
|
public void Remove(int placeX, int placeY) => lists[placeY].Remove(placeX);
|
|
public void Set(int placeX, int placeY, T input) => lists[placeY][placeX] = input;
|
|
public void SetAll(T input) { for (int i = 0; i < lists.Length; i++) for (int j = 0; j < lists[i].Length; j++) lists[i][j] = input; }
|
|
|
|
public static Matrix<T> AllDefault(int lengthX, int lengthY) => new(lengthX, lengthY, default);
|
|
|
|
public override bool Equals(object obj) => base.Equals(obj);
|
|
public bool Equals(Matrix<T> other) => GetAll() == other.GetAll();
|
|
public override int GetHashCode() => base.GetHashCode();
|
|
public override string ToString() => lists.ToString();
|
|
public string ToString(bool showAll)
|
|
{
|
|
if (showAll)
|
|
{
|
|
string r = "";
|
|
for (int i = 0; i < lists.Length; i++)
|
|
{
|
|
for (int j = 0; j < lists[i].Length; j++)
|
|
{
|
|
r += lists[i][j];
|
|
if (j != lists[i].Length - 1) r += ", ";
|
|
}
|
|
if (i != lists.Length - 1) r += "\n";
|
|
}
|
|
return r;
|
|
}
|
|
else return ToString();
|
|
}
|
|
|
|
public static bool operator ==(Matrix<T> a, Matrix<T> b) => a.Equals(b);
|
|
public static bool operator !=(Matrix<T> a, Matrix<T> b) => !a.Equals(b);
|
|
|
|
public enum DirectionType
|
|
{
|
|
x,
|
|
y,
|
|
}
|
|
}
|
|
|
|
[Serializable]
|
|
public class ReadOnlyList<T> : IEnumerable, IEnumerable<T>
|
|
{
|
|
public static ReadOnlyList<T> Empty => new();
|
|
|
|
internal T[] array;
|
|
|
|
public T this[int index] => array[index];
|
|
|
|
public List<T> Duplicate => new(array);
|
|
public bool IsEmpty => array == Array.Empty<T>();
|
|
public bool IsNull => array == null;
|
|
public bool IsNullOrEmpty => IsNull || IsEmpty;
|
|
public int Length => array.Length;
|
|
|
|
public ReadOnlyList() => array = Array.Empty<T>();
|
|
public ReadOnlyList(params T[] items) => array = items;
|
|
public ReadOnlyList(int length) => array = new T[length];
|
|
public ReadOnlyList(int length, T itemAll)
|
|
{
|
|
array = new T[length];
|
|
for (int i = 0; i < array.Length; i++) array[i] = itemAll;
|
|
}
|
|
public ReadOnlyList(IEnumerable<T> items) => array = new List<T>(items).ToArray();
|
|
|
|
public bool Contains(Predicate<T> predicate)
|
|
{
|
|
foreach (T t in array) if (predicate.Invoke(t)) return true;
|
|
return false;
|
|
}
|
|
public bool Contains(T match)
|
|
{
|
|
foreach (T t in array) if (t.Equals(match)) return true;
|
|
return false;
|
|
}
|
|
public int Count()
|
|
{
|
|
int r = 0;
|
|
foreach (T _ in array) r++;
|
|
return r;
|
|
}
|
|
public int Count(Predicate<T> predicate)
|
|
{
|
|
if (!Contains(predicate)) return 0;
|
|
int r = 0;
|
|
foreach (T t in array) if (predicate.Invoke(t)) r++;
|
|
return r;
|
|
}
|
|
public int Count(T match)
|
|
{
|
|
if (!Contains(match)) return 0;
|
|
int r = 0;
|
|
foreach (T t in array) if (t.Equals(match)) r++;
|
|
return r;
|
|
}
|
|
public T Find(Predicate<T> predicate)
|
|
{
|
|
foreach (T t in array) if (predicate.Invoke(t)) return t;
|
|
throw new Exception("Parameter " + nameof(predicate) + " does not exist in the list.");
|
|
}
|
|
public T Find(T match)
|
|
{
|
|
foreach (T t in array) if (t.Equals(match)) return t;
|
|
throw new Exception("Parameter " + nameof(match) + " does not exist in the list.");
|
|
}
|
|
public T Find(Predicate<T> predicate, int start)
|
|
{
|
|
for (int i = start; i < array.Length; i++) if (predicate.Invoke(array[i])) return array[i];
|
|
throw new Exception("Parameter " + nameof(predicate) + " does not exist in the list.");
|
|
}
|
|
public T Find(T match, int start)
|
|
{
|
|
for (int i = start; i < array.Length; i++) if (array[i].Equals(match)) return array[i];
|
|
throw new Exception("Parameter " + nameof(match) + " does not exist in the list.");
|
|
}
|
|
public T Find(Predicate<T> predicate, int start, int max)
|
|
{
|
|
for (int i = start; i <= max; i++) if (predicate.Invoke(array[i])) return array[i];
|
|
throw new Exception("Parameter " + nameof(predicate) + " does not exist in the list.");
|
|
}
|
|
public T Find(T match, int start, int max)
|
|
{
|
|
for (int i = start; i <= max; i++) if (array[i].Equals(match)) return array[i];
|
|
throw new Exception("Parameter " + nameof(match) + " does not exist in the list.");
|
|
}
|
|
public T FindOrDefault(Predicate<T> predicate)
|
|
{
|
|
foreach (T t in array) if (predicate.Invoke(t)) return t;
|
|
return default;
|
|
}
|
|
public T FindOrDefault(T match)
|
|
{
|
|
foreach (T t in array) if (t.Equals(match)) return t;
|
|
return default;
|
|
}
|
|
public T FindOrDefault(Predicate<T> predicate, int start)
|
|
{
|
|
for (int i = start; i < array.Length; i++) if (predicate.Invoke(array[i])) return array[i];
|
|
return default;
|
|
}
|
|
public T FindOrDefault(T match, int start)
|
|
{
|
|
for (int i = start; i < array.Length; i++) if (array[i].Equals(match)) return array[i];
|
|
return default;
|
|
}
|
|
public T FindOrDefault(Predicate<T> predicate, int start, int max)
|
|
{
|
|
for (int i = start; i <= max; i++) if (predicate.Invoke(array[i])) return array[i];
|
|
return default;
|
|
}
|
|
public T FindOrDefault(T match, int start, int max)
|
|
{
|
|
for (int i = start; i <= max; i++) if (array[i].Equals(match)) return array[i];
|
|
return default;
|
|
}
|
|
public List<T> FindAll(Predicate<T> predicate)
|
|
{
|
|
List<T> r = new();
|
|
foreach (T t in array) if (predicate.Invoke(t)) r.Add(t);
|
|
return r;
|
|
}
|
|
public List<T> FindAll(T match)
|
|
{
|
|
List<T> r = new();
|
|
foreach (T t in array) if (t.Equals(match)) r.Add(t);
|
|
return r;
|
|
}
|
|
public List<T> FindAll(Predicate<T> predicate, int start)
|
|
{
|
|
List<T> r = new();
|
|
for (int i = start; i < array.Length; i++) if (predicate.Invoke(array[i])) r.Add(array[i]);
|
|
return r;
|
|
}
|
|
public List<T> FindAll(T match, int start)
|
|
{
|
|
List<T> r = new();
|
|
for (int i = start; i < array.Length; i++) if (array[i].Equals(match)) r.Add(array[i]);
|
|
return r;
|
|
}
|
|
public List<T> FindAll(Predicate<T> predicate, int start, int max)
|
|
{
|
|
List<T> r = new();
|
|
for (int i = start; i <= max; i++) if (predicate.Invoke(array[i])) r.Add(array[i]);
|
|
return r;
|
|
}
|
|
public List<T> FindAll(T match, int start, int max)
|
|
{
|
|
List<T> r = new();
|
|
for (int i = start; i <= max; i++) if (array[i].Equals(match)) r.Add(array[i]);
|
|
return r;
|
|
}
|
|
public T FindLast(Predicate<T> predicate)
|
|
{
|
|
for (int i = array.Length - 1; i >= 0; i--) if (predicate.Invoke(array[i])) return array[i];
|
|
throw new Exception("Parameter " + nameof(predicate) + " does not exist in the list.");
|
|
}
|
|
public T FindLast(T match)
|
|
{
|
|
for (int i = array.Length - 1; i >= 0; i--) if (array[i].Equals(match)) return array[i];
|
|
throw new Exception("Parameter " + nameof(match) + " does not exist in the list.");
|
|
}
|
|
public T FindLast(Predicate<T> predicate, int start)
|
|
{
|
|
for (int i = array.Length - 1; i >= start; i--) if (predicate.Invoke(array[i])) return array[i];
|
|
throw new Exception("Parameter " + nameof(predicate) + " does not exist in the list.");
|
|
}
|
|
public T FindLast(T match, int start)
|
|
{
|
|
for (int i = array.Length - 1; i >= start; i--) if (array[i].Equals(match)) return array[i];
|
|
throw new Exception("Parameter " + nameof(match) + " does not exist in the list.");
|
|
}
|
|
public T FindLast(Predicate<T> predicate, int start, int max)
|
|
{
|
|
for (int i = max; i >= start; i--) if (predicate.Invoke(array[i])) return array[i];
|
|
throw new Exception("Parameter " + nameof(predicate) + " does not exist in the list.");
|
|
}
|
|
public T FindLast(T match, int start, int max)
|
|
{
|
|
for (int i = max; i >= start; i--) if (array[i].Equals(match)) return array[i];
|
|
throw new Exception("Parameter " + nameof(match) + " does not exist in the list.");
|
|
}
|
|
public T FindLastOrDefault(Predicate<T> predicate)
|
|
{
|
|
for (int i = array.Length - 1; i >= 0; i--) if (predicate.Invoke(array[i])) return array[i];
|
|
return default;
|
|
}
|
|
public T FindLastOrDefault(T match)
|
|
{
|
|
for (int i = array.Length - 1; i >= 0; i--) if (array[i].Equals(match)) return array[i];
|
|
return default;
|
|
}
|
|
public T FindLastOrDefault(Predicate<T> predicate, int start)
|
|
{
|
|
for (int i = array.Length - 1; i >= start; i--) if (predicate.Invoke(array[i])) return array[i];
|
|
return default;
|
|
}
|
|
public T FindLastOrDefault(T match, int start)
|
|
{
|
|
for (int i = array.Length - 1; i >= start; i--) if (array[i].Equals(match)) return array[i];
|
|
return default;
|
|
}
|
|
public T FindLastOrDefault(Predicate<T> predicate, int start, int max)
|
|
{
|
|
for (int i = max; i >= start; i--) if (predicate.Invoke(array[i])) return array[i];
|
|
return default;
|
|
}
|
|
public T FindLastOrDefault(T match, int start, int max)
|
|
{
|
|
for (int i = max; i >= start; i--) if (array[i].Equals(match)) return array[i];
|
|
return default;
|
|
}
|
|
public int FindIndex(Predicate<T> predicate)
|
|
{
|
|
for (int i = 0; i < array.Length; i++) if (predicate.Invoke(array[i])) return i;
|
|
return -1;
|
|
}
|
|
public int FindIndex(T match)
|
|
{
|
|
for (int i = 0; i < array.Length; i++) if (array[i].Equals(match)) return i;
|
|
return -1;
|
|
}
|
|
public int FindIndex(Predicate<T> predicate, int start)
|
|
{
|
|
for (int i = start; i < array.Length; i++) if (predicate.Invoke(array[i])) return i;
|
|
return -1;
|
|
}
|
|
public int FindIndex(T match, int start)
|
|
{
|
|
for (int i = start; i < array.Length; i++) if (array[i].Equals(match)) return i;
|
|
return -1;
|
|
}
|
|
public int FindIndex(Predicate<T> predicate, int start, int max)
|
|
{
|
|
for (int i = start; i <= max; i++) if (predicate.Invoke(array[i])) return i;
|
|
return -1;
|
|
}
|
|
public int FindIndex(T match, int start, int max)
|
|
{
|
|
for (int i = start; i <= max; i++) if (array[i].Equals(match)) return i;
|
|
return -1;
|
|
}
|
|
public List<int> FindAllIndex()
|
|
{
|
|
List<int> ret = new();
|
|
for (int i = 0; i < array.Length; i++) ret.Add(i);
|
|
return ret;
|
|
}
|
|
public List<int> FindAllIndex(Predicate<T> predicate)
|
|
{
|
|
List<int> r = new();
|
|
for (int i = 0; i < array.Length; i++) if (predicate.Invoke(array[i])) r.Add(i);
|
|
return r;
|
|
}
|
|
public List<int> FindAllIndex(T match)
|
|
{
|
|
List<int> r = new();
|
|
for (int i = 0; i < array.Length; i++) if (array[i].Equals(match)) r.Add(i);
|
|
return r;
|
|
}
|
|
public List<int> FindAllIndex(int start)
|
|
{
|
|
List<int> ret = new();
|
|
for (int i = start; i < array.Length; i++) ret.Add(i);
|
|
return ret;
|
|
}
|
|
public List<int> FindAllIndex(Predicate<T> predicate, int start)
|
|
{
|
|
List<int> r = new();
|
|
for (int i = start; i < array.Length; i++) if (predicate.Invoke(array[i])) r.Add(i);
|
|
return r;
|
|
}
|
|
public List<int> FindAllIndex(T match, int start)
|
|
{
|
|
List<int> r = new();
|
|
for (int i = start; i < array.Length; i++) if (array[i].Equals(match)) r.Add(i);
|
|
return r;
|
|
}
|
|
public List<int> FindAllIndex(int start, int max)
|
|
{
|
|
List<int> ret = new();
|
|
for (int i = start; i <= max; i++) ret.Add(i);
|
|
return ret;
|
|
}
|
|
public List<int> FindAllIndex(Predicate<T> predicate, int start, int max)
|
|
{
|
|
List<int> r = new();
|
|
for (int i = start; i <= max; i++) if (predicate.Invoke(array[i])) r.Add(i);
|
|
return r;
|
|
}
|
|
public List<int> FindAllIndex(T match, int start, int max)
|
|
{
|
|
List<int> r = new();
|
|
for (int i = start; i <= max; i++) if (array[i].Equals(match)) r.Add(i);
|
|
return r;
|
|
}
|
|
public int FindLastIndex(Predicate<T> predicate)
|
|
{
|
|
for (int i = array.Length - 1; i >= 0; i--) if (predicate.Invoke(array[i])) return i;
|
|
return -1;
|
|
}
|
|
public int FindLastIndex(T match)
|
|
{
|
|
for (int i = array.Length - 1; i >= 0; i--) if (array[i].Equals(match)) return i;
|
|
return -1;
|
|
}
|
|
public int FindLastIndex(Predicate<T> predicate, int start)
|
|
{
|
|
for (int i = array.Length - 1; i >= start; i--) if (predicate.Invoke(array[i])) return i;
|
|
return -1;
|
|
}
|
|
public int FindLastIndex(T match, int start)
|
|
{
|
|
for (int i = array.Length - 1; i >= start; i--) if (array[i].Equals(match)) return i;
|
|
return -1;
|
|
}
|
|
public int FindLastIndex(Predicate<T> predicate, int start, int max)
|
|
{
|
|
for (int i = max; i >= start; i--) if (predicate.Invoke(array[i])) return i;
|
|
return -1;
|
|
}
|
|
public int FindLastIndex(T match, int start, int max)
|
|
{
|
|
for (int i = max; i >= start; i--) if (array[i].Equals(match)) return i;
|
|
return -1;
|
|
}
|
|
public IEnumerator GetEnumerator() => array.GetEnumerator();
|
|
IEnumerator<T> IEnumerable<T>.GetEnumerator() => (IEnumerator<T>)array.GetEnumerator();
|
|
public List<T> GetRange(int start, int max)
|
|
{
|
|
List<T> r = new();
|
|
for (int i = start; i <= max; i++) r.Add(array[i]);
|
|
return r;
|
|
}
|
|
public bool MatchesAll(Predicate<T> predicate) => FindAll(predicate).array == array;
|
|
public bool MatchesAll(T match) => FindAll(match).array == array;
|
|
public T[] ToArray() => array;
|
|
public List<T> ToList() => new(array);
|
|
public System.Collections.Generic.List<T> ToSystemList() => new(array);
|
|
public ReadOnlyCollection<T> ToSystemReadOnly() => new(array);
|
|
|
|
public override bool Equals(object obj) => base.Equals(obj);
|
|
public bool Equals(T[] other)
|
|
{
|
|
bool returned = true;
|
|
if (Length == other.Length)
|
|
{
|
|
for (int i = 0; i < Length; i++)
|
|
{
|
|
returned &= array[i].Equals(other[i]);
|
|
}
|
|
}
|
|
return returned;
|
|
}
|
|
public bool Equals(ReadOnlyList<T> list)
|
|
{
|
|
if (Length != list.Length) return false;
|
|
bool equal = true;
|
|
for (int i = 0; i < Length; i++) equal &= array[i].Equals(list[i]);
|
|
return equal;
|
|
}
|
|
public bool Equals(IEnumerable<T> list) => Equals(new ReadOnlyList<T>(list));
|
|
public override int GetHashCode() => base.GetHashCode();
|
|
public override string ToString() => ToString(false);
|
|
public string ToString(bool showAll = false)
|
|
{
|
|
string ret = "List of " + Length + " Elements (" + typeof(T).ToString() + ")";
|
|
if (showAll) for (int i = 0; i < Length; i++) ret += "\n" + i + ": " + array[i];
|
|
return ret;
|
|
}
|
|
|
|
public static bool operator ==(ReadOnlyList<T> a, ReadOnlyList<T> b) => a.Equals(b);
|
|
public static bool operator ==(ReadOnlyList<T> a, T[] b)
|
|
{
|
|
return a.Equals(b);
|
|
}
|
|
public static bool operator ==(T[] a, ReadOnlyList<T> b)
|
|
{
|
|
return b.Equals(a);
|
|
}
|
|
public static bool operator ==(IEnumerable<T> a, ReadOnlyList<T> b) => a.Equals(b);
|
|
public static bool operator ==(ReadOnlyList<T> a, IEnumerable<T> b) => a.Equals(b);
|
|
public static bool operator !=(ReadOnlyList<T> a, ReadOnlyList<T> b) => !a.Equals(b);
|
|
public static bool operator !=(ReadOnlyList<T> a, T[] b)
|
|
{
|
|
return !a.Equals(b);
|
|
}
|
|
public static bool operator !=(T[] a, ReadOnlyList<T> b)
|
|
{
|
|
return !b.Equals(a);
|
|
}
|
|
public static bool operator !=(IEnumerable<T> a, ReadOnlyList<T> b) => !a.Equals(b);
|
|
public static bool operator !=(ReadOnlyList<T> a, IEnumerable<T> b) => !a.Equals(b);
|
|
}
|
|
} |