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 "detail/buffer_iterator.hpp"
#include "detail/socket.hpp"
#include "socket_address.hpp"
 
#include <memory>
#include <optional>
#include <vector>
namespace io::socket {
struct message_header {
  std::span<std::byte> msg_name;
  std::span<native_buffer_type> msg_iov;
  std::span<std::byte> msg_control;
  int flags{};
 
  [[nodiscard]] explicit operator socket_message_type() noexcept;
};
 
template <AllocatorLike Allocator = std::allocator<native_buffer_type>>
class message_buffer {
public:
  using buffer_type = std::vector<native_buffer_type, Allocator>;
  using iterator = buffer_iterator<typename buffer_type::iterator>;
  using const_iterator = buffer_iterator<typename buffer_type::const_iterator>;
  using size_type = typename buffer_type::size_type;
 
  message_buffer(const Allocator &alloc = Allocator()) noexcept(
      noexcept(Allocator()));
 
  template <ScatterGatherLike... Bufs>
  constexpr message_buffer(const Bufs &...bufs) noexcept;
 
  template <ScatterGatherLike Buf>
  constexpr auto push_back(const Buf &buf) -> void;
 
  constexpr auto push_back(native_buffer_type buf) -> void;
 
  template <typename... Args>
  constexpr auto emplace_back(Args &&...args) -> decltype(auto);
 
  [[nodiscard]] constexpr auto begin() noexcept -> iterator;
 
  [[nodiscard]] constexpr auto begin() const noexcept -> const_iterator;
 
  [[nodiscard]] constexpr auto end() noexcept -> iterator;
 
  [[nodiscard]] constexpr auto end() const noexcept -> const_iterator;
 
  [[nodiscard]] constexpr auto size() const noexcept -> size_type;
 
  [[nodiscard]] constexpr auto empty() const noexcept -> bool;
 
  [[nodiscard]] explicit constexpr operator bool() const noexcept;
 
  auto operator+=(std::size_t len) noexcept -> message_buffer &;
 
  constexpr auto native() -> buffer_type & { return buffer_; }
 
private:
  buffer_type buffer_;
};
 
template <SocketAddress Addr = sockaddr_storage_type,
          AllocatorLike Allocator = std::allocator<char>>
struct socket_message {
  using message_allocator = std::allocator_traits<
      Allocator>::template rebind_alloc<native_buffer_type>;
  using control_allocator =
      std::allocator_traits<Allocator>::template rebind_alloc<std::byte>;
  using address_type = std::optional<socket_address<Addr>>;
  using message_type = message_buffer<message_allocator>;
  using control_type = std::vector<std::byte, control_allocator>;
 
  address_type address;
 
  message_type buffers;
 
  control_type control;
 
  int flags{};
 
  [[nodiscard]] explicit operator message_header() noexcept;
  [[nodiscard]] explicit operator socket_message_type() noexcept;
};
 
} // namespace io::socket
 
#include "impl/socket_message_impl.hpp" // IWYU pragma: export
 
#endif // IO_SOCKET_MESSAGE_HPP