docs_dir: pages

site_name: rpclib

- 'Home': 'index.md'

- 'Guides':

- 'Getting started': 'gettingstarted.md'

- toc:

permalink: False

baselevel: 2

- admonition

- attr_list

- codehilite

| void | [wait_all_responses](#classrpc_1_1client_1ac37437bc05b70588c079079b957eb15f)()

```cpp

rpc::client::client(std::string const &addr, uint16_t port);

```

When a client is constructed, it initiates a connection asynchronically. This means that it will not block while the connection is established. However, when the first call is performed, it *might* block if the connection was not already established.

```cpp

rpc::client::~client();

```

During destruction, the connection to the server is gracefully closed. This means that any outstanding reads and writes are completed first.

```cpp

RPCLIB_MSGPACK::object_handle rpc::client::call(std::string const &func_name, Args... args);

```

A RPCLIB_MSGPACK::object containing the result of the function (if any). To obtain a typed value, use the msgpack API.

```cpp

std::future< RPCLIB_MSGPACK::object_handle > rpc::client::async_call(std::string const &func_name, Args... args);

```

A std::future, possibly holding a future result (which is a RPCLIB_MSGPACK::object).

```cpp

void rpc::client::send(std::string const &func_name, Args... args);

```

!!! warn

This function returns immediately (possibly before the notification is written to the socket).

```cpp

nonstd::optional< int64_t > rpc::client::get_timeout() const;

```

!!! warn

The timeout has no effect on async calls. For those, the preferred timeout mechanism remains using std::future.

```cpp

void rpc::client::set_timeout(int64_t value);

```

Sets the timeout for synchronous calls. For more information, see

```cpp

void rpc::client::clear_timeout();

```

Clears the timeout for synchronous calls. For more information, see

```cpp

connection_state rpc::client::get_connection_state() const;

```

Returns the current connection state.

```cpp

void rpc::client::wait_all_responses();

```

| RPCLIB_MSGPACK::object_handle & | [get_error](#classrpc_1_1rpc__error_1a88ab8f211393ae62813042a797c08663)()

```cpp

std::string rpc::rpc_error::get_function_name() const;

```

Returns the name of the function that was called on the server while the error occurred.

```cpp

RPCLIB_MSGPACK::object_handle & rpc::rpc_error::get_error();

```

| void | [close_sessions](#classrpc_1_1server_1abf6bebbbeea52451aef2126d29240094)()

```cpp

rpc::server::server(uint16_t port);

```

`port` The port number to listen on.

```cpp

rpc::server::server(server &&other) noexcept;

```

`other` The other instance to move from.

```cpp

rpc::server::server(std::string const &address, uint16_t port);

```

`port` The port number to listen on.

```cpp

rpc::server::~server();

```

When the server is destroyed, all ongoin sessions are closed gracefully.

```cpp

server rpc::server::operator=(server &&other);

```

The result of the assignment.

```cpp

void rpc::server::run();

```

First and foremost, running the event loop causes the server to start listening on the specified port. Also, as connections are established and calls are made by clients, the server executes the calls as part of this call. This means that the handlers are executed on the thread that calls `run`. Reads and writes are initiated by this function internally as well.

```cpp

void rpc::server::async_run(std::size_t worker_threads=1);

```

This function behaves similarly to `run`, except the event loop is optionally started on different threads. Effectively this sets up a worker thread pool for the server. Handlers will be executed on one of the threads.

```cpp

void rpc::server::bind(std::string const &name, F func);

```

This function template accepts a wide range of callables. The arguments and return types of these callables should be serializable by msgpack. `bind` effectively generates a suitable, light-weight compile-time wrapper for the functor.

```cpp

void rpc::server::suppress_exceptions(bool suppress);

```

!!! warn

Setting this flag only affects subsequent connections.

```cpp

void rpc::server::stop();

```

!!! warn

This should not be called from worker threads.

```cpp

void rpc::server::close_sessions();

```

| void | [clear](#classrpc_1_1this__handler__t_1a0a53e27b4d8d5b542790b218029d26f4)()

```cpp

void rpc::this_handler_t::respond_error(T &&err_obj);

```

`err_obj` The error object. This can be anything that is possible to encode with messagepack (even custom structures).

```cpp

void rpc::this_handler_t::respond(T &&resp_obj);

```

!!! warn

The normal return value of the function (if any) will be ignored if a special response is set.

```cpp

void rpc::this_handler_t::disable_response();

```

!!! warn

It is unusual to not send a response to requests, and doing so might cause problems in the client (depending on its implementation).

```cpp

void rpc::this_handler_t::enable_response();

```

Enables sending a response to the call. Sending the response is by default enabled. Enabling the response multiple times have no effect.

```cpp

void rpc::this_handler_t::clear();

```

| void | [cancel_stop](#classrpc_1_1this__server__t_1a127035c6f2281a5a1bfadf19f4dfe451)()

```cpp

void rpc::this_server_t::stop();

```

Gracefully stops the server.

```cpp

void rpc::this_server_t::cancel_stop();

```

| session_id_t | [id](#classrpc_1_1this__session__t_1aada2250ec9dd3d88781ca16eb4352047)() const

```cpp

void rpc::this_session_t::post_exit();

```

!!! warn

Use this function if you need to close the connection from a handler.

```cpp

session_id_t rpc::this_session_t::id() const;

```

| const char * | [what](#classrpc_1_1timeout_1ad782f083798c650188b5927a226c3b04)() const noexcept override

```cpp

const char * rpc::timeout::what() const noexcept override;

```