socket_message.hpp

Go to the documentation of this file.

/* Copyright 2025 Kevin Exton
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#pragma once
#ifndef IO_SOCKET_MESSAGE_HPP
#define IO_SOCKET_MESSAGE_HPP
#include <boost/predef.h>
 
#if BOOST_OS_WINDOWS
#include "platforms/windows/socket.hpp"
#else
#include "platforms/posix/socket.hpp"
#endif
 
#include "socket_address.hpp"
 
#include <memory>
#include <mutex>
#include <vector>
 
namespace io::socket {
 
using ancillary_buffer = std::vector<char>;
 
using scatter_gather_buffer = std::vector<socket_buffer_type>;
 
struct message_data {
  socket_address address; 
  scatter_gather_buffer
      buffers; 
  ancillary_buffer control; 
  int flags{};              
};
 
class socket_message {
 
public:
  socket_message();
 
  socket_message(const socket_message &other) = delete;
 
  auto operator=(const socket_message &other) -> socket_message & = delete;
 
  socket_message(socket_message &&other) noexcept;
 
  auto operator=(socket_message &&other) noexcept -> socket_message &;
 
  friend auto swap(socket_message &lhs, socket_message &rhs) noexcept -> void;
 
  [[nodiscard]] auto get() const -> message_data;
 
  auto operator=(message_data data) -> socket_message &;
 
  [[nodiscard]] auto address() const -> socket_address;
 
  auto set_address(socket_address address) -> socket_message &;
 
  auto exchange_address(socket_address address) -> socket_address;
 
  [[nodiscard]] auto buffers() const -> scatter_gather_buffer;
 
  auto set_buffers(scatter_gather_buffer buffers) -> socket_message &;
 
  auto exchange_buffers(scatter_gather_buffer buffers) -> scatter_gather_buffer;
 
  auto push_back(socket_buffer_type buffer) -> socket_message &;
 
  template <typename... Args>
  auto emplace_back(Args &&...args) -> socket_message & {
    std::lock_guard<std::mutex> lock{mtx_};
    data_->buffers.emplace_back(std::forward<Args>(args)...);
    return *this;
  }
 
  [[nodiscard]] auto control() const -> ancillary_buffer;
 
  auto set_control(ancillary_buffer control) -> socket_message &;
 
  auto exchange_control(ancillary_buffer control) -> ancillary_buffer;
 
  [[nodiscard]] auto flags() const -> int;
 
  auto set_flags(int flags) -> socket_message &;
 
  auto exchange_flags(int flags) -> int;
 
  ~socket_message() = default;
 
private:
  std::unique_ptr<message_data> data_;
  mutable std::mutex mtx_;
};
 
// TODO implement customization points for sendmsg and recvmsg that are passed
// in socket_message types.
 
} // namespace io::socket
 
#endif // IO_SOCKET_MESSAGE_HPP