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