public int Append(IReadOnlySeries <Variant, Variant> appendMap, AppendOption option) { if (appendMap is VariantSeries <TKey, TValue> vs) { return(MutableInner.Append(vs.Inner, option)); } throw new NotImplementedException(); }
public static TImpl Create(IReadOnlySeries <TKey, TValue> innerSeries) { if (Pool == null || !Pool.TryTake(out TImpl instance)) { instance = new TImpl(); instance._comparer = KeyComparer <TKey2> .Create(new ConvertComparer(instance)); } instance.Inner = innerSeries; return(instance); }
public static bool ClonedCursorsAreIndependent <TKey, TValue>(IReadOnlySeries <TKey, TValue> lazySeries) { var sm = lazySeries.ToSortedMap(); var mc = sm.GetCursor(); var c1 = lazySeries.GetCursor(); var c2 = c1.Clone(); while (mc.MoveNext()) { var c3 = c2.Clone(); Assert.True(c1.MoveNext()); Assert.True(c2.MoveNext()); Assert.True(c3.MoveNext()); Assert.AreEqual(c1.Current, mc.Current); Assert.AreEqual(c1.Current, c2.Current); Assert.AreEqual(c1.Current, c3.Current); c3.Dispose(); } while (mc.MovePrevious()) { var c3 = c2.Clone(); Assert.True(c1.MovePrevious()); Assert.True(c2.MovePrevious()); Assert.True(c3.MovePrevious()); Assert.AreEqual(c1.Current, mc.Current); Assert.AreEqual(c1.Current, c2.Current); Assert.AreEqual(c1.Current, c3.Current); c3.Dispose(); } if (mc.MoveLast()) { Assert.True(c1.MoveLast()); Assert.True(c2.MoveLast()); Assert.AreEqual(c1.Current, mc.Current); Assert.AreEqual(c1.Current, c2.Current); } if (mc.MoveFirst()) { Assert.True(c1.MoveFirst()); Assert.True(c2.MoveFirst()); Assert.AreEqual(c1.Current, mc.Current); Assert.AreEqual(c1.Current, c2.Current); } return(true); }
public static TImpl Create(IReadOnlySeries <TKey, TValue> innerSeries) { TImpl inner; if (!Pool.TryTake(out inner)) { inner = new TImpl(); } inner.Inner = innerSeries; return(inner); }
public static VariantSeries <TKey, TValue> Create(IReadOnlySeries <TKey, TValue> innerSeries) { VariantSeries <TKey, TValue> instance; if (_pool == null || ReferenceEquals(instance = _pool.Allocate(), null)) { instance = new VariantSeries <TKey, TValue>(innerSeries); } else { instance.Inner = innerSeries; } return(instance); }
public virtual void Dispose(bool disposing) { var disposable = Inner as IDisposable; disposable?.Dispose(); Inner = null; var pooled = Pool.TryAdd(this as TImpl); // TODO review if (disposing && !pooled) { GC.SuppressFinalize(this); } }
protected virtual void Dispose(bool disposing) { var disposable = Inner as IDisposable; disposable?.Dispose(); Inner = null; if (disposing) { // no pooling from finalizers, just don't do that if (_pool == null) { _pool = new ObjectPool <VariantSeries <TKey, TValue> >(() => null, Environment.ProcessorCount * 2); } _pool.Free(this); } }
public virtual void Dispose(bool disposing) { var disposable = Inner as IDisposable; disposable?.Dispose(); Inner = null; if (disposing) { // no pooling from finalizers, just don't do that if (Pool == null) { Pool = new BoundedConcurrentBag <TImpl>(Environment.ProcessorCount * 2); } if (!Pool.TryAdd(this as TImpl)) { // not added to the pool, let it die GC.SuppressFinalize(this); } } }
public ContractsTests(IReadOnlySeries <K, V> testSeries, SortedMap <K, V> materializedSeries, SortedMap <K, V> ephemeralSeries = null) { if (testSeries == null) { throw new ArgumentNullException(nameof(testSeries)); } if (materializedSeries == null) { throw new ArgumentNullException(nameof(materializedSeries)); } _testSeries = testSeries; _materializedSeries = materializedSeries; _ephemeralSeries = ephemeralSeries; if (ephemeralSeries != null) { var eqc = EqualityComparer <V> .Default; // TODO (UX) Spreads signature conflicts with LINQ, easy to fix but not very convenient var intersect = materializedSeries.Zip(ephemeralSeries, (l, r) => { if (!eqc.Equals(l, r)) { throw new ArgumentException("materializedSeries and ephemeralSeries contain different values for the same keys"); } else { return(l); } }); if (intersect.IsEmpty) { foreach (var kvp in materializedSeries.Take(10)) { ephemeralSeries[kvp.Key] = kvp.Value; } } } }
public int Append(IReadOnlySeries <TK, TV> appendMap, AppendOption option) { return(_innerSeries.Append(appendMap, option)); }
/// <summary> /// When lazy series is materialized to SortedMap, at each materialized key the result of lookup on the /// lazy series must match the lookup on the materialized series. /// </summary> public static bool MoveAtShouldWorkOnLazySeries <TKey, TValue>(IReadOnlySeries <TKey, TValue> lazySeries) { var materializedSeries = lazySeries.ToSortedMap(); var c = lazySeries.GetCursor(); foreach (var kvp in materializedSeries) { // EQ { Assert.True(materializedSeries.TryFind(kvp.Key, Lookup.EQ, out var materialized)); lazySeries.TryFind(kvp.Key, Lookup.EQ, out var lazy); Assert.AreEqual(materialized, lazy); Assert.True(c.MoveAt(kvp.Key, Lookup.EQ)); Assert.AreEqual(materialized, c.Current); } // LT { if (materializedSeries.TryFind(kvp.Key, Lookup.LT, out var materialized)) { Assert.True(lazySeries.TryFind(kvp.Key, Lookup.LT, out var lazy)); Assert.AreEqual(materialized, lazy); Assert.True(c.MoveAt(kvp.Key, Lookup.LT)); Assert.AreEqual(materialized, c.Current); } } // LE { if (materializedSeries.TryFind(kvp.Key, Lookup.LE, out var materialized)) { Assert.True(lazySeries.TryFind(kvp.Key, Lookup.LE, out var lazy)); Assert.AreEqual(materialized, lazy); Assert.True(c.MoveAt(kvp.Key, Lookup.LE)); Assert.AreEqual(materialized, c.Current); } } // GT { if (materializedSeries.TryFind(kvp.Key, Lookup.GT, out var materialized)) { Assert.True(lazySeries.TryFind(kvp.Key, Lookup.GT, out var lazy)); Assert.AreEqual(materialized, lazy); Assert.True(c.MoveAt(kvp.Key, Lookup.GT)); Assert.AreEqual(materialized, c.Current); } } // GE { if (materializedSeries.TryFind(kvp.Key, Lookup.GE, out var materialized)) { Assert.True(lazySeries.TryFind(kvp.Key, Lookup.GE, out var lazy)); Assert.AreEqual(materialized, lazy); Assert.True(c.MoveAt(kvp.Key, Lookup.GE)); Assert.AreEqual(materialized, c.Current); } } } return(true); }
public VariantSeries(IReadOnlySeries <TKey, TValue> inner) : base(inner) { }
protected ConvertSeries(IReadOnlySeries <TKey, TValue> inner) { Inner = inner; Comparer = new ConvertComparer(this as TImpl); }
public int Append(IReadOnlySeries <TKey2, TValue2> appendMap, AppendOption option) { // TODO using ConvertSeries throw new NotImplementedException(); }
protected ConvertSeries(IReadOnlySeries <TKey, TValue> inner) { Inner = inner; _comparer = KeyComparer <TKey2> .Create(new ConvertComparer(this as TImpl)); }
public VariantSeries(IReadOnlySeries <TKey, TValue> inner) { Inner = inner; _comparer = KeyComparer <Variant> .Create(new VariantComparer(Inner)); }
public VariantComparer(IReadOnlySeries <TKey, TValue> inner) { _sourceComparer = inner.Comparer; }