net_ip.hpp

Go to the documentation of this file.

 
#ifndef NET_IP_HPP_INCLUDED
#define NET_IP_HPP_INCLUDED
 
#include <memory> // std::shared_ptr
#include <cstddef> // std::size_t
#include <string_view>
#include <vector>
#include <chrono>
#include <variant> // std::visit
#include <type_traits> // std::enable_if
 
#include <mutex> // std::scoped_lock, std::mutex
 
#include "asio/io_context.hpp"
#include "asio/ip/tcp.hpp"
#include "asio/ip/udp.hpp"
 
#include "net_ip/net_ip_error.hpp"
#include "net_ip/net_entity.hpp"
 
#include "net_ip/detail/tcp_connector.hpp"
#include "net_ip/detail/tcp_acceptor.hpp"
#include "net_ip/detail/udp_entity_io.hpp"
 
#include "net_ip/tcp_connector_timeout.hpp"
 
namespace chops {
namespace net {
 
class net_ip {
private:
 
  asio::io_context&                             m_ioc;
  mutable std::mutex                            m_mutex;
 
  std::vector<detail::tcp_acceptor_shared_ptr>  m_acceptors;
  std::vector<detail::tcp_connector_shared_ptr> m_connectors;
  std::vector<detail::udp_entity_io_shared_ptr> m_udp_entities;
 
private:
  using lg = std::scoped_lock<std::mutex>;
 
public:
 
  explicit net_ip(asio::io_context& ioc) :
    m_ioc(ioc), m_acceptors(), m_connectors(), m_udp_entities() { }
 
private:
 
  net_ip() = delete;
  net_ip(const net_ip&) = delete;
  net_ip(net_ip&&) = delete;
  net_ip& operator=(const net_ip&) = delete;
  net_ip& operator=(net_ip&&) = delete;
 
public:
 
  net_entity make_tcp_acceptor (std::string_view local_port_or_service, 
                                std::string_view listen_intf = "",
                                bool reuse_addr = true) {
    auto p = std::make_shared<detail::tcp_acceptor>(m_ioc, local_port_or_service, 
                                                    listen_intf, reuse_addr);
    lg g(m_mutex);
    m_acceptors.push_back(p);
    return net_entity(p);
  }
 
  net_entity make_tcp_acceptor (const asio::ip::tcp::endpoint& endp,
                                bool reuse_addr = true) {
    auto p = std::make_shared<detail::tcp_acceptor>(m_ioc, endp, reuse_addr);
    lg g(m_mutex);
    m_acceptors.push_back(p);
    return net_entity(p);
  }
 
  template <typename F = simple_timeout>
  net_entity make_tcp_connector (std::string_view remote_port_or_service,
                                 std::string_view remote_host,
                                 const F& timeout_func = simple_timeout { },
                                 bool reconn_on_err = false) {
 
    auto p = std::make_shared<detail::tcp_connector>(m_ioc, remote_port_or_service, remote_host, 
                                                     tcp_connector_timeout_func(timeout_func),
                                                     reconn_on_err);
    lg g(m_mutex);
    m_connectors.push_back(p);
    return net_entity(p);
  }
 
  template <typename Iter, typename F = simple_timeout>
  auto make_tcp_connector (Iter beg, Iter end,
                           const F& timeout_func = simple_timeout { },
                           bool reconn_on_err = false) ->
        std::enable_if_t<std::is_same_v<std::decay<decltype(*beg)>, asio::ip::tcp::endpoint>, net_entity> {
    auto p = std::make_shared<detail::tcp_connector>(m_ioc, beg, end, 
                                                     tcp_connector_timeout_func(timeout_func),
                                                     reconn_on_err);
    lg g(m_mutex);
    m_connectors.push_back(p);
    return net_entity(p);
  }
 
  template <typename F = simple_timeout>
  net_entity make_tcp_connector (const asio::ip::tcp::endpoint& endp,
                                 const F& timeout_func = simple_timeout { },
                                 bool reconn_on_err = false) {
    std::vector<asio::ip::tcp::endpoint> vec { endp };
    return make_tcp_connector(vec.cbegin(), vec.cend(), timeout_func, reconn_on_err);
  }
 
  net_entity make_udp_unicast (std::string_view local_port_or_service, 
                               std::string_view local_intf = "") {
    auto p = std::make_shared<detail::udp_entity_io>(m_ioc, local_port_or_service, local_intf);
    lg g(m_mutex);
    m_udp_entities.push_back(p);
    return net_entity(p);
  }
 
  net_entity make_udp_unicast (const asio::ip::udp::endpoint& endp) {
    auto p = std::make_shared<detail::udp_entity_io>(m_ioc, endp);
    lg g(m_mutex);
    m_udp_entities.push_back(p);
    return net_entity(p);
  }
 
  net_entity make_udp_sender () {
    return make_udp_unicast(asio::ip::udp::endpoint());
  }
 
// TODO: multicast make methods 
 
  void remove(net_entity ent) {
    lg g(m_mutex);
// overloaded utility brought in from net_entity.hpp
    std::visit (detail::overloaded {
        [this] (detail::tcp_acceptor_weak_ptr p) { 
          std::erase_if(m_acceptors, [p] (detail::tcp_acceptor_shared_ptr sp) { return sp == p.lock(); } );
    },
        [this] (detail::tcp_connector_weak_ptr p) { 
          std::erase_if(m_connectors, [p] (detail::tcp_connector_shared_ptr sp) { return sp == p.lock(); } );
    },
        [this] (detail::udp_entity_io_weak_ptr p) {
          std::erase_if(m_udp_entities, [p] (detail::udp_entity_io_shared_ptr sp) { return sp == p.lock(); } );
    }
      }, ent.m_wptr);
  }
 
  void remove_all() {
    lg g(m_mutex);
    m_udp_entities.clear();
    m_connectors.clear();
    m_acceptors.clear();
  }
 
  void stop_all() {
    lg g(m_mutex);
    for (auto i : m_udp_entities) { i->stop(); }
    for (auto i : m_connectors) { i->stop(); }
    for (auto i : m_acceptors) { i->stop(); }
  }
 
};
 
}  // end net namespace
}  // end chops namespace
 
#endif