async_udp_service.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 CPPNET_ASYNC_UDP_SERVICE_HPP
#define CPPNET_ASYNC_UDP_SERVICE_HPP
#include "async_context.hpp"
namespace net::service {
// NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
template <typename UDPStreamHandler, std::size_t Size = 64 * 1024UL>
class async_udp_service {
public:
  template <typename T> using socket_address = io::socket::socket_address<T>;
  using async_context = service::async_context;
  using async_scope = async_context::async_scope;
  using multiplexer_type = async_context::multiplexer_type;
  using socket_handle = io::socket::socket_handle;
  using socket_dialog = io::socket::socket_dialog<multiplexer_type>;
  using enum async_context::signals;
 
  struct read_context {
    using buffer_type = std::array<std::byte, Size>;
    using socket_address = io::socket::socket_address<sockaddr_in6>;
    using socket_message = io::socket::socket_message<sockaddr_in6>;
 
    buffer_type read_buffer{};
    std::span<std::byte> buffer{read_buffer};
    socket_message msg{.address = socket_address{}, .buffers = buffer};
  };
 
  auto signal_handler(int signum) noexcept -> void;
  auto start(async_context &ctx) noexcept -> std::error_code;
  auto submit_recv(async_context &ctx, const socket_dialog &socket,
                   std::shared_ptr<read_context> rctx) -> void;
 
protected:
  async_udp_service() = default;
  template <typename T>
  explicit async_udp_service(socket_address<T> address) noexcept;
 
private:
  using socket_type = io::socket::native_socket_type;
 
  auto emit(async_context &ctx, const socket_dialog &socket,
            std::shared_ptr<read_context> rctx = {},
            std::span<const std::byte> buf = {}) -> void;
 
  [[nodiscard]] auto
  initialize_(const socket_handle &socket) -> std::error_code;
 
  auto stop_() -> void;
  socket_address<sockaddr_in6> address_;
  std::atomic<socket_type> server_sockfd_ = io::socket::INVALID_SOCKET;
};
 
} // namespace net::service
 
#include "impl/async_udp_service_impl.hpp" // IWYU pragma: export
#endif                                     // CPPNET_ASYNC_UDP_SERVICE_HPP