pars::net::op Class Reference

#include <op.h>

Public Member Functions
	~op ()
	operator bool ()
template<ev::event_c event_t, tool_c tool_t>
void	send (ev::enqueuer &r, tool_t &t, pipe p, event_t ev)
template<tool_c tool_t>
void	recv (ev::enqueuer &r, tool_t &t)
void	sleep (nng_duration ms, std::function< void()> f)
void	reset_sleep (nng_duration ms)
std::error_code	result () const
	return result of asynchronous operation
void	abort (nngxx::err err)
	abort asynchronous I/O operation
void	cancel ()
	cancel asynchronous I/O operation
void	wait () const
	wait for asynchronous I/O operation
void	stop ()
	stop asynchronous I/O operation

Detailed Description

Definition at line 53 of file op.h.

Constructor & Destructor Documentation

~op()

pars::net::op::~op ( )

inline

Definition at line 56 of file op.h.

  {
    if (aio_m)
      aio_m.wait();
  }

Member Function Documentation

abort()

void pars::net::op::abort ( nngxx::err err )

inline

abort asynchronous I/O operation

Parameters

err

The abort() function aborts an operation previously started with the handle aio.

If the operation is aborted, then the callback for the handle will be called, and the function result() will return the error err.

Definition at line 194 of file op.h.

{ aio_m.abort(err); }

References pars::err().

Here is the call graph for this function:

cancel()

void pars::net::op::cancel ( )

inline

cancel asynchronous I/O operation

The nng_aio_cancel() function aborts an operation previously started with the handle aio. If the operation is aborted, then the callback for the handle will be called, and the function nng_aio_result() will return the error NNG_ECANCELED.

This function does not wait for the operation to be fully aborted, but returns immediately.

If no operation is currently in progress (either because it has already finished, or no operation has been started yet), then this function has no effect.

Same as abort(nngxx::error::canceled)

Definition at line 213 of file op.h.

{ aio_m.cancel(); }

operator bool()

pars::net::op::operator bool ( )

inlineexplicit

Definition at line 62 of file op.h.

{ return static_cast<bool>(aio_m); }

recv()

template<tool_c tool_t>

void pars::net::op::recv ( ev::enqueuer & r, tool_t & t )

inline

Definition at line 107 of file op.h.

  {
    pars::debug(SL, lf::net, "{}: Receive Message!", f::pntl{{}, t});
 
    // replace the operation with the new one
    cb_m = [&](clev::expected<void> res, nngxx::msg m) {
      if (res)
      {
        // NOTE: m is not empty on success
 
        auto pv = m.get_pipe();
 
        pars::debug(SL, lf::net, "{}: Received Message! [{}]", f::pntl{pv, t},
                    m);
 
        r.queue_received(std::move(m), t.socket_id(), t, pv);
      }
      else
      {
        // NOTE: m is empty on failure
 
        auto pv = nngxx::pipe_view();
 
        pars::err(SL, lf::net, "{}: Error Receiving! [{}]", f::pntl{pv, t},
                  res.error());
 
        r.queue_fire(ev::network_error{res.error(), dir::in}, t.socket_id(), t,
                     pv);
      }
    };
 
    // make aio - NOTE: pass this, cant move op
    aio_m = nngxx::make_aio(op::recv_cb, this).value_or_abort();
 
    // start recv
    t.recv_aio(aio_m);
  }

References pars::debug(), pars::err(), pars::net::in, pars::net, pars::ev::enqueuer::queue_fire(), pars::ev::enqueuer::queue_received(), and SL.

Here is the call graph for this function:

reset_sleep()

void pars::net::op::reset_sleep ( nng_duration ms )

inline

Definition at line 161 of file op.h.

  {
    stop();
 
    // make aio - NOTE: pass this, cant move op
    aio_m = nngxx::make_aio(op::sleep_cb, this).value_or_abort();
 
    nngxx::sleep(ms, aio_m);
  }

References stop().

Here is the call graph for this function:

result()

std::error_code pars::net::op::result ( ) const

inline

return result of asynchronous operation

Returns

The nng_aio_result() returns the result of the operation associated with the handle aio. If the operation was successful, then 0 is returned. Otherwise a non-zero error code is returned.

Definition at line 179 of file op.h.

  {
    return aio_m.result().error_or(nngxx::err::success);
  }

References nngxx::success.

send()

template<ev::event_c event_t, tool_c tool_t>

void pars::net::op::send ( ev::enqueuer & r, tool_t & t, pipe p, event_t ev )

inline

Definition at line 65 of file op.h.

  {
    auto m = ev::serialize::to_network(ev);
 
    if (p)
      m.set_pipe(p);
 
    pars::debug(SL, lf::net, "{}: Send Message [{}]!", f::pntl{p, t}, m);
 
    // replace the callback with the new one
    cb_m = [&, p](clev::expected<void> res, nngxx::msg m) mutable {
      if (res)
      {
        // NOTE: m is empty on success
 
        pars::debug(SL, lf::net, "{}: Sent Event [{}]!", f::pntl{p, t}, ev);
 
        r.queue_sent(std::move(ev), t.socket_id(), t, p);
      }
      else
      {
        // NOTE: m is not empty on failure
 
        auto pv = m.get_pipe();
 
        pars::err(SL, lf::net, "{}: Error Sending {}! [msg:{},err:{}]",
                  f::pntl{pv, t}, nametype(ev), m, res.error());
 
        r.queue_fire(ev::network_error{res.error(), dir::out}, t.socket_id(), t,
                     pv);
      }
    };
 
    // make aio - NOTE: pass this, cant move op
    aio_m = nngxx::make_aio(op::send_cb, this).value_or_abort();
 
    // start send
    aio_m.set_msg(std::move(m));
    t.send_aio(aio_m);
  }

References pars::debug(), pars::err(), nametype(), pars::net, pars::net::out, pars::ev::enqueuer::queue_fire(), pars::ev::enqueuer::queue_sent(), SL, and pars::ev::serialize::to_network().

Here is the call graph for this function:

sleep()

void pars::net::op::sleep ( nng_duration ms, std::function< void()> f )

inline

Definition at line 145 of file op.h.

  {
    cb_m = [&, f](clev::expected<void> res, nngxx::msg m) {
      if (res)
      {
        // the sleep completed successfully, execute f
        f();
      }
    };
 
    // make aio - NOTE: pass this, cant move op
    aio_m = nngxx::make_aio(op::sleep_cb, this).value_or_abort();
 
    nngxx::sleep(ms, aio_m);
  }

stop()

void pars::net::op::stop ( )

inline

stop asynchronous I/O operation

The stop() function stops the asynchronous I/O operation associated with aio by aborting with NNG_ECANCELED, and then waits for it to complete or to be completely aborted, and for the callback associated with the aio to have completed executing.

Same as cancel() + wait().

Definition at line 234 of file op.h.

{ aio_m.stop(); }

Referenced by reset_sleep().

Here is the caller graph for this function:

wait()

void pars::net::op::wait ( ) const

inline

wait for asynchronous I/O operation

The nng_aio_wait() function waits for an asynchronous I/O operation to complete. If the operation has not been started, or has already completed, then it returns immediately.

Definition at line 222 of file op.h.

{ aio_m.wait(); }

---

The documentation for this class was generated from the following file:

• /home/runner/work/pars-cxx/pars-cxx/lib/include/pars/net/op.h