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;
}
