net_entity.hpp

Go to the documentation of this file.

 
#ifndef NET_ENTITY_HPP_INCLUDED
#define NET_ENTITY_HPP_INCLUDED
 
 
#include <memory> // std::shared_ptr, std::weak_ptr
#include <cstddef> // std::size_t 
#include <utility> // std::move, std::forward
#include <variant>
#include <type_traits> // std::is_invocable
#include <system_error> // std::make_error, std::error_code
#include <string_view>
 
#include "nonstd/expected.hpp"
 
#include "net_ip/net_ip_error.hpp"
 
#include "net_ip/detail/tcp_acceptor.hpp"
#include "net_ip/detail/tcp_connector.hpp"
#include "net_ip/detail/udp_entity_io.hpp"
 
#include "net_ip/detail/wp_access.hpp"
 
#include "net_ip/io_type_decls.hpp"
 
namespace chops {
namespace net {
 
namespace detail {
// std::visit utility taken directly from cppreference
  template<class... Ts>
  struct overloaded : Ts... { using Ts::operator()...; };
}
 
class net_entity {
private:
  using udp_wp = detail::udp_entity_io_weak_ptr;
  using acc_wp = detail::tcp_acceptor_weak_ptr;
  using conn_wp = detail::tcp_connector_weak_ptr;
 
private:
  std::variant<udp_wp, acc_wp, conn_wp> m_wptr;
 
private:
  friend class net_ip;
 
public:
 
  net_entity () = default;
 
  net_entity(const net_entity&) = default;
  net_entity(net_entity&&) = default;
 
  net_entity& operator=(const net_entity&) = default;
  net_entity& operator=(net_entity&&) = default;
 
  template <typename ET>
  explicit net_entity (const std::shared_ptr<ET>& p) noexcept : m_wptr(p) { }
 
  bool is_valid() const noexcept {
    return std::visit([] (const auto& wp) { return !wp.expired(); }, m_wptr);
  }
 
  auto is_started() const -> 
          nonstd::expected<bool, std::error_code> {
    return std::visit(detail::overloaded {
        [] (const udp_wp& wp) -> nonstd::expected<bool, std::error_code> {
          return detail::wp_access<bool>(wp, 
                 [] (detail::udp_entity_io_shared_ptr sp) { return sp->is_started(); } );
        },
        [] (const acc_wp& wp) -> nonstd::expected<bool, std::error_code> {
          return detail::wp_access<bool>(wp,
                 [] (detail::tcp_acceptor_shared_ptr sp) { return sp->is_started(); } );
        },
        [] (const conn_wp& wp) -> nonstd::expected<bool, std::error_code> {
          return detail::wp_access<bool>(wp,
                 [] (detail::tcp_connector_shared_ptr sp) { return sp->is_started(); } );
        },
      },  m_wptr);
  }
 
  template <typename F>
  auto visit_socket(F&& func) const ->
          nonstd::expected<void, std::error_code> {
    return std::visit(detail::overloaded {
        [&func] (const udp_wp& wp) -> nonstd::expected<void, std::error_code> {
          if constexpr (std::is_invocable_v<F, asio::ip::udp::socket&>) {
            return detail::wp_access_void(wp,
                [&func] (detail::udp_entity_io_shared_ptr sp) { sp->visit_socket(func); return std::error_code(); } );
          }
          return nonstd::make_unexpected(std::make_error_code(net_ip_errc::functor_variant_mismatch));
        },
        [&func] (const acc_wp& wp) -> nonstd::expected<void, std::error_code> {
          if constexpr (std::is_invocable_v<F, asio::ip::tcp::acceptor&>) {
            return detail::wp_access_void(wp,
                [&func] (detail::tcp_acceptor_shared_ptr sp) { sp->visit_socket(func); return std::error_code(); } );
          }
          return nonstd::make_unexpected(std::make_error_code(net_ip_errc::functor_variant_mismatch));
        },
        [&func] (const conn_wp& wp) -> nonstd::expected<void, std::error_code> {
          if constexpr (std::is_invocable_v<F, asio::ip::tcp::socket&>) {
            return detail::wp_access_void(wp,
                [&func] (detail::tcp_connector_shared_ptr sp) { sp->visit_socket(func); return std::error_code(); } );
          }
          return nonstd::make_unexpected(std::make_error_code(net_ip_errc::functor_variant_mismatch));
        },
      },  m_wptr);
  }
 
  template <typename F>
  auto visit_io_output(F&& func) const ->
          nonstd::expected<std::size_t, std::error_code> {
    return std::visit(detail::overloaded {
        [&func] (const udp_wp& wp)-> nonstd::expected<std::size_t, std::error_code>  {
          if constexpr (std::is_invocable_v<F, chops::net::udp_io_output>) {
            return detail::wp_access<std::size_t>(wp,
                [&func] (detail::udp_entity_io_shared_ptr sp) { return sp->visit_io_output(func); } );
          }
          return nonstd::make_unexpected(std::make_error_code(net_ip_errc::functor_variant_mismatch));
        },
        [&func] (const acc_wp& wp)-> nonstd::expected<std::size_t, std::error_code>  {
          if constexpr (std::is_invocable_v<F, chops::net::tcp_io_output>) {
            return detail::wp_access<std::size_t>(wp,
                [&func] (detail::tcp_acceptor_shared_ptr sp) { return sp->visit_io_output(func); } );
          }
          return nonstd::make_unexpected(std::make_error_code(net_ip_errc::functor_variant_mismatch));
        },
        [&func] (const conn_wp& wp)-> nonstd::expected<std::size_t, std::error_code>  {
          if constexpr (std::is_invocable_v<F, chops::net::tcp_io_output>) {
            return detail::wp_access<std::size_t>(wp,
                [&func] (detail::tcp_connector_shared_ptr sp) { return sp->visit_io_output(func); } );
          }
          return nonstd::make_unexpected(std::make_error_code(net_ip_errc::functor_variant_mismatch));
        },
      },  m_wptr);
  }
 
  template <typename F1, typename F2>
  auto start(F1&& io_state_chg_func, F2&& err_func) ->
          nonstd::expected<void, std::error_code> {
    return std::visit(detail::overloaded {
        [&io_state_chg_func, &err_func] (const udp_wp& wp)->nonstd::expected<void, std::error_code> {
          if constexpr (std::is_invocable_v<F1, udp_io_interface, std::size_t, bool> &&
                        std::is_invocable_v<F2, udp_io_interface, std::error_code>) {
            return detail::wp_access_void(wp,
                [&io_state_chg_func, &err_func] (detail::udp_entity_io_shared_ptr sp) 
                  { return sp->start(io_state_chg_func, err_func); } );
          }
          return nonstd::make_unexpected(std::make_error_code(net_ip_errc::functor_variant_mismatch));
        },
        [&io_state_chg_func, &err_func] (const acc_wp& wp)->nonstd::expected<void, std::error_code> {
          if constexpr (std::is_invocable_v<F1, tcp_io_interface, std::size_t, bool> &&
                        std::is_invocable_v<F2, tcp_io_interface, std::error_code>) {
            return detail::wp_access_void(wp,
                [&io_state_chg_func, &err_func] (detail::tcp_acceptor_shared_ptr sp) 
                  { return sp->start(io_state_chg_func, err_func); } );
          }
          return nonstd::make_unexpected(std::make_error_code(net_ip_errc::functor_variant_mismatch));
        },
        [&io_state_chg_func, &err_func] (const conn_wp& wp)->nonstd::expected<void, std::error_code> {
          if constexpr (std::is_invocable_v<F1, tcp_io_interface, std::size_t, bool> &&
                        std::is_invocable_v<F2, tcp_io_interface, std::error_code>) {
            return detail::wp_access_void(wp,
                [&io_state_chg_func, &err_func] (detail::tcp_connector_shared_ptr sp) 
                  { return sp->start(io_state_chg_func, err_func); } );
          }
          return nonstd::make_unexpected(std::make_error_code(net_ip_errc::functor_variant_mismatch));
        },
      },  m_wptr);
  }
 
  auto stop() ->
          nonstd::expected<void, std::error_code> {
    return std::visit(detail::overloaded {
        [] (const udp_wp& wp)->nonstd::expected<void, std::error_code> {
          return detail::wp_access_void(wp, 
              [] (detail::udp_entity_io_shared_ptr sp) { return sp->stop(); } );
        },
        [] (const acc_wp& wp)->nonstd::expected<void, std::error_code> {
          return detail::wp_access_void(wp, 
              [] (detail::tcp_acceptor_shared_ptr sp) { return sp->stop(); } );
        },
        [] (const conn_wp& wp)->nonstd::expected<void, std::error_code> {
          return detail::wp_access_void(wp, 
              [] (detail::tcp_connector_shared_ptr sp) { return sp->stop(); } );
        },
      },  m_wptr);
  }
 
  std::string_view stream_out() const noexcept {
    return std::visit(detail::overloaded {
        [] (const udp_wp& wp) { return "[UDP network entity]"; },
        [] (const acc_wp& wp) { return "[TCP acceptor network entity]"; },
        [] (const conn_wp& wp) { return "[TCP connector network entity]"; },
      },  m_wptr);
  }
 
  friend bool operator==(const net_entity&, const net_entity&) noexcept;
  friend bool operator<(const net_entity&, const net_entity&) noexcept;
 
};
 
inline bool operator==(const net_entity& lhs, const net_entity& rhs) noexcept {
  return std::visit(detail::overloaded {
    [] (const net_entity::udp_wp& lwp, const net_entity::udp_wp& rwp) {
          return lwp.lock() == rwp.lock();
        },
    [] (const net_entity::udp_wp& lwp, const net_entity::acc_wp& rwp) {
          return false;
        },
    [] (const net_entity::udp_wp& lwp, const net_entity::conn_wp& rwp) {
          return false;
        },
    [] (const net_entity::acc_wp& lwp, const net_entity::acc_wp& rwp) {
          return lwp.lock() == rwp.lock();
        },
    [] (const net_entity::acc_wp& lwp, const net_entity::udp_wp& rwp) {
          return false;
        },
    [] (const net_entity::acc_wp& lwp, const net_entity::conn_wp& rwp) {
          return false;
        },
    [] (const net_entity::conn_wp& lwp, const net_entity::conn_wp& rwp) {
          return lwp.lock() == rwp.lock();
        },
    [] (const net_entity::conn_wp& lwp, const net_entity::udp_wp& rwp) {
          return false;
        },
    [] (const net_entity::conn_wp& lwp, const net_entity::acc_wp& rwp) {
          return false;
        },
    }, lhs.m_wptr, rhs.m_wptr);
}
 
inline bool operator<(const net_entity& lhs, const net_entity& rhs) noexcept {
  return std::visit(detail::overloaded {
    [] (const net_entity::udp_wp& lwp, const net_entity::udp_wp& rwp) {
          return lwp.lock() < rwp.lock();
        },
    [] (const net_entity::udp_wp& lwp, const net_entity::acc_wp& rwp) {
          return true;
        },
    [] (const net_entity::udp_wp& lwp, const net_entity::conn_wp& rwp) {
          return true;
        },
    [] (const net_entity::acc_wp& lwp, const net_entity::acc_wp& rwp) {
          return lwp.lock() < rwp.lock();
        },
    [] (const net_entity::acc_wp& lwp, const net_entity::udp_wp& rwp) {
          return false;
        },
    [] (const net_entity::acc_wp& lwp, const net_entity::conn_wp& rwp) {
          return true;
        },
    [] (const net_entity::conn_wp& lwp, const net_entity::conn_wp& rwp) {
          return lwp.lock() < rwp.lock();
        },
    [] (const net_entity::conn_wp& lwp, const net_entity::udp_wp& rwp) {
          return false;
        },
    [] (const net_entity::conn_wp& lwp, const net_entity::acc_wp& rwp) {
          return false;
        },
    }, lhs.m_wptr, rhs.m_wptr);
  }
 
template <typename IOT>
void empty_error_func(basic_io_interface<IOT>, std::error_code) { } 
 
inline void tcp_empty_error_func(tcp_io_interface, std::error_code) { }
 
inline void udp_empty_error_func(udp_io_interface, std::error_code) { }
 
 
} // end net namespace
} // end chops namespace
 
#endif