io_state_change.hpp

Go to the documentation of this file.

 
#ifndef IO_STATE_CHANGE_HPP_INCLUDED
#define IO_STATE_CHANGE_HPP_INCLUDED
 
#include <cstddef> // std::size_t, std::byte
#include <utility> // std::move
 
#include "asio/ip/udp.hpp" // ip::udp::endpoint
 
#include "net_ip/io_type_decls.hpp"
 
#include "net_ip/simple_variable_len_msg_frame.hpp"
 
namespace chops {
namespace net {
 
template <typename MH>
auto make_simple_variable_len_msg_frame_io_state_change (std::size_t hdr_size, 
                                                         MH&& msg_hdlr,
                                                         hdr_decoder_func hdr_func) {
  return [hdr_size, hdr_func, mh = std::move(msg_hdlr)] 
                  (tcp_io_interface io, std::size_t num, bool starting) {
    if (starting) {
      io.start_io(hdr_size, std::move(mh), hdr_func);
    }
  };
}
 
template <typename MH, typename MF>
auto make_msg_frame_io_state_change (std::size_t hdr_size, 
                                     MH&& msg_hdlr,
                                     MF&& msg_frame) {
  return [hdr_size, mh = std::move(msg_hdlr), mf = std::move(msg_frame)] 
                  (tcp_io_interface io, std::size_t num, bool starting) {
    if (starting) {
      io.start_io(hdr_size, std::move(mh), std::move(mf));
    }
  };
}
 
template <typename MH>
auto make_delimiter_read_io_state_change (std::string_view delim, MH&& msg_hdlr) {
  return [delim, mh = std::move(msg_hdlr)] 
                  (tcp_io_interface io, std::size_t num, bool starting) {
    if (starting) {
      io.start_io(delim, std::move(mh));
    }
  };
}
 
template <typename MH, typename IOT = udp_io>
auto make_read_io_state_change (std::size_t rd_size, MH&& msg_hdlr) {
  return [rd_size, mh = std::move(msg_hdlr)] 
                  (basic_io_interface<IOT> io, std::size_t num, bool starting) {
    if (starting) {
      io.start_io(rd_size, std::move(mh));
    }
  };
}
 
template <typename IOT>
auto make_send_only_io_state_change () {
  return [] (basic_io_interface<IOT> io, std::size_t num, bool starting) {
    if (starting) {
      io.start_io();
    }
  };
}
 
template <typename MH>
auto make_default_endp_io_state_change (const asio::ip::udp::endpoint& endp,
                                        std::size_t max_size,
                                        MH&& msg_hdlr) {
  return [max_size, endp, mh = std::move(msg_hdlr)] 
                  (udp_io_interface io, std::size_t num, bool starting) {
    if (starting) {
      io.start_io(endp, max_size, std::move(mh));
    }
  };
}
 
inline
auto make_send_only_default_endp_io_state_change (const asio::ip::udp::endpoint& endp) {
  return [endp] (udp_io_interface io, std::size_t num, bool starting) {
    if (starting) {
      io.start_io(endp);
    }
  };
}
 
} // end net namespace
} // end chops namespace
 
#endif