agrpc::BasicClientUnaryReactor< Executor > Class Template Reference

(experimental) I/O object for client-side, unary rpcs More...

#include <agrpc/client_callback.hpp>

Inheritance diagram for agrpc::BasicClientUnaryReactor< Executor >:

Collaboration diagram for agrpc::BasicClientUnaryReactor< Executor >:

Classes
struct	rebind_executor
	Rebind the BasicClientUnaryReactor to another executor. More...

Public Types
using	executor_type = Executor
	The executor type.

Public Member Functions
template<class StubAsync , class Request , class Response >
void	start (detail::AsyncUnaryReactorFn< StubAsync, Request, Response > fn, StubAsync *stub, const Request &request, Response &response)
	Start a codegen-ed rpc.
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
auto	wait_for_initial_metadata (CompletionToken &&token=CompletionToken{})
	Wait for initial metadata.
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
auto	wait_for_finish (CompletionToken &&token=CompletionToken{})
	Wait for finish.
const Executor &	get_executor () const noexcept
	Get the executor.
grpc::ClientContext &	context () noexcept
	Get the underlying grpc::ClientContext
const grpc::ClientContext &	context () const noexcept
	Get the underlying grpc::ClientContext (const overload)

Detailed Description

template<class Executor>
class agrpc::BasicClientUnaryReactor< Executor >

(experimental) I/O object for client-side, unary rpcs

Create an object of this type using agrpc::make_reactor/agrpc::allocate_reactor. This class should only be used if the unary rpc wants to receive initial metadata without waiting for the server's response message.

Example:

void unary(asio::io_context& io_context, example::v1::Example::Stub& stub, const example::v1::Request& request)
{
    auto ptr = agrpc::make_reactor<agrpc::ClientUnaryReactor>(io_context.get_executor());
    auto& rpc = *ptr;
    auto response = std::make_unique<example::v1::Response>();
    rpc.start(&example::v1::Example::Stub::async::Unary, stub.async(), request, *response);
    rpc.wait_for_initial_metadata(
        [ptr = std::move(ptr), response = std::move(response)](const error_code&, bool ok) mutable
        {
            if (!ok)
            {
                return;
            }
            // Utilize the server's initial metadata:
            //   ptr->context().GetServerInitialMetadata()
            ptr->wait_for_finish(
                [response = std::move(response)](const error_code&, const grpc::Status& status)
                {
                    if (!status.ok())
                    {
                        // ...
                    }
                });
        });
}

Based on .proto file:

syntax = "proto3";
 
package example.v1;
 
service Example {
  rpc ServerStreaming(Request) returns (stream Response) {}
 
  rpc ClientStreaming(stream Request) returns (Response) {}
 
  rpc BidirectionalStreaming(stream Request) returns (stream Response) {}
 
  rpc Unary(Request) returns (Response) {}
}
 
message Request {
  int32 integer = 1;
}
 
message Response {
  int32 integer = 1;
}

Template Parameters

Executor

The executor type.

Per-Operation Cancellation

All. Cancellation will merely interrupt the act of waiting and does not cancel the underlying rpc.

Since

3.5.0

Member Function Documentation

start()

template<class Executor >

template<class StubAsync , class Request , class Response >

void agrpc::BasicClientUnaryReactor< Executor >::start ( detail::AsyncUnaryReactorFn< StubAsync, Request, Response > fn, StubAsync * stub, const Request & request, Response & response )

inline

Start a codegen-ed rpc.

The response object must remain valid until the rpc is finished. May only be called once.

• fn Pointer to the protoc generated Stub::async::Method.

wait_for_initial_metadata()

template<class Executor >

template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>>

auto agrpc::BasicClientUnaryReactor< Executor >::wait_for_initial_metadata ( CompletionToken && token = CompletionToken{} )

inline

Wait for initial metadata.

Only one wait for initial metadata may be outstanding at any time.

Completion signature is void(error_code, bool). If the bool is false then the rpc failed (cancelled, disconnected, deadline reached, ...).

wait_for_finish()

template<class Executor >

template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>>

auto agrpc::BasicClientUnaryReactor< Executor >::wait_for_finish ( CompletionToken && token = CompletionToken{} )

inline

Wait for finish.

Wait until all operations associated with this rpc have completed. Only one wait for finish may be outstanding at any time.

Completion signature is void(error_code, grpc::Status). Once this operation completes the response passed to start() will have been be populated if grpc::Status::ok() is true.

get_executor()

template<class Executor >

const Executor & agrpc::detail::ReactorExecutorBase< Executor >::get_executor ( ) const

inlinenodiscardnoexceptinherited

Get the executor.

Thread-safe