public ProgressiveList(IEnumerable <T> enumerable, IEqualityComparer <T> comparer)
: this(Progressor <T> .CreateFromIEnumerable(enumerable), new List <T>(), comparer)
{
// Empty
}
protected ProgressiveSet(Progressor <T> progressor, ISet <T> cache, IEqualityComparer <T>?comparer)
: base(progressor, cache, comparer)
{
// Empty
}
public ProgressiveLookup(IEnumerable <IGrouping <TKey, T> > enumerable)
: this(Progressor <IGrouping <TKey, T> > .CreateFromIEnumerable(enumerable), new NullAwareDictionary <TKey, IGrouping <TKey, T> >(), null, null)
{
// Empty
}
// Note: these constructors uses ExtendedSet because HashSet is not an ISet<T> in .NET 3.5 and base class needs an ISet<T>
public ProgressiveSet(IEnumerable <T> enumerable)
: this(Progressor <T> .CreateFromIEnumerable(enumerable), new HashSetEx <T>(), null)
{
// Empty
}
public ProgressiveSet(IObservable <T> observable)
: this(Progressor <T> .CreateFromIObservable(observable), new HashSetEx <T>(), null)
{
// Empty
}
public ProgressiveSet(Progressor <T> wrapped, IEqualityComparer <T> comparer)
: this(wrapped, new ExtendedSet <T>(comparer), null)
{
// Empty
}
public ProgressiveCollection(IEnumerable <T> enumerable)
: this(Progressor <T> .CreateFromIEnumerable(enumerable), new List <T>(), null)
{
// Empty
}
public ProgressiveSet(IEnumerable <T> enumerable, IEqualityComparer <T> comparer)
: this(Progressor <T> .CreateFromIEnumerable(enumerable), new ExtendedSet <T>(comparer), null)
{
// Empty
}
public ProgressiveSet(IObservable <T> observable, IEqualityComparer <T> comparer)
: this(Progressor <T> .CreateFromIObservable(observable), new ExtendedSet <T>(comparer), null)
{
// Empty
}
// Note: these constructors uses ExtendedSet because HashSet is not an ISet<T> in .NET 3.5 and base class needs an ISet<T>
public ProgressiveSet(IEnumerable <T> enumerable)
: this(Progressor <T> .CreateFromIEnumerable(enumerable), new ExtendedSet <T>(), null)
{
// Empty
}
public ProgressiveSet(IObservable <T> observable)
: this(Progressor <T> .CreateFromIObservable(observable), new ExtendedSet <T>(), null)
{
// Empty
}
internal new static ProgressiveSet <T> Create <TSet>(Progressor <T> progressor, IEqualityComparer <T> comparer)
where TSet : ISet <T>, new()
{
return(new ProgressiveSet <T>(progressor, new TSet(), comparer));
}
protected ProgressiveList(Progressor <T> progressor, IList <T> cache, IEqualityComparer <T>?comparer)
: base(progressor, cache, comparer)
{
_cache = cache;
Cache = new ReadOnlyCollectionEx <T>(_cache);
}
public ProgressiveList(IObservable <T> observable, IEqualityComparer <T> comparer)
: this(Progressor <T> .CreateFromIObservable(observable), new List <T>(), comparer)
{
// Empty
}
public ProgressiveList(Progressor <T> wrapped, IEqualityComparer <T> comparer)
: this(wrapped, new List <T>(), comparer)
{
// Empty
}
public Progressor(T[] preface, Progressor <T> wrapped)
{
if (wrapped == null)
{
throw new ArgumentNullException("wrapped");
}
if (preface == null)
{
throw new ArgumentNullException("preface");
}
var control = 0;
var guard = 0;
var index = -1;
Predicate <T> newFilter = item => Thread.VolatileRead(ref control) == 0;
var buffer = new SafeQueue <T>();
wrapped.SubscribeAction
(
item =>
{
if (newFilter(item))
{
buffer.Add(item);
}
}
);
_proxy = new ProxyObservable <T>();
TryTake <T> tryTakeReplacement = (out T value) =>
{
Interlocked.Increment(ref control);
try
{
if (buffer.TryTake(out value) || wrapped.TryTake(out value))
{
_proxy.OnNext(value);
return(true);
}
else
{
_done = wrapped._done;
return(false);
}
}
finally
{
Interlocked.Decrement(ref control);
}
};
_tryTake = (out T value) =>
{
if (Thread.VolatileRead(ref guard) == 0)
{
var currentIndex = Interlocked.Increment(ref index);
if (currentIndex < preface.Length)
{
value = preface[currentIndex];
_proxy.OnNext(value);
return(true);
}
Interlocked.CompareExchange(ref guard, 1, 0);
}
if (Interlocked.CompareExchange(ref guard, 2, 1) == 1)
{
_tryTake = tryTakeReplacement;
Thread.VolatileWrite(ref guard, 3);
}
else
{
ThreadingHelper.SpinWaitUntil(ref guard, 3);
}
var tryTake = _tryTake;
return(tryTake(out value));
};
}
public ProgressiveSet(Progressor <T> wrapped)
: this(wrapped, new ExtendedSet <T>(), null)
{
// Empty
}
public static Progressor <T> CreatedFilteredConverted <TInput>(Progressor <TInput> wrapped, Predicate <TInput> filter, Converter <TInput, T> converter)
{
if (wrapped == null)
{
throw new ArgumentNullException("wrapped");
}
if (filter == null)
{
throw new ArgumentNullException("filter");
}
if (converter == null)
{
throw new ArgumentNullException("converter");
}
var control = 0;
Predicate <TInput> newFilter = item => Thread.VolatileRead(ref control) == 0 && filter(item);
var buffer = new SafeQueue <T>();
var proxy = new ProxyObservable <T>();
var result = new Progressor <T>(
(out T value) =>
{
Interlocked.Increment(ref control);
try
{
TInput item;
again:
if (buffer.TryTake(out value))
{
proxy.OnNext(value);
return(true);
}
else if (wrapped.TryTake(out item))
{
if (filter(item))
{
value = converter(item);
proxy.OnNext(value);
return(true);
}
else
{
goto again;
}
}
value = default(T);
return(false);
}
finally
{
Interlocked.Decrement(ref control);
}
},
proxy
);
wrapped.Subscribe
(
new CustomObserver <TInput>
(
() => result._done = true,
exception => result._done = true,
item =>
{
if (newFilter(item))
{
buffer.Add(converter(item));
}
}
)
);
return(result);
}
internal static ProgressiveCollection <T> Create <TCollection>(Progressor <T> progressor, IEqualityComparer <T> comparer)
where TCollection : ICollection <T>, new()
{
return(new ProgressiveCollection <T>(progressor, new TCollection(), comparer));
}
public static Progressor <T> CreateDistinct(Progressor <T> wrapped)
{
if (wrapped == null)
{
throw new ArgumentNullException("wrapped");
}
var control = 0;
var buffer = new SafeDictionary <T, bool>();
Predicate <T> newFilter = item => Thread.VolatileRead(ref control) == 0;
var proxy = new ProxyObservable <T>();
var result = new Progressor <T>(
(out T value) =>
{
Interlocked.Increment(ref control);
try
{
again:
foreach (var item in buffer.Where(item => !item.Value))
{
value = item.Key;
buffer.Set(value, true);
proxy.OnNext(value);
return(true);
}
if (wrapped.TryTake(out value))
{
bool seen;
if (!buffer.TryGetValue(value, out seen) || !seen)
{
buffer.Set(value, true);
proxy.OnNext(value);
return(true);
}
else
{
goto again;
}
}
else
{
return(false);
}
}
finally
{
Interlocked.Decrement(ref control);
}
},
proxy
);
wrapped.Subscribe
(
new CustomObserver <T>
(
() => result._done = true,
exception => result._done = true,
item =>
{
if (newFilter(item))
{
buffer.TryAdd(item, false);
}
}
)
);
return(result);
}
public ProgressiveCollection(IObservable <T> observable)
: this(Progressor <T> .CreateFromIObservable(observable), new List <T>(), null)
{
// Empty
}
public Progressor(IEnumerable <T> preface, Progressor <T> wrapped)
{
if (wrapped == null)
{
throw new ArgumentNullException("wrapped");
}
if (preface == null)
{
throw new ArgumentNullException("preface");
}
var enumerator = preface.GetEnumerator();
if (enumerator == null)
{
throw new ArgumentException("preface.GetEnumerator()");
}
var control = 0;
var guard = 0;
Predicate <T> newFilter = item => Thread.VolatileRead(ref control) == 0;
var buffer = new SafeQueue <T>();
wrapped.SubscribeAction
(
item =>
{
if (newFilter(item))
{
buffer.Add(item);
}
}
);
_proxy = new ProxyObservable <T>();
TryTake <T> tryTakeReplacement = (out T value) =>
{
Interlocked.Increment(ref control);
try
{
if (buffer.TryTake(out value) || wrapped.TryTake(out value))
{
_proxy.OnNext(value);
return(true);
}
else
{
_done = wrapped._done;
return(false);
}
}
finally
{
Interlocked.Decrement(ref control);
}
};
_tryTake = (out T value) =>
{
value = default(T);
if (Thread.VolatileRead(ref guard) == 0)
{
bool result;
// We need a lock, there is no way around it. IEnumerator is just awful. Use another overload if possible.
lock (enumerator)
{
result = enumerator.MoveNext();
if (result)
{
value = enumerator.Current;
}
}
if (result)
{
_proxy.OnNext(value);
return(true);
}
enumerator.Dispose();
Interlocked.CompareExchange(ref guard, 1, 0);
}
if (Interlocked.CompareExchange(ref guard, 2, 1) == 1)
{
_tryTake = tryTakeReplacement;
Thread.VolatileWrite(ref guard, 3);
}
else
{
ThreadingHelper.SpinWaitUntil(ref guard, 3);
}
var tryTake = _tryTake;
return(tryTake(out value));
};
}
public ProgressiveSet(IEnumerable <T> enumerable, IEqualityComparer <T>?comparer)
: this(Progressor <T> .CreateFromIEnumerable(enumerable), new HashSetEx <T>(comparer), null)
{
// Empty
}
public ProgressiveCollection(Progressor <T> wrapped)
: this(wrapped, new HashSet <T>(), null)
{
// Empty
}
public ProgressiveSet(IObservable <T> observable, IEqualityComparer <T>?comparer)
: this(Progressor <T> .CreateFromIObservable(observable), new HashSetEx <T>(comparer), null)
{
// Empty
}
public ProgressiveCollection(Progressor <T> wrapped, IEqualityComparer <T> comparer)
: this(wrapped, new HashSet <T>(comparer), comparer)
{
// Empty
}
private EmptyList()
: base(BuildEmptyEnumerable())
{
Progressor.AsEnumerable().Consume();
}
public ProgressiveList(Progressor <T> wrapped)
: this(wrapped, new List <T>(), null)
{
// Empty
}
public ProgressiveLookup(IEnumerable <IGrouping <TKey, T> > enumerable, IEqualityComparer <TKey> keyComparer)
: this(Progressor <IGrouping <TKey, T> > .CreateFromIEnumerable(enumerable), new NullAwareDictionary <TKey, IGrouping <TKey, T> >(keyComparer), keyComparer, null)
{
// Empty
}
internal static ProgressiveLookup <TKey, T> Create <TGroupingDictionary>(Progressor <IGrouping <TKey, T> > progressor, IEqualityComparer <TKey> keyComparer, IEqualityComparer <T> itemComparer)
where TGroupingDictionary : IDictionary <TKey, IGrouping <TKey, T> >, new()
{
return(new ProgressiveLookup <TKey, T>(progressor, new TGroupingDictionary(), keyComparer, itemComparer));
}
