include/boost/corosio/native/detail/reactor/reactor_socket_service.hpp

97.7% Lines (43 / 44, 1 excl) 93.5% Functions (86 / 92)

[ ] prev/next file n p prev/next uncovered line

reactor_socket_service.hpp

f(x) Functions (92)

Function Calls Lines Blocks

Line	Hits	Source Code
1		//
2		// Copyright (c) 2026 Steve Gerbino
3		//
4		// Distributed under the Boost Software License, Version 1.0. (See accompanying
5		// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6		//
7		// Official repository: https://github.com/cppalliance/corosio
8		//
9
10		#ifndef BOOST_COROSIO_NATIVE_DETAIL_REACTOR_REACTOR_SOCKET_SERVICE_HPP
11		#define BOOST_COROSIO_NATIVE_DETAIL_REACTOR_REACTOR_SOCKET_SERVICE_HPP
12
13		#include <boost/corosio/io/io_object.hpp>
14		#include <boost/corosio/detail/scheduler_op.hpp>
15		#include <boost/corosio/native/detail/reactor/reactor_service_state.hpp>
16		#include <boost/capy/ex/execution_context.hpp>
17
18		#include <memory>
19		#include <mutex>
20
21		namespace boost::corosio::detail {
22
23		/** CRTP base for reactor-backed socket/datagram service implementations.
24
25		Provides the shared construct/destroy/shutdown/close/post/work
26		logic that is identical across all reactor backends and socket
27		types. Derived classes add only protocol-specific open/bind.
28
29		@tparam Derived The concrete service type (CRTP).
30		@tparam ServiceBase The abstract service base (tcp_service
31		or udp_service).
32		@tparam Scheduler The backend's scheduler type.
33		@tparam Impl The backend's socket/datagram impl type.
34		*/
35		template<class Derived, class ServiceBase, class Scheduler, class Impl>
36		class reactor_socket_service : public ServiceBase
37		{
38		friend Derived;
39		using state_type = reactor_service_state<Scheduler, Impl>;
40
41		protected:
42		// NOLINTNEXTLINE(bugprone-crtp-constructor-accessibility)
43	1351x	explicit reactor_socket_service(capy::execution_context& ctx)
44	1351x	: state_(
45		std::make_unique<state_type>(
46	1351x	ctx.template use_service<Scheduler>()))
47		{
48	1351x	}
49
50		public:
51	1351x	~reactor_socket_service() override = default;
52
53	1351x	void shutdown() override
54		{
55	1351x	std::lock_guard lock(state_->mutex_);
56
57	1356x	while (auto* impl = state_->impl_list_.pop_front())
58		{
59	5x	static_cast<Derived*>(this)->pre_shutdown(impl);
60	5x	impl->close_socket();
61		}
62
63		// Don't clear impl_ptrs_ here. The scheduler shuts down after us
64		// and drains completed_ops_, calling destroy() on each queued op.
65		// Letting ~state_ release the ptrs (during service destruction,
66		// after scheduler shutdown) keeps every impl alive until all ops
67		// have been drained.
68	1351x	}
69
70	14869x	io_object::implementation* construct() override
71		{
72	14869x	auto impl = std::make_shared<Impl>(static_cast<Derived&>(*this));
73	14869x	auto* raw = impl.get();
74
75		{
76	14869x	std::lock_guard lock(state_->mutex_);
77	14869x	state_->impl_ptrs_.emplace(raw, std::move(impl));
78	14869x	state_->impl_list_.push_back(raw);
79	14869x	}
80
81	14869x	return raw;
82	14869x	}
83
84	14864x	void destroy(io_object::implementation* impl) override
85		{
86	14864x	auto* typed = static_cast<Impl*>(impl);
87	14864x	static_cast<Derived*>(this)->pre_destroy(typed);
88	14864x	typed->close_socket();
89	14864x	std::lock_guard lock(state_->mutex_);
90	14864x	state_->impl_list_.remove(typed);
91	14864x	state_->impl_ptrs_.erase(typed);
92	14864x	}
93
94	24784x	void close(io_object::handle& h) override
95		{
96	24784x	static_cast<Impl*>(h.get())->close_socket();
97	24784x	}
98
99	450013x	Scheduler& scheduler() const noexcept
100		{
101	450013x	return state_->sched_;
102		}
103
104	86290x	void post(scheduler_op* op)
105		{
106	86290x	state_->sched_.post(op);
107	86290x	}
108
109	5771x	void work_started() noexcept
110		{
111	5771x	state_->sched_.work_started();
112	5771x	}
113
114	489x	void work_finished() noexcept
115		{
116	489x	state_->sched_.work_finished();
117	489x	}
118
119		protected:
120		// Override in derived to add pre-close logic. No backend currently needs
121		// it; the hooks exist so a trait can run fd-level teardown before close.
122	✗	void pre_shutdown(Impl*) noexcept {
123	−	} // LCOV_EXCL_LINE optional CRTP hook; no backend overrides it today
124	979x	void pre_destroy(Impl*) noexcept {}
125
126		std::unique_ptr<state_type> state_;
127
128		private:
129		reactor_socket_service(reactor_socket_service const&) = delete;
130		reactor_socket_service& operator=(reactor_socket_service const&) = delete;
131		};
132
133		} // namespace boost::corosio::detail
134
135		#endif // BOOST_COROSIO_NATIVE_DETAIL_REACTOR_REACTOR_SOCKET_SERVICE_HPP
136