no_framing.hpp

#pragma once
#include <ossia/network/sockets/writers.hpp>
 
#include <boost/asio/buffer.hpp>
#include <boost/asio/error.hpp>
#include <boost/asio/write.hpp>
 
namespace ossia::net
{
 
struct no_framing
{
  template <typename Socket>
  struct encoder
  {
    Socket& socket;
    void write(const char* data, std::size_t sz)
    {
      this->write(socket, boost::asio::buffer(data, sz));
    }
 
    template <typename T>
    void write(T& sock, const boost::asio::const_buffer& buf)
    {
      boost::asio::write(sock, buf);
    }
 
    template <typename T>
    void write(multi_socket_writer<T>& sock, const boost::asio::const_buffer& buf)
    {
      sock.write(buf);
    }
  };
 
  template <typename Socket>
  struct decoder
  {
    Socket& socket;
    alignas(64) uint8_t m_readbuf[4096];
    lifetime_token m_lifetime;
 
    explicit decoder(Socket& s)
        : socket{s}
    {
    }
 
    decoder() = delete;
    decoder(const decoder&) = delete;
    decoder(decoder&&) = delete;
    decoder& operator=(const decoder&) = delete;
    decoder& operator=(decoder&&) = delete;
 
    template <typename F>
    void receive(F f)
    {
      socket.async_read_some(
          boost::asio::buffer(m_readbuf),
          [this, alive = m_lifetime.watch(),
           f = std::move(f)](boost::system::error_code ec, std::size_t sz) mutable {
        // The socket may be gone since this read was armed; see lifetime_token.
        if(alive.expired())
          return;
 
        if(!f.validate_stream(ec))
          return;
 
        f(m_readbuf, sz);
        receive(std::move(f));
      });
    }
  };
};
 
}