basic_io_output.hpp

Go to the documentation of this file.

 
#ifndef BASIC_IO_OUTPUT_HPP_INCLUDED
#define BASIC_IO_OUTPUT_HPP_INCLUDED
 
#include <memory> // std::weak_ptr, std::shared_ptr
#include <system_error>
#include <cstddef> // std::size_t, std::byte
#include <utility> // std::move
 
#include "nonstd/expected.hpp"
 
#include "buffer/shared_buffer.hpp"
#include "net_ip/queue_stats.hpp"
 
#include "net_ip/detail/wp_access.hpp"
 
namespace chops {
namespace net {
 
 
template <typename IOT>
class basic_io_output {
 
private:
  std::weak_ptr<IOT>   m_ioh_wptr;
 
public:
  using endpoint_type = typename IOT::endpoint_type;
 
public:
 
  basic_io_output() = default;
 
  explicit basic_io_output(std::weak_ptr<IOT> p) noexcept : m_ioh_wptr(p) { }
 
  bool is_valid() const noexcept { return !m_ioh_wptr.expired(); }
 
  auto get_output_queue_stats() const ->
         nonstd::expected<output_queue_stats, std::error_code> {
    return detail::wp_access<output_queue_stats>( m_ioh_wptr,
          [] (std::shared_ptr<IOT> sp) { return sp->get_output_queue_stats(); } );
  }
 
  bool send(const void* buf, std::size_t sz) const { return send(chops::const_shared_buffer(buf, sz)); }
 
  bool send(const chops::const_shared_buffer& buf) const {
    auto sp = m_ioh_wptr.lock();
    return sp ?  sp->send(buf) : false;
  }
 
  bool send(chops::mutable_shared_buffer&& buf) const { 
    return send(chops::const_shared_buffer(std::move(buf)));
  }
 
  bool send(const void* buf, std::size_t sz, const endpoint_type& endp) const {
    return send(chops::const_shared_buffer(buf, sz), endp);
  }
 
  bool send(const chops::const_shared_buffer& buf, const endpoint_type& endp) const {
    auto sp = m_ioh_wptr.lock();
    return sp ?  sp->send(buf, endp) : false;
  }
 
  bool send(chops::mutable_shared_buffer&& buf, const endpoint_type& endp) const {
    return send(chops::const_shared_buffer(std::move(buf)), endp);
  }
 
  bool operator==(const basic_io_output<IOT>& rhs) const noexcept {
    return (m_ioh_wptr.lock() == rhs.m_ioh_wptr.lock());
  }
 
  bool operator<(const basic_io_output<IOT>& rhs) const noexcept {
    return (m_ioh_wptr.lock() < rhs.m_ioh_wptr.lock());
  }
 
};
 
} // end net namespace
} // end chops namespace
 
#endif