concepts.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_CONCEPTS_HPP
#define IO_CONCEPTS_HPP
#include "io/config.h"
#if OS_WINDOWS
#else
#include "platforms/posix/concepts_posix.hpp" // IWYU pragma: export
#endif
#include "io/socket/detail/socket.hpp"
 
#include <memory>
#include <optional>
#include <type_traits>
// Forward declarations
namespace io {
namespace socket {
class socket_handle;
} // namespace socket
namespace execution {
enum struct execution_trigger : std::uint8_t;
} // namespace execution
} // namespace io
 
namespace io {
 
template <typename Allocator>
concept AllocatorLike =
    requires(Allocator alloc, typename Allocator::value_type *ptr) {
      { alloc.allocate(0) } -> std::same_as<decltype(ptr)>;
      { alloc.deallocate(ptr, 0) } -> std::same_as<void>;
    };
 
template <typename Lock>
concept BasicLockable = requires(Lock lock) {
  { lock.lock() } -> std::same_as<void>;
  { lock.unlock() } -> std::same_as<void>;
};
 
template <typename B>
concept ScatterGatherLike = requires(B buf) {
  std::ranges::data(buf);
  std::ranges::size(buf);
};
 
template <typename T>
concept MuxTag = requires(T tag) {
  typename T::event_type;
  typename T::interval_type;
  typename T::size_type;
  typename T::template is_eager_t<T>;
  T::template is_eager_v<T>;
};
 
template <typename Fn>
concept Completion = requires(Fn &&func) {
  requires std::is_invocable_v<Fn>;
  typename std::invoke_result_t<Fn>::value_type;
  requires std::is_same_v<
      std::invoke_result_t<Fn>,
      std::optional<typename std::invoke_result_t<Fn>::value_type>>;
};
 
template <typename T>
concept Multiplexer = requires(T mux) {
  requires MuxTag<T>;
  typename T::demultiplexer;
  typename T::template sender<decltype([]() -> std::optional<int> {
    return std::nullopt;
  })>;
  mux.set(std::shared_ptr<socket::socket_handle>{},
          execution::execution_trigger{},
          []() -> std::optional<int> { return std::nullopt; });
  mux.wait_for(typename T::interval_type{});
};
 
template <typename Socket>
concept SocketLike = requires {
  requires std::is_constructible_v<Socket, socket::native_socket_type>;
  static_cast<socket::native_socket_type>(Socket{});
};
 
template <typename Dialog>
concept DialogLike = requires(Dialog &dialog) {
  typename Dialog::executor_type;
  dialog.executor;
  dialog.socket;
};
 
template <typename Message>
concept MessageLike =
    requires(Message msg) { static_cast<socket::socket_message_type>(msg); };
 
} // namespace io
#endif // IO_CONCEPTS_HPP