private void NextThen() { var tid = Thread.CurrentThread.ManagedThreadId; //等待的事件成功,继续下一步 waitable.Then(() => { if (Status != WaitableStatus.Running) { return; } var fastCall = tid == Thread.CurrentThread.ManagedThreadId; var complete = waitable is ICompleteCoroutineWaitable; waitable = null; if (complete) { Enqueue(Success, fastCall); } else { Enqueue(NextStep, fastCall); } }); }
public bool TryEnqueue(T item, int timeoutMilliseconds = 0) { if (item == null) { return(false); } //The method only throws exception on thread lock timeout using (IWaitable syncLock = SyncRoot.Enter(timeoutMilliseconds) as IWaitable) { if (IsDisposing || IsDisposed) { return(false); } if (m_count == m_size) { return(false); } m_items[m_tail++] = item; // Place the new item immediately after tail, then increment tail pos m_tail %= m_size; // Modulus new tail pos with size so queue items will wrap around m_count++; // Count will never be more than size after incrementing here //Signal that an item has been enqueued to unblock waiting //dequeue threads syncLock.PulseAll(); return(true); } }
private void NextCatch() { var tid = Thread.CurrentThread.ManagedThreadId; waitable.Catch(e => { if (Status != WaitableStatus.Running) { return; } var fastCall = tid == Thread.CurrentThread.ManagedThreadId; waitable = null; if (waitable is ICompleteCoroutineWaitable) { Enqueue(() => Fail(e), fastCall); } else { //等待的事件失败,继续下一步,由调用者处理异常,coroutine本身未失败 Enqueue(NextStep, fastCall); } }); }
public bool TryDequeue(out T item, int timeoutMilliseconds = 0) { //This method only throws exception on thread lock timeout using (IWaitable syncRoot = SyncRoot.Enter(timeoutMilliseconds) as IWaitable) { if (IsDisposing || IsDisposed) { item = null; return(false); } if (m_count == 0) { item = null; return(false); } item = m_items[m_head]; // Get item at head of queue m_items[m_head++] = null; // Clear item at head of queue then increment head pos m_head %= m_size; // Modulus new head pos with size so queue items will wrap around m_count--; // Count will never be less than zero after decrementing here //Signal that an item has been dequeued to unblock waiting //enqueue threads syncRoot.PulseAll(); return(true); } }
public static IWaitable Catch(this IWaitable self, Action callback) { if (callback == null) { return(self); } return(self.Catch(e => callback())); }
public static IWaitable <T> Then <T>(this IWaitable <T> self, Action <T> callback) { Assert.NotNull(self, nameof(self)); Assert.NotNull(callback, nameof(callback)); self.Then(() => callback(self.Result)); return(self); }
public static Exception Throw(this IWaitable self) { if (self.Exception != null) { ExceptionDispatchInfo.Capture(self.Exception).Throw(); } return(null); }
public static IWaitable Finally(this IWaitable self, Action callback) { Assert.NotNull(self, nameof(self)); Assert.NotNull(callback, nameof(callback)); self.Then(callback); self.Catch(e => callback()); return(self); }
public static void WaitOnUI(this IWaitable comp, Action task) { Task.Run(() => { comp.StartWait(); task.Invoke(); comp.StopWait(); }); }
public void ClearAllCoroutines() { var list = new IWaitable[waitables.Count]; waitables.CopyTo(list); waitables.Clear(); foreach (var waitable in list) { waitable.Abort(); } }
public static IWaitable Finally(this IWaitable self, Action callback) { if (callback == null) { return(self); } self.Then(callback); self.Catch(callback); return(self); }
private void Dispatch(IWaitable waitable) { this.waitable = waitable; if (waitable is IBindCoroutineWaitable bindCoroutineWaitable) { bindCoroutineWaitable.Bind(container); } NextThen(); NextCatch(); }
public void Clear() { using (IWaitable syncLock = SyncRoot.Enter() as IWaitable) { //Unblock waiting threads syncLock.PulseAll(); m_count = 0; m_head = 0; m_tail = 0; m_items = new T[m_size]; } }
private void Dispose() { waitable = null; if (enumerator is IDisposable disposable) { disposable.Dispose(); } enumerator = null; successCallbacks = null; failCallbacks = null; }
public bool IsDone(float deltaTime) { bool isNoNeedWait = true, isMoveOver = true; var current = Enumerator.Current; if (current is IWaitable) { IWaitable waitable = current as IWaitable; isNoNeedWait = waitable.IsTickOver(deltaTime); } if (isNoNeedWait) { isMoveOver = Enumerator.MoveNext(); } return(!isMoveOver); }
public static void Throw(this IWaitable self) { Assert.NotNull(self, nameof(self)); var exception = self.Exception; var status = self.Status; if (exception != null) { ExceptionDispatchInfo.Capture(exception).Throw(); return; } if (status == WaitableStatus.Abort) { throw new WaitableAbortException(); } }
public void TestAbort2() { var i = 0; IWaitable co2 = null; var co1 = CoroutineContainer.StartCoroutine(RunFather()); Assert.AreEqual(0, i); CoroutineManager.OneLoop(); Assert.AreEqual(1, i); CoroutineManager.OneLoop(); Assert.AreEqual(2, i); CoroutineManager.OneLoop(); Assert.AreEqual(3, i); co1.Abort(); Assert.AreEqual(3, i); CoroutineManager.OneLoop(); Assert.AreEqual(3, i); Tick(); Assert.AreEqual(3, i); Assert.AreEqual(WaitableStatus.Abort, co1.Status); Assert.AreEqual(WaitableStatus.Abort, co2.Status); Assert.IsTrue(co1.IsAborted()); Assert.IsTrue(co2.IsAborted()); IEnumerable RunFather() { i++; co2 = CoroutineContainer.StartCoroutine(RunChild()); yield return(co2); i++; } IEnumerable RunChild() { while (true) { i++; yield return(null); } } }
private void NextStep() { bool moveNext; try { moveNext = enumerator.MoveNext(); } catch (Exception e) { //coroutine本身抛出异常,当前coroutine失败 Fail(e); return; } waitable = null; if (!moveNext) { Success(); return; } var current = enumerator.Current; switch (current) { case null: Enqueue(NextStep, false); break; case IEnumerable enumerable: Dispatch(container.StartCoroutine(enumerable)); break; case Task task: Dispatch(new WaitForTask(task)); break; default: Dispatch((IWaitable)current); break; } }
private void NextStep() { bool moveNext; try { moveNext = enumerator.MoveNext(); } catch (Exception e) { //coroutine本身抛出异常,当前coroutine失败 Fail(e); return; } waitable = null; if (!moveNext) { Success(default);
public void Enqueue(T item, int timeoutMilliseconds = -1) { if (item == null) { throw new ArgumentNullException("item", "item cannot be null"); } if (IsDisposing || IsDisposed) { throw new ObjectDisposedException(nameof(BoundedBlockingQueue <T>)); } using (IWaitable syncLock = SyncRoot.Enter(timeoutMilliseconds) as IWaitable) { //While the queue is full, wait for an empty space //Timeout won't be exact if multiple enqueues are blocked on a full queue //So a dequeue could be followed by a different enqueue so this will wait //for another loop while (m_count == m_size) { //Wait for a pulse from a dequeue if (!syncLock.Wait(timeoutMilliseconds)) { throw new TimeoutException("Enqueue timed out while waiting for available queue space"); } //Double check not disposed since waiting for available space if (IsDisposing || IsDisposed) { throw new ObjectDisposedException(nameof(BoundedBlockingQueue <T>)); } } m_items[m_tail++] = item; // Place the new item immediately after tail, then increment tail pos m_tail %= m_size; // Modulus new tail pos with size so queue items will wrap around m_count++; // Count will never be more than size after incrementing here //Signal that an item has been enqueued to unblock waiting //dequeue threads syncLock.PulseAll(); } }
public void Clear() { IWaitable[] list; using (spin.Hold()) { list = new IWaitable[waitables.Count]; waitables.CopyTo(list); waitables.Clear(); } foreach (var waitable in list) { try { waitable.Abort(); } catch (Exception e) { Console.Error.WriteLine(e); } } }
public T Peek(int timeoutMilliseconds = -1, bool waitForEnqueue = false) { using (IWaitable syncLock = SyncRoot.Enter(timeoutMilliseconds) as IWaitable) { if (IsDisposing || IsDisposed) { throw new ObjectDisposedException(nameof(BoundedBlockingQueue <T>)); } if (m_count == 0) { if (waitForEnqueue) { //While queue is empty, wait for an item to enqueue while (m_count == 0) { //Wait for a signal from an enqueue if (!syncLock.Wait(timeoutMilliseconds)) { throw new TimeoutException("Dequeue timed out while waiting for queue item to dequeue"); } //Double check not disposed since waiting for item to be enqueued if (IsDisposing || IsDisposed) { throw new ObjectDisposedException(nameof(BoundedBlockingQueue <T>)); } } } else { throw new InvalidOperationException("Bounded Blocking Queue is empty"); } } T value = m_items[m_head]; return(value); } }
public T Dequeue(int timeoutMilliseconds = -1) { if (IsDisposing || IsDisposed) { throw new ObjectDisposedException(nameof(BoundedBlockingQueue <T>)); } using (IWaitable syncLock = SyncRoot.Enter(timeoutMilliseconds) as IWaitable) { //Similar reasoning for here from Enqueue method //While queue is empty, wait for an item to enqueue while (m_count == 0) { //Wait for a signal from an enqueue if (!syncLock.Wait(timeoutMilliseconds)) { throw new TimeoutException("Dequeue timed out while waiting for queue item to dequeue"); } //Double check not disposed since waiting for item to be enqueued if (IsDisposing || IsDisposed) { throw new ObjectDisposedException(nameof(BoundedBlockingQueue <T>)); } } T value = m_items[m_head]; // Get item at head of queue m_items[m_head++] = null; // Clear item at head of queue then increment head pos m_head %= m_size; // Modulus new head pos with size so queue items will wrap around m_count--; // Count will never be less than zero after decrementing here //Signal that an item has been dequeued to unblock waiting //enqueue threads syncLock.PulseAll(); return(value); } }
public static void Wait(IWaitable wait, Action okCallback) { CCosmosEngine.EngineInstance.StartCoroutine(CoWaitTrue(new[] { wait }, okCallback)); }
public static bool IsCompleted(this IWaitable self) { Assert.NotNull(self, nameof(self)); return(self.Status != WaitableStatus.Running); }
private IWaitable Add(IWaitable waitable) { waitables.Add(waitable); waitable.Finally(() => waitables.Remove(waitable)); return(waitable); }
public void WaitsOn(IWaitable waitable) { WaitsOn(new List <IWaitable> { waitable }); }
public MalockTryEnterCallback(EventWaitHandle handle) { this.handle = handle; this.signal = handle.NewWaitable(); }
public static Awaiter GetAwaiter(this IWaitable waitable) { return(new Awaiter(waitable)); }
public Awaiter(IWaitable waitable) { this.waitable = waitable; }