.. _program_listing_file_NetioReceiver.cpp:

Program Listing for File NetioReceiver.cpp
==========================================

|exhale_lsh| :ref:`Return to documentation for file <file_NetioReceiver.cpp>` (``NetioReceiver.cpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #include "netio3/NetioReceiver.hpp"
   
   #include <stdexcept>
   #include <memory>
   #include <utility>
   
   #include <netio3-backend/EventLoop/BaseEventLoop.hpp>
   #include <netio3-backend/Netio3Backend.hpp>
   
   #include "netio3/BufferFormatter.hpp"
   
   using namespace netio3;
   
   NetioReceiver::NetioReceiver(const NetioReceiverConfig& config,
                                std::shared_ptr<BaseEventLoop> evloop) :
       m_backend_type{config.backend_type},
       m_backend(NetworkBackend::create(
                     m_backend_type,
                     {
                         .mode=config.backend_mode,
                         .thread_safety = config.thread_safety,
                         .callbacks{
                           .on_data_cb = [this] (std::span<const uint8_t> data){
                               on_data(data);},
                           .on_connection_established_cb = [this] (
                               const EndPointAddress& ep, const EndPointAddress&, EndpointCapabilities) {
                               connection_established(ep);},
                           .on_connection_closed_cb = [this] (
                               const EndPointAddress& ep, const std::vector<std::uint64_t>& /* keys */) {connection_closed(ep);}
                           }
                     },
                     evloop)) {
       ERS_DEBUG(5, "Entered");
   }
   
   NetioReceiver::~NetioReceiver() {
       ERS_DEBUG(5, "Entered "
              << " now have " << m_listeners.size() << " listeners");
       for (auto con : m_listeners) {
           ERS_DEBUG(1, "Closing handle: " << con << "");
           try {
               m_backend->close_listen_endpoint(con);
           }
           catch(const std::invalid_argument& exc) {
               continue;
           }
       }
       ERS_DEBUG(5, "Finished");
   }
   
   unsigned short NetioReceiver::listen(const EndPointAddress& ep, const ConnectionParametersRecv& conn_params) {
       auto epaddr = m_backend->open_listen_endpoint(ep, {.recv_params{conn_params}});
       m_listeners.insert(epaddr);
       ERS_DEBUG(6, " now have " << m_listeners.size() << " listeners");
   
       return epaddr.port();
   }
   
   void NetioReceiver::close(const EndPointAddress& ep) {
       m_backend->close_listen_endpoint(ep);
       m_listeners.erase(ep);
       ERS_DEBUG(6, " now have " << m_listeners.size() << " listeners");
   }
   
   void NetioReceiver::on_data(std::span<const uint8_t> data) {
       ERS_DEBUG(6, " Recieved data of size " << data.size());
       if (m_on_buffer_cb) {
           m_on_buffer_cb(data);
       }
       if (m_on_data_cb) {
           BufferFormatter::decode(data, m_on_data_cb);
       }
   }
   
   void NetioReceiver::connection_established(const EndPointAddress& ep) {
       m_on_connection_established_cb(ep);
   }
   void NetioReceiver::connection_closed(const EndPointAddress& ep) {
       m_on_connection_closed_cb(ep);
   }
   
   void NetioReceiver::set_on_data_cb (CbMessageReceived cb) {
       m_on_data_cb = std::move(cb);
   }
   
   void NetioReceiver::set_on_buffer_cb (CbBufferReceived cb) {
       m_on_buffer_cb = std::move(cb);
   }
   
   void NetioReceiver::set_on_connection_established_cb (OnConnectionEstablishedSimpleCb cb) {
       m_on_connection_established_cb = std::move(cb);
   }
   void NetioReceiver::set_on_connection_closed_cb (OnConnectionClosedCb cb) {
       m_on_connection_closed_cb = std::move(cb);
   }