customization.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_CUSTOMIZATION_HPP
#define IO_CUSTOMIZATION_HPP
#include <span>
#include <utility>
namespace io {
 
struct accept_t {};
struct bind_t {};
struct connect_t {};
struct fcntl_t {};
struct getpeername_t {};
struct getsockname_t {};
struct getsockopt_t {};
struct listen_t {};
struct recvmsg_t {};
struct sendmsg_t {};
struct setsockopt_t {};
struct shutdown_t {};
 
// TODO: Implement free-standing functions in the berkeley sockets APIs
// - send
// - sendto
// - recv
// - recvfrom
 
template <typename T> struct cpo {
  template <typename... Args>
  constexpr auto operator()(Args &&...args) const -> decltype(auto)
  {
    return tag_invoke(static_cast<T *>(nullptr), std::forward<Args>(args)...);
  }
};
 
inline auto accept(auto &&socket,
                   std::span<std::byte> address = {}) -> decltype(auto)
{
  static constexpr cpo<accept_t> accept{};
  return accept(std::forward<decltype(socket)>(socket), std::move(address));
}
 
inline auto bind(auto &&socket,
                 std::span<const std::byte> address) -> decltype(auto)
{
  static constexpr cpo<bind_t> bind{};
  return bind(std::forward<decltype(socket)>(socket), std::move(address));
}
 
inline auto connect(auto &&socket,
                    std::span<const std::byte> address) -> decltype(auto)
{
  static constexpr cpo<connect_t> connect{};
  return connect(std::forward<decltype(socket)>(socket), std::move(address));
}
 
inline auto fcntl(auto &&socket, int cmd, auto &&...args) -> decltype(auto)
{
  static constexpr cpo<fcntl_t> fcntl{};
  return fcntl(std::forward<decltype(socket)>(socket), cmd,
               std::forward<decltype(args)>(args)...);
}
 
inline auto getpeername(auto &&socket,
                        std::span<std::byte> address) -> decltype(auto)
{
  static constexpr cpo<getpeername_t> getpeername{};
  return getpeername(std::forward<decltype(socket)>(socket),
                     std::move(address));
}
 
// NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
inline auto getsockopt(auto &&socket, int level, int optname,
                       std::span<std::byte> option) -> decltype(auto)
{
  static constexpr cpo<getsockopt_t> getsockopt{};
  return getsockopt(std::forward<decltype(socket)>(socket), level, optname,
                    std::move(option));
}
 
inline auto getsockname(auto &&socket,
                        std::span<std::byte> address) -> decltype(auto)
{
  static constexpr cpo<getsockname_t> getsockname{};
  return getsockname(std::forward<decltype(socket)>(socket),
                     std::move(address));
}
 
inline auto listen(auto &&socket, int backlog) -> decltype(auto)
{
  static constexpr cpo<listen_t> listen{};
  return listen(std::forward<decltype(socket)>(socket), backlog);
}
 
inline auto recvmsg(auto &&socket, auto &&msg, int flags) -> decltype(auto)
{
  static constexpr cpo<recvmsg_t> recvmsg{};
  return recvmsg(std::forward<decltype(socket)>(socket),
                 std::forward<decltype(msg)>(msg), flags);
}
 
inline auto sendmsg(auto &&socket, auto &&msg, int flags) -> decltype(auto)
{
  static constexpr cpo<sendmsg_t> sendmsg{};
  return sendmsg(std::forward<decltype(socket)>(socket),
                 std::forward<decltype(msg)>(msg), flags);
}
 
// NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
inline auto setsockopt(auto &&socket, int level, int optname,
                       std::span<const std::byte> option) -> decltype(auto)
{
  static constexpr cpo<setsockopt_t> setsockopt{};
  return setsockopt(std::forward<decltype(socket)>(socket), level, optname,
                    std::move(option));
}
 
inline auto shutdown(auto &&socket, int how) -> decltype(auto)
{
  static constexpr cpo<shutdown_t> shutdown{};
  return shutdown(std::forward<decltype(socket)>(socket), how);
}
} // namespace io
#endif // IO_CUSTOMIZATION_HPP