stream.hpp

Go to the documentation of this file.

#pragma once
 
/// @file userver/ugrpc/server/stream.hpp
/// @brief Server streaming interfaces
 
#include <grpcpp/server_context.h>
 
USERVER_NAMESPACE_BEGIN
 
namespace ugrpc::server {
 
/// @brief Interface to read client's requests.
///
/// This class is not thread-safe.
///
/// If any method throws, further methods must not be called on the same stream.
template <class Request>
class Reader {
public:
    /// @cond
    virtual ~Reader() = default;
    /// @endcond
 
    /// @brief Await and read the next incoming message
    /// @param request where to put the request on success
    /// @returns `true` on success, `false` on end-of-input
    /// @throws ugrpc::server::RpcError on an RPC error
    [[nodiscard]] virtual bool Read(Request& request) = 0;
};
 
/// @brief Interface to write server's responses.
///
/// This class is not thread-safe.
///
/// If any method throws, further methods must not be called on the same stream.
template <class Response>
class Writer {
public:
    /// @cond
    virtual ~Writer() = default;
    /// @endcond
 
    /// @brief Write the next outgoing message
    /// @param response the next message to write
    /// @throws ugrpc::server::RpcError on an RPC error
    /// @throws std::exception (internal) on error from middlewares
    ///
    /// This method uses move-only semantics for safety:
    /// - Middlewares may modify responses during writes, making reuse dangerous
    /// - After the call, `response` is in moved-from state and must not be reused
    /// - Explicit std::move ensures ownership transfer and prevents accidental reuse
    virtual void Write(Response&& response) = 0;
 
    /// @brief Write the next outgoing message
    /// @param response the next message to write
    /// @param options the write options
    /// @throws ugrpc::server::RpcError on an RPC error
    /// @throws std::exception (internal) on error from middlewares
    ///
    /// This method uses move-only semantics for safety:
    /// - Middlewares may modify responses during writes, making reuse dangerous
    /// - After the call, `response` is in moved-from state and must not be reused
    /// - Explicit std::move ensures ownership transfer and prevents accidental reuse
    virtual void Write(Response&& response, const grpc::WriteOptions& options) = 0;
};
 
/// @brief Interface to both read and write messages.
///
/// If any method throws, further methods must not be called on the same stream.
///
/// This class allows the following concurrent calls:
///
///   - `Read`;
///   - `Write`
///
/// and there can only be one Read and one Write in flight at a time.
///
/// If any method throws, further methods must not be called on the same stream.
template <class Request, class Response>
class ReaderWriter : public Reader<Request>, public Writer<Response> {};
 
}  // namespace ugrpc::server
 
USERVER_NAMESPACE_END