YARP
Yet Another Robot Platform
 
Loading...
Searching...
No Matches
PortCoreMsgs.cpp
Go to the documentation of this file.
1/*
2 * SPDX-FileCopyrightText: 2006-2021 Istituto Italiano di Tecnologia (IIT)
3 * SPDX-License-Identifier: BSD-3-Clause
4 */
5
6// Autogenerated by Thrift (based on compiler 0.14.1-yarped)
7// yarpidl_thrift version 2.0 - 11/11/2026
8// Protocol version: protocol_version=0, yarp_major=4, yarp_minor=0, yarp_patch=2
9// This is an automatically generated file.
10// It could get re-generated if the ALLOW_IDL_GENERATION flag is on.
11
12#include <yarp/conf/version.h>
15#include <yarp/os/LogStream.h>
16
18
19#include <algorithm>
20
21namespace
22{
23 YARP_LOG_COMPONENT(SERVICE_LOG_COMPONENT, "PortCoreMsgs")
24}
25
26namespace yarp::os {
27
28//PortCoreMsgs_getRemoteProtocolVersion_helper declaration
39
41{
42 yarp::os::idl::WireWriter writer(connection);
43 if (!writer.writeListHeader(1)) {
44 return false;
45 }
46 if (!writer.writeString("getRemoteProtocolVersion")) {
47 return false;
48 }
49 return true;
50}
51
52bool PortCoreMsgs_getRemoteProtocolVersion_helper ::read(yarp::os::ConnectionReader & connection)
53 {
54 yarp::os::idl::WireReader reader(connection);
55 if (!reader.readListHeader()) {
56 reader.fail();
57 return false;
58 }
59
60 if (!helper_proto.read(connection)) {
61 reader.fail();
62 return false;
63 }
64 return true;
65}
66
67//ProtocolVersion, client side
69 {
70 if(!yarp().canWrite()) {
71 yError(" Missing server method PortCoreMsgs::getRemoteProtocolVersion");
72 }
74 bool ok = yarp().write(helper, helper);
75 if (ok) {
76 return helper.helper_proto;}
77 else {
79 return failureproto;}
80}
81
82//ProtocolVersion, client side
84 {
85 auto locproto = this->getLocalProtocolVersion();
87 if (remproto.protocol_version != locproto.protocol_version)
88 {
89 yCError(SERVICE_LOG_COMPONENT) << "Invalid communication protocol.";
90 yCError(SERVICE_LOG_COMPONENT) << "Local Protocol Version: " << locproto.toString();
91 yCError(SERVICE_LOG_COMPONENT) << "Remote Protocol Version: " << remproto.toString();
92 return false;
93 }
94 return true;
95}
96
97//ProtocolVersion, server side
99{
101 //myproto.protocol_version using default value = 0
102 //to change this value add the following line to the .thrift file:
103 //const i16 protocol_version = <your_number_here>
104 myproto.protocol_version = 0;
105 myproto.yarp_major = YARP_VERSION_MAJOR;
106 myproto.yarp_minor = YARP_VERSION_MINOR;
107 myproto.yarp_patch = YARP_VERSION_PATCH;
108 return myproto;
109}
110
111// addConnection helper class declaration
113 public yarp::os::Portable
114{
115public:
117 PortCoreMsgs_addConnection_helper(const std::string& portname, const std::string& carrier);
118 bool write(yarp::os::ConnectionWriter& connection) const override;
119 bool read(yarp::os::ConnectionReader& connection) override;
120
121 class Command :
123 {
124 public:
125 Command() = default;
126 Command(const std::string& portname, const std::string& carrier);
127
128 ~Command() override = default;
129
130 bool write(yarp::os::ConnectionWriter& connection) const override;
131 bool read(yarp::os::ConnectionReader& connection) override;
132
133 bool write(const yarp::os::idl::WireWriter& writer) const override;
134 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
135 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
136
137 bool read(yarp::os::idl::WireReader& reader) override;
140
141 std::string portname{};
142 std::string carrier{""};
143 };
144
145 class Reply :
147 {
148 public:
149 Reply() = default;
150 ~Reply() override = default;
151
152 bool write(yarp::os::ConnectionWriter& connection) const override;
153 bool read(yarp::os::ConnectionReader& connection) override;
154
155 bool write(const yarp::os::idl::WireWriter& writer) const override;
156 bool read(yarp::os::idl::WireReader& reader) override;
157
159 };
160
161 using funcptr_t = return_addConnection (*)(const std::string&, const std::string&);
162 void call(PortCoreMsgs* ptr);
163
166
167 static constexpr const char* s_tag{"addConnection"};
168 static constexpr size_t s_tag_len{1};
169 static constexpr size_t s_cmd_len{3};
170 static constexpr size_t s_reply_len{3};
171 static constexpr const char* s_prototype{"return_addConnection PortCoreMsgs::addConnection(const std::string& portname, const std::string& carrier)"};
172 static constexpr const char* s_help{
173 "Add an output connection from this port to another port.\n"
174 "@param portname the destination port of the connection\n"
175 "@param carrier the carrier of the connection, e.g. tcp, udp, fast_tcp (optional, the default carrier is used if empty)\n"
176 "@return success: true if the connection has been added; message: a description of the result"
177 };
178};
179
180// delConnection helper class declaration
182 public yarp::os::Portable
183{
184public:
186 explicit PortCoreMsgs_delConnection_helper(const std::string& portname);
187 bool write(yarp::os::ConnectionWriter& connection) const override;
188 bool read(yarp::os::ConnectionReader& connection) override;
189
190 class Command :
192 {
193 public:
194 Command() = default;
195 explicit Command(const std::string& portname);
196
197 ~Command() override = default;
198
199 bool write(yarp::os::ConnectionWriter& connection) const override;
200 bool read(yarp::os::ConnectionReader& connection) override;
201
202 bool write(const yarp::os::idl::WireWriter& writer) const override;
203 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
204 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
205
206 bool read(yarp::os::idl::WireReader& reader) override;
209
210 std::string portname{};
211 };
212
213 class Reply :
215 {
216 public:
217 Reply() = default;
218 ~Reply() override = default;
219
220 bool write(yarp::os::ConnectionWriter& connection) const override;
221 bool read(yarp::os::ConnectionReader& connection) override;
222
223 bool write(const yarp::os::idl::WireWriter& writer) const override;
224 bool read(yarp::os::idl::WireReader& reader) override;
225
227 };
228
229 using funcptr_t = return_delConnection (*)(const std::string&);
230 void call(PortCoreMsgs* ptr);
231
234
235 static constexpr const char* s_tag{"delConnection"};
236 static constexpr size_t s_tag_len{1};
237 static constexpr size_t s_cmd_len{2};
238 static constexpr size_t s_reply_len{3};
239 static constexpr const char* s_prototype{"return_delConnection PortCoreMsgs::delConnection(const std::string& portname)"};
240 static constexpr const char* s_help{
241 "Remove all the input and output connections between this port and another port.\n"
242 "@param portname the port at the other end of the connection(s)\n"
243 "@return success: true if at least one connection has been removed; message: a description of the result"
244 };
245};
246
247// attachPortmonitorOut helper class declaration
249 public yarp::os::Portable
250{
251public:
253 explicit PortCoreMsgs_attachPortmonitorOut_helper(const std::string& prop);
254 bool write(yarp::os::ConnectionWriter& connection) const override;
255 bool read(yarp::os::ConnectionReader& connection) override;
256
257 class Command :
259 {
260 public:
261 Command() = default;
262 explicit Command(const std::string& prop);
263
264 ~Command() override = default;
265
266 bool write(yarp::os::ConnectionWriter& connection) const override;
267 bool read(yarp::os::ConnectionReader& connection) override;
268
269 bool write(const yarp::os::idl::WireWriter& writer) const override;
270 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
271 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
272
273 bool read(yarp::os::idl::WireReader& reader) override;
276
277 std::string prop{};
278 };
279
280 class Reply :
282 {
283 public:
284 Reply() = default;
285 ~Reply() override = default;
286
287 bool write(yarp::os::ConnectionWriter& connection) const override;
288 bool read(yarp::os::ConnectionReader& connection) override;
289
290 bool write(const yarp::os::idl::WireWriter& writer) const override;
291 bool read(yarp::os::idl::WireReader& reader) override;
292
293 bool return_helper{false};
294 };
295
296 using funcptr_t = bool (*)(const std::string&);
297 void call(PortCoreMsgs* ptr);
298
301
302 static constexpr const char* s_tag{"attachPortmonitorOut"};
303 static constexpr size_t s_tag_len{1};
304 static constexpr size_t s_cmd_len{2};
305 static constexpr size_t s_reply_len{1};
306 static constexpr const char* s_prototype{"bool PortCoreMsgs::attachPortmonitorOut(const std::string& prop)"};
307 static constexpr const char* s_help{
308 "Attach a portmonitor plug-in to the output of this port (it replaces the one previously attached, if any).\n"
309 "@param prop the portmonitor configuration, in yarp::os::Property format, e.g. \"(type dll) (file test_numbers1)\" or \"(context yarpviz) (file portrate)\"\n"
310 "@return true if the portmonitor has been attached"
311 };
312};
313
314// attachPortmonitorIn helper class declaration
316 public yarp::os::Portable
317{
318public:
320 explicit PortCoreMsgs_attachPortmonitorIn_helper(const std::string& prop);
321 bool write(yarp::os::ConnectionWriter& connection) const override;
322 bool read(yarp::os::ConnectionReader& connection) override;
323
324 class Command :
326 {
327 public:
328 Command() = default;
329 explicit Command(const std::string& prop);
330
331 ~Command() override = default;
332
333 bool write(yarp::os::ConnectionWriter& connection) const override;
334 bool read(yarp::os::ConnectionReader& connection) override;
335
336 bool write(const yarp::os::idl::WireWriter& writer) const override;
337 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
338 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
339
340 bool read(yarp::os::idl::WireReader& reader) override;
343
344 std::string prop{};
345 };
346
347 class Reply :
349 {
350 public:
351 Reply() = default;
352 ~Reply() override = default;
353
354 bool write(yarp::os::ConnectionWriter& connection) const override;
355 bool read(yarp::os::ConnectionReader& connection) override;
356
357 bool write(const yarp::os::idl::WireWriter& writer) const override;
358 bool read(yarp::os::idl::WireReader& reader) override;
359
360 bool return_helper{false};
361 };
362
363 using funcptr_t = bool (*)(const std::string&);
364 void call(PortCoreMsgs* ptr);
365
368
369 static constexpr const char* s_tag{"attachPortmonitorIn"};
370 static constexpr size_t s_tag_len{1};
371 static constexpr size_t s_cmd_len{2};
372 static constexpr size_t s_reply_len{1};
373 static constexpr const char* s_prototype{"bool PortCoreMsgs::attachPortmonitorIn(const std::string& prop)"};
374 static constexpr const char* s_help{
375 "Attach a portmonitor plug-in to the input of this port (it replaces the one previously attached, if any).\n"
376 "@param prop the portmonitor configuration, in yarp::os::Property format, e.g. \"(type dll) (file test_numbers1)\" or \"(context yarpviz) (file portrate)\"\n"
377 "@return true if the portmonitor has been attached"
378 };
379};
380
381// detachPortmonitorOut helper class declaration
383 public yarp::os::Portable
384{
385public:
387 bool write(yarp::os::ConnectionWriter& connection) const override;
388 bool read(yarp::os::ConnectionReader& connection) override;
389
390 class Command :
392 {
393 public:
394 Command() = default;
395 ~Command() override = default;
396
397 bool write(yarp::os::ConnectionWriter& connection) const override;
398 bool read(yarp::os::ConnectionReader& connection) override;
399
400 bool write(const yarp::os::idl::WireWriter& writer) const override;
401 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
402 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
403
404 bool read(yarp::os::idl::WireReader& reader) override;
407 };
408
409 class Reply :
411 {
412 public:
413 Reply() = default;
414 ~Reply() override = default;
415
416 bool write(yarp::os::ConnectionWriter& connection) const override;
417 bool read(yarp::os::ConnectionReader& connection) override;
418
419 bool write(const yarp::os::idl::WireWriter& writer) const override;
420 bool read(yarp::os::idl::WireReader& reader) override;
421
422 bool return_helper{false};
423 };
424
425 using funcptr_t = bool (*)();
426 void call(PortCoreMsgs* ptr);
427
430
431 static constexpr const char* s_tag{"detachPortmonitorOut"};
432 static constexpr size_t s_tag_len{1};
433 static constexpr size_t s_cmd_len{1};
434 static constexpr size_t s_reply_len{1};
435 static constexpr const char* s_prototype{"bool PortCoreMsgs::detachPortmonitorOut()"};
436 static constexpr const char* s_help{
437 "Detach the portmonitor plug-in from the output of this port.\n"
438 "@return true (also if no portmonitor was attached)"
439 };
440};
441
442// detachPortmonitorIn helper class declaration
444 public yarp::os::Portable
445{
446public:
448 bool write(yarp::os::ConnectionWriter& connection) const override;
449 bool read(yarp::os::ConnectionReader& connection) override;
450
451 class Command :
453 {
454 public:
455 Command() = default;
456 ~Command() override = default;
457
458 bool write(yarp::os::ConnectionWriter& connection) const override;
459 bool read(yarp::os::ConnectionReader& connection) override;
460
461 bool write(const yarp::os::idl::WireWriter& writer) const override;
462 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
463 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
464
465 bool read(yarp::os::idl::WireReader& reader) override;
468 };
469
470 class Reply :
472 {
473 public:
474 Reply() = default;
475 ~Reply() override = default;
476
477 bool write(yarp::os::ConnectionWriter& connection) const override;
478 bool read(yarp::os::ConnectionReader& connection) override;
479
480 bool write(const yarp::os::idl::WireWriter& writer) const override;
481 bool read(yarp::os::idl::WireReader& reader) override;
482
483 bool return_helper{false};
484 };
485
486 using funcptr_t = bool (*)();
487 void call(PortCoreMsgs* ptr);
488
491
492 static constexpr const char* s_tag{"detachPortmonitorIn"};
493 static constexpr size_t s_tag_len{1};
494 static constexpr size_t s_cmd_len{1};
495 static constexpr size_t s_reply_len{1};
496 static constexpr const char* s_prototype{"bool PortCoreMsgs::detachPortmonitorIn()"};
497 static constexpr const char* s_help{
498 "Detach the portmonitor plug-in from the input of this port.\n"
499 "@return true (also if no portmonitor was attached)"
500 };
501};
502
503// setPortmonitorParamsOut helper class declaration
505 public yarp::os::Portable
506{
507public:
509 explicit PortCoreMsgs_setPortmonitorParamsOut_helper(const std::string& params);
510 bool write(yarp::os::ConnectionWriter& connection) const override;
511 bool read(yarp::os::ConnectionReader& connection) override;
512
513 class Command :
515 {
516 public:
517 Command() = default;
518 explicit Command(const std::string& params);
519
520 ~Command() override = default;
521
522 bool write(yarp::os::ConnectionWriter& connection) const override;
523 bool read(yarp::os::ConnectionReader& connection) override;
524
525 bool write(const yarp::os::idl::WireWriter& writer) const override;
526 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
527 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
528
529 bool read(yarp::os::idl::WireReader& reader) override;
532
533 std::string params{};
534 };
535
536 class Reply :
538 {
539 public:
540 Reply() = default;
541 ~Reply() override = default;
542
543 bool write(yarp::os::ConnectionWriter& connection) const override;
544 bool read(yarp::os::ConnectionReader& connection) override;
545
546 bool write(const yarp::os::idl::WireWriter& writer) const override;
547 bool read(yarp::os::idl::WireReader& reader) override;
548
550 };
551
552 using funcptr_t = return_setPortmonitorParams (*)(const std::string&);
553 void call(PortCoreMsgs* ptr);
554
557
558 static constexpr const char* s_tag{"setPortmonitorParamsOut"};
559 static constexpr size_t s_tag_len{1};
560 static constexpr size_t s_cmd_len{2};
561 static constexpr size_t s_reply_len{3};
562 static constexpr const char* s_prototype{"return_setPortmonitorParams PortCoreMsgs::setPortmonitorParamsOut(const std::string& params)"};
563 static constexpr const char* s_help{
564 "Set the parameters of the portmonitor plug-in attached to the output of this port.\n"
565 "@param params the parameters, in yarp::os::Property format, e.g. \"(log_save 1)\"; their meaning depends on the portmonitor\n"
566 "@return success: false if no portmonitor is attached; message: a description of the error (if any)"
567 };
568};
569
570// setPortmonitorParamsIn helper class declaration
572 public yarp::os::Portable
573{
574public:
576 explicit PortCoreMsgs_setPortmonitorParamsIn_helper(const std::string& params);
577 bool write(yarp::os::ConnectionWriter& connection) const override;
578 bool read(yarp::os::ConnectionReader& connection) override;
579
580 class Command :
582 {
583 public:
584 Command() = default;
585 explicit Command(const std::string& params);
586
587 ~Command() override = default;
588
589 bool write(yarp::os::ConnectionWriter& connection) const override;
590 bool read(yarp::os::ConnectionReader& connection) override;
591
592 bool write(const yarp::os::idl::WireWriter& writer) const override;
593 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
594 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
595
596 bool read(yarp::os::idl::WireReader& reader) override;
599
600 std::string params{};
601 };
602
603 class Reply :
605 {
606 public:
607 Reply() = default;
608 ~Reply() override = default;
609
610 bool write(yarp::os::ConnectionWriter& connection) const override;
611 bool read(yarp::os::ConnectionReader& connection) override;
612
613 bool write(const yarp::os::idl::WireWriter& writer) const override;
614 bool read(yarp::os::idl::WireReader& reader) override;
615
617 };
618
619 using funcptr_t = return_setPortmonitorParams (*)(const std::string&);
620 void call(PortCoreMsgs* ptr);
621
624
625 static constexpr const char* s_tag{"setPortmonitorParamsIn"};
626 static constexpr size_t s_tag_len{1};
627 static constexpr size_t s_cmd_len{2};
628 static constexpr size_t s_reply_len{3};
629 static constexpr const char* s_prototype{"return_setPortmonitorParams PortCoreMsgs::setPortmonitorParamsIn(const std::string& params)"};
630 static constexpr const char* s_help{
631 "Set the parameters of the portmonitor plug-in attached to the input of this port.\n"
632 "@param params the parameters, in yarp::os::Property format, e.g. \"(log_save 1)\"; their meaning depends on the portmonitor\n"
633 "@return success: false if no portmonitor is attached; message: a description of the error (if any)"
634 };
635};
636
637// getPortmonitorParamsOut helper class declaration
639 public yarp::os::Portable
640{
641public:
643 bool write(yarp::os::ConnectionWriter& connection) const override;
644 bool read(yarp::os::ConnectionReader& connection) override;
645
646 class Command :
648 {
649 public:
650 Command() = default;
651 ~Command() override = default;
652
653 bool write(yarp::os::ConnectionWriter& connection) const override;
654 bool read(yarp::os::ConnectionReader& connection) override;
655
656 bool write(const yarp::os::idl::WireWriter& writer) const override;
657 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
658 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
659
660 bool read(yarp::os::idl::WireReader& reader) override;
663 };
664
665 class Reply :
667 {
668 public:
669 Reply() = default;
670 ~Reply() override = default;
671
672 bool write(yarp::os::ConnectionWriter& connection) const override;
673 bool read(yarp::os::ConnectionReader& connection) override;
674
675 bool write(const yarp::os::idl::WireWriter& writer) const override;
676 bool read(yarp::os::idl::WireReader& reader) override;
677
679 };
680
682 void call(PortCoreMsgs* ptr);
683
686
687 static constexpr const char* s_tag{"getPortmonitorParamsOut"};
688 static constexpr size_t s_tag_len{1};
689 static constexpr size_t s_cmd_len{1};
690 static constexpr size_t s_reply_len{4};
691 static constexpr const char* s_prototype{"return_getPortmonitorParams PortCoreMsgs::getPortmonitorParamsOut()"};
692 static constexpr const char* s_help{
693 "Get the parameters of the portmonitor plug-in attached to the output of this port.\n"
694 "@return success: false if no portmonitor is attached; params: the parameters, in yarp::os::Property format; message: a description of the error (if any)"
695 };
696};
697
698// getPortmonitorParamsIn helper class declaration
700 public yarp::os::Portable
701{
702public:
704 bool write(yarp::os::ConnectionWriter& connection) const override;
705 bool read(yarp::os::ConnectionReader& connection) override;
706
707 class Command :
709 {
710 public:
711 Command() = default;
712 ~Command() override = default;
713
714 bool write(yarp::os::ConnectionWriter& connection) const override;
715 bool read(yarp::os::ConnectionReader& connection) override;
716
717 bool write(const yarp::os::idl::WireWriter& writer) const override;
718 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
719 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
720
721 bool read(yarp::os::idl::WireReader& reader) override;
724 };
725
726 class Reply :
728 {
729 public:
730 Reply() = default;
731 ~Reply() override = default;
732
733 bool write(yarp::os::ConnectionWriter& connection) const override;
734 bool read(yarp::os::ConnectionReader& connection) override;
735
736 bool write(const yarp::os::idl::WireWriter& writer) const override;
737 bool read(yarp::os::idl::WireReader& reader) override;
738
740 };
741
743 void call(PortCoreMsgs* ptr);
744
747
748 static constexpr const char* s_tag{"getPortmonitorParamsIn"};
749 static constexpr size_t s_tag_len{1};
750 static constexpr size_t s_cmd_len{1};
751 static constexpr size_t s_reply_len{4};
752 static constexpr const char* s_prototype{"return_getPortmonitorParams PortCoreMsgs::getPortmonitorParamsIn()"};
753 static constexpr const char* s_help{
754 "Get the parameters of the portmonitor plug-in attached to the input of this port.\n"
755 "@return success: false if no portmonitor is attached; params: the parameters, in yarp::os::Property format; message: a description of the error (if any)"
756 };
757};
758
759// setConnectionParamsOut helper class declaration
761 public yarp::os::Portable
762{
763public:
765 PortCoreMsgs_setConnectionParamsOut_helper(const std::string& portname, const std::string& params);
766 bool write(yarp::os::ConnectionWriter& connection) const override;
767 bool read(yarp::os::ConnectionReader& connection) override;
768
769 class Command :
771 {
772 public:
773 Command() = default;
774 Command(const std::string& portname, const std::string& params);
775
776 ~Command() override = default;
777
778 bool write(yarp::os::ConnectionWriter& connection) const override;
779 bool read(yarp::os::ConnectionReader& connection) override;
780
781 bool write(const yarp::os::idl::WireWriter& writer) const override;
782 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
783 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
784
785 bool read(yarp::os::idl::WireReader& reader) override;
788
789 std::string portname{};
790 std::string params{};
791 };
792
793 class Reply :
795 {
796 public:
797 Reply() = default;
798 ~Reply() override = default;
799
800 bool write(yarp::os::ConnectionWriter& connection) const override;
801 bool read(yarp::os::ConnectionReader& connection) override;
802
803 bool write(const yarp::os::idl::WireWriter& writer) const override;
804 bool read(yarp::os::idl::WireReader& reader) override;
805
807 };
808
809 using funcptr_t = return_setConnectionParams (*)(const std::string&, const std::string&);
810 void call(PortCoreMsgs* ptr);
811
814
815 static constexpr const char* s_tag{"setConnectionParamsOut"};
816 static constexpr size_t s_tag_len{1};
817 static constexpr size_t s_cmd_len{3};
818 static constexpr size_t s_reply_len{3};
819 static constexpr const char* s_prototype{"return_setConnectionParams PortCoreMsgs::setConnectionParamsOut(const std::string& portname, const std::string& params)"};
820 static constexpr const char* s_help{
821 "Set the carrier parameters of the output connection going from this port to another port.\n"
822 "@param portname the destination port of the connection\n"
823 "@param params the parameters, in yarp::os::Property format; their meaning depends on the carrier of the connection\n"
824 "@return success: false if there is no such connection; message: a description of the result"
825 };
826};
827
828// setConnectionParamsIn helper class declaration
830 public yarp::os::Portable
831{
832public:
834 PortCoreMsgs_setConnectionParamsIn_helper(const std::string& portname, const std::string& params);
835 bool write(yarp::os::ConnectionWriter& connection) const override;
836 bool read(yarp::os::ConnectionReader& connection) override;
837
838 class Command :
840 {
841 public:
842 Command() = default;
843 Command(const std::string& portname, const std::string& params);
844
845 ~Command() override = default;
846
847 bool write(yarp::os::ConnectionWriter& connection) const override;
848 bool read(yarp::os::ConnectionReader& connection) override;
849
850 bool write(const yarp::os::idl::WireWriter& writer) const override;
851 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
852 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
853
854 bool read(yarp::os::idl::WireReader& reader) override;
857
858 std::string portname{};
859 std::string params{};
860 };
861
862 class Reply :
864 {
865 public:
866 Reply() = default;
867 ~Reply() override = default;
868
869 bool write(yarp::os::ConnectionWriter& connection) const override;
870 bool read(yarp::os::ConnectionReader& connection) override;
871
872 bool write(const yarp::os::idl::WireWriter& writer) const override;
873 bool read(yarp::os::idl::WireReader& reader) override;
874
876 };
877
878 using funcptr_t = return_setConnectionParams (*)(const std::string&, const std::string&);
879 void call(PortCoreMsgs* ptr);
880
883
884 static constexpr const char* s_tag{"setConnectionParamsIn"};
885 static constexpr size_t s_tag_len{1};
886 static constexpr size_t s_cmd_len{3};
887 static constexpr size_t s_reply_len{3};
888 static constexpr const char* s_prototype{"return_setConnectionParams PortCoreMsgs::setConnectionParamsIn(const std::string& portname, const std::string& params)"};
889 static constexpr const char* s_help{
890 "Set the carrier parameters of the input connection coming from another port to this port.\n"
891 "@param portname the source port of the connection\n"
892 "@param params the parameters, in yarp::os::Property format; their meaning depends on the carrier of the connection\n"
893 "@return success: false if there is no such connection; message: a description of the result"
894 };
895};
896
897// getConnectionParamsOut helper class declaration
899 public yarp::os::Portable
900{
901public:
903 explicit PortCoreMsgs_getConnectionParamsOut_helper(const std::string& portname);
904 bool write(yarp::os::ConnectionWriter& connection) const override;
905 bool read(yarp::os::ConnectionReader& connection) override;
906
907 class Command :
909 {
910 public:
911 Command() = default;
912 explicit Command(const std::string& portname);
913
914 ~Command() override = default;
915
916 bool write(yarp::os::ConnectionWriter& connection) const override;
917 bool read(yarp::os::ConnectionReader& connection) override;
918
919 bool write(const yarp::os::idl::WireWriter& writer) const override;
920 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
921 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
922
923 bool read(yarp::os::idl::WireReader& reader) override;
926
927 std::string portname{};
928 };
929
930 class Reply :
932 {
933 public:
934 Reply() = default;
935 ~Reply() override = default;
936
937 bool write(yarp::os::ConnectionWriter& connection) const override;
938 bool read(yarp::os::ConnectionReader& connection) override;
939
940 bool write(const yarp::os::idl::WireWriter& writer) const override;
941 bool read(yarp::os::idl::WireReader& reader) override;
942
944 };
945
946 using funcptr_t = return_getConnectionParams (*)(const std::string&);
947 void call(PortCoreMsgs* ptr);
948
951
952 static constexpr const char* s_tag{"getConnectionParamsOut"};
953 static constexpr size_t s_tag_len{1};
954 static constexpr size_t s_cmd_len{2};
955 static constexpr size_t s_reply_len{4};
956 static constexpr const char* s_prototype{"return_getConnectionParams PortCoreMsgs::getConnectionParamsOut(const std::string& portname)"};
957 static constexpr const char* s_help{
958 "Get the carrier parameters of the output connection going from this port to another port.\n"
959 "@param portname the destination port of the connection\n"
960 "@return success: false if there is no such connection; params: the parameters, in yarp::os::Property format; message: a description of the error (if any)"
961 };
962};
963
964// getConnectionParamsIn helper class declaration
966 public yarp::os::Portable
967{
968public:
970 explicit PortCoreMsgs_getConnectionParamsIn_helper(const std::string& portname);
971 bool write(yarp::os::ConnectionWriter& connection) const override;
972 bool read(yarp::os::ConnectionReader& connection) override;
973
974 class Command :
976 {
977 public:
978 Command() = default;
979 explicit Command(const std::string& portname);
980
981 ~Command() override = default;
982
983 bool write(yarp::os::ConnectionWriter& connection) const override;
984 bool read(yarp::os::ConnectionReader& connection) override;
985
986 bool write(const yarp::os::idl::WireWriter& writer) const override;
987 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
988 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
989
990 bool read(yarp::os::idl::WireReader& reader) override;
993
994 std::string portname{};
995 };
996
997 class Reply :
999 {
1000 public:
1001 Reply() = default;
1002 ~Reply() override = default;
1003
1004 bool write(yarp::os::ConnectionWriter& connection) const override;
1005 bool read(yarp::os::ConnectionReader& connection) override;
1006
1007 bool write(const yarp::os::idl::WireWriter& writer) const override;
1008 bool read(yarp::os::idl::WireReader& reader) override;
1009
1011 };
1012
1013 using funcptr_t = return_getConnectionParams (*)(const std::string&);
1014 void call(PortCoreMsgs* ptr);
1015
1018
1019 static constexpr const char* s_tag{"getConnectionParamsIn"};
1020 static constexpr size_t s_tag_len{1};
1021 static constexpr size_t s_cmd_len{2};
1022 static constexpr size_t s_reply_len{4};
1023 static constexpr const char* s_prototype{"return_getConnectionParams PortCoreMsgs::getConnectionParamsIn(const std::string& portname)"};
1024 static constexpr const char* s_help{
1025 "Get the carrier parameters of the input connection coming from another port to this port.\n"
1026 "@param portname the source port of the connection\n"
1027 "@return success: false if there is no such connection; params: the parameters, in yarp::os::Property format; message: a description of the error (if any)"
1028 };
1029};
1030
1031// listConnectionsIn helper class declaration
1033 public yarp::os::Portable
1034{
1035public:
1037 bool write(yarp::os::ConnectionWriter& connection) const override;
1038 bool read(yarp::os::ConnectionReader& connection) override;
1039
1040 class Command :
1042 {
1043 public:
1044 Command() = default;
1045 ~Command() override = default;
1046
1047 bool write(yarp::os::ConnectionWriter& connection) const override;
1048 bool read(yarp::os::ConnectionReader& connection) override;
1049
1050 bool write(const yarp::os::idl::WireWriter& writer) const override;
1051 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1052 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1053
1054 bool read(yarp::os::idl::WireReader& reader) override;
1055 bool readTag(yarp::os::idl::WireReader& reader);
1056 bool readArgs(yarp::os::idl::WireReader& reader);
1057 };
1058
1059 class Reply :
1061 {
1062 public:
1063 Reply() = default;
1064 ~Reply() override = default;
1065
1066 bool write(yarp::os::ConnectionWriter& connection) const override;
1067 bool read(yarp::os::ConnectionReader& connection) override;
1068
1069 bool write(const yarp::os::idl::WireWriter& writer) const override;
1070 bool read(yarp::os::idl::WireReader& reader) override;
1071
1073 };
1074
1076 void call(PortCoreMsgs* ptr);
1077
1080
1081 static constexpr const char* s_tag{"listConnectionsIn"};
1082 static constexpr size_t s_tag_len{1};
1083 static constexpr size_t s_cmd_len{1};
1084 static constexpr size_t s_reply_len{2};
1085 static constexpr const char* s_prototype{"return_listConnections PortCoreMsgs::listConnectionsIn()"};
1086 static constexpr const char* s_help{
1087 "List the ports connected to the input of this port.\n"
1088 "@return connections: the names of the source ports of the input connections"
1089 };
1090};
1091
1092// listConnectionsOut helper class declaration
1094 public yarp::os::Portable
1095{
1096public:
1098 bool write(yarp::os::ConnectionWriter& connection) const override;
1099 bool read(yarp::os::ConnectionReader& connection) override;
1100
1101 class Command :
1103 {
1104 public:
1105 Command() = default;
1106 ~Command() override = default;
1107
1108 bool write(yarp::os::ConnectionWriter& connection) const override;
1109 bool read(yarp::os::ConnectionReader& connection) override;
1110
1111 bool write(const yarp::os::idl::WireWriter& writer) const override;
1112 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1113 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1114
1115 bool read(yarp::os::idl::WireReader& reader) override;
1116 bool readTag(yarp::os::idl::WireReader& reader);
1117 bool readArgs(yarp::os::idl::WireReader& reader);
1118 };
1119
1120 class Reply :
1122 {
1123 public:
1124 Reply() = default;
1125 ~Reply() override = default;
1126
1127 bool write(yarp::os::ConnectionWriter& connection) const override;
1128 bool read(yarp::os::ConnectionReader& connection) override;
1129
1130 bool write(const yarp::os::idl::WireWriter& writer) const override;
1131 bool read(yarp::os::idl::WireReader& reader) override;
1132
1134 };
1135
1137 void call(PortCoreMsgs* ptr);
1138
1141
1142 static constexpr const char* s_tag{"listConnectionsOut"};
1143 static constexpr size_t s_tag_len{1};
1144 static constexpr size_t s_cmd_len{1};
1145 static constexpr size_t s_reply_len{2};
1146 static constexpr const char* s_prototype{"return_listConnections PortCoreMsgs::listConnectionsOut()"};
1147 static constexpr const char* s_help{
1148 "List the ports connected to the output of this port.\n"
1149 "@return connections: the names of the destination ports of the output connections"
1150 };
1151};
1152
1153// getConnectionInfoIn helper class declaration
1155 public yarp::os::Portable
1156{
1157public:
1159 explicit PortCoreMsgs_getConnectionInfoIn_helper(const std::string& portname);
1160 bool write(yarp::os::ConnectionWriter& connection) const override;
1161 bool read(yarp::os::ConnectionReader& connection) override;
1162
1163 class Command :
1165 {
1166 public:
1167 Command() = default;
1168 explicit Command(const std::string& portname);
1169
1170 ~Command() override = default;
1171
1172 bool write(yarp::os::ConnectionWriter& connection) const override;
1173 bool read(yarp::os::ConnectionReader& connection) override;
1174
1175 bool write(const yarp::os::idl::WireWriter& writer) const override;
1176 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1177 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1178
1179 bool read(yarp::os::idl::WireReader& reader) override;
1180 bool readTag(yarp::os::idl::WireReader& reader);
1181 bool readArgs(yarp::os::idl::WireReader& reader);
1182
1183 std::string portname{};
1184 };
1185
1186 class Reply :
1188 {
1189 public:
1190 Reply() = default;
1191 ~Reply() override = default;
1192
1193 bool write(yarp::os::ConnectionWriter& connection) const override;
1194 bool read(yarp::os::ConnectionReader& connection) override;
1195
1196 bool write(const yarp::os::idl::WireWriter& writer) const override;
1197 bool read(yarp::os::idl::WireReader& reader) override;
1198
1200 };
1201
1202 using funcptr_t = return_getConnectionInfo (*)(const std::string&);
1203 void call(PortCoreMsgs* ptr);
1204
1207
1208 static constexpr const char* s_tag{"getConnectionInfoIn"};
1209 static constexpr size_t s_tag_len{1};
1210 static constexpr size_t s_cmd_len{2};
1211 static constexpr size_t s_reply_len{7};
1212 static constexpr const char* s_prototype{"return_getConnectionInfo PortCoreMsgs::getConnectionInfoIn(const std::string& portname)"};
1213 static constexpr const char* s_help{
1214 "Give details about the input connection coming from another port to this port.\n"
1215 "@param portname the source port of the connection\n"
1216 "@return found: false if there is no such connection; from_port, to_port: the ends of the connection; carrier: the carrier of the connection; connectionless: true if the carrier is connectionless (e.g. udp); push: false if the carrier is reversed (pull)"
1217 };
1218};
1219
1220// getConnectionInfoOut helper class declaration
1222 public yarp::os::Portable
1223{
1224public:
1226 explicit PortCoreMsgs_getConnectionInfoOut_helper(const std::string& portname);
1227 bool write(yarp::os::ConnectionWriter& connection) const override;
1228 bool read(yarp::os::ConnectionReader& connection) override;
1229
1230 class Command :
1232 {
1233 public:
1234 Command() = default;
1235 explicit Command(const std::string& portname);
1236
1237 ~Command() override = default;
1238
1239 bool write(yarp::os::ConnectionWriter& connection) const override;
1240 bool read(yarp::os::ConnectionReader& connection) override;
1241
1242 bool write(const yarp::os::idl::WireWriter& writer) const override;
1243 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1244 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1245
1246 bool read(yarp::os::idl::WireReader& reader) override;
1247 bool readTag(yarp::os::idl::WireReader& reader);
1248 bool readArgs(yarp::os::idl::WireReader& reader);
1249
1250 std::string portname{};
1251 };
1252
1253 class Reply :
1255 {
1256 public:
1257 Reply() = default;
1258 ~Reply() override = default;
1259
1260 bool write(yarp::os::ConnectionWriter& connection) const override;
1261 bool read(yarp::os::ConnectionReader& connection) override;
1262
1263 bool write(const yarp::os::idl::WireWriter& writer) const override;
1264 bool read(yarp::os::idl::WireReader& reader) override;
1265
1267 };
1268
1269 using funcptr_t = return_getConnectionInfo (*)(const std::string&);
1270 void call(PortCoreMsgs* ptr);
1271
1274
1275 static constexpr const char* s_tag{"getConnectionInfoOut"};
1276 static constexpr size_t s_tag_len{1};
1277 static constexpr size_t s_cmd_len{2};
1278 static constexpr size_t s_reply_len{7};
1279 static constexpr const char* s_prototype{"return_getConnectionInfo PortCoreMsgs::getConnectionInfoOut(const std::string& portname)"};
1280 static constexpr const char* s_help{
1281 "Give details about the output connection going from this port to another port.\n"
1282 "@param portname the destination port of the connection\n"
1283 "@return found: false if there is no such connection; from_port, to_port: the ends of the connection; carrier: the carrier of the connection; connectionless: true if the carrier is connectionless (e.g. udp); push: false if the carrier is reversed (pull)"
1284 };
1285};
1286
1287// getAdminProtocolVersion helper class declaration
1289 public yarp::os::Portable
1290{
1291public:
1293 bool write(yarp::os::ConnectionWriter& connection) const override;
1294 bool read(yarp::os::ConnectionReader& connection) override;
1295
1296 class Command :
1298 {
1299 public:
1300 Command() = default;
1301 ~Command() override = default;
1302
1303 bool write(yarp::os::ConnectionWriter& connection) const override;
1304 bool read(yarp::os::ConnectionReader& connection) override;
1305
1306 bool write(const yarp::os::idl::WireWriter& writer) const override;
1307 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1308 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1309
1310 bool read(yarp::os::idl::WireReader& reader) override;
1311 bool readTag(yarp::os::idl::WireReader& reader);
1312 bool readArgs(yarp::os::idl::WireReader& reader);
1313 };
1314
1315 class Reply :
1317 {
1318 public:
1319 Reply() = default;
1320 ~Reply() override = default;
1321
1322 bool write(yarp::os::ConnectionWriter& connection) const override;
1323 bool read(yarp::os::ConnectionReader& connection) override;
1324
1325 bool write(const yarp::os::idl::WireWriter& writer) const override;
1326 bool read(yarp::os::idl::WireReader& reader) override;
1327
1329 };
1330
1332 void call(PortCoreMsgs* ptr);
1333
1336
1337 static constexpr const char* s_tag{"getAdminProtocolVersion"};
1338 static constexpr size_t s_tag_len{1};
1339 static constexpr size_t s_cmd_len{1};
1340 static constexpr size_t s_reply_len{4};
1341 static constexpr const char* s_prototype{"return_getAdminProtocolVersion PortCoreMsgs::getAdminProtocolVersion()"};
1342 static constexpr const char* s_help{
1343 "Report the version of the administrative protocol of this port (it is distinct from the version of the YARP library).\n"
1344 "@return version_major, version_minor, version_patch: the version of the protocol"
1345 };
1346};
1347
1348// getPortInfo helper class declaration
1350 public yarp::os::Portable
1351{
1352public:
1354 bool write(yarp::os::ConnectionWriter& connection) const override;
1355 bool read(yarp::os::ConnectionReader& connection) override;
1356
1357 class Command :
1359 {
1360 public:
1361 Command() = default;
1362 ~Command() override = default;
1363
1364 bool write(yarp::os::ConnectionWriter& connection) const override;
1365 bool read(yarp::os::ConnectionReader& connection) override;
1366
1367 bool write(const yarp::os::idl::WireWriter& writer) const override;
1368 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1369 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1370
1371 bool read(yarp::os::idl::WireReader& reader) override;
1372 bool readTag(yarp::os::idl::WireReader& reader);
1373 bool readArgs(yarp::os::idl::WireReader& reader);
1374 };
1375
1376 class Reply :
1378 {
1379 public:
1380 Reply() = default;
1381 ~Reply() override = default;
1382
1383 bool write(yarp::os::ConnectionWriter& connection) const override;
1384 bool read(yarp::os::ConnectionReader& connection) override;
1385
1386 bool write(const yarp::os::idl::WireWriter& writer) const override;
1387 bool read(yarp::os::idl::WireReader& reader) override;
1388
1390 };
1391
1393 void call(PortCoreMsgs* ptr);
1394
1397
1398 static constexpr const char* s_tag{"getPortInfo"};
1399 static constexpr size_t s_tag_len{1};
1400 static constexpr size_t s_cmd_len{1};
1401 static constexpr size_t s_reply_len{20};
1402 static constexpr const char* s_prototype{"return_getPortInfo PortCoreMsgs::getPortInfo()"};
1403 static constexpr const char* s_help{
1404 "Give information about this port, its main thread, and the process and the platform on which it is running.\n"
1405 "@return process: name, arguments, scheduling policy and priority, pid of the process; platform: name, distribution, release, codename, kernel, environment variables of the operating system; thread: tid, priority, policy of the main thread of the port; port: is_input, is_output, is_rpc, type, hostname of the port"
1406 };
1407};
1408
1409// getConnectionQosIn helper class declaration
1411 public yarp::os::Portable
1412{
1413public:
1415 explicit PortCoreMsgs_getConnectionQosIn_helper(const std::string& portname);
1416 bool write(yarp::os::ConnectionWriter& connection) const override;
1417 bool read(yarp::os::ConnectionReader& connection) override;
1418
1419 class Command :
1421 {
1422 public:
1423 Command() = default;
1424 explicit Command(const std::string& portname);
1425
1426 ~Command() override = default;
1427
1428 bool write(yarp::os::ConnectionWriter& connection) const override;
1429 bool read(yarp::os::ConnectionReader& connection) override;
1430
1431 bool write(const yarp::os::idl::WireWriter& writer) const override;
1432 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1433 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1434
1435 bool read(yarp::os::idl::WireReader& reader) override;
1436 bool readTag(yarp::os::idl::WireReader& reader);
1437 bool readArgs(yarp::os::idl::WireReader& reader);
1438
1439 std::string portname{};
1440 };
1441
1442 class Reply :
1444 {
1445 public:
1446 Reply() = default;
1447 ~Reply() override = default;
1448
1449 bool write(yarp::os::ConnectionWriter& connection) const override;
1450 bool read(yarp::os::ConnectionReader& connection) override;
1451
1452 bool write(const yarp::os::idl::WireWriter& writer) const override;
1453 bool read(yarp::os::idl::WireReader& reader) override;
1454
1456 };
1457
1458 using funcptr_t = return_getConnectionQos (*)(const std::string&);
1459 void call(PortCoreMsgs* ptr);
1460
1463
1464 static constexpr const char* s_tag{"getConnectionQosIn"};
1465 static constexpr size_t s_tag_len{1};
1466 static constexpr size_t s_cmd_len{2};
1467 static constexpr size_t s_reply_len{6};
1468 static constexpr const char* s_prototype{"return_getConnectionQos PortCoreMsgs::getConnectionQosIn(const std::string& portname)"};
1469 static constexpr const char* s_help{
1470 "Get the quality of service of the input connection coming from another port to this port.\n"
1471 "@param portname the source port of the connection\n"
1472 "@return found: false if there is no such connection; thread: tid, scheduling priority and policy of the thread which handles the connection; qos_tos: the type of service of the packets of the connection (-1 if not available)"
1473 };
1474};
1475
1476// getConnectionQosOut helper class declaration
1478 public yarp::os::Portable
1479{
1480public:
1482 explicit PortCoreMsgs_getConnectionQosOut_helper(const std::string& portname);
1483 bool write(yarp::os::ConnectionWriter& connection) const override;
1484 bool read(yarp::os::ConnectionReader& connection) override;
1485
1486 class Command :
1488 {
1489 public:
1490 Command() = default;
1491 explicit Command(const std::string& portname);
1492
1493 ~Command() override = default;
1494
1495 bool write(yarp::os::ConnectionWriter& connection) const override;
1496 bool read(yarp::os::ConnectionReader& connection) override;
1497
1498 bool write(const yarp::os::idl::WireWriter& writer) const override;
1499 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1500 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1501
1502 bool read(yarp::os::idl::WireReader& reader) override;
1503 bool readTag(yarp::os::idl::WireReader& reader);
1504 bool readArgs(yarp::os::idl::WireReader& reader);
1505
1506 std::string portname{};
1507 };
1508
1509 class Reply :
1511 {
1512 public:
1513 Reply() = default;
1514 ~Reply() override = default;
1515
1516 bool write(yarp::os::ConnectionWriter& connection) const override;
1517 bool read(yarp::os::ConnectionReader& connection) override;
1518
1519 bool write(const yarp::os::idl::WireWriter& writer) const override;
1520 bool read(yarp::os::idl::WireReader& reader) override;
1521
1523 };
1524
1525 using funcptr_t = return_getConnectionQos (*)(const std::string&);
1526 void call(PortCoreMsgs* ptr);
1527
1530
1531 static constexpr const char* s_tag{"getConnectionQosOut"};
1532 static constexpr size_t s_tag_len{1};
1533 static constexpr size_t s_cmd_len{2};
1534 static constexpr size_t s_reply_len{6};
1535 static constexpr const char* s_prototype{"return_getConnectionQos PortCoreMsgs::getConnectionQosOut(const std::string& portname)"};
1536 static constexpr const char* s_help{
1537 "Get the quality of service of the output connection going from this port to another port.\n"
1538 "@param portname the destination port of the connection\n"
1539 "@return found: false if there is no such connection; thread: tid, scheduling priority and policy of the thread which handles the connection; qos_tos: the type of service of the packets of the connection (-1 if not available)"
1540 };
1541};
1542
1543// setConnectionQosIn helper class declaration
1545 public yarp::os::Portable
1546{
1547public:
1549 PortCoreMsgs_setConnectionQosIn_helper(const std::string& portname, const std::int32_t scheduler_priority, const std::int32_t scheduler_policy, const std::int32_t qos_tos);
1550 bool write(yarp::os::ConnectionWriter& connection) const override;
1551 bool read(yarp::os::ConnectionReader& connection) override;
1552
1553 class Command :
1555 {
1556 public:
1557 Command() = default;
1558 Command(const std::string& portname, const std::int32_t scheduler_priority, const std::int32_t scheduler_policy, const std::int32_t qos_tos);
1559
1560 ~Command() override = default;
1561
1562 bool write(yarp::os::ConnectionWriter& connection) const override;
1563 bool read(yarp::os::ConnectionReader& connection) override;
1564
1565 bool write(const yarp::os::idl::WireWriter& writer) const override;
1566 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1567 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1568
1569 bool read(yarp::os::idl::WireReader& reader) override;
1570 bool readTag(yarp::os::idl::WireReader& reader);
1571 bool readArgs(yarp::os::idl::WireReader& reader);
1572
1573 std::string portname{};
1574 std::int32_t scheduler_priority{0};
1575 std::int32_t scheduler_policy{0};
1576 std::int32_t qos_tos{0};
1577 };
1578
1579 class Reply :
1581 {
1582 public:
1583 Reply() = default;
1584 ~Reply() override = default;
1585
1586 bool write(yarp::os::ConnectionWriter& connection) const override;
1587 bool read(yarp::os::ConnectionReader& connection) override;
1588
1589 bool write(const yarp::os::idl::WireWriter& writer) const override;
1590 bool read(yarp::os::idl::WireReader& reader) override;
1591
1593 };
1594
1595 using funcptr_t = return_setConnectionQos (*)(const std::string&, const std::int32_t, const std::int32_t, const std::int32_t);
1596 void call(PortCoreMsgs* ptr);
1597
1600
1601 static constexpr const char* s_tag{"setConnectionQosIn"};
1602 static constexpr size_t s_tag_len{1};
1603 static constexpr size_t s_cmd_len{5};
1604 static constexpr size_t s_reply_len{3};
1605 static constexpr const char* s_prototype{"return_setConnectionQos PortCoreMsgs::setConnectionQosIn(const std::string& portname, const std::int32_t scheduler_priority, const std::int32_t scheduler_policy, const std::int32_t qos_tos)"};
1606 static constexpr const char* s_help{
1607 "Set the quality of service of the input connection coming from another port to this port.\n"
1608 "@param portname the source port of the connection\n"
1609 "@param scheduler_priority the scheduling priority of the thread which handles the connection (OS specific; -1 leaves the scheduling of the thread unchanged)\n"
1610 "@param scheduler_policy the scheduling policy of the thread which handles the connection (OS specific, e.g. on Linux 0 = SCHED_OTHER, 1 = SCHED_FIFO, 2 = SCHED_RR)\n"
1611 "@param qos_tos the type of service of the packets of the connection, e.g. LOW = 40, NORMAL = 0, HIGH = 144, CRITICAL = 176 (a negative value leaves it unchanged)\n"
1612 "@return success: false if there is no such connection or if the qos could not be set; message: a description of the error (if any)"
1613 };
1614};
1615
1616// setConnectionQosOut helper class declaration
1618 public yarp::os::Portable
1619{
1620public:
1622 PortCoreMsgs_setConnectionQosOut_helper(const std::string& portname, const std::int32_t scheduler_priority, const std::int32_t scheduler_policy, const std::int32_t qos_tos);
1623 bool write(yarp::os::ConnectionWriter& connection) const override;
1624 bool read(yarp::os::ConnectionReader& connection) override;
1625
1626 class Command :
1628 {
1629 public:
1630 Command() = default;
1631 Command(const std::string& portname, const std::int32_t scheduler_priority, const std::int32_t scheduler_policy, const std::int32_t qos_tos);
1632
1633 ~Command() override = default;
1634
1635 bool write(yarp::os::ConnectionWriter& connection) const override;
1636 bool read(yarp::os::ConnectionReader& connection) override;
1637
1638 bool write(const yarp::os::idl::WireWriter& writer) const override;
1639 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1640 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1641
1642 bool read(yarp::os::idl::WireReader& reader) override;
1643 bool readTag(yarp::os::idl::WireReader& reader);
1644 bool readArgs(yarp::os::idl::WireReader& reader);
1645
1646 std::string portname{};
1647 std::int32_t scheduler_priority{0};
1648 std::int32_t scheduler_policy{0};
1649 std::int32_t qos_tos{0};
1650 };
1651
1652 class Reply :
1654 {
1655 public:
1656 Reply() = default;
1657 ~Reply() override = default;
1658
1659 bool write(yarp::os::ConnectionWriter& connection) const override;
1660 bool read(yarp::os::ConnectionReader& connection) override;
1661
1662 bool write(const yarp::os::idl::WireWriter& writer) const override;
1663 bool read(yarp::os::idl::WireReader& reader) override;
1664
1666 };
1667
1668 using funcptr_t = return_setConnectionQos (*)(const std::string&, const std::int32_t, const std::int32_t, const std::int32_t);
1669 void call(PortCoreMsgs* ptr);
1670
1673
1674 static constexpr const char* s_tag{"setConnectionQosOut"};
1675 static constexpr size_t s_tag_len{1};
1676 static constexpr size_t s_cmd_len{5};
1677 static constexpr size_t s_reply_len{3};
1678 static constexpr const char* s_prototype{"return_setConnectionQos PortCoreMsgs::setConnectionQosOut(const std::string& portname, const std::int32_t scheduler_priority, const std::int32_t scheduler_policy, const std::int32_t qos_tos)"};
1679 static constexpr const char* s_help{
1680 "Set the quality of service of the output connection going from this port to another port.\n"
1681 "@param portname the destination port of the connection\n"
1682 "@param scheduler_priority the scheduling priority of the thread which handles the connection (OS specific; -1 leaves the scheduling of the thread unchanged)\n"
1683 "@param scheduler_policy the scheduling policy of the thread which handles the connection (OS specific, e.g. on Linux 0 = SCHED_OTHER, 1 = SCHED_FIFO, 2 = SCHED_RR)\n"
1684 "@param qos_tos the type of service of the packets of the connection, e.g. LOW = 40, NORMAL = 0, HIGH = 144, CRITICAL = 176 (a negative value leaves it unchanged)\n"
1685 "@return success: false if there is no such connection or if the qos could not be set; message: a description of the error (if any)"
1686 };
1687};
1688
1689// setProcessScheduling helper class declaration
1691 public yarp::os::Portable
1692{
1693public:
1695 PortCoreMsgs_setProcessScheduling_helper(const std::int32_t priority, const std::int32_t policy);
1696 bool write(yarp::os::ConnectionWriter& connection) const override;
1697 bool read(yarp::os::ConnectionReader& connection) override;
1698
1699 class Command :
1701 {
1702 public:
1703 Command() = default;
1704 Command(const std::int32_t priority, const std::int32_t policy);
1705
1706 ~Command() override = default;
1707
1708 bool write(yarp::os::ConnectionWriter& connection) const override;
1709 bool read(yarp::os::ConnectionReader& connection) override;
1710
1711 bool write(const yarp::os::idl::WireWriter& writer) const override;
1712 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1713 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1714
1715 bool read(yarp::os::idl::WireReader& reader) override;
1716 bool readTag(yarp::os::idl::WireReader& reader);
1717 bool readArgs(yarp::os::idl::WireReader& reader);
1718
1719 std::int32_t priority{0};
1720 std::int32_t policy{0};
1721 };
1722
1723 class Reply :
1725 {
1726 public:
1727 Reply() = default;
1728 ~Reply() override = default;
1729
1730 bool write(yarp::os::ConnectionWriter& connection) const override;
1731 bool read(yarp::os::ConnectionReader& connection) override;
1732
1733 bool write(const yarp::os::idl::WireWriter& writer) const override;
1734 bool read(yarp::os::idl::WireReader& reader) override;
1735
1736 bool return_helper{false};
1737 };
1738
1739 using funcptr_t = bool (*)(const std::int32_t, const std::int32_t);
1740 void call(PortCoreMsgs* ptr);
1741
1744
1745 static constexpr const char* s_tag{"setProcessScheduling"};
1746 static constexpr size_t s_tag_len{1};
1747 static constexpr size_t s_cmd_len{3};
1748 static constexpr size_t s_reply_len{1};
1749 static constexpr const char* s_prototype{"bool PortCoreMsgs::setProcessScheduling(const std::int32_t priority, const std::int32_t policy)"};
1750 static constexpr const char* s_help{
1751 "Set the scheduling parameters of all the threads of the process which owns this port.\n"
1752 "@param priority the scheduling priority (OS specific)\n"
1753 "@param policy the scheduling policy (OS specific, e.g. on Linux 0 = SCHED_OTHER, 1 = SCHED_FIFO, 2 = SCHED_RR)\n"
1754 "@return true if the scheduling parameters have been set"
1755 };
1756};
1757
1758// addConnection helper class implementation
1759PortCoreMsgs_addConnection_helper::PortCoreMsgs_addConnection_helper(const std::string& portname, const std::string& carrier) :
1760 cmd{portname, carrier}
1761{
1762}
1763
1765{
1766 return cmd.write(connection);
1767}
1768
1770{
1771 return reply.read(connection);
1772}
1773
1774PortCoreMsgs_addConnection_helper::Command::Command(const std::string& portname, const std::string& carrier) :
1775 portname{portname},
1776 carrier{carrier}
1777{
1778}
1779
1781{
1782 yarp::os::idl::WireWriter writer(connection);
1783 if (!writer.writeListHeader(s_cmd_len)) {
1784 return false;
1785 }
1786 return write(writer);
1787}
1788
1790{
1791 yarp::os::idl::WireReader reader(connection);
1792 if (!reader.readListHeader()) {
1793 reader.fail();
1794 return false;
1795 }
1796 return read(reader);
1797}
1798
1800{
1801 if (!writeTag(writer)) {
1802 return false;
1803 }
1804 if (!writeArgs(writer)) {
1805 return false;
1806 }
1807 return true;
1808}
1809
1811{
1812 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1813 return false;
1814 }
1815 return true;
1816}
1817
1819{
1820 if (!writer.writeString(portname)) {
1821 return false;
1822 }
1823 if (!writer.writeString(carrier)) {
1824 return false;
1825 }
1826 return true;
1827}
1828
1830{
1831 if (!readTag(reader)) {
1832 return false;
1833 }
1834 if (!readArgs(reader)) {
1835 return false;
1836 }
1837 return true;
1838}
1839
1841{
1842 std::string tag = reader.readTag(s_tag_len);
1843 if (reader.isError()) {
1844 return false;
1845 }
1846 if (tag != s_tag) {
1847 reader.fail();
1848 return false;
1849 }
1850 return true;
1851}
1852
1854{
1855 if (reader.noMore()) {
1856 reader.fail();
1857 return false;
1858 }
1859 if (!reader.readString(portname)) {
1860 reader.fail();
1861 return false;
1862 }
1863 if (!reader.readString(carrier)) {
1864 carrier = "";
1865 }
1866 if (!reader.noMore()) {
1867 reader.fail();
1868 return false;
1869 }
1870 return true;
1871}
1872
1874{
1875 yarp::os::idl::WireWriter writer(connection);
1876 return write(writer);
1877}
1878
1880{
1881 yarp::os::idl::WireReader reader(connection);
1882 return read(reader);
1883}
1884
1886{
1887 if (!writer.isNull()) {
1888 if (!writer.writeListHeader(s_reply_len)) {
1889 return false;
1890 }
1891 if (!writer.write(return_helper)) {
1892 return false;
1893 }
1894 }
1895 return true;
1896}
1897
1899{
1900 if (!reader.readListReturn()) {
1901 return false;
1902 }
1903 if (reader.noMore()) {
1904 reader.fail();
1905 return false;
1906 }
1907 if (!reader.read(return_helper)) {
1908 reader.fail();
1909 return false;
1910 }
1911 return true;
1912}
1913
1918
1919// delConnection helper class implementation
1921 cmd{portname}
1922{
1923}
1924
1926{
1927 return cmd.write(connection);
1928}
1929
1931{
1932 return reply.read(connection);
1933}
1934
1936 portname{portname}
1937{
1938}
1939
1941{
1942 yarp::os::idl::WireWriter writer(connection);
1943 if (!writer.writeListHeader(s_cmd_len)) {
1944 return false;
1945 }
1946 return write(writer);
1947}
1948
1950{
1951 yarp::os::idl::WireReader reader(connection);
1952 if (!reader.readListHeader()) {
1953 reader.fail();
1954 return false;
1955 }
1956 return read(reader);
1957}
1958
1960{
1961 if (!writeTag(writer)) {
1962 return false;
1963 }
1964 if (!writeArgs(writer)) {
1965 return false;
1966 }
1967 return true;
1968}
1969
1971{
1972 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1973 return false;
1974 }
1975 return true;
1976}
1977
1979{
1980 if (!writer.writeString(portname)) {
1981 return false;
1982 }
1983 return true;
1984}
1985
1987{
1988 if (!readTag(reader)) {
1989 return false;
1990 }
1991 if (!readArgs(reader)) {
1992 return false;
1993 }
1994 return true;
1995}
1996
1998{
1999 std::string tag = reader.readTag(s_tag_len);
2000 if (reader.isError()) {
2001 return false;
2002 }
2003 if (tag != s_tag) {
2004 reader.fail();
2005 return false;
2006 }
2007 return true;
2008}
2009
2011{
2012 if (reader.noMore()) {
2013 reader.fail();
2014 return false;
2015 }
2016 if (!reader.readString(portname)) {
2017 reader.fail();
2018 return false;
2019 }
2020 if (!reader.noMore()) {
2021 reader.fail();
2022 return false;
2023 }
2024 return true;
2025}
2026
2028{
2029 yarp::os::idl::WireWriter writer(connection);
2030 return write(writer);
2031}
2032
2034{
2035 yarp::os::idl::WireReader reader(connection);
2036 return read(reader);
2037}
2038
2040{
2041 if (!writer.isNull()) {
2042 if (!writer.writeListHeader(s_reply_len)) {
2043 return false;
2044 }
2045 if (!writer.write(return_helper)) {
2046 return false;
2047 }
2048 }
2049 return true;
2050}
2051
2053{
2054 if (!reader.readListReturn()) {
2055 return false;
2056 }
2057 if (reader.noMore()) {
2058 reader.fail();
2059 return false;
2060 }
2061 if (!reader.read(return_helper)) {
2062 reader.fail();
2063 return false;
2064 }
2065 return true;
2066}
2067
2072
2073// attachPortmonitorOut helper class implementation
2078
2080{
2081 return cmd.write(connection);
2082}
2083
2085{
2086 return reply.read(connection);
2087}
2088
2090 prop{prop}
2091{
2092}
2093
2095{
2096 yarp::os::idl::WireWriter writer(connection);
2097 if (!writer.writeListHeader(s_cmd_len)) {
2098 return false;
2099 }
2100 return write(writer);
2101}
2102
2104{
2105 yarp::os::idl::WireReader reader(connection);
2106 if (!reader.readListHeader()) {
2107 reader.fail();
2108 return false;
2109 }
2110 return read(reader);
2111}
2112
2114{
2115 if (!writeTag(writer)) {
2116 return false;
2117 }
2118 if (!writeArgs(writer)) {
2119 return false;
2120 }
2121 return true;
2122}
2123
2125{
2126 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2127 return false;
2128 }
2129 return true;
2130}
2131
2133{
2134 if (!writer.writeString(prop)) {
2135 return false;
2136 }
2137 return true;
2138}
2139
2141{
2142 if (!readTag(reader)) {
2143 return false;
2144 }
2145 if (!readArgs(reader)) {
2146 return false;
2147 }
2148 return true;
2149}
2150
2152{
2153 std::string tag = reader.readTag(s_tag_len);
2154 if (reader.isError()) {
2155 return false;
2156 }
2157 if (tag != s_tag) {
2158 reader.fail();
2159 return false;
2160 }
2161 return true;
2162}
2163
2165{
2166 if (reader.noMore()) {
2167 reader.fail();
2168 return false;
2169 }
2170 if (!reader.readString(prop)) {
2171 reader.fail();
2172 return false;
2173 }
2174 if (!reader.noMore()) {
2175 reader.fail();
2176 return false;
2177 }
2178 return true;
2179}
2180
2182{
2183 yarp::os::idl::WireWriter writer(connection);
2184 return write(writer);
2185}
2186
2188{
2189 yarp::os::idl::WireReader reader(connection);
2190 return read(reader);
2191}
2192
2194{
2195 if (!writer.isNull()) {
2196 if (!writer.writeListHeader(s_reply_len)) {
2197 return false;
2198 }
2199 if (!writer.writeBool(return_helper)) {
2200 return false;
2201 }
2202 }
2203 return true;
2204}
2205
2207{
2208 if (!reader.readListReturn()) {
2209 return false;
2210 }
2211 if (reader.noMore()) {
2212 reader.fail();
2213 return false;
2214 }
2215 if (!reader.readBool(return_helper)) {
2216 reader.fail();
2217 return false;
2218 }
2219 return true;
2220}
2221
2226
2227// attachPortmonitorIn helper class implementation
2232
2234{
2235 return cmd.write(connection);
2236}
2237
2239{
2240 return reply.read(connection);
2241}
2242
2244 prop{prop}
2245{
2246}
2247
2249{
2250 yarp::os::idl::WireWriter writer(connection);
2251 if (!writer.writeListHeader(s_cmd_len)) {
2252 return false;
2253 }
2254 return write(writer);
2255}
2256
2258{
2259 yarp::os::idl::WireReader reader(connection);
2260 if (!reader.readListHeader()) {
2261 reader.fail();
2262 return false;
2263 }
2264 return read(reader);
2265}
2266
2268{
2269 if (!writeTag(writer)) {
2270 return false;
2271 }
2272 if (!writeArgs(writer)) {
2273 return false;
2274 }
2275 return true;
2276}
2277
2279{
2280 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2281 return false;
2282 }
2283 return true;
2284}
2285
2287{
2288 if (!writer.writeString(prop)) {
2289 return false;
2290 }
2291 return true;
2292}
2293
2295{
2296 if (!readTag(reader)) {
2297 return false;
2298 }
2299 if (!readArgs(reader)) {
2300 return false;
2301 }
2302 return true;
2303}
2304
2306{
2307 std::string tag = reader.readTag(s_tag_len);
2308 if (reader.isError()) {
2309 return false;
2310 }
2311 if (tag != s_tag) {
2312 reader.fail();
2313 return false;
2314 }
2315 return true;
2316}
2317
2319{
2320 if (reader.noMore()) {
2321 reader.fail();
2322 return false;
2323 }
2324 if (!reader.readString(prop)) {
2325 reader.fail();
2326 return false;
2327 }
2328 if (!reader.noMore()) {
2329 reader.fail();
2330 return false;
2331 }
2332 return true;
2333}
2334
2336{
2337 yarp::os::idl::WireWriter writer(connection);
2338 return write(writer);
2339}
2340
2342{
2343 yarp::os::idl::WireReader reader(connection);
2344 return read(reader);
2345}
2346
2348{
2349 if (!writer.isNull()) {
2350 if (!writer.writeListHeader(s_reply_len)) {
2351 return false;
2352 }
2353 if (!writer.writeBool(return_helper)) {
2354 return false;
2355 }
2356 }
2357 return true;
2358}
2359
2361{
2362 if (!reader.readListReturn()) {
2363 return false;
2364 }
2365 if (reader.noMore()) {
2366 reader.fail();
2367 return false;
2368 }
2369 if (!reader.readBool(return_helper)) {
2370 reader.fail();
2371 return false;
2372 }
2373 return true;
2374}
2375
2380
2381// detachPortmonitorOut helper class implementation
2383{
2384 return cmd.write(connection);
2385}
2386
2388{
2389 return reply.read(connection);
2390}
2391
2393{
2394 yarp::os::idl::WireWriter writer(connection);
2395 if (!writer.writeListHeader(s_cmd_len)) {
2396 return false;
2397 }
2398 return write(writer);
2399}
2400
2402{
2403 yarp::os::idl::WireReader reader(connection);
2404 if (!reader.readListHeader()) {
2405 reader.fail();
2406 return false;
2407 }
2408 return read(reader);
2409}
2410
2412{
2413 if (!writeTag(writer)) {
2414 return false;
2415 }
2416 if (!writeArgs(writer)) {
2417 return false;
2418 }
2419 return true;
2420}
2421
2423{
2424 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2425 return false;
2426 }
2427 return true;
2428}
2429
2434
2436{
2437 if (!readTag(reader)) {
2438 return false;
2439 }
2440 if (!readArgs(reader)) {
2441 return false;
2442 }
2443 return true;
2444}
2445
2447{
2448 std::string tag = reader.readTag(s_tag_len);
2449 if (reader.isError()) {
2450 return false;
2451 }
2452 if (tag != s_tag) {
2453 reader.fail();
2454 return false;
2455 }
2456 return true;
2457}
2458
2460{
2461 if (!reader.noMore()) {
2462 reader.fail();
2463 return false;
2464 }
2465 return true;
2466}
2467
2469{
2470 yarp::os::idl::WireWriter writer(connection);
2471 return write(writer);
2472}
2473
2475{
2476 yarp::os::idl::WireReader reader(connection);
2477 return read(reader);
2478}
2479
2481{
2482 if (!writer.isNull()) {
2483 if (!writer.writeListHeader(s_reply_len)) {
2484 return false;
2485 }
2486 if (!writer.writeBool(return_helper)) {
2487 return false;
2488 }
2489 }
2490 return true;
2491}
2492
2494{
2495 if (!reader.readListReturn()) {
2496 return false;
2497 }
2498 if (reader.noMore()) {
2499 reader.fail();
2500 return false;
2501 }
2502 if (!reader.readBool(return_helper)) {
2503 reader.fail();
2504 return false;
2505 }
2506 return true;
2507}
2508
2513
2514// detachPortmonitorIn helper class implementation
2516{
2517 return cmd.write(connection);
2518}
2519
2521{
2522 return reply.read(connection);
2523}
2524
2526{
2527 yarp::os::idl::WireWriter writer(connection);
2528 if (!writer.writeListHeader(s_cmd_len)) {
2529 return false;
2530 }
2531 return write(writer);
2532}
2533
2535{
2536 yarp::os::idl::WireReader reader(connection);
2537 if (!reader.readListHeader()) {
2538 reader.fail();
2539 return false;
2540 }
2541 return read(reader);
2542}
2543
2545{
2546 if (!writeTag(writer)) {
2547 return false;
2548 }
2549 if (!writeArgs(writer)) {
2550 return false;
2551 }
2552 return true;
2553}
2554
2556{
2557 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2558 return false;
2559 }
2560 return true;
2561}
2562
2567
2569{
2570 if (!readTag(reader)) {
2571 return false;
2572 }
2573 if (!readArgs(reader)) {
2574 return false;
2575 }
2576 return true;
2577}
2578
2580{
2581 std::string tag = reader.readTag(s_tag_len);
2582 if (reader.isError()) {
2583 return false;
2584 }
2585 if (tag != s_tag) {
2586 reader.fail();
2587 return false;
2588 }
2589 return true;
2590}
2591
2593{
2594 if (!reader.noMore()) {
2595 reader.fail();
2596 return false;
2597 }
2598 return true;
2599}
2600
2602{
2603 yarp::os::idl::WireWriter writer(connection);
2604 return write(writer);
2605}
2606
2608{
2609 yarp::os::idl::WireReader reader(connection);
2610 return read(reader);
2611}
2612
2614{
2615 if (!writer.isNull()) {
2616 if (!writer.writeListHeader(s_reply_len)) {
2617 return false;
2618 }
2619 if (!writer.writeBool(return_helper)) {
2620 return false;
2621 }
2622 }
2623 return true;
2624}
2625
2627{
2628 if (!reader.readListReturn()) {
2629 return false;
2630 }
2631 if (reader.noMore()) {
2632 reader.fail();
2633 return false;
2634 }
2635 if (!reader.readBool(return_helper)) {
2636 reader.fail();
2637 return false;
2638 }
2639 return true;
2640}
2641
2646
2647// setPortmonitorParamsOut helper class implementation
2652
2654{
2655 return cmd.write(connection);
2656}
2657
2662
2664 params{params}
2665{
2666}
2667
2669{
2670 yarp::os::idl::WireWriter writer(connection);
2671 if (!writer.writeListHeader(s_cmd_len)) {
2672 return false;
2673 }
2674 return write(writer);
2675}
2676
2678{
2679 yarp::os::idl::WireReader reader(connection);
2680 if (!reader.readListHeader()) {
2681 reader.fail();
2682 return false;
2683 }
2684 return read(reader);
2685}
2686
2688{
2689 if (!writeTag(writer)) {
2690 return false;
2691 }
2692 if (!writeArgs(writer)) {
2693 return false;
2694 }
2695 return true;
2696}
2697
2699{
2700 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2701 return false;
2702 }
2703 return true;
2704}
2705
2707{
2708 if (!writer.writeString(params)) {
2709 return false;
2710 }
2711 return true;
2712}
2713
2715{
2716 if (!readTag(reader)) {
2717 return false;
2718 }
2719 if (!readArgs(reader)) {
2720 return false;
2721 }
2722 return true;
2723}
2724
2726{
2727 std::string tag = reader.readTag(s_tag_len);
2728 if (reader.isError()) {
2729 return false;
2730 }
2731 if (tag != s_tag) {
2732 reader.fail();
2733 return false;
2734 }
2735 return true;
2736}
2737
2739{
2740 if (reader.noMore()) {
2741 reader.fail();
2742 return false;
2743 }
2744 if (!reader.readString(params)) {
2745 reader.fail();
2746 return false;
2747 }
2748 if (!reader.noMore()) {
2749 reader.fail();
2750 return false;
2751 }
2752 return true;
2753}
2754
2756{
2757 yarp::os::idl::WireWriter writer(connection);
2758 return write(writer);
2759}
2760
2762{
2763 yarp::os::idl::WireReader reader(connection);
2764 return read(reader);
2765}
2766
2768{
2769 if (!writer.isNull()) {
2770 if (!writer.writeListHeader(s_reply_len)) {
2771 return false;
2772 }
2773 if (!writer.write(return_helper)) {
2774 return false;
2775 }
2776 }
2777 return true;
2778}
2779
2781{
2782 if (!reader.readListReturn()) {
2783 return false;
2784 }
2785 if (reader.noMore()) {
2786 reader.fail();
2787 return false;
2788 }
2789 if (!reader.read(return_helper)) {
2790 reader.fail();
2791 return false;
2792 }
2793 return true;
2794}
2795
2800
2801// setPortmonitorParamsIn helper class implementation
2806
2808{
2809 return cmd.write(connection);
2810}
2811
2813{
2814 return reply.read(connection);
2815}
2816
2818 params{params}
2819{
2820}
2821
2823{
2824 yarp::os::idl::WireWriter writer(connection);
2825 if (!writer.writeListHeader(s_cmd_len)) {
2826 return false;
2827 }
2828 return write(writer);
2829}
2830
2832{
2833 yarp::os::idl::WireReader reader(connection);
2834 if (!reader.readListHeader()) {
2835 reader.fail();
2836 return false;
2837 }
2838 return read(reader);
2839}
2840
2842{
2843 if (!writeTag(writer)) {
2844 return false;
2845 }
2846 if (!writeArgs(writer)) {
2847 return false;
2848 }
2849 return true;
2850}
2851
2853{
2854 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2855 return false;
2856 }
2857 return true;
2858}
2859
2861{
2862 if (!writer.writeString(params)) {
2863 return false;
2864 }
2865 return true;
2866}
2867
2869{
2870 if (!readTag(reader)) {
2871 return false;
2872 }
2873 if (!readArgs(reader)) {
2874 return false;
2875 }
2876 return true;
2877}
2878
2880{
2881 std::string tag = reader.readTag(s_tag_len);
2882 if (reader.isError()) {
2883 return false;
2884 }
2885 if (tag != s_tag) {
2886 reader.fail();
2887 return false;
2888 }
2889 return true;
2890}
2891
2893{
2894 if (reader.noMore()) {
2895 reader.fail();
2896 return false;
2897 }
2898 if (!reader.readString(params)) {
2899 reader.fail();
2900 return false;
2901 }
2902 if (!reader.noMore()) {
2903 reader.fail();
2904 return false;
2905 }
2906 return true;
2907}
2908
2910{
2911 yarp::os::idl::WireWriter writer(connection);
2912 return write(writer);
2913}
2914
2916{
2917 yarp::os::idl::WireReader reader(connection);
2918 return read(reader);
2919}
2920
2922{
2923 if (!writer.isNull()) {
2924 if (!writer.writeListHeader(s_reply_len)) {
2925 return false;
2926 }
2927 if (!writer.write(return_helper)) {
2928 return false;
2929 }
2930 }
2931 return true;
2932}
2933
2935{
2936 if (!reader.readListReturn()) {
2937 return false;
2938 }
2939 if (reader.noMore()) {
2940 reader.fail();
2941 return false;
2942 }
2943 if (!reader.read(return_helper)) {
2944 reader.fail();
2945 return false;
2946 }
2947 return true;
2948}
2949
2954
2955// getPortmonitorParamsOut helper class implementation
2957{
2958 return cmd.write(connection);
2959}
2960
2965
2967{
2968 yarp::os::idl::WireWriter writer(connection);
2969 if (!writer.writeListHeader(s_cmd_len)) {
2970 return false;
2971 }
2972 return write(writer);
2973}
2974
2976{
2977 yarp::os::idl::WireReader reader(connection);
2978 if (!reader.readListHeader()) {
2979 reader.fail();
2980 return false;
2981 }
2982 return read(reader);
2983}
2984
2986{
2987 if (!writeTag(writer)) {
2988 return false;
2989 }
2990 if (!writeArgs(writer)) {
2991 return false;
2992 }
2993 return true;
2994}
2995
2997{
2998 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2999 return false;
3000 }
3001 return true;
3002}
3003
3008
3010{
3011 if (!readTag(reader)) {
3012 return false;
3013 }
3014 if (!readArgs(reader)) {
3015 return false;
3016 }
3017 return true;
3018}
3019
3021{
3022 std::string tag = reader.readTag(s_tag_len);
3023 if (reader.isError()) {
3024 return false;
3025 }
3026 if (tag != s_tag) {
3027 reader.fail();
3028 return false;
3029 }
3030 return true;
3031}
3032
3034{
3035 if (!reader.noMore()) {
3036 reader.fail();
3037 return false;
3038 }
3039 return true;
3040}
3041
3043{
3044 yarp::os::idl::WireWriter writer(connection);
3045 return write(writer);
3046}
3047
3049{
3050 yarp::os::idl::WireReader reader(connection);
3051 return read(reader);
3052}
3053
3055{
3056 if (!writer.isNull()) {
3057 if (!writer.writeListHeader(s_reply_len)) {
3058 return false;
3059 }
3060 if (!writer.write(return_helper)) {
3061 return false;
3062 }
3063 }
3064 return true;
3065}
3066
3068{
3069 if (!reader.readListReturn()) {
3070 return false;
3071 }
3072 if (reader.noMore()) {
3073 reader.fail();
3074 return false;
3075 }
3076 if (!reader.read(return_helper)) {
3077 reader.fail();
3078 return false;
3079 }
3080 return true;
3081}
3082
3087
3088// getPortmonitorParamsIn helper class implementation
3090{
3091 return cmd.write(connection);
3092}
3093
3095{
3096 return reply.read(connection);
3097}
3098
3100{
3101 yarp::os::idl::WireWriter writer(connection);
3102 if (!writer.writeListHeader(s_cmd_len)) {
3103 return false;
3104 }
3105 return write(writer);
3106}
3107
3109{
3110 yarp::os::idl::WireReader reader(connection);
3111 if (!reader.readListHeader()) {
3112 reader.fail();
3113 return false;
3114 }
3115 return read(reader);
3116}
3117
3119{
3120 if (!writeTag(writer)) {
3121 return false;
3122 }
3123 if (!writeArgs(writer)) {
3124 return false;
3125 }
3126 return true;
3127}
3128
3130{
3131 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3132 return false;
3133 }
3134 return true;
3135}
3136
3141
3143{
3144 if (!readTag(reader)) {
3145 return false;
3146 }
3147 if (!readArgs(reader)) {
3148 return false;
3149 }
3150 return true;
3151}
3152
3154{
3155 std::string tag = reader.readTag(s_tag_len);
3156 if (reader.isError()) {
3157 return false;
3158 }
3159 if (tag != s_tag) {
3160 reader.fail();
3161 return false;
3162 }
3163 return true;
3164}
3165
3167{
3168 if (!reader.noMore()) {
3169 reader.fail();
3170 return false;
3171 }
3172 return true;
3173}
3174
3176{
3177 yarp::os::idl::WireWriter writer(connection);
3178 return write(writer);
3179}
3180
3182{
3183 yarp::os::idl::WireReader reader(connection);
3184 return read(reader);
3185}
3186
3188{
3189 if (!writer.isNull()) {
3190 if (!writer.writeListHeader(s_reply_len)) {
3191 return false;
3192 }
3193 if (!writer.write(return_helper)) {
3194 return false;
3195 }
3196 }
3197 return true;
3198}
3199
3201{
3202 if (!reader.readListReturn()) {
3203 return false;
3204 }
3205 if (reader.noMore()) {
3206 reader.fail();
3207 return false;
3208 }
3209 if (!reader.read(return_helper)) {
3210 reader.fail();
3211 return false;
3212 }
3213 return true;
3214}
3215
3220
3221// setConnectionParamsOut helper class implementation
3223 cmd{portname, params}
3224{
3225}
3226
3228{
3229 return cmd.write(connection);
3230}
3231
3233{
3234 return reply.read(connection);
3235}
3236
3237PortCoreMsgs_setConnectionParamsOut_helper::Command::Command(const std::string& portname, const std::string& params) :
3238 portname{portname},
3239 params{params}
3240{
3241}
3242
3244{
3245 yarp::os::idl::WireWriter writer(connection);
3246 if (!writer.writeListHeader(s_cmd_len)) {
3247 return false;
3248 }
3249 return write(writer);
3250}
3251
3253{
3254 yarp::os::idl::WireReader reader(connection);
3255 if (!reader.readListHeader()) {
3256 reader.fail();
3257 return false;
3258 }
3259 return read(reader);
3260}
3261
3263{
3264 if (!writeTag(writer)) {
3265 return false;
3266 }
3267 if (!writeArgs(writer)) {
3268 return false;
3269 }
3270 return true;
3271}
3272
3274{
3275 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3276 return false;
3277 }
3278 return true;
3279}
3280
3282{
3283 if (!writer.writeString(portname)) {
3284 return false;
3285 }
3286 if (!writer.writeString(params)) {
3287 return false;
3288 }
3289 return true;
3290}
3291
3293{
3294 if (!readTag(reader)) {
3295 return false;
3296 }
3297 if (!readArgs(reader)) {
3298 return false;
3299 }
3300 return true;
3301}
3302
3304{
3305 std::string tag = reader.readTag(s_tag_len);
3306 if (reader.isError()) {
3307 return false;
3308 }
3309 if (tag != s_tag) {
3310 reader.fail();
3311 return false;
3312 }
3313 return true;
3314}
3315
3317{
3318 if (reader.noMore()) {
3319 reader.fail();
3320 return false;
3321 }
3322 if (!reader.readString(portname)) {
3323 reader.fail();
3324 return false;
3325 }
3326 if (reader.noMore()) {
3327 reader.fail();
3328 return false;
3329 }
3330 if (!reader.readString(params)) {
3331 reader.fail();
3332 return false;
3333 }
3334 if (!reader.noMore()) {
3335 reader.fail();
3336 return false;
3337 }
3338 return true;
3339}
3340
3342{
3343 yarp::os::idl::WireWriter writer(connection);
3344 return write(writer);
3345}
3346
3348{
3349 yarp::os::idl::WireReader reader(connection);
3350 return read(reader);
3351}
3352
3354{
3355 if (!writer.isNull()) {
3356 if (!writer.writeListHeader(s_reply_len)) {
3357 return false;
3358 }
3359 if (!writer.write(return_helper)) {
3360 return false;
3361 }
3362 }
3363 return true;
3364}
3365
3367{
3368 if (!reader.readListReturn()) {
3369 return false;
3370 }
3371 if (reader.noMore()) {
3372 reader.fail();
3373 return false;
3374 }
3375 if (!reader.read(return_helper)) {
3376 reader.fail();
3377 return false;
3378 }
3379 return true;
3380}
3381
3386
3387// setConnectionParamsIn helper class implementation
3389 cmd{portname, params}
3390{
3391}
3392
3394{
3395 return cmd.write(connection);
3396}
3397
3399{
3400 return reply.read(connection);
3401}
3402
3403PortCoreMsgs_setConnectionParamsIn_helper::Command::Command(const std::string& portname, const std::string& params) :
3404 portname{portname},
3405 params{params}
3406{
3407}
3408
3410{
3411 yarp::os::idl::WireWriter writer(connection);
3412 if (!writer.writeListHeader(s_cmd_len)) {
3413 return false;
3414 }
3415 return write(writer);
3416}
3417
3419{
3420 yarp::os::idl::WireReader reader(connection);
3421 if (!reader.readListHeader()) {
3422 reader.fail();
3423 return false;
3424 }
3425 return read(reader);
3426}
3427
3429{
3430 if (!writeTag(writer)) {
3431 return false;
3432 }
3433 if (!writeArgs(writer)) {
3434 return false;
3435 }
3436 return true;
3437}
3438
3440{
3441 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3442 return false;
3443 }
3444 return true;
3445}
3446
3448{
3449 if (!writer.writeString(portname)) {
3450 return false;
3451 }
3452 if (!writer.writeString(params)) {
3453 return false;
3454 }
3455 return true;
3456}
3457
3459{
3460 if (!readTag(reader)) {
3461 return false;
3462 }
3463 if (!readArgs(reader)) {
3464 return false;
3465 }
3466 return true;
3467}
3468
3470{
3471 std::string tag = reader.readTag(s_tag_len);
3472 if (reader.isError()) {
3473 return false;
3474 }
3475 if (tag != s_tag) {
3476 reader.fail();
3477 return false;
3478 }
3479 return true;
3480}
3481
3483{
3484 if (reader.noMore()) {
3485 reader.fail();
3486 return false;
3487 }
3488 if (!reader.readString(portname)) {
3489 reader.fail();
3490 return false;
3491 }
3492 if (reader.noMore()) {
3493 reader.fail();
3494 return false;
3495 }
3496 if (!reader.readString(params)) {
3497 reader.fail();
3498 return false;
3499 }
3500 if (!reader.noMore()) {
3501 reader.fail();
3502 return false;
3503 }
3504 return true;
3505}
3506
3508{
3509 yarp::os::idl::WireWriter writer(connection);
3510 return write(writer);
3511}
3512
3514{
3515 yarp::os::idl::WireReader reader(connection);
3516 return read(reader);
3517}
3518
3520{
3521 if (!writer.isNull()) {
3522 if (!writer.writeListHeader(s_reply_len)) {
3523 return false;
3524 }
3525 if (!writer.write(return_helper)) {
3526 return false;
3527 }
3528 }
3529 return true;
3530}
3531
3533{
3534 if (!reader.readListReturn()) {
3535 return false;
3536 }
3537 if (reader.noMore()) {
3538 reader.fail();
3539 return false;
3540 }
3541 if (!reader.read(return_helper)) {
3542 reader.fail();
3543 return false;
3544 }
3545 return true;
3546}
3547
3552
3553// getConnectionParamsOut helper class implementation
3558
3560{
3561 return cmd.write(connection);
3562}
3563
3565{
3566 return reply.read(connection);
3567}
3568
3570 portname{portname}
3571{
3572}
3573
3575{
3576 yarp::os::idl::WireWriter writer(connection);
3577 if (!writer.writeListHeader(s_cmd_len)) {
3578 return false;
3579 }
3580 return write(writer);
3581}
3582
3584{
3585 yarp::os::idl::WireReader reader(connection);
3586 if (!reader.readListHeader()) {
3587 reader.fail();
3588 return false;
3589 }
3590 return read(reader);
3591}
3592
3594{
3595 if (!writeTag(writer)) {
3596 return false;
3597 }
3598 if (!writeArgs(writer)) {
3599 return false;
3600 }
3601 return true;
3602}
3603
3605{
3606 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3607 return false;
3608 }
3609 return true;
3610}
3611
3613{
3614 if (!writer.writeString(portname)) {
3615 return false;
3616 }
3617 return true;
3618}
3619
3621{
3622 if (!readTag(reader)) {
3623 return false;
3624 }
3625 if (!readArgs(reader)) {
3626 return false;
3627 }
3628 return true;
3629}
3630
3632{
3633 std::string tag = reader.readTag(s_tag_len);
3634 if (reader.isError()) {
3635 return false;
3636 }
3637 if (tag != s_tag) {
3638 reader.fail();
3639 return false;
3640 }
3641 return true;
3642}
3643
3645{
3646 if (reader.noMore()) {
3647 reader.fail();
3648 return false;
3649 }
3650 if (!reader.readString(portname)) {
3651 reader.fail();
3652 return false;
3653 }
3654 if (!reader.noMore()) {
3655 reader.fail();
3656 return false;
3657 }
3658 return true;
3659}
3660
3662{
3663 yarp::os::idl::WireWriter writer(connection);
3664 return write(writer);
3665}
3666
3668{
3669 yarp::os::idl::WireReader reader(connection);
3670 return read(reader);
3671}
3672
3674{
3675 if (!writer.isNull()) {
3676 if (!writer.writeListHeader(s_reply_len)) {
3677 return false;
3678 }
3679 if (!writer.write(return_helper)) {
3680 return false;
3681 }
3682 }
3683 return true;
3684}
3685
3687{
3688 if (!reader.readListReturn()) {
3689 return false;
3690 }
3691 if (reader.noMore()) {
3692 reader.fail();
3693 return false;
3694 }
3695 if (!reader.read(return_helper)) {
3696 reader.fail();
3697 return false;
3698 }
3699 return true;
3700}
3701
3706
3707// getConnectionParamsIn helper class implementation
3712
3714{
3715 return cmd.write(connection);
3716}
3717
3719{
3720 return reply.read(connection);
3721}
3722
3724 portname{portname}
3725{
3726}
3727
3729{
3730 yarp::os::idl::WireWriter writer(connection);
3731 if (!writer.writeListHeader(s_cmd_len)) {
3732 return false;
3733 }
3734 return write(writer);
3735}
3736
3738{
3739 yarp::os::idl::WireReader reader(connection);
3740 if (!reader.readListHeader()) {
3741 reader.fail();
3742 return false;
3743 }
3744 return read(reader);
3745}
3746
3748{
3749 if (!writeTag(writer)) {
3750 return false;
3751 }
3752 if (!writeArgs(writer)) {
3753 return false;
3754 }
3755 return true;
3756}
3757
3759{
3760 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3761 return false;
3762 }
3763 return true;
3764}
3765
3767{
3768 if (!writer.writeString(portname)) {
3769 return false;
3770 }
3771 return true;
3772}
3773
3775{
3776 if (!readTag(reader)) {
3777 return false;
3778 }
3779 if (!readArgs(reader)) {
3780 return false;
3781 }
3782 return true;
3783}
3784
3786{
3787 std::string tag = reader.readTag(s_tag_len);
3788 if (reader.isError()) {
3789 return false;
3790 }
3791 if (tag != s_tag) {
3792 reader.fail();
3793 return false;
3794 }
3795 return true;
3796}
3797
3799{
3800 if (reader.noMore()) {
3801 reader.fail();
3802 return false;
3803 }
3804 if (!reader.readString(portname)) {
3805 reader.fail();
3806 return false;
3807 }
3808 if (!reader.noMore()) {
3809 reader.fail();
3810 return false;
3811 }
3812 return true;
3813}
3814
3816{
3817 yarp::os::idl::WireWriter writer(connection);
3818 return write(writer);
3819}
3820
3822{
3823 yarp::os::idl::WireReader reader(connection);
3824 return read(reader);
3825}
3826
3828{
3829 if (!writer.isNull()) {
3830 if (!writer.writeListHeader(s_reply_len)) {
3831 return false;
3832 }
3833 if (!writer.write(return_helper)) {
3834 return false;
3835 }
3836 }
3837 return true;
3838}
3839
3841{
3842 if (!reader.readListReturn()) {
3843 return false;
3844 }
3845 if (reader.noMore()) {
3846 reader.fail();
3847 return false;
3848 }
3849 if (!reader.read(return_helper)) {
3850 reader.fail();
3851 return false;
3852 }
3853 return true;
3854}
3855
3860
3861// listConnectionsIn helper class implementation
3863{
3864 return cmd.write(connection);
3865}
3866
3868{
3869 return reply.read(connection);
3870}
3871
3873{
3874 yarp::os::idl::WireWriter writer(connection);
3875 if (!writer.writeListHeader(s_cmd_len)) {
3876 return false;
3877 }
3878 return write(writer);
3879}
3880
3882{
3883 yarp::os::idl::WireReader reader(connection);
3884 if (!reader.readListHeader()) {
3885 reader.fail();
3886 return false;
3887 }
3888 return read(reader);
3889}
3890
3892{
3893 if (!writeTag(writer)) {
3894 return false;
3895 }
3896 if (!writeArgs(writer)) {
3897 return false;
3898 }
3899 return true;
3900}
3901
3903{
3904 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3905 return false;
3906 }
3907 return true;
3908}
3909
3914
3916{
3917 if (!readTag(reader)) {
3918 return false;
3919 }
3920 if (!readArgs(reader)) {
3921 return false;
3922 }
3923 return true;
3924}
3925
3927{
3928 std::string tag = reader.readTag(s_tag_len);
3929 if (reader.isError()) {
3930 return false;
3931 }
3932 if (tag != s_tag) {
3933 reader.fail();
3934 return false;
3935 }
3936 return true;
3937}
3938
3940{
3941 if (!reader.noMore()) {
3942 reader.fail();
3943 return false;
3944 }
3945 return true;
3946}
3947
3949{
3950 yarp::os::idl::WireWriter writer(connection);
3951 return write(writer);
3952}
3953
3955{
3956 yarp::os::idl::WireReader reader(connection);
3957 return read(reader);
3958}
3959
3961{
3962 if (!writer.isNull()) {
3963 if (!writer.writeListHeader(s_reply_len)) {
3964 return false;
3965 }
3966 if (!writer.write(return_helper)) {
3967 return false;
3968 }
3969 }
3970 return true;
3971}
3972
3974{
3975 if (!reader.readListReturn()) {
3976 return false;
3977 }
3978 if (reader.noMore()) {
3979 reader.fail();
3980 return false;
3981 }
3982 if (!reader.read(return_helper)) {
3983 reader.fail();
3984 return false;
3985 }
3986 return true;
3987}
3988
3993
3994// listConnectionsOut helper class implementation
3996{
3997 return cmd.write(connection);
3998}
3999
4001{
4002 return reply.read(connection);
4003}
4004
4006{
4007 yarp::os::idl::WireWriter writer(connection);
4008 if (!writer.writeListHeader(s_cmd_len)) {
4009 return false;
4010 }
4011 return write(writer);
4012}
4013
4015{
4016 yarp::os::idl::WireReader reader(connection);
4017 if (!reader.readListHeader()) {
4018 reader.fail();
4019 return false;
4020 }
4021 return read(reader);
4022}
4023
4025{
4026 if (!writeTag(writer)) {
4027 return false;
4028 }
4029 if (!writeArgs(writer)) {
4030 return false;
4031 }
4032 return true;
4033}
4034
4036{
4037 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4038 return false;
4039 }
4040 return true;
4041}
4042
4047
4049{
4050 if (!readTag(reader)) {
4051 return false;
4052 }
4053 if (!readArgs(reader)) {
4054 return false;
4055 }
4056 return true;
4057}
4058
4060{
4061 std::string tag = reader.readTag(s_tag_len);
4062 if (reader.isError()) {
4063 return false;
4064 }
4065 if (tag != s_tag) {
4066 reader.fail();
4067 return false;
4068 }
4069 return true;
4070}
4071
4073{
4074 if (!reader.noMore()) {
4075 reader.fail();
4076 return false;
4077 }
4078 return true;
4079}
4080
4082{
4083 yarp::os::idl::WireWriter writer(connection);
4084 return write(writer);
4085}
4086
4088{
4089 yarp::os::idl::WireReader reader(connection);
4090 return read(reader);
4091}
4092
4094{
4095 if (!writer.isNull()) {
4096 if (!writer.writeListHeader(s_reply_len)) {
4097 return false;
4098 }
4099 if (!writer.write(return_helper)) {
4100 return false;
4101 }
4102 }
4103 return true;
4104}
4105
4107{
4108 if (!reader.readListReturn()) {
4109 return false;
4110 }
4111 if (reader.noMore()) {
4112 reader.fail();
4113 return false;
4114 }
4115 if (!reader.read(return_helper)) {
4116 reader.fail();
4117 return false;
4118 }
4119 return true;
4120}
4121
4126
4127// getConnectionInfoIn helper class implementation
4129 cmd{portname}
4130{
4131}
4132
4134{
4135 return cmd.write(connection);
4136}
4137
4139{
4140 return reply.read(connection);
4141}
4142
4144 portname{portname}
4145{
4146}
4147
4149{
4150 yarp::os::idl::WireWriter writer(connection);
4151 if (!writer.writeListHeader(s_cmd_len)) {
4152 return false;
4153 }
4154 return write(writer);
4155}
4156
4158{
4159 yarp::os::idl::WireReader reader(connection);
4160 if (!reader.readListHeader()) {
4161 reader.fail();
4162 return false;
4163 }
4164 return read(reader);
4165}
4166
4168{
4169 if (!writeTag(writer)) {
4170 return false;
4171 }
4172 if (!writeArgs(writer)) {
4173 return false;
4174 }
4175 return true;
4176}
4177
4179{
4180 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4181 return false;
4182 }
4183 return true;
4184}
4185
4187{
4188 if (!writer.writeString(portname)) {
4189 return false;
4190 }
4191 return true;
4192}
4193
4195{
4196 if (!readTag(reader)) {
4197 return false;
4198 }
4199 if (!readArgs(reader)) {
4200 return false;
4201 }
4202 return true;
4203}
4204
4206{
4207 std::string tag = reader.readTag(s_tag_len);
4208 if (reader.isError()) {
4209 return false;
4210 }
4211 if (tag != s_tag) {
4212 reader.fail();
4213 return false;
4214 }
4215 return true;
4216}
4217
4219{
4220 if (reader.noMore()) {
4221 reader.fail();
4222 return false;
4223 }
4224 if (!reader.readString(portname)) {
4225 reader.fail();
4226 return false;
4227 }
4228 if (!reader.noMore()) {
4229 reader.fail();
4230 return false;
4231 }
4232 return true;
4233}
4234
4236{
4237 yarp::os::idl::WireWriter writer(connection);
4238 return write(writer);
4239}
4240
4242{
4243 yarp::os::idl::WireReader reader(connection);
4244 return read(reader);
4245}
4246
4248{
4249 if (!writer.isNull()) {
4250 if (!writer.writeListHeader(s_reply_len)) {
4251 return false;
4252 }
4253 if (!writer.write(return_helper)) {
4254 return false;
4255 }
4256 }
4257 return true;
4258}
4259
4261{
4262 if (!reader.readListReturn()) {
4263 return false;
4264 }
4265 if (reader.noMore()) {
4266 reader.fail();
4267 return false;
4268 }
4269 if (!reader.read(return_helper)) {
4270 reader.fail();
4271 return false;
4272 }
4273 return true;
4274}
4275
4280
4281// getConnectionInfoOut helper class implementation
4283 cmd{portname}
4284{
4285}
4286
4288{
4289 return cmd.write(connection);
4290}
4291
4293{
4294 return reply.read(connection);
4295}
4296
4298 portname{portname}
4299{
4300}
4301
4303{
4304 yarp::os::idl::WireWriter writer(connection);
4305 if (!writer.writeListHeader(s_cmd_len)) {
4306 return false;
4307 }
4308 return write(writer);
4309}
4310
4312{
4313 yarp::os::idl::WireReader reader(connection);
4314 if (!reader.readListHeader()) {
4315 reader.fail();
4316 return false;
4317 }
4318 return read(reader);
4319}
4320
4322{
4323 if (!writeTag(writer)) {
4324 return false;
4325 }
4326 if (!writeArgs(writer)) {
4327 return false;
4328 }
4329 return true;
4330}
4331
4333{
4334 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4335 return false;
4336 }
4337 return true;
4338}
4339
4341{
4342 if (!writer.writeString(portname)) {
4343 return false;
4344 }
4345 return true;
4346}
4347
4349{
4350 if (!readTag(reader)) {
4351 return false;
4352 }
4353 if (!readArgs(reader)) {
4354 return false;
4355 }
4356 return true;
4357}
4358
4360{
4361 std::string tag = reader.readTag(s_tag_len);
4362 if (reader.isError()) {
4363 return false;
4364 }
4365 if (tag != s_tag) {
4366 reader.fail();
4367 return false;
4368 }
4369 return true;
4370}
4371
4373{
4374 if (reader.noMore()) {
4375 reader.fail();
4376 return false;
4377 }
4378 if (!reader.readString(portname)) {
4379 reader.fail();
4380 return false;
4381 }
4382 if (!reader.noMore()) {
4383 reader.fail();
4384 return false;
4385 }
4386 return true;
4387}
4388
4390{
4391 yarp::os::idl::WireWriter writer(connection);
4392 return write(writer);
4393}
4394
4396{
4397 yarp::os::idl::WireReader reader(connection);
4398 return read(reader);
4399}
4400
4402{
4403 if (!writer.isNull()) {
4404 if (!writer.writeListHeader(s_reply_len)) {
4405 return false;
4406 }
4407 if (!writer.write(return_helper)) {
4408 return false;
4409 }
4410 }
4411 return true;
4412}
4413
4415{
4416 if (!reader.readListReturn()) {
4417 return false;
4418 }
4419 if (reader.noMore()) {
4420 reader.fail();
4421 return false;
4422 }
4423 if (!reader.read(return_helper)) {
4424 reader.fail();
4425 return false;
4426 }
4427 return true;
4428}
4429
4434
4435// getAdminProtocolVersion helper class implementation
4437{
4438 return cmd.write(connection);
4439}
4440
4445
4447{
4448 yarp::os::idl::WireWriter writer(connection);
4449 if (!writer.writeListHeader(s_cmd_len)) {
4450 return false;
4451 }
4452 return write(writer);
4453}
4454
4456{
4457 yarp::os::idl::WireReader reader(connection);
4458 if (!reader.readListHeader()) {
4459 reader.fail();
4460 return false;
4461 }
4462 return read(reader);
4463}
4464
4466{
4467 if (!writeTag(writer)) {
4468 return false;
4469 }
4470 if (!writeArgs(writer)) {
4471 return false;
4472 }
4473 return true;
4474}
4475
4477{
4478 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4479 return false;
4480 }
4481 return true;
4482}
4483
4488
4490{
4491 if (!readTag(reader)) {
4492 return false;
4493 }
4494 if (!readArgs(reader)) {
4495 return false;
4496 }
4497 return true;
4498}
4499
4501{
4502 std::string tag = reader.readTag(s_tag_len);
4503 if (reader.isError()) {
4504 return false;
4505 }
4506 if (tag != s_tag) {
4507 reader.fail();
4508 return false;
4509 }
4510 return true;
4511}
4512
4514{
4515 if (!reader.noMore()) {
4516 reader.fail();
4517 return false;
4518 }
4519 return true;
4520}
4521
4523{
4524 yarp::os::idl::WireWriter writer(connection);
4525 return write(writer);
4526}
4527
4529{
4530 yarp::os::idl::WireReader reader(connection);
4531 return read(reader);
4532}
4533
4535{
4536 if (!writer.isNull()) {
4537 if (!writer.writeListHeader(s_reply_len)) {
4538 return false;
4539 }
4540 if (!writer.write(return_helper)) {
4541 return false;
4542 }
4543 }
4544 return true;
4545}
4546
4548{
4549 if (!reader.readListReturn()) {
4550 return false;
4551 }
4552 if (reader.noMore()) {
4553 reader.fail();
4554 return false;
4555 }
4556 if (!reader.read(return_helper)) {
4557 reader.fail();
4558 return false;
4559 }
4560 return true;
4561}
4562
4567
4568// getPortInfo helper class implementation
4570{
4571 return cmd.write(connection);
4572}
4573
4575{
4576 return reply.read(connection);
4577}
4578
4580{
4581 yarp::os::idl::WireWriter writer(connection);
4582 if (!writer.writeListHeader(s_cmd_len)) {
4583 return false;
4584 }
4585 return write(writer);
4586}
4587
4589{
4590 yarp::os::idl::WireReader reader(connection);
4591 if (!reader.readListHeader()) {
4592 reader.fail();
4593 return false;
4594 }
4595 return read(reader);
4596}
4597
4599{
4600 if (!writeTag(writer)) {
4601 return false;
4602 }
4603 if (!writeArgs(writer)) {
4604 return false;
4605 }
4606 return true;
4607}
4608
4610{
4611 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4612 return false;
4613 }
4614 return true;
4615}
4616
4618{
4619 return true;
4620}
4621
4623{
4624 if (!readTag(reader)) {
4625 return false;
4626 }
4627 if (!readArgs(reader)) {
4628 return false;
4629 }
4630 return true;
4631}
4632
4634{
4635 std::string tag = reader.readTag(s_tag_len);
4636 if (reader.isError()) {
4637 return false;
4638 }
4639 if (tag != s_tag) {
4640 reader.fail();
4641 return false;
4642 }
4643 return true;
4644}
4645
4647{
4648 if (!reader.noMore()) {
4649 reader.fail();
4650 return false;
4651 }
4652 return true;
4653}
4654
4656{
4657 yarp::os::idl::WireWriter writer(connection);
4658 return write(writer);
4659}
4660
4662{
4663 yarp::os::idl::WireReader reader(connection);
4664 return read(reader);
4665}
4666
4668{
4669 if (!writer.isNull()) {
4670 if (!writer.writeListHeader(s_reply_len)) {
4671 return false;
4672 }
4673 if (!writer.write(return_helper)) {
4674 return false;
4675 }
4676 }
4677 return true;
4678}
4679
4681{
4682 if (!reader.readListReturn()) {
4683 return false;
4684 }
4685 if (reader.noMore()) {
4686 reader.fail();
4687 return false;
4688 }
4689 if (!reader.read(return_helper)) {
4690 reader.fail();
4691 return false;
4692 }
4693 return true;
4694}
4695
4700
4701// getConnectionQosIn helper class implementation
4703 cmd{portname}
4704{
4705}
4706
4708{
4709 return cmd.write(connection);
4710}
4711
4713{
4714 return reply.read(connection);
4715}
4716
4718 portname{portname}
4719{
4720}
4721
4723{
4724 yarp::os::idl::WireWriter writer(connection);
4725 if (!writer.writeListHeader(s_cmd_len)) {
4726 return false;
4727 }
4728 return write(writer);
4729}
4730
4732{
4733 yarp::os::idl::WireReader reader(connection);
4734 if (!reader.readListHeader()) {
4735 reader.fail();
4736 return false;
4737 }
4738 return read(reader);
4739}
4740
4742{
4743 if (!writeTag(writer)) {
4744 return false;
4745 }
4746 if (!writeArgs(writer)) {
4747 return false;
4748 }
4749 return true;
4750}
4751
4753{
4754 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4755 return false;
4756 }
4757 return true;
4758}
4759
4761{
4762 if (!writer.writeString(portname)) {
4763 return false;
4764 }
4765 return true;
4766}
4767
4769{
4770 if (!readTag(reader)) {
4771 return false;
4772 }
4773 if (!readArgs(reader)) {
4774 return false;
4775 }
4776 return true;
4777}
4778
4780{
4781 std::string tag = reader.readTag(s_tag_len);
4782 if (reader.isError()) {
4783 return false;
4784 }
4785 if (tag != s_tag) {
4786 reader.fail();
4787 return false;
4788 }
4789 return true;
4790}
4791
4793{
4794 if (reader.noMore()) {
4795 reader.fail();
4796 return false;
4797 }
4798 if (!reader.readString(portname)) {
4799 reader.fail();
4800 return false;
4801 }
4802 if (!reader.noMore()) {
4803 reader.fail();
4804 return false;
4805 }
4806 return true;
4807}
4808
4810{
4811 yarp::os::idl::WireWriter writer(connection);
4812 return write(writer);
4813}
4814
4816{
4817 yarp::os::idl::WireReader reader(connection);
4818 return read(reader);
4819}
4820
4822{
4823 if (!writer.isNull()) {
4824 if (!writer.writeListHeader(s_reply_len)) {
4825 return false;
4826 }
4827 if (!writer.write(return_helper)) {
4828 return false;
4829 }
4830 }
4831 return true;
4832}
4833
4835{
4836 if (!reader.readListReturn()) {
4837 return false;
4838 }
4839 if (reader.noMore()) {
4840 reader.fail();
4841 return false;
4842 }
4843 if (!reader.read(return_helper)) {
4844 reader.fail();
4845 return false;
4846 }
4847 return true;
4848}
4849
4854
4855// getConnectionQosOut helper class implementation
4857 cmd{portname}
4858{
4859}
4860
4862{
4863 return cmd.write(connection);
4864}
4865
4867{
4868 return reply.read(connection);
4869}
4870
4872 portname{portname}
4873{
4874}
4875
4877{
4878 yarp::os::idl::WireWriter writer(connection);
4879 if (!writer.writeListHeader(s_cmd_len)) {
4880 return false;
4881 }
4882 return write(writer);
4883}
4884
4886{
4887 yarp::os::idl::WireReader reader(connection);
4888 if (!reader.readListHeader()) {
4889 reader.fail();
4890 return false;
4891 }
4892 return read(reader);
4893}
4894
4896{
4897 if (!writeTag(writer)) {
4898 return false;
4899 }
4900 if (!writeArgs(writer)) {
4901 return false;
4902 }
4903 return true;
4904}
4905
4907{
4908 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4909 return false;
4910 }
4911 return true;
4912}
4913
4915{
4916 if (!writer.writeString(portname)) {
4917 return false;
4918 }
4919 return true;
4920}
4921
4923{
4924 if (!readTag(reader)) {
4925 return false;
4926 }
4927 if (!readArgs(reader)) {
4928 return false;
4929 }
4930 return true;
4931}
4932
4934{
4935 std::string tag = reader.readTag(s_tag_len);
4936 if (reader.isError()) {
4937 return false;
4938 }
4939 if (tag != s_tag) {
4940 reader.fail();
4941 return false;
4942 }
4943 return true;
4944}
4945
4947{
4948 if (reader.noMore()) {
4949 reader.fail();
4950 return false;
4951 }
4952 if (!reader.readString(portname)) {
4953 reader.fail();
4954 return false;
4955 }
4956 if (!reader.noMore()) {
4957 reader.fail();
4958 return false;
4959 }
4960 return true;
4961}
4962
4964{
4965 yarp::os::idl::WireWriter writer(connection);
4966 return write(writer);
4967}
4968
4970{
4971 yarp::os::idl::WireReader reader(connection);
4972 return read(reader);
4973}
4974
4976{
4977 if (!writer.isNull()) {
4978 if (!writer.writeListHeader(s_reply_len)) {
4979 return false;
4980 }
4981 if (!writer.write(return_helper)) {
4982 return false;
4983 }
4984 }
4985 return true;
4986}
4987
4989{
4990 if (!reader.readListReturn()) {
4991 return false;
4992 }
4993 if (reader.noMore()) {
4994 reader.fail();
4995 return false;
4996 }
4997 if (!reader.read(return_helper)) {
4998 reader.fail();
4999 return false;
5000 }
5001 return true;
5002}
5003
5008
5009// setConnectionQosIn helper class implementation
5010PortCoreMsgs_setConnectionQosIn_helper::PortCoreMsgs_setConnectionQosIn_helper(const std::string& portname, const std::int32_t scheduler_priority, const std::int32_t scheduler_policy, const std::int32_t qos_tos) :
5011 cmd{portname, scheduler_priority, scheduler_policy, qos_tos}
5012{
5013}
5014
5016{
5017 return cmd.write(connection);
5018}
5019
5021{
5022 return reply.read(connection);
5023}
5024
5025PortCoreMsgs_setConnectionQosIn_helper::Command::Command(const std::string& portname, const std::int32_t scheduler_priority, const std::int32_t scheduler_policy, const std::int32_t qos_tos) :
5026 portname{portname},
5027 scheduler_priority{scheduler_priority},
5028 scheduler_policy{scheduler_policy},
5029 qos_tos{qos_tos}
5030{
5031}
5032
5034{
5035 yarp::os::idl::WireWriter writer(connection);
5036 if (!writer.writeListHeader(s_cmd_len)) {
5037 return false;
5038 }
5039 return write(writer);
5040}
5041
5043{
5044 yarp::os::idl::WireReader reader(connection);
5045 if (!reader.readListHeader()) {
5046 reader.fail();
5047 return false;
5048 }
5049 return read(reader);
5050}
5051
5053{
5054 if (!writeTag(writer)) {
5055 return false;
5056 }
5057 if (!writeArgs(writer)) {
5058 return false;
5059 }
5060 return true;
5061}
5062
5064{
5065 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5066 return false;
5067 }
5068 return true;
5069}
5070
5072{
5073 if (!writer.writeString(portname)) {
5074 return false;
5075 }
5076 if (!writer.writeI32(scheduler_priority)) {
5077 return false;
5078 }
5079 if (!writer.writeI32(scheduler_policy)) {
5080 return false;
5081 }
5082 if (!writer.writeI32(qos_tos)) {
5083 return false;
5084 }
5085 return true;
5086}
5087
5089{
5090 if (!readTag(reader)) {
5091 return false;
5092 }
5093 if (!readArgs(reader)) {
5094 return false;
5095 }
5096 return true;
5097}
5098
5100{
5101 std::string tag = reader.readTag(s_tag_len);
5102 if (reader.isError()) {
5103 return false;
5104 }
5105 if (tag != s_tag) {
5106 reader.fail();
5107 return false;
5108 }
5109 return true;
5110}
5111
5113{
5114 if (reader.noMore()) {
5115 reader.fail();
5116 return false;
5117 }
5118 if (!reader.readString(portname)) {
5119 reader.fail();
5120 return false;
5121 }
5122 if (reader.noMore()) {
5123 reader.fail();
5124 return false;
5125 }
5126 if (!reader.readI32(scheduler_priority)) {
5127 reader.fail();
5128 return false;
5129 }
5130 if (reader.noMore()) {
5131 reader.fail();
5132 return false;
5133 }
5134 if (!reader.readI32(scheduler_policy)) {
5135 reader.fail();
5136 return false;
5137 }
5138 if (reader.noMore()) {
5139 reader.fail();
5140 return false;
5141 }
5142 if (!reader.readI32(qos_tos)) {
5143 reader.fail();
5144 return false;
5145 }
5146 if (!reader.noMore()) {
5147 reader.fail();
5148 return false;
5149 }
5150 return true;
5151}
5152
5154{
5155 yarp::os::idl::WireWriter writer(connection);
5156 return write(writer);
5157}
5158
5160{
5161 yarp::os::idl::WireReader reader(connection);
5162 return read(reader);
5163}
5164
5166{
5167 if (!writer.isNull()) {
5168 if (!writer.writeListHeader(s_reply_len)) {
5169 return false;
5170 }
5171 if (!writer.write(return_helper)) {
5172 return false;
5173 }
5174 }
5175 return true;
5176}
5177
5179{
5180 if (!reader.readListReturn()) {
5181 return false;
5182 }
5183 if (reader.noMore()) {
5184 reader.fail();
5185 return false;
5186 }
5187 if (!reader.read(return_helper)) {
5188 reader.fail();
5189 return false;
5190 }
5191 return true;
5192}
5193
5198
5199// setConnectionQosOut helper class implementation
5200PortCoreMsgs_setConnectionQosOut_helper::PortCoreMsgs_setConnectionQosOut_helper(const std::string& portname, const std::int32_t scheduler_priority, const std::int32_t scheduler_policy, const std::int32_t qos_tos) :
5201 cmd{portname, scheduler_priority, scheduler_policy, qos_tos}
5202{
5203}
5204
5206{
5207 return cmd.write(connection);
5208}
5209
5211{
5212 return reply.read(connection);
5213}
5214
5215PortCoreMsgs_setConnectionQosOut_helper::Command::Command(const std::string& portname, const std::int32_t scheduler_priority, const std::int32_t scheduler_policy, const std::int32_t qos_tos) :
5216 portname{portname},
5217 scheduler_priority{scheduler_priority},
5218 scheduler_policy{scheduler_policy},
5219 qos_tos{qos_tos}
5220{
5221}
5222
5224{
5225 yarp::os::idl::WireWriter writer(connection);
5226 if (!writer.writeListHeader(s_cmd_len)) {
5227 return false;
5228 }
5229 return write(writer);
5230}
5231
5233{
5234 yarp::os::idl::WireReader reader(connection);
5235 if (!reader.readListHeader()) {
5236 reader.fail();
5237 return false;
5238 }
5239 return read(reader);
5240}
5241
5243{
5244 if (!writeTag(writer)) {
5245 return false;
5246 }
5247 if (!writeArgs(writer)) {
5248 return false;
5249 }
5250 return true;
5251}
5252
5254{
5255 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5256 return false;
5257 }
5258 return true;
5259}
5260
5262{
5263 if (!writer.writeString(portname)) {
5264 return false;
5265 }
5266 if (!writer.writeI32(scheduler_priority)) {
5267 return false;
5268 }
5269 if (!writer.writeI32(scheduler_policy)) {
5270 return false;
5271 }
5272 if (!writer.writeI32(qos_tos)) {
5273 return false;
5274 }
5275 return true;
5276}
5277
5279{
5280 if (!readTag(reader)) {
5281 return false;
5282 }
5283 if (!readArgs(reader)) {
5284 return false;
5285 }
5286 return true;
5287}
5288
5290{
5291 std::string tag = reader.readTag(s_tag_len);
5292 if (reader.isError()) {
5293 return false;
5294 }
5295 if (tag != s_tag) {
5296 reader.fail();
5297 return false;
5298 }
5299 return true;
5300}
5301
5303{
5304 if (reader.noMore()) {
5305 reader.fail();
5306 return false;
5307 }
5308 if (!reader.readString(portname)) {
5309 reader.fail();
5310 return false;
5311 }
5312 if (reader.noMore()) {
5313 reader.fail();
5314 return false;
5315 }
5316 if (!reader.readI32(scheduler_priority)) {
5317 reader.fail();
5318 return false;
5319 }
5320 if (reader.noMore()) {
5321 reader.fail();
5322 return false;
5323 }
5324 if (!reader.readI32(scheduler_policy)) {
5325 reader.fail();
5326 return false;
5327 }
5328 if (reader.noMore()) {
5329 reader.fail();
5330 return false;
5331 }
5332 if (!reader.readI32(qos_tos)) {
5333 reader.fail();
5334 return false;
5335 }
5336 if (!reader.noMore()) {
5337 reader.fail();
5338 return false;
5339 }
5340 return true;
5341}
5342
5344{
5345 yarp::os::idl::WireWriter writer(connection);
5346 return write(writer);
5347}
5348
5350{
5351 yarp::os::idl::WireReader reader(connection);
5352 return read(reader);
5353}
5354
5356{
5357 if (!writer.isNull()) {
5358 if (!writer.writeListHeader(s_reply_len)) {
5359 return false;
5360 }
5361 if (!writer.write(return_helper)) {
5362 return false;
5363 }
5364 }
5365 return true;
5366}
5367
5369{
5370 if (!reader.readListReturn()) {
5371 return false;
5372 }
5373 if (reader.noMore()) {
5374 reader.fail();
5375 return false;
5376 }
5377 if (!reader.read(return_helper)) {
5378 reader.fail();
5379 return false;
5380 }
5381 return true;
5382}
5383
5388
5389// setProcessScheduling helper class implementation
5390PortCoreMsgs_setProcessScheduling_helper::PortCoreMsgs_setProcessScheduling_helper(const std::int32_t priority, const std::int32_t policy) :
5391 cmd{priority, policy}
5392{
5393}
5394
5396{
5397 return cmd.write(connection);
5398}
5399
5401{
5402 return reply.read(connection);
5403}
5404
5405PortCoreMsgs_setProcessScheduling_helper::Command::Command(const std::int32_t priority, const std::int32_t policy) :
5406 priority{priority},
5407 policy{policy}
5408{
5409}
5410
5412{
5413 yarp::os::idl::WireWriter writer(connection);
5414 if (!writer.writeListHeader(s_cmd_len)) {
5415 return false;
5416 }
5417 return write(writer);
5418}
5419
5421{
5422 yarp::os::idl::WireReader reader(connection);
5423 if (!reader.readListHeader()) {
5424 reader.fail();
5425 return false;
5426 }
5427 return read(reader);
5428}
5429
5431{
5432 if (!writeTag(writer)) {
5433 return false;
5434 }
5435 if (!writeArgs(writer)) {
5436 return false;
5437 }
5438 return true;
5439}
5440
5442{
5443 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5444 return false;
5445 }
5446 return true;
5447}
5448
5450{
5451 if (!writer.writeI32(priority)) {
5452 return false;
5453 }
5454 if (!writer.writeI32(policy)) {
5455 return false;
5456 }
5457 return true;
5458}
5459
5461{
5462 if (!readTag(reader)) {
5463 return false;
5464 }
5465 if (!readArgs(reader)) {
5466 return false;
5467 }
5468 return true;
5469}
5470
5472{
5473 std::string tag = reader.readTag(s_tag_len);
5474 if (reader.isError()) {
5475 return false;
5476 }
5477 if (tag != s_tag) {
5478 reader.fail();
5479 return false;
5480 }
5481 return true;
5482}
5483
5485{
5486 if (reader.noMore()) {
5487 reader.fail();
5488 return false;
5489 }
5490 if (!reader.readI32(priority)) {
5491 reader.fail();
5492 return false;
5493 }
5494 if (reader.noMore()) {
5495 reader.fail();
5496 return false;
5497 }
5498 if (!reader.readI32(policy)) {
5499 reader.fail();
5500 return false;
5501 }
5502 if (!reader.noMore()) {
5503 reader.fail();
5504 return false;
5505 }
5506 return true;
5507}
5508
5510{
5511 yarp::os::idl::WireWriter writer(connection);
5512 return write(writer);
5513}
5514
5516{
5517 yarp::os::idl::WireReader reader(connection);
5518 return read(reader);
5519}
5520
5522{
5523 if (!writer.isNull()) {
5524 if (!writer.writeListHeader(s_reply_len)) {
5525 return false;
5526 }
5527 if (!writer.writeBool(return_helper)) {
5528 return false;
5529 }
5530 }
5531 return true;
5532}
5533
5535{
5536 if (!reader.readListReturn()) {
5537 return false;
5538 }
5539 if (reader.noMore()) {
5540 reader.fail();
5541 return false;
5542 }
5543 if (!reader.readBool(return_helper)) {
5544 reader.fail();
5545 return false;
5546 }
5547 return true;
5548}
5549
5554
5555// Constructor
5557{
5558 yarp().setOwner(*this);
5559}
5560
5561return_addConnection PortCoreMsgs::addConnection(const std::string& portname, const std::string& carrier)
5562{
5563 if (!yarp().canWrite()) {
5564 yError("Missing server method '%s'?", PortCoreMsgs_addConnection_helper::s_prototype);
5565 }
5566 PortCoreMsgs_addConnection_helper helper{portname, carrier};
5567 bool ok = yarp().write(helper, helper);
5568 return ok ? helper.reply.return_helper : return_addConnection{};
5569}
5570
5572{
5573 if (!yarp().canWrite()) {
5574 yError("Missing server method '%s'?", PortCoreMsgs_delConnection_helper::s_prototype);
5575 }
5576 PortCoreMsgs_delConnection_helper helper{portname};
5577 bool ok = yarp().write(helper, helper);
5578 return ok ? helper.reply.return_helper : return_delConnection{};
5579}
5580
5581bool PortCoreMsgs::attachPortmonitorOut(const std::string& prop)
5582{
5583 if (!yarp().canWrite()) {
5584 yError("Missing server method '%s'?", PortCoreMsgs_attachPortmonitorOut_helper::s_prototype);
5585 }
5587 bool ok = yarp().write(helper, helper);
5588 return ok ? helper.reply.return_helper : bool{};
5589}
5590
5591bool PortCoreMsgs::attachPortmonitorIn(const std::string& prop)
5592{
5593 if (!yarp().canWrite()) {
5594 yError("Missing server method '%s'?", PortCoreMsgs_attachPortmonitorIn_helper::s_prototype);
5595 }
5597 bool ok = yarp().write(helper, helper);
5598 return ok ? helper.reply.return_helper : bool{};
5599}
5600
5602{
5603 if (!yarp().canWrite()) {
5604 yError("Missing server method '%s'?", PortCoreMsgs_detachPortmonitorOut_helper::s_prototype);
5605 }
5607 bool ok = yarp().write(helper, helper);
5608 return ok ? helper.reply.return_helper : bool{};
5609}
5610
5612{
5613 if (!yarp().canWrite()) {
5614 yError("Missing server method '%s'?", PortCoreMsgs_detachPortmonitorIn_helper::s_prototype);
5615 }
5617 bool ok = yarp().write(helper, helper);
5618 return ok ? helper.reply.return_helper : bool{};
5619}
5620
5622{
5623 if (!yarp().canWrite()) {
5625 }
5627 bool ok = yarp().write(helper, helper);
5628 return ok ? helper.reply.return_helper : return_setPortmonitorParams{};
5629}
5630
5632{
5633 if (!yarp().canWrite()) {
5635 }
5637 bool ok = yarp().write(helper, helper);
5638 return ok ? helper.reply.return_helper : return_setPortmonitorParams{};
5639}
5640
5642{
5643 if (!yarp().canWrite()) {
5645 }
5647 bool ok = yarp().write(helper, helper);
5648 return ok ? helper.reply.return_helper : return_getPortmonitorParams{};
5649}
5650
5652{
5653 if (!yarp().canWrite()) {
5655 }
5657 bool ok = yarp().write(helper, helper);
5658 return ok ? helper.reply.return_helper : return_getPortmonitorParams{};
5659}
5660
5661return_setConnectionParams PortCoreMsgs::setConnectionParamsOut(const std::string& portname, const std::string& params)
5662{
5663 if (!yarp().canWrite()) {
5665 }
5666 PortCoreMsgs_setConnectionParamsOut_helper helper{portname, params};
5667 bool ok = yarp().write(helper, helper);
5668 return ok ? helper.reply.return_helper : return_setConnectionParams{};
5669}
5670
5671return_setConnectionParams PortCoreMsgs::setConnectionParamsIn(const std::string& portname, const std::string& params)
5672{
5673 if (!yarp().canWrite()) {
5674 yError("Missing server method '%s'?", PortCoreMsgs_setConnectionParamsIn_helper::s_prototype);
5675 }
5676 PortCoreMsgs_setConnectionParamsIn_helper helper{portname, params};
5677 bool ok = yarp().write(helper, helper);
5678 return ok ? helper.reply.return_helper : return_setConnectionParams{};
5679}
5680
5682{
5683 if (!yarp().canWrite()) {
5685 }
5687 bool ok = yarp().write(helper, helper);
5688 return ok ? helper.reply.return_helper : return_getConnectionParams{};
5689}
5690
5692{
5693 if (!yarp().canWrite()) {
5694 yError("Missing server method '%s'?", PortCoreMsgs_getConnectionParamsIn_helper::s_prototype);
5695 }
5697 bool ok = yarp().write(helper, helper);
5698 return ok ? helper.reply.return_helper : return_getConnectionParams{};
5699}
5700
5702{
5703 if (!yarp().canWrite()) {
5704 yError("Missing server method '%s'?", PortCoreMsgs_listConnectionsIn_helper::s_prototype);
5705 }
5707 bool ok = yarp().write(helper, helper);
5708 return ok ? helper.reply.return_helper : return_listConnections{};
5709}
5710
5712{
5713 if (!yarp().canWrite()) {
5714 yError("Missing server method '%s'?", PortCoreMsgs_listConnectionsOut_helper::s_prototype);
5715 }
5717 bool ok = yarp().write(helper, helper);
5718 return ok ? helper.reply.return_helper : return_listConnections{};
5719}
5720
5722{
5723 if (!yarp().canWrite()) {
5724 yError("Missing server method '%s'?", PortCoreMsgs_getConnectionInfoIn_helper::s_prototype);
5725 }
5727 bool ok = yarp().write(helper, helper);
5728 return ok ? helper.reply.return_helper : return_getConnectionInfo{};
5729}
5730
5732{
5733 if (!yarp().canWrite()) {
5734 yError("Missing server method '%s'?", PortCoreMsgs_getConnectionInfoOut_helper::s_prototype);
5735 }
5737 bool ok = yarp().write(helper, helper);
5738 return ok ? helper.reply.return_helper : return_getConnectionInfo{};
5739}
5740
5742{
5743 if (!yarp().canWrite()) {
5745 }
5747 bool ok = yarp().write(helper, helper);
5748 return ok ? helper.reply.return_helper : return_getAdminProtocolVersion{};
5749}
5750
5752{
5753 if (!yarp().canWrite()) {
5754 yError("Missing server method '%s'?", PortCoreMsgs_getPortInfo_helper::s_prototype);
5755 }
5757 bool ok = yarp().write(helper, helper);
5758 return ok ? helper.reply.return_helper : return_getPortInfo{};
5759}
5760
5762{
5763 if (!yarp().canWrite()) {
5764 yError("Missing server method '%s'?", PortCoreMsgs_getConnectionQosIn_helper::s_prototype);
5765 }
5767 bool ok = yarp().write(helper, helper);
5768 return ok ? helper.reply.return_helper : return_getConnectionQos{};
5769}
5770
5772{
5773 if (!yarp().canWrite()) {
5774 yError("Missing server method '%s'?", PortCoreMsgs_getConnectionQosOut_helper::s_prototype);
5775 }
5777 bool ok = yarp().write(helper, helper);
5778 return ok ? helper.reply.return_helper : return_getConnectionQos{};
5779}
5780
5781return_setConnectionQos PortCoreMsgs::setConnectionQosIn(const std::string& portname, const std::int32_t scheduler_priority, const std::int32_t scheduler_policy, const std::int32_t qos_tos)
5782{
5783 if (!yarp().canWrite()) {
5784 yError("Missing server method '%s'?", PortCoreMsgs_setConnectionQosIn_helper::s_prototype);
5785 }
5786 PortCoreMsgs_setConnectionQosIn_helper helper{portname, scheduler_priority, scheduler_policy, qos_tos};
5787 bool ok = yarp().write(helper, helper);
5788 return ok ? helper.reply.return_helper : return_setConnectionQos{};
5789}
5790
5791return_setConnectionQos PortCoreMsgs::setConnectionQosOut(const std::string& portname, const std::int32_t scheduler_priority, const std::int32_t scheduler_policy, const std::int32_t qos_tos)
5792{
5793 if (!yarp().canWrite()) {
5794 yError("Missing server method '%s'?", PortCoreMsgs_setConnectionQosOut_helper::s_prototype);
5795 }
5796 PortCoreMsgs_setConnectionQosOut_helper helper{portname, scheduler_priority, scheduler_policy, qos_tos};
5797 bool ok = yarp().write(helper, helper);
5798 return ok ? helper.reply.return_helper : return_setConnectionQos{};
5799}
5800
5801bool PortCoreMsgs::setProcessScheduling(const std::int32_t priority, const std::int32_t policy)
5802{
5803 if (!yarp().canWrite()) {
5804 yError("Missing server method '%s'?", PortCoreMsgs_setProcessScheduling_helper::s_prototype);
5805 }
5806 PortCoreMsgs_setProcessScheduling_helper helper{priority, policy};
5807 bool ok = yarp().write(helper, helper);
5808 return ok ? helper.reply.return_helper : bool{};
5809}
5810
5811// help method
5812std::vector<std::string> PortCoreMsgs::help(const std::string& functionName)
5813{
5814 bool showAll = (functionName == "--all");
5815 std::vector<std::string> helpString;
5816 if (showAll) {
5817 helpString.emplace_back("*** Available commands:");
5843 helpString.emplace_back("help");
5844 } else {
5848 }
5852 }
5856 }
5860 }
5864 }
5868 }
5872 }
5876 }
5880 }
5884 }
5888 }
5892 }
5896 }
5900 }
5904 }
5908 }
5912 }
5916 }
5920 }
5924 }
5928 }
5932 }
5936 }
5940 }
5944 }
5945 if (functionName == "help") {
5946 helpString.emplace_back("std::vector<std::string> help(const std::string& functionName = \"--all\")");
5947 helpString.emplace_back("Return list of available commands, or help message for a specific function");
5948 helpString.emplace_back("@param functionName name of command for which to get a detailed description. If none or '--all' is provided, print list of available commands");
5949 helpString.emplace_back("@return list of strings (one string per line)");
5950 }
5951 }
5952 if (helpString.empty()) {
5953 helpString.emplace_back("Command not found");
5954 }
5955 return helpString;
5956}
5957
5958// read from ConnectionReader
5960{
5961 constexpr size_t max_tag_len = 1;
5962 size_t tag_len = 1;
5963
5964 yarp::os::idl::WireReader reader(connection);
5965 reader.expectAccept();
5966 if (!reader.readListHeader()) {
5967 reader.fail();
5968 return false;
5969 }
5970
5971 std::string tag = reader.readTag(1);
5972 bool direct = (tag == "__direct__");
5973 if (direct) {
5974 tag = reader.readTag(1);
5975 }
5976 while (tag_len <= max_tag_len && !reader.isError()) {
5977 if(tag == "getRemoteProtocolVersion") {
5978 if (!reader.noMore()) {
5979 yError("Reader invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
5980 reader.fail();
5981 return false;
5982 }
5983
5984 auto proto = getLocalProtocolVersion();
5985
5986 yarp::os::idl::WireWriter writer(reader);
5987 if (!writer.writeListHeader(1)) {
5988 yWarning("Writer invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
5989 return false;}
5990 if (!writer.write(proto)) {
5991 yWarning("Writer invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
5992 return false;
5993 }
5994 reader.accept();
5995 return true;
5996 }
5999 if (!helper.cmd.readArgs(reader)) {
6000 return false;
6001 }
6002
6003 helper.call(this);
6004
6005 yarp::os::idl::WireWriter writer(reader);
6006 if (!helper.reply.write(writer)) {
6007 return false;
6008 }
6009 reader.accept();
6010 return true;
6011 }
6014 if (!helper.cmd.readArgs(reader)) {
6015 return false;
6016 }
6017
6018 helper.call(this);
6019
6020 yarp::os::idl::WireWriter writer(reader);
6021 if (!helper.reply.write(writer)) {
6022 return false;
6023 }
6024 reader.accept();
6025 return true;
6026 }
6029 if (!helper.cmd.readArgs(reader)) {
6030 return false;
6031 }
6032
6033 helper.call(this);
6034
6035 yarp::os::idl::WireWriter writer(reader);
6036 if (!helper.reply.write(writer)) {
6037 return false;
6038 }
6039 reader.accept();
6040 return true;
6041 }
6044 if (!helper.cmd.readArgs(reader)) {
6045 return false;
6046 }
6047
6048 helper.call(this);
6049
6050 yarp::os::idl::WireWriter writer(reader);
6051 if (!helper.reply.write(writer)) {
6052 return false;
6053 }
6054 reader.accept();
6055 return true;
6056 }
6059 if (!helper.cmd.readArgs(reader)) {
6060 return false;
6061 }
6062
6063 helper.call(this);
6064
6065 yarp::os::idl::WireWriter writer(reader);
6066 if (!helper.reply.write(writer)) {
6067 return false;
6068 }
6069 reader.accept();
6070 return true;
6071 }
6074 if (!helper.cmd.readArgs(reader)) {
6075 return false;
6076 }
6077
6078 helper.call(this);
6079
6080 yarp::os::idl::WireWriter writer(reader);
6081 if (!helper.reply.write(writer)) {
6082 return false;
6083 }
6084 reader.accept();
6085 return true;
6086 }
6089 if (!helper.cmd.readArgs(reader)) {
6090 return false;
6091 }
6092
6093 helper.call(this);
6094
6095 yarp::os::idl::WireWriter writer(reader);
6096 if (!helper.reply.write(writer)) {
6097 return false;
6098 }
6099 reader.accept();
6100 return true;
6101 }
6104 if (!helper.cmd.readArgs(reader)) {
6105 return false;
6106 }
6107
6108 helper.call(this);
6109
6110 yarp::os::idl::WireWriter writer(reader);
6111 if (!helper.reply.write(writer)) {
6112 return false;
6113 }
6114 reader.accept();
6115 return true;
6116 }
6119 if (!helper.cmd.readArgs(reader)) {
6120 return false;
6121 }
6122
6123 helper.call(this);
6124
6125 yarp::os::idl::WireWriter writer(reader);
6126 if (!helper.reply.write(writer)) {
6127 return false;
6128 }
6129 reader.accept();
6130 return true;
6131 }
6134 if (!helper.cmd.readArgs(reader)) {
6135 return false;
6136 }
6137
6138 helper.call(this);
6139
6140 yarp::os::idl::WireWriter writer(reader);
6141 if (!helper.reply.write(writer)) {
6142 return false;
6143 }
6144 reader.accept();
6145 return true;
6146 }
6149 if (!helper.cmd.readArgs(reader)) {
6150 return false;
6151 }
6152
6153 helper.call(this);
6154
6155 yarp::os::idl::WireWriter writer(reader);
6156 if (!helper.reply.write(writer)) {
6157 return false;
6158 }
6159 reader.accept();
6160 return true;
6161 }
6164 if (!helper.cmd.readArgs(reader)) {
6165 return false;
6166 }
6167
6168 helper.call(this);
6169
6170 yarp::os::idl::WireWriter writer(reader);
6171 if (!helper.reply.write(writer)) {
6172 return false;
6173 }
6174 reader.accept();
6175 return true;
6176 }
6179 if (!helper.cmd.readArgs(reader)) {
6180 return false;
6181 }
6182
6183 helper.call(this);
6184
6185 yarp::os::idl::WireWriter writer(reader);
6186 if (!helper.reply.write(writer)) {
6187 return false;
6188 }
6189 reader.accept();
6190 return true;
6191 }
6194 if (!helper.cmd.readArgs(reader)) {
6195 return false;
6196 }
6197
6198 helper.call(this);
6199
6200 yarp::os::idl::WireWriter writer(reader);
6201 if (!helper.reply.write(writer)) {
6202 return false;
6203 }
6204 reader.accept();
6205 return true;
6206 }
6209 if (!helper.cmd.readArgs(reader)) {
6210 return false;
6211 }
6212
6213 helper.call(this);
6214
6215 yarp::os::idl::WireWriter writer(reader);
6216 if (!helper.reply.write(writer)) {
6217 return false;
6218 }
6219 reader.accept();
6220 return true;
6221 }
6224 if (!helper.cmd.readArgs(reader)) {
6225 return false;
6226 }
6227
6228 helper.call(this);
6229
6230 yarp::os::idl::WireWriter writer(reader);
6231 if (!helper.reply.write(writer)) {
6232 return false;
6233 }
6234 reader.accept();
6235 return true;
6236 }
6239 if (!helper.cmd.readArgs(reader)) {
6240 return false;
6241 }
6242
6243 helper.call(this);
6244
6245 yarp::os::idl::WireWriter writer(reader);
6246 if (!helper.reply.write(writer)) {
6247 return false;
6248 }
6249 reader.accept();
6250 return true;
6251 }
6254 if (!helper.cmd.readArgs(reader)) {
6255 return false;
6256 }
6257
6258 helper.call(this);
6259
6260 yarp::os::idl::WireWriter writer(reader);
6261 if (!helper.reply.write(writer)) {
6262 return false;
6263 }
6264 reader.accept();
6265 return true;
6266 }
6269 if (!helper.cmd.readArgs(reader)) {
6270 return false;
6271 }
6272
6273 helper.call(this);
6274
6275 yarp::os::idl::WireWriter writer(reader);
6276 if (!helper.reply.write(writer)) {
6277 return false;
6278 }
6279 reader.accept();
6280 return true;
6281 }
6284 if (!helper.cmd.readArgs(reader)) {
6285 return false;
6286 }
6287
6288 helper.call(this);
6289
6290 yarp::os::idl::WireWriter writer(reader);
6291 if (!helper.reply.write(writer)) {
6292 return false;
6293 }
6294 reader.accept();
6295 return true;
6296 }
6299 if (!helper.cmd.readArgs(reader)) {
6300 return false;
6301 }
6302
6303 helper.call(this);
6304
6305 yarp::os::idl::WireWriter writer(reader);
6306 if (!helper.reply.write(writer)) {
6307 return false;
6308 }
6309 reader.accept();
6310 return true;
6311 }
6314 if (!helper.cmd.readArgs(reader)) {
6315 return false;
6316 }
6317
6318 helper.call(this);
6319
6320 yarp::os::idl::WireWriter writer(reader);
6321 if (!helper.reply.write(writer)) {
6322 return false;
6323 }
6324 reader.accept();
6325 return true;
6326 }
6329 if (!helper.cmd.readArgs(reader)) {
6330 return false;
6331 }
6332
6333 helper.call(this);
6334
6335 yarp::os::idl::WireWriter writer(reader);
6336 if (!helper.reply.write(writer)) {
6337 return false;
6338 }
6339 reader.accept();
6340 return true;
6341 }
6344 if (!helper.cmd.readArgs(reader)) {
6345 return false;
6346 }
6347
6348 helper.call(this);
6349
6350 yarp::os::idl::WireWriter writer(reader);
6351 if (!helper.reply.write(writer)) {
6352 return false;
6353 }
6354 reader.accept();
6355 return true;
6356 }
6359 if (!helper.cmd.readArgs(reader)) {
6360 return false;
6361 }
6362
6363 helper.call(this);
6364
6365 yarp::os::idl::WireWriter writer(reader);
6366 if (!helper.reply.write(writer)) {
6367 return false;
6368 }
6369 reader.accept();
6370 return true;
6371 }
6372 if (tag == "help") {
6373 std::string functionName;
6374 if (!reader.readString(functionName)) {
6375 functionName = "--all";
6376 }
6377 auto help_strings = help(functionName);
6378 yarp::os::idl::WireWriter writer(reader);
6379 if (!writer.isNull()) {
6380 if (!writer.writeListHeader(2)) {
6381 return false;
6382 }
6383 if (!writer.writeTag("many", 1, 0)) {
6384 return false;
6385 }
6386 if (!writer.writeListBegin(0, help_strings.size())) {
6387 return false;
6388 }
6389 for (const auto& help_string : help_strings) {
6390 if (!writer.writeString(help_string)) {
6391 return false;
6392 }
6393 }
6394 if (!writer.writeListEnd()) {
6395 return false;
6396 }
6397 }
6398 reader.accept();
6399 return true;
6400 }
6401 if (reader.noMore()) {
6402 reader.fail();
6403 return false;
6404 }
6405 std::string next_tag = reader.readTag(1);
6406 if (next_tag.empty()) {
6407 break;
6408 }
6409 tag.append("_").append(next_tag);
6410 tag_len = std::count(tag.begin(), tag.end(), '_') + 1;
6411 }
6412 return false;
6413}
6414
6415} // namespace yarp::os
#define yError(...)
Definition Log.h:361
#define __YFUNCTION__
Definition Log.h:24
#define yWarning(...)
Definition Log.h:340
A mini-server for performing network communication in the background.
An interface for reading from a network connection.
An interface for writing to a network connection.
bool readTag(yarp::os::idl::WireReader &reader)
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool readArgs(yarp::os::idl::WireReader &reader)
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
return_addConnection(*)(const std::string &, const std::string &) funcptr_t
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_prototype
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool readTag(yarp::os::idl::WireReader &reader)
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool readArgs(yarp::os::idl::WireReader &reader)
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
return_delConnection(*)(const std::string &) funcptr_t
static constexpr const char * s_prototype
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
return_getConnectionInfo(*)(const std::string &) funcptr_t
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
return_getConnectionInfo(*)(const std::string &) funcptr_t
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
return_getConnectionParams(*)(const std::string &) funcptr_t
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
return_getConnectionParams(*)(const std::string &) funcptr_t
bool readArgs(yarp::os::idl::WireReader &reader)
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool readTag(yarp::os::idl::WireReader &reader)
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
return_getConnectionQos(*)(const std::string &) funcptr_t
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
return_getConnectionQos(*)(const std::string &) funcptr_t
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool readTag(yarp::os::idl::WireReader &reader)
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool readArgs(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_help
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_tag
static constexpr const char * s_prototype
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
yarp::os::ApplicationNetworkProtocolVersion helper_proto
bool readTag(yarp::os::idl::WireReader &reader)
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool readArgs(yarp::os::idl::WireReader &reader)
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool readArgs(yarp::os::idl::WireReader &reader)
bool readTag(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
return_setConnectionParams(*)(const std::string &, const std::string &) funcptr_t
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
return_setConnectionParams(*)(const std::string &, const std::string &) funcptr_t
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool readArgs(yarp::os::idl::WireReader &reader)
bool readTag(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
return_setConnectionQos(*)(const std::string &, const std::int32_t, const std::int32_t, const std::int32_t) funcptr_t
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
return_setConnectionQos(*)(const std::string &, const std::int32_t, const std::int32_t, const std::int32_t) funcptr_t
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
return_setPortmonitorParams(*)(const std::string &) funcptr_t
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
return_setPortmonitorParams(*)(const std::string &) funcptr_t
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool(*)(const std::int32_t, const std::int32_t) funcptr_t
Administrative commands of a YARP port, handled by PortCore::adminBlock().
virtual return_getPortInfo getPortInfo()
Give information about this port, its main thread, and the process and the platform on which it is ru...
virtual return_getConnectionInfo getConnectionInfoOut(const std::string &portname)
Give details about the output connection going from this port to another port.
virtual yarp::os::ApplicationNetworkProtocolVersion getLocalProtocolVersion()
virtual return_getAdminProtocolVersion getAdminProtocolVersion()
Report the version of the administrative protocol of this port (it is distinct from the version of th...
virtual return_listConnections listConnectionsOut()
List the ports connected to the output of this port.
virtual bool attachPortmonitorIn(const std::string &prop)
Attach a portmonitor plug-in to the input of this port (it replaces the one previously attached,...
virtual return_setPortmonitorParams setPortmonitorParamsIn(const std::string &params)
Set the parameters of the portmonitor plug-in attached to the input of this port.
virtual return_getConnectionQos getConnectionQosOut(const std::string &portname)
Get the quality of service of the output connection going from this port to another port.
virtual bool setProcessScheduling(const std::int32_t priority, const std::int32_t policy)
Set the scheduling parameters of all the threads of the process which owns this port.
virtual return_setConnectionQos setConnectionQosOut(const std::string &portname, const std::int32_t scheduler_priority, const std::int32_t scheduler_policy, const std::int32_t qos_tos)
Set the quality of service of the output connection going from this port to another port.
virtual return_getPortmonitorParams getPortmonitorParamsIn()
Get the parameters of the portmonitor plug-in attached to the input of this port.
virtual return_getConnectionQos getConnectionQosIn(const std::string &portname)
Get the quality of service of the input connection coming from another port to this port.
virtual return_setConnectionParams setConnectionParamsOut(const std::string &portname, const std::string &params)
Set the carrier parameters of the output connection going from this port to another port.
virtual yarp::os::ApplicationNetworkProtocolVersion getRemoteProtocolVersion()
virtual return_getConnectionParams getConnectionParamsIn(const std::string &portname)
Get the carrier parameters of the input connection coming from another port to this port.
virtual return_setConnectionParams setConnectionParamsIn(const std::string &portname, const std::string &params)
Set the carrier parameters of the input connection coming from another port to this port.
virtual bool checkProtocolVersion()
virtual bool detachPortmonitorOut()
Detach the portmonitor plug-in from the output of this port.
virtual return_getPortmonitorParams getPortmonitorParamsOut()
Get the parameters of the portmonitor plug-in attached to the output of this port.
virtual std::vector< std::string > help(const std::string &functionName="--all")
virtual bool attachPortmonitorOut(const std::string &prop)
Attach a portmonitor plug-in to the output of this port (it replaces the one previously attached,...
virtual return_delConnection delConnection(const std::string &portname)
Remove all the input and output connections between this port and another port.
virtual bool detachPortmonitorIn()
Detach the portmonitor plug-in from the input of this port.
virtual return_setConnectionQos setConnectionQosIn(const std::string &portname, const std::int32_t scheduler_priority, const std::int32_t scheduler_policy, const std::int32_t qos_tos)
Set the quality of service of the input connection coming from another port to this port.
virtual return_addConnection addConnection(const std::string &portname, const std::string &carrier="")
Add an output connection from this port to another port.
virtual return_listConnections listConnectionsIn()
List the ports connected to the input of this port.
virtual return_getConnectionInfo getConnectionInfoIn(const std::string &portname)
Give details about the input connection coming from another port to this port.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
virtual return_getConnectionParams getConnectionParamsOut(const std::string &portname)
Get the carrier parameters of the output connection going from this port to another port.
virtual return_setPortmonitorParams setPortmonitorParamsOut(const std::string &params)
Set the parameters of the portmonitor plug-in attached to the output of this port.
This is a base class for objects that can be both read from and be written to the YARP network.
Definition Portable.h:25
yarp::os::WireLink & yarp()
Get YARP state associated with this object.
Definition Wire.h:28
A "tamed" Portable, that promises to serialize itself in an IDL-friendly way.
IDL-friendly connection reader.
Definition WireReader.h:27
bool readString(std::string &str, bool *is_vocab=nullptr)
bool readI32(std::int32_t &x)
std::string readTag(size_t len=static_cast< size_t >(-1))
bool read(WirePortable &obj)
IDL-friendly connection writer.
Definition WireWriter.h:28
bool writeBool(bool x, bool skip_tag=false) const
bool write(const WirePortable &obj) const
bool writeI32(std::int32_t x, bool skip_tag=false) const
bool writeListHeader(int len) const
bool writeTag(const char *tag, int split, int len) const
bool writeString(const std::string &str, bool skip_tag=false) const
bool writeListBegin(int tag, size_t len) const
Reply of PortCoreMsgs::addConnection().
Reply of PortCoreMsgs::delConnection().
Reply of PortCoreMsgs::getAdminProtocolVersion().
Reply of PortCoreMsgs::getConnectionInfoIn() and PortCoreMsgs::getConnectionInfoOut().
Reply of PortCoreMsgs::getConnectionParamsIn() and PortCoreMsgs::getConnectionParamsOut().
Reply of PortCoreMsgs::getConnectionQosIn() and PortCoreMsgs::getConnectionQosOut().
Reply of PortCoreMsgs::getPortInfo().
Reply of PortCoreMsgs::getPortmonitorParamsIn() and PortCoreMsgs::getPortmonitorParamsOut().
Reply of PortCoreMsgs::listConnectionsIn() and PortCoreMsgs::listConnectionsOut().
Reply of PortCoreMsgs::setConnectionParamsIn() and PortCoreMsgs::setConnectionParamsOut().
Reply of PortCoreMsgs::setConnectionQosIn() and PortCoreMsgs::setConnectionQosOut().
Reply of PortCoreMsgs::setPortmonitorParamsIn() and PortCoreMsgs::setPortmonitorParamsOut().
#define yCError(component,...)
#define YARP_LOG_COMPONENT(name,...)
An interface to the operating system, including Port based communication.
The main, catch-all namespace for YARP.
Definition dirs.h:16
#define YARP_VERSION_PATCH
Definition version.h:12
#define YARP_VERSION_MAJOR
Definition version.h:10
#define YARP_VERSION_MINOR
Definition version.h:11