internal StreamQueue(Stream <T> stream)
{
stream.Subscribe(this, Handle);
_awaitable = null;
_toDeliver = new CAppendOnlyList <T>();
}
public DisposeOnOperator(Stream <T> inner, CAwaitable awaitable)
{
_inner = inner;
inner.Subscribe(this, Notify);
awaitable.GetAwaiter().OnCompleted(Dispose);
}
public static CAwaitable Yield(bool persistable = true)
{
var awaitable = new CAwaitable();
ThreadLocalScheduler.Value.Schedule(awaitable.SignalCompletion, persistable);
return(awaitable);
}
public ScheduleOnNextEventSubscription(Stream <T> stream, bool persistable)
{
_persistable = persistable;
Stream = stream;
Awaitable = new CAwaitable <T>();
Stream.Subscribe(this, HandleNextEvent);
}
public void Dispose()
{
_disposed = true;
SafeTry(() => _awaitable?.SignalThrownException(new ObjectDisposedException(nameof(StreamQueue <T>))));
_awaitable = null;
_stream?.Unsubscribe(this);
_stream = null;
}
private WaitForOperator(int count, CAwaitable <IEnumerable <T> > awaitable, Stream <T> inner, bool completed, CAppendOnlyList <T> list)
{
_count = count;
Awaitable = awaitable;
_completed = completed;
_inner = inner;
_list = list;
}
public static CAwaitable This(Func <bool> predicate, bool persistable = true)
{
var awaitable = new CAwaitable();
var wrapper = new UntilWrapper(predicate, awaitable.SignalCompletion, persistable);
Scheduler.Schedule(wrapper.TestCondition, persistable);
return(awaitable);
}
private ScheduleOnNextEventSubscription(Stream <T> stream, CAwaitable <T> awaitable, bool persistable)
{
Stream = stream;
Awaitable = awaitable;
_persistable = persistable;
_serialized = true;
}
public PersistentSleeper(DateTime expires, CAwaitable awaitable, bool rootify)
{
_expires = expires;
_awaitable = awaitable;
if (rootify)
{
Roots.EntangleAnonymously(this);
}
}
internal CAwaitable Sync(bool persistable = true)
{
var awaitable = new CAwaitable();
var action = new CAction(awaitable.SignalCompletion, persistable);
_callbacks.Add(action);
return(awaitable);
}
public WaitForOperator(int count, Stream <T> inner, TimeSpan?timeout, bool persistable)
{
_inner = inner;
_count = count;
Awaitable = new CAwaitable <IEnumerable <T> >(); //todo should the continuation be scheduled or not?
_list = new CAppendOnlyList <T>();
if (timeout != null)
{
Sleep.Until(timeout.Value, HandleTimeout, persistable);
}
_inner.Subscribe(this, Handle);
}
private void AsyncMethodTest(CAwaitable a1, CAwaitable a2, PValue <int> value)
{
async CTask Do()
{
value.Value = -1;
await a1;
value.Value = 1;
await a2;
value.Value = 2;
}
_ = Do();
}
public void AsyncVoidMethodCanBeSerialized()
{
var storage = new InMemoryStorageEngine();
var os = ObjectStore.New(storage);
var a1 = new CAwaitable();
var a2 = new CAwaitable();
var tuple = new PTuple <CAwaitable, CAwaitable>(a1, a2);
var value = new PValue <int>();
AsyncMethodTest(a1, a2, value);
os.Entangle(tuple);
os.Entangle(value);
os.Persist();
os = ObjectStore.Load(storage, true);
tuple = os.Resolve <PTuple <CAwaitable, CAwaitable> >();
value = os.Resolve <PValue <int> >();
value.Value.ShouldBe(-1);
tuple.First.SignalCompletion();
value.Value.ShouldBe(1);
os.Persist();
os = ObjectStore.Load(storage, true);
tuple = os.Resolve <PTuple <CAwaitable, CAwaitable> >();
value = os.Resolve <PValue <int> >();
value.Value.ShouldBe(1);
tuple.Second.SignalCompletion();
value.Value.ShouldBe(2);
os.Persist();
os = ObjectStore.Load(storage, true);
tuple = os.Resolve <PTuple <CAwaitable, CAwaitable> >();
value = os.Resolve <PValue <int> >();
value.Value.ShouldBe(2);
}
public void SubscriptionIsDisposedAfterAwaitableCompletes()
{
var storage = new InMemoryStorageEngine();
var os = ObjectStore.New(storage);
var source = new Source <int>();
var awaitable = new CAwaitable();
var valueHolder = new ValueHolder <int>();
source.DisposeOn(awaitable).CallOnEvent(valueHolder.SetValue);
source.Emit(1);
valueHolder.Value.ShouldBe(1);
os.Entangle(source);
os.Entangle(awaitable);
os.Entangle(valueHolder);
os.Persist();
os = ObjectStore.Load(storage, true);
source = os.Resolve <Source <int> >();
awaitable = os.Resolve <CAwaitable>();
valueHolder = os.Resolve <ValueHolder <int> >();
source.Emit(2);
valueHolder.Value.ShouldBe(2);
awaitable.SignalCompletion();
source.Emit(3);
valueHolder.Value.ShouldBe(2);
os.Persist();
os = ObjectStore.Load(storage, true);
source = os.Resolve <Source <int> >();
awaitable = os.Resolve <CAwaitable>();
valueHolder = os.Resolve <ValueHolder <int> >();
source.Emit(4);
valueHolder.Value.ShouldBe(2);
}
public static CAwaitable Until(TimeSpan delay, bool persistable = true)
{
var awaitable = new CAwaitable();
var scheduler = Engine.Current;
if (!persistable)
{
Task.Delay(delay).ContinueWith(_ => scheduler.Schedule(awaitable.SignalCompletion));
}
else
{
new PersistentSleeper(
DateTime.UtcNow + delay,
awaitable,
true
).Start();
}
return(awaitable);
}
private CallOnNextEventSubscription(Stream <T> stream, CAwaitable <T> awaitable)
{
Stream = stream;
Awaitable = awaitable;
_serialized = true;
}
public CallOnNextEventSubscription(Stream <T> stream)
{
Stream = stream;
Awaitable = new CAwaitable <T>();
Stream.Subscribe(this, HandleNextEvent);
}
private CTask(CAwaitable awaitable) => Awaitable = awaitable;
private void SignalAwaitable()
{
_awaitable.SignalCompletion(_toDeliver);
_awaitable = null;
_toDeliver = new CAppendOnlyList <T>();
}
private WaitForWorkflow(Source <int> source, CAwaitable <IEnumerable <int> > waitFor, Exception thrownException)
{
Source = source;
WaitFor = waitFor;
ThrownException = thrownException;
}
