basic_io_interface.hpp

Go to the documentation of this file.

 
#ifndef BASIC_IO_INTERFACE_HPP_INCLUDED
#define BASIC_IO_INTERFACE_HPP_INCLUDED
 
#include <memory> // std::weak_ptr, std::shared_ptr
#include <string_view>
#include <system_error>
#include <cstddef> // std::size_t, std::byte
#include <utility> // std::forward, std::move
 
#include "nonstd/expected.hpp"
 
#include "net_ip/net_ip_error.hpp"
#include "net_ip/basic_io_output.hpp"
 
#include "net_ip/simple_variable_len_msg_frame.hpp"
 
#include "net_ip/detail/wp_access.hpp"
 
namespace chops {
namespace net {
 
template <typename IOT>
class basic_io_interface {
private:
  std::weak_ptr<IOT> m_ioh_wptr;
 
public:
  using endpoint_type = typename IOT::endpoint_type;
 
public:
 
  basic_io_interface() = default;
 
  basic_io_interface(const basic_io_interface&) = default;
  basic_io_interface(basic_io_interface&&) = default;
 
  basic_io_interface<IOT>& operator=(const basic_io_interface&) = default;
  basic_io_interface<IOT>& operator=(basic_io_interface&&) = default;
  
  explicit basic_io_interface(std::weak_ptr<IOT> p) noexcept : m_ioh_wptr(p) { }
 
  bool is_valid() const noexcept { return !m_ioh_wptr.expired(); }
 
  auto make_io_output() const ->
        nonstd::expected<basic_io_output<IOT>, std::error_code> {
    return detail::wp_access<basic_io_output<IOT>>( m_ioh_wptr, 
          [] (std::shared_ptr<IOT> sp) { return basic_io_output<IOT>(sp); } );
  }
 
  auto is_io_started() const ->
        nonstd::expected<bool, std::error_code> {
    return detail::wp_access<bool>( m_ioh_wptr, 
          [] (std::shared_ptr<IOT> sp) { return sp->is_io_started(); } );
  }
 
  template <typename F>
  auto visit_socket(F&& func) ->
        nonstd::expected<void, std::error_code> {
    return detail::wp_access_void( m_ioh_wptr, [&func] (std::shared_ptr<IOT> sp) {
            sp->visit_socket(func); return std::error_code { }; } );
  }
 
  template <typename MH, typename MF>
  auto start_io(std::size_t header_size, MH&& msg_handler, MF&& msg_frame) ->
        nonstd::expected<void, std::error_code> {
    return detail::wp_access_void( m_ioh_wptr,
                [header_size, &msg_handler, &msg_frame] (std::shared_ptr<IOT> sp) {
            return sp->start_io(header_size, msg_handler, msg_frame) ? std::error_code() :
                                std::make_error_code(net_ip_errc::io_already_started);
        } );
  }
 
  template <typename MH>
  auto start_io(std::size_t header_size, MH&& msg_handler, hdr_decoder_func func) ->
        nonstd::expected<void, std::error_code> {
    return detail::wp_access_void( m_ioh_wptr,
                [header_size, &msg_handler, func] (std::shared_ptr<IOT> sp) {
            return sp->start_io(header_size, msg_handler, func) ? std::error_code() :
                                std::make_error_code(net_ip_errc::io_already_started);
        } );
  }
 
  template <typename MH>
  auto start_io(std::string_view delimiter, MH&& msg_handler) ->
        nonstd::expected<void, std::error_code> {
    return detail::wp_access_void( m_ioh_wptr,
                [delimiter, &msg_handler] (std::shared_ptr<IOT> sp) {
            return sp->start_io(delimiter, msg_handler) ? std::error_code() :
                                std::make_error_code(net_ip_errc::io_already_started);
        } );
  }
 
  template <typename MH>
  auto start_io(std::size_t read_size, MH&& msg_handler) ->
        nonstd::expected<void, std::error_code> {
    return detail::wp_access_void( m_ioh_wptr,
                [read_size, &msg_handler] (std::shared_ptr<IOT> sp) {
            return sp->start_io(read_size, msg_handler) ? std::error_code() :
                                std::make_error_code(net_ip_errc::io_already_started);
        } );
  }
 
  template <typename MH>
  auto start_io(const endpoint_type& endp, std::size_t max_size, MH&& msg_handler) ->
        nonstd::expected<void, std::error_code> {
    return detail::wp_access_void( m_ioh_wptr,
                [endp, max_size, &msg_handler] (std::shared_ptr<IOT> sp) {
            return sp->start_io(endp, max_size, msg_handler) ? std::error_code() :
                                std::make_error_code(net_ip_errc::io_already_started);
        } );
  }
 
  auto start_io() ->
        nonstd::expected<void, std::error_code> {
    return detail::wp_access_void( m_ioh_wptr,
                [] (std::shared_ptr<IOT> sp) {
            return sp->start_io() ? std::error_code() :
                                std::make_error_code(net_ip_errc::io_already_started);
        } );
  }
 
  auto start_io(const endpoint_type& endp) ->
        nonstd::expected<void, std::error_code> {
    return detail::wp_access_void( m_ioh_wptr,
                [endp] (std::shared_ptr<IOT> sp) {
            return sp->start_io(endp) ? std::error_code() :
                                std::make_error_code(net_ip_errc::io_already_started);
        } );
  }
 
  auto stop_io() ->
        nonstd::expected<void, std::error_code> {
    return detail::wp_access_void( m_ioh_wptr,
                [] (std::shared_ptr<IOT> sp) {
            return sp->stop_io() ? std::error_code() :
                                std::make_error_code(net_ip_errc::io_already_stopped);
        } );
  }
 
  bool operator==(const basic_io_interface<IOT>& rhs) const noexcept {
    return (m_ioh_wptr.lock() == rhs.m_ioh_wptr.lock());
  }
 
  bool operator<(const basic_io_interface<IOT>& rhs) const noexcept {
    return (m_ioh_wptr.lock() < rhs.m_ioh_wptr.lock());
  }
 
  const void* get_ptr() const noexcept {
    return static_cast<const void*>(m_ioh_wptr.lock().get());
  }
 
};
 
} // end net namespace
} // end chops namespace
 
#endif