triggers.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_TRIGGERS_HPP
#define IO_TRIGGERS_HPP
#include "executor.hpp"
#include "io/detail/concepts.hpp"
#include "io/socket/socket_dialog.hpp"
#include "io/socket/socket_handle.hpp"
 
#include <memory>
namespace io::execution {
template <Multiplexer Mux> class basic_triggers {
public:
  using socket_handle = ::io::socket::socket_handle;
  using socket_dialog = ::io::socket::socket_dialog<Mux>;
  using executor_type = executor<Mux>;
 
  basic_triggers() = default;
 
  basic_triggers(const basic_triggers &) = delete;
 
  basic_triggers(basic_triggers &&) = default;
 
  template <AllocatorLike Allocator>
  explicit basic_triggers(const Allocator &alloc = Allocator()) noexcept(
      noexcept(Allocator()))
      : executor_{std::allocate_shared<executor_type>(alloc, alloc)}
  {}
 
  auto operator=(const basic_triggers &) -> basic_triggers & = delete;
 
  auto operator=(basic_triggers &&) -> basic_triggers & = default;
 
  template <SocketLike Socket>
  auto push(std::shared_ptr<Socket> socket) -> socket_dialog
  {
    return {executor_, executor_type::push(std::move(socket))};
  }
 
  template <typename... Args> auto emplace(Args &&...args) -> socket_dialog
  {
    return {executor_, executor_type::emplace(std::forward<Args>(args)...)};
  }
 
  template <typename... Args> auto set(Args &&...args) -> decltype(auto)
  {
    return executor_->set(std::forward<Args>(args)...);
  }
 
  constexpr auto wait_for(int interval = -1) -> decltype(auto)
  {
    return executor_->wait_for(interval);
  }
 
  constexpr auto wait() -> decltype(auto) { return executor_->wait(); }
 
  [[nodiscard]] auto on_empty() -> decltype(auto)
  {
    return executor_->on_empty();
  }
 
  [[nodiscard]] auto
  get_executor() const noexcept -> std::weak_ptr<executor_type>
  {
    return executor_;
  }
 
  ~basic_triggers() = default;
 
private:
  std::shared_ptr<executor_type> executor_{std::make_shared<executor_type>()};
};
 
} // namespace io::execution
#endif // IO_TRIGGERS_HPP