diff --git a/docs/.nojekyll b/docs/.nojekyll new file mode 100644 index 00000000..e69de29b diff --git a/docs/annotated.html b/docs/annotated.html new file mode 100644 index 00000000..dd91fa32 --- /dev/null +++ b/docs/annotated.html @@ -0,0 +1,173 @@ + + + +
+ + + + +
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
▼Nagrpc | Public namespace |
▼Ndetail | |
CClientRPCBase | ServerRPC base |
CClientRPCBidiStreamingBase< ResponderT< RequestT, ResponseT >, Executor > | Bidirectional-streaming ClientRPC base |
CClientRPCContextBase | ClientRPC grpc::ClientContext base |
▼CClientRPCServerStreamingBase< PrepareAsyncServerStreaming, Executor > | Server-streaming ClientRPC base |
Crebind_executor | Rebind the ClientRPC to another executor |
▼CClientRPCUnaryBase< PrepareAsyncUnary, Executor > | Unary ClientRPC base |
Crebind_executor | Rebind the ClientRPC to another executor |
CNotifyOnStateChangeFn | Function to set notification for a grpc::Channel state change |
CReadFn | Server/ClientRPC.read in form of a function object |
CRPCExecutorBase | RPC's executor base |
CServerRPCBase | ServerRPC base |
CServerRPCBidiStreamingBase< ResponderT< ResponseT, RequestT >, TraitsT, Executor > | ServerRPC bidirectional-streaming base |
CServerRPCContextBase | ServerRPC ServerContext base |
CServerRPCNotifyWhenDoneMixin | ServerRPC NotifyWhenDone base |
CBasicAlarm | I/O object for grpc::Alarm |
CBasicGrpcExecutor | GrpcContext's executor |
CClientRPC | Primary ClientRPC template |
▼CClientRPC< agrpc::ClientRPCType::GENERIC_STREAMING, Executor > | I/O object for client-side, generic, streaming rpcs |
Crebind_executor | Rebind the ClientRPC to another executor |
▼CClientRPC< agrpc::ClientRPCType::GENERIC_UNARY, Executor > | I/O object for client-side, generic, unary rpcs |
Crebind_executor | Rebind the ClientRPC to another executor |
▼CClientRPC< PrepareAsyncBidiStreaming, Executor > | I/O object for client-side, bidirectional-streaming rpcs |
Crebind_executor | Rebind the ClientRPC to another executor |
▼CClientRPC< PrepareAsyncClientStreaming, Executor > | I/O object for client-side, client-streaming rpcs |
Crebind_executor | Rebind the ClientRPC to another executor |
CClientRPC< PrepareAsyncServerStreaming, Executor > | I/O object for client-side, server-streaming rpcs |
CClientRPC< PrepareAsyncUnary, Executor > | I/O object for client-side, unary rpcs |
CDefaultRunTraits | (experimental) Default run traits |
CDefaultServerRPCTraits | Default ServerRPC traits |
CGrpcContext | Execution context based on grpc::CompletionQueue |
CHealthCheckService | CompletionQueue-based implementation of grpc::HealthCheckServiceInterface |
CServerRPC | Primary ServerRPC template |
▼CServerRPC< agrpc::ServerRPCType::GENERIC, TraitsT, Executor > | I/O object for server-side, generic rpcs |
Crebind_executor | Rebind the ServerRPC to another executor |
▼CServerRPC< RequestBidiStreaming, TraitsT, Executor > | I/O object for server-side, bidirectional-streaming rpcs |
Crebind_executor | Rebind the ServerRPC to another executor |
▼CServerRPC< RequestClientStreaming, TraitsT, Executor > | I/O object for server-side, client-streaming rpcs |
Crebind_executor | Rebind the ServerRPC to another executor |
▼CServerRPC< RequestServerStreaming, TraitsT, Executor > | I/O object for server-side, server-streaming rpcs |
Crebind_executor | Rebind the ServerRPC to another executor |
▼CServerRPC< RequestUnary, TraitsT, Executor > | I/O object for server-side, unary rpcs |
Crebind_executor | Rebind the ServerRPC to another executor |
CServerRPCPtr | Allocated ServerRPC created by register_callback_rpc_handler |
CUseSender | Sender completion token |
▼CWaiter | (experimental) Utility class for uncancelable operations |
Crebind_executor | Rebind the Waiter to another executor |
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
This is the complete list of members for agrpc::BasicAlarm< Executor >, including all inherited members.
+BasicAlarm(const Executor &executor) | agrpc::BasicAlarm< Executor > | inlineexplicit |
BasicAlarm(agrpc::GrpcContext &grpc_context) | agrpc::BasicAlarm< Executor > | inlineexplicit |
cancel() | agrpc::BasicAlarm< Executor > | inline |
executor_type typedef | agrpc::BasicAlarm< Executor > | |
get_executor() const noexcept | agrpc::BasicAlarm< Executor > | inline |
get_scheduler() const noexcept | agrpc::BasicAlarm< Executor > | inline |
wait(const Deadline &deadline, CompletionToken &&token=CompletionToken{}) & | agrpc::BasicAlarm< Executor > | inline |
wait(const Deadline &deadline, CompletionToken &&token=CompletionToken{}) && | agrpc::BasicAlarm< Executor > | inline |
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
I/O object for grpc::Alarm
+ More...
#include <agrpc/alarm.hpp>
+Public Types | |
+using | executor_type = Executor |
The executor type. | |
+Public Member Functions | |
+ | BasicAlarm (const Executor &executor) |
Construct a BasicAlarm from an executor. | |
+ | BasicAlarm (agrpc::GrpcContext &grpc_context) |
Construct a BasicAlarm from a GrpcContext. | |
template<class Deadline , class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | wait (const Deadline &deadline, CompletionToken &&token=CompletionToken{}) & |
Wait until a specified deadline has been reached (lvalue overload) | |
template<class Deadline , class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | wait (const Deadline &deadline, CompletionToken &&token=CompletionToken{}) && |
Wait until a specified deadline has been reached (rvalue overload) | |
void | cancel () |
Cancel an outstanding wait. | |
const executor_type & | get_executor () const noexcept |
Get the executor. | |
const executor_type & | get_scheduler () const noexcept |
Get the scheduler. | |
I/O object for grpc::Alarm
Wraps a grpc::Alarm as an I/O object.
+Executor | The executor type, must be capable of referring to a GrpcContext. |
Per-Operation Cancellation
+All. Effectively calls grpc::Alarm::Cancel which will cause the operation to complete with false
.
+
|
+ +inline | +
Wait until a specified deadline has been reached (lvalue overload)
+The operation finishes once the alarm expires (at deadline) or is cancelled. If the alarm expired, the result will be true, false otherwise (i.e. upon cancellation).
+Example:
+deadline | By default gRPC supports two types of deadlines: gpr_timespec and std::chrono::system_clock::time_point . More types can be added by specializing grpc::TimePoint. |
token | A completion token like asio::yield_context or the one created by agrpc::use_sender . The completion signature is void(bool) . true if it expired, false if it was canceled. |
+
|
+ +inline | +
Wait until a specified deadline has been reached (rvalue overload)
+Extends the lifetime of the Alarm until the end of the wait. Otherwise, equivalent to the lvalue overload.
+Example:
+token | A completion token like asio::yield_context or the one created by agrpc::use_sender . The completion signature is void(bool, BasicAlarm) . true if it expired, false if it was canceled. |
+
|
+ +inline | +
Cancel an outstanding wait.
+The outstanding wait will complete with false
if the Alarm did not fire yet, otherwise this function has no effect.
Thread-safe
+ +
+
|
+ +inlinenodiscardnoexcept | +
Get the executor.
+Thread-safe
+ +
+
|
+ +inlinenodiscardnoexcept | +
Get the scheduler.
+Thread-safe
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
This is the complete list of members for agrpc::BasicGrpcExecutor< Allocator, Options >, including all inherited members.
+allocator_type typedef | agrpc::BasicGrpcExecutor< Allocator, Options > | |
BasicGrpcExecutor()=default | agrpc::BasicGrpcExecutor< Allocator, Options > | |
context() const noexcept | agrpc::BasicGrpcExecutor< Allocator, Options > | inline |
defer(Function &&function, const OtherAllocator &other_allocator) const | agrpc::BasicGrpcExecutor< Allocator, Options > | inline |
dispatch(Function &&function, const OtherAllocator &other_allocator) const | agrpc::BasicGrpcExecutor< Allocator, Options > | inline |
execute(Function &&function) const | agrpc::BasicGrpcExecutor< Allocator, Options > | inline |
get_allocator() const noexcept | agrpc::BasicGrpcExecutor< Allocator, Options > | inline |
on_work_finished() const noexcept | agrpc::BasicGrpcExecutor< Allocator, Options > | inline |
on_work_started() const noexcept | agrpc::BasicGrpcExecutor< Allocator, Options > | inline |
operator!=(const BasicGrpcExecutor &lhs, const agrpc::BasicGrpcExecutor< Allocator, OtherOptions > &rhs) noexcept | agrpc::BasicGrpcExecutor< Allocator, Options > | friend |
operator==(const BasicGrpcExecutor &lhs, const agrpc::BasicGrpcExecutor< Allocator, OtherOptions > &rhs) noexcept | agrpc::BasicGrpcExecutor< Allocator, Options > | friend |
post(Function &&function, const OtherAllocator &other_allocator) const | agrpc::BasicGrpcExecutor< Allocator, Options > | inline |
prefer(asio::execution::relationship_t::fork_t) const noexcept | agrpc::BasicGrpcExecutor< Allocator, Options > | inline |
prefer(asio::execution::relationship_t::continuation_t) const noexcept | agrpc::BasicGrpcExecutor< Allocator, Options > | inline |
query(asio::execution::blocking_t) noexcept | agrpc::BasicGrpcExecutor< Allocator, Options > | inlinestatic |
query(asio::execution::mapping_t) noexcept | agrpc::BasicGrpcExecutor< Allocator, Options > | inlinestatic |
query(asio::execution::context_t) const noexcept | agrpc::BasicGrpcExecutor< Allocator, Options > | inline |
query(asio::execution::relationship_t) noexcept | agrpc::BasicGrpcExecutor< Allocator, Options > | inlinestatic |
query(asio::execution::outstanding_work_t) noexcept | agrpc::BasicGrpcExecutor< Allocator, Options > | inlinestatic |
query(asio::execution::allocator_t< OtherAllocator >) const noexcept | agrpc::BasicGrpcExecutor< Allocator, Options > | inline |
require(asio::execution::blocking_t::possibly_t) const noexcept -> agrpc::BasicGrpcExecutor< Allocator, detail::set_blocking_never(Options, false)> | agrpc::BasicGrpcExecutor< Allocator, Options > | inline |
require(asio::execution::blocking_t::never_t) const noexcept -> agrpc::BasicGrpcExecutor< Allocator, detail::set_blocking_never(Options, true)> | agrpc::BasicGrpcExecutor< Allocator, Options > | inline |
require(asio::execution::outstanding_work_t::tracked_t) const noexcept -> agrpc::BasicGrpcExecutor< Allocator, detail::set_outstanding_work_tracked(Options, true)> | agrpc::BasicGrpcExecutor< Allocator, Options > | inline |
require(asio::execution::outstanding_work_t::untracked_t) const noexcept -> agrpc::BasicGrpcExecutor< Allocator, detail::set_outstanding_work_tracked(Options, false)> | agrpc::BasicGrpcExecutor< Allocator, Options > | inline |
require(asio::execution::allocator_t< OtherAllocator > other_allocator) const noexcept -> agrpc::BasicGrpcExecutor< OtherAllocator, Options > | agrpc::BasicGrpcExecutor< Allocator, Options > | inline |
require(asio::execution::allocator_t< void >) const noexcept -> agrpc::BasicGrpcExecutor< std::allocator< void >, Options > | agrpc::BasicGrpcExecutor< Allocator, Options > | inline |
running_in_this_thread() const noexcept | agrpc::BasicGrpcExecutor< Allocator, Options > | inline |
schedule() const noexcept | agrpc::BasicGrpcExecutor< Allocator, Options > | inline |
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
GrpcContext's executor. + More...
+ +#include <agrpc/grpc_executor.hpp>
+Public Types | |
+using | allocator_type = Allocator |
The associated allocator type. | |
+Public Member Functions | |
BasicGrpcExecutor ()=default | |
Default construct an executor. | |
constexpr agrpc::GrpcContext & | context () const noexcept |
Get the underlying GrpcContext. | |
constexpr allocator_type | get_allocator () const noexcept |
Get the associated allocator. | |
bool | running_in_this_thread () const noexcept |
Determine whether the GrpcContext is running in the current thread. | |
void | on_work_started () const noexcept |
Signal the GrpcContext that an asynchronous operation is in progress. | |
void | on_work_finished () const noexcept |
Signal the GrpcContext that an asynchronous operation has completed. | |
template<class Function , class OtherAllocator > | |
void | dispatch (Function &&function, const OtherAllocator &other_allocator) const |
Request the GrpcContext to invoke the given function object. | |
template<class Function , class OtherAllocator > | |
void | post (Function &&function, const OtherAllocator &other_allocator) const |
Request the GrpcContext to invoke the given function object. | |
template<class Function , class OtherAllocator > | |
void | defer (Function &&function, const OtherAllocator &other_allocator) const |
Request the GrpcContext to invoke the given function object. | |
template<class Function > | |
void | execute (Function &&function) const |
Request the GrpcContext to invoke the given function object. | |
detail::ScheduleSender | schedule () const noexcept |
Create a Sender that completes on the GrpcContext. | |
constexpr auto | require (asio::execution::blocking_t::possibly_t) const noexcept -> agrpc::BasicGrpcExecutor< Allocator, detail::set_blocking_never(Options, false)> |
Obtain an executor with the blocking.possibly property. | |
constexpr auto | require (asio::execution::blocking_t::never_t) const noexcept -> agrpc::BasicGrpcExecutor< Allocator, detail::set_blocking_never(Options, true)> |
Obtain an executor with the blocking.never property. | |
constexpr auto | prefer (asio::execution::relationship_t::fork_t) const noexcept |
Obtain an executor with the relationship.fork property. | |
constexpr auto | prefer (asio::execution::relationship_t::continuation_t) const noexcept |
Obtain an executor with the relationship.continuation property. | |
constexpr auto | require (asio::execution::outstanding_work_t::tracked_t) const noexcept -> agrpc::BasicGrpcExecutor< Allocator, detail::set_outstanding_work_tracked(Options, true)> |
Obtain an executor with the outstanding_work.tracked property. | |
constexpr auto | require (asio::execution::outstanding_work_t::untracked_t) const noexcept -> agrpc::BasicGrpcExecutor< Allocator, detail::set_outstanding_work_tracked(Options, false)> |
Obtain an executor with the outstanding_work.untracked property. | |
template<class OtherAllocator > | |
constexpr auto | require (asio::execution::allocator_t< OtherAllocator > other_allocator) const noexcept -> agrpc::BasicGrpcExecutor< OtherAllocator, Options > |
Obtain an executor with the specified allocator property. | |
constexpr auto | require (asio::execution::allocator_t< void >) const noexcept -> agrpc::BasicGrpcExecutor< std::allocator< void >, Options > |
Obtain an executor with the default allocator property. | |
constexpr agrpc::GrpcContext & | query (asio::execution::context_t) const noexcept |
Query the current value of the context property. | |
template<class OtherAllocator > | |
constexpr allocator_type | query (asio::execution::allocator_t< OtherAllocator >) const noexcept |
Query the current value of the allocator property. | |
+Static Public Member Functions | |
static constexpr auto | query (asio::execution::blocking_t) noexcept |
Query the current value of the blocking property. | |
static constexpr detail::QueryStaticMapping::result_type | query (asio::execution::mapping_t) noexcept |
Query the current value of the mapping property. | |
static constexpr detail::QueryStaticRelationship::result_type | query (asio::execution::relationship_t) noexcept |
Query the current value of the relationship property. | |
static constexpr auto | query (asio::execution::outstanding_work_t) noexcept |
Query the current value of the outstanding_work property. | |
+Friends | |
template<std::uint32_t OtherOptions> | |
constexpr bool | operator== (const BasicGrpcExecutor &lhs, const agrpc::BasicGrpcExecutor< Allocator, OtherOptions > &rhs) noexcept |
Compare two GrpcExecutor for equality. | |
template<std::uint32_t OtherOptions> | |
constexpr bool | operator!= (const BasicGrpcExecutor &lhs, const agrpc::BasicGrpcExecutor< Allocator, OtherOptions > &rhs) noexcept |
Compare two GrpcExecutor for inequality. | |
GrpcContext's executor.
+A lightweight handle to a GrpcContext. Trivially copyable if it is not tracking outstanding work.
+Satisfies the Executor and Networking TS and Scheduler requirements and can therefore be used in places where Asio/libunifex expects an Executor
or Scheduler
.
+
|
+ +default | +
Default construct an executor.
+The constructed object may not be used until it is assigned a valid executor, for example through GrpcContext::get_executor
.
+
|
+ +inlinenodiscardconstexprnoexcept | +
Get the underlying GrpcContext.
+Thread-safe
+Since 1.6.0 this function is hidden when (BOOST_)ASIO_NO_TS_EXECUTORS
is defined.
+
|
+ +inlinenodiscardconstexprnoexcept | +
Get the associated allocator.
+Thread-safe
+ +
+
|
+ +inlinenodiscardnoexcept | +
Determine whether the GrpcContext is running in the current thread.
+Thread-safe
+ +
+
|
+ +inlinenoexcept | +
Signal the GrpcContext that an asynchronous operation is in progress.
+Thread-safe
+Since 1.6.0 this function is hidden when (BOOST_)ASIO_NO_TS_EXECUTORS
is defined.
+
|
+ +inlinenoexcept | +
Signal the GrpcContext that an asynchronous operation has completed.
+Once all outstanding asynchronous operations have completed the GrpcContext will go into the stopped state.
+Thread-safe
+Since 1.6.0 this function is hidden when (BOOST_)ASIO_NO_TS_EXECUTORS
is defined.
+
|
+ +inline | +
Request the GrpcContext to invoke the given function object.
+Do not call this function directly, it is intended to be used by the asio::dispatch free function.
+Thread-safe
+Since 1.6.0 this function is hidden when (BOOST_)ASIO_NO_TS_EXECUTORS
is defined.
+
|
+ +inline | +
Request the GrpcContext to invoke the given function object.
+Do not call this function directly, it is intended to be used by the asio::post free function.
+Thread-safe
+Since 1.6.0 this function is hidden when (BOOST_)ASIO_NO_TS_EXECUTORS
is defined.
+
|
+ +inline | +
Request the GrpcContext to invoke the given function object.
+Do not call this function directly, it is intended to be used by the asio::defer free function.
+Thread-safe
+Since 1.6.0 this function is hidden when (BOOST_)ASIO_NO_TS_EXECUTORS
is defined.
+
|
+ +inline | +
Request the GrpcContext to invoke the given function object.
+Thread-safe
+ +
+
|
+ +inlinenodiscardnoexcept | +
Create a Sender that completes on the GrpcContext.
+Do not call this function directly. It is intended to be used by the unifex::schedule customisation point.
+Thread-safe
+ +
+
|
+ +inlinenodiscardconstexprnoexcept | +
Obtain an executor with the blocking.possibly property.
+Do not call this function directly. It is intended to be used by the asio::require customisation point.
+Thread-safe
+ +
+
|
+ +inlinenodiscardconstexprnoexcept | +
Obtain an executor with the blocking.never property.
+Do not call this function directly. It is intended to be used by the asio::require customisation point.
+Thread-safe
+ +
+
|
+ +inlinenodiscardconstexprnoexcept | +
Obtain an executor with the relationship.fork property.
+The GrpcExecutor always forks.
+Do not call this function directly. It is intended to be used by the asio::prefer customisation point.
+Thread-safe
+ +
+
|
+ +inlinenodiscardconstexprnoexcept | +
Obtain an executor with the relationship.continuation property.
+The GrpcExecutor does not support continuation.
+Do not call this function directly. It is intended to be used by the asio::prefer customisation point.
+Thread-safe
+ +
+
|
+ +inlinenodiscardconstexprnoexcept | +
Obtain an executor with the outstanding_work.tracked property.
+Do not call this function directly. It is intended to be used by the asio::require customisation point.
+Thread-safe
+ +
+
|
+ +inlinenodiscardconstexprnoexcept | +
Obtain an executor with the outstanding_work.untracked property.
+Do not call this function directly. It is intended to be used by the asio::require customisation point.
+Thread-safe
+ +
+
|
+ +inlinenodiscardconstexprnoexcept | +
Obtain an executor with the specified allocator property.
+Do not call this function directly. It is intended to be used by the asio::require customisation point.
+Thread-safe
+ +
+
|
+ +inlinenodiscardconstexprnoexcept | +
Obtain an executor with the default allocator property.
+Do not call this function directly. It is intended to be used by the asio::require customisation point.
+Thread-safe
+ +
+
|
+ +inlinestaticnodiscardconstexprnoexcept | +
Query the current value of the blocking property.
+Do not call this function directly. It is intended to be used by the asio::query customisation point.
+Thread-safe
+ +
+
|
+ +inlinestaticnodiscardconstexprnoexcept | +
Query the current value of the mapping property.
+Do not call this function directly. It is intended to be used by the asio::query customisation point.
+Thread-safe
+ +
+
|
+ +inlinenodiscardconstexprnoexcept | +
Query the current value of the context property.
+Do not call this function directly. It is intended to be used by the asio::query customisation point.
+Thread-safe
+ +
+
|
+ +inlinestaticnodiscardconstexprnoexcept | +
Query the current value of the relationship property.
+Do not call this function directly. It is intended to be used by the asio::query customisation point.
+Thread-safe
+ +
+
|
+ +inlinestaticnodiscardconstexprnoexcept | +
Query the current value of the outstanding_work property.
+Do not call this function directly. It is intended to be used by the asio::query customisation point.
+Thread-safe
+ +
+
|
+ +inlinenodiscardconstexprnoexcept | +
Query the current value of the allocator property.
+Do not call this function directly. It is intended to be used by the asio::query customisation point.
+Thread-safe
+ +
+
|
+ +friend | +
Compare two GrpcExecutor for equality.
+Returns true if the two executors can be interchanged with identical effects.
+Thread-safe
+ +
+
|
+ +friend | +
Compare two GrpcExecutor for inequality.
+Returns true if interchanging the two executors may not lead to identical effects.
+Thread-safe
+ +
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
Primary ClientRPC template. + More...
+Primary ClientRPC template.
+This is the main entrypoint for implementing asynchronous gRPC clients.
+agrpc::ClientRPC<PrepareAsyncUnary,Executor>
agrpc::ClientRPC<agrpc::ClientRPCType::GENERIC_UNARY,Executor>
agrpc::ClientRPC<PrepareAsyncClientStreaming,Executor>
agrpc::ClientRPC<PrepareAsyncServerStreaming,Executor>
agrpc::ClientRPC<PrepareAsyncBidiStreaming,Executor>
agrpc::ClientRPC<agrpc::ClientRPCType::GENERIC_STREAMING,Executor>
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
This is the complete list of members for agrpc::ClientRPC< PrepareAsyncBidiStreaming, Executor >, including all inherited members.
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
I/O object for client-side, bidirectional-streaming rpcs. + More...
+ +#include <agrpc/client_rpc.hpp>
+Classes | |
struct | rebind_executor |
Rebind the ClientRPC to another executor. More... | |
+Public Member Functions | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | start (StubT &stub, CompletionToken &&token=CompletionToken{}) |
Start a bidirectional-streaming request. | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | read_initial_metadata (CompletionToken &&token=CompletionToken{}) |
Read initial metadata. | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | read (ResponseT &response, CompletionToken &&token=CompletionToken{}) |
Receive a message from the server. | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | write (const RequestT &request, grpc::WriteOptions options, CompletionToken &&token=CompletionToken{}) |
Send a message to the server. | |
+template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | write (const RequestT &request, CompletionToken &&token=CompletionToken{}) |
Send a message to the server (default WriteOptions) | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | writes_done (CompletionToken &&token=CompletionToken{}) |
Signal writes done to the server. | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | finish (CompletionToken &&token=CompletionToken{}) |
Signal writes done and finish the rpc. | |
const executor_type & | get_executor () const noexcept |
Get the executor. | |
const executor_type & | get_scheduler () const noexcept |
Get the scheduler. | |
+grpc::ClientContext & | context () |
Get the underlying grpc::ClientContext | |
+const grpc::ClientContext & | context () const |
Get the underlying grpc::ClientContext (const overload) | |
void | cancel () noexcept |
Cancel this RPC. | |
+Static Public Member Functions | |
static constexpr std::string_view | service_name () noexcept |
Name of the gRPC service. | |
static constexpr std::string_view | method_name () noexcept |
Name of the gRPC method. | |
+Static Public Attributes | |
+static constexpr agrpc::ClientRPCType | TYPE = agrpc::ClientRPCType::BIDIRECTIONAL_STREAMING |
The rpc type. | |
I/O object for client-side, bidirectional-streaming rpcs.
+Example:
+Based on .proto
file:
PrepareAsyncBidiStreaming | A pointer to the generated, async version of the gRPC method. The async version starts with PrepareAsync . |
Executor | The executor type, must be capable of referring to a GrpcContext. |
Per-Operation Cancellation
+Terminal and partial. Cancellation is performed by invoking grpc::ClientContext::TryCancel. After successful cancellation no further operations may be started on the rpc (except finish()). Operations are also cancelled when the deadline of the rpc has been reached (see grpc::ClientContext::set_deadline).
+
+
|
+ +inlinestaticconstexprnoexcept | +
Name of the gRPC service.
+Equal to the generated Service::service_full_name()
.
E.g. for the .proto
schema
the return value would be "example.v1.Example"
.
+
|
+ +inlinestaticconstexprnoexcept | +
Name of the gRPC method.
+E.g. for agrpc::ClientRPC<&example::Example::Stub::PrepareAsyncMyMethod>
the return value would be "MyMethod"
.
+
|
+ +inline | +
Start a bidirectional-streaming request.
+stub | The Stub that corresponds to the gRPC method. |
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true means that the rpc was started successfully. If it is false , then call finish() to obtain error details. |
+
|
+ +inlineinherited | +
Read initial metadata.
+Request notification of the reading of the initial metadata.
+This call is optional.
+Side effect:
+write()
is called.token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true indicates that the metadata was read. If it is false , then the call is dead. |
+
|
+ +inlineinherited | +
Receive a message from the server.
+This is thread-safe with respect to write()
or writes_done()
methods. It should not be called concurrently with other operations. It is not meaningful to call it concurrently with another read on the same stream since reads on the same stream are delivered in order.
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true indicates that a valid message was read. false when there will be no more incoming messages, either because the other server is finished sending messages or the stream has failed (or been cancelled). |
+
|
+ +inlineinherited | +
Send a message to the server.
+Only one write may be outstanding at any given time. This is thread-safe with respect to read()
. It should not be called concurrently with other operations.
request | The request message, save to delete when this function returns, unless a deferred completion token is used like agrpc::use_sender or asio::deferred . |
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true means that the data is going to go to the wire. If it is false , it is not going to the wire because the call is already dead (i.e., canceled, deadline expired, other side dropped the channel, etc). |
+
|
+ +inlineinherited | +
Signal writes done to the server.
+May only be called once. Should not be called after performing a write with the set_last_message option.
+Signal the client is done with the writes (half-close the client stream). Thread-safe with respect to read. May not be called concurrently with a write()
that has the set_last_message option set.
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true means that the data is going to go to the wire. If it is false , it is not going to the wire because the call is already dead (i.e., canceled, deadline expired, other side dropped the channel, etc). |
+
|
+ +inlineinherited | +
Signal writes done and finish the rpc.
+Indicate that the stream is to be finished and request notification for when the call has been ended.
+May not be used concurrently with other operations and may only be called once.
+It is appropriate to call this method when:
+false
).The operation will finish when either:
+Note that implementations of this method attempt to receive initial metadata from the server if initial metadata has not been received yet.
+Side effect:
+token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(grpc::Status) . |
+
|
+ +inlinenodiscardnoexceptinherited | +
Get the executor.
+Thread-safe
+ +
+
|
+ +inlinenodiscardnoexceptinherited | +
Get the scheduler.
+Thread-safe
+
+
|
+ +inlinenoexceptinherited | +
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
This is the complete list of members for agrpc::ClientRPC< PrepareAsyncClientStreaming, Executor >, including all inherited members.
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
I/O object for client-side, client-streaming rpcs. + More...
+ +#include <agrpc/client_rpc.hpp>
+Classes | |
struct | rebind_executor |
Rebind the ClientRPC to another executor. More... | |
+Public Member Functions | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | start (StubT &stub, ResponseT &response, CompletionToken &&token=CompletionToken{}) |
Start a client-streaming request. | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | read_initial_metadata (CompletionToken &&token=CompletionToken{}) |
Read initial metadata. | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | write (const RequestT &request, grpc::WriteOptions options, CompletionToken &&token=CompletionToken{}) |
Send a message to the server. | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | write (const RequestT &request, CompletionToken &&token=CompletionToken{}) |
Send a message to the server. | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | finish (CompletionToken &&token=CompletionToken{}) |
Finish the rpc. | |
const executor_type & | get_executor () const noexcept |
Get the executor. | |
const executor_type & | get_scheduler () const noexcept |
Get the scheduler. | |
+grpc::ClientContext & | context () |
Get the underlying grpc::ClientContext | |
+const grpc::ClientContext & | context () const |
Get the underlying grpc::ClientContext (const overload) | |
void | cancel () noexcept |
Cancel this RPC. | |
+Static Public Member Functions | |
static constexpr std::string_view | service_name () noexcept |
Name of the gRPC service. | |
static constexpr std::string_view | method_name () noexcept |
Name of the gRPC method. | |
+Static Public Attributes | |
+static constexpr agrpc::ClientRPCType | TYPE = agrpc::ClientRPCType::CLIENT_STREAMING |
The rpc type. | |
I/O object for client-side, client-streaming rpcs.
+Example:
+Based on .proto
file:
PrepareAsyncClientStreaming | A pointer to the generated, async version of the gRPC method. The async version starts with PrepareAsync . |
Executor | The executor type, must be capable of referring to a GrpcContext. |
Per-Operation Cancellation
+Terminal and partial. Cancellation is performed by invoking grpc::ClientContext::TryCancel. After successful cancellation no further operations may be started on the rpc (except finish()). Operations are also cancelled when the deadline of the rpc has been reached (see grpc::ClientContext::set_deadline).
+
+
|
+ +inlinestaticconstexprnoexcept | +
Name of the gRPC service.
+Equal to the generated Service::service_full_name()
.
E.g. for the .proto
schema
the return value would be "example.v1.Example"
.
+
|
+ +inlinestaticconstexprnoexcept | +
Name of the gRPC method.
+E.g. for agrpc::ClientRPC<&example::Example::Stub::PrepareAsyncMyMethod>
the return value would be "MyMethod"
.
+
|
+ +inline | +
Start a client-streaming request.
+stub | The Stub that corresponds to the gRPC method. |
response | The response message, will be filled by the server upon finishing this rpc. Must remain alive until this rpc is finished. |
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true means that the rpc was started successfully. If it is false , then call finish() to obtain error details. |
+
|
+ +inline | +
Read initial metadata.
+Request notification of the reading of the initial metadata.
+This call is optional.
+Side effect:
+write()
is called.token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true indicates that the metadata was read. If it is false , then the call is dead. |
+
|
+ +inline | +
Send a message to the server.
+WriteOptions options is used to set the write options of this message, otherwise identical to: write(request, token)
.
+
|
+ +inline | +
Send a message to the server.
+Only one write may be outstanding at any given time. May not be called concurrently with read_initial_metadata()
.
request | The request message, save to delete when this function returns, unless a deferred completion token is used like agrpc::use_sender or asio::deferred . |
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true means that the data is going to go to the wire. If it is false , it is not going to the wire because the call is already dead (i.e., canceled, deadline expired, other side dropped the channel, etc). |
+
|
+ +inline | +
Finish the rpc.
+Indicate that the stream is to be finished and request notification for when the call has been ended.
+May not be used concurrently with other operations and may only be called once.
+The operation will finish when either:
+Note that implementations of this method attempt to receive initial metadata from the server if initial metadata has not been received yet.
+Side effect:
+start()
.token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(grpc::Status) . |
+
|
+ +inlinenodiscardnoexceptinherited | +
Get the executor.
+Thread-safe
+ +
+
|
+ +inlinenodiscardnoexceptinherited | +
Get the scheduler.
+Thread-safe
+
+
|
+ +inlinenoexceptinherited | +
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
This is the complete list of members for agrpc::ClientRPC< PrepareAsyncServerStreaming, Executor >, including all inherited members.
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
I/O object for client-side, server-streaming rpcs. + More...
+ +#include <agrpc/client_rpc.hpp>
+Public Member Functions | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | start (StubT &stub, const RequestT &request, CompletionToken &&token=CompletionToken{}) |
Start a server-streaming request. | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | read (ResponseT &response, CompletionToken &&token=CompletionToken{}) |
Receive a message from the server. | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | finish (CompletionToken &&token=CompletionToken{}) |
Finish the rpc. | |
auto | read_initial_metadata (CompletionToken &&token=detail::DefaultCompletionTokenT< Executor >{}) |
Read initial metadata. | |
const executor_type & | get_executor () const noexcept |
Get the executor. | |
const executor_type & | get_scheduler () const noexcept |
Get the scheduler. | |
+grpc::ClientContext & | context () |
Get the underlying grpc::ClientContext | |
+const grpc::ClientContext & | context () const |
Get the underlying grpc::ClientContext (const overload) | |
void | cancel () noexcept |
Cancel this RPC. | |
+Static Public Member Functions | |
static constexpr std::string_view | service_name () noexcept |
Name of the gRPC service. | |
static constexpr std::string_view | method_name () noexcept |
Name of the gRPC method. | |
+Static Public Attributes | |
+static constexpr agrpc::ClientRPCType | TYPE = agrpc::ClientRPCType::SERVER_STREAMING |
The rpc type. | |
I/O object for client-side, server-streaming rpcs.
+Example:
+Based on .proto
file:
PrepareAsyncServerStreaming | A pointer to the generated, async version of the gRPC method. The async version starts with PrepareAsync . |
Executor | The executor type, must be capable of referring to a GrpcContext. |
Per-Operation Cancellation
+Terminal and partial. Cancellation is performed by invoking grpc::ClientContext::TryCancel. After successful cancellation no further operations may be started on the rpc (except finish()). Operations are also cancelled when the deadline of the rpc has been reached (see grpc::ClientContext::set_deadline).
+
+
|
+ +inlinestaticconstexprnoexceptinherited | +
Name of the gRPC service.
+Equal to the generated Service::service_full_name()
.
E.g. for the .proto
schema
the return value would be "example.v1.Example"
.
+
|
+ +inlinestaticconstexprnoexceptinherited | +
Name of the gRPC method.
+E.g. for agrpc::ClientRPC<&example::Example::Stub::PrepareAsyncMyMethod>
the return value would be "MyMethod"
.
+
|
+ +inlineinherited | +
Start a server-streaming request.
+stub | The Stub that corresponds to the gRPC method. |
request | The request message, save to delete when this function returns, unless a deferred completion token is used like agrpc::use_sender or asio::deferred . |
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true means that the rpc was started successfully. If it is false , then call finish() to obtain error details. |
+
|
+ +inlineinherited | +
Receive a message from the server.
+May not be called concurrently with read_initial_metadata()
. It is not meaningful to call it concurrently with another read on the same stream since reads on the same stream are delivered in order.
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true indicates that a valid message was read. false when there will be no more incoming messages, either because the other server is finished sending messages or the stream has failed (or been cancelled). |
+
|
+ +inlineinherited | +
Finish the rpc.
+Indicate that the stream is to be finished and request notification for when the call has been ended.
+May not be used concurrently with other operations and may only be called once.
+It is appropriate to call this method when:
+false
).The operation will finish when either:
+Note that implementations of this method attempt to receive initial metadata from the server if initial metadata has not been received yet.
+Side effect:
+token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(grpc::Status) . |
+
|
+ +inlineinherited | +
Read initial metadata.
+Request notification of the reading of the initial metadata.
+This call is optional.
+Side effect:
+token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true indicates that the metadata was read. If it is false , then the call is dead. |
+
|
+ +inlinenodiscardnoexceptinherited | +
Get the executor.
+Thread-safe
+ +
+
|
+ +inlinenodiscardnoexceptinherited | +
Get the scheduler.
+Thread-safe
+
+
|
+ +inlinenoexceptinherited | +
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
This is the complete list of members for agrpc::ClientRPC< PrepareAsyncUnary, Executor >, including all inherited members.
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
I/O object for client-side, unary rpcs. + More...
+ +#include <agrpc/client_rpc.hpp>
+Public Member Functions | |
void | start (StubT &stub, const RequestT &req) |
Start the rpc. | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | finish (ResponseT &response, CompletionToken &&token=CompletionToken{}) |
Finish the rpc. | |
auto | read_initial_metadata (CompletionToken &&token=detail::DefaultCompletionTokenT< Executor >{}) |
Read initial metadata. | |
const executor_type & | get_executor () const noexcept |
Get the executor. | |
const executor_type & | get_scheduler () const noexcept |
Get the scheduler. | |
+grpc::ClientContext & | context () |
Get the underlying grpc::ClientContext | |
+const grpc::ClientContext & | context () const |
Get the underlying grpc::ClientContext (const overload) | |
void | cancel () noexcept |
Cancel this RPC. | |
+Static Public Member Functions | |
static constexpr std::string_view | service_name () noexcept |
Name of the gRPC service. | |
static constexpr std::string_view | method_name () noexcept |
Name of the gRPC method. | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
static auto | request (agrpc::GrpcContext &grpc_context, StubT &stub, grpc::ClientContext &context, const RequestT &request, ResponseT &response, CompletionToken &&token=CompletionToken{}) |
Perform a request. | |
+template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
static auto | request (const Executor &executor, StubT &stub, grpc::ClientContext &context, const RequestT &request, ResponseT &response, CompletionToken &&token=CompletionToken{}) |
Start a generic unary request (executor overload) | |
+Static Public Attributes | |
+static constexpr agrpc::ClientRPCType | TYPE = agrpc::ClientRPCType::UNARY |
The rpc type. | |
I/O object for client-side, unary rpcs.
+Example:
+Alternative version that waits the server's initial metadata first:
+Based on .proto
file:
PrepareAsyncUnary | A pointer to the generated, async version of the gRPC method. The async version starts with PrepareAsync . |
Executor | The executor type, must be capable of referring to a GrpcContext. |
Per-Operation Cancellation
+Terminal and partial. Cancellation is performed by invoking grpc::ClientContext::TryCancel. Operations are also cancelled when the deadline of the rpc has been reached (see grpc::ClientContext::set_deadline).
+
+
|
+ +inlinestaticconstexprnoexceptinherited | +
Name of the gRPC service.
+Equal to the generated Service::service_full_name()
.
E.g. for the .proto
schema
the return value would be "example.v1.Example"
.
+
|
+ +inlinestaticconstexprnoexceptinherited | +
Name of the gRPC method.
+E.g. for agrpc::ClientRPC<&example::Example::Stub::PrepareAsyncMyMethod>
the return value would be "MyMethod"
.
+
|
+ +inlinestaticinherited | +
Perform a request.
+request | The request message, save to delete when this function returns, unless a deferred completion token is used like agrpc::use_sender or asio::deferred . |
response | The response message, will be filled by the server upon finishing this rpc. Must remain alive until this rpc is finished. |
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(grpc::Status) . Use grpc::Status::ok() to check whether the request was successful. |
+
|
+ +inlineinherited | +
Start the rpc.
+req | The request message, save to delete when this function returns, unless a deferred completion token like agrpc::use_sender or asio::deferred is used. |
+
|
+ +inlineinherited | +
Finish the rpc.
+Receive the server's response message and final status for the call.
+This operation will finish when either:
+Side effect:
+token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(grpc::Status) . |
+
|
+ +inlineinherited | +
Read initial metadata.
+Request notification of the reading of the initial metadata.
+This call is optional.
+Side effect:
+token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true indicates that the metadata was read. If it is false , then the call is dead. |
+
|
+ +inlinenodiscardnoexceptinherited | +
Get the executor.
+Thread-safe
+ +
+
|
+ +inlinenodiscardnoexceptinherited | +
Get the scheduler.
+Thread-safe
+
+
|
+ +inlinenoexceptinherited | +
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
This is the complete list of members for agrpc::ClientRPC< agrpc::ClientRPCType::GENERIC_STREAMING, Executor >, including all inherited members.
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
I/O object for client-side, generic, streaming rpcs. + More...
+ +#include <agrpc/client_rpc.hpp>
+Classes | |
struct | rebind_executor |
Rebind the ClientRPC to another executor. More... | |
+Public Member Functions | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | start (const std::string &method, grpc::GenericStub &stub, CompletionToken &&token=CompletionToken{}) |
Start a generic streaming request. | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | read_initial_metadata (CompletionToken &&token=CompletionToken{}) |
Read initial metadata. | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | read (ResponseT &response, CompletionToken &&token=CompletionToken{}) |
Receive a message from the server. | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | write (const RequestT &request, grpc::WriteOptions options, CompletionToken &&token=CompletionToken{}) |
Send a message to the server. | |
+template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | write (const RequestT &request, CompletionToken &&token=CompletionToken{}) |
Send a message to the server (default WriteOptions) | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | writes_done (CompletionToken &&token=CompletionToken{}) |
Signal writes done to the server. | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | finish (CompletionToken &&token=CompletionToken{}) |
Signal writes done and finish the rpc. | |
const executor_type & | get_executor () const noexcept |
Get the executor. | |
const executor_type & | get_scheduler () const noexcept |
Get the scheduler. | |
+grpc::ClientContext & | context () |
Get the underlying grpc::ClientContext | |
+const grpc::ClientContext & | context () const |
Get the underlying grpc::ClientContext (const overload) | |
void | cancel () noexcept |
Cancel this RPC. | |
+Static Public Attributes | |
+static constexpr agrpc::ClientRPCType | TYPE = agrpc::ClientRPCType::GENERIC_STREAMING |
The rpc type. | |
I/O object for client-side, generic, streaming rpcs.
+Executor | The executor type, must be capable of referring to a GrpcContext. |
Per-Operation Cancellation
+Terminal and partial. Cancellation is performed by invoking grpc::ClientContext::TryCancel. After successful cancellation no further operations may be started on the rpc (except finish()). Operations are also cancelled when the deadline of the rpc has been reached (see grpc::ClientContext::set_deadline).
+
+
|
+ +inline | +
Start a generic streaming request.
+token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true means that the rpc was started successfully. If it is false , then call finish() to obtain error details. |
+
|
+ +inlineinherited | +
Read initial metadata.
+Request notification of the reading of the initial metadata.
+This call is optional.
+Side effect:
+write()
is called.token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true indicates that the metadata was read. If it is false , then the call is dead. |
+
|
+ +inlineinherited | +
Receive a message from the server.
+This is thread-safe with respect to write()
or writes_done()
methods. It should not be called concurrently with other operations. It is not meaningful to call it concurrently with another read on the same stream since reads on the same stream are delivered in order.
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true indicates that a valid message was read. false when there will be no more incoming messages, either because the other server is finished sending messages or the stream has failed (or been cancelled). |
+
|
+ +inlineinherited | +
Send a message to the server.
+Only one write may be outstanding at any given time. This is thread-safe with respect to read()
. It should not be called concurrently with other operations.
request | The request message, save to delete when this function returns, unless a deferred completion token is used like agrpc::use_sender or asio::deferred . |
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true means that the data is going to go to the wire. If it is false , it is not going to the wire because the call is already dead (i.e., canceled, deadline expired, other side dropped the channel, etc). |
+
|
+ +inlineinherited | +
Signal writes done to the server.
+May only be called once. Should not be called after performing a write with the set_last_message option.
+Signal the client is done with the writes (half-close the client stream). Thread-safe with respect to read. May not be called concurrently with a write()
that has the set_last_message option set.
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true means that the data is going to go to the wire. If it is false , it is not going to the wire because the call is already dead (i.e., canceled, deadline expired, other side dropped the channel, etc). |
+
|
+ +inlineinherited | +
Signal writes done and finish the rpc.
+Indicate that the stream is to be finished and request notification for when the call has been ended.
+May not be used concurrently with other operations and may only be called once.
+It is appropriate to call this method when:
+false
).The operation will finish when either:
+Note that implementations of this method attempt to receive initial metadata from the server if initial metadata has not been received yet.
+Side effect:
+token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(grpc::Status) . |
+
|
+ +inlinenodiscardnoexceptinherited | +
Get the executor.
+Thread-safe
+ +
+
|
+ +inlinenodiscardnoexceptinherited | +
Get the scheduler.
+Thread-safe
+
+
|
+ +inlinenoexceptinherited | +
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
This is the complete list of members for agrpc::ClientRPC< agrpc::ClientRPCType::GENERIC_UNARY, Executor >, including all inherited members.
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
I/O object for client-side, generic, unary rpcs. + More...
+ +#include <agrpc/client_rpc.hpp>
+Classes | |
struct | rebind_executor |
Rebind the ClientRPC to another executor. More... | |
+Public Member Functions | |
void | start (const std::string &method, grpc::GenericStub &stub, const grpc::ByteBuffer &req) |
Start the rpc. | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | finish (grpc::ByteBuffer &response, CompletionToken &&token=CompletionToken{}) |
Finish the rpc. | |
auto | read_initial_metadata (CompletionToken &&token=detail::DefaultCompletionTokenT< Executor >{}) |
Read initial metadata. | |
const executor_type & | get_executor () const noexcept |
Get the executor. | |
const executor_type & | get_scheduler () const noexcept |
Get the scheduler. | |
+grpc::ClientContext & | context () |
Get the underlying grpc::ClientContext | |
+const grpc::ClientContext & | context () const |
Get the underlying grpc::ClientContext (const overload) | |
void | cancel () noexcept |
Cancel this RPC. | |
+Static Public Member Functions | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
static auto | request (agrpc::GrpcContext &grpc_context, const std::string &method, grpc::GenericStub &stub, grpc::ClientContext &context, const grpc::ByteBuffer &request, grpc::ByteBuffer &response, CompletionToken &&token=CompletionToken{}) |
Start a generic unary request. | |
+template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
static auto | request (const Executor &executor, const std::string &method, grpc::GenericStub &stub, grpc::ClientContext &context, const grpc::ByteBuffer &request, grpc::ByteBuffer &response, CompletionToken &&token=CompletionToken{}) |
Start a generic unary request (executor overload) | |
+Static Public Attributes | |
+static constexpr agrpc::ClientRPCType | TYPE = agrpc::ClientRPCType::GENERIC_UNARY |
The rpc type. | |
I/O object for client-side, generic, unary rpcs.
+Example:
+Based on .proto
file:
Executor | The executor type, must be capable of referring to a GrpcContext. |
Per-Operation Cancellation
+Terminal and partial. Cancellation is performed by invoking grpc::ClientContext::TryCancel. Operations are also cancelled when the deadline of the rpc has been reached (see grpc::ClientContext::set_deadline).
+
+
|
+ +inlinestatic | +
Start a generic unary request.
+method | The gRPC method to call, e.g. "/test.v1.Test/Unary" |
request | The request message, save to delete when this function returns, unless a deferred completion token is used like agrpc::use_sender or asio::deferred . |
response | The response message, will be filled by the server upon finishing this rpc. Must remain alive until this rpc is finished. |
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(grpc::Status) . Use grpc::Status::ok() to check whether the request was successful. |
+
|
+ +inline | +
Start the rpc.
+req | The request message, save to delete when this function returns, unless a deferred completion token like agrpc::use_sender or asio::deferred is used. |
method | The RPC method to call, e.g. "/test.v1.Test/Unary" |
+
|
+ +inline | +
Finish the rpc.
+Receive the server's response message and final status for the call.
+This operation will finish when either:
+Side effect:
+token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(grpc::Status) . |
+
|
+ +inlineinherited | +
Read initial metadata.
+Request notification of the reading of the initial metadata.
+This call is optional.
+Side effect:
+token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true indicates that the metadata was read. If it is false , then the call is dead. |
+
|
+ +inlinenodiscardnoexceptinherited | +
Get the executor.
+Thread-safe
+ +
+
|
+ +inlinenodiscardnoexceptinherited | +
Get the scheduler.
+Thread-safe
+
+
|
+ +inlinenoexceptinherited | +
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
This is the complete list of members for agrpc::GrpcContext, including all inherited members.
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
Execution context based on grpc::CompletionQueue
+ More...
#include <agrpc/grpc_context.hpp>
+Public Types | |
+using | executor_type = agrpc::BasicGrpcExecutor<> |
The associated executor type. | |
+using | allocator_type = detail::GrpcContextLocalAllocator |
The associated allocator type. | |
+Public Member Functions | |
GrpcContext () | |
Construct a GrpcContext for gRPC clients. | |
GrpcContext (std::size_t concurrency_hint) | |
Construct a GrpcContext for multi-threaded gRPC clients. | |
GrpcContext (std::unique_ptr< grpc::ServerCompletionQueue > completion_queue) | |
Construct a GrpcContext for gRPC servers. | |
GrpcContext (std::unique_ptr< grpc::ServerCompletionQueue > completion_queue, std::size_t concurrency_hint) | |
Construct a GrpcContext for multi-threaded gRPC servers. | |
~GrpcContext () | |
Destruct the GrpcContext. | |
bool | run () |
Run ready completion handlers and grpc::CompletionQueue | |
template<class Deadline > | |
bool | run_until (const Deadline &deadline) |
Run ready completion handlers and grpc::CompletionQueue until deadline. | |
template<class Condition > | |
bool | run_while (Condition &&condition) |
Run ready completion handlers and grpc::CompletionQueue while a condition holds. | |
bool | run_completion_queue () |
Run the grpc::CompletionQueue | |
bool | poll () |
Poll ready completion handlers and grpc::CompletionQueue | |
bool | poll_completion_queue () |
Poll the grpc::CompletionQueue | |
void | stop () |
Signal the GrpcContext to stop. | |
void | reset () noexcept |
Bring a stopped GrpcContext back into the ready state. | |
bool | is_stopped () const noexcept |
Is the GrpcContext in the stopped state? | |
executor_type | get_executor () noexcept |
Get the associated executor. | |
executor_type | get_scheduler () noexcept |
Get the associated scheduler. | |
allocator_type | get_allocator () noexcept |
Get the associated allocator. | |
void | work_started () noexcept |
Signal that work has started. | |
void | work_finished () noexcept |
Signal that work has finished. | |
grpc::CompletionQueue * | get_completion_queue () noexcept |
Get the underlying grpc::CompletionQueue | |
grpc::ServerCompletionQueue * | get_server_completion_queue () noexcept |
Get the underlying grpc::CompletionQueue | |
Execution context based on grpc::CompletionQueue
Satisfies the ExecutionContext requirements and can therefore be used in all places where Asio expects an ExecutionContext
.
Performance recommendation: Use exactly one GrpcContext per thread.
+
+
|
+ +inline | +
Construct a GrpcContext for gRPC clients.
+
+
|
+ +inlineexplicit | +
Construct a GrpcContext for multi-threaded gRPC clients.
+
+
|
+ +inlineexplicit | +
Construct a GrpcContext for gRPC servers.
+The resulting GrpcContext can also be used for clients.
+Example:
+
+
|
+ +inline | +
Construct a GrpcContext for multi-threaded gRPC servers.
+The resulting GrpcContext can also be used for clients.
+Example:
+
+
|
+ +inline | +
Destruct the GrpcContext.
+Calls Shutdown() on the grpc::CompletionQueue
and drains it. Pending completion handlers will not be invoked.
+
|
+ +inline | +
Run ready completion handlers and grpc::CompletionQueue
Runs the main event loop logic until the GrpcContext runs out of work or is stopped. The GrpcContext will be brought into the ready state when this function is invoked. Upon return, the GrpcContext will be in the stopped state.
+concurrency_hint
greater than one. Even then it may not be called concurrently with run_completion_queue() or poll_completion_queue() (since 3.2.0)].
+
|
+ +inline | +
Run ready completion handlers and grpc::CompletionQueue
until deadline.
Runs the main event loop logic until the GrpcContext runs out of work, is stopped or the specified deadline has been reached. The GrpcContext will be brought into the ready state when this function is invoked.
+concurrency_hint
greater than one. Even then it may not be called concurrently with run_completion_queue() or poll_completion_queue() (since 3.2.0)].Deadline | A type that is compatible with grpc::TimePoint<Deadline> . |
+
|
+ +inline | +
Run ready completion handlers and grpc::CompletionQueue
while a condition holds.
Runs the main event loop logic until the GrpcContext runs out of work, is stopped or the specified condition returns false. The GrpcContext will be brought into the ready state when this function is invoked.
+concurrency_hint
greater than one. Even then it may not be called concurrently with run_completion_queue() or poll_completion_queue() (since 3.2.0)].Condition | A callable that returns false when the GrpcContext should stop. |
+
|
+ +inline | +
Run the grpc::CompletionQueue
Runs the main event loop logic until the GrpcContext runs out of work or is stopped. Only events from the grpc::CompletionQueue
will be handled. That means that completion handler that were e.g. created using asio::post(grpc_context, ...)
will not be processed. The GrpcContext will be brought into the ready state when this function is invoked. Upon return, the GrpcContext will be in the stopped state.
concurrency_hint
greater than one. Even then it may not be called concurrently with run, run_until, run_while and poll (since 3.2.0)].
+
|
+ +inline | +
Poll ready completion handlers and grpc::CompletionQueue
Processes all ready completion handlers and ready events of the grpc::CompletionQueue
. The GrpcContext will be brought into the ready state when this function is invoked.
concurrency_hint
greater than one. Even then it may not be called concurrently with run_completion_queue() or poll_completion_queue() (since 3.2.0)].
+
|
+ +inline | +
Poll the grpc::CompletionQueue
Processes only ready events of the grpc::CompletionQueue
. That means that completion handler that were e.g. created using asio::post(grpc_context, ...)
will not be processed. The GrpcContext will be brought into the ready state when this function is invoked.
concurrency_hint
greater than one. Even then it may not be called concurrently with run, run_until, run_while and poll (since 3.2.0)].
+
|
+ +inline | +
Signal the GrpcContext to stop.
+Causes a call to run() to return as soon as possible.
+Thread-safe with regards to other functions except the destructor.
+ +
+
|
+ +inlinenoexcept | +
Bring a stopped GrpcContext back into the ready state.
+When a call to run() or stop() returns, the GrpcContext will be in a stopped state. This function brings the GrpcContext back into the ready state.
+Thread-safe with regards to other functions except the destructor.
+ +
+
|
+ +inlinenodiscardnoexcept | +
Is the GrpcContext in the stopped state?
+Thread-safe
+ +
+
|
+ +inlinenodiscardnoexcept | +
Get the associated executor.
+Thread-safe
+ +
+
|
+ +inlinenodiscardnoexcept | +
Get the associated scheduler.
+Thread-safe
+ +
+
|
+ +inlinenodiscardnoexcept | +
Get the associated allocator.
+Thread-safe
+ +
+
|
+ +inlinenoexcept | +
Signal that work has started.
+The GrpcContext maintains an internal counter on how many operations have been started. Once that counter reaches zero it will go into the stopped state. Every call to work_started() should be matched to a call of work_finished().
+Thread-safe
+ +
+
|
+ +inlinenoexcept | +
Signal that work has finished.
+Thread-safe
+ +
+
|
+ +inlinenodiscardnoexcept | +
Get the underlying grpc::CompletionQueue
Do not use any functions of the returned CompletionQueue that might interfere with the GrpcContext, like Next().
+Do not delete the returned pointer.
+Thread-safe, never nullptr
+ +
+
|
+ +inlinenodiscardnoexcept | +
Get the underlying grpc::CompletionQueue
Do not use any functions of the returned CompletionQueue that might interfere with the GrpcContext, like Next().
+Do not delete the returned pointer.
+Thread-safe, never nullptr
+ +
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
This is the complete list of members for agrpc::HealthCheckService, including all inherited members.
+add_health_check_service(grpc::ServerBuilder &builder) | agrpc::HealthCheckService | related |
SetServingStatus(const std::string &service_name, bool serving) | agrpc::HealthCheckService | inline |
SetServingStatus(bool serving) | agrpc::HealthCheckService | inline |
Shutdown() | agrpc::HealthCheckService | inline |
start_health_check_service(agrpc::HealthCheckService &service, agrpc::GrpcContext &grpc_context) | agrpc::HealthCheckService | related |
start_health_check_service(grpc::Server &server, agrpc::GrpcContext &grpc_context) | agrpc::HealthCheckService | related |
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
CompletionQueue-based implementation of grpc::HealthCheckServiceInterface. + More...
+ +#include <agrpc/health_check_service.hpp>
+Public Member Functions | |
void | SetServingStatus (const std::string &service_name, bool serving) |
Set or change the serving status of the given service_name. | |
void | SetServingStatus (bool serving) |
Apply a serving status to all registered service names. | |
void | Shutdown () |
Set all registered service names to not serving and prevent future state changes. | |
+Related Symbols | |
(Note that these are not member symbols.) + | |
grpc::ServerBuilder & | add_health_check_service (grpc::ServerBuilder &builder) |
Add a HealthCheckService to a grpc::Server | |
void | start_health_check_service (agrpc::HealthCheckService &service, agrpc::GrpcContext &grpc_context) |
Start a previously added HealthCheckService. | |
void | start_health_check_service (grpc::Server &server, agrpc::GrpcContext &grpc_context) |
Start a previously added HealthCheckService (grpc::Server overload) | |
CompletionQueue-based implementation of grpc::HealthCheckServiceInterface.
+This class is a drop-in replacement for the grpc::DefaultHealthCheckService
. It should be added to a grpc::ServerBuilder
using add_health_check_service()
.
Motivation: grpc::DefaultHealthCheckService
is implemented in terms of gRPC's generic callback API. Mixing callback services and CompletionQueue-based services in one grpc::Server
significantly degrades performance.
__has_include
then you must also include health.grpc.pb.h
before including agrpc/health_check_service.hpp
.
+
|
+ +inline | +
Set or change the serving status of the given service_name.
+Thread-safe
+ +
+
|
+ +inline | +
Apply a serving status to all registered service names.
+Thread-safe
+ +
+
|
+ +inline | +
Set all registered service names to not serving and prevent future state changes.
+Thread-safe
+ +
+
|
+ +related | +
Add a HealthCheckService to a grpc::Server
Must be called before grpc::ServerBuilder.BuildAndStart()
and the service must be started using start_health_check_service()
afterwards. May only be called once for a given ServerBuilder.
Example:
+
+
|
+ +related | +
Start a previously added HealthCheckService.
+Must be called after grpc::ServerBuilder.BuildAndStart()
. The service must have been added using add_health_check_service()
. May only be called once for a given HealthCheckService.
Does not contribute to the work tracking of the GrpcContext.
+GrpcContext::run/poll
. May not be used with a multi-threaded GrpcContext.GrpcContext::run/poll_completion_queue
then none of the member functions of the service may be used.
+
|
+ +related | +
Start a previously added HealthCheckService (grpc::Server
overload)
The service must have been added using add_health_check_service()
. May only be called once for a given HealthCheckService.
Effectively performs:
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
Primary ServerRPC template. + More...
+Primary ServerRPC template.
+This is the main entrypoint for implementing asynchronous gRPC servers.
+agrpc::ServerRPC<RequestUnary,TraitsT,Executor>
agrpc::ServerRPC<RequestClientStreaming,TraitsT,Executor>
agrpc::ServerRPC<RequestServerStreaming,TraitsT,Executor>
agrpc::ServerRPC<RequestBidiStreaming,TraitsT,Executor>
agrpc::ServerRPC<agrpc::ServerRPCType::GENERIC,TraitsT,Executor>
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
This is the complete list of members for agrpc::ServerRPC< RequestBidiStreaming, TraitsT, Executor >, including all inherited members.
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
I/O object for server-side, bidirectional-streaming rpcs. + More...
+ +#include <agrpc/server_rpc.hpp>
+Classes | |
struct | rebind_executor |
Rebind the ServerRPC to another executor. More... | |
+Public Types | |
+using | Ptr = agrpc::ServerRPCPtr<ServerRPC> |
ServerRPCPtr specialized on this type. | |
+using | Request = RequestT |
The response message type. | |
+using | Response = ResponseT |
The request message type. | |
+using | Traits = TraitsT |
The traits type. | |
+using | executor_type = Executor |
The executor type. | |
+Public Member Functions | |
+ | ServerRPC ()=delete |
Deleted default constructor. | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | read (RequestT &req, CompletionToken &&token=CompletionToken{}) |
Receive a message from the client. | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | write (const ResponseT &response, grpc::WriteOptions options, CompletionToken &&token=CompletionToken{}) |
Send a message to the client. | |
+template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | write (const ResponseT &response, CompletionToken &&token=CompletionToken{}) |
Send a message to the client (default WriteOptions) | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | write_and_finish (const ResponseT &response, grpc::WriteOptions options, const grpc::Status &status, CompletionToken &&token=CompletionToken{}) |
Coalesce write and finish of this rpc. | |
+template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | write_and_finish (const ResponseT &response, const grpc::Status &status, CompletionToken &&token=CompletionToken{}) |
Coalesce write and finish of this rpc (default WriteOptions) | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | finish (const grpc::Status &status, CompletionToken &&token=CompletionToken{}) |
Finish this rpc. | |
auto | send_initial_metadata (CompletionToken &&token=detail::DefaultCompletionTokenT< Executor >{}) |
Send initial metadata. | |
bool | is_done () const noexcept |
Is this rpc done? | |
auto | wait_for_done (CompletionToken &&token=detail::DefaultCompletionTokenT< Executor >{}) |
Wait for done. | |
const executor_type & | get_executor () const noexcept |
Get the executor. | |
const executor_type & | get_scheduler () const noexcept |
Get the scheduler. | |
+auto & | context () |
Get the underlying ServerContext | |
+const auto & | context () const |
Get the underlying ServerContext (const overload) | |
void | cancel () noexcept |
Cancel this RPC. | |
+Static Public Member Functions | |
static constexpr std::string_view | service_name () noexcept |
Name of the gRPC service. | |
static constexpr std::string_view | method_name () noexcept |
Name of the gRPC method. | |
+Static Public Attributes | |
+static constexpr agrpc::ServerRPCType | TYPE = agrpc::ServerRPCType::BIDIRECTIONAL_STREAMING |
The rpc type. | |
I/O object for server-side, bidirectional-streaming rpcs.
+Use one of the agrpc::register_
functions to set up request handling.
Example:
+Based on .proto
file:
RequestUnary | A pointer to the generated gRPC method. |
Traits | A type used to customize this rpc. See agrpc::DefaultServerRPCTraits . |
Executor | The executor type, must be capable of referring to a GrpcContext. |
Per-Operation Cancellation
+(except wait_for_done()
) Terminal and partial. Cancellation is performed by invoking grpc::ServerContext::TryCancel. After successful cancellation no further operations should be started on the rpc. Operations are also cancelled when the deadline of the rpc has been reached.
+
|
+ +inlinestaticconstexprnoexcept | +
Name of the gRPC service.
+Equal to the generated Service::service_full_name()
.
E.g. for the .proto
schema
the return value would be "example.v1.Example"
.
+
|
+ +inlinestaticconstexprnoexcept | +
Name of the gRPC method.
+E.g. for agrpc::ServerRPC<&example::Example::AsyncService::RequestMyMethod>
the return value would be "MyMethod"
.
+
|
+ +inlineinherited | +
Receive a message from the client.
+May not be called currently with finish()
/write_and_finish()
. It is not meaningful to call it concurrently with another read on the same rpc since reads on the same stream are delivered in order.
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true indicates that a valid message was read. false when there will be no more incoming messages, either because the other side has called WritesDone() or the stream has failed (or been cancelled). |
+
|
+ +inlineinherited | +
Send a message to the client.
+Only one write may be outstanding at any given time. It may not be called concurrently with operations other than read()
.
GRPC does not take ownership or a reference to response
, so it is safe to to deallocate once write()
returns, unless a deferred completion token like agrpc::use_sender
or asio::deferred
is used.
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true means that the data/metadata/status/etc is going to go to the wire. If it is false , it is not going to the wire because the call is already dead (i.e., canceled, deadline expired, other side dropped the channel, etc). |
+
|
+ +inlineinherited | +
Coalesce write and finish of this rpc.
+Write response and coalesce it with trailing metadata which contains status, using WriteOptions options. May not be used concurrently with other operations.
+write_and_finish is equivalent of performing write with WriteOptions.set_last_message() and finish in a single step.
+GRPC does not take ownership or a reference to response
and status
, so it is safe to deallocate once write_and_finish()
returns, unless a deferred completion token like agrpc::use_sender
or asio::deferred
is used.
Implicit input parameter:
+token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true means that the data/metadata/status/etc is going to go to the wire. If it is false , it is not going to the wire because the call is already dead (i.e., canceled, deadline expired, other side dropped the channel, etc). |
+
|
+ +inlineinherited | +
Finish this rpc.
+Indicate that the stream is to be finished with a certain status code.
+Completes when the server has sent the appropriate signals to the client to end the call.
+Should not be used concurrently with other operations and may only be called once.
+It is appropriate to call this method when either:
+false
).This operation will end when the server has finished sending out initial metadata (if not sent already) and status, or if some failure occurred when trying to do so.
+GRPC does not take ownership or a reference to status
, so it is safe to to deallocate once finish()
returns, unless a deferred completion token like agrpc::use_sender
or asio::deferred
is used.
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true means that the data/metadata/status/etc is going to go to the wire. If it is false , it is not going to the wire because the call is already dead (i.e., canceled, deadline expired, other side dropped the channel, etc). |
+
|
+ +inlineinherited | +
Send initial metadata.
+Request notification of the sending of initial metadata to the client.
+This call is optional, but if it is used, it cannot be used concurrently with or after the finish()
/finish_with_error()
method.
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true means that the data/metadata/status/etc is going to go to the wire. If it is false , it is not going to the wire because the call is already dead (i.e., canceled, deadline expired, other side dropped the channel, etc). |
+
|
+ +inlinenodiscardnoexceptinherited | +
Is this rpc done?
+Only available if Traits
contain NOTIFY_WHEN_DONE = true
.
Returns true if NotifyWhenDone has fired which indicates that finish()
has been called or that the rpc is dead (i.e., canceled, deadline expired, other side dropped the channel, etc).
Thread-safe
+ +
+
|
+ +inlineinherited | +
Wait for done.
+Only available if Traits
contain NOTIFY_WHEN_DONE = true
.
Request notification of the completion of this rpc, either due to calling finish()
or because the rpc is dead (i.e., canceled, deadline expired, other side dropped the channel, etc). rpc.context().IsCancelled() may only be called after this operation completes.
Cancelling this operation does not invoke grpc::ServerContext::TryCancel.
+Internally, this operation uses grpc::ServerContext::AsyncNotifyWhenDone.
+wait_for_done()
may be outstanding at a time.token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void() . |
+
|
+ +inlinenodiscardnoexceptinherited | +
Get the executor.
+Thread-safe
+ +
+
|
+ +inlinenodiscardnoexceptinherited | +
Get the scheduler.
+Thread-safe
+
+
|
+ +inlinenoexceptinherited | +
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
This is the complete list of members for agrpc::ServerRPC< RequestClientStreaming, TraitsT, Executor >, including all inherited members.
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
I/O object for server-side, client-streaming rpcs. + More...
+ +#include <agrpc/server_rpc.hpp>
+Classes | |
struct | rebind_executor |
Rebind the ServerRPC to another executor. More... | |
+Public Types | |
+using | Request = RequestT |
The response message type. | |
+using | Response = ResponseT |
The request message type. | |
+using | Traits = TraitsT |
The traits type. | |
+using | Ptr = agrpc::ServerRPCPtr<ServerRPC> |
ServerRPCPtr specialized on this type. | |
+using | executor_type = Executor |
The executor type. | |
+Public Member Functions | |
+ | ServerRPC ()=delete |
Deleted default constructor. | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | read (RequestT &req, CompletionToken &&token=CompletionToken{}) |
Receive a message from the client. | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | finish (const ResponseT &response, const grpc::Status &status, CompletionToken &&token=CompletionToken{}) |
Finish the rpc. | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | finish_with_error (const grpc::Status &status, CompletionToken &&token=CompletionToken{}) |
Finish the rpc with an error. | |
auto | send_initial_metadata (CompletionToken &&token=detail::DefaultCompletionTokenT< Executor >{}) |
Send initial metadata. | |
bool | is_done () const noexcept |
Is this rpc done? | |
auto | wait_for_done (CompletionToken &&token=detail::DefaultCompletionTokenT< Executor >{}) |
Wait for done. | |
const executor_type & | get_executor () const noexcept |
Get the executor. | |
const executor_type & | get_scheduler () const noexcept |
Get the scheduler. | |
+auto & | context () |
Get the underlying ServerContext | |
+const auto & | context () const |
Get the underlying ServerContext (const overload) | |
void | cancel () noexcept |
Cancel this RPC. | |
+Static Public Member Functions | |
static constexpr std::string_view | service_name () noexcept |
Name of the gRPC service. | |
static constexpr std::string_view | method_name () noexcept |
Name of the gRPC method. | |
+Static Public Attributes | |
+static constexpr agrpc::ServerRPCType | TYPE = agrpc::ServerRPCType::CLIENT_STREAMING |
The rpc type. | |
I/O object for server-side, client-streaming rpcs.
+Use one of the agrpc::register_
functions to set up request handling.
Example:
+Based on .proto
file:
RequestUnary | A pointer to the generated gRPC method. |
Traits | A type used to customize this rpc. See agrpc::DefaultServerRPCTraits . |
Executor | The executor type, must be capable of referring to a GrpcContext. |
Per-Operation Cancellation
+(except wait_for_done()
) Terminal and partial. Cancellation is performed by invoking grpc::ServerContext::TryCancel. After successful cancellation no further operations should be started on the rpc. Operations are also cancelled when the deadline of the rpc has been reached.
+
|
+ +inlinestaticconstexprnoexcept | +
Name of the gRPC service.
+Equal to the generated Service::service_full_name()
.
E.g. for the .proto
schema
the return value would be "example.v1.Example"
.
+
|
+ +inlinestaticconstexprnoexcept | +
Name of the gRPC method.
+E.g. for agrpc::ServerRPC<&example::Example::AsyncService::RequestMyMethod>
the return value would be "MyMethod"
.
+
|
+ +inline | +
Receive a message from the client.
+May not be called currently with finish()
/finish_with_error()
. It is not meaningful to call it concurrently with another read on the same rpc since reads on the same stream are delivered in order.
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true indicates that a valid message was read. false when there will be no more incoming messages, either because the other side has called WritesDone() or the stream has failed (or been cancelled). |
+
|
+ +inline | +
Finish the rpc.
+Indicate that the stream is to be finished with a certain status code and also send out a response to the client.
+Should not be used concurrently with other operations and may only be called once.
+It is appropriate to call this method when:
+false
).This operation will end when the server has finished sending out initial and trailing metadata, response message, and status, or if some failure occurred when trying to do so.
+GRPC does not take ownership or a reference to response
or status
, so it is safe to deallocate once finish()
returns, unless a deferred completion token like agrpc::use_sender
or asio::deferred
is used.
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true means that the data/metadata/status/etc is going to go to the wire. If it is false , it is not going to the wire because the call is already dead (i.e., canceled, deadline expired, other side dropped the channel, etc). |
+
|
+ +inline | +
Finish the rpc with an error.
+Indicate that the stream is to be finished with a certain non-OK status code.
+Should not be used concurrently with other operations and may only be called once.
+This call is meant to end the call with some error, and can be called at any point that the server would like to "fail" the call (except during send_initial_metadata
).
This operation will end when the server has finished sending out initial and trailing metadata and status, or if some failure occurred when trying to do so.
+GRPC does not take ownership or a reference to status
, so it is safe to to deallocate once finish_with_error()
returns, unless a deferred completion token like agrpc::use_sender
or asio::deferred
is used.
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true means that the data/metadata/status/etc is going to go to the wire. If it is false , it is not going to the wire because the call is already dead (i.e., canceled, deadline expired, other side dropped the channel, etc). |
+
|
+ +inlineinherited | +
Send initial metadata.
+Request notification of the sending of initial metadata to the client.
+This call is optional, but if it is used, it cannot be used concurrently with or after the finish()
/finish_with_error()
method.
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true means that the data/metadata/status/etc is going to go to the wire. If it is false , it is not going to the wire because the call is already dead (i.e., canceled, deadline expired, other side dropped the channel, etc). |
+
|
+ +inlinenodiscardnoexceptinherited | +
Is this rpc done?
+Only available if Traits
contain NOTIFY_WHEN_DONE = true
.
Returns true if NotifyWhenDone has fired which indicates that finish()
has been called or that the rpc is dead (i.e., canceled, deadline expired, other side dropped the channel, etc).
Thread-safe
+ +
+
|
+ +inlineinherited | +
Wait for done.
+Only available if Traits
contain NOTIFY_WHEN_DONE = true
.
Request notification of the completion of this rpc, either due to calling finish()
or because the rpc is dead (i.e., canceled, deadline expired, other side dropped the channel, etc). rpc.context().IsCancelled() may only be called after this operation completes.
Cancelling this operation does not invoke grpc::ServerContext::TryCancel.
+Internally, this operation uses grpc::ServerContext::AsyncNotifyWhenDone.
+wait_for_done()
may be outstanding at a time.token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void() . |
+
|
+ +inlinenodiscardnoexceptinherited | +
Get the executor.
+Thread-safe
+ +
+
|
+ +inlinenodiscardnoexceptinherited | +
Get the scheduler.
+Thread-safe
+
+
|
+ +inlinenoexceptinherited | +
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
This is the complete list of members for agrpc::ServerRPC< RequestServerStreaming, TraitsT, Executor >, including all inherited members.
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
I/O object for server-side, server-streaming rpcs. + More...
+ +#include <agrpc/server_rpc.hpp>
+Classes | |
struct | rebind_executor |
Rebind the ServerRPC to another executor. More... | |
+Public Types | |
+using | Request = RequestT |
The response message type. | |
+using | Response = ResponseT |
The request message type. | |
+using | Traits = TraitsT |
The traits type. | |
+using | Ptr = agrpc::ServerRPCPtr<ServerRPC> |
ServerRPCPtr specialized on this type. | |
+using | executor_type = Executor |
The executor type. | |
+Public Member Functions | |
+ | ServerRPC ()=delete |
Deleted default constructor. | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | write (const ResponseT &response, grpc::WriteOptions options, CompletionToken &&token=CompletionToken{}) |
Send a message to the client. | |
+template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | write (const ResponseT &response, CompletionToken &&token=CompletionToken{}) |
Send a message to the client (default WriteOptions) | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | write_and_finish (const ResponseT &response, grpc::WriteOptions options, const grpc::Status &status, CompletionToken &&token=CompletionToken{}) |
Coalesce write and finish of this rpc. | |
+template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | write_and_finish (const ResponseT &response, const grpc::Status &status, CompletionToken &&token=CompletionToken{}) |
Coalesce write and finish of this rpc (default WriteOptions) | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | finish (const grpc::Status &status, CompletionToken &&token=CompletionToken{}) |
Finish this rpc. | |
auto | send_initial_metadata (CompletionToken &&token=detail::DefaultCompletionTokenT< Executor >{}) |
Send initial metadata. | |
bool | is_done () const noexcept |
Is this rpc done? | |
auto | wait_for_done (CompletionToken &&token=detail::DefaultCompletionTokenT< Executor >{}) |
Wait for done. | |
const executor_type & | get_executor () const noexcept |
Get the executor. | |
const executor_type & | get_scheduler () const noexcept |
Get the scheduler. | |
+auto & | context () |
Get the underlying ServerContext | |
+const auto & | context () const |
Get the underlying ServerContext (const overload) | |
void | cancel () noexcept |
Cancel this RPC. | |
+Static Public Member Functions | |
static constexpr std::string_view | service_name () noexcept |
Name of the gRPC service. | |
static constexpr std::string_view | method_name () noexcept |
Name of the gRPC method. | |
+Static Public Attributes | |
+static constexpr agrpc::ServerRPCType | TYPE = agrpc::ServerRPCType::SERVER_STREAMING |
The rpc type. | |
I/O object for server-side, server-streaming rpcs.
+Use one of the agrpc::register_
functions to set up request handling.
Example:
+Based on .proto
file:
RequestUnary | A pointer to the generated gRPC method. |
Traits | A type used to customize this rpc. See agrpc::DefaultServerRPCTraits . |
Executor | The executor type, must be capable of referring to a GrpcContext. |
Per-Operation Cancellation
+(except wait_for_done()
) Terminal and partial. Cancellation is performed by invoking grpc::ServerContext::TryCancel. After successful cancellation no further operations should be started on the rpc. Operations are also cancelled when the deadline of the rpc has been reached.
+
|
+ +inlinestaticconstexprnoexcept | +
Name of the gRPC service.
+Equal to the generated Service::service_full_name()
.
E.g. for the .proto
schema
the return value would be "example.v1.Example"
.
+
|
+ +inlinestaticconstexprnoexcept | +
Name of the gRPC method.
+E.g. for agrpc::ServerRPC<&example::Example::AsyncService::RequestMyMethod>
the return value would be "MyMethod"
.
+
|
+ +inline | +
Send a message to the client.
+Only one write may be outstanding at any given time.
+GRPC does not take ownership or a reference to response
, so it is safe to to deallocate once write()
returns, unless a deferred completion token like agrpc::use_sender
or asio::deferred
is used.
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true means that the data/metadata/status/etc is going to go to the wire. If it is false , it is not going to the wire because the call is already dead (i.e., canceled, deadline expired, other side dropped the channel, etc). |
+
|
+ +inline | +
Coalesce write and finish of this rpc.
+Write response and coalesce it with trailing metadata which contains status, using WriteOptions options.
+write_and_finish is equivalent of performing write with WriteOptions.set_last_message()
and finish in a single step.
GRPC does not take ownership or a reference to response
and status
, so it is safe to deallocate once write_and_finish()
returns, unless a deferred completion token like agrpc::use_sender
or asio::deferred
is used.
Implicit input parameter:
+token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true means that the data/metadata/status/etc is going to go to the wire. If it is false , it is not going to the wire because the call is already dead (i.e., canceled, deadline expired, other side dropped the channel, etc). |
+
|
+ +inline | +
Finish this rpc.
+Indicate that the stream is to be finished with a certain status code.
+Should not be used concurrently with other operations and may only be called once.
+This operation will end when the server has finished sending out initial metadata (if not sent already) and status, or if some failure occurred when trying to do so.
+GRPC does not take ownership or a reference to status
, so it is safe to to deallocate once finish()
returns, unless a deferred completion token like agrpc::use_sender
or asio::deferred
is used.
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true means that the data/metadata/status/etc is going to go to the wire. If it is false , it is not going to the wire because the call is already dead (i.e., canceled, deadline expired, other side dropped the channel, etc). |
+
|
+ +inlineinherited | +
Send initial metadata.
+Request notification of the sending of initial metadata to the client.
+This call is optional, but if it is used, it cannot be used concurrently with or after the finish()
/finish_with_error()
method.
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true means that the data/metadata/status/etc is going to go to the wire. If it is false , it is not going to the wire because the call is already dead (i.e., canceled, deadline expired, other side dropped the channel, etc). |
+
|
+ +inlinenodiscardnoexceptinherited | +
Is this rpc done?
+Only available if Traits
contain NOTIFY_WHEN_DONE = true
.
Returns true if NotifyWhenDone has fired which indicates that finish()
has been called or that the rpc is dead (i.e., canceled, deadline expired, other side dropped the channel, etc).
Thread-safe
+ +
+
|
+ +inlineinherited | +
Wait for done.
+Only available if Traits
contain NOTIFY_WHEN_DONE = true
.
Request notification of the completion of this rpc, either due to calling finish()
or because the rpc is dead (i.e., canceled, deadline expired, other side dropped the channel, etc). rpc.context().IsCancelled() may only be called after this operation completes.
Cancelling this operation does not invoke grpc::ServerContext::TryCancel.
+Internally, this operation uses grpc::ServerContext::AsyncNotifyWhenDone.
+wait_for_done()
may be outstanding at a time.token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void() . |
+
|
+ +inlinenodiscardnoexceptinherited | +
Get the executor.
+Thread-safe
+ +
+
|
+ +inlinenodiscardnoexceptinherited | +
Get the scheduler.
+Thread-safe
+
+
|
+ +inlinenoexceptinherited | +
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
This is the complete list of members for agrpc::ServerRPC< RequestUnary, TraitsT, Executor >, including all inherited members.
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
I/O object for server-side, unary rpcs. + More...
+ +#include <agrpc/server_rpc.hpp>
+Classes | |
struct | rebind_executor |
Rebind the ServerRPC to another executor. More... | |
+Public Types | |
+using | Request = RequestT |
The response message type. | |
+using | Response = ResponseT |
The request message type. | |
+using | Traits = TraitsT |
The traits type. | |
+using | Ptr = agrpc::ServerRPCPtr<ServerRPC> |
ServerRPCPtr specialized on this type. | |
+using | executor_type = Executor |
The executor type. | |
+Public Member Functions | |
+ | ServerRPC ()=delete |
Deleted default constructor. | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | finish (const ResponseT &response, const grpc::Status &status, CompletionToken &&token=CompletionToken{}) |
Finish the rpc. | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | finish_with_error (const grpc::Status &status, CompletionToken &&token=CompletionToken{}) |
Finish the rpc with an error. | |
auto | send_initial_metadata (CompletionToken &&token=detail::DefaultCompletionTokenT< Executor >{}) |
Send initial metadata. | |
bool | is_done () const noexcept |
Is this rpc done? | |
auto | wait_for_done (CompletionToken &&token=detail::DefaultCompletionTokenT< Executor >{}) |
Wait for done. | |
const executor_type & | get_executor () const noexcept |
Get the executor. | |
const executor_type & | get_scheduler () const noexcept |
Get the scheduler. | |
+auto & | context () |
Get the underlying ServerContext | |
+const auto & | context () const |
Get the underlying ServerContext (const overload) | |
void | cancel () noexcept |
Cancel this RPC. | |
+Static Public Member Functions | |
static constexpr std::string_view | service_name () noexcept |
Name of the gRPC service. | |
static constexpr std::string_view | method_name () noexcept |
Name of the gRPC method. | |
+Static Public Attributes | |
+static constexpr agrpc::ServerRPCType | TYPE = agrpc::ServerRPCType::UNARY |
The rpc type. | |
I/O object for server-side, unary rpcs.
+Use one of the agrpc::register_
functions to set up request handling.
Example:
+Based on .proto
file:
RequestUnary | A pointer to the generated gRPC method. |
Traits | A type used to customize this rpc. See agrpc::DefaultServerRPCTraits . |
Executor | The executor type, must be capable of referring to a GrpcContext. |
Per-Operation Cancellation
+(except wait_for_done()
) Terminal and partial. Cancellation is performed by invoking grpc::ServerContext::TryCancel. After successful cancellation no further operations should be started on the rpc. Operations are also cancelled when the deadline of the rpc has been reached.
+
|
+ +inlinestaticconstexprnoexcept | +
Name of the gRPC service.
+Equal to the generated Service::service_full_name()
.
E.g. for the .proto
schema
the return value would be "example.v1.Example"
.
+
|
+ +inlinestaticconstexprnoexcept | +
Name of the gRPC method.
+E.g. for agrpc::ServerRPC<&example::Example::AsyncService::RequestMyMethod>
the return value would be "MyMethod"
.
+
|
+ +inline | +
Finish the rpc.
+Indicate that the RPC is to be finished and request notification when the server has sent the appropriate signals to the client to end the call. Should not be used concurrently with other operations.
+Side effect:
+GRPC does not take ownership or a reference to response
and status
, so it is safe to deallocate once finish()
returns, unless a deferred completion token like agrpc::use_sender
or asio::deferred
is used.
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true means that the data/metadata/status/etc is going to go to the wire. If it is false , it is not going to the wire because the call is already dead (i.e., canceled, deadline expired, other side dropped the channel, etc). |
+
|
+ +inline | +
Finish the rpc with an error.
+Indicate that the stream is to be finished with a non-OK status, and request notification for when the server has finished sending the appropriate signals to the client to end the call.
+It should not be called concurrently with other streaming APIs on the same stream.
+Side effect:
+GRPC does not take ownership or a reference to status
, so it is safe to deallocate once finish_with_error()
returns, unless a deferred completion token like agrpc::use_sender
or asio::deferred
is used.
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true means that the data/metadata/status/etc is going to go to the wire. If it is false , it is not going to the wire because the call is already dead (i.e., canceled, deadline expired, other side dropped the channel, etc). |
+
|
+ +inlineinherited | +
Send initial metadata.
+Request notification of the sending of initial metadata to the client.
+This call is optional, but if it is used, it cannot be used concurrently with or after the finish()
/finish_with_error()
method.
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true means that the data/metadata/status/etc is going to go to the wire. If it is false , it is not going to the wire because the call is already dead (i.e., canceled, deadline expired, other side dropped the channel, etc). |
+
|
+ +inlinenodiscardnoexceptinherited | +
Is this rpc done?
+Only available if Traits
contain NOTIFY_WHEN_DONE = true
.
Returns true if NotifyWhenDone has fired which indicates that finish()
has been called or that the rpc is dead (i.e., canceled, deadline expired, other side dropped the channel, etc).
Thread-safe
+ +
+
|
+ +inlineinherited | +
Wait for done.
+Only available if Traits
contain NOTIFY_WHEN_DONE = true
.
Request notification of the completion of this rpc, either due to calling finish()
or because the rpc is dead (i.e., canceled, deadline expired, other side dropped the channel, etc). rpc.context().IsCancelled() may only be called after this operation completes.
Cancelling this operation does not invoke grpc::ServerContext::TryCancel.
+Internally, this operation uses grpc::ServerContext::AsyncNotifyWhenDone.
+wait_for_done()
may be outstanding at a time.token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void() . |
+
|
+ +inlinenodiscardnoexceptinherited | +
Get the executor.
+Thread-safe
+ +
+
|
+ +inlinenodiscardnoexceptinherited | +
Get the scheduler.
+Thread-safe
+
+
|
+ +inlinenoexceptinherited | +
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
This is the complete list of members for agrpc::ServerRPC< agrpc::ServerRPCType::GENERIC, TraitsT, Executor >, including all inherited members.
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
I/O object for server-side, generic rpcs. + More...
+ +#include <agrpc/server_rpc.hpp>
+Classes | |
struct | rebind_executor |
Rebind the ServerRPC to another executor. More... | |
+Public Types | |
+using | Ptr = agrpc::ServerRPCPtr<ServerRPC> |
ServerRPCPtr specialized on this type. | |
+using | Request = RequestT |
The response message type. | |
+using | Response = ResponseT |
The request message type. | |
+using | Traits = TraitsT |
The traits type. | |
+using | executor_type = Executor |
The executor type. | |
+Public Member Functions | |
+ | ServerRPC ()=delete |
Deleted default constructor. | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | read (RequestT &req, CompletionToken &&token=CompletionToken{}) |
Receive a message from the client. | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | write (const ResponseT &response, grpc::WriteOptions options, CompletionToken &&token=CompletionToken{}) |
Send a message to the client. | |
+template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | write (const ResponseT &response, CompletionToken &&token=CompletionToken{}) |
Send a message to the client (default WriteOptions) | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | write_and_finish (const ResponseT &response, grpc::WriteOptions options, const grpc::Status &status, CompletionToken &&token=CompletionToken{}) |
Coalesce write and finish of this rpc. | |
+template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | write_and_finish (const ResponseT &response, const grpc::Status &status, CompletionToken &&token=CompletionToken{}) |
Coalesce write and finish of this rpc (default WriteOptions) | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | finish (const grpc::Status &status, CompletionToken &&token=CompletionToken{}) |
Finish this rpc. | |
auto | send_initial_metadata (CompletionToken &&token=detail::DefaultCompletionTokenT< Executor >{}) |
Send initial metadata. | |
bool | is_done () const noexcept |
Is this rpc done? | |
auto | wait_for_done (CompletionToken &&token=detail::DefaultCompletionTokenT< Executor >{}) |
Wait for done. | |
const executor_type & | get_executor () const noexcept |
Get the executor. | |
const executor_type & | get_scheduler () const noexcept |
Get the scheduler. | |
+auto & | context () |
Get the underlying ServerContext | |
+const auto & | context () const |
Get the underlying ServerContext (const overload) | |
void | cancel () noexcept |
Cancel this RPC. | |
+Static Public Attributes | |
+static constexpr agrpc::ServerRPCType | TYPE = agrpc::ServerRPCType::GENERIC |
The rpc type. | |
I/O object for server-side, generic rpcs.
+Use one of the agrpc::register_
functions to set up request handling.
Example:
+Based on .proto
file:
RequestUnary | A pointer to the generated gRPC method. |
Traits | A type used to customize this rpc. See agrpc::DefaultServerRPCTraits . |
Executor | The executor type, must be capable of referring to a GrpcContext. |
Per-Operation Cancellation
+(except wait_for_done()
) Terminal and partial. Cancellation is performed by invoking grpc::ServerContext::TryCancel. After successful cancellation no further operations should be started on the rpc. Operations are also cancelled when the deadline of the rpc has been reached.
+
|
+ +inlineinherited | +
Receive a message from the client.
+May not be called currently with finish()
/write_and_finish()
. It is not meaningful to call it concurrently with another read on the same rpc since reads on the same stream are delivered in order.
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true indicates that a valid message was read. false when there will be no more incoming messages, either because the other side has called WritesDone() or the stream has failed (or been cancelled). |
+
|
+ +inlineinherited | +
Send a message to the client.
+Only one write may be outstanding at any given time. It may not be called concurrently with operations other than read()
.
GRPC does not take ownership or a reference to response
, so it is safe to to deallocate once write()
returns, unless a deferred completion token like agrpc::use_sender
or asio::deferred
is used.
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true means that the data/metadata/status/etc is going to go to the wire. If it is false , it is not going to the wire because the call is already dead (i.e., canceled, deadline expired, other side dropped the channel, etc). |
+
|
+ +inlineinherited | +
Coalesce write and finish of this rpc.
+Write response and coalesce it with trailing metadata which contains status, using WriteOptions options. May not be used concurrently with other operations.
+write_and_finish is equivalent of performing write with WriteOptions.set_last_message() and finish in a single step.
+GRPC does not take ownership or a reference to response
and status
, so it is safe to deallocate once write_and_finish()
returns, unless a deferred completion token like agrpc::use_sender
or asio::deferred
is used.
Implicit input parameter:
+token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true means that the data/metadata/status/etc is going to go to the wire. If it is false , it is not going to the wire because the call is already dead (i.e., canceled, deadline expired, other side dropped the channel, etc). |
+
|
+ +inlineinherited | +
Finish this rpc.
+Indicate that the stream is to be finished with a certain status code.
+Completes when the server has sent the appropriate signals to the client to end the call.
+Should not be used concurrently with other operations and may only be called once.
+It is appropriate to call this method when either:
+false
).This operation will end when the server has finished sending out initial metadata (if not sent already) and status, or if some failure occurred when trying to do so.
+GRPC does not take ownership or a reference to status
, so it is safe to to deallocate once finish()
returns, unless a deferred completion token like agrpc::use_sender
or asio::deferred
is used.
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true means that the data/metadata/status/etc is going to go to the wire. If it is false , it is not going to the wire because the call is already dead (i.e., canceled, deadline expired, other side dropped the channel, etc). |
+
|
+ +inlineinherited | +
Send initial metadata.
+Request notification of the sending of initial metadata to the client.
+This call is optional, but if it is used, it cannot be used concurrently with or after the finish()
/finish_with_error()
method.
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true means that the data/metadata/status/etc is going to go to the wire. If it is false , it is not going to the wire because the call is already dead (i.e., canceled, deadline expired, other side dropped the channel, etc). |
+
|
+ +inlinenodiscardnoexceptinherited | +
Is this rpc done?
+Only available if Traits
contain NOTIFY_WHEN_DONE = true
.
Returns true if NotifyWhenDone has fired which indicates that finish()
has been called or that the rpc is dead (i.e., canceled, deadline expired, other side dropped the channel, etc).
Thread-safe
+ +
+
|
+ +inlineinherited | +
Wait for done.
+Only available if Traits
contain NOTIFY_WHEN_DONE = true
.
Request notification of the completion of this rpc, either due to calling finish()
or because the rpc is dead (i.e., canceled, deadline expired, other side dropped the channel, etc). rpc.context().IsCancelled() may only be called after this operation completes.
Cancelling this operation does not invoke grpc::ServerContext::TryCancel.
+Internally, this operation uses grpc::ServerContext::AsyncNotifyWhenDone.
+wait_for_done()
may be outstanding at a time.token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void() . |
+
|
+ +inlinenodiscardnoexceptinherited | +
Get the executor.
+Thread-safe
+ +
+
|
+ +inlinenodiscardnoexceptinherited | +
Get the scheduler.
+Thread-safe
+
+
|
+ +inlinenoexceptinherited | +
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
This is the complete list of members for agrpc::ServerRPCPtr< ServerRPCT >, including all inherited members.
+operator bool() const noexcept | agrpc::ServerRPCPtr< ServerRPCT > | inlineexplicit |
operator*() noexcept | agrpc::ServerRPCPtr< ServerRPCT > | inline |
operator*() const noexcept | agrpc::ServerRPCPtr< ServerRPCT > | inline |
operator->() noexcept | agrpc::ServerRPCPtr< ServerRPCT > | inline |
operator->() const noexcept | agrpc::ServerRPCPtr< ServerRPCT > | inline |
request() noexcept | agrpc::ServerRPCPtr< ServerRPCT > | inline |
request() const noexcept | agrpc::ServerRPCPtr< ServerRPCT > | inline |
ServerRPC typedef | agrpc::ServerRPCPtr< ServerRPCT > | |
ServerRPCPtr()=default | agrpc::ServerRPCPtr< ServerRPCT > | |
swap(ServerRPCPtr &lhs, ServerRPCPtr &rhs) noexcept | agrpc::ServerRPCPtr< ServerRPCT > | friend |
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
Allocated ServerRPC created by register_callback_rpc_handler. + More...
+ +#include <agrpc/server_rpc_ptr.hpp>
+Public Types | |
+using | ServerRPC = ServerRPCT |
The ServerRPC type. | |
+Public Member Functions | |
ServerRPCPtr ()=default | |
Default constructor. | |
+ServerRPCT & | operator* () noexcept |
Get reference to underlying ServerRPC. | |
+const ServerRPCT & | operator* () const noexcept |
Get reference to underlying ServerRPC (const overload) | |
+ServerRPCT * | operator-> () noexcept |
Access underlying ServerRPC. | |
+const ServerRPCT * | operator-> () const noexcept |
Access underlying ServerRPC (const overload) | |
operator bool () const noexcept | |
Check whether this pointer owns a ServerRPC. | |
+decltype(auto) | request () noexcept |
Get client's initial request message. | |
+decltype(auto) | request () const noexcept |
Get client's initial request message (const overload) | |
+Friends | |
void | swap (ServerRPCPtr &lhs, ServerRPCPtr &rhs) noexcept |
Swap the contents of two ServerRPCPtr. | |
Allocated ServerRPC created by register_callback_rpc_handler.
+
+
|
+ +default | +
Default constructor.
+The only valid operations after construction are move-assignment, operator bool, swap and destruction.
+ +
+
|
+ +inlineexplicitnoexcept | +
Check whether this pointer owns a ServerRPC.
+
+
|
+ +friend | +
Swap the contents of two ServerRPCPtr.
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
This is the complete list of members for agrpc::Waiter< Signature, Executor >, including all inherited members.
+executor_type typedef | agrpc::Waiter< Signature, Executor > | |
initiate(Function &&function, ExecutorOrIoObject &&executor_or_io_object, Args &&... args) | agrpc::Waiter< Signature, Executor > | inline |
is_ready() const noexcept | agrpc::Waiter< Signature, Executor > | inline |
wait(CompletionToken &&token=CompletionToken{}) | agrpc::Waiter< Signature, Executor > | inline |
Waiter() noexcept | agrpc::Waiter< Signature, Executor > | inline |
~Waiter() noexcept | agrpc::Waiter< Signature, Executor > | inline |
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
(experimental) Utility class for uncancelable operations + More...
+ +#include <agrpc/waiter.hpp>
+Classes | |
struct | rebind_executor |
Rebind the Waiter to another executor. More... | |
+Public Types | |
+using | executor_type = Executor |
The associated executor type. | |
+Public Member Functions | |
+ | Waiter () noexcept |
Default construct a Waiter. | |
~Waiter () noexcept | |
Destruct the Waiter. | |
template<class Function , class ExecutorOrIoObject , class... Args> | |
auto | initiate (Function &&function, ExecutorOrIoObject &&executor_or_io_object, Args &&... args) |
Initiate an operation. | |
bool | is_ready () const noexcept |
Has the initiated operation finished? | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | wait (CompletionToken &&token=CompletionToken{}) |
Wait for the initiated operation to complete. | |
(experimental) Utility class for uncancelable operations
+Provides cancellation support for otherwise uncancelable operations by canceling only the act of waiting for completion as opposed to the operation itself.
+Signature | Completion signature of the operation. For example, for agrpc::Alarm::wait this would be void(bool) . |
Executor | Type of the I/O executor. For agrpc::Alarm this would be agrpc::GrpcExecutor or asio::any_io_executor . Default: agrpc::GrpcExecutor |
+
|
+ +inlinenoexcept | +
+
|
+ +inline | +
Initiate an operation.
+Only one operation may be running at a time.
+All operations must complete before this object is destructed.
+Example:
+function
returns a sender then only the set_value
channel is forwarded to the waiting operation.function | Callable that will be invoked with all subsequent arguments followed by the completion handler of this Waiter (Asio) or it returns a sender composed of the result of the call (unifex/stdexec only). |
executor_or_io_object | Either an executor itself or an object that implements get_executor() . This will become the I/O executor of subsequent calls to wait() . |
+
|
+ +inlinenodiscardnoexcept | +
Has the initiated operation finished?
+Thread-safe
+ +
+
|
+ +inline | +
Wait for the initiated operation to complete.
+Only one call to wait()
may be outstanding at a time. May be called before an operation has been initiated. Care must be taken when invoking this function multiple times for an already completed operation as completion arguments are moved into the completion handler.
Per-Operation Cancellation
+All. Upon cancellation, the initiated operation continues to run.
+ +
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
This is the complete list of members for agrpc::detail::ClientRPCBase< Responder, Executor >, including all inherited members.
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
#include <agrpc/detail/client_rpc_base.hpp>
+Public Types | |
+using | executor_type = Executor |
The executor type. | |
+Public Member Functions | |
+ | ClientRPCBase (agrpc::GrpcContext &grpc_context) |
Construct from a GrpcContext. | |
template<class ClientContextInitFunction > | |
ClientRPCBase (agrpc::GrpcContext &grpc_context, ClientContextInitFunction &&init_function) | |
Construct from a GrpcContext and an init function. | |
+ | ClientRPCBase (const Executor &executor) |
Construct from an executor. | |
template<class ClientContextInitFunction > | |
ClientRPCBase (const Executor &executor, ClientContextInitFunction &&init_function) | |
Construct from an executor and init function. | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | read_initial_metadata (CompletionToken &&token=detail::DefaultCompletionTokenT< Executor >{}) |
Read initial metadata. | |
const executor_type & | get_executor () const noexcept |
Get the executor. | |
const executor_type & | get_scheduler () const noexcept |
Get the scheduler. | |
+grpc::ClientContext & | context () |
Get the underlying grpc::ClientContext | |
+const grpc::ClientContext & | context () const |
Get the underlying grpc::ClientContext (const overload) | |
void | cancel () noexcept |
Cancel this RPC. | |
ServerRPC base.
+
+
|
+ +inline | +
Construct from a GrpcContext and an init function.
+ClientContextInitFunction | A function with signature void(grpc::ClientContext&) which will be invoked during construction. It can, for example, be used to set this rpc's deadline. |
+
|
+ +inline | +
Construct from an executor and init function.
+ClientContextInitFunction | A function with signature void(grpc::ClientContext&) which will be invoked during construction. It can, for example, be used to set this rpc's deadline. |
+
|
+ +inline | +
Read initial metadata.
+Request notification of the reading of the initial metadata.
+This call is optional.
+Side effect:
+token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true indicates that the metadata was read. If it is false , then the call is dead. |
+
|
+ +inlinenodiscardnoexceptinherited | +
Get the executor.
+Thread-safe
+ +
+
|
+ +inlinenodiscardnoexceptinherited | +
Get the scheduler.
+Thread-safe
+
+
|
+ +inlinenoexceptinherited | +
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
This is the complete list of members for agrpc::detail::ClientRPCBidiStreamingBase< ResponderT< RequestT, ResponseT >, Executor >, including all inherited members.
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
Bidirectional-streaming ClientRPC base. + More...
+ +#include <agrpc/client_rpc.hpp>
+Public Types | |
+using | Request = RequestT |
The request message type. | |
+using | Response = ResponseT |
The response message type. | |
+using | executor_type = Executor |
The executor type. | |
+Public Member Functions | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | read_initial_metadata (CompletionToken &&token=CompletionToken{}) |
Read initial metadata. | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | read (ResponseT &response, CompletionToken &&token=CompletionToken{}) |
Receive a message from the server. | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | write (const RequestT &request, grpc::WriteOptions options, CompletionToken &&token=CompletionToken{}) |
Send a message to the server. | |
+template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | write (const RequestT &request, CompletionToken &&token=CompletionToken{}) |
Send a message to the server (default WriteOptions) | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | writes_done (CompletionToken &&token=CompletionToken{}) |
Signal writes done to the server. | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | finish (CompletionToken &&token=CompletionToken{}) |
Signal writes done and finish the rpc. | |
const executor_type & | get_executor () const noexcept |
Get the executor. | |
const executor_type & | get_scheduler () const noexcept |
Get the scheduler. | |
+grpc::ClientContext & | context () |
Get the underlying grpc::ClientContext | |
+const grpc::ClientContext & | context () const |
Get the underlying grpc::ClientContext (const overload) | |
void | cancel () noexcept |
Cancel this RPC. | |
Bidirectional-streaming ClientRPC base.
+
+
|
+ +inline | +
Read initial metadata.
+Request notification of the reading of the initial metadata.
+This call is optional.
+Side effect:
+write()
is called.token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true indicates that the metadata was read. If it is false , then the call is dead. |
+
|
+ +inline | +
Receive a message from the server.
+This is thread-safe with respect to write()
or writes_done()
methods. It should not be called concurrently with other operations. It is not meaningful to call it concurrently with another read on the same stream since reads on the same stream are delivered in order.
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true indicates that a valid message was read. false when there will be no more incoming messages, either because the other server is finished sending messages or the stream has failed (or been cancelled). |
+
|
+ +inline | +
Send a message to the server.
+Only one write may be outstanding at any given time. This is thread-safe with respect to read()
. It should not be called concurrently with other operations.
request | The request message, save to delete when this function returns, unless a deferred completion token is used like agrpc::use_sender or asio::deferred . |
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true means that the data is going to go to the wire. If it is false , it is not going to the wire because the call is already dead (i.e., canceled, deadline expired, other side dropped the channel, etc). |
+
|
+ +inline | +
Signal writes done to the server.
+May only be called once. Should not be called after performing a write with the set_last_message option.
+Signal the client is done with the writes (half-close the client stream). Thread-safe with respect to read. May not be called concurrently with a write()
that has the set_last_message option set.
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true means that the data is going to go to the wire. If it is false , it is not going to the wire because the call is already dead (i.e., canceled, deadline expired, other side dropped the channel, etc). |
+
|
+ +inline | +
Signal writes done and finish the rpc.
+Indicate that the stream is to be finished and request notification for when the call has been ended.
+May not be used concurrently with other operations and may only be called once.
+It is appropriate to call this method when:
+false
).The operation will finish when either:
+Note that implementations of this method attempt to receive initial metadata from the server if initial metadata has not been received yet.
+Side effect:
+token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(grpc::Status) . |
+
|
+ +inlinenodiscardnoexceptinherited | +
Get the executor.
+Thread-safe
+ +
+
|
+ +inlinenodiscardnoexceptinherited | +
Get the scheduler.
+Thread-safe
+
+
|
+ +inlinenoexceptinherited | +
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
This is the complete list of members for agrpc::detail::ClientRPCContextBase< Responder >, including all inherited members.
+cancel() noexcept | agrpc::detail::ClientRPCContextBase< Responder > | inline |
context() | agrpc::detail::ClientRPCContextBase< Responder > | inline |
context() const | agrpc::detail::ClientRPCContextBase< Responder > | inline |
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
ClientRPC grpc::ClientContext base. + More...
+ +#include <agrpc/detail/client_rpc_context_base.hpp>
+Public Member Functions | |
+grpc::ClientContext & | context () |
Get the underlying grpc::ClientContext | |
+const grpc::ClientContext & | context () const |
Get the underlying grpc::ClientContext (const overload) | |
void | cancel () noexcept |
Cancel this RPC. | |
ClientRPC grpc::ClientContext base.
+
+
|
+ +inlinenoexcept | +
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
This is the complete list of members for agrpc::detail::ClientRPCServerStreamingBase< PrepareAsyncServerStreaming, Executor >, including all inherited members.
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
Server-streaming ClientRPC base. + More...
+ +#include <agrpc/client_rpc.hpp>
+Classes | |
struct | rebind_executor |
Rebind the ClientRPC to another executor. More... | |
+Public Member Functions | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | start (StubT &stub, const RequestT &request, CompletionToken &&token=CompletionToken{}) |
Start a server-streaming request. | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | read (ResponseT &response, CompletionToken &&token=CompletionToken{}) |
Receive a message from the server. | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | finish (CompletionToken &&token=CompletionToken{}) |
Finish the rpc. | |
auto | read_initial_metadata (CompletionToken &&token=detail::DefaultCompletionTokenT< Executor >{}) |
Read initial metadata. | |
const executor_type & | get_executor () const noexcept |
Get the executor. | |
const executor_type & | get_scheduler () const noexcept |
Get the scheduler. | |
+grpc::ClientContext & | context () |
Get the underlying grpc::ClientContext | |
+const grpc::ClientContext & | context () const |
Get the underlying grpc::ClientContext (const overload) | |
void | cancel () noexcept |
Cancel this RPC. | |
+Static Public Member Functions | |
static constexpr std::string_view | service_name () noexcept |
Name of the gRPC service. | |
static constexpr std::string_view | method_name () noexcept |
Name of the gRPC method. | |
+Static Public Attributes | |
+static constexpr agrpc::ClientRPCType | TYPE = agrpc::ClientRPCType::SERVER_STREAMING |
The rpc type. | |
Server-streaming ClientRPC base.
+
+
|
+ +inlinestaticconstexprnoexcept | +
Name of the gRPC service.
+Equal to the generated Service::service_full_name()
.
E.g. for the .proto
schema
the return value would be "example.v1.Example"
.
+
|
+ +inlinestaticconstexprnoexcept | +
Name of the gRPC method.
+E.g. for agrpc::ClientRPC<&example::Example::Stub::PrepareAsyncMyMethod>
the return value would be "MyMethod"
.
+
|
+ +inline | +
Start a server-streaming request.
+stub | The Stub that corresponds to the gRPC method. |
request | The request message, save to delete when this function returns, unless a deferred completion token is used like agrpc::use_sender or asio::deferred . |
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true means that the rpc was started successfully. If it is false , then call finish() to obtain error details. |
+
|
+ +inline | +
Receive a message from the server.
+May not be called concurrently with read_initial_metadata()
. It is not meaningful to call it concurrently with another read on the same stream since reads on the same stream are delivered in order.
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true indicates that a valid message was read. false when there will be no more incoming messages, either because the other server is finished sending messages or the stream has failed (or been cancelled). |
+
|
+ +inline | +
Finish the rpc.
+Indicate that the stream is to be finished and request notification for when the call has been ended.
+May not be used concurrently with other operations and may only be called once.
+It is appropriate to call this method when:
+false
).The operation will finish when either:
+Note that implementations of this method attempt to receive initial metadata from the server if initial metadata has not been received yet.
+Side effect:
+token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(grpc::Status) . |
+
|
+ +inlineinherited | +
Read initial metadata.
+Request notification of the reading of the initial metadata.
+This call is optional.
+Side effect:
+token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true indicates that the metadata was read. If it is false , then the call is dead. |
+
|
+ +inlinenodiscardnoexceptinherited | +
Get the executor.
+Thread-safe
+ +
+
|
+ +inlinenodiscardnoexceptinherited | +
Get the scheduler.
+Thread-safe
+
+
|
+ +inlinenoexceptinherited | +
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
This is the complete list of members for agrpc::detail::ClientRPCUnaryBase< PrepareAsyncUnary, Executor >, including all inherited members.
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
Unary ClientRPC base. + More...
+ +#include <agrpc/client_rpc.hpp>
+Classes | |
struct | rebind_executor |
Rebind the ClientRPC to another executor. More... | |
+Public Member Functions | |
void | start (StubT &stub, const RequestT &req) |
Start the rpc. | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | finish (ResponseT &response, CompletionToken &&token=CompletionToken{}) |
Finish the rpc. | |
auto | read_initial_metadata (CompletionToken &&token=detail::DefaultCompletionTokenT< Executor >{}) |
Read initial metadata. | |
const executor_type & | get_executor () const noexcept |
Get the executor. | |
const executor_type & | get_scheduler () const noexcept |
Get the scheduler. | |
+grpc::ClientContext & | context () |
Get the underlying grpc::ClientContext | |
+const grpc::ClientContext & | context () const |
Get the underlying grpc::ClientContext (const overload) | |
void | cancel () noexcept |
Cancel this RPC. | |
+Static Public Member Functions | |
static constexpr std::string_view | service_name () noexcept |
Name of the gRPC service. | |
static constexpr std::string_view | method_name () noexcept |
Name of the gRPC method. | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
static auto | request (agrpc::GrpcContext &grpc_context, StubT &stub, grpc::ClientContext &context, const RequestT &request, ResponseT &response, CompletionToken &&token=CompletionToken{}) |
Perform a request. | |
+template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
static auto | request (const Executor &executor, StubT &stub, grpc::ClientContext &context, const RequestT &request, ResponseT &response, CompletionToken &&token=CompletionToken{}) |
Start a generic unary request (executor overload) | |
+Static Public Attributes | |
+static constexpr agrpc::ClientRPCType | TYPE = agrpc::ClientRPCType::UNARY |
The rpc type. | |
Unary ClientRPC base.
+
+
|
+ +inlinestaticconstexprnoexcept | +
Name of the gRPC service.
+Equal to the generated Service::service_full_name()
.
E.g. for the .proto
schema
the return value would be "example.v1.Example"
.
+
|
+ +inlinestaticconstexprnoexcept | +
Name of the gRPC method.
+E.g. for agrpc::ClientRPC<&example::Example::Stub::PrepareAsyncMyMethod>
the return value would be "MyMethod"
.
+
|
+ +inlinestatic | +
Perform a request.
+request | The request message, save to delete when this function returns, unless a deferred completion token is used like agrpc::use_sender or asio::deferred . |
response | The response message, will be filled by the server upon finishing this rpc. Must remain alive until this rpc is finished. |
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(grpc::Status) . Use grpc::Status::ok() to check whether the request was successful. |
+
|
+ +inline | +
Start the rpc.
+req | The request message, save to delete when this function returns, unless a deferred completion token like agrpc::use_sender or asio::deferred is used. |
+
|
+ +inline | +
Finish the rpc.
+Receive the server's response message and final status for the call.
+This operation will finish when either:
+Side effect:
+token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(grpc::Status) . |
+
|
+ +inlineinherited | +
Read initial metadata.
+Request notification of the reading of the initial metadata.
+This call is optional.
+Side effect:
+token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true indicates that the metadata was read. If it is false , then the call is dead. |
+
|
+ +inlinenodiscardnoexceptinherited | +
Get the executor.
+Thread-safe
+ +
+
|
+ +inlinenodiscardnoexceptinherited | +
Get the scheduler.
+Thread-safe
+
+
|
+ +inlinenoexceptinherited | +
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
This is the complete list of members for agrpc::detail::RPCExecutorBase< Executor >, including all inherited members.
+executor_type typedef | agrpc::detail::RPCExecutorBase< Executor > | |
get_executor() const noexcept | agrpc::detail::RPCExecutorBase< Executor > | inline |
get_scheduler() const noexcept | agrpc::detail::RPCExecutorBase< Executor > | inline |
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
RPC's executor base. + More...
+ +#include <agrpc/detail/rpc_executor_base.hpp>
+Public Types | |
+using | executor_type = Executor |
The executor type. | |
+Public Member Functions | |
const executor_type & | get_executor () const noexcept |
Get the executor. | |
const executor_type & | get_scheduler () const noexcept |
Get the scheduler. | |
+Friends | |
+template<auto , class > | |
class | agrpc::ClientRPC |
+template<auto , class , class > | |
class | agrpc::ServerRPC |
RPC's executor base.
+
+
|
+ +inlinenodiscardnoexcept | +
Get the executor.
+Thread-safe
+ +
+
|
+ +inlinenodiscardnoexcept | +
Get the scheduler.
+Thread-safe
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
This is the complete list of members for agrpc::detail::ServerRPCBase< Responder, Traits, Executor >, including all inherited members.
+cancel() noexcept | agrpc::detail::ServerRPCContextBase< Responder > | inline |
context() | agrpc::detail::ServerRPCContextBase< Responder > | inline |
context() const | agrpc::detail::ServerRPCContextBase< Responder > | inline |
executor_type typedef | agrpc::detail::RPCExecutorBase< Executor > | |
get_executor() const noexcept | agrpc::detail::RPCExecutorBase< Executor > | inline |
get_scheduler() const noexcept | agrpc::detail::RPCExecutorBase< Executor > | inline |
is_done() const noexcept | agrpc::detail::ServerRPCNotifyWhenDoneMixin< Traits::NOTIFY_WHEN_DONE, Responder, Executor > | inline |
send_initial_metadata(CompletionToken &&token=detail::DefaultCompletionTokenT< Executor >{}) | agrpc::detail::ServerRPCBase< Responder, Traits, Executor > | inline |
wait_for_done(CompletionToken &&token=detail::DefaultCompletionTokenT< Executor >{}) | agrpc::detail::ServerRPCNotifyWhenDoneMixin< Traits::NOTIFY_WHEN_DONE, Responder, Executor > | inline |
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
#include <agrpc/detail/server_rpc_base.hpp>
+Public Types | |
+using | executor_type = Executor |
The executor type. | |
+Public Member Functions | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | send_initial_metadata (CompletionToken &&token=detail::DefaultCompletionTokenT< Executor >{}) |
Send initial metadata. | |
bool | is_done () const noexcept |
Is this rpc done? | |
auto | wait_for_done (CompletionToken &&token=detail::DefaultCompletionTokenT< Executor >{}) |
Wait for done. | |
const executor_type & | get_executor () const noexcept |
Get the executor. | |
const executor_type & | get_scheduler () const noexcept |
Get the scheduler. | |
+auto & | context () |
Get the underlying ServerContext | |
+const auto & | context () const |
Get the underlying ServerContext (const overload) | |
void | cancel () noexcept |
Cancel this RPC. | |
ServerRPC base.
+
+
|
+ +inline | +
Send initial metadata.
+Request notification of the sending of initial metadata to the client.
+This call is optional, but if it is used, it cannot be used concurrently with or after the finish()
/finish_with_error()
method.
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true means that the data/metadata/status/etc is going to go to the wire. If it is false , it is not going to the wire because the call is already dead (i.e., canceled, deadline expired, other side dropped the channel, etc). |
+
|
+ +inlinenodiscardnoexceptinherited | +
Is this rpc done?
+Only available if Traits
contain NOTIFY_WHEN_DONE = true
.
Returns true if NotifyWhenDone has fired which indicates that finish()
has been called or that the rpc is dead (i.e., canceled, deadline expired, other side dropped the channel, etc).
Thread-safe
+ +
+
|
+ +inlineinherited | +
Wait for done.
+Only available if Traits
contain NOTIFY_WHEN_DONE = true
.
Request notification of the completion of this rpc, either due to calling finish()
or because the rpc is dead (i.e., canceled, deadline expired, other side dropped the channel, etc). rpc.context().IsCancelled() may only be called after this operation completes.
Cancelling this operation does not invoke grpc::ServerContext::TryCancel.
+Internally, this operation uses grpc::ServerContext::AsyncNotifyWhenDone.
+wait_for_done()
may be outstanding at a time.token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void() . |
+
|
+ +inlinenodiscardnoexceptinherited | +
Get the executor.
+Thread-safe
+ +
+
|
+ +inlinenodiscardnoexceptinherited | +
Get the scheduler.
+Thread-safe
+
+
|
+ +inlinenoexceptinherited | +
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
This is the complete list of members for agrpc::detail::ServerRPCBidiStreamingBase< ResponderT< ResponseT, RequestT >, TraitsT, Executor >, including all inherited members.
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
ServerRPC bidirectional-streaming base. + More...
+ +#include <agrpc/server_rpc.hpp>
+Public Member Functions | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | read (RequestT &req, CompletionToken &&token=CompletionToken{}) |
Receive a message from the client. | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | write (const ResponseT &response, grpc::WriteOptions options, CompletionToken &&token=CompletionToken{}) |
Send a message to the client. | |
+template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | write (const ResponseT &response, CompletionToken &&token=CompletionToken{}) |
Send a message to the client (default WriteOptions) | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | write_and_finish (const ResponseT &response, grpc::WriteOptions options, const grpc::Status &status, CompletionToken &&token=CompletionToken{}) |
Coalesce write and finish of this rpc. | |
+template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | write_and_finish (const ResponseT &response, const grpc::Status &status, CompletionToken &&token=CompletionToken{}) |
Coalesce write and finish of this rpc (default WriteOptions) | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | finish (const grpc::Status &status, CompletionToken &&token=CompletionToken{}) |
Finish this rpc. | |
auto | send_initial_metadata (CompletionToken &&token=detail::DefaultCompletionTokenT< Executor >{}) |
Send initial metadata. | |
bool | is_done () const noexcept |
Is this rpc done? | |
auto | wait_for_done (CompletionToken &&token=detail::DefaultCompletionTokenT< Executor >{}) |
Wait for done. | |
const executor_type & | get_executor () const noexcept |
Get the executor. | |
const executor_type & | get_scheduler () const noexcept |
Get the scheduler. | |
+auto & | context () |
Get the underlying ServerContext | |
+const auto & | context () const |
Get the underlying ServerContext (const overload) | |
void | cancel () noexcept |
Cancel this RPC. | |
ServerRPC bidirectional-streaming base.
+
+
|
+ +inline | +
Receive a message from the client.
+May not be called currently with finish()
/write_and_finish()
. It is not meaningful to call it concurrently with another read on the same rpc since reads on the same stream are delivered in order.
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true indicates that a valid message was read. false when there will be no more incoming messages, either because the other side has called WritesDone() or the stream has failed (or been cancelled). |
+
|
+ +inline | +
Send a message to the client.
+Only one write may be outstanding at any given time. It may not be called concurrently with operations other than read()
.
GRPC does not take ownership or a reference to response
, so it is safe to to deallocate once write()
returns, unless a deferred completion token like agrpc::use_sender
or asio::deferred
is used.
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true means that the data/metadata/status/etc is going to go to the wire. If it is false , it is not going to the wire because the call is already dead (i.e., canceled, deadline expired, other side dropped the channel, etc). |
+
|
+ +inline | +
Coalesce write and finish of this rpc.
+Write response and coalesce it with trailing metadata which contains status, using WriteOptions options. May not be used concurrently with other operations.
+write_and_finish is equivalent of performing write with WriteOptions.set_last_message() and finish in a single step.
+GRPC does not take ownership or a reference to response
and status
, so it is safe to deallocate once write_and_finish()
returns, unless a deferred completion token like agrpc::use_sender
or asio::deferred
is used.
Implicit input parameter:
+token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true means that the data/metadata/status/etc is going to go to the wire. If it is false , it is not going to the wire because the call is already dead (i.e., canceled, deadline expired, other side dropped the channel, etc). |
+
|
+ +inline | +
Finish this rpc.
+Indicate that the stream is to be finished with a certain status code.
+Completes when the server has sent the appropriate signals to the client to end the call.
+Should not be used concurrently with other operations and may only be called once.
+It is appropriate to call this method when either:
+false
).This operation will end when the server has finished sending out initial metadata (if not sent already) and status, or if some failure occurred when trying to do so.
+GRPC does not take ownership or a reference to status
, so it is safe to to deallocate once finish()
returns, unless a deferred completion token like agrpc::use_sender
or asio::deferred
is used.
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true means that the data/metadata/status/etc is going to go to the wire. If it is false , it is not going to the wire because the call is already dead (i.e., canceled, deadline expired, other side dropped the channel, etc). |
+
|
+ +inlineinherited | +
Send initial metadata.
+Request notification of the sending of initial metadata to the client.
+This call is optional, but if it is used, it cannot be used concurrently with or after the finish()
/finish_with_error()
method.
token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void(bool) . true means that the data/metadata/status/etc is going to go to the wire. If it is false , it is not going to the wire because the call is already dead (i.e., canceled, deadline expired, other side dropped the channel, etc). |
+
|
+ +inlinenodiscardnoexceptinherited | +
Is this rpc done?
+Only available if Traits
contain NOTIFY_WHEN_DONE = true
.
Returns true if NotifyWhenDone has fired which indicates that finish()
has been called or that the rpc is dead (i.e., canceled, deadline expired, other side dropped the channel, etc).
Thread-safe
+ +
+
|
+ +inlineinherited | +
Wait for done.
+Only available if Traits
contain NOTIFY_WHEN_DONE = true
.
Request notification of the completion of this rpc, either due to calling finish()
or because the rpc is dead (i.e., canceled, deadline expired, other side dropped the channel, etc). rpc.context().IsCancelled() may only be called after this operation completes.
Cancelling this operation does not invoke grpc::ServerContext::TryCancel.
+Internally, this operation uses grpc::ServerContext::AsyncNotifyWhenDone.
+wait_for_done()
may be outstanding at a time.token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void() . |
+
|
+ +inlinenodiscardnoexceptinherited | +
Get the executor.
+Thread-safe
+ +
+
|
+ +inlinenodiscardnoexceptinherited | +
Get the scheduler.
+Thread-safe
+
+
|
+ +inlinenoexceptinherited | +
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
This is the complete list of members for agrpc::detail::ServerRPCContextBase< Responder >, including all inherited members.
+cancel() noexcept | agrpc::detail::ServerRPCContextBase< Responder > | inline |
context() | agrpc::detail::ServerRPCContextBase< Responder > | inline |
context() const | agrpc::detail::ServerRPCContextBase< Responder > | inline |
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
ServerRPC ServerContext base. + More...
+ +#include <agrpc/detail/server_rpc_context_base.hpp>
+Public Member Functions | |
+auto & | context () |
Get the underlying ServerContext | |
+const auto & | context () const |
Get the underlying ServerContext (const overload) | |
void | cancel () noexcept |
Cancel this RPC. | |
ServerRPC ServerContext base.
+
+
|
+ +inlinenoexcept | +
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
This is the complete list of members for agrpc::detail::ServerRPCNotifyWhenDoneMixin< IsNotifyWhenDone, Responder, Executor >, including all inherited members.
+cancel() noexcept | agrpc::detail::ServerRPCContextBase< Responder > | inline |
context() | agrpc::detail::ServerRPCContextBase< Responder > | inline |
context() const | agrpc::detail::ServerRPCContextBase< Responder > | inline |
executor_type typedef | agrpc::detail::RPCExecutorBase< Executor > | |
get_executor() const noexcept | agrpc::detail::RPCExecutorBase< Executor > | inline |
get_scheduler() const noexcept | agrpc::detail::RPCExecutorBase< Executor > | inline |
is_done() const noexcept | agrpc::detail::ServerRPCNotifyWhenDoneMixin< IsNotifyWhenDone, Responder, Executor > | inline |
wait_for_done(CompletionToken &&token=detail::DefaultCompletionTokenT< Executor >{}) | agrpc::detail::ServerRPCNotifyWhenDoneMixin< IsNotifyWhenDone, Responder, Executor > | inline |
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
ServerRPC NotifyWhenDone base. + More...
+ +#include <agrpc/detail/server_rpc_notify_when_done_mixin.hpp>
+Public Types | |
+using | executor_type = Executor |
The executor type. | |
+Public Member Functions | |
bool | is_done () const noexcept |
Is this rpc done? | |
template<class CompletionToken = detail::DefaultCompletionTokenT<Executor>> | |
auto | wait_for_done (CompletionToken &&token=detail::DefaultCompletionTokenT< Executor >{}) |
Wait for done. | |
const executor_type & | get_executor () const noexcept |
Get the executor. | |
const executor_type & | get_scheduler () const noexcept |
Get the scheduler. | |
+auto & | context () |
Get the underlying ServerContext | |
+const auto & | context () const |
Get the underlying ServerContext (const overload) | |
void | cancel () noexcept |
Cancel this RPC. | |
ServerRPC NotifyWhenDone base.
+
+
|
+ +inlinenodiscardnoexcept | +
Is this rpc done?
+Only available if Traits
contain NOTIFY_WHEN_DONE = true
.
Returns true if NotifyWhenDone has fired which indicates that finish()
has been called or that the rpc is dead (i.e., canceled, deadline expired, other side dropped the channel, etc).
Thread-safe
+ +
+
|
+ +inline | +
Wait for done.
+Only available if Traits
contain NOTIFY_WHEN_DONE = true
.
Request notification of the completion of this rpc, either due to calling finish()
or because the rpc is dead (i.e., canceled, deadline expired, other side dropped the channel, etc). rpc.context().IsCancelled() may only be called after this operation completes.
Cancelling this operation does not invoke grpc::ServerContext::TryCancel.
+Internally, this operation uses grpc::ServerContext::AsyncNotifyWhenDone.
+wait_for_done()
may be outstanding at a time.token | A completion token like asio::yield_context or agrpc::use_sender . The completion signature is void() . |
+
|
+ +inlinenodiscardnoexceptinherited | +
Get the executor.
+Thread-safe
+ +
+
|
+ +inlinenodiscardnoexceptinherited | +
Get the scheduler.
+Thread-safe
+
+
|
+ +inlinenoexceptinherited | +
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
+Directories | |
agrpc | |
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
This page explains how to interpret the graphs that are generated by doxygen.
+Consider the following example:
This will result in the following graph:
+The boxes in the above graph have the following meaning:
+The arrows have the following meaning:
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
Feature overview, installation and performance benchmark can be found on github.
+agrpc::GrpcContext
, agrpc::GrpcExecutor
.agrpc::ClientRPC
,agrpc::ServerRPC
, agrpc::register_awaitable_rpc_handler
, agrpc::register_yield_rpc_handler
, agrpc::register_sender_rpc_handler
, agrpc::register_callback_rpc_handler
agrpc::Alarm
asio::io_context
: agrpc::run
, agrpc::run_completion_queue
agrpc::HealthCheckService
agrpc::Waiter
protoc
from CMake to generate gRPC source files: CMake protobuf generate
+ asio-grpc v3.2.1
+
+ Asynchronous gRPC with Asio/unified executors
+ |
+
+ + |
+ + |
+ + |
+ + |
+ + |
+ + |
+ + |
+ + |
+ + |
+ + |
+ + |
+ + |
+ + |
+ + |
+ + |
+ + |
+ + |
+ + |
+ + |
+ + |
+ + |
+ + |
+ + |
+ + |
+ + |
+ + |
+ + |
+ + |
+ + |
+ + |
+ + |
+ + |
+ + |
+ + |
+ + |