Lines Matching defs:Handler
124 /// This error is returned if the remote does not have a handler installed for
484 // the handler ran.
519 // Traits class that strips the response function from the list of handler
569 // Function type of the handler.
572 // Return type of the handler.
575 // Call the given handler with the given arguments.
578 unpackAndRun(HandlerT &Handler, std::tuple<TArgTs...> &Args) {
579 return unpackAndRunHelper(Handler, Args,
583 // Call the given handler with the given arguments.
585 static Error unpackAndRunAsync(HandlerT &Handler, ResponderT &Responder,
587 return unpackAndRunAsyncHelper(Handler, Responder, Args,
591 // Call the given handler with the given arguments.
596 run(HandlerT &Handler, ArgTs &&... Args) {
597 Handler(std::move(Args)...);
605 run(HandlerT &Handler, TArgTs... Args) {
606 return Handler(std::move(Args)...);
633 unpackAndRunHelper(HandlerT &Handler, ArgTuple &Args,
635 return run(Handler, std::move(std::get<Indexes>(Args))...);
643 unpackAndRunAsyncHelper(HandlerT &Handler, ResponderT &Responder,
646 return run(Handler, Responder, std::move(std::get<Indexes>(Args))...);
650 // Handler traits for free functions.
655 // Handler traits for class methods (especially call operators for lambdas).
660 // Handler traits for const class methods (especially call operators for
666 // Utility to peel the Expected wrapper off a response handler error type.
692 // ResponseHandler represents a handler for a not-yet-received function call
701 // user-specified handler or setting a promise value.
717 ResponseHandlerImpl(HandlerT Handler) : Handler(std::move(Handler)) {}
720 // to the user defined handler.
731 return Handler(std::move(Result));
734 // Abandon this response by calling the handler with an 'abandoned response'
737 if (auto Err = Handler(this->createAbandonedResponseError())) {
744 HandlerT Handler;
752 ResponseHandlerImpl(HandlerT Handler) : Handler(std::move(Handler)) {}
755 // has completed on the remote end) by calling the user-defined handler with
760 return Handler(Error::success());
763 // Abandon this response by calling the handler with an 'abandoned response'
766 if (auto Err = Handler(this->createAbandonedResponseError())) {
773 HandlerT Handler;
780 ResponseHandlerImpl(HandlerT Handler) : Handler(std::move(Handler)) {}
783 // to the user defined handler.
795 return Handler(std::move(Result));
798 // Abandon this response by calling the handler with an 'abandoned response'
801 if (auto Err = Handler(this->createAbandonedResponseError())) {
808 HandlerT Handler;
815 ResponseHandlerImpl(HandlerT Handler) : Handler(std::move(Handler)) {}
818 // to the user defined handler.
826 return Handler(std::move(Result));
829 // Abandon this response by calling the handler with an 'abandoned response'
832 if (auto Err = Handler(this->createAbandonedResponseError())) {
839 HandlerT Handler;
842 // Create a ResponseHandler from a given user handler.
1058 // Register the negotiate function id and handler.
1072 /// The first argument specifies a user-defined handler to be run when the
1073 /// function returns. The handler should take an Expected<Func::ReturnType>,
1074 /// or an Error (if Func::ReturnType is void). The handler will be called
1077 Error appendCallAsync(HandlerT Handler, const ArgTs &... Args) {
1089 // Negotiation failed. Notify the handler then return the negotiate-failed
1091 cantFail(Handler(make_error<ResponseAbandoned>()));
1105 // Install the user handler.
1108 std::move(Handler));
1136 Error callAsync(HandlerT Handler, const ArgTs &... Args) {
1137 if (auto Err = appendCallAsync<Func>(std::move(Handler), Args...))
1156 // else: No handler found. Report error to client?
1197 /// Remove the handler for the given function.
1198 /// A handler must currently be registered for this function.
1203 "Function does not have a registered handler");
1206 "Function does not have a registered handler");
1221 /// Add the given handler to the handler map and make it available for
1224 void addHandlerImpl(HandlerT Handler) {
1233 Handlers[NewFnId] = wrapHandler<Func>(std::move(Handler));
1237 void addAsyncHandlerImpl(HandlerT Handler) {
1248 Handlers[NewFnId] = wrapAsyncHandler<Func>(std::move(Handler));
1252 using Handler = typename decltype(PendingResponses)::mapped_type;
1253 Handler PRHandler;
1274 "If we didn't find a response handler we should have bailed out");
1328 // Wrap the given user handler in the necessary argument-deserialization code,
1331 WrappedHandlerFn wrapHandler(HandlerT Handler) {
1332 return [this, Handler](ChannelT &Channel,
1357 HTraits::unpackAndRun(Handler, *Args));
1361 // Wrap the given user handler in the necessary argument-deserialization code,
1364 WrappedHandlerFn wrapAsyncHandler(HandlerT Handler) {
1365 return [this, Handler](ChannelT &Channel,
1396 return HTraits::unpackAndRunAsync(Handler, Responder, *Args);
1436 /// Add a handler
1437 /// This installs the given handler functor for the given RPC Function, and
1440 void addHandler(HandlerT Handler) {
1441 return this->template addHandlerImpl<Func>(std::move(Handler));
1444 /// Add a class-method as a handler.
1452 void addAsyncHandler(HandlerT Handler) {
1453 return this->template addAsyncHandlerImpl<Func>(std::move(Handler));
1456 /// Add a class-method as a handler.
1481 // FIXME: Stack allocate and move this into the handler once LLVM builds
1555 void addHandler(HandlerT Handler) {
1556 return this->template addHandlerImpl<Func>(std::move(Handler));
1566 void addAsyncHandler(HandlerT Handler) {
1567 return this->template addAsyncHandlerImpl<Func>(std::move(Handler));
1570 /// Add a class-method as a handler.
1586 // point) so that it can be overwritten in the async handler.
1620 Error operator()(HandlerT Handler, const ArgTs &... Args) const {
1621 return Endpoint.template appendCallAsync<Func>(std::move(Handler), Args...);
1645 Error call(const AsyncDispatcher &AsyncDispatch, HandlerT Handler,
1648 // we invoke the call, as the handler may (depending on scheduling)
1650 // in the wrapped handler below to run before the increment.
1656 // Wrap the user handler in a lambda that will decrement the
1660 // FIXME: Move handler into wrapped handler once we have C++14.
1661 auto WrappedHandler = [this, Handler](ArgType Arg) {
1662 auto Err = Handler(std::move(Arg));
