public void Test1()
{
var parser = new FiltersParser();
var fastCollection = new FastCollection <TestClassA>();
var parsed = parser.ParsePredicate((TestClassA x) => x.F1 > 3, OperationTargetBuilder.BuildForRoot(fastCollection));
Assert.IsAssignableFrom <ComparisonFilter>(parsed);
Assert.AreEqual(ComparisonFilterType.Greater, ((ComparisonFilter)parsed).ComparisonFilterType);
Assert.AreEqual(3, ((ComparisonFilter)parsed).Value);
Assert.AreSame(fastCollection, ((ComparisonFilter)parsed).OperationTarget.RootFastCollection);
}
internal static void UpdateTransformations(FastCollection <TransformComponent> transformationComponents)
{
Dispatcher.ForEach(transformationComponents, transformation =>
{
UpdateTransformation(transformation);
// Recurse
if (transformation.Children.Count > 0)
{
UpdateTransformationsRecursive(transformation.Children);
}
});
}
private static void UpdateTransformationsRecursive(FastCollection <TransformComponent> transformationComponents)
{
foreach (var transformation in transformationComponents)
{
UpdateTransformation(transformation);
// Recurse
if (transformation.Children.Count > 0)
{
UpdateTransformationsRecursive(transformation.Children);
}
}
}
public void RemoveAllWorks()
{
var c = new FastCollection<int> { 1, 2, 3, 4, 5 };
c.RemoveAll(x => x % 2 == 0);
AssertEquals(c, new[] { 1, 3, 5 });
c.RemoveAll(x => false);
AssertEquals(c, new[] { 1, 3, 5 });
c.RemoveAll(x => true);
Assert.Equal(0, c.Count);
Assert.False(c.Any());
c.RemoveAll(x => true);
Assert.Equal(0, c.Count);
Assert.False(c.Any());
}
public void Remove()
{
IList b = new List <int>();
var fc = new FastCollection <IList>();
fc.Add(b, 2);
Assert.AreEqual(1, b.Count);
fc.Remove(b, 2);
Assert.AreEqual(0, b.Count);
}
private static void UpdateTransformationsRecursive(FastCollection <TransformComponent> transformationComponents)
{
for (int i = 0; i < transformationComponents.Count; i++)
{
TransformComponent transformation = transformationComponents[i];
UpdateTransformation(transformation);
// Recurse
if (transformation.Children.Count > 0)
{
UpdateTransformationsRecursive(transformation.Children);
}
}
}
internal void UpdateTransformations(FastCollection <TransformComponent> transformationComponents)
{
Dispatcher.ForEach(transformationComponents, UpdateTransformationAndChildren);
// Re-update model node links to avoid one frame delay compared reference model (ideally entity should be sorted to avoid this in future).
if (ModelNodeLinkProcessor != null)
{
modelNodeLinkComponents.Clear();
foreach (var modelNodeLink in ModelNodeLinkProcessor.ModelNodeLinkComponents)
{
modelNodeLinkComponents.Add(modelNodeLink.Entity.Transform);
}
Dispatcher.ForEach(modelNodeLinkComponents, UpdateTransformationAndChildren);
}
}
public static FastList <Vector3> GetPoints(SplineMeshComponent component, FastCollection <TransformComponent> children)
{
// Setup the points
var points = new FastList <Vector3>();
foreach (var child in children)
{
points.Add(child.WorldMatrix.TranslationVector);
}
var output = new FastList <Vector3>();
GetPoints(points, component.SegmentLength, output);
return(output);
}
private static void UpdateTransformationsRecursive(FastCollection <TransformComponent> transformationComponents)
{
for (int i = 0; i < transformationComponents.Count; i++)
{
TransformComponent transformation = transformationComponents[i];
transformation.UpdateLocalMatrix();
transformation.UpdateWorldMatrixInternal(false);
// Recurse
if (transformation.Children.Count > 0)
{
UpdateTransformationsRecursive(transformation.Children);
}
}
}
public void AddRangeEnumerableWorks()
{
var c = new FastCollection<int>();
const int count = 10;
var array = (IEnumerable<int>)Enumerable.Range(0, count).ToArray();
c.AddRange(array, 10);
AssertEquals(c, array);
c.AddRange(array, 0);
AssertEquals(c, array);
c.Clear();
Assert.Equal(0, c.Count);
c.AddRange(array, 0);
Assert.Equal(0, c.Count);
c.AddRange(array, 2);
AssertEquals(c, array.Take(2));
}
public void AddRangeArrayWorks()
{
var c = new FastCollection<int>();
var array = Enumerable.Range(0, 10).ToArray();
c.AddRange(array, 0, 10);
AssertEquals(c, array);
c.AddRange(array, 5, 0);
AssertEquals(c, array);
c.Clear();
Assert.Equal(0, c.Count);
c.AddRange(array, 0);
Assert.Equal(0, c.Count);
c.AddRange(array, 0, 2);
AssertEquals(c, array.Take(2));
c.AddRange(array, 2, 3);
AssertEquals(c, array.Take(5));
}
/// <summary>
/// Initializes a new instance of the <see cref="EntityManager"/> class.
/// </summary>
/// <param name="registry">The registry.</param>
/// <exception cref="System.ArgumentNullException">registry</exception>
protected EntityManager(IServiceRegistry registry)
{
if (registry == null)
{
throw new ArgumentNullException("registry");
}
Services = registry;
entities = new TrackingDictionary <Entity, List <EntityProcessor> >();
enabledEntities = new TrackingHashSet <Entity>();
processors = new FastCollection <EntityProcessor>();
newProcessors = new List <EntityProcessor>();
componentTypes = new HashSet <Type>();
processorTypes = new HashSet <Type>();
}
internal static void UpdateTransformations(FastCollection <TransformationComponent> transformationComponents, bool skipSpecialRoots)
{
// To avoid GC pressure (due to lambda), parallelize only if required
if (transformationComponents.Count >= 1024)
{
TaskList.Dispatch(
transformationComponents,
8,
1024,
(i, transformation) =>
{
if (skipSpecialRoots && transformation.isSpecialRoot)
{
return;
}
UpdateTransformation(transformation);
// Recurse
if (transformation.Children.Count > 0)
{
UpdateTransformations(transformation.Children, true);
}
}
);
}
else
{
foreach (var transformation in transformationComponents)
{
if (skipSpecialRoots && transformation.isSpecialRoot)
{
continue;
}
UpdateTransformation(transformation);
// Recurse
if (transformation.Children.Count > 0)
{
UpdateTransformations(transformation.Children, true);
}
}
}
}
public void Test1()
{
var fastCollection = new FastCollection <int>();
var filter1 = new ComparisonFilter(OperationTargetBuilder.BuildForRoot(fastCollection), ComparisonFilterType.Less, 3);
var filter2 = new ComparisonFilter(OperationTargetBuilder.BuildForRoot(fastCollection), ComparisonFilterType.Greater, 6);
var filter3 = new CompoundFilter(
CompoundFilter.CompoundFilterType.And,
filter1,
filter2);
var executionGroups = FiltersExecutionPipeline.Build(filter3).GetExecutionGroups();
Assert.AreEqual(0, executionGroups.ElementAt(0).Level);
CollectionAssert.AreEquivalent(new [] { filter1, filter2 }, executionGroups.ElementAt(0).Filters);
Assert.AreEqual(1, executionGroups.ElementAt(1).Level);
CollectionAssert.AreEquivalent(new [] { filter3 }, executionGroups.ElementAt(1).Filters);
}
public void AndCompoundTest()
{
var parser = new FiltersParser();
var fastCollection = new FastCollection <TestClassA>();
var parsed = parser.ParsePredicate((TestClassA x) => (x.F1 > 3) && (x.F1 <= 10), OperationTargetBuilder.BuildForRoot(fastCollection));
Assert.IsAssignableFrom <CompoundFilter>(parsed);
Assert.AreEqual(CompoundFilter.CompoundFilterType.And, ((CompoundFilter)parsed).OperationType);
var filter1 = (ComparisonFilter)((CompoundFilter)parsed).Operands.ElementAt(0);
Assert.AreEqual(ComparisonFilterType.Greater, filter1.ComparisonFilterType);
Assert.AreEqual(3, filter1.Value);
var filter2 = (ComparisonFilter)((CompoundFilter)parsed).Operands.ElementAt(1);
Assert.AreEqual(ComparisonFilterType.LessOrEqual, filter2.ComparisonFilterType);
Assert.AreEqual(10, filter2.Value);
}
public void DoesntHoldReferencesRemoveAll()
{
var wr1 = new WeakReference(new object());
var wr2 = new WeakReference(new object());
var c = new FastCollection<object> { wr1.Target, wr2.Target };
GCEx.CollectAndWait();
Assert.Equal(2, c.Count);
Assert.True(wr1.IsAlive);
Assert.True(wr2.IsAlive);
c.RemoveAll(x => x == wr1.Target);
GCEx.CollectAndWait();
Assert.Equal(1, c.Count);
Assert.False(wr1.IsAlive);
Assert.True(wr2.IsAlive);
c.RemoveAll(x => x == wr2.Target);
GCEx.CollectAndWait();
Assert.Equal(0, c.Count);
Assert.False(wr1.IsAlive);
Assert.False(wr2.IsAlive);
}
public void IndexOfWorks()
{
var c = new FastCollection<int> { 1, 2, 3 };
Assert.Equal(1, c[c.IndexOf(1)]);
Assert.Equal(2, c[c.IndexOf(2)]);
Assert.Equal(3, c[c.IndexOf(3)]);
Assert.Equal(-1, c.IndexOf(4));
c.Remove(1);
Assert.Equal(2, c[c.IndexOf(2)]);
Assert.Equal(3, c[c.IndexOf(3)]);
Assert.Equal(-1, c.IndexOf(1));
c.Clear();
Assert.Equal(-1, c.IndexOf(1));
Assert.Equal(-1, c.IndexOf(2));
Assert.Equal(-1, c.IndexOf(3));
c.Add(3);
Assert.Equal(-1, c.IndexOf(1));
Assert.Equal(-1, c.IndexOf(2));
Assert.Equal(0, c.IndexOf(3));
Assert.Equal(3, c[0]);
}
public void ContainsWorks()
{
var c = new FastCollection<int> { 1, 2, 3 };
Assert.True(c.Contains(1));
Assert.True(c.Contains(2));
Assert.True(c.Contains(3));
Assert.False(c.Contains(4));
c.Remove(1);
Assert.False(c.Contains(1));
Assert.True(c.Contains(2));
Assert.True(c.Contains(3));
Assert.False(c.Contains(4));
c.Clear();
Assert.False(c.Contains(1));
Assert.False(c.Contains(2));
Assert.False(c.Contains(3));
c.Add(3);
Assert.False(c.Contains(1));
Assert.False(c.Contains(2));
Assert.True(c.Contains(3));
}
private bool RecurseCheckChildren(FastCollection <TransformComponent> children, TransformComponent targetTransform)
{
foreach (var transformComponentChild in children)
{
if (transformComponentChild.Parent == null)
{
continue; // skip this case, the parent has not updated it's list yet
}
if (!RecurseCheckChildren(transformComponentChild.Children, targetTransform))
{
return(false);
}
if (targetTransform.Entity.Id != transformComponentChild.Entity.Id)
{
continue;
}
return(false);
}
return(true);
}
public void DoesntHoldReferences()
{
var wr1 = new WeakReference(new object());
var wr2 = new WeakReference(new object());
var c = new FastCollection<object> { wr1.Target, wr2.Target };
GC.Collect();
//GC.WaitForFullGCComplete();
Assert.Equal(2, c.Count);
Assert.True(wr1.IsAlive);
Assert.True(wr2.IsAlive);
c.Remove(wr1.Target);
GC.Collect();
//GC.WaitForFullGCComplete();
Assert.Equal(1, c.Count);
Assert.False(wr1.IsAlive);
Assert.True(wr2.IsAlive);
c.Clear();
GC.Collect();
//GC.WaitForFullGCComplete();
Assert.Equal(0, c.Count);
Assert.False(wr1.IsAlive);
Assert.False(wr2.IsAlive);
}
public static void ForEach <T>([NotNull] FastCollection <T> collection, [Pooled] Action <T> action)
{
For(0, collection.Count, i => action(collection[i]));
}
public TransformationComponentData()
{
UseTRS = true;
Scaling = Vector3.One;
Children = new FastCollection <EntityComponentReference <TransformationComponent> >();
}
public ArrayTupleStorage(int capacity)
{
_storage = new FastCollection <T>(capacity);
}
internal FastCollectionBuilderFlow([NotNull] FastCollection <TRaw> fastCollection)
{
_fastCollection = fastCollection;
}
/// <summary>
/// Initializes a new instance of the <see cref="AppSettings"/> class with a settings collection.
/// </summary>
/// <param name="settings">The settings collection.</param>
public AppSettings(IEnumerable <object> settings)
{
Settings = new FastCollection <object>(settings);
}
private static void AssertEquals<T>(FastCollection<T> collection, IEnumerable<T> enumerable)
{
var array = enumerable as T[] ?? enumerable.ToArray();
Assert.Equal(array.Length, collection.Count);
Assert.True(collection.All(e => array.Contains(e)));
}