/// <summary> /// Scheduled a wait for the return value, then invoke the <see cref="Call{C, T}(IFiber{C}, Rest{C, T}, T)"/> method. /// </summary> public static IWait <C> Call <C, T, R>(this IFiber <C> fiber, Rest <C, T> invokeHandler, T item, Rest <C, R> returnHandler) { // tell the leaf frame of the stack to wait for the return value var wait = fiber.Wait(returnHandler); // call the child return(fiber.Call <C, T>(invokeHandler, item)); }
public Task <Message> Process(Func <IOperationContext, Task <Message> > next, IOperationContext operation) { var lockType = LockType.Write; if (_lockConfig != null) { lockType = _lockConfig.GetLockType(operation.Message.GetType()); } return(_fiber.Call(() => next(operation), lockType)); }
public async Task <IWait> NextAsync(IFiber fiber, IItem <object> ignore) { --this.count; if (this.count >= 0) { return(fiber.Call <T, object>(this.rest, this.item, NextAsync)); } else { return(fiber.Done(this.item)); } }
public async Task <IWait <C> > NextAsync(IFiber <C> fiber, C context, IItem <object> ignore, CancellationToken token) { --this.count; if (this.count >= 0) { return(fiber.Call <C, T, object>(this.rest, this.item, NextAsync)); } else { return(fiber.Done(this.item)); } }
public async Task <IWait> LoopAsync(IFiber fiber, IItem <T> item) { this.item = await item; --this.count; if (this.count >= 0) { return(fiber.Call <T, object>(this.rest, this.item, NextAsync)); } else { return(fiber.Done(this.item)); } }
public Task <Message> Process(Func <IOperationContext, Task <Message> > next, IOperationContext context) { LockedOperationDesc handler; if (_handlerByType.TryGetValue(context.Message.GetType(), out handler)) { return(_fiber.Call(() => handler.ProcessFunc(context), handler.Lock)); } else if (next != null) { return(next(context)); } else if (_throwIfUnhandled) { throw new ProcessingException(BasicErrorCode.DispatcherFuncNotFound); } else { return(Task.FromResult <Message>(null)); } }
// TODO: split off R to get better type inference on T public static IWait<C> Call<C, T, R>(this IFiber<C> fiber, Rest<C, T> invokeHandler, T item, Rest<C, R> returnHandler) { fiber.NextWait<R>().Wait(returnHandler); return fiber.Call<C, T>(invokeHandler, item); }
public async Task <IWait> RootAsync(IFiber fiber, IItem <T> item) { return(fiber.Call <T, object>(this.rest, await item, DoneAsync)); }
public async Task <IWait <C> > RootAsync(IFiber <C> fiber, C context, IItem <T> item) { return(fiber.Call <C, T, object>(this.rest, await item, DoneAsync)); }
// TODO: split off R to get better type inference on T public static IWait Call <T, R>(this IFiber fiber, Rest <T> invokeHandler, T item, Rest <R> returnHandler) { fiber.NextWait <R>().Wait(returnHandler); return(fiber.Call <T>(invokeHandler, item)); }