Loading...
Searching...
No Matches
Port.hpp
1#pragma once
2#include <State/Address.hpp>
3#include <State/Domain.hpp>
4#include <State/Unit.hpp>
5
6#include <Device/Address/AddressSettings.hpp>
7
8#include <Process/Dataflow/PortForward.hpp>
9#include <Process/Dataflow/PortType.hpp>
10
11#include <score/model/IdentifiedObject.hpp>
12#include <score/model/path/Path.hpp>
13#include <score/plugins/SerializableInterface.hpp>
14#include <score/selection/Selectable.hpp>
15#include <score/serialization/VisitorInterface.hpp>
16
17#include <ossia/detail/small_vector.hpp>
18#include <ossia/network/value/value.hpp>
19
20#include <QPointF>
21
22#include <score_lib_process_export.h>
23#include <smallfun.hpp>
24
25#include <verdigris>
26
27#if __cpp_constexpr >= 201907
28#define VIRTUAL_CONSTEXPR constexpr
29#else
30#define VIRTUAL_CONSTEXPR
31#endif
32
33namespace ossia
34{
35struct inlet;
36struct outlet;
37}
38namespace Process
39{
40class Port;
41class Inlet;
42class Outlet;
43class ValueInlet;
44class ValueOutlet;
45class AudioInlet;
46class AudioOutlet;
47class MidiInlet;
48class MidiOutlet;
49class ControlInlet;
50class ControlOutlet;
51}
52UUID_METADATA(
53 SCORE_LIB_PROCESS_EXPORT, Process::Port, Process::Inlet,
54 "8884228a-d197-4b0a-b6ca-d1fb15291559")
55UUID_METADATA(
56 SCORE_LIB_PROCESS_EXPORT, Process::Port, Process::Outlet,
57 "34e2c5a7-18c4-4759-b6cc-46feaeee06e2")
58UUID_METADATA(
59 SCORE_LIB_PROCESS_EXPORT, Process::Port, Process::ValueInlet,
60 "769dd38a-bfb3-4dc6-b52a-b6abb7afe2a3")
61UUID_METADATA(
62 SCORE_LIB_PROCESS_EXPORT, Process::Port, Process::ValueOutlet,
63 "cff96158-cc72-46d7-99dc-b6038171375b")
64UUID_METADATA(
65 SCORE_LIB_PROCESS_EXPORT, Process::Port, Process::MidiInlet,
66 "c18adc77-e0e0-4ddf-a46c-43cb0719a890")
67UUID_METADATA(
68 SCORE_LIB_PROCESS_EXPORT, Process::Port, Process::MidiOutlet,
69 "d8a3ed3d-b9c2-46f2-bdb3-d282a48481c6")
70UUID_METADATA(
71 SCORE_LIB_PROCESS_EXPORT, Process::Port, Process::AudioInlet,
72 "a1574bb0-cbd4-4c7d-9417-0c25cfd1187b")
73UUID_METADATA(
74 SCORE_LIB_PROCESS_EXPORT, Process::Port, Process::AudioOutlet,
75 "a1d97535-18ac-444a-8417-0cbc1692d897")
76UUID_METADATA(
77 SCORE_LIB_PROCESS_EXPORT, Process::Port, Process::ControlInlet,
78 "9a13fb32-269a-47bf-99a9-930188c1f19c")
79UUID_METADATA(
80 SCORE_LIB_PROCESS_EXPORT, Process::Port, Process::ControlOutlet,
81 "3620ea94-5991-41cf-89b3-11f842cc39d0")
82namespace Process
83{
84
85// Used to know where to layout items for a given
86// kind of port.
87static constexpr const qreal default_margin = 5.;
88static constexpr const qreal default_padding = 5.;
89
90struct PortItemLayout
91{
92 QPointF port{0., 1.};
93 QPointF label{12., 0.};
94 QPointF control{0., 12.};
95 Qt::Alignment labelAlignment{};
96 Qt::Alignment controlAlignment{};
97 bool labelVisible{true};
98};
99
100class Cable;
101class SCORE_LIB_PROCESS_EXPORT Port
102 : public IdentifiedObject<Port>
103 , public score::SerializableInterface<Port>
104{
105 W_OBJECT(Port)
106 SCORE_SERIALIZE_FRIENDS
107public:
108 Selectable selection{this};
109 bool displayHandledExplicitly{};
110 bool noValueChangeOnMove{};
111 // Declared again by the process when constructing/loading its ports.
112 // Preset reloads match these by identity, not mutable name or row position.
113 bool stableIdentity{};
114
115 void addCable(const Process::Cable& c);
116 void removeCable(const Path<Process::Cable>& c);
117 void takeCables(Process::Port&& c);
118
119 const QString& visualName() const noexcept;
120 const QString& visualDescription() const noexcept;
121
122 const QString& name() const noexcept;
123 const State::AddressAccessor& address() const noexcept;
124 const std::vector<Path<Cable>>& cables() const noexcept;
125 const QString& exposed() const noexcept;
126 const QString& description() const noexcept;
127
132 virtual const State::Unit& unit() const noexcept;
133 void setUnit(State::Unit u) noexcept;
134
135 virtual PortType type() const noexcept = 0;
136
137 virtual Device::FullAddressAccessorSettings settings() const noexcept;
138 virtual void setSettings(const Device::FullAddressAccessorSettings& set) noexcept;
139
140public:
141 void setName(const QString& customData);
142 W_SLOT(setName);
143 void setExposed(const QString& add);
144 W_SLOT(setExposed);
145 void setDescription(const QString& add);
146 W_SLOT(setDescription);
147 void setAddress(const State::AddressAccessor& address);
148 W_SLOT(setAddress);
149
150 void nameChanged(const QString& name)
151 E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, nameChanged, name)
152 void exposedChanged(const QString& addr)
153 E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, exposedChanged, addr)
154 void descriptionChanged(const QString& txt)
155 E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, descriptionChanged, txt)
156 void cablesChanged() E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, cablesChanged)
157 void addressChanged(const State::AddressAccessor& address)
158 E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, addressChanged, address)
159 void executionReset() E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, executionReset)
160
161 PROPERTY(
162 State::AddressAccessor,
163 address W_READ address W_WRITE setAddress W_NOTIFY addressChanged)
164 PROPERTY(QString, name W_READ name W_WRITE setName W_NOTIFY nameChanged)
165 PROPERTY(Process::PortType, type W_READ type W_CONSTANT W_FINAL)
166
167 virtual QByteArray saveData() const noexcept;
168
169 virtual void loadData(const QByteArray& arr, PortLoadDataFlags = {}) noexcept;
170
171protected:
172 Port() = delete;
173 ~Port() override;
174 Port(const Port&) = delete;
175 Port(Id<Port> c, const QString& name, QObject* parent);
176
177 Port(DataStream::Deserializer& vis, QObject* parent);
178 Port(JSONObject::Deserializer& vis, QObject* parent);
179 Port(DataStream::Deserializer&& vis, QObject* parent);
180 Port(JSONObject::Deserializer&& vis, QObject* parent);
181
182protected:
183 std::vector<Path<Cable>> m_cables;
184 QString m_name;
185 QString m_exposed;
186 QString m_description;
187 State::AddressAccessor m_address;
188 State::Unit m_unit;
189};
190
191class SCORE_LIB_PROCESS_EXPORT Inlet : public Port
192{
193 W_OBJECT(Inlet)
194public:
195 using score_base_type = Inlet;
196 MODEL_METADATA_IMPL_HPP(Inlet)
197
198 ~Inlet() override;
199
200 virtual void setupExecution(ossia::inlet&, QObject* exec_context) const noexcept;
201 virtual void forChildInlets(const smallfun::function<void(Inlet&)>&) const noexcept;
202 virtual void mapExecution(
203 ossia::inlet&,
204 const smallfun::function<void(Inlet&, ossia::inlet&)>&) const noexcept;
205
206protected:
207 Inlet() = delete;
208 Inlet(const Inlet&) = delete;
209 Inlet(const QString& name, Id<Process::Port> c, QObject* parent);
210
211 Inlet(DataStream::Deserializer& vis, QObject* parent);
212 Inlet(JSONObject::Deserializer& vis, QObject* parent);
213 Inlet(DataStream::Deserializer&& vis, QObject* parent);
214 Inlet(JSONObject::Deserializer&& vis, QObject* parent);
215};
216
217class SCORE_LIB_PROCESS_EXPORT ControlInlet : public Inlet
218{
219 W_OBJECT(ControlInlet)
220
221 SCORE_SERIALIZE_FRIENDS
222public:
223 MODEL_METADATA_IMPL_HPP(ControlInlet)
224 ControlInlet() = delete;
225 ~ControlInlet() override;
226 ControlInlet(const ControlInlet&) = delete;
227 ControlInlet(const QString& name, Id<Process::Port> c, QObject* parent);
228
229 ControlInlet(DataStream::Deserializer& vis, QObject* parent, bool skip_this = false);
230 ControlInlet(JSONObject::Deserializer& vis, QObject* parent, bool skip_this = false);
231 ControlInlet(DataStream::Deserializer&& vis, QObject* parent, bool skip_this = false);
232 ControlInlet(JSONObject::Deserializer&& vis, QObject* parent, bool skip_this = false);
233
234 VIRTUAL_CONSTEXPR PortType type() const noexcept override
235 {
236 return Process::PortType::Message;
237 }
238
239 const ossia::value& value() const noexcept { return m_value; }
240 const ossia::value& init() const noexcept { return m_init; }
241 const State::Domain& domain() const noexcept { return m_domain; }
242
243 QByteArray saveData() const noexcept override;
244 void loadData(const QByteArray& arr, PortLoadDataFlags = {}) noexcept override;
245
246public:
247 void valueChanged(const ossia::value& v)
248 E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, valueChanged, v)
249 void initChanged(const ossia::value& v)
250 E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, initChanged, v)
251 void executionValueChanged(const ossia::value& v)
252 E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, executionValueChanged, v)
253 void domainChanged(const State::Domain& d)
254 E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, domainChanged, d)
255
256public:
257 virtual void setValue(const ossia::value& value);
258 W_SLOT(setValue)
259 void setInit(const ossia::value& value);
260 W_SLOT(setInit)
261
262 inline void setExecutionValue(const ossia::value& value)
263 {
264 executionValueChanged(value);
265 }
266
267 void setDomain(const State::Domain& d)
268 {
269 if(m_domain != d)
270 {
271 m_domain = d;
272 domainChanged(d);
273 }
274 }
275 W_SLOT(setDomain)
276
277protected:
286 void setDomainWithoutNotifying(const State::Domain& d) noexcept { m_domain = d; }
287
288public:
289
290 PROPERTY(State::Domain, domain W_READ domain W_WRITE setDomain W_NOTIFY domainChanged)
291 PROPERTY(ossia::value, value W_READ value W_WRITE setValue W_NOTIFY valueChanged)
292 PROPERTY(ossia::value, init W_READ init W_WRITE setInit W_NOTIFY initChanged)
293private:
294 ossia::value m_value;
295 ossia::value m_init;
296 State::Domain m_domain;
297};
298
299class SCORE_LIB_PROCESS_EXPORT Outlet : public Port
300{
301 W_OBJECT(Outlet)
302
303 SCORE_SERIALIZE_FRIENDS
304public:
305 using score_base_type = Outlet;
306 MODEL_METADATA_IMPL_HPP(Outlet)
307
308 ~Outlet() override;
309 virtual void setupExecution(ossia::outlet&, QObject* exec_context) const noexcept;
310 virtual void forChildInlets(const smallfun::function<void(Inlet&)>&) const noexcept;
311 virtual void mapExecution(
312 ossia::outlet&,
313 const smallfun::function<void(Inlet&, ossia::inlet&)>&) const noexcept;
314
315protected:
316 Outlet() = delete;
317 Outlet(const Outlet&) = delete;
318 Outlet(const QString& name, Id<Process::Port> c, QObject* parent);
319
320 Outlet(DataStream::Deserializer& vis, QObject* parent);
321 Outlet(JSONObject::Deserializer& vis, QObject* parent);
322 Outlet(DataStream::Deserializer&& vis, QObject* parent);
323 Outlet(JSONObject::Deserializer&& vis, QObject* parent);
324};
325
326class SCORE_LIB_PROCESS_EXPORT AudioInlet : public Inlet
327{
328 W_OBJECT(AudioInlet)
329
330 SCORE_SERIALIZE_FRIENDS
331public:
332 MODEL_METADATA_IMPL_HPP(AudioInlet)
333 AudioInlet() = delete;
334 ~AudioInlet() override;
335 AudioInlet(const AudioInlet&) = delete;
336 AudioInlet(const QString& name, Id<Process::Port> c, QObject* parent);
337
338 AudioInlet(DataStream::Deserializer& vis, QObject* parent);
339 AudioInlet(JSONObject::Deserializer& vis, QObject* parent);
340 AudioInlet(DataStream::Deserializer&& vis, QObject* parent);
341 AudioInlet(JSONObject::Deserializer&& vis, QObject* parent);
342
343 VIRTUAL_CONSTEXPR PortType type() const noexcept override
344 {
345 return Process::PortType::Audio;
346 }
347};
348
349class SCORE_LIB_PROCESS_EXPORT AudioOutlet : public Outlet
350{
351 W_OBJECT(AudioOutlet)
352
353 SCORE_SERIALIZE_FRIENDS
354public:
355 MODEL_METADATA_IMPL_HPP(AudioOutlet)
356 AudioOutlet() = delete;
357 ~AudioOutlet() override;
358 AudioOutlet(const AudioOutlet&) = delete;
359 AudioOutlet(const QString& name, Id<Process::Port> c, QObject* parent);
360
361 AudioOutlet(DataStream::Deserializer& vis, QObject* parent);
362 AudioOutlet(JSONObject::Deserializer& vis, QObject* parent);
363 AudioOutlet(DataStream::Deserializer&& vis, QObject* parent);
364 AudioOutlet(JSONObject::Deserializer&& vis, QObject* parent);
365
366 VIRTUAL_CONSTEXPR PortType type() const noexcept override
367 {
368 return Process::PortType::Audio;
369 }
370
371 void forChildInlets(const smallfun::function<void(Inlet&)>&) const noexcept override;
372 void mapExecution(
373 ossia::outlet&,
374 const smallfun::function<void(Inlet&, ossia::inlet&)>&) const noexcept override;
375
376 QByteArray saveData() const noexcept override;
377 void loadData(const QByteArray& arr, PortLoadDataFlags = {}) noexcept override;
378
379 bool propagate() const;
380 void setPropagate(bool propagate);
381 void propagateChanged(bool propagate)
382 E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, propagateChanged, propagate)
383
384 double gain() const;
385 void setGain(double g);
386 void gainChanged(double g) E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, gainChanged, g)
387
388 pan_weight pan() const;
389 void setPan(pan_weight g);
390 void panChanged(pan_weight g) E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, panChanged, g)
391
392 std::unique_ptr<Process::ControlInlet> gainInlet;
393 std::unique_ptr<Process::ControlInlet> panInlet;
394
395 PROPERTY(
396 bool, propagate W_READ propagate W_WRITE setPropagate W_NOTIFY propagateChanged)
397 PROPERTY(double, gain W_READ gain W_WRITE setGain W_NOTIFY gainChanged)
398 PROPERTY(pan_weight, pan W_READ pan W_WRITE setPan W_NOTIFY panChanged)
399private:
400 double m_gain{};
401 pan_weight m_pan;
402 bool m_propagate{false};
403};
404
405class SCORE_LIB_PROCESS_EXPORT MidiInlet : public Inlet
406{
407 W_OBJECT(MidiInlet)
408
409 SCORE_SERIALIZE_FRIENDS
410public:
411 MODEL_METADATA_IMPL_HPP(MidiInlet)
412 MidiInlet() = delete;
413 ~MidiInlet() override;
414 MidiInlet(const MidiInlet&) = delete;
415 MidiInlet(const QString& name, Id<Process::Port> c, QObject* parent);
416
417 MidiInlet(DataStream::Deserializer& vis, QObject* parent);
418 MidiInlet(JSONObject::Deserializer& vis, QObject* parent);
419 MidiInlet(DataStream::Deserializer&& vis, QObject* parent);
420 MidiInlet(JSONObject::Deserializer&& vis, QObject* parent);
421
422 VIRTUAL_CONSTEXPR PortType type() const noexcept override
423 {
424 return Process::PortType::Midi;
425 }
426};
427
428class SCORE_LIB_PROCESS_EXPORT MidiOutlet : public Outlet
429{
430 W_OBJECT(MidiOutlet)
431
432 SCORE_SERIALIZE_FRIENDS
433public:
434 MODEL_METADATA_IMPL_HPP(MidiOutlet)
435 MidiOutlet() = delete;
436 ~MidiOutlet() override;
437 MidiOutlet(const MidiOutlet&) = delete;
438 MidiOutlet(const QString& name, Id<Process::Port> c, QObject* parent);
439
440 MidiOutlet(DataStream::Deserializer& vis, QObject* parent);
441 MidiOutlet(JSONObject::Deserializer& vis, QObject* parent);
442 MidiOutlet(DataStream::Deserializer&& vis, QObject* parent);
443 MidiOutlet(JSONObject::Deserializer&& vis, QObject* parent);
444
445 VIRTUAL_CONSTEXPR PortType type() const noexcept override
446 {
447 return Process::PortType::Midi;
448 }
449};
450
451class SCORE_LIB_PROCESS_EXPORT ControlOutlet : public Outlet
452{
453 W_OBJECT(ControlOutlet)
454
455 SCORE_SERIALIZE_FRIENDS
456public:
457 MODEL_METADATA_IMPL_HPP(ControlOutlet)
458 ControlOutlet() = delete;
459 ControlOutlet(const Outlet&) = delete;
460 ControlOutlet(const QString& name, Id<Process::Port> c, QObject* parent);
461 ~ControlOutlet() override;
462
463 ControlOutlet(DataStream::Deserializer& vis, QObject* parent);
464 ControlOutlet(JSONObject::Deserializer& vis, QObject* parent);
465 ControlOutlet(DataStream::Deserializer&& vis, QObject* parent);
466 ControlOutlet(JSONObject::Deserializer&& vis, QObject* parent);
467
468 VIRTUAL_CONSTEXPR PortType type() const noexcept override
469 {
470 return Process::PortType::Message;
471 }
472
473 QByteArray saveData() const noexcept override;
474 void loadData(const QByteArray& arr, PortLoadDataFlags = {}) noexcept override;
475
476 const ossia::value& value() const { return m_value; }
477 const State::Domain& domain() const { return m_domain; }
478
479public:
480 void valueChanged(const ossia::value& v)
481 E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, valueChanged, v)
482 void executionValueChanged(const ossia::value& v)
483 E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, executionValueChanged, v)
484 void domainChanged(const State::Domain& d)
485 E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, domainChanged, d)
486
487public:
488 void setExecutionValue(const ossia::value& value) { executionValueChanged(value); }
489
490 void setValue(const ossia::value& value)
491 {
492 if(value != m_value)
493 {
494 m_value = value;
495 valueChanged(value);
496 }
497 }
498 W_SLOT(setValue)
499
500 void setDomain(const State::Domain& d)
501 {
502 if(m_domain != d)
503 {
504 m_domain = d;
505 domainChanged(d);
506 }
507 }
508 W_SLOT(setDomain)
509
510 PROPERTY(State::Domain, domain W_READ domain W_WRITE setDomain W_NOTIFY domainChanged)
511 PROPERTY(ossia::value, value W_READ value W_WRITE setValue W_NOTIFY valueChanged)
512private:
513 ossia::value m_value;
514 State::Domain m_domain;
515};
516
517class SCORE_LIB_PROCESS_EXPORT ValueInlet : public Inlet
518{
519 W_OBJECT(ValueInlet)
520
521 SCORE_SERIALIZE_FRIENDS
522public:
523 MODEL_METADATA_IMPL_HPP(ValueInlet)
524 ValueInlet() = delete;
525 ~ValueInlet() override;
526 ValueInlet(const ValueInlet&) = delete;
527 ValueInlet(const QString& name, Id<Process::Port> c, QObject* parent);
528
529 ValueInlet(DataStream::Deserializer& vis, QObject* parent);
530 ValueInlet(JSONObject::Deserializer& vis, QObject* parent);
531 ValueInlet(DataStream::Deserializer&& vis, QObject* parent);
532 ValueInlet(JSONObject::Deserializer&& vis, QObject* parent);
533
534 QByteArray saveData() const noexcept override;
535 void loadData(const QByteArray& arr, PortLoadDataFlags = {}) noexcept override;
536
537 VIRTUAL_CONSTEXPR PortType type() const noexcept override
538 {
539 return Process::PortType::Message;
540 }
541};
542
543class SCORE_LIB_PROCESS_EXPORT ValueOutlet : public Outlet
544{
545 W_OBJECT(ValueOutlet)
546
547 SCORE_SERIALIZE_FRIENDS
548public:
549 MODEL_METADATA_IMPL_HPP(ValueOutlet)
550 ValueOutlet() = delete;
551 ~ValueOutlet() override;
552 ValueOutlet(const ValueOutlet&) = delete;
553 ValueOutlet(const QString& name, Id<Process::Port> c, QObject* parent);
554
555 ValueOutlet(DataStream::Deserializer& vis, QObject* parent);
556 ValueOutlet(JSONObject::Deserializer& vis, QObject* parent);
557 ValueOutlet(DataStream::Deserializer&& vis, QObject* parent);
558 ValueOutlet(JSONObject::Deserializer&& vis, QObject* parent);
559
560 VIRTUAL_CONSTEXPR PortType type() const noexcept override
561 {
562 return Process::PortType::Message;
563 }
564};
565
566}
567
568DEFAULT_MODEL_METADATA(Process::Port, "Port")
569
570W_REGISTER_ARGTYPE(Id<Process::Port>)
571W_REGISTER_ARGTYPE(Process::Port)
572W_REGISTER_ARGTYPE(Process::Inlet)
573W_REGISTER_ARGTYPE(Process::Outlet)
574W_REGISTER_ARGTYPE(Process::ControlInlet)
575W_REGISTER_ARGTYPE(Process::ControlOutlet)
576W_REGISTER_ARGTYPE(Process::ValueInlet)
577W_REGISTER_ARGTYPE(Process::ValueOutlet)
578W_REGISTER_ARGTYPE(Process::MidiInlet)
579W_REGISTER_ARGTYPE(Process::MidiOutlet)
580W_REGISTER_ARGTYPE(Process::AudioInlet)
581W_REGISTER_ARGTYPE(Process::AudioOutlet)
582
583W_REGISTER_ARGTYPE(Process::Port*)
584W_REGISTER_ARGTYPE(Process::Inlet*)
585W_REGISTER_ARGTYPE(Process::Outlet*)
586W_REGISTER_ARGTYPE(Process::ControlInlet*)
587W_REGISTER_ARGTYPE(Process::ControlOutlet*)
588W_REGISTER_ARGTYPE(Process::ValueInlet*)
589W_REGISTER_ARGTYPE(Process::ValueOutlet*)
590W_REGISTER_ARGTYPE(Process::MidiInlet*)
591W_REGISTER_ARGTYPE(Process::MidiOutlet*)
592W_REGISTER_ARGTYPE(Process::AudioInlet*)
593W_REGISTER_ARGTYPE(Process::AudioOutlet*)
594// Q_DECLARE_METATYPE(Process::pan_weight)
595W_REGISTER_ARGTYPE(Process::pan_weight)
DataStreamWriter
Definition DataStreamVisitor.hpp:202
IdentifiedObject
The IdentifiedObject class.
Definition IdentifiedObject.hpp:19
JSONWriter
Definition JSONVisitor.hpp:423
Path
The Path class is a typesafe wrapper around ObjectPath.
Definition Path.hpp:52
Process::AudioInlet
Definition Port.hpp:327
Process::AudioOutlet
Definition Port.hpp:350
Process::Cable
Definition Cable.hpp:38
Process::ControlInlet
Definition Port.hpp:218
Process::ControlInlet::setDomainWithoutNotifying
void setDomainWithoutNotifying(const State::Domain &d) noexcept
Definition Port.hpp:286
Process::ControlOutlet
Definition Port.hpp:452
Process::Inlet
Definition Port.hpp:192
Process::MidiInlet
Definition Port.hpp:406
Process::MidiOutlet
Definition Port.hpp:429
Process::Outlet
Definition Port.hpp:300
Process::Port
Definition Port.hpp:104
Process::ValueInlet
Definition Port.hpp:518
Process::ValueOutlet
Definition Port.hpp:544
Selectable
The Selectable class.
Definition Selectable.hpp:14
id_base_t
The id_base_t class.
Definition Identifier.hpp:59
score::SerializableInterface
Generic serialization method for abstract classes.
Definition SerializableInterface.hpp:21
Process
Base classes and tools to implement processes and layers.
Definition JSONVisitor.hpp:1115
Device::FullAddressAccessorSettings
Definition AddressSettings.hpp:131
Process::PortItemLayout
Definition Port.hpp:91
Process::pan_weight
Definition PortForward.hpp:31
State::AddressAccessor
Definition Address.hpp:108
State::Domain
Definition Domain.hpp:17
State::Unit
Definition Unit.hpp:18