1234 lines
48 KiB
C#
1234 lines
48 KiB
C#
using System;
|
|
using Unity.Collections.LowLevel.Unsafe;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// <auto-generated>
|
|
// This code was generated by a tool.
|
|
//
|
|
// t4 Packages/com.unity.collections/Unity.Collections/NativeParallelHashSetExtensions.tt
|
|
//
|
|
// Changes to this file may cause incorrect behavior and will be lost if
|
|
// the code is regenerated.
|
|
// </auto-generated>
|
|
//------------------------------------------------------------------------------
|
|
|
|
namespace Unity.Collections
|
|
{
|
|
/// <summary>
|
|
/// Provides extension methods for sets.
|
|
/// </summary>
|
|
public unsafe static class HashSetExtensions
|
|
{
|
|
/// <summary>
|
|
/// Removes the values from this set which are also present in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void ExceptWith<T>(this ref NativeHashSet<T> container, FixedList128Bytes<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.Remove(item);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes the values from this set which are absent in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void IntersectWith<T>(this ref NativeHashSet<T> container, FixedList128Bytes<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
var result = new UnsafeList<T>(container.Count, Allocator.Temp);
|
|
|
|
foreach (var item in other)
|
|
{
|
|
if (container.Contains(item))
|
|
{
|
|
result.Add(item);
|
|
}
|
|
}
|
|
|
|
container.Clear();
|
|
container.UnionWith(result);
|
|
|
|
result.Dispose();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds all distinct values from the other collection to this set.
|
|
/// Does not throw if a value is already in this set.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to add values to.</param>
|
|
/// <param name="other">The collection to copy values from.</param>
|
|
public static void UnionWith<T>(this ref NativeHashSet<T> container, FixedList128Bytes<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.TryAdd(item);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Removes the values from this set which are also present in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void ExceptWith<T>(this ref NativeHashSet<T> container, FixedList32Bytes<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.Remove(item);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes the values from this set which are absent in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void IntersectWith<T>(this ref NativeHashSet<T> container, FixedList32Bytes<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
var result = new UnsafeList<T>(container.Count, Allocator.Temp);
|
|
|
|
foreach (var item in other)
|
|
{
|
|
if (container.Contains(item))
|
|
{
|
|
result.Add(item);
|
|
}
|
|
}
|
|
|
|
container.Clear();
|
|
container.UnionWith(result);
|
|
|
|
result.Dispose();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds all distinct values from the other collection to this set.
|
|
/// Does not throw if a value is already in this set.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to add values to.</param>
|
|
/// <param name="other">The collection to copy values from.</param>
|
|
public static void UnionWith<T>(this ref NativeHashSet<T> container, FixedList32Bytes<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.TryAdd(item);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Removes the values from this set which are also present in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void ExceptWith<T>(this ref NativeHashSet<T> container, FixedList4096Bytes<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.Remove(item);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes the values from this set which are absent in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void IntersectWith<T>(this ref NativeHashSet<T> container, FixedList4096Bytes<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
var result = new UnsafeList<T>(container.Count, Allocator.Temp);
|
|
|
|
foreach (var item in other)
|
|
{
|
|
if (container.Contains(item))
|
|
{
|
|
result.Add(item);
|
|
}
|
|
}
|
|
|
|
container.Clear();
|
|
container.UnionWith(result);
|
|
|
|
result.Dispose();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds all distinct values from the other collection to this set.
|
|
/// Does not throw if a value is already in this set.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to add values to.</param>
|
|
/// <param name="other">The collection to copy values from.</param>
|
|
public static void UnionWith<T>(this ref NativeHashSet<T> container, FixedList4096Bytes<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.TryAdd(item);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Removes the values from this set which are also present in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void ExceptWith<T>(this ref NativeHashSet<T> container, FixedList512Bytes<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.Remove(item);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes the values from this set which are absent in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void IntersectWith<T>(this ref NativeHashSet<T> container, FixedList512Bytes<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
var result = new UnsafeList<T>(container.Count, Allocator.Temp);
|
|
|
|
foreach (var item in other)
|
|
{
|
|
if (container.Contains(item))
|
|
{
|
|
result.Add(item);
|
|
}
|
|
}
|
|
|
|
container.Clear();
|
|
container.UnionWith(result);
|
|
|
|
result.Dispose();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds all distinct values from the other collection to this set.
|
|
/// Does not throw if a value is already in this set.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to add values to.</param>
|
|
/// <param name="other">The collection to copy values from.</param>
|
|
public static void UnionWith<T>(this ref NativeHashSet<T> container, FixedList512Bytes<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.TryAdd(item);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Removes the values from this set which are also present in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void ExceptWith<T>(this ref NativeHashSet<T> container, FixedList64Bytes<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.Remove(item);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes the values from this set which are absent in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void IntersectWith<T>(this ref NativeHashSet<T> container, FixedList64Bytes<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
var result = new UnsafeList<T>(container.Count, Allocator.Temp);
|
|
|
|
foreach (var item in other)
|
|
{
|
|
if (container.Contains(item))
|
|
{
|
|
result.Add(item);
|
|
}
|
|
}
|
|
|
|
container.Clear();
|
|
container.UnionWith(result);
|
|
|
|
result.Dispose();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds all distinct values from the other collection to this set.
|
|
/// Does not throw if a value is already in this set.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to add values to.</param>
|
|
/// <param name="other">The collection to copy values from.</param>
|
|
public static void UnionWith<T>(this ref NativeHashSet<T> container, FixedList64Bytes<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.TryAdd(item);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Removes the values from this set which are also present in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void ExceptWith<T>(this ref NativeHashSet<T> container, NativeArray<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.Remove(item);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes the values from this set which are absent in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void IntersectWith<T>(this ref NativeHashSet<T> container, NativeArray<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
var result = new UnsafeList<T>(container.Count, Allocator.Temp);
|
|
|
|
foreach (var item in other)
|
|
{
|
|
if (container.Contains(item))
|
|
{
|
|
result.Add(item);
|
|
}
|
|
}
|
|
|
|
container.Clear();
|
|
container.UnionWith(result);
|
|
|
|
result.Dispose();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds all distinct values from the other collection to this set.
|
|
/// Does not throw if a value is already in this set.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to add values to.</param>
|
|
/// <param name="other">The collection to copy values from.</param>
|
|
public static void UnionWith<T>(this ref NativeHashSet<T> container, NativeArray<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.TryAdd(item);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Removes the values from this set which are also present in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void ExceptWith<T>(this ref NativeHashSet<T> container, NativeHashSet<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.Remove(item);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes the values from this set which are absent in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void IntersectWith<T>(this ref NativeHashSet<T> container, NativeHashSet<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
var result = new UnsafeList<T>(container.Count, Allocator.Temp);
|
|
|
|
foreach (var item in other)
|
|
{
|
|
if (container.Contains(item))
|
|
{
|
|
result.Add(item);
|
|
}
|
|
}
|
|
|
|
container.Clear();
|
|
container.UnionWith(result);
|
|
|
|
result.Dispose();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds all distinct values from the other collection to this set.
|
|
/// Does not throw if a value is already in this set.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to add values to.</param>
|
|
/// <param name="other">The collection to copy values from.</param>
|
|
public static void UnionWith<T>(this ref NativeHashSet<T> container, NativeHashSet<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.TryAdd(item);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Removes the values from this set which are also present in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void ExceptWith<T>(this ref NativeHashSet<T> container, NativeHashSet<T>.ReadOnly other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.Remove(item);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes the values from this set which are absent in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void IntersectWith<T>(this ref NativeHashSet<T> container, NativeHashSet<T>.ReadOnly other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
var result = new UnsafeList<T>(container.Count, Allocator.Temp);
|
|
|
|
foreach (var item in other)
|
|
{
|
|
if (container.Contains(item))
|
|
{
|
|
result.Add(item);
|
|
}
|
|
}
|
|
|
|
container.Clear();
|
|
container.UnionWith(result);
|
|
|
|
result.Dispose();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds all distinct values from the other collection to this set.
|
|
/// Does not throw if a value is already in this set.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to add values to.</param>
|
|
/// <param name="other">The collection to copy values from.</param>
|
|
public static void UnionWith<T>(this ref NativeHashSet<T> container, NativeHashSet<T>.ReadOnly other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.TryAdd(item);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Removes the values from this set which are also present in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void ExceptWith<T>(this ref NativeHashSet<T> container, NativeParallelHashSet<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.Remove(item);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes the values from this set which are absent in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void IntersectWith<T>(this ref NativeHashSet<T> container, NativeParallelHashSet<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
var result = new UnsafeList<T>(container.Count, Allocator.Temp);
|
|
|
|
foreach (var item in other)
|
|
{
|
|
if (container.Contains(item))
|
|
{
|
|
result.Add(item);
|
|
}
|
|
}
|
|
|
|
container.Clear();
|
|
container.UnionWith(result);
|
|
|
|
result.Dispose();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds all distinct values from the other collection to this set.
|
|
/// Does not throw if a value is already in this set.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to add values to.</param>
|
|
/// <param name="other">The collection to copy values from.</param>
|
|
public static void UnionWith<T>(this ref NativeHashSet<T> container, NativeParallelHashSet<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.TryAdd(item);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Removes the values from this set which are also present in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void ExceptWith<T>(this ref NativeHashSet<T> container, NativeParallelHashSet<T>.ReadOnly other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.Remove(item);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes the values from this set which are absent in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void IntersectWith<T>(this ref NativeHashSet<T> container, NativeParallelHashSet<T>.ReadOnly other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
var result = new UnsafeList<T>(container.Count, Allocator.Temp);
|
|
|
|
foreach (var item in other)
|
|
{
|
|
if (container.Contains(item))
|
|
{
|
|
result.Add(item);
|
|
}
|
|
}
|
|
|
|
container.Clear();
|
|
container.UnionWith(result);
|
|
|
|
result.Dispose();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds all distinct values from the other collection to this set.
|
|
/// Does not throw if a value is already in this set.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to add values to.</param>
|
|
/// <param name="other">The collection to copy values from.</param>
|
|
public static void UnionWith<T>(this ref NativeHashSet<T> container, NativeParallelHashSet<T>.ReadOnly other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.TryAdd(item);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Removes the values from this set which are also present in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void ExceptWith<T>(this ref NativeHashSet<T> container, NativeList<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.Remove(item);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes the values from this set which are absent in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void IntersectWith<T>(this ref NativeHashSet<T> container, NativeList<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
var result = new UnsafeList<T>(container.Count, Allocator.Temp);
|
|
|
|
foreach (var item in other)
|
|
{
|
|
if (container.Contains(item))
|
|
{
|
|
result.Add(item);
|
|
}
|
|
}
|
|
|
|
container.Clear();
|
|
container.UnionWith(result);
|
|
|
|
result.Dispose();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds all distinct values from the other collection to this set.
|
|
/// Does not throw if a value is already in this set.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to add values to.</param>
|
|
/// <param name="other">The collection to copy values from.</param>
|
|
public static void UnionWith<T>(this ref NativeHashSet<T> container, NativeList<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.TryAdd(item);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Removes the values from this set which are also present in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void ExceptWith<T>(this ref NativeParallelHashSet<T> container, FixedList128Bytes<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.Remove(item);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes the values from this set which are absent in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void IntersectWith<T>(this ref NativeParallelHashSet<T> container, FixedList128Bytes<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
var result = new UnsafeList<T>(container.Count(), Allocator.Temp);
|
|
|
|
foreach (var item in other)
|
|
{
|
|
if (container.Contains(item))
|
|
{
|
|
result.Add(item);
|
|
}
|
|
}
|
|
|
|
container.Clear();
|
|
container.UnionWith(result);
|
|
|
|
result.Dispose();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds all distinct values from the other collection to this set.
|
|
/// Does not throw if a value is already in this set.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to add values to.</param>
|
|
/// <param name="other">The collection to copy values from.</param>
|
|
public static void UnionWith<T>(this ref NativeParallelHashSet<T> container, FixedList128Bytes<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.TryAdd(item);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Removes the values from this set which are also present in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void ExceptWith<T>(this ref NativeParallelHashSet<T> container, FixedList32Bytes<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.Remove(item);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes the values from this set which are absent in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void IntersectWith<T>(this ref NativeParallelHashSet<T> container, FixedList32Bytes<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
var result = new UnsafeList<T>(container.Count(), Allocator.Temp);
|
|
|
|
foreach (var item in other)
|
|
{
|
|
if (container.Contains(item))
|
|
{
|
|
result.Add(item);
|
|
}
|
|
}
|
|
|
|
container.Clear();
|
|
container.UnionWith(result);
|
|
|
|
result.Dispose();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds all distinct values from the other collection to this set.
|
|
/// Does not throw if a value is already in this set.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to add values to.</param>
|
|
/// <param name="other">The collection to copy values from.</param>
|
|
public static void UnionWith<T>(this ref NativeParallelHashSet<T> container, FixedList32Bytes<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.TryAdd(item);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Removes the values from this set which are also present in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void ExceptWith<T>(this ref NativeParallelHashSet<T> container, FixedList4096Bytes<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.Remove(item);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes the values from this set which are absent in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void IntersectWith<T>(this ref NativeParallelHashSet<T> container, FixedList4096Bytes<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
var result = new UnsafeList<T>(container.Count(), Allocator.Temp);
|
|
|
|
foreach (var item in other)
|
|
{
|
|
if (container.Contains(item))
|
|
{
|
|
result.Add(item);
|
|
}
|
|
}
|
|
|
|
container.Clear();
|
|
container.UnionWith(result);
|
|
|
|
result.Dispose();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds all distinct values from the other collection to this set.
|
|
/// Does not throw if a value is already in this set.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to add values to.</param>
|
|
/// <param name="other">The collection to copy values from.</param>
|
|
public static void UnionWith<T>(this ref NativeParallelHashSet<T> container, FixedList4096Bytes<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.TryAdd(item);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Removes the values from this set which are also present in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void ExceptWith<T>(this ref NativeParallelHashSet<T> container, FixedList512Bytes<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.Remove(item);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes the values from this set which are absent in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void IntersectWith<T>(this ref NativeParallelHashSet<T> container, FixedList512Bytes<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
var result = new UnsafeList<T>(container.Count(), Allocator.Temp);
|
|
|
|
foreach (var item in other)
|
|
{
|
|
if (container.Contains(item))
|
|
{
|
|
result.Add(item);
|
|
}
|
|
}
|
|
|
|
container.Clear();
|
|
container.UnionWith(result);
|
|
|
|
result.Dispose();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds all distinct values from the other collection to this set.
|
|
/// Does not throw if a value is already in this set.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to add values to.</param>
|
|
/// <param name="other">The collection to copy values from.</param>
|
|
public static void UnionWith<T>(this ref NativeParallelHashSet<T> container, FixedList512Bytes<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.TryAdd(item);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Removes the values from this set which are also present in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void ExceptWith<T>(this ref NativeParallelHashSet<T> container, FixedList64Bytes<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.Remove(item);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes the values from this set which are absent in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void IntersectWith<T>(this ref NativeParallelHashSet<T> container, FixedList64Bytes<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
var result = new UnsafeList<T>(container.Count(), Allocator.Temp);
|
|
|
|
foreach (var item in other)
|
|
{
|
|
if (container.Contains(item))
|
|
{
|
|
result.Add(item);
|
|
}
|
|
}
|
|
|
|
container.Clear();
|
|
container.UnionWith(result);
|
|
|
|
result.Dispose();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds all distinct values from the other collection to this set.
|
|
/// Does not throw if a value is already in this set.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to add values to.</param>
|
|
/// <param name="other">The collection to copy values from.</param>
|
|
public static void UnionWith<T>(this ref NativeParallelHashSet<T> container, FixedList64Bytes<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.TryAdd(item);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Removes the values from this set which are also present in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void ExceptWith<T>(this ref NativeParallelHashSet<T> container, NativeArray<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.Remove(item);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes the values from this set which are absent in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void IntersectWith<T>(this ref NativeParallelHashSet<T> container, NativeArray<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
var result = new UnsafeList<T>(container.Count(), Allocator.Temp);
|
|
|
|
foreach (var item in other)
|
|
{
|
|
if (container.Contains(item))
|
|
{
|
|
result.Add(item);
|
|
}
|
|
}
|
|
|
|
container.Clear();
|
|
container.UnionWith(result);
|
|
|
|
result.Dispose();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds all distinct values from the other collection to this set.
|
|
/// Does not throw if a value is already in this set.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to add values to.</param>
|
|
/// <param name="other">The collection to copy values from.</param>
|
|
public static void UnionWith<T>(this ref NativeParallelHashSet<T> container, NativeArray<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.TryAdd(item);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Removes the values from this set which are also present in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void ExceptWith<T>(this ref NativeParallelHashSet<T> container, NativeHashSet<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.Remove(item);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes the values from this set which are absent in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void IntersectWith<T>(this ref NativeParallelHashSet<T> container, NativeHashSet<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
var result = new UnsafeList<T>(container.Count(), Allocator.Temp);
|
|
|
|
foreach (var item in other)
|
|
{
|
|
if (container.Contains(item))
|
|
{
|
|
result.Add(item);
|
|
}
|
|
}
|
|
|
|
container.Clear();
|
|
container.UnionWith(result);
|
|
|
|
result.Dispose();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds all distinct values from the other collection to this set.
|
|
/// Does not throw if a value is already in this set.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to add values to.</param>
|
|
/// <param name="other">The collection to copy values from.</param>
|
|
public static void UnionWith<T>(this ref NativeParallelHashSet<T> container, NativeHashSet<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.TryAdd(item);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Removes the values from this set which are also present in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void ExceptWith<T>(this ref NativeParallelHashSet<T> container, NativeHashSet<T>.ReadOnly other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.Remove(item);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes the values from this set which are absent in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void IntersectWith<T>(this ref NativeParallelHashSet<T> container, NativeHashSet<T>.ReadOnly other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
var result = new UnsafeList<T>(container.Count(), Allocator.Temp);
|
|
|
|
foreach (var item in other)
|
|
{
|
|
if (container.Contains(item))
|
|
{
|
|
result.Add(item);
|
|
}
|
|
}
|
|
|
|
container.Clear();
|
|
container.UnionWith(result);
|
|
|
|
result.Dispose();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds all distinct values from the other collection to this set.
|
|
/// Does not throw if a value is already in this set.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to add values to.</param>
|
|
/// <param name="other">The collection to copy values from.</param>
|
|
public static void UnionWith<T>(this ref NativeParallelHashSet<T> container, NativeHashSet<T>.ReadOnly other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.TryAdd(item);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Removes the values from this set which are also present in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void ExceptWith<T>(this ref NativeParallelHashSet<T> container, NativeParallelHashSet<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.Remove(item);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes the values from this set which are absent in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void IntersectWith<T>(this ref NativeParallelHashSet<T> container, NativeParallelHashSet<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
var result = new UnsafeList<T>(container.Count(), Allocator.Temp);
|
|
|
|
foreach (var item in other)
|
|
{
|
|
if (container.Contains(item))
|
|
{
|
|
result.Add(item);
|
|
}
|
|
}
|
|
|
|
container.Clear();
|
|
container.UnionWith(result);
|
|
|
|
result.Dispose();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds all distinct values from the other collection to this set.
|
|
/// Does not throw if a value is already in this set.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to add values to.</param>
|
|
/// <param name="other">The collection to copy values from.</param>
|
|
public static void UnionWith<T>(this ref NativeParallelHashSet<T> container, NativeParallelHashSet<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.TryAdd(item);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Removes the values from this set which are also present in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void ExceptWith<T>(this ref NativeParallelHashSet<T> container, NativeParallelHashSet<T>.ReadOnly other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.Remove(item);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes the values from this set which are absent in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void IntersectWith<T>(this ref NativeParallelHashSet<T> container, NativeParallelHashSet<T>.ReadOnly other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
var result = new UnsafeList<T>(container.Count(), Allocator.Temp);
|
|
|
|
foreach (var item in other)
|
|
{
|
|
if (container.Contains(item))
|
|
{
|
|
result.Add(item);
|
|
}
|
|
}
|
|
|
|
container.Clear();
|
|
container.UnionWith(result);
|
|
|
|
result.Dispose();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds all distinct values from the other collection to this set.
|
|
/// Does not throw if a value is already in this set.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to add values to.</param>
|
|
/// <param name="other">The collection to copy values from.</param>
|
|
public static void UnionWith<T>(this ref NativeParallelHashSet<T> container, NativeParallelHashSet<T>.ReadOnly other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.TryAdd(item);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Removes the values from this set which are also present in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void ExceptWith<T>(this ref NativeParallelHashSet<T> container, NativeList<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.Remove(item);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes the values from this set which are absent in another collection.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to remove values from.</param>
|
|
/// <param name="other">The collection to compare with.</param>
|
|
public static void IntersectWith<T>(this ref NativeParallelHashSet<T> container, NativeList<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
var result = new UnsafeList<T>(container.Count(), Allocator.Temp);
|
|
|
|
foreach (var item in other)
|
|
{
|
|
if (container.Contains(item))
|
|
{
|
|
result.Add(item);
|
|
}
|
|
}
|
|
|
|
container.Clear();
|
|
container.UnionWith(result);
|
|
|
|
result.Dispose();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds all distinct values from the other collection to this set.
|
|
/// Does not throw if a value is already in this set.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of values.</typeparam>
|
|
/// <param name="container">The set to add values to.</param>
|
|
/// <param name="other">The collection to copy values from.</param>
|
|
public static void UnionWith<T>(this ref NativeParallelHashSet<T> container, NativeList<T> other)
|
|
where T : unmanaged, IEquatable<T>
|
|
{
|
|
foreach (var item in other)
|
|
{
|
|
container.TryAdd(item);
|
|
}
|
|
}
|
|
}
|
|
}
|