public void CopyFrom(RefList <T> other) { ArrayUtils.Copy(in other.arr, ref this.arr); if (this.freePrepared != null) { PoolHashSetCopyable <int> .Recycle(ref this.freePrepared); } this.freePrepared = PoolHashSetCopyable <int> .Spawn(other.freePrepared.Count); this.freePrepared.CopyFrom(other.freePrepared); if (this.freePeek != null) { PoolQueueCopyable <int> .Recycle(ref this.freePeek); } this.freePeek = PoolQueueCopyable <int> .Spawn(other.freePeek.Count); this.freePeek.CopyFrom(other.freePeek); if (this.free != null) { PoolHashSetCopyable <int> .Recycle(ref this.free); } this.free = PoolHashSetCopyable <int> .Spawn(other.free.Count); this.free.CopyFrom(other.free); this.size = other.size; this.capacity = other.capacity; this.count = other.count; this.fromIndex = other.fromIndex; this.initCapacity = other.initCapacity; }
private void Init(int capacity) { if (capacity < 0) { capacity = 0; } this.count = 0; this.size = 0; this.capacity = -1; this.fromIndex = 0; if (this.freePeek == null) { this.freePeek = PoolQueueCopyable <int> .Spawn(capacity); } this.freePeek.Clear(); if (this.free == null) { this.free = PoolHashSetCopyable <int> .Spawn(capacity); } this.free.Clear(); if (this.freePrepared == null) { this.freePrepared = PoolHashSetCopyable <int> .Spawn(capacity); } this.freePrepared.Clear(); this.Resize_INTERNAL(capacity); }
/// <summary> /// Checks if this is a superset of other /// /// Implementation Notes: /// The following properties are used up-front to avoid element-wise checks: /// 1. If other has no elements (it's the empty set), then this is a superset, even if this /// is also the empty set. /// 2. If other has unique elements according to this equality comparer, and this has less /// than the number of elements in other, then this can't be a superset /// /// </summary> /// <param name="other"></param> /// <returns>true if this is a superset of other; false if not</returns> public bool IsSupersetOf(IEnumerable <T> other) { if (other == null) { throw new ArgumentNullException("other"); } // try to fall out early based on counts ICollection <T> otherAsCollection = other as ICollection <T>; if (otherAsCollection != null) { // if other is the empty set then this is a superset if (otherAsCollection.Count == 0) { return(true); } HashSetCopyable <T> otherAsSet = other as HashSetCopyable <T>; // try to compare based on counts alone if other is a hashset with // same equality comparer if (otherAsSet != null && AreEqualityComparersEqual(this, otherAsSet)) { if (otherAsSet.Count > m_count) { return(false); } } } return(ContainsAllElements(other)); }
internal Enumerator(HashSetCopyable <T> set) { this.set = set; index = 0; version = set.m_version; current = default(T); }
/// <summary> /// Internal method used for HashSetEqualityComparer. Compares set1 and set2 according /// to specified comparer. /// /// Because items are hashed according to a specific equality comparer, we have to resort /// to n^2 search if they're using different equality comparers. /// </summary> /// <param name="set1"></param> /// <param name="set2"></param> /// <param name="comparer"></param> /// <returns></returns> internal static bool HashSetEquals(HashSetCopyable <T> set1, HashSetCopyable <T> set2, IEqualityComparer <T> comparer) { // handle null cases first if (set1 == null) { return(set2 == null); } else if (set2 == null) { // set1 != null return(false); } // all comparers are the same; this is faster if (AreEqualityComparersEqual(set1, set2)) { if (set1.Count != set2.Count) { return(false); } // suffices to check subset foreach (T item in set2) { if (!set1.Contains(item)) { return(false); } } return(true); } else // n^2 search because items are hashed according to their respective ECs { foreach (T set2Item in set2) { bool found = false; foreach (T set1Item in set1) { if (comparer.Equals(set2Item, set1Item)) { found = true; break; } } if (!found) { return(false); } } return(true); } }
public void CopyFrom(HashSetCopyable <T> other) { if (this.m_buckets != null) { PoolArray <int> .Recycle(ref this.m_buckets); } if (other.m_buckets != null) { this.m_buckets = PoolArray <int> .Spawn(other.m_buckets.Length); for (int i = 0; i < this.m_buckets.Length; ++i) { this.m_buckets[i] = other.m_buckets[i]; } } if (this.m_slots != null) { PoolArray <Slot> .Recycle(ref this.m_slots); } if (other.m_slots != null) { this.m_slots = PoolArray <Slot> .Spawn(other.m_slots.Length); for (int i = 0; i < this.m_slots.Length; ++i) { this.m_slots[i] = other.m_slots[i]; } } this.m_count = other.m_count; this.m_lastIndex = other.m_lastIndex; this.m_freeList = other.m_freeList; this.m_comparer = other.m_comparer; this.m_version = other.m_version; }
/// <summary> /// Checks if equality comparers are equal. This is used for algorithms that can /// speed up if it knows the other item has unique elements. I.e. if they're using /// different equality comparers, then uniqueness assumption between sets break. /// </summary> /// <param name="set1"></param> /// <param name="set2"></param> /// <returns></returns> private static bool AreEqualityComparersEqual(HashSetCopyable <T> set1, HashSetCopyable <T> set2) { return(set1.Comparer.Equals(set2.Comparer)); }