2 #include <ossia/detail/lockfree_queue.hpp>
4 #include <ossia/detail/mutex.hpp>
5 #include <ossia/network/base/listening.hpp>
6 #include <ossia/network/base/parameter.hpp>
7 #include <ossia/network/base/protocol.hpp>
8 #include <ossia/network/context.hpp>
9 #include <ossia/network/domain/domain.hpp>
10 #include <ossia/network/exceptions.hpp>
11 #include <ossia/network/generic/generic_device.hpp>
12 #include <ossia/network/generic/generic_parameter.hpp>
13 #include <ossia/network/osc/detail/osc_1_0_policy.hpp>
14 #include <ossia/network/osc/detail/osc_1_1_extended_policy.hpp>
15 #include <ossia/network/osc/detail/osc_1_1_policy.hpp>
16 #include <ossia/network/osc/detail/osc_protocol_common.hpp>
17 #include <ossia/network/sockets/configuration.hpp>
18 #include <ossia/network/sockets/null_socket.hpp>
19 #include <ossia/network/sockets/writers.hpp>
20 #include <ossia/network/value/value.hpp>
22 #include <ossia/detail/hash_map.hpp>
29 template <
typename OscMode,
typename SendSocket,
typename RecvSocket>
30 class osc_generic_bidir_protocol :
public can_learn<ossia::net::protocol_base>
34 using writer_type = socket_writer<SendSocket>;
36 osc_generic_bidir_protocol(
37 network_context_ptr ctx,
const send_fd_configuration& send_conf,
38 const receive_fd_configuration& recv_conf)
39 : can_learn<
ossia::net::protocol_base>{flags{SupportsMultiplex}}
40 , m_ctx{std::move(ctx)}
42 , from_client{recv_conf, m_ctx->
context}
43 , to_client{send_conf, m_ctx->
context}
48 from_client.receive([
this](
const char* data, std::size_t sz) {
51 auto on_message = [
this](
auto&& msg) { this->on_received_message(msg); };
52 osc_packet_processor<decltype(on_message)>{on_message}(data, sz);
56 osc_generic_bidir_protocol(
57 network_context_ptr ctx,
const send_socket_configuration& send_conf,
58 const receive_socket_configuration& recv_conf)
59 : can_learn<
ossia::net::protocol_base>{flags{SupportsMultiplex}}
60 , m_ctx{std::move(ctx)}
62 , from_client{recv_conf, m_ctx->
context}
63 , to_client{send_conf, m_ctx->
context}
68 from_client.receive([
this](
const char* data, std::size_t sz) {
71 auto on_message = [
this](
auto&& msg) { this->on_received_message(msg); };
72 osc_packet_processor<decltype(on_message)>{on_message}(data, sz);
76 osc_generic_bidir_protocol(
77 network_context_ptr ctx,
const send_socket_configuration& send_conf)
78 : can_learn<
ossia::net::protocol_base>{flags{SupportsMultiplex}}
79 , m_ctx{std::move(ctx)}
81 , to_client{send_conf, m_ctx->
context}
86 osc_generic_bidir_protocol(
87 network_context_ptr ctx,
const receive_socket_configuration& recv_conf)
88 : can_learn<
ossia::net::protocol_base>{flags{SupportsMultiplex}}
89 , m_ctx{std::move(ctx)}
91 , from_client{recv_conf, m_ctx->
context}
95 from_client.receive([
this](
const char* data, std::size_t sz) {
98 auto on_message = [
this](
auto&& msg) { this->on_received_message(msg); };
99 osc_packet_processor<decltype(on_message)>{on_message}(data, sz);
103 osc_generic_bidir_protocol(
104 network_context_ptr ctx,
const send_fd_configuration& send_conf)
105 : can_learn<
ossia::net::protocol_base>{flags{SupportsMultiplex}}
106 , m_ctx{std::move(ctx)}
108 , to_client{send_conf, m_ctx->
context}
113 osc_generic_bidir_protocol(
114 network_context_ptr ctx,
const receive_fd_configuration& recv_conf)
115 : can_learn<
ossia::net::protocol_base>{flags{SupportsMultiplex}}
116 , m_ctx{std::move(ctx)}
118 , from_client{recv_conf, m_ctx->
context}
122 from_client.receive([
this](
const char* data, std::size_t sz) {
125 auto on_message = [
this](
auto&& msg) { this->on_received_message(msg); };
126 osc_packet_processor<decltype(on_message)>{on_message}(data, sz);
130 osc_generic_bidir_protocol(
const osc_generic_bidir_protocol&) =
delete;
131 osc_generic_bidir_protocol(osc_generic_bidir_protocol&&) =
delete;
132 osc_generic_bidir_protocol& operator=(
const osc_generic_bidir_protocol&) =
delete;
133 osc_generic_bidir_protocol& operator=(osc_generic_bidir_protocol&&) =
delete;
135 ~osc_generic_bidir_protocol()
override =
default;
143 if constexpr(!std::is_same_v<RecvSocket, ossia::net::null_socket>)
145 return OscMode::observe(*
this, parameter_base, enable);
153 bool echo_incoming_message(
154 const message_origin_identifier&
id,
const parameter_base& addr,
155 const value& val)
override
157 if constexpr(!std::is_same_v<SendSocket, ossia::net::null_socket>)
159 return OscMode::echo_incoming_message(*
this,
id, addr, val);
169 if constexpr(!std::is_same_v<SendSocket, ossia::net::null_socket>)
171 return OscMode::push(*
this, addr, v);
181 if constexpr(!std::is_same_v<SendSocket, ossia::net::null_socket>)
183 return OscMode::push(*
this, addr, std::move(v));
193 if constexpr(!std::is_same_v<SendSocket, ossia::net::null_socket>)
195 return OscMode::push_raw(*
this, addr);
203 bool push_bundle(
const std::vector<const parameter_base*>& addresses)
override
205 if constexpr(!std::is_same_v<SendSocket, ossia::net::null_socket>)
207 return OscMode::push_bundle(*
this, writer(), addresses);
215 bool push_bundle(tcb::span<ossia::bundle_element> addresses)
override
217 if constexpr(!std::is_same_v<SendSocket, ossia::net::null_socket>)
219 return OscMode::push_bundle(*
this, writer(), addresses);
227 bool push_bundle_bounded(tcb::span<ossia::bundle_element> addresses)
override
229 if constexpr(!std::is_same_v<SendSocket, ossia::net::null_socket>)
231 return OscMode::push_bundle_bounded(*
this, writer(), addresses);
240 push_raw_bundle(
const std::vector<ossia::net::full_parameter_data>& addresses)
override
242 if constexpr(!std::is_same_v<SendSocket, ossia::net::null_socket>)
244 return OscMode::push_bundle(*
this, writer(), addresses);
252 void on_received_message(
const oscpack::ReceivedMessage& m)
254 if constexpr(!std::is_same_v<RecvSocket, ossia::net::null_socket>)
256 return OscMode::on_received_message(*
this, m);
262 auto writer() noexcept {
return writer_type{to_client}; }
264 using ossia::net::protocol_base::m_logger;
265 ossia::net::network_context_ptr m_ctx;
266 message_origin_identifier m_id;
267 listened_parameters m_listening;
271 RecvSocket from_client;
272 SendSocket to_client;
275 template <
typename OscMode,
typename Socket>
276 class osc_generic_server_protocol :
public can_learn<ossia::net::protocol_base>
279 using socket_type = Socket;
280 using writer_type = socket_writer<socket_type>;
282 template <
typename Configuration>
283 osc_generic_server_protocol(network_context_ptr ctx,
const Configuration& conf)
284 : can_learn<
ossia::net::protocol_base>{flags{SupportsMultiplex}}
285 , m_ctx{std::move(ctx)}
287 , m_server{conf, m_ctx->
context}
294 m_server.listen([
this](
const unsigned char* data, std::size_t sz) {
295 auto on_message = [
this](
auto&& msg) { this->on_received_message(msg); };
296 osc_packet_processor<decltype(on_message)>{on_message}((
const char*)data, sz);
300 osc_generic_server_protocol(
const osc_generic_server_protocol&) =
delete;
301 osc_generic_server_protocol(osc_generic_server_protocol&&) =
delete;
302 osc_generic_server_protocol& operator=(
const osc_generic_server_protocol&) =
delete;
303 osc_generic_server_protocol& operator=(osc_generic_server_protocol&&) =
delete;
305 ~osc_generic_server_protocol()
override =
default;
313 return OscMode::observe(*
this, parameter_base, enable);
316 bool echo_incoming_message(
317 const message_origin_identifier&
id,
const parameter_base& addr,
318 const value& val)
override
320 return OscMode::echo_incoming_message(*
this,
id, addr, val);
325 return OscMode::push(*
this, addr, v);
330 return OscMode::push(*
this, addr, std::move(v));
335 return OscMode::push_raw(*
this, addr);
338 bool push_bundle(
const std::vector<const parameter_base*>& addresses)
override
340 return OscMode::push_bundle(*
this, writer(), addresses);
343 bool push_bundle(tcb::span<ossia::bundle_element> addresses)
override
345 return OscMode::push_bundle(*
this, writer(), addresses);
348 bool push_bundle_bounded(tcb::span<ossia::bundle_element> addresses)
override
350 return OscMode::push_bundle_bounded(*
this, writer(), addresses);
354 push_raw_bundle(
const std::vector<ossia::net::full_parameter_data>& addresses)
override
356 return OscMode::push_bundle(*
this, writer(), addresses);
359 void on_received_message(
const oscpack::ReceivedMessage& m)
361 return OscMode::on_received_message(*
this, m);
366 auto writer() noexcept {
return writer_type{m_server}; }
368 using ossia::net::protocol_base::m_logger;
369 ossia::net::network_context_ptr m_ctx;
370 message_origin_identifier m_id;
371 listened_parameters m_listening;
378 template <
typename OscMode,
typename Socket>
379 class osc_generic_client_protocol :
public can_learn<ossia::net::protocol_base>
382 using socket_type = Socket;
383 using writer_type = socket_writer<socket_type>;
385 template <
typename Configuration>
386 osc_generic_client_protocol(network_context_ptr ctx,
const Configuration& conf)
387 : can_learn<
ossia::net::protocol_base>{flags{SupportsMultiplex}}
388 , m_ctx{std::move(ctx)}
390 , m_client{conf, m_ctx->
context}
397 m_client.on_open.connect(this->on_connection_open);
398 m_client.on_close.connect(this->on_connection_closed);
399 m_client.on_fail.connect(this->on_connection_failure);
402 m_client.receive([
this](
const unsigned char* data, std::size_t sz) {
403 auto on_message = [
this](
auto&& msg) { this->on_received_message(msg); };
404 osc_packet_processor<decltype(on_message)>{on_message}((
const char*)data, sz);
408 osc_generic_client_protocol(
const osc_generic_client_protocol&) =
delete;
409 osc_generic_client_protocol(osc_generic_client_protocol&&) =
delete;
410 osc_generic_client_protocol& operator=(
const osc_generic_client_protocol&) =
delete;
411 osc_generic_client_protocol& operator=(osc_generic_client_protocol&&) =
delete;
413 ~osc_generic_client_protocol()
override =
default;
421 return OscMode::observe(*
this, parameter_base, enable);
424 bool echo_incoming_message(
425 const message_origin_identifier&
id,
const parameter_base& addr,
426 const value& val)
override
428 return OscMode::echo_incoming_message(*
this,
id, addr, val);
433 return OscMode::push(*
this, addr, v);
438 return OscMode::push(*
this, addr, std::move(v));
443 return OscMode::push_raw(*
this, addr);
446 bool push_bundle(
const std::vector<const parameter_base*>& addresses)
override
448 return OscMode::push_bundle(*
this, writer(), addresses);
451 bool push_bundle(tcb::span<ossia::bundle_element> addresses)
override
453 return OscMode::push_bundle(*
this, writer(), addresses);
456 bool push_bundle_bounded(tcb::span<ossia::bundle_element> addresses)
override
458 return OscMode::push_bundle_bounded(*
this, writer(), addresses);
462 push_raw_bundle(
const std::vector<ossia::net::full_parameter_data>& addresses)
override
464 return OscMode::push_bundle(*
this, writer(), addresses);
467 void on_received_message(
const oscpack::ReceivedMessage& m)
469 return OscMode::on_received_message(*
this, m);
474 auto writer() noexcept {
return writer_type{m_client}; }
476 bool connected() const noexcept
override {
return m_client.connected(); }
478 void connect()
override {
return m_client.connect(); }
480 using ossia::net::protocol_base::m_logger;
481 ossia::net::network_context_ptr m_ctx;
482 message_origin_identifier m_id;
483 listened_parameters m_listening;
Root of a device tree.
Definition: ossia/network/base/device.hpp:58
The node_base class.
Definition: network/base/node.hpp:48
The parameter_base class.
Definition: ossia/network/base/parameter.hpp:48
The value class.
Definition: value.hpp:173
If using the library, you should create this class at some point.
Definition: context.hpp:27
context()
Most common case.
Definition: context.cpp:73
Full information about a parameter.
Definition: parameter_data.hpp:61