executor.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_EXECUTOR_HPP
#define IO_EXECUTOR_HPP
#include "io/detail/concepts.hpp"
#include "io/detail/customization.hpp"
#include "io/error.hpp"
#include "io/socket/socket_handle.hpp"
 
#include <exec/async_scope.hpp>
#include <stdexec/execution.hpp>
 
#include <utility>
// Forward declarations
namespace io::execution {
template <Multiplexer Mux> class basic_triggers;
} // namespace io::execution
 
namespace io::execution {
template <Multiplexer Mux> class executor : public Mux {
  friend class basic_triggers<Mux>;
  using socket_handle = ::io::socket::socket_handle;
  using async_scope = exec::async_scope;
 
public:
  using Mux::Mux;
  template <SocketLike Socket>
  static auto push(std::shared_ptr<Socket> socket) -> decltype(auto)
  {
    if (::io::fcntl(*socket, F_SETFL,
                    ::io::fcntl(*socket, F_GETFL) | O_NONBLOCK))
    {
      throw_system_error(IO_ERROR_MESSAGE("fcntl failed."));
    }
    return socket;
  }
  template <SocketLike Socket>
  static auto push(Socket &&handle) -> decltype(auto)
  {
    return push(std::make_shared<Socket>(std::forward<Socket>(handle)));
  }
  template <typename... Args>
  static auto emplace(Args &&...args) -> std::shared_ptr<socket_handle>
  {
    return push(socket_handle{std::forward<Args>(args)...});
  }
  template <typename... Args> auto set(Args &&...args) -> decltype(auto)
  {
    return scope_.nest(Mux::set(std::forward<Args>(args)...));
  }
  [[nodiscard]] auto on_empty() -> decltype(auto) { return scope_.on_empty(); }
 
private:
  constexpr auto wait_for(int interval = -1) -> decltype(auto)
  {
    return Mux::wait_for(typename Mux::interval_type{interval});
  }
  constexpr auto wait() -> decltype(auto) { return wait_for(); }
  async_scope scope_;
};
 
} // namespace io::execution
#endif // IO_EXECUTOR_HPP