YARP
Yet Another Robot Platform
 
Loading...
Searching...
No Matches
RGBDSensorMsgs.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>
13#include <RGBDSensorMsgs.h>
15#include <yarp/os/LogStream.h>
16
18
19#include <algorithm>
20
21namespace
22{
23 YARP_LOG_COMPONENT(SERVICE_LOG_COMPONENT, "RGBDSensorMsgs")
24}
25
26//RGBDSensorMsgs_getRemoteProtocolVersion_helper declaration
37
39{
40 yarp::os::idl::WireWriter writer(connection);
41 if (!writer.writeListHeader(1)) {
42 return false;
43 }
44 if (!writer.writeString("getRemoteProtocolVersion")) {
45 return false;
46 }
47 return true;
48}
49
50bool RGBDSensorMsgs_getRemoteProtocolVersion_helper ::read(yarp::os::ConnectionReader & connection)
51 {
52 yarp::os::idl::WireReader reader(connection);
53 if (!reader.readListHeader()) {
54 reader.fail();
55 return false;
56 }
57
58 if (!helper_proto.read(connection)) {
59 reader.fail();
60 return false;
61 }
62 return true;
63}
64
65//ProtocolVersion, client side
67 {
68 if(!yarp().canWrite()) {
69 yError(" Missing server method RGBDSensorMsgs::getRemoteProtocolVersion");
70 }
72 bool ok = yarp().write(helper, helper);
73 if (ok) {
74 return helper.helper_proto;}
75 else {
77 return failureproto;}
78}
79
80//ProtocolVersion, client side
82 {
83 auto locproto = this->getLocalProtocolVersion();
84 auto remproto = this->getRemoteProtocolVersion();
85 if (remproto.protocol_version != locproto.protocol_version)
86 {
87 yCError(SERVICE_LOG_COMPONENT) << "Invalid communication protocol.";
88 yCError(SERVICE_LOG_COMPONENT) << "Local Protocol Version: " << locproto.toString();
89 yCError(SERVICE_LOG_COMPONENT) << "Remote Protocol Version: " << remproto.toString();
90 return false;
91 }
92 return true;
93}
94
95//ProtocolVersion, server side
97{
99 //myproto.protocol_version using default value = 0
100 //to change this value add the following line to the .thrift file:
101 //const i16 protocol_version = <your_number_here>
102 myproto.protocol_version = 0;
106 return myproto;
107}
108
109// getExtrinsicParamRPC helper class declaration
111 public yarp::os::Portable
112{
113public:
115 bool write(yarp::os::ConnectionWriter& connection) const override;
116 bool read(yarp::os::ConnectionReader& connection) override;
117
118 class Command :
120 {
121 public:
122 Command() = default;
123 ~Command() override = default;
124
125 bool write(yarp::os::ConnectionWriter& connection) const override;
126 bool read(yarp::os::ConnectionReader& connection) override;
127
128 bool write(const yarp::os::idl::WireWriter& writer) const override;
129 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
130 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
131
132 bool read(yarp::os::idl::WireReader& reader) override;
135 };
136
137 class Reply :
139 {
140 public:
141 Reply() = default;
142 ~Reply() override = default;
143
144 bool write(yarp::os::ConnectionWriter& connection) const override;
145 bool read(yarp::os::ConnectionReader& connection) override;
146
147 bool write(const yarp::os::idl::WireWriter& writer) const override;
148 bool read(yarp::os::idl::WireReader& reader) override;
149
151 };
152
154 void call(RGBDSensorMsgs* ptr);
155
158
159 static constexpr const char* s_tag{"getExtrinsicParamRPC"};
160 static constexpr size_t s_tag_len{1};
161 static constexpr size_t s_cmd_len{1};
162 static constexpr size_t s_reply_len{2};
163 static constexpr const char* s_prototype{"IRGBDMsgs_return_getExtrinsic RGBDSensorMsgs::getExtrinsicParamRPC()"};
164 static constexpr const char* s_help{""};
165};
166
167// getLastErrorMsgRPC helper class declaration
169 public yarp::os::Portable
170{
171public:
173 bool write(yarp::os::ConnectionWriter& connection) const override;
174 bool read(yarp::os::ConnectionReader& connection) override;
175
176 class Command :
178 {
179 public:
180 Command() = default;
181 ~Command() override = default;
182
183 bool write(yarp::os::ConnectionWriter& connection) const override;
184 bool read(yarp::os::ConnectionReader& connection) override;
185
186 bool write(const yarp::os::idl::WireWriter& writer) const override;
187 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
188 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
189
190 bool read(yarp::os::idl::WireReader& reader) override;
193 };
194
195 class Reply :
197 {
198 public:
199 Reply() = default;
200 ~Reply() override = default;
201
202 bool write(yarp::os::ConnectionWriter& connection) const override;
203 bool read(yarp::os::ConnectionReader& connection) override;
204
205 bool write(const yarp::os::idl::WireWriter& writer) const override;
206 bool read(yarp::os::idl::WireReader& reader) override;
207
209 };
210
212 void call(RGBDSensorMsgs* ptr);
213
216
217 static constexpr const char* s_tag{"getLastErrorMsgRPC"};
218 static constexpr size_t s_tag_len{1};
219 static constexpr size_t s_cmd_len{1};
220 static constexpr size_t s_reply_len{3};
221 static constexpr const char* s_prototype{"IRGBDMsgs_return_getLastErrorMsg RGBDSensorMsgs::getLastErrorMsgRPC()"};
222 static constexpr const char* s_help{""};
223};
224
225// getRgbImageRPC helper class declaration
227 public yarp::os::Portable
228{
229public:
231 bool write(yarp::os::ConnectionWriter& connection) const override;
232 bool read(yarp::os::ConnectionReader& connection) override;
233
234 class Command :
236 {
237 public:
238 Command() = default;
239 ~Command() override = default;
240
241 bool write(yarp::os::ConnectionWriter& connection) const override;
242 bool read(yarp::os::ConnectionReader& connection) override;
243
244 bool write(const yarp::os::idl::WireWriter& writer) const override;
245 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
246 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
247
248 bool read(yarp::os::idl::WireReader& reader) override;
251 };
252
253 class Reply :
255 {
256 public:
257 Reply() = default;
258 ~Reply() override = default;
259
260 bool write(yarp::os::ConnectionWriter& connection) const override;
261 bool read(yarp::os::ConnectionReader& connection) override;
262
263 bool write(const yarp::os::idl::WireWriter& writer) const override;
264 bool read(yarp::os::idl::WireReader& reader) override;
265
267 };
268
270 void call(RGBDSensorMsgs* ptr);
271
274
275 static constexpr const char* s_tag{"getRgbImageRPC"};
276 static constexpr size_t s_tag_len{1};
277 static constexpr size_t s_cmd_len{1};
278 static constexpr size_t s_reply_len{3};
279 static constexpr const char* s_prototype{"IRGBDMsgs_return_getRgbImage RGBDSensorMsgs::getRgbImageRPC()"};
280 static constexpr const char* s_help{""};
281};
282
283// getDepthImageRPC helper class declaration
285 public yarp::os::Portable
286{
287public:
289 bool write(yarp::os::ConnectionWriter& connection) const override;
290 bool read(yarp::os::ConnectionReader& connection) override;
291
292 class Command :
294 {
295 public:
296 Command() = default;
297 ~Command() override = default;
298
299 bool write(yarp::os::ConnectionWriter& connection) const override;
300 bool read(yarp::os::ConnectionReader& connection) override;
301
302 bool write(const yarp::os::idl::WireWriter& writer) const override;
303 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
304 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
305
306 bool read(yarp::os::idl::WireReader& reader) override;
309 };
310
311 class Reply :
313 {
314 public:
315 Reply() = default;
316 ~Reply() override = default;
317
318 bool write(yarp::os::ConnectionWriter& connection) const override;
319 bool read(yarp::os::ConnectionReader& connection) override;
320
321 bool write(const yarp::os::idl::WireWriter& writer) const override;
322 bool read(yarp::os::idl::WireReader& reader) override;
323
325 };
326
328 void call(RGBDSensorMsgs* ptr);
329
332
333 static constexpr const char* s_tag{"getDepthImageRPC"};
334 static constexpr size_t s_tag_len{1};
335 static constexpr size_t s_cmd_len{1};
336 static constexpr size_t s_reply_len{3};
337 static constexpr const char* s_prototype{"IRGBDMsgs_return_getDepthImage RGBDSensorMsgs::getDepthImageRPC()"};
338 static constexpr const char* s_help{""};
339};
340
341// getImagesRPC helper class declaration
343 public yarp::os::Portable
344{
345public:
347 bool write(yarp::os::ConnectionWriter& connection) const override;
348 bool read(yarp::os::ConnectionReader& connection) override;
349
350 class Command :
352 {
353 public:
354 Command() = default;
355 ~Command() override = default;
356
357 bool write(yarp::os::ConnectionWriter& connection) const override;
358 bool read(yarp::os::ConnectionReader& connection) override;
359
360 bool write(const yarp::os::idl::WireWriter& writer) const override;
361 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
362 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
363
364 bool read(yarp::os::idl::WireReader& reader) override;
367 };
368
369 class Reply :
371 {
372 public:
373 Reply() = default;
374 ~Reply() override = default;
375
376 bool write(yarp::os::ConnectionWriter& connection) const override;
377 bool read(yarp::os::ConnectionReader& connection) override;
378
379 bool write(const yarp::os::idl::WireWriter& writer) const override;
380 bool read(yarp::os::idl::WireReader& reader) override;
381
383 };
384
386 void call(RGBDSensorMsgs* ptr);
387
390
391 static constexpr const char* s_tag{"getImagesRPC"};
392 static constexpr size_t s_tag_len{1};
393 static constexpr size_t s_cmd_len{1};
394 static constexpr size_t s_reply_len{5};
395 static constexpr const char* s_prototype{"IRGBDMsgs_return_getImages RGBDSensorMsgs::getImagesRPC()"};
396 static constexpr const char* s_help{""};
397};
398
399// getSensorStatusRPC helper class declaration
401 public yarp::os::Portable
402{
403public:
405 bool write(yarp::os::ConnectionWriter& connection) const override;
406 bool read(yarp::os::ConnectionReader& connection) override;
407
408 class Command :
410 {
411 public:
412 Command() = default;
413 ~Command() override = default;
414
415 bool write(yarp::os::ConnectionWriter& connection) const override;
416 bool read(yarp::os::ConnectionReader& connection) override;
417
418 bool write(const yarp::os::idl::WireWriter& writer) const override;
419 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
420 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
421
422 bool read(yarp::os::idl::WireReader& reader) override;
425 };
426
427 class Reply :
429 {
430 public:
431 Reply() = default;
432 ~Reply() override = default;
433
434 bool write(yarp::os::ConnectionWriter& connection) const override;
435 bool read(yarp::os::ConnectionReader& connection) override;
436
437 bool write(const yarp::os::idl::WireWriter& writer) const override;
438 bool read(yarp::os::idl::WireReader& reader) override;
439
441 };
442
444 void call(RGBDSensorMsgs* ptr);
445
448
449 static constexpr const char* s_tag{"getSensorStatusRPC"};
450 static constexpr size_t s_tag_len{1};
451 static constexpr size_t s_cmd_len{1};
452 static constexpr size_t s_reply_len{2};
453 static constexpr const char* s_prototype{"IRGBDMsgs_return_getSensorStatus RGBDSensorMsgs::getSensorStatusRPC()"};
454 static constexpr const char* s_help{""};
455};
456
457// getRgbWidthRPC helper class declaration
459 public yarp::os::Portable
460{
461public:
463 bool write(yarp::os::ConnectionWriter& connection) const override;
464 bool read(yarp::os::ConnectionReader& connection) override;
465
466 class Command :
468 {
469 public:
470 Command() = default;
471 ~Command() override = default;
472
473 bool write(yarp::os::ConnectionWriter& connection) const override;
474 bool read(yarp::os::ConnectionReader& connection) override;
475
476 bool write(const yarp::os::idl::WireWriter& writer) const override;
477 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
478 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
479
480 bool read(yarp::os::idl::WireReader& reader) override;
483 };
484
485 class Reply :
487 {
488 public:
489 Reply() = default;
490 ~Reply() override = default;
491
492 bool write(yarp::os::ConnectionWriter& connection) const override;
493 bool read(yarp::os::ConnectionReader& connection) override;
494
495 bool write(const yarp::os::idl::WireWriter& writer) const override;
496 bool read(yarp::os::idl::WireReader& reader) override;
497
499 };
500
502 void call(RGBDSensorMsgs* ptr);
503
506
507 static constexpr const char* s_tag{"getRgbWidthRPC"};
508 static constexpr size_t s_tag_len{1};
509 static constexpr size_t s_cmd_len{1};
510 static constexpr size_t s_reply_len{2};
511 static constexpr const char* s_prototype{"IRGBVisualParamsMsgs_return_getRgbWidth RGBDSensorMsgs::getRgbWidthRPC()"};
512 static constexpr const char* s_help{""};
513};
514
515// getRgbHeightRPC helper class declaration
517 public yarp::os::Portable
518{
519public:
521 bool write(yarp::os::ConnectionWriter& connection) const override;
522 bool read(yarp::os::ConnectionReader& connection) override;
523
524 class Command :
526 {
527 public:
528 Command() = default;
529 ~Command() override = default;
530
531 bool write(yarp::os::ConnectionWriter& connection) const override;
532 bool read(yarp::os::ConnectionReader& connection) override;
533
534 bool write(const yarp::os::idl::WireWriter& writer) const override;
535 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
536 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
537
538 bool read(yarp::os::idl::WireReader& reader) override;
541 };
542
543 class Reply :
545 {
546 public:
547 Reply() = default;
548 ~Reply() override = default;
549
550 bool write(yarp::os::ConnectionWriter& connection) const override;
551 bool read(yarp::os::ConnectionReader& connection) override;
552
553 bool write(const yarp::os::idl::WireWriter& writer) const override;
554 bool read(yarp::os::idl::WireReader& reader) override;
555
557 };
558
560 void call(RGBDSensorMsgs* ptr);
561
564
565 static constexpr const char* s_tag{"getRgbHeightRPC"};
566 static constexpr size_t s_tag_len{1};
567 static constexpr size_t s_cmd_len{1};
568 static constexpr size_t s_reply_len{2};
569 static constexpr const char* s_prototype{"IRGBVisualParamsMsgs_return_getRgbHeight RGBDSensorMsgs::getRgbHeightRPC()"};
570 static constexpr const char* s_help{""};
571};
572
573// getRgbSupportedConfigurationsRPC helper class declaration
575 public yarp::os::Portable
576{
577public:
579 bool write(yarp::os::ConnectionWriter& connection) const override;
580 bool read(yarp::os::ConnectionReader& connection) override;
581
582 class Command :
584 {
585 public:
586 Command() = default;
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
601 class Reply :
603 {
604 public:
605 Reply() = default;
606 ~Reply() override = default;
607
608 bool write(yarp::os::ConnectionWriter& connection) const override;
609 bool read(yarp::os::ConnectionReader& connection) override;
610
611 bool write(const yarp::os::idl::WireWriter& writer) const override;
612 bool read(yarp::os::idl::WireReader& reader) override;
613
615 };
616
618 void call(RGBDSensorMsgs* ptr);
619
622
623 static constexpr const char* s_tag{"getRgbSupportedConfigurationsRPC"};
624 static constexpr size_t s_tag_len{1};
625 static constexpr size_t s_cmd_len{1};
626 static constexpr size_t s_reply_len{2};
627 static constexpr const char* s_prototype{"IRGBVisualParamsMsgs_return_getRgbSupportedCfg RGBDSensorMsgs::getRgbSupportedConfigurationsRPC()"};
628 static constexpr const char* s_help{""};
629};
630
631// getRgbResolutionRPC helper class declaration
633 public yarp::os::Portable
634{
635public:
637 bool write(yarp::os::ConnectionWriter& connection) const override;
638 bool read(yarp::os::ConnectionReader& connection) override;
639
640 class Command :
642 {
643 public:
644 Command() = default;
645 ~Command() override = default;
646
647 bool write(yarp::os::ConnectionWriter& connection) const override;
648 bool read(yarp::os::ConnectionReader& connection) override;
649
650 bool write(const yarp::os::idl::WireWriter& writer) const override;
651 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
652 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
653
654 bool read(yarp::os::idl::WireReader& reader) override;
657 };
658
659 class Reply :
661 {
662 public:
663 Reply() = default;
664 ~Reply() override = default;
665
666 bool write(yarp::os::ConnectionWriter& connection) const override;
667 bool read(yarp::os::ConnectionReader& connection) override;
668
669 bool write(const yarp::os::idl::WireWriter& writer) const override;
670 bool read(yarp::os::idl::WireReader& reader) override;
671
673 };
674
676 void call(RGBDSensorMsgs* ptr);
677
680
681 static constexpr const char* s_tag{"getRgbResolutionRPC"};
682 static constexpr size_t s_tag_len{1};
683 static constexpr size_t s_cmd_len{1};
684 static constexpr size_t s_reply_len{3};
685 static constexpr const char* s_prototype{"IRGBVisualParamsMsgs_return_getRgbResolution RGBDSensorMsgs::getRgbResolutionRPC()"};
686 static constexpr const char* s_help{""};
687};
688
689// setRgbResolutionRPC helper class declaration
691 public yarp::os::Portable
692{
693public:
695 RGBDSensorMsgs_setRgbResolutionRPC_helper(const std::int32_t width, const std::int32_t height);
696 bool write(yarp::os::ConnectionWriter& connection) const override;
697 bool read(yarp::os::ConnectionReader& connection) override;
698
699 class Command :
701 {
702 public:
703 Command() = default;
704 Command(const std::int32_t width, const std::int32_t height);
705
706 ~Command() override = default;
707
708 bool write(yarp::os::ConnectionWriter& connection) const override;
709 bool read(yarp::os::ConnectionReader& connection) override;
710
711 bool write(const yarp::os::idl::WireWriter& writer) const override;
712 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
713 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
714
715 bool read(yarp::os::idl::WireReader& reader) override;
718
719 std::int32_t width{0};
720 std::int32_t height{0};
721 };
722
723 class Reply :
725 {
726 public:
727 Reply() = default;
728 ~Reply() override = default;
729
730 bool write(yarp::os::ConnectionWriter& connection) const override;
731 bool read(yarp::os::ConnectionReader& connection) override;
732
733 bool write(const yarp::os::idl::WireWriter& writer) const override;
734 bool read(yarp::os::idl::WireReader& reader) override;
735
737 };
738
739 using funcptr_t = yarp::dev::ReturnValue (*)(const std::int32_t, const std::int32_t);
740 void call(RGBDSensorMsgs* ptr);
741
744
745 static constexpr const char* s_tag{"setRgbResolutionRPC"};
746 static constexpr size_t s_tag_len{1};
747 static constexpr size_t s_cmd_len{3};
748 static constexpr size_t s_reply_len{1};
749 static constexpr const char* s_prototype{"yarp::dev::ReturnValue RGBDSensorMsgs::setRgbResolutionRPC(const std::int32_t width, const std::int32_t height)"};
750 static constexpr const char* s_help{""};
751};
752
753// getRgbFOVRPC helper class declaration
755 public yarp::os::Portable
756{
757public:
759 bool write(yarp::os::ConnectionWriter& connection) const override;
760 bool read(yarp::os::ConnectionReader& connection) override;
761
762 class Command :
764 {
765 public:
766 Command() = default;
767 ~Command() override = default;
768
769 bool write(yarp::os::ConnectionWriter& connection) const override;
770 bool read(yarp::os::ConnectionReader& connection) override;
771
772 bool write(const yarp::os::idl::WireWriter& writer) const override;
773 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
774 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
775
776 bool read(yarp::os::idl::WireReader& reader) override;
779 };
780
781 class Reply :
783 {
784 public:
785 Reply() = default;
786 ~Reply() override = default;
787
788 bool write(yarp::os::ConnectionWriter& connection) const override;
789 bool read(yarp::os::ConnectionReader& connection) override;
790
791 bool write(const yarp::os::idl::WireWriter& writer) const override;
792 bool read(yarp::os::idl::WireReader& reader) override;
793
795 };
796
798 void call(RGBDSensorMsgs* ptr);
799
802
803 static constexpr const char* s_tag{"getRgbFOVRPC"};
804 static constexpr size_t s_tag_len{1};
805 static constexpr size_t s_cmd_len{1};
806 static constexpr size_t s_reply_len{3};
807 static constexpr const char* s_prototype{"IRGBVisualParamsMsgs_return_getRgbFOV RGBDSensorMsgs::getRgbFOVRPC()"};
808 static constexpr const char* s_help{""};
809};
810
811// setRgbFOVRPC helper class declaration
813 public yarp::os::Portable
814{
815public:
817 RGBDSensorMsgs_setRgbFOVRPC_helper(const double horizontalFov, const double verticalFov);
818 bool write(yarp::os::ConnectionWriter& connection) const override;
819 bool read(yarp::os::ConnectionReader& connection) override;
820
821 class Command :
823 {
824 public:
825 Command() = default;
826 Command(const double horizontalFov, const double verticalFov);
827
828 ~Command() override = default;
829
830 bool write(yarp::os::ConnectionWriter& connection) const override;
831 bool read(yarp::os::ConnectionReader& connection) override;
832
833 bool write(const yarp::os::idl::WireWriter& writer) const override;
834 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
835 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
836
837 bool read(yarp::os::idl::WireReader& reader) override;
840
841 double horizontalFov{0.0};
842 double verticalFov{0.0};
843 };
844
845 class Reply :
847 {
848 public:
849 Reply() = default;
850 ~Reply() override = default;
851
852 bool write(yarp::os::ConnectionWriter& connection) const override;
853 bool read(yarp::os::ConnectionReader& connection) override;
854
855 bool write(const yarp::os::idl::WireWriter& writer) const override;
856 bool read(yarp::os::idl::WireReader& reader) override;
857
859 };
860
861 using funcptr_t = yarp::dev::ReturnValue (*)(const double, const double);
862 void call(RGBDSensorMsgs* ptr);
863
866
867 static constexpr const char* s_tag{"setRgbFOVRPC"};
868 static constexpr size_t s_tag_len{1};
869 static constexpr size_t s_cmd_len{3};
870 static constexpr size_t s_reply_len{1};
871 static constexpr const char* s_prototype{"yarp::dev::ReturnValue RGBDSensorMsgs::setRgbFOVRPC(const double horizontalFov, const double verticalFov)"};
872 static constexpr const char* s_help{""};
873};
874
875// getRgbIntrinsicParamRPC helper class declaration
877 public yarp::os::Portable
878{
879public:
881 bool write(yarp::os::ConnectionWriter& connection) const override;
882 bool read(yarp::os::ConnectionReader& connection) override;
883
884 class Command :
886 {
887 public:
888 Command() = default;
889 ~Command() override = default;
890
891 bool write(yarp::os::ConnectionWriter& connection) const override;
892 bool read(yarp::os::ConnectionReader& connection) override;
893
894 bool write(const yarp::os::idl::WireWriter& writer) const override;
895 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
896 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
897
898 bool read(yarp::os::idl::WireReader& reader) override;
901 };
902
903 class Reply :
905 {
906 public:
907 Reply() = default;
908 ~Reply() override = default;
909
910 bool write(yarp::os::ConnectionWriter& connection) const override;
911 bool read(yarp::os::ConnectionReader& connection) override;
912
913 bool write(const yarp::os::idl::WireWriter& writer) const override;
914 bool read(yarp::os::idl::WireReader& reader) override;
915
917 };
918
920 void call(RGBDSensorMsgs* ptr);
921
924
925 static constexpr const char* s_tag{"getRgbIntrinsicParamRPC"};
926 static constexpr size_t s_tag_len{1};
927 static constexpr size_t s_cmd_len{1};
928 static constexpr size_t s_reply_len{2};
929 static constexpr const char* s_prototype{"IRGBVisualParamsMsgs_return_getRgbIntrinsicParam RGBDSensorMsgs::getRgbIntrinsicParamRPC()"};
930 static constexpr const char* s_help{""};
931};
932
933// getRgbMirroringRPC helper class declaration
935 public yarp::os::Portable
936{
937public:
939 bool write(yarp::os::ConnectionWriter& connection) const override;
940 bool read(yarp::os::ConnectionReader& connection) override;
941
942 class Command :
944 {
945 public:
946 Command() = default;
947 ~Command() override = default;
948
949 bool write(yarp::os::ConnectionWriter& connection) const override;
950 bool read(yarp::os::ConnectionReader& connection) override;
951
952 bool write(const yarp::os::idl::WireWriter& writer) const override;
953 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
954 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
955
956 bool read(yarp::os::idl::WireReader& reader) override;
959 };
960
961 class Reply :
963 {
964 public:
965 Reply() = default;
966 ~Reply() override = default;
967
968 bool write(yarp::os::ConnectionWriter& connection) const override;
969 bool read(yarp::os::ConnectionReader& connection) override;
970
971 bool write(const yarp::os::idl::WireWriter& writer) const override;
972 bool read(yarp::os::idl::WireReader& reader) override;
973
975 };
976
978 void call(RGBDSensorMsgs* ptr);
979
982
983 static constexpr const char* s_tag{"getRgbMirroringRPC"};
984 static constexpr size_t s_tag_len{1};
985 static constexpr size_t s_cmd_len{1};
986 static constexpr size_t s_reply_len{2};
987 static constexpr const char* s_prototype{"IRGBVisualParamsMsgs_return_getRgbMirroring RGBDSensorMsgs::getRgbMirroringRPC()"};
988 static constexpr const char* s_help{""};
989};
990
991// setRgbMirroringRPC helper class declaration
993 public yarp::os::Portable
994{
995public:
997 explicit RGBDSensorMsgs_setRgbMirroringRPC_helper(const bool mirror);
998 bool write(yarp::os::ConnectionWriter& connection) const override;
999 bool read(yarp::os::ConnectionReader& connection) override;
1000
1001 class Command :
1003 {
1004 public:
1005 Command() = default;
1006 explicit Command(const bool mirror);
1007
1008 ~Command() override = default;
1009
1010 bool write(yarp::os::ConnectionWriter& connection) const override;
1011 bool read(yarp::os::ConnectionReader& connection) override;
1012
1013 bool write(const yarp::os::idl::WireWriter& writer) const override;
1014 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1015 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1016
1017 bool read(yarp::os::idl::WireReader& reader) override;
1018 bool readTag(yarp::os::idl::WireReader& reader);
1019 bool readArgs(yarp::os::idl::WireReader& reader);
1020
1021 bool mirror{false};
1022 };
1023
1024 class Reply :
1026 {
1027 public:
1028 Reply() = default;
1029 ~Reply() override = default;
1030
1031 bool write(yarp::os::ConnectionWriter& connection) const override;
1032 bool read(yarp::os::ConnectionReader& connection) override;
1033
1034 bool write(const yarp::os::idl::WireWriter& writer) const override;
1035 bool read(yarp::os::idl::WireReader& reader) override;
1036
1038 };
1039
1040 using funcptr_t = yarp::dev::ReturnValue (*)(const bool);
1041 void call(RGBDSensorMsgs* ptr);
1042
1045
1046 static constexpr const char* s_tag{"setRgbMirroringRPC"};
1047 static constexpr size_t s_tag_len{1};
1048 static constexpr size_t s_cmd_len{2};
1049 static constexpr size_t s_reply_len{1};
1050 static constexpr const char* s_prototype{"yarp::dev::ReturnValue RGBDSensorMsgs::setRgbMirroringRPC(const bool mirror)"};
1051 static constexpr const char* s_help{""};
1052};
1053
1054// getDepthWidthRPC helper class declaration
1056 public yarp::os::Portable
1057{
1058public:
1060 bool write(yarp::os::ConnectionWriter& connection) const override;
1061 bool read(yarp::os::ConnectionReader& connection) override;
1062
1063 class Command :
1065 {
1066 public:
1067 Command() = default;
1068 ~Command() override = default;
1069
1070 bool write(yarp::os::ConnectionWriter& connection) const override;
1071 bool read(yarp::os::ConnectionReader& connection) override;
1072
1073 bool write(const yarp::os::idl::WireWriter& writer) const override;
1074 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1075 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1076
1077 bool read(yarp::os::idl::WireReader& reader) override;
1078 bool readTag(yarp::os::idl::WireReader& reader);
1079 bool readArgs(yarp::os::idl::WireReader& reader);
1080 };
1081
1082 class Reply :
1084 {
1085 public:
1086 Reply() = default;
1087 ~Reply() override = default;
1088
1089 bool write(yarp::os::ConnectionWriter& connection) const override;
1090 bool read(yarp::os::ConnectionReader& connection) override;
1091
1092 bool write(const yarp::os::idl::WireWriter& writer) const override;
1093 bool read(yarp::os::idl::WireReader& reader) override;
1094
1096 };
1097
1099 void call(RGBDSensorMsgs* ptr);
1100
1103
1104 static constexpr const char* s_tag{"getDepthWidthRPC"};
1105 static constexpr size_t s_tag_len{1};
1106 static constexpr size_t s_cmd_len{1};
1107 static constexpr size_t s_reply_len{2};
1108 static constexpr const char* s_prototype{"IDepthVisualParamsMsgs_return_getDepthWidth RGBDSensorMsgs::getDepthWidthRPC()"};
1109 static constexpr const char* s_help{""};
1110};
1111
1112// getDepthHeightRPC helper class declaration
1114 public yarp::os::Portable
1115{
1116public:
1118 bool write(yarp::os::ConnectionWriter& connection) const override;
1119 bool read(yarp::os::ConnectionReader& connection) override;
1120
1121 class Command :
1123 {
1124 public:
1125 Command() = default;
1126 ~Command() override = default;
1127
1128 bool write(yarp::os::ConnectionWriter& connection) const override;
1129 bool read(yarp::os::ConnectionReader& connection) override;
1130
1131 bool write(const yarp::os::idl::WireWriter& writer) const override;
1132 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1133 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1134
1135 bool read(yarp::os::idl::WireReader& reader) override;
1136 bool readTag(yarp::os::idl::WireReader& reader);
1137 bool readArgs(yarp::os::idl::WireReader& reader);
1138 };
1139
1140 class Reply :
1142 {
1143 public:
1144 Reply() = default;
1145 ~Reply() override = default;
1146
1147 bool write(yarp::os::ConnectionWriter& connection) const override;
1148 bool read(yarp::os::ConnectionReader& connection) override;
1149
1150 bool write(const yarp::os::idl::WireWriter& writer) const override;
1151 bool read(yarp::os::idl::WireReader& reader) override;
1152
1154 };
1155
1157 void call(RGBDSensorMsgs* ptr);
1158
1161
1162 static constexpr const char* s_tag{"getDepthHeightRPC"};
1163 static constexpr size_t s_tag_len{1};
1164 static constexpr size_t s_cmd_len{1};
1165 static constexpr size_t s_reply_len{2};
1166 static constexpr const char* s_prototype{"IDepthVisualParamsMsgs_return_getDepthHeight RGBDSensorMsgs::getDepthHeightRPC()"};
1167 static constexpr const char* s_help{""};
1168};
1169
1170// getDepthResolutionRPC helper class declaration
1172 public yarp::os::Portable
1173{
1174public:
1176 bool write(yarp::os::ConnectionWriter& connection) const override;
1177 bool read(yarp::os::ConnectionReader& connection) override;
1178
1179 class Command :
1181 {
1182 public:
1183 Command() = default;
1184 ~Command() override = default;
1185
1186 bool write(yarp::os::ConnectionWriter& connection) const override;
1187 bool read(yarp::os::ConnectionReader& connection) override;
1188
1189 bool write(const yarp::os::idl::WireWriter& writer) const override;
1190 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1191 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1192
1193 bool read(yarp::os::idl::WireReader& reader) override;
1194 bool readTag(yarp::os::idl::WireReader& reader);
1195 bool readArgs(yarp::os::idl::WireReader& reader);
1196 };
1197
1198 class Reply :
1200 {
1201 public:
1202 Reply() = default;
1203 ~Reply() override = default;
1204
1205 bool write(yarp::os::ConnectionWriter& connection) const override;
1206 bool read(yarp::os::ConnectionReader& connection) override;
1207
1208 bool write(const yarp::os::idl::WireWriter& writer) const override;
1209 bool read(yarp::os::idl::WireReader& reader) override;
1210
1212 };
1213
1215 void call(RGBDSensorMsgs* ptr);
1216
1219
1220 static constexpr const char* s_tag{"getDepthResolutionRPC"};
1221 static constexpr size_t s_tag_len{1};
1222 static constexpr size_t s_cmd_len{1};
1223 static constexpr size_t s_reply_len{3};
1224 static constexpr const char* s_prototype{"IDepthVisualParamsMsgs_return_getDepthResolution RGBDSensorMsgs::getDepthResolutionRPC()"};
1225 static constexpr const char* s_help{""};
1226};
1227
1228// setDepthResolutionRPC helper class declaration
1230 public yarp::os::Portable
1231{
1232public:
1234 RGBDSensorMsgs_setDepthResolutionRPC_helper(const std::int32_t width, const std::int32_t height);
1235 bool write(yarp::os::ConnectionWriter& connection) const override;
1236 bool read(yarp::os::ConnectionReader& connection) override;
1237
1238 class Command :
1240 {
1241 public:
1242 Command() = default;
1243 Command(const std::int32_t width, const std::int32_t height);
1244
1245 ~Command() override = default;
1246
1247 bool write(yarp::os::ConnectionWriter& connection) const override;
1248 bool read(yarp::os::ConnectionReader& connection) override;
1249
1250 bool write(const yarp::os::idl::WireWriter& writer) const override;
1251 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1252 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1253
1254 bool read(yarp::os::idl::WireReader& reader) override;
1255 bool readTag(yarp::os::idl::WireReader& reader);
1256 bool readArgs(yarp::os::idl::WireReader& reader);
1257
1258 std::int32_t width{0};
1259 std::int32_t height{0};
1260 };
1261
1262 class Reply :
1264 {
1265 public:
1266 Reply() = default;
1267 ~Reply() override = default;
1268
1269 bool write(yarp::os::ConnectionWriter& connection) const override;
1270 bool read(yarp::os::ConnectionReader& connection) override;
1271
1272 bool write(const yarp::os::idl::WireWriter& writer) const override;
1273 bool read(yarp::os::idl::WireReader& reader) override;
1274
1276 };
1277
1278 using funcptr_t = yarp::dev::ReturnValue (*)(const std::int32_t, const std::int32_t);
1279 void call(RGBDSensorMsgs* ptr);
1280
1283
1284 static constexpr const char* s_tag{"setDepthResolutionRPC"};
1285 static constexpr size_t s_tag_len{1};
1286 static constexpr size_t s_cmd_len{3};
1287 static constexpr size_t s_reply_len{1};
1288 static constexpr const char* s_prototype{"yarp::dev::ReturnValue RGBDSensorMsgs::setDepthResolutionRPC(const std::int32_t width, const std::int32_t height)"};
1289 static constexpr const char* s_help{""};
1290};
1291
1292// getDepthFOVRPC helper class declaration
1294 public yarp::os::Portable
1295{
1296public:
1298 bool write(yarp::os::ConnectionWriter& connection) const override;
1299 bool read(yarp::os::ConnectionReader& connection) override;
1300
1301 class Command :
1303 {
1304 public:
1305 Command() = default;
1306 ~Command() override = default;
1307
1308 bool write(yarp::os::ConnectionWriter& connection) const override;
1309 bool read(yarp::os::ConnectionReader& connection) override;
1310
1311 bool write(const yarp::os::idl::WireWriter& writer) const override;
1312 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1313 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1314
1315 bool read(yarp::os::idl::WireReader& reader) override;
1316 bool readTag(yarp::os::idl::WireReader& reader);
1317 bool readArgs(yarp::os::idl::WireReader& reader);
1318 };
1319
1320 class Reply :
1322 {
1323 public:
1324 Reply() = default;
1325 ~Reply() override = default;
1326
1327 bool write(yarp::os::ConnectionWriter& connection) const override;
1328 bool read(yarp::os::ConnectionReader& connection) override;
1329
1330 bool write(const yarp::os::idl::WireWriter& writer) const override;
1331 bool read(yarp::os::idl::WireReader& reader) override;
1332
1334 };
1335
1337 void call(RGBDSensorMsgs* ptr);
1338
1341
1342 static constexpr const char* s_tag{"getDepthFOVRPC"};
1343 static constexpr size_t s_tag_len{1};
1344 static constexpr size_t s_cmd_len{1};
1345 static constexpr size_t s_reply_len{3};
1346 static constexpr const char* s_prototype{"IDepthVisualParamsMsgs_return_getDepthFOV RGBDSensorMsgs::getDepthFOVRPC()"};
1347 static constexpr const char* s_help{""};
1348};
1349
1350// setDepthFOVRPC helper class declaration
1352 public yarp::os::Portable
1353{
1354public:
1356 RGBDSensorMsgs_setDepthFOVRPC_helper(const double horizontalFov, const double verticalFov);
1357 bool write(yarp::os::ConnectionWriter& connection) const override;
1358 bool read(yarp::os::ConnectionReader& connection) override;
1359
1360 class Command :
1362 {
1363 public:
1364 Command() = default;
1365 Command(const double horizontalFov, const double verticalFov);
1366
1367 ~Command() override = default;
1368
1369 bool write(yarp::os::ConnectionWriter& connection) const override;
1370 bool read(yarp::os::ConnectionReader& connection) override;
1371
1372 bool write(const yarp::os::idl::WireWriter& writer) const override;
1373 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1374 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1375
1376 bool read(yarp::os::idl::WireReader& reader) override;
1377 bool readTag(yarp::os::idl::WireReader& reader);
1378 bool readArgs(yarp::os::idl::WireReader& reader);
1379
1380 double horizontalFov{0.0};
1381 double verticalFov{0.0};
1382 };
1383
1384 class Reply :
1386 {
1387 public:
1388 Reply() = default;
1389 ~Reply() override = default;
1390
1391 bool write(yarp::os::ConnectionWriter& connection) const override;
1392 bool read(yarp::os::ConnectionReader& connection) override;
1393
1394 bool write(const yarp::os::idl::WireWriter& writer) const override;
1395 bool read(yarp::os::idl::WireReader& reader) override;
1396
1398 };
1399
1400 using funcptr_t = yarp::dev::ReturnValue (*)(const double, const double);
1401 void call(RGBDSensorMsgs* ptr);
1402
1405
1406 static constexpr const char* s_tag{"setDepthFOVRPC"};
1407 static constexpr size_t s_tag_len{1};
1408 static constexpr size_t s_cmd_len{3};
1409 static constexpr size_t s_reply_len{1};
1410 static constexpr const char* s_prototype{"yarp::dev::ReturnValue RGBDSensorMsgs::setDepthFOVRPC(const double horizontalFov, const double verticalFov)"};
1411 static constexpr const char* s_help{""};
1412};
1413
1414// getDepthAccuracyRPC helper class declaration
1416 public yarp::os::Portable
1417{
1418public:
1420 bool write(yarp::os::ConnectionWriter& connection) const override;
1421 bool read(yarp::os::ConnectionReader& connection) override;
1422
1423 class Command :
1425 {
1426 public:
1427 Command() = default;
1428 ~Command() override = default;
1429
1430 bool write(yarp::os::ConnectionWriter& connection) const override;
1431 bool read(yarp::os::ConnectionReader& connection) override;
1432
1433 bool write(const yarp::os::idl::WireWriter& writer) const override;
1434 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1435 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1436
1437 bool read(yarp::os::idl::WireReader& reader) override;
1438 bool readTag(yarp::os::idl::WireReader& reader);
1439 bool readArgs(yarp::os::idl::WireReader& reader);
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
1459 void call(RGBDSensorMsgs* ptr);
1460
1463
1464 static constexpr const char* s_tag{"getDepthAccuracyRPC"};
1465 static constexpr size_t s_tag_len{1};
1466 static constexpr size_t s_cmd_len{1};
1467 static constexpr size_t s_reply_len{2};
1468 static constexpr const char* s_prototype{"IDepthVisualParamsMsgs_return_getDepthAccuracy RGBDSensorMsgs::getDepthAccuracyRPC()"};
1469 static constexpr const char* s_help{""};
1470};
1471
1472// setDepthAccuracyRPC helper class declaration
1474 public yarp::os::Portable
1475{
1476public:
1479 bool write(yarp::os::ConnectionWriter& connection) const override;
1480 bool read(yarp::os::ConnectionReader& connection) override;
1481
1482 class Command :
1484 {
1485 public:
1486 Command() = default;
1487 explicit Command(const double accuracy);
1488
1489 ~Command() override = default;
1490
1491 bool write(yarp::os::ConnectionWriter& connection) const override;
1492 bool read(yarp::os::ConnectionReader& connection) override;
1493
1494 bool write(const yarp::os::idl::WireWriter& writer) const override;
1495 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1496 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1497
1498 bool read(yarp::os::idl::WireReader& reader) override;
1499 bool readTag(yarp::os::idl::WireReader& reader);
1500 bool readArgs(yarp::os::idl::WireReader& reader);
1501
1502 double accuracy{0.0};
1503 };
1504
1505 class Reply :
1507 {
1508 public:
1509 Reply() = default;
1510 ~Reply() override = default;
1511
1512 bool write(yarp::os::ConnectionWriter& connection) const override;
1513 bool read(yarp::os::ConnectionReader& connection) override;
1514
1515 bool write(const yarp::os::idl::WireWriter& writer) const override;
1516 bool read(yarp::os::idl::WireReader& reader) override;
1517
1519 };
1520
1521 using funcptr_t = yarp::dev::ReturnValue (*)(const double);
1522 void call(RGBDSensorMsgs* ptr);
1523
1526
1527 static constexpr const char* s_tag{"setDepthAccuracyRPC"};
1528 static constexpr size_t s_tag_len{1};
1529 static constexpr size_t s_cmd_len{2};
1530 static constexpr size_t s_reply_len{1};
1531 static constexpr const char* s_prototype{"yarp::dev::ReturnValue RGBDSensorMsgs::setDepthAccuracyRPC(const double accuracy)"};
1532 static constexpr const char* s_help{""};
1533};
1534
1535// getDepthClipPlanesRPC helper class declaration
1537 public yarp::os::Portable
1538{
1539public:
1541 bool write(yarp::os::ConnectionWriter& connection) const override;
1542 bool read(yarp::os::ConnectionReader& connection) override;
1543
1544 class Command :
1546 {
1547 public:
1548 Command() = default;
1549 ~Command() override = default;
1550
1551 bool write(yarp::os::ConnectionWriter& connection) const override;
1552 bool read(yarp::os::ConnectionReader& connection) override;
1553
1554 bool write(const yarp::os::idl::WireWriter& writer) const override;
1555 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1556 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1557
1558 bool read(yarp::os::idl::WireReader& reader) override;
1559 bool readTag(yarp::os::idl::WireReader& reader);
1560 bool readArgs(yarp::os::idl::WireReader& reader);
1561 };
1562
1563 class Reply :
1565 {
1566 public:
1567 Reply() = default;
1568 ~Reply() override = default;
1569
1570 bool write(yarp::os::ConnectionWriter& connection) const override;
1571 bool read(yarp::os::ConnectionReader& connection) override;
1572
1573 bool write(const yarp::os::idl::WireWriter& writer) const override;
1574 bool read(yarp::os::idl::WireReader& reader) override;
1575
1577 };
1578
1580 void call(RGBDSensorMsgs* ptr);
1581
1584
1585 static constexpr const char* s_tag{"getDepthClipPlanesRPC"};
1586 static constexpr size_t s_tag_len{1};
1587 static constexpr size_t s_cmd_len{1};
1588 static constexpr size_t s_reply_len{3};
1589 static constexpr const char* s_prototype{"IDepthVisualParamsMsgs_return_getDepthClipPlanes RGBDSensorMsgs::getDepthClipPlanesRPC()"};
1590 static constexpr const char* s_help{""};
1591};
1592
1593// setDepthClipPlanesRPC helper class declaration
1595 public yarp::os::Portable
1596{
1597public:
1599 RGBDSensorMsgs_setDepthClipPlanesRPC_helper(const double nearPlane, const double farPlane);
1600 bool write(yarp::os::ConnectionWriter& connection) const override;
1601 bool read(yarp::os::ConnectionReader& connection) override;
1602
1603 class Command :
1605 {
1606 public:
1607 Command() = default;
1608 Command(const double nearPlane, const double farPlane);
1609
1610 ~Command() override = default;
1611
1612 bool write(yarp::os::ConnectionWriter& connection) const override;
1613 bool read(yarp::os::ConnectionReader& connection) override;
1614
1615 bool write(const yarp::os::idl::WireWriter& writer) const override;
1616 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1617 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1618
1619 bool read(yarp::os::idl::WireReader& reader) override;
1620 bool readTag(yarp::os::idl::WireReader& reader);
1621 bool readArgs(yarp::os::idl::WireReader& reader);
1622
1623 double nearPlane{0.0};
1624 double farPlane{0.0};
1625 };
1626
1627 class Reply :
1629 {
1630 public:
1631 Reply() = default;
1632 ~Reply() override = default;
1633
1634 bool write(yarp::os::ConnectionWriter& connection) const override;
1635 bool read(yarp::os::ConnectionReader& connection) override;
1636
1637 bool write(const yarp::os::idl::WireWriter& writer) const override;
1638 bool read(yarp::os::idl::WireReader& reader) override;
1639
1641 };
1642
1643 using funcptr_t = yarp::dev::ReturnValue (*)(const double, const double);
1644 void call(RGBDSensorMsgs* ptr);
1645
1648
1649 static constexpr const char* s_tag{"setDepthClipPlanesRPC"};
1650 static constexpr size_t s_tag_len{1};
1651 static constexpr size_t s_cmd_len{3};
1652 static constexpr size_t s_reply_len{1};
1653 static constexpr const char* s_prototype{"yarp::dev::ReturnValue RGBDSensorMsgs::setDepthClipPlanesRPC(const double nearPlane, const double farPlane)"};
1654 static constexpr const char* s_help{""};
1655};
1656
1657// getDepthMirroringRPC helper class declaration
1659 public yarp::os::Portable
1660{
1661public:
1663 bool write(yarp::os::ConnectionWriter& connection) const override;
1664 bool read(yarp::os::ConnectionReader& connection) override;
1665
1666 class Command :
1668 {
1669 public:
1670 Command() = default;
1671 ~Command() override = default;
1672
1673 bool write(yarp::os::ConnectionWriter& connection) const override;
1674 bool read(yarp::os::ConnectionReader& connection) override;
1675
1676 bool write(const yarp::os::idl::WireWriter& writer) const override;
1677 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1678 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1679
1680 bool read(yarp::os::idl::WireReader& reader) override;
1681 bool readTag(yarp::os::idl::WireReader& reader);
1682 bool readArgs(yarp::os::idl::WireReader& reader);
1683 };
1684
1685 class Reply :
1687 {
1688 public:
1689 Reply() = default;
1690 ~Reply() override = default;
1691
1692 bool write(yarp::os::ConnectionWriter& connection) const override;
1693 bool read(yarp::os::ConnectionReader& connection) override;
1694
1695 bool write(const yarp::os::idl::WireWriter& writer) const override;
1696 bool read(yarp::os::idl::WireReader& reader) override;
1697
1699 };
1700
1702 void call(RGBDSensorMsgs* ptr);
1703
1706
1707 static constexpr const char* s_tag{"getDepthMirroringRPC"};
1708 static constexpr size_t s_tag_len{1};
1709 static constexpr size_t s_cmd_len{1};
1710 static constexpr size_t s_reply_len{2};
1711 static constexpr const char* s_prototype{"IDepthVisualParamsMsgs_return_getDepthMirroring RGBDSensorMsgs::getDepthMirroringRPC()"};
1712 static constexpr const char* s_help{""};
1713};
1714
1715// setDepthMirroringRPC helper class declaration
1717 public yarp::os::Portable
1718{
1719public:
1721 explicit RGBDSensorMsgs_setDepthMirroringRPC_helper(const bool mirror);
1722 bool write(yarp::os::ConnectionWriter& connection) const override;
1723 bool read(yarp::os::ConnectionReader& connection) override;
1724
1725 class Command :
1727 {
1728 public:
1729 Command() = default;
1730 explicit Command(const bool mirror);
1731
1732 ~Command() override = default;
1733
1734 bool write(yarp::os::ConnectionWriter& connection) const override;
1735 bool read(yarp::os::ConnectionReader& connection) override;
1736
1737 bool write(const yarp::os::idl::WireWriter& writer) const override;
1738 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1739 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1740
1741 bool read(yarp::os::idl::WireReader& reader) override;
1742 bool readTag(yarp::os::idl::WireReader& reader);
1743 bool readArgs(yarp::os::idl::WireReader& reader);
1744
1745 bool mirror{false};
1746 };
1747
1748 class Reply :
1750 {
1751 public:
1752 Reply() = default;
1753 ~Reply() override = default;
1754
1755 bool write(yarp::os::ConnectionWriter& connection) const override;
1756 bool read(yarp::os::ConnectionReader& connection) override;
1757
1758 bool write(const yarp::os::idl::WireWriter& writer) const override;
1759 bool read(yarp::os::idl::WireReader& reader) override;
1760
1762 };
1763
1764 using funcptr_t = yarp::dev::ReturnValue (*)(const bool);
1765 void call(RGBDSensorMsgs* ptr);
1766
1769
1770 static constexpr const char* s_tag{"setDepthMirroringRPC"};
1771 static constexpr size_t s_tag_len{1};
1772 static constexpr size_t s_cmd_len{2};
1773 static constexpr size_t s_reply_len{1};
1774 static constexpr const char* s_prototype{"yarp::dev::ReturnValue RGBDSensorMsgs::setDepthMirroringRPC(const bool mirror)"};
1775 static constexpr const char* s_help{""};
1776};
1777
1778// getDepthIntrinsicParamRPC helper class declaration
1780 public yarp::os::Portable
1781{
1782public:
1784 bool write(yarp::os::ConnectionWriter& connection) const override;
1785 bool read(yarp::os::ConnectionReader& connection) override;
1786
1787 class Command :
1789 {
1790 public:
1791 Command() = default;
1792 ~Command() override = default;
1793
1794 bool write(yarp::os::ConnectionWriter& connection) const override;
1795 bool read(yarp::os::ConnectionReader& connection) override;
1796
1797 bool write(const yarp::os::idl::WireWriter& writer) const override;
1798 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1799 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1800
1801 bool read(yarp::os::idl::WireReader& reader) override;
1802 bool readTag(yarp::os::idl::WireReader& reader);
1803 bool readArgs(yarp::os::idl::WireReader& reader);
1804 };
1805
1806 class Reply :
1808 {
1809 public:
1810 Reply() = default;
1811 ~Reply() override = default;
1812
1813 bool write(yarp::os::ConnectionWriter& connection) const override;
1814 bool read(yarp::os::ConnectionReader& connection) override;
1815
1816 bool write(const yarp::os::idl::WireWriter& writer) const override;
1817 bool read(yarp::os::idl::WireReader& reader) override;
1818
1820 };
1821
1823 void call(RGBDSensorMsgs* ptr);
1824
1827
1828 static constexpr const char* s_tag{"getDepthIntrinsicParamRPC"};
1829 static constexpr size_t s_tag_len{1};
1830 static constexpr size_t s_cmd_len{1};
1831 static constexpr size_t s_reply_len{2};
1832 static constexpr const char* s_prototype{"IDepthVisualParamsMsgs_return_getDepthIntrinsicParam RGBDSensorMsgs::getDepthIntrinsicParamRPC()"};
1833 static constexpr const char* s_help{""};
1834};
1835
1836// getCameraDescriptionRPC helper class declaration
1838 public yarp::os::Portable
1839{
1840public:
1842 bool write(yarp::os::ConnectionWriter& connection) const override;
1843 bool read(yarp::os::ConnectionReader& connection) override;
1844
1845 class Command :
1847 {
1848 public:
1849 Command() = default;
1850 ~Command() override = default;
1851
1852 bool write(yarp::os::ConnectionWriter& connection) const override;
1853 bool read(yarp::os::ConnectionReader& connection) override;
1854
1855 bool write(const yarp::os::idl::WireWriter& writer) const override;
1856 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1857 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1858
1859 bool read(yarp::os::idl::WireReader& reader) override;
1860 bool readTag(yarp::os::idl::WireReader& reader);
1861 bool readArgs(yarp::os::idl::WireReader& reader);
1862 };
1863
1864 class Reply :
1866 {
1867 public:
1868 Reply() = default;
1869 ~Reply() override = default;
1870
1871 bool write(yarp::os::ConnectionWriter& connection) const override;
1872 bool read(yarp::os::ConnectionReader& connection) override;
1873
1874 bool write(const yarp::os::idl::WireWriter& writer) const override;
1875 bool read(yarp::os::idl::WireReader& reader) override;
1876
1878 };
1879
1881 void call(RGBDSensorMsgs* ptr);
1882
1885
1886 static constexpr const char* s_tag{"getCameraDescriptionRPC"};
1887 static constexpr size_t s_tag_len{1};
1888 static constexpr size_t s_cmd_len{1};
1889 static constexpr size_t s_reply_len{3};
1890 static constexpr const char* s_prototype{"IFrameGrabberControlMsgs_return_getCameraDescription RGBDSensorMsgs::getCameraDescriptionRPC()"};
1891 static constexpr const char* s_help{""};
1892};
1893
1894// hasFeatureRPC helper class declaration
1896 public yarp::os::Portable
1897{
1898public:
1900 explicit RGBDSensorMsgs_hasFeatureRPC_helper(const std::int32_t feature);
1901 bool write(yarp::os::ConnectionWriter& connection) const override;
1902 bool read(yarp::os::ConnectionReader& connection) override;
1903
1904 class Command :
1906 {
1907 public:
1908 Command() = default;
1909 explicit Command(const std::int32_t feature);
1910
1911 ~Command() override = default;
1912
1913 bool write(yarp::os::ConnectionWriter& connection) const override;
1914 bool read(yarp::os::ConnectionReader& connection) override;
1915
1916 bool write(const yarp::os::idl::WireWriter& writer) const override;
1917 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1918 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1919
1920 bool read(yarp::os::idl::WireReader& reader) override;
1921 bool readTag(yarp::os::idl::WireReader& reader);
1922 bool readArgs(yarp::os::idl::WireReader& reader);
1923
1924 std::int32_t feature{0};
1925 };
1926
1927 class Reply :
1929 {
1930 public:
1931 Reply() = default;
1932 ~Reply() override = default;
1933
1934 bool write(yarp::os::ConnectionWriter& connection) const override;
1935 bool read(yarp::os::ConnectionReader& connection) override;
1936
1937 bool write(const yarp::os::idl::WireWriter& writer) const override;
1938 bool read(yarp::os::idl::WireReader& reader) override;
1939
1941 };
1942
1944 void call(RGBDSensorMsgs* ptr);
1945
1948
1949 static constexpr const char* s_tag{"hasFeatureRPC"};
1950 static constexpr size_t s_tag_len{1};
1951 static constexpr size_t s_cmd_len{2};
1952 static constexpr size_t s_reply_len{2};
1953 static constexpr const char* s_prototype{"IFrameGrabberControlMsgs_return_hasFeature RGBDSensorMsgs::hasFeatureRPC(const std::int32_t feature)"};
1954 static constexpr const char* s_help{""};
1955};
1956
1957// setFeature1RPC helper class declaration
1959 public yarp::os::Portable
1960{
1961public:
1963 RGBDSensorMsgs_setFeature1RPC_helper(const std::int32_t feature, const double value);
1964 bool write(yarp::os::ConnectionWriter& connection) const override;
1965 bool read(yarp::os::ConnectionReader& connection) override;
1966
1967 class Command :
1969 {
1970 public:
1971 Command() = default;
1972 Command(const std::int32_t feature, const double value);
1973
1974 ~Command() override = default;
1975
1976 bool write(yarp::os::ConnectionWriter& connection) const override;
1977 bool read(yarp::os::ConnectionReader& connection) override;
1978
1979 bool write(const yarp::os::idl::WireWriter& writer) const override;
1980 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1981 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1982
1983 bool read(yarp::os::idl::WireReader& reader) override;
1984 bool readTag(yarp::os::idl::WireReader& reader);
1985 bool readArgs(yarp::os::idl::WireReader& reader);
1986
1987 std::int32_t feature{0};
1988 double value{0.0};
1989 };
1990
1991 class Reply :
1993 {
1994 public:
1995 Reply() = default;
1996 ~Reply() override = default;
1997
1998 bool write(yarp::os::ConnectionWriter& connection) const override;
1999 bool read(yarp::os::ConnectionReader& connection) override;
2000
2001 bool write(const yarp::os::idl::WireWriter& writer) const override;
2002 bool read(yarp::os::idl::WireReader& reader) override;
2003
2005 };
2006
2007 using funcptr_t = yarp::dev::ReturnValue (*)(const std::int32_t, const double);
2008 void call(RGBDSensorMsgs* ptr);
2009
2012
2013 static constexpr const char* s_tag{"setFeature1RPC"};
2014 static constexpr size_t s_tag_len{1};
2015 static constexpr size_t s_cmd_len{3};
2016 static constexpr size_t s_reply_len{1};
2017 static constexpr const char* s_prototype{"yarp::dev::ReturnValue RGBDSensorMsgs::setFeature1RPC(const std::int32_t feature, const double value)"};
2018 static constexpr const char* s_help{""};
2019};
2020
2021// getFeature1RPC helper class declaration
2023 public yarp::os::Portable
2024{
2025public:
2027 explicit RGBDSensorMsgs_getFeature1RPC_helper(const std::int32_t feature);
2028 bool write(yarp::os::ConnectionWriter& connection) const override;
2029 bool read(yarp::os::ConnectionReader& connection) override;
2030
2031 class Command :
2033 {
2034 public:
2035 Command() = default;
2036 explicit Command(const std::int32_t feature);
2037
2038 ~Command() override = default;
2039
2040 bool write(yarp::os::ConnectionWriter& connection) const override;
2041 bool read(yarp::os::ConnectionReader& connection) override;
2042
2043 bool write(const yarp::os::idl::WireWriter& writer) const override;
2044 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2045 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2046
2047 bool read(yarp::os::idl::WireReader& reader) override;
2048 bool readTag(yarp::os::idl::WireReader& reader);
2049 bool readArgs(yarp::os::idl::WireReader& reader);
2050
2051 std::int32_t feature{0};
2052 };
2053
2054 class Reply :
2056 {
2057 public:
2058 Reply() = default;
2059 ~Reply() override = default;
2060
2061 bool write(yarp::os::ConnectionWriter& connection) const override;
2062 bool read(yarp::os::ConnectionReader& connection) override;
2063
2064 bool write(const yarp::os::idl::WireWriter& writer) const override;
2065 bool read(yarp::os::idl::WireReader& reader) override;
2066
2068 };
2069
2071 void call(RGBDSensorMsgs* ptr);
2072
2075
2076 static constexpr const char* s_tag{"getFeature1RPC"};
2077 static constexpr size_t s_tag_len{1};
2078 static constexpr size_t s_cmd_len{2};
2079 static constexpr size_t s_reply_len{2};
2080 static constexpr const char* s_prototype{"IFrameGrabberControlMsgs_return_getFeature1 RGBDSensorMsgs::getFeature1RPC(const std::int32_t feature)"};
2081 static constexpr const char* s_help{""};
2082};
2083
2084// setFeature2RPC helper class declaration
2086 public yarp::os::Portable
2087{
2088public:
2090 RGBDSensorMsgs_setFeature2RPC_helper(const std::int32_t feature, const double value1, const double value2);
2091 bool write(yarp::os::ConnectionWriter& connection) const override;
2092 bool read(yarp::os::ConnectionReader& connection) override;
2093
2094 class Command :
2096 {
2097 public:
2098 Command() = default;
2099 Command(const std::int32_t feature, const double value1, const double value2);
2100
2101 ~Command() override = default;
2102
2103 bool write(yarp::os::ConnectionWriter& connection) const override;
2104 bool read(yarp::os::ConnectionReader& connection) override;
2105
2106 bool write(const yarp::os::idl::WireWriter& writer) const override;
2107 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2108 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2109
2110 bool read(yarp::os::idl::WireReader& reader) override;
2111 bool readTag(yarp::os::idl::WireReader& reader);
2112 bool readArgs(yarp::os::idl::WireReader& reader);
2113
2114 std::int32_t feature{0};
2115 double value1{0.0};
2116 double value2{0.0};
2117 };
2118
2119 class Reply :
2121 {
2122 public:
2123 Reply() = default;
2124 ~Reply() override = default;
2125
2126 bool write(yarp::os::ConnectionWriter& connection) const override;
2127 bool read(yarp::os::ConnectionReader& connection) override;
2128
2129 bool write(const yarp::os::idl::WireWriter& writer) const override;
2130 bool read(yarp::os::idl::WireReader& reader) override;
2131
2133 };
2134
2135 using funcptr_t = yarp::dev::ReturnValue (*)(const std::int32_t, const double, const double);
2136 void call(RGBDSensorMsgs* ptr);
2137
2140
2141 static constexpr const char* s_tag{"setFeature2RPC"};
2142 static constexpr size_t s_tag_len{1};
2143 static constexpr size_t s_cmd_len{4};
2144 static constexpr size_t s_reply_len{1};
2145 static constexpr const char* s_prototype{"yarp::dev::ReturnValue RGBDSensorMsgs::setFeature2RPC(const std::int32_t feature, const double value1, const double value2)"};
2146 static constexpr const char* s_help{""};
2147};
2148
2149// getFeature2RPC helper class declaration
2151 public yarp::os::Portable
2152{
2153public:
2155 explicit RGBDSensorMsgs_getFeature2RPC_helper(const std::int32_t feature);
2156 bool write(yarp::os::ConnectionWriter& connection) const override;
2157 bool read(yarp::os::ConnectionReader& connection) override;
2158
2159 class Command :
2161 {
2162 public:
2163 Command() = default;
2164 explicit Command(const std::int32_t feature);
2165
2166 ~Command() override = default;
2167
2168 bool write(yarp::os::ConnectionWriter& connection) const override;
2169 bool read(yarp::os::ConnectionReader& connection) override;
2170
2171 bool write(const yarp::os::idl::WireWriter& writer) const override;
2172 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2173 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2174
2175 bool read(yarp::os::idl::WireReader& reader) override;
2176 bool readTag(yarp::os::idl::WireReader& reader);
2177 bool readArgs(yarp::os::idl::WireReader& reader);
2178
2179 std::int32_t feature{0};
2180 };
2181
2182 class Reply :
2184 {
2185 public:
2186 Reply() = default;
2187 ~Reply() override = default;
2188
2189 bool write(yarp::os::ConnectionWriter& connection) const override;
2190 bool read(yarp::os::ConnectionReader& connection) override;
2191
2192 bool write(const yarp::os::idl::WireWriter& writer) const override;
2193 bool read(yarp::os::idl::WireReader& reader) override;
2194
2196 };
2197
2199 void call(RGBDSensorMsgs* ptr);
2200
2203
2204 static constexpr const char* s_tag{"getFeature2RPC"};
2205 static constexpr size_t s_tag_len{1};
2206 static constexpr size_t s_cmd_len{2};
2207 static constexpr size_t s_reply_len{3};
2208 static constexpr const char* s_prototype{"IFrameGrabberControlMsgs_return_getFeature2 RGBDSensorMsgs::getFeature2RPC(const std::int32_t feature)"};
2209 static constexpr const char* s_help{""};
2210};
2211
2212// hasOnOffRPC helper class declaration
2214 public yarp::os::Portable
2215{
2216public:
2218 explicit RGBDSensorMsgs_hasOnOffRPC_helper(const std::int32_t feature);
2219 bool write(yarp::os::ConnectionWriter& connection) const override;
2220 bool read(yarp::os::ConnectionReader& connection) override;
2221
2222 class Command :
2224 {
2225 public:
2226 Command() = default;
2227 explicit Command(const std::int32_t feature);
2228
2229 ~Command() override = default;
2230
2231 bool write(yarp::os::ConnectionWriter& connection) const override;
2232 bool read(yarp::os::ConnectionReader& connection) override;
2233
2234 bool write(const yarp::os::idl::WireWriter& writer) const override;
2235 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2236 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2237
2238 bool read(yarp::os::idl::WireReader& reader) override;
2239 bool readTag(yarp::os::idl::WireReader& reader);
2240 bool readArgs(yarp::os::idl::WireReader& reader);
2241
2242 std::int32_t feature{0};
2243 };
2244
2245 class Reply :
2247 {
2248 public:
2249 Reply() = default;
2250 ~Reply() override = default;
2251
2252 bool write(yarp::os::ConnectionWriter& connection) const override;
2253 bool read(yarp::os::ConnectionReader& connection) override;
2254
2255 bool write(const yarp::os::idl::WireWriter& writer) const override;
2256 bool read(yarp::os::idl::WireReader& reader) override;
2257
2259 };
2260
2262 void call(RGBDSensorMsgs* ptr);
2263
2266
2267 static constexpr const char* s_tag{"hasOnOffRPC"};
2268 static constexpr size_t s_tag_len{1};
2269 static constexpr size_t s_cmd_len{2};
2270 static constexpr size_t s_reply_len{2};
2271 static constexpr const char* s_prototype{"IFrameGrabberControlMsgs_return_hasOnOff RGBDSensorMsgs::hasOnOffRPC(const std::int32_t feature)"};
2272 static constexpr const char* s_help{""};
2273};
2274
2275// setActiveRPC helper class declaration
2277 public yarp::os::Portable
2278{
2279public:
2281 RGBDSensorMsgs_setActiveRPC_helper(const std::int32_t feature, const bool onoff);
2282 bool write(yarp::os::ConnectionWriter& connection) const override;
2283 bool read(yarp::os::ConnectionReader& connection) override;
2284
2285 class Command :
2287 {
2288 public:
2289 Command() = default;
2290 Command(const std::int32_t feature, const bool onoff);
2291
2292 ~Command() override = default;
2293
2294 bool write(yarp::os::ConnectionWriter& connection) const override;
2295 bool read(yarp::os::ConnectionReader& connection) override;
2296
2297 bool write(const yarp::os::idl::WireWriter& writer) const override;
2298 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2299 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2300
2301 bool read(yarp::os::idl::WireReader& reader) override;
2302 bool readTag(yarp::os::idl::WireReader& reader);
2303 bool readArgs(yarp::os::idl::WireReader& reader);
2304
2305 std::int32_t feature{0};
2306 bool onoff{false};
2307 };
2308
2309 class Reply :
2311 {
2312 public:
2313 Reply() = default;
2314 ~Reply() override = default;
2315
2316 bool write(yarp::os::ConnectionWriter& connection) const override;
2317 bool read(yarp::os::ConnectionReader& connection) override;
2318
2319 bool write(const yarp::os::idl::WireWriter& writer) const override;
2320 bool read(yarp::os::idl::WireReader& reader) override;
2321
2323 };
2324
2325 using funcptr_t = yarp::dev::ReturnValue (*)(const std::int32_t, const bool);
2326 void call(RGBDSensorMsgs* ptr);
2327
2330
2331 static constexpr const char* s_tag{"setActiveRPC"};
2332 static constexpr size_t s_tag_len{1};
2333 static constexpr size_t s_cmd_len{3};
2334 static constexpr size_t s_reply_len{1};
2335 static constexpr const char* s_prototype{"yarp::dev::ReturnValue RGBDSensorMsgs::setActiveRPC(const std::int32_t feature, const bool onoff)"};
2336 static constexpr const char* s_help{""};
2337};
2338
2339// getActiveRPC helper class declaration
2341 public yarp::os::Portable
2342{
2343public:
2345 explicit RGBDSensorMsgs_getActiveRPC_helper(const std::int32_t feature);
2346 bool write(yarp::os::ConnectionWriter& connection) const override;
2347 bool read(yarp::os::ConnectionReader& connection) override;
2348
2349 class Command :
2351 {
2352 public:
2353 Command() = default;
2354 explicit Command(const std::int32_t feature);
2355
2356 ~Command() override = default;
2357
2358 bool write(yarp::os::ConnectionWriter& connection) const override;
2359 bool read(yarp::os::ConnectionReader& connection) override;
2360
2361 bool write(const yarp::os::idl::WireWriter& writer) const override;
2362 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2363 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2364
2365 bool read(yarp::os::idl::WireReader& reader) override;
2366 bool readTag(yarp::os::idl::WireReader& reader);
2367 bool readArgs(yarp::os::idl::WireReader& reader);
2368
2369 std::int32_t feature{0};
2370 };
2371
2372 class Reply :
2374 {
2375 public:
2376 Reply() = default;
2377 ~Reply() override = default;
2378
2379 bool write(yarp::os::ConnectionWriter& connection) const override;
2380 bool read(yarp::os::ConnectionReader& connection) override;
2381
2382 bool write(const yarp::os::idl::WireWriter& writer) const override;
2383 bool read(yarp::os::idl::WireReader& reader) override;
2384
2386 };
2387
2389 void call(RGBDSensorMsgs* ptr);
2390
2393
2394 static constexpr const char* s_tag{"getActiveRPC"};
2395 static constexpr size_t s_tag_len{1};
2396 static constexpr size_t s_cmd_len{2};
2397 static constexpr size_t s_reply_len{2};
2398 static constexpr const char* s_prototype{"IFrameGrabberControlMsgs_return_getActive RGBDSensorMsgs::getActiveRPC(const std::int32_t feature)"};
2399 static constexpr const char* s_help{""};
2400};
2401
2402// hasAutoRPC helper class declaration
2404 public yarp::os::Portable
2405{
2406public:
2408 explicit RGBDSensorMsgs_hasAutoRPC_helper(const std::int32_t feature);
2409 bool write(yarp::os::ConnectionWriter& connection) const override;
2410 bool read(yarp::os::ConnectionReader& connection) override;
2411
2412 class Command :
2414 {
2415 public:
2416 Command() = default;
2417 explicit Command(const std::int32_t feature);
2418
2419 ~Command() override = default;
2420
2421 bool write(yarp::os::ConnectionWriter& connection) const override;
2422 bool read(yarp::os::ConnectionReader& connection) override;
2423
2424 bool write(const yarp::os::idl::WireWriter& writer) const override;
2425 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2426 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2427
2428 bool read(yarp::os::idl::WireReader& reader) override;
2429 bool readTag(yarp::os::idl::WireReader& reader);
2430 bool readArgs(yarp::os::idl::WireReader& reader);
2431
2432 std::int32_t feature{0};
2433 };
2434
2435 class Reply :
2437 {
2438 public:
2439 Reply() = default;
2440 ~Reply() override = default;
2441
2442 bool write(yarp::os::ConnectionWriter& connection) const override;
2443 bool read(yarp::os::ConnectionReader& connection) override;
2444
2445 bool write(const yarp::os::idl::WireWriter& writer) const override;
2446 bool read(yarp::os::idl::WireReader& reader) override;
2447
2449 };
2450
2452 void call(RGBDSensorMsgs* ptr);
2453
2456
2457 static constexpr const char* s_tag{"hasAutoRPC"};
2458 static constexpr size_t s_tag_len{1};
2459 static constexpr size_t s_cmd_len{2};
2460 static constexpr size_t s_reply_len{2};
2461 static constexpr const char* s_prototype{"IFrameGrabberControlMsgs_return_hasAuto RGBDSensorMsgs::hasAutoRPC(const std::int32_t feature)"};
2462 static constexpr const char* s_help{""};
2463};
2464
2465// hasManualRPC helper class declaration
2467 public yarp::os::Portable
2468{
2469public:
2471 explicit RGBDSensorMsgs_hasManualRPC_helper(const std::int32_t feature);
2472 bool write(yarp::os::ConnectionWriter& connection) const override;
2473 bool read(yarp::os::ConnectionReader& connection) override;
2474
2475 class Command :
2477 {
2478 public:
2479 Command() = default;
2480 explicit Command(const std::int32_t feature);
2481
2482 ~Command() override = default;
2483
2484 bool write(yarp::os::ConnectionWriter& connection) const override;
2485 bool read(yarp::os::ConnectionReader& connection) override;
2486
2487 bool write(const yarp::os::idl::WireWriter& writer) const override;
2488 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2489 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2490
2491 bool read(yarp::os::idl::WireReader& reader) override;
2492 bool readTag(yarp::os::idl::WireReader& reader);
2493 bool readArgs(yarp::os::idl::WireReader& reader);
2494
2495 std::int32_t feature{0};
2496 };
2497
2498 class Reply :
2500 {
2501 public:
2502 Reply() = default;
2503 ~Reply() override = default;
2504
2505 bool write(yarp::os::ConnectionWriter& connection) const override;
2506 bool read(yarp::os::ConnectionReader& connection) override;
2507
2508 bool write(const yarp::os::idl::WireWriter& writer) const override;
2509 bool read(yarp::os::idl::WireReader& reader) override;
2510
2512 };
2513
2515 void call(RGBDSensorMsgs* ptr);
2516
2519
2520 static constexpr const char* s_tag{"hasManualRPC"};
2521 static constexpr size_t s_tag_len{1};
2522 static constexpr size_t s_cmd_len{2};
2523 static constexpr size_t s_reply_len{2};
2524 static constexpr const char* s_prototype{"IFrameGrabberControlMsgs_return_hasManual RGBDSensorMsgs::hasManualRPC(const std::int32_t feature)"};
2525 static constexpr const char* s_help{""};
2526};
2527
2528// hasOnePushRPC helper class declaration
2530 public yarp::os::Portable
2531{
2532public:
2534 explicit RGBDSensorMsgs_hasOnePushRPC_helper(const std::int32_t feature);
2535 bool write(yarp::os::ConnectionWriter& connection) const override;
2536 bool read(yarp::os::ConnectionReader& connection) override;
2537
2538 class Command :
2540 {
2541 public:
2542 Command() = default;
2543 explicit Command(const std::int32_t feature);
2544
2545 ~Command() override = default;
2546
2547 bool write(yarp::os::ConnectionWriter& connection) const override;
2548 bool read(yarp::os::ConnectionReader& connection) override;
2549
2550 bool write(const yarp::os::idl::WireWriter& writer) const override;
2551 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2552 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2553
2554 bool read(yarp::os::idl::WireReader& reader) override;
2555 bool readTag(yarp::os::idl::WireReader& reader);
2556 bool readArgs(yarp::os::idl::WireReader& reader);
2557
2558 std::int32_t feature{0};
2559 };
2560
2561 class Reply :
2563 {
2564 public:
2565 Reply() = default;
2566 ~Reply() override = default;
2567
2568 bool write(yarp::os::ConnectionWriter& connection) const override;
2569 bool read(yarp::os::ConnectionReader& connection) override;
2570
2571 bool write(const yarp::os::idl::WireWriter& writer) const override;
2572 bool read(yarp::os::idl::WireReader& reader) override;
2573
2575 };
2576
2578 void call(RGBDSensorMsgs* ptr);
2579
2582
2583 static constexpr const char* s_tag{"hasOnePushRPC"};
2584 static constexpr size_t s_tag_len{1};
2585 static constexpr size_t s_cmd_len{2};
2586 static constexpr size_t s_reply_len{2};
2587 static constexpr const char* s_prototype{"IFrameGrabberControlMsgs_return_hasOnePush RGBDSensorMsgs::hasOnePushRPC(const std::int32_t feature)"};
2588 static constexpr const char* s_help{""};
2589};
2590
2591// setModeRPC helper class declaration
2593 public yarp::os::Portable
2594{
2595public:
2598 bool write(yarp::os::ConnectionWriter& connection) const override;
2599 bool read(yarp::os::ConnectionReader& connection) override;
2600
2601 class Command :
2603 {
2604 public:
2605 Command() = default;
2606 Command(const std::int32_t feature, const yarp::dev::FeatureMode mode);
2607
2608 ~Command() override = default;
2609
2610 bool write(yarp::os::ConnectionWriter& connection) const override;
2611 bool read(yarp::os::ConnectionReader& connection) override;
2612
2613 bool write(const yarp::os::idl::WireWriter& writer) const override;
2614 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2615 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2616
2617 bool read(yarp::os::idl::WireReader& reader) override;
2618 bool readTag(yarp::os::idl::WireReader& reader);
2619 bool readArgs(yarp::os::idl::WireReader& reader);
2620
2621 std::int32_t feature{0};
2623 };
2624
2625 class Reply :
2627 {
2628 public:
2629 Reply() = default;
2630 ~Reply() override = default;
2631
2632 bool write(yarp::os::ConnectionWriter& connection) const override;
2633 bool read(yarp::os::ConnectionReader& connection) override;
2634
2635 bool write(const yarp::os::idl::WireWriter& writer) const override;
2636 bool read(yarp::os::idl::WireReader& reader) override;
2637
2639 };
2640
2641 using funcptr_t = yarp::dev::ReturnValue (*)(const std::int32_t, const yarp::dev::FeatureMode);
2642 void call(RGBDSensorMsgs* ptr);
2643
2646
2647 static constexpr const char* s_tag{"setModeRPC"};
2648 static constexpr size_t s_tag_len{1};
2649 static constexpr size_t s_cmd_len{3};
2650 static constexpr size_t s_reply_len{1};
2651 static constexpr const char* s_prototype{"yarp::dev::ReturnValue RGBDSensorMsgs::setModeRPC(const std::int32_t feature, const yarp::dev::FeatureMode mode)"};
2652 static constexpr const char* s_help{""};
2653};
2654
2655// getModeRPC helper class declaration
2657 public yarp::os::Portable
2658{
2659public:
2661 explicit RGBDSensorMsgs_getModeRPC_helper(const std::int32_t feature);
2662 bool write(yarp::os::ConnectionWriter& connection) const override;
2663 bool read(yarp::os::ConnectionReader& connection) override;
2664
2665 class Command :
2667 {
2668 public:
2669 Command() = default;
2670 explicit Command(const std::int32_t feature);
2671
2672 ~Command() override = default;
2673
2674 bool write(yarp::os::ConnectionWriter& connection) const override;
2675 bool read(yarp::os::ConnectionReader& connection) override;
2676
2677 bool write(const yarp::os::idl::WireWriter& writer) const override;
2678 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2679 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2680
2681 bool read(yarp::os::idl::WireReader& reader) override;
2682 bool readTag(yarp::os::idl::WireReader& reader);
2683 bool readArgs(yarp::os::idl::WireReader& reader);
2684
2685 std::int32_t feature{0};
2686 };
2687
2688 class Reply :
2690 {
2691 public:
2692 Reply() = default;
2693 ~Reply() override = default;
2694
2695 bool write(yarp::os::ConnectionWriter& connection) const override;
2696 bool read(yarp::os::ConnectionReader& connection) override;
2697
2698 bool write(const yarp::os::idl::WireWriter& writer) const override;
2699 bool read(yarp::os::idl::WireReader& reader) override;
2700
2702 };
2703
2705 void call(RGBDSensorMsgs* ptr);
2706
2709
2710 static constexpr const char* s_tag{"getModeRPC"};
2711 static constexpr size_t s_tag_len{1};
2712 static constexpr size_t s_cmd_len{2};
2713 static constexpr size_t s_reply_len{2};
2714 static constexpr const char* s_prototype{"IFrameGrabberControlMsgs_return_getMode RGBDSensorMsgs::getModeRPC(const std::int32_t feature)"};
2715 static constexpr const char* s_help{""};
2716};
2717
2718// setOnePushRPC helper class declaration
2720 public yarp::os::Portable
2721{
2722public:
2724 explicit RGBDSensorMsgs_setOnePushRPC_helper(const std::int32_t feature);
2725 bool write(yarp::os::ConnectionWriter& connection) const override;
2726 bool read(yarp::os::ConnectionReader& connection) override;
2727
2728 class Command :
2730 {
2731 public:
2732 Command() = default;
2733 explicit Command(const std::int32_t feature);
2734
2735 ~Command() override = default;
2736
2737 bool write(yarp::os::ConnectionWriter& connection) const override;
2738 bool read(yarp::os::ConnectionReader& connection) override;
2739
2740 bool write(const yarp::os::idl::WireWriter& writer) const override;
2741 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2742 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2743
2744 bool read(yarp::os::idl::WireReader& reader) override;
2745 bool readTag(yarp::os::idl::WireReader& reader);
2746 bool readArgs(yarp::os::idl::WireReader& reader);
2747
2748 std::int32_t feature{0};
2749 };
2750
2751 class Reply :
2753 {
2754 public:
2755 Reply() = default;
2756 ~Reply() override = default;
2757
2758 bool write(yarp::os::ConnectionWriter& connection) const override;
2759 bool read(yarp::os::ConnectionReader& connection) override;
2760
2761 bool write(const yarp::os::idl::WireWriter& writer) const override;
2762 bool read(yarp::os::idl::WireReader& reader) override;
2763
2765 };
2766
2767 using funcptr_t = yarp::dev::ReturnValue (*)(const std::int32_t);
2768 void call(RGBDSensorMsgs* ptr);
2769
2772
2773 static constexpr const char* s_tag{"setOnePushRPC"};
2774 static constexpr size_t s_tag_len{1};
2775 static constexpr size_t s_cmd_len{2};
2776 static constexpr size_t s_reply_len{1};
2777 static constexpr const char* s_prototype{"yarp::dev::ReturnValue RGBDSensorMsgs::setOnePushRPC(const std::int32_t feature)"};
2778 static constexpr const char* s_help{""};
2779};
2780
2781// getExtrinsicParamRPC helper class implementation
2783{
2784 return cmd.write(connection);
2785}
2786
2788{
2789 return reply.read(connection);
2790}
2791
2793{
2794 yarp::os::idl::WireWriter writer(connection);
2795 if (!writer.writeListHeader(s_cmd_len)) {
2796 return false;
2797 }
2798 return write(writer);
2799}
2800
2802{
2803 yarp::os::idl::WireReader reader(connection);
2804 if (!reader.readListHeader()) {
2805 reader.fail();
2806 return false;
2807 }
2808 return read(reader);
2809}
2810
2812{
2813 if (!writeTag(writer)) {
2814 return false;
2815 }
2816 if (!writeArgs(writer)) {
2817 return false;
2818 }
2819 return true;
2820}
2821
2823{
2824 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2825 return false;
2826 }
2827 return true;
2828}
2829
2831{
2832 return true;
2833}
2834
2836{
2837 if (!readTag(reader)) {
2838 return false;
2839 }
2840 if (!readArgs(reader)) {
2841 return false;
2842 }
2843 return true;
2844}
2845
2847{
2848 std::string tag = reader.readTag(s_tag_len);
2849 if (reader.isError()) {
2850 return false;
2851 }
2852 if (tag != s_tag) {
2853 reader.fail();
2854 return false;
2855 }
2856 return true;
2857}
2858
2860{
2861 if (!reader.noMore()) {
2862 reader.fail();
2863 return false;
2864 }
2865 return true;
2866}
2867
2869{
2870 yarp::os::idl::WireWriter writer(connection);
2871 return write(writer);
2872}
2873
2875{
2876 yarp::os::idl::WireReader reader(connection);
2877 return read(reader);
2878}
2879
2881{
2882 if (!writer.isNull()) {
2883 if (!writer.writeListHeader(s_reply_len)) {
2884 return false;
2885 }
2886 if (!writer.write(return_helper)) {
2887 return false;
2888 }
2889 }
2890 return true;
2891}
2892
2894{
2895 if (!reader.readListReturn()) {
2896 return false;
2897 }
2898 if (reader.noMore()) {
2899 reader.fail();
2900 return false;
2901 }
2902 if (!reader.read(return_helper)) {
2903 reader.fail();
2904 return false;
2905 }
2906 return true;
2907}
2908
2913
2914// getLastErrorMsgRPC helper class implementation
2916{
2917 return cmd.write(connection);
2918}
2919
2921{
2922 return reply.read(connection);
2923}
2924
2926{
2927 yarp::os::idl::WireWriter writer(connection);
2928 if (!writer.writeListHeader(s_cmd_len)) {
2929 return false;
2930 }
2931 return write(writer);
2932}
2933
2935{
2936 yarp::os::idl::WireReader reader(connection);
2937 if (!reader.readListHeader()) {
2938 reader.fail();
2939 return false;
2940 }
2941 return read(reader);
2942}
2943
2945{
2946 if (!writeTag(writer)) {
2947 return false;
2948 }
2949 if (!writeArgs(writer)) {
2950 return false;
2951 }
2952 return true;
2953}
2954
2956{
2957 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2958 return false;
2959 }
2960 return true;
2961}
2962
2964{
2965 return true;
2966}
2967
2969{
2970 if (!readTag(reader)) {
2971 return false;
2972 }
2973 if (!readArgs(reader)) {
2974 return false;
2975 }
2976 return true;
2977}
2978
2980{
2981 std::string tag = reader.readTag(s_tag_len);
2982 if (reader.isError()) {
2983 return false;
2984 }
2985 if (tag != s_tag) {
2986 reader.fail();
2987 return false;
2988 }
2989 return true;
2990}
2991
2993{
2994 if (!reader.noMore()) {
2995 reader.fail();
2996 return false;
2997 }
2998 return true;
2999}
3000
3002{
3003 yarp::os::idl::WireWriter writer(connection);
3004 return write(writer);
3005}
3006
3008{
3009 yarp::os::idl::WireReader reader(connection);
3010 return read(reader);
3011}
3012
3014{
3015 if (!writer.isNull()) {
3016 if (!writer.writeListHeader(s_reply_len)) {
3017 return false;
3018 }
3019 if (!writer.write(return_helper)) {
3020 return false;
3021 }
3022 }
3023 return true;
3024}
3025
3027{
3028 if (!reader.readListReturn()) {
3029 return false;
3030 }
3031 if (reader.noMore()) {
3032 reader.fail();
3033 return false;
3034 }
3035 if (!reader.read(return_helper)) {
3036 reader.fail();
3037 return false;
3038 }
3039 return true;
3040}
3041
3046
3047// getRgbImageRPC helper class implementation
3049{
3050 return cmd.write(connection);
3051}
3052
3054{
3055 return reply.read(connection);
3056}
3057
3059{
3060 yarp::os::idl::WireWriter writer(connection);
3061 if (!writer.writeListHeader(s_cmd_len)) {
3062 return false;
3063 }
3064 return write(writer);
3065}
3066
3068{
3069 yarp::os::idl::WireReader reader(connection);
3070 if (!reader.readListHeader()) {
3071 reader.fail();
3072 return false;
3073 }
3074 return read(reader);
3075}
3076
3078{
3079 if (!writeTag(writer)) {
3080 return false;
3081 }
3082 if (!writeArgs(writer)) {
3083 return false;
3084 }
3085 return true;
3086}
3087
3089{
3090 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3091 return false;
3092 }
3093 return true;
3094}
3095
3097{
3098 return true;
3099}
3100
3102{
3103 if (!readTag(reader)) {
3104 return false;
3105 }
3106 if (!readArgs(reader)) {
3107 return false;
3108 }
3109 return true;
3110}
3111
3113{
3114 std::string tag = reader.readTag(s_tag_len);
3115 if (reader.isError()) {
3116 return false;
3117 }
3118 if (tag != s_tag) {
3119 reader.fail();
3120 return false;
3121 }
3122 return true;
3123}
3124
3126{
3127 if (!reader.noMore()) {
3128 reader.fail();
3129 return false;
3130 }
3131 return true;
3132}
3133
3135{
3136 yarp::os::idl::WireWriter writer(connection);
3137 return write(writer);
3138}
3139
3141{
3142 yarp::os::idl::WireReader reader(connection);
3143 return read(reader);
3144}
3145
3147{
3148 if (!writer.isNull()) {
3149 if (!writer.writeListHeader(s_reply_len)) {
3150 return false;
3151 }
3152 if (!writer.write(return_helper)) {
3153 return false;
3154 }
3155 }
3156 return true;
3157}
3158
3160{
3161 if (!reader.readListReturn()) {
3162 return false;
3163 }
3164 if (reader.noMore()) {
3165 reader.fail();
3166 return false;
3167 }
3168 if (!reader.read(return_helper)) {
3169 reader.fail();
3170 return false;
3171 }
3172 return true;
3173}
3174
3179
3180// getDepthImageRPC helper class implementation
3182{
3183 return cmd.write(connection);
3184}
3185
3187{
3188 return reply.read(connection);
3189}
3190
3192{
3193 yarp::os::idl::WireWriter writer(connection);
3194 if (!writer.writeListHeader(s_cmd_len)) {
3195 return false;
3196 }
3197 return write(writer);
3198}
3199
3201{
3202 yarp::os::idl::WireReader reader(connection);
3203 if (!reader.readListHeader()) {
3204 reader.fail();
3205 return false;
3206 }
3207 return read(reader);
3208}
3209
3211{
3212 if (!writeTag(writer)) {
3213 return false;
3214 }
3215 if (!writeArgs(writer)) {
3216 return false;
3217 }
3218 return true;
3219}
3220
3222{
3223 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3224 return false;
3225 }
3226 return true;
3227}
3228
3230{
3231 return true;
3232}
3233
3235{
3236 if (!readTag(reader)) {
3237 return false;
3238 }
3239 if (!readArgs(reader)) {
3240 return false;
3241 }
3242 return true;
3243}
3244
3246{
3247 std::string tag = reader.readTag(s_tag_len);
3248 if (reader.isError()) {
3249 return false;
3250 }
3251 if (tag != s_tag) {
3252 reader.fail();
3253 return false;
3254 }
3255 return true;
3256}
3257
3259{
3260 if (!reader.noMore()) {
3261 reader.fail();
3262 return false;
3263 }
3264 return true;
3265}
3266
3268{
3269 yarp::os::idl::WireWriter writer(connection);
3270 return write(writer);
3271}
3272
3274{
3275 yarp::os::idl::WireReader reader(connection);
3276 return read(reader);
3277}
3278
3280{
3281 if (!writer.isNull()) {
3282 if (!writer.writeListHeader(s_reply_len)) {
3283 return false;
3284 }
3285 if (!writer.write(return_helper)) {
3286 return false;
3287 }
3288 }
3289 return true;
3290}
3291
3293{
3294 if (!reader.readListReturn()) {
3295 return false;
3296 }
3297 if (reader.noMore()) {
3298 reader.fail();
3299 return false;
3300 }
3301 if (!reader.read(return_helper)) {
3302 reader.fail();
3303 return false;
3304 }
3305 return true;
3306}
3307
3312
3313// getImagesRPC helper class implementation
3315{
3316 return cmd.write(connection);
3317}
3318
3320{
3321 return reply.read(connection);
3322}
3323
3325{
3326 yarp::os::idl::WireWriter writer(connection);
3327 if (!writer.writeListHeader(s_cmd_len)) {
3328 return false;
3329 }
3330 return write(writer);
3331}
3332
3334{
3335 yarp::os::idl::WireReader reader(connection);
3336 if (!reader.readListHeader()) {
3337 reader.fail();
3338 return false;
3339 }
3340 return read(reader);
3341}
3342
3344{
3345 if (!writeTag(writer)) {
3346 return false;
3347 }
3348 if (!writeArgs(writer)) {
3349 return false;
3350 }
3351 return true;
3352}
3353
3355{
3356 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3357 return false;
3358 }
3359 return true;
3360}
3361
3363{
3364 return true;
3365}
3366
3368{
3369 if (!readTag(reader)) {
3370 return false;
3371 }
3372 if (!readArgs(reader)) {
3373 return false;
3374 }
3375 return true;
3376}
3377
3379{
3380 std::string tag = reader.readTag(s_tag_len);
3381 if (reader.isError()) {
3382 return false;
3383 }
3384 if (tag != s_tag) {
3385 reader.fail();
3386 return false;
3387 }
3388 return true;
3389}
3390
3392{
3393 if (!reader.noMore()) {
3394 reader.fail();
3395 return false;
3396 }
3397 return true;
3398}
3399
3401{
3402 yarp::os::idl::WireWriter writer(connection);
3403 return write(writer);
3404}
3405
3407{
3408 yarp::os::idl::WireReader reader(connection);
3409 return read(reader);
3410}
3411
3413{
3414 if (!writer.isNull()) {
3415 if (!writer.writeListHeader(s_reply_len)) {
3416 return false;
3417 }
3418 if (!writer.write(return_helper)) {
3419 return false;
3420 }
3421 }
3422 return true;
3423}
3424
3426{
3427 if (!reader.readListReturn()) {
3428 return false;
3429 }
3430 if (reader.noMore()) {
3431 reader.fail();
3432 return false;
3433 }
3434 if (!reader.read(return_helper)) {
3435 reader.fail();
3436 return false;
3437 }
3438 return true;
3439}
3440
3445
3446// getSensorStatusRPC helper class implementation
3448{
3449 return cmd.write(connection);
3450}
3451
3453{
3454 return reply.read(connection);
3455}
3456
3458{
3459 yarp::os::idl::WireWriter writer(connection);
3460 if (!writer.writeListHeader(s_cmd_len)) {
3461 return false;
3462 }
3463 return write(writer);
3464}
3465
3467{
3468 yarp::os::idl::WireReader reader(connection);
3469 if (!reader.readListHeader()) {
3470 reader.fail();
3471 return false;
3472 }
3473 return read(reader);
3474}
3475
3477{
3478 if (!writeTag(writer)) {
3479 return false;
3480 }
3481 if (!writeArgs(writer)) {
3482 return false;
3483 }
3484 return true;
3485}
3486
3488{
3489 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3490 return false;
3491 }
3492 return true;
3493}
3494
3496{
3497 return true;
3498}
3499
3501{
3502 if (!readTag(reader)) {
3503 return false;
3504 }
3505 if (!readArgs(reader)) {
3506 return false;
3507 }
3508 return true;
3509}
3510
3512{
3513 std::string tag = reader.readTag(s_tag_len);
3514 if (reader.isError()) {
3515 return false;
3516 }
3517 if (tag != s_tag) {
3518 reader.fail();
3519 return false;
3520 }
3521 return true;
3522}
3523
3525{
3526 if (!reader.noMore()) {
3527 reader.fail();
3528 return false;
3529 }
3530 return true;
3531}
3532
3534{
3535 yarp::os::idl::WireWriter writer(connection);
3536 return write(writer);
3537}
3538
3540{
3541 yarp::os::idl::WireReader reader(connection);
3542 return read(reader);
3543}
3544
3546{
3547 if (!writer.isNull()) {
3548 if (!writer.writeListHeader(s_reply_len)) {
3549 return false;
3550 }
3551 if (!writer.write(return_helper)) {
3552 return false;
3553 }
3554 }
3555 return true;
3556}
3557
3559{
3560 if (!reader.readListReturn()) {
3561 return false;
3562 }
3563 if (reader.noMore()) {
3564 reader.fail();
3565 return false;
3566 }
3567 if (!reader.read(return_helper)) {
3568 reader.fail();
3569 return false;
3570 }
3571 return true;
3572}
3573
3578
3579// getRgbWidthRPC helper class implementation
3581{
3582 return cmd.write(connection);
3583}
3584
3586{
3587 return reply.read(connection);
3588}
3589
3591{
3592 yarp::os::idl::WireWriter writer(connection);
3593 if (!writer.writeListHeader(s_cmd_len)) {
3594 return false;
3595 }
3596 return write(writer);
3597}
3598
3600{
3601 yarp::os::idl::WireReader reader(connection);
3602 if (!reader.readListHeader()) {
3603 reader.fail();
3604 return false;
3605 }
3606 return read(reader);
3607}
3608
3610{
3611 if (!writeTag(writer)) {
3612 return false;
3613 }
3614 if (!writeArgs(writer)) {
3615 return false;
3616 }
3617 return true;
3618}
3619
3621{
3622 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3623 return false;
3624 }
3625 return true;
3626}
3627
3629{
3630 return true;
3631}
3632
3634{
3635 if (!readTag(reader)) {
3636 return false;
3637 }
3638 if (!readArgs(reader)) {
3639 return false;
3640 }
3641 return true;
3642}
3643
3645{
3646 std::string tag = reader.readTag(s_tag_len);
3647 if (reader.isError()) {
3648 return false;
3649 }
3650 if (tag != s_tag) {
3651 reader.fail();
3652 return false;
3653 }
3654 return true;
3655}
3656
3658{
3659 if (!reader.noMore()) {
3660 reader.fail();
3661 return false;
3662 }
3663 return true;
3664}
3665
3667{
3668 yarp::os::idl::WireWriter writer(connection);
3669 return write(writer);
3670}
3671
3673{
3674 yarp::os::idl::WireReader reader(connection);
3675 return read(reader);
3676}
3677
3679{
3680 if (!writer.isNull()) {
3681 if (!writer.writeListHeader(s_reply_len)) {
3682 return false;
3683 }
3684 if (!writer.write(return_helper)) {
3685 return false;
3686 }
3687 }
3688 return true;
3689}
3690
3692{
3693 if (!reader.readListReturn()) {
3694 return false;
3695 }
3696 if (reader.noMore()) {
3697 reader.fail();
3698 return false;
3699 }
3700 if (!reader.read(return_helper)) {
3701 reader.fail();
3702 return false;
3703 }
3704 return true;
3705}
3706
3711
3712// getRgbHeightRPC helper class implementation
3714{
3715 return cmd.write(connection);
3716}
3717
3719{
3720 return reply.read(connection);
3721}
3722
3724{
3725 yarp::os::idl::WireWriter writer(connection);
3726 if (!writer.writeListHeader(s_cmd_len)) {
3727 return false;
3728 }
3729 return write(writer);
3730}
3731
3733{
3734 yarp::os::idl::WireReader reader(connection);
3735 if (!reader.readListHeader()) {
3736 reader.fail();
3737 return false;
3738 }
3739 return read(reader);
3740}
3741
3743{
3744 if (!writeTag(writer)) {
3745 return false;
3746 }
3747 if (!writeArgs(writer)) {
3748 return false;
3749 }
3750 return true;
3751}
3752
3754{
3755 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3756 return false;
3757 }
3758 return true;
3759}
3760
3762{
3763 return true;
3764}
3765
3767{
3768 if (!readTag(reader)) {
3769 return false;
3770 }
3771 if (!readArgs(reader)) {
3772 return false;
3773 }
3774 return true;
3775}
3776
3778{
3779 std::string tag = reader.readTag(s_tag_len);
3780 if (reader.isError()) {
3781 return false;
3782 }
3783 if (tag != s_tag) {
3784 reader.fail();
3785 return false;
3786 }
3787 return true;
3788}
3789
3791{
3792 if (!reader.noMore()) {
3793 reader.fail();
3794 return false;
3795 }
3796 return true;
3797}
3798
3800{
3801 yarp::os::idl::WireWriter writer(connection);
3802 return write(writer);
3803}
3804
3806{
3807 yarp::os::idl::WireReader reader(connection);
3808 return read(reader);
3809}
3810
3812{
3813 if (!writer.isNull()) {
3814 if (!writer.writeListHeader(s_reply_len)) {
3815 return false;
3816 }
3817 if (!writer.write(return_helper)) {
3818 return false;
3819 }
3820 }
3821 return true;
3822}
3823
3825{
3826 if (!reader.readListReturn()) {
3827 return false;
3828 }
3829 if (reader.noMore()) {
3830 reader.fail();
3831 return false;
3832 }
3833 if (!reader.read(return_helper)) {
3834 reader.fail();
3835 return false;
3836 }
3837 return true;
3838}
3839
3844
3845// getRgbSupportedConfigurationsRPC helper class implementation
3850
3855
3857{
3858 yarp::os::idl::WireWriter writer(connection);
3859 if (!writer.writeListHeader(s_cmd_len)) {
3860 return false;
3861 }
3862 return write(writer);
3863}
3864
3866{
3867 yarp::os::idl::WireReader reader(connection);
3868 if (!reader.readListHeader()) {
3869 reader.fail();
3870 return false;
3871 }
3872 return read(reader);
3873}
3874
3876{
3877 if (!writeTag(writer)) {
3878 return false;
3879 }
3880 if (!writeArgs(writer)) {
3881 return false;
3882 }
3883 return true;
3884}
3885
3887{
3888 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3889 return false;
3890 }
3891 return true;
3892}
3893
3895{
3896 return true;
3897}
3898
3900{
3901 if (!readTag(reader)) {
3902 return false;
3903 }
3904 if (!readArgs(reader)) {
3905 return false;
3906 }
3907 return true;
3908}
3909
3911{
3912 std::string tag = reader.readTag(s_tag_len);
3913 if (reader.isError()) {
3914 return false;
3915 }
3916 if (tag != s_tag) {
3917 reader.fail();
3918 return false;
3919 }
3920 return true;
3921}
3922
3924{
3925 if (!reader.noMore()) {
3926 reader.fail();
3927 return false;
3928 }
3929 return true;
3930}
3931
3933{
3934 yarp::os::idl::WireWriter writer(connection);
3935 return write(writer);
3936}
3937
3943
3945{
3946 if (!writer.isNull()) {
3947 if (!writer.writeListHeader(s_reply_len)) {
3948 return false;
3949 }
3950 if (!writer.write(return_helper)) {
3951 return false;
3952 }
3953 }
3954 return true;
3955}
3956
3958{
3959 if (!reader.readListReturn()) {
3960 return false;
3961 }
3962 if (reader.noMore()) {
3963 reader.fail();
3964 return false;
3965 }
3966 if (!reader.read(return_helper)) {
3967 reader.fail();
3968 return false;
3969 }
3970 return true;
3971}
3972
3977
3978// getRgbResolutionRPC helper class implementation
3980{
3981 return cmd.write(connection);
3982}
3983
3985{
3986 return reply.read(connection);
3987}
3988
3990{
3991 yarp::os::idl::WireWriter writer(connection);
3992 if (!writer.writeListHeader(s_cmd_len)) {
3993 return false;
3994 }
3995 return write(writer);
3996}
3997
3999{
4000 yarp::os::idl::WireReader reader(connection);
4001 if (!reader.readListHeader()) {
4002 reader.fail();
4003 return false;
4004 }
4005 return read(reader);
4006}
4007
4009{
4010 if (!writeTag(writer)) {
4011 return false;
4012 }
4013 if (!writeArgs(writer)) {
4014 return false;
4015 }
4016 return true;
4017}
4018
4020{
4021 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4022 return false;
4023 }
4024 return true;
4025}
4026
4028{
4029 return true;
4030}
4031
4033{
4034 if (!readTag(reader)) {
4035 return false;
4036 }
4037 if (!readArgs(reader)) {
4038 return false;
4039 }
4040 return true;
4041}
4042
4044{
4045 std::string tag = reader.readTag(s_tag_len);
4046 if (reader.isError()) {
4047 return false;
4048 }
4049 if (tag != s_tag) {
4050 reader.fail();
4051 return false;
4052 }
4053 return true;
4054}
4055
4057{
4058 if (!reader.noMore()) {
4059 reader.fail();
4060 return false;
4061 }
4062 return true;
4063}
4064
4066{
4067 yarp::os::idl::WireWriter writer(connection);
4068 return write(writer);
4069}
4070
4072{
4073 yarp::os::idl::WireReader reader(connection);
4074 return read(reader);
4075}
4076
4078{
4079 if (!writer.isNull()) {
4080 if (!writer.writeListHeader(s_reply_len)) {
4081 return false;
4082 }
4083 if (!writer.write(return_helper)) {
4084 return false;
4085 }
4086 }
4087 return true;
4088}
4089
4091{
4092 if (!reader.readListReturn()) {
4093 return false;
4094 }
4095 if (reader.noMore()) {
4096 reader.fail();
4097 return false;
4098 }
4099 if (!reader.read(return_helper)) {
4100 reader.fail();
4101 return false;
4102 }
4103 return true;
4104}
4105
4110
4111// setRgbResolutionRPC helper class implementation
4113 cmd{width, height}
4114{
4115}
4116
4118{
4119 return cmd.write(connection);
4120}
4121
4123{
4124 return reply.read(connection);
4125}
4126
4127RGBDSensorMsgs_setRgbResolutionRPC_helper::Command::Command(const std::int32_t width, const std::int32_t height) :
4128 width{width},
4129 height{height}
4130{
4131}
4132
4134{
4135 yarp::os::idl::WireWriter writer(connection);
4136 if (!writer.writeListHeader(s_cmd_len)) {
4137 return false;
4138 }
4139 return write(writer);
4140}
4141
4143{
4144 yarp::os::idl::WireReader reader(connection);
4145 if (!reader.readListHeader()) {
4146 reader.fail();
4147 return false;
4148 }
4149 return read(reader);
4150}
4151
4153{
4154 if (!writeTag(writer)) {
4155 return false;
4156 }
4157 if (!writeArgs(writer)) {
4158 return false;
4159 }
4160 return true;
4161}
4162
4164{
4165 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4166 return false;
4167 }
4168 return true;
4169}
4170
4172{
4173 if (!writer.writeI32(width)) {
4174 return false;
4175 }
4176 if (!writer.writeI32(height)) {
4177 return false;
4178 }
4179 return true;
4180}
4181
4183{
4184 if (!readTag(reader)) {
4185 return false;
4186 }
4187 if (!readArgs(reader)) {
4188 return false;
4189 }
4190 return true;
4191}
4192
4194{
4195 std::string tag = reader.readTag(s_tag_len);
4196 if (reader.isError()) {
4197 return false;
4198 }
4199 if (tag != s_tag) {
4200 reader.fail();
4201 return false;
4202 }
4203 return true;
4204}
4205
4207{
4208 if (reader.noMore()) {
4209 reader.fail();
4210 return false;
4211 }
4212 if (!reader.readI32(width)) {
4213 reader.fail();
4214 return false;
4215 }
4216 if (reader.noMore()) {
4217 reader.fail();
4218 return false;
4219 }
4220 if (!reader.readI32(height)) {
4221 reader.fail();
4222 return false;
4223 }
4224 if (!reader.noMore()) {
4225 reader.fail();
4226 return false;
4227 }
4228 return true;
4229}
4230
4232{
4233 yarp::os::idl::WireWriter writer(connection);
4234 return write(writer);
4235}
4236
4238{
4239 yarp::os::idl::WireReader reader(connection);
4240 return read(reader);
4241}
4242
4244{
4245 if (!writer.isNull()) {
4246 if (!writer.write(return_helper)) {
4247 return false;
4248 }
4249 }
4250 return true;
4251}
4252
4254{
4255 if (reader.noMore()) {
4256 reader.fail();
4257 return false;
4258 }
4259 if (!reader.read(return_helper)) {
4260 reader.fail();
4261 return false;
4262 }
4263 return true;
4264}
4265
4270
4271// getRgbFOVRPC helper class implementation
4273{
4274 return cmd.write(connection);
4275}
4276
4278{
4279 return reply.read(connection);
4280}
4281
4283{
4284 yarp::os::idl::WireWriter writer(connection);
4285 if (!writer.writeListHeader(s_cmd_len)) {
4286 return false;
4287 }
4288 return write(writer);
4289}
4290
4292{
4293 yarp::os::idl::WireReader reader(connection);
4294 if (!reader.readListHeader()) {
4295 reader.fail();
4296 return false;
4297 }
4298 return read(reader);
4299}
4300
4302{
4303 if (!writeTag(writer)) {
4304 return false;
4305 }
4306 if (!writeArgs(writer)) {
4307 return false;
4308 }
4309 return true;
4310}
4311
4313{
4314 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4315 return false;
4316 }
4317 return true;
4318}
4319
4321{
4322 return true;
4323}
4324
4326{
4327 if (!readTag(reader)) {
4328 return false;
4329 }
4330 if (!readArgs(reader)) {
4331 return false;
4332 }
4333 return true;
4334}
4335
4337{
4338 std::string tag = reader.readTag(s_tag_len);
4339 if (reader.isError()) {
4340 return false;
4341 }
4342 if (tag != s_tag) {
4343 reader.fail();
4344 return false;
4345 }
4346 return true;
4347}
4348
4350{
4351 if (!reader.noMore()) {
4352 reader.fail();
4353 return false;
4354 }
4355 return true;
4356}
4357
4359{
4360 yarp::os::idl::WireWriter writer(connection);
4361 return write(writer);
4362}
4363
4365{
4366 yarp::os::idl::WireReader reader(connection);
4367 return read(reader);
4368}
4369
4371{
4372 if (!writer.isNull()) {
4373 if (!writer.writeListHeader(s_reply_len)) {
4374 return false;
4375 }
4376 if (!writer.write(return_helper)) {
4377 return false;
4378 }
4379 }
4380 return true;
4381}
4382
4384{
4385 if (!reader.readListReturn()) {
4386 return false;
4387 }
4388 if (reader.noMore()) {
4389 reader.fail();
4390 return false;
4391 }
4392 if (!reader.read(return_helper)) {
4393 reader.fail();
4394 return false;
4395 }
4396 return true;
4397}
4398
4403
4404// setRgbFOVRPC helper class implementation
4405RGBDSensorMsgs_setRgbFOVRPC_helper::RGBDSensorMsgs_setRgbFOVRPC_helper(const double horizontalFov, const double verticalFov) :
4406 cmd{horizontalFov, verticalFov}
4407{
4408}
4409
4411{
4412 return cmd.write(connection);
4413}
4414
4416{
4417 return reply.read(connection);
4418}
4419
4420RGBDSensorMsgs_setRgbFOVRPC_helper::Command::Command(const double horizontalFov, const double verticalFov) :
4421 horizontalFov{horizontalFov},
4422 verticalFov{verticalFov}
4423{
4424}
4425
4427{
4428 yarp::os::idl::WireWriter writer(connection);
4429 if (!writer.writeListHeader(s_cmd_len)) {
4430 return false;
4431 }
4432 return write(writer);
4433}
4434
4436{
4437 yarp::os::idl::WireReader reader(connection);
4438 if (!reader.readListHeader()) {
4439 reader.fail();
4440 return false;
4441 }
4442 return read(reader);
4443}
4444
4446{
4447 if (!writeTag(writer)) {
4448 return false;
4449 }
4450 if (!writeArgs(writer)) {
4451 return false;
4452 }
4453 return true;
4454}
4455
4457{
4458 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4459 return false;
4460 }
4461 return true;
4462}
4463
4465{
4466 if (!writer.writeFloat64(horizontalFov)) {
4467 return false;
4468 }
4469 if (!writer.writeFloat64(verticalFov)) {
4470 return false;
4471 }
4472 return true;
4473}
4474
4476{
4477 if (!readTag(reader)) {
4478 return false;
4479 }
4480 if (!readArgs(reader)) {
4481 return false;
4482 }
4483 return true;
4484}
4485
4487{
4488 std::string tag = reader.readTag(s_tag_len);
4489 if (reader.isError()) {
4490 return false;
4491 }
4492 if (tag != s_tag) {
4493 reader.fail();
4494 return false;
4495 }
4496 return true;
4497}
4498
4500{
4501 if (reader.noMore()) {
4502 reader.fail();
4503 return false;
4504 }
4505 if (!reader.readFloat64(horizontalFov)) {
4506 reader.fail();
4507 return false;
4508 }
4509 if (reader.noMore()) {
4510 reader.fail();
4511 return false;
4512 }
4513 if (!reader.readFloat64(verticalFov)) {
4514 reader.fail();
4515 return false;
4516 }
4517 if (!reader.noMore()) {
4518 reader.fail();
4519 return false;
4520 }
4521 return true;
4522}
4523
4525{
4526 yarp::os::idl::WireWriter writer(connection);
4527 return write(writer);
4528}
4529
4531{
4532 yarp::os::idl::WireReader reader(connection);
4533 return read(reader);
4534}
4535
4537{
4538 if (!writer.isNull()) {
4539 if (!writer.write(return_helper)) {
4540 return false;
4541 }
4542 }
4543 return true;
4544}
4545
4547{
4548 if (reader.noMore()) {
4549 reader.fail();
4550 return false;
4551 }
4552 if (!reader.read(return_helper)) {
4553 reader.fail();
4554 return false;
4555 }
4556 return true;
4557}
4558
4563
4564// getRgbIntrinsicParamRPC helper class implementation
4566{
4567 return cmd.write(connection);
4568}
4569
4574
4576{
4577 yarp::os::idl::WireWriter writer(connection);
4578 if (!writer.writeListHeader(s_cmd_len)) {
4579 return false;
4580 }
4581 return write(writer);
4582}
4583
4585{
4586 yarp::os::idl::WireReader reader(connection);
4587 if (!reader.readListHeader()) {
4588 reader.fail();
4589 return false;
4590 }
4591 return read(reader);
4592}
4593
4595{
4596 if (!writeTag(writer)) {
4597 return false;
4598 }
4599 if (!writeArgs(writer)) {
4600 return false;
4601 }
4602 return true;
4603}
4604
4606{
4607 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4608 return false;
4609 }
4610 return true;
4611}
4612
4614{
4615 return true;
4616}
4617
4619{
4620 if (!readTag(reader)) {
4621 return false;
4622 }
4623 if (!readArgs(reader)) {
4624 return false;
4625 }
4626 return true;
4627}
4628
4630{
4631 std::string tag = reader.readTag(s_tag_len);
4632 if (reader.isError()) {
4633 return false;
4634 }
4635 if (tag != s_tag) {
4636 reader.fail();
4637 return false;
4638 }
4639 return true;
4640}
4641
4643{
4644 if (!reader.noMore()) {
4645 reader.fail();
4646 return false;
4647 }
4648 return true;
4649}
4650
4652{
4653 yarp::os::idl::WireWriter writer(connection);
4654 return write(writer);
4655}
4656
4658{
4659 yarp::os::idl::WireReader reader(connection);
4660 return read(reader);
4661}
4662
4664{
4665 if (!writer.isNull()) {
4666 if (!writer.writeListHeader(s_reply_len)) {
4667 return false;
4668 }
4669 if (!writer.write(return_helper)) {
4670 return false;
4671 }
4672 }
4673 return true;
4674}
4675
4677{
4678 if (!reader.readListReturn()) {
4679 return false;
4680 }
4681 if (reader.noMore()) {
4682 reader.fail();
4683 return false;
4684 }
4685 if (!reader.read(return_helper)) {
4686 reader.fail();
4687 return false;
4688 }
4689 return true;
4690}
4691
4696
4697// getRgbMirroringRPC helper class implementation
4699{
4700 return cmd.write(connection);
4701}
4702
4704{
4705 return reply.read(connection);
4706}
4707
4709{
4710 yarp::os::idl::WireWriter writer(connection);
4711 if (!writer.writeListHeader(s_cmd_len)) {
4712 return false;
4713 }
4714 return write(writer);
4715}
4716
4718{
4719 yarp::os::idl::WireReader reader(connection);
4720 if (!reader.readListHeader()) {
4721 reader.fail();
4722 return false;
4723 }
4724 return read(reader);
4725}
4726
4728{
4729 if (!writeTag(writer)) {
4730 return false;
4731 }
4732 if (!writeArgs(writer)) {
4733 return false;
4734 }
4735 return true;
4736}
4737
4739{
4740 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4741 return false;
4742 }
4743 return true;
4744}
4745
4747{
4748 return true;
4749}
4750
4752{
4753 if (!readTag(reader)) {
4754 return false;
4755 }
4756 if (!readArgs(reader)) {
4757 return false;
4758 }
4759 return true;
4760}
4761
4763{
4764 std::string tag = reader.readTag(s_tag_len);
4765 if (reader.isError()) {
4766 return false;
4767 }
4768 if (tag != s_tag) {
4769 reader.fail();
4770 return false;
4771 }
4772 return true;
4773}
4774
4776{
4777 if (!reader.noMore()) {
4778 reader.fail();
4779 return false;
4780 }
4781 return true;
4782}
4783
4785{
4786 yarp::os::idl::WireWriter writer(connection);
4787 return write(writer);
4788}
4789
4791{
4792 yarp::os::idl::WireReader reader(connection);
4793 return read(reader);
4794}
4795
4797{
4798 if (!writer.isNull()) {
4799 if (!writer.writeListHeader(s_reply_len)) {
4800 return false;
4801 }
4802 if (!writer.write(return_helper)) {
4803 return false;
4804 }
4805 }
4806 return true;
4807}
4808
4810{
4811 if (!reader.readListReturn()) {
4812 return false;
4813 }
4814 if (reader.noMore()) {
4815 reader.fail();
4816 return false;
4817 }
4818 if (!reader.read(return_helper)) {
4819 reader.fail();
4820 return false;
4821 }
4822 return true;
4823}
4824
4829
4830// setRgbMirroringRPC helper class implementation
4835
4837{
4838 return cmd.write(connection);
4839}
4840
4842{
4843 return reply.read(connection);
4844}
4845
4847 mirror{mirror}
4848{
4849}
4850
4852{
4853 yarp::os::idl::WireWriter writer(connection);
4854 if (!writer.writeListHeader(s_cmd_len)) {
4855 return false;
4856 }
4857 return write(writer);
4858}
4859
4861{
4862 yarp::os::idl::WireReader reader(connection);
4863 if (!reader.readListHeader()) {
4864 reader.fail();
4865 return false;
4866 }
4867 return read(reader);
4868}
4869
4871{
4872 if (!writeTag(writer)) {
4873 return false;
4874 }
4875 if (!writeArgs(writer)) {
4876 return false;
4877 }
4878 return true;
4879}
4880
4882{
4883 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4884 return false;
4885 }
4886 return true;
4887}
4888
4890{
4891 if (!writer.writeBool(mirror)) {
4892 return false;
4893 }
4894 return true;
4895}
4896
4898{
4899 if (!readTag(reader)) {
4900 return false;
4901 }
4902 if (!readArgs(reader)) {
4903 return false;
4904 }
4905 return true;
4906}
4907
4909{
4910 std::string tag = reader.readTag(s_tag_len);
4911 if (reader.isError()) {
4912 return false;
4913 }
4914 if (tag != s_tag) {
4915 reader.fail();
4916 return false;
4917 }
4918 return true;
4919}
4920
4922{
4923 if (reader.noMore()) {
4924 reader.fail();
4925 return false;
4926 }
4927 if (!reader.readBool(mirror)) {
4928 reader.fail();
4929 return false;
4930 }
4931 if (!reader.noMore()) {
4932 reader.fail();
4933 return false;
4934 }
4935 return true;
4936}
4937
4939{
4940 yarp::os::idl::WireWriter writer(connection);
4941 return write(writer);
4942}
4943
4945{
4946 yarp::os::idl::WireReader reader(connection);
4947 return read(reader);
4948}
4949
4951{
4952 if (!writer.isNull()) {
4953 if (!writer.write(return_helper)) {
4954 return false;
4955 }
4956 }
4957 return true;
4958}
4959
4961{
4962 if (reader.noMore()) {
4963 reader.fail();
4964 return false;
4965 }
4966 if (!reader.read(return_helper)) {
4967 reader.fail();
4968 return false;
4969 }
4970 return true;
4971}
4972
4977
4978// getDepthWidthRPC helper class implementation
4980{
4981 return cmd.write(connection);
4982}
4983
4985{
4986 return reply.read(connection);
4987}
4988
4990{
4991 yarp::os::idl::WireWriter writer(connection);
4992 if (!writer.writeListHeader(s_cmd_len)) {
4993 return false;
4994 }
4995 return write(writer);
4996}
4997
4999{
5000 yarp::os::idl::WireReader reader(connection);
5001 if (!reader.readListHeader()) {
5002 reader.fail();
5003 return false;
5004 }
5005 return read(reader);
5006}
5007
5009{
5010 if (!writeTag(writer)) {
5011 return false;
5012 }
5013 if (!writeArgs(writer)) {
5014 return false;
5015 }
5016 return true;
5017}
5018
5020{
5021 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5022 return false;
5023 }
5024 return true;
5025}
5026
5028{
5029 return true;
5030}
5031
5033{
5034 if (!readTag(reader)) {
5035 return false;
5036 }
5037 if (!readArgs(reader)) {
5038 return false;
5039 }
5040 return true;
5041}
5042
5044{
5045 std::string tag = reader.readTag(s_tag_len);
5046 if (reader.isError()) {
5047 return false;
5048 }
5049 if (tag != s_tag) {
5050 reader.fail();
5051 return false;
5052 }
5053 return true;
5054}
5055
5057{
5058 if (!reader.noMore()) {
5059 reader.fail();
5060 return false;
5061 }
5062 return true;
5063}
5064
5066{
5067 yarp::os::idl::WireWriter writer(connection);
5068 return write(writer);
5069}
5070
5072{
5073 yarp::os::idl::WireReader reader(connection);
5074 return read(reader);
5075}
5076
5078{
5079 if (!writer.isNull()) {
5080 if (!writer.writeListHeader(s_reply_len)) {
5081 return false;
5082 }
5083 if (!writer.write(return_helper)) {
5084 return false;
5085 }
5086 }
5087 return true;
5088}
5089
5091{
5092 if (!reader.readListReturn()) {
5093 return false;
5094 }
5095 if (reader.noMore()) {
5096 reader.fail();
5097 return false;
5098 }
5099 if (!reader.read(return_helper)) {
5100 reader.fail();
5101 return false;
5102 }
5103 return true;
5104}
5105
5110
5111// getDepthHeightRPC helper class implementation
5113{
5114 return cmd.write(connection);
5115}
5116
5118{
5119 return reply.read(connection);
5120}
5121
5123{
5124 yarp::os::idl::WireWriter writer(connection);
5125 if (!writer.writeListHeader(s_cmd_len)) {
5126 return false;
5127 }
5128 return write(writer);
5129}
5130
5132{
5133 yarp::os::idl::WireReader reader(connection);
5134 if (!reader.readListHeader()) {
5135 reader.fail();
5136 return false;
5137 }
5138 return read(reader);
5139}
5140
5142{
5143 if (!writeTag(writer)) {
5144 return false;
5145 }
5146 if (!writeArgs(writer)) {
5147 return false;
5148 }
5149 return true;
5150}
5151
5153{
5154 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5155 return false;
5156 }
5157 return true;
5158}
5159
5161{
5162 return true;
5163}
5164
5166{
5167 if (!readTag(reader)) {
5168 return false;
5169 }
5170 if (!readArgs(reader)) {
5171 return false;
5172 }
5173 return true;
5174}
5175
5177{
5178 std::string tag = reader.readTag(s_tag_len);
5179 if (reader.isError()) {
5180 return false;
5181 }
5182 if (tag != s_tag) {
5183 reader.fail();
5184 return false;
5185 }
5186 return true;
5187}
5188
5190{
5191 if (!reader.noMore()) {
5192 reader.fail();
5193 return false;
5194 }
5195 return true;
5196}
5197
5199{
5200 yarp::os::idl::WireWriter writer(connection);
5201 return write(writer);
5202}
5203
5205{
5206 yarp::os::idl::WireReader reader(connection);
5207 return read(reader);
5208}
5209
5211{
5212 if (!writer.isNull()) {
5213 if (!writer.writeListHeader(s_reply_len)) {
5214 return false;
5215 }
5216 if (!writer.write(return_helper)) {
5217 return false;
5218 }
5219 }
5220 return true;
5221}
5222
5224{
5225 if (!reader.readListReturn()) {
5226 return false;
5227 }
5228 if (reader.noMore()) {
5229 reader.fail();
5230 return false;
5231 }
5232 if (!reader.read(return_helper)) {
5233 reader.fail();
5234 return false;
5235 }
5236 return true;
5237}
5238
5243
5244// getDepthResolutionRPC helper class implementation
5246{
5247 return cmd.write(connection);
5248}
5249
5254
5256{
5257 yarp::os::idl::WireWriter writer(connection);
5258 if (!writer.writeListHeader(s_cmd_len)) {
5259 return false;
5260 }
5261 return write(writer);
5262}
5263
5265{
5266 yarp::os::idl::WireReader reader(connection);
5267 if (!reader.readListHeader()) {
5268 reader.fail();
5269 return false;
5270 }
5271 return read(reader);
5272}
5273
5275{
5276 if (!writeTag(writer)) {
5277 return false;
5278 }
5279 if (!writeArgs(writer)) {
5280 return false;
5281 }
5282 return true;
5283}
5284
5286{
5287 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5288 return false;
5289 }
5290 return true;
5291}
5292
5294{
5295 return true;
5296}
5297
5299{
5300 if (!readTag(reader)) {
5301 return false;
5302 }
5303 if (!readArgs(reader)) {
5304 return false;
5305 }
5306 return true;
5307}
5308
5310{
5311 std::string tag = reader.readTag(s_tag_len);
5312 if (reader.isError()) {
5313 return false;
5314 }
5315 if (tag != s_tag) {
5316 reader.fail();
5317 return false;
5318 }
5319 return true;
5320}
5321
5323{
5324 if (!reader.noMore()) {
5325 reader.fail();
5326 return false;
5327 }
5328 return true;
5329}
5330
5332{
5333 yarp::os::idl::WireWriter writer(connection);
5334 return write(writer);
5335}
5336
5338{
5339 yarp::os::idl::WireReader reader(connection);
5340 return read(reader);
5341}
5342
5344{
5345 if (!writer.isNull()) {
5346 if (!writer.writeListHeader(s_reply_len)) {
5347 return false;
5348 }
5349 if (!writer.write(return_helper)) {
5350 return false;
5351 }
5352 }
5353 return true;
5354}
5355
5357{
5358 if (!reader.readListReturn()) {
5359 return false;
5360 }
5361 if (reader.noMore()) {
5362 reader.fail();
5363 return false;
5364 }
5365 if (!reader.read(return_helper)) {
5366 reader.fail();
5367 return false;
5368 }
5369 return true;
5370}
5371
5376
5377// setDepthResolutionRPC helper class implementation
5379 cmd{width, height}
5380{
5381}
5382
5384{
5385 return cmd.write(connection);
5386}
5387
5392
5393RGBDSensorMsgs_setDepthResolutionRPC_helper::Command::Command(const std::int32_t width, const std::int32_t height) :
5394 width{width},
5395 height{height}
5396{
5397}
5398
5400{
5401 yarp::os::idl::WireWriter writer(connection);
5402 if (!writer.writeListHeader(s_cmd_len)) {
5403 return false;
5404 }
5405 return write(writer);
5406}
5407
5409{
5410 yarp::os::idl::WireReader reader(connection);
5411 if (!reader.readListHeader()) {
5412 reader.fail();
5413 return false;
5414 }
5415 return read(reader);
5416}
5417
5419{
5420 if (!writeTag(writer)) {
5421 return false;
5422 }
5423 if (!writeArgs(writer)) {
5424 return false;
5425 }
5426 return true;
5427}
5428
5430{
5431 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5432 return false;
5433 }
5434 return true;
5435}
5436
5438{
5439 if (!writer.writeI32(width)) {
5440 return false;
5441 }
5442 if (!writer.writeI32(height)) {
5443 return false;
5444 }
5445 return true;
5446}
5447
5449{
5450 if (!readTag(reader)) {
5451 return false;
5452 }
5453 if (!readArgs(reader)) {
5454 return false;
5455 }
5456 return true;
5457}
5458
5460{
5461 std::string tag = reader.readTag(s_tag_len);
5462 if (reader.isError()) {
5463 return false;
5464 }
5465 if (tag != s_tag) {
5466 reader.fail();
5467 return false;
5468 }
5469 return true;
5470}
5471
5473{
5474 if (reader.noMore()) {
5475 reader.fail();
5476 return false;
5477 }
5478 if (!reader.readI32(width)) {
5479 reader.fail();
5480 return false;
5481 }
5482 if (reader.noMore()) {
5483 reader.fail();
5484 return false;
5485 }
5486 if (!reader.readI32(height)) {
5487 reader.fail();
5488 return false;
5489 }
5490 if (!reader.noMore()) {
5491 reader.fail();
5492 return false;
5493 }
5494 return true;
5495}
5496
5498{
5499 yarp::os::idl::WireWriter writer(connection);
5500 return write(writer);
5501}
5502
5504{
5505 yarp::os::idl::WireReader reader(connection);
5506 return read(reader);
5507}
5508
5510{
5511 if (!writer.isNull()) {
5512 if (!writer.write(return_helper)) {
5513 return false;
5514 }
5515 }
5516 return true;
5517}
5518
5520{
5521 if (reader.noMore()) {
5522 reader.fail();
5523 return false;
5524 }
5525 if (!reader.read(return_helper)) {
5526 reader.fail();
5527 return false;
5528 }
5529 return true;
5530}
5531
5536
5537// getDepthFOVRPC helper class implementation
5539{
5540 return cmd.write(connection);
5541}
5542
5544{
5545 return reply.read(connection);
5546}
5547
5549{
5550 yarp::os::idl::WireWriter writer(connection);
5551 if (!writer.writeListHeader(s_cmd_len)) {
5552 return false;
5553 }
5554 return write(writer);
5555}
5556
5558{
5559 yarp::os::idl::WireReader reader(connection);
5560 if (!reader.readListHeader()) {
5561 reader.fail();
5562 return false;
5563 }
5564 return read(reader);
5565}
5566
5568{
5569 if (!writeTag(writer)) {
5570 return false;
5571 }
5572 if (!writeArgs(writer)) {
5573 return false;
5574 }
5575 return true;
5576}
5577
5579{
5580 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5581 return false;
5582 }
5583 return true;
5584}
5585
5587{
5588 return true;
5589}
5590
5592{
5593 if (!readTag(reader)) {
5594 return false;
5595 }
5596 if (!readArgs(reader)) {
5597 return false;
5598 }
5599 return true;
5600}
5601
5603{
5604 std::string tag = reader.readTag(s_tag_len);
5605 if (reader.isError()) {
5606 return false;
5607 }
5608 if (tag != s_tag) {
5609 reader.fail();
5610 return false;
5611 }
5612 return true;
5613}
5614
5616{
5617 if (!reader.noMore()) {
5618 reader.fail();
5619 return false;
5620 }
5621 return true;
5622}
5623
5625{
5626 yarp::os::idl::WireWriter writer(connection);
5627 return write(writer);
5628}
5629
5631{
5632 yarp::os::idl::WireReader reader(connection);
5633 return read(reader);
5634}
5635
5637{
5638 if (!writer.isNull()) {
5639 if (!writer.writeListHeader(s_reply_len)) {
5640 return false;
5641 }
5642 if (!writer.write(return_helper)) {
5643 return false;
5644 }
5645 }
5646 return true;
5647}
5648
5650{
5651 if (!reader.readListReturn()) {
5652 return false;
5653 }
5654 if (reader.noMore()) {
5655 reader.fail();
5656 return false;
5657 }
5658 if (!reader.read(return_helper)) {
5659 reader.fail();
5660 return false;
5661 }
5662 return true;
5663}
5664
5669
5670// setDepthFOVRPC helper class implementation
5671RGBDSensorMsgs_setDepthFOVRPC_helper::RGBDSensorMsgs_setDepthFOVRPC_helper(const double horizontalFov, const double verticalFov) :
5672 cmd{horizontalFov, verticalFov}
5673{
5674}
5675
5677{
5678 return cmd.write(connection);
5679}
5680
5682{
5683 return reply.read(connection);
5684}
5685
5686RGBDSensorMsgs_setDepthFOVRPC_helper::Command::Command(const double horizontalFov, const double verticalFov) :
5687 horizontalFov{horizontalFov},
5688 verticalFov{verticalFov}
5689{
5690}
5691
5693{
5694 yarp::os::idl::WireWriter writer(connection);
5695 if (!writer.writeListHeader(s_cmd_len)) {
5696 return false;
5697 }
5698 return write(writer);
5699}
5700
5702{
5703 yarp::os::idl::WireReader reader(connection);
5704 if (!reader.readListHeader()) {
5705 reader.fail();
5706 return false;
5707 }
5708 return read(reader);
5709}
5710
5712{
5713 if (!writeTag(writer)) {
5714 return false;
5715 }
5716 if (!writeArgs(writer)) {
5717 return false;
5718 }
5719 return true;
5720}
5721
5723{
5724 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5725 return false;
5726 }
5727 return true;
5728}
5729
5731{
5732 if (!writer.writeFloat64(horizontalFov)) {
5733 return false;
5734 }
5735 if (!writer.writeFloat64(verticalFov)) {
5736 return false;
5737 }
5738 return true;
5739}
5740
5742{
5743 if (!readTag(reader)) {
5744 return false;
5745 }
5746 if (!readArgs(reader)) {
5747 return false;
5748 }
5749 return true;
5750}
5751
5753{
5754 std::string tag = reader.readTag(s_tag_len);
5755 if (reader.isError()) {
5756 return false;
5757 }
5758 if (tag != s_tag) {
5759 reader.fail();
5760 return false;
5761 }
5762 return true;
5763}
5764
5766{
5767 if (reader.noMore()) {
5768 reader.fail();
5769 return false;
5770 }
5771 if (!reader.readFloat64(horizontalFov)) {
5772 reader.fail();
5773 return false;
5774 }
5775 if (reader.noMore()) {
5776 reader.fail();
5777 return false;
5778 }
5779 if (!reader.readFloat64(verticalFov)) {
5780 reader.fail();
5781 return false;
5782 }
5783 if (!reader.noMore()) {
5784 reader.fail();
5785 return false;
5786 }
5787 return true;
5788}
5789
5791{
5792 yarp::os::idl::WireWriter writer(connection);
5793 return write(writer);
5794}
5795
5797{
5798 yarp::os::idl::WireReader reader(connection);
5799 return read(reader);
5800}
5801
5803{
5804 if (!writer.isNull()) {
5805 if (!writer.write(return_helper)) {
5806 return false;
5807 }
5808 }
5809 return true;
5810}
5811
5813{
5814 if (reader.noMore()) {
5815 reader.fail();
5816 return false;
5817 }
5818 if (!reader.read(return_helper)) {
5819 reader.fail();
5820 return false;
5821 }
5822 return true;
5823}
5824
5829
5830// getDepthAccuracyRPC helper class implementation
5832{
5833 return cmd.write(connection);
5834}
5835
5837{
5838 return reply.read(connection);
5839}
5840
5842{
5843 yarp::os::idl::WireWriter writer(connection);
5844 if (!writer.writeListHeader(s_cmd_len)) {
5845 return false;
5846 }
5847 return write(writer);
5848}
5849
5851{
5852 yarp::os::idl::WireReader reader(connection);
5853 if (!reader.readListHeader()) {
5854 reader.fail();
5855 return false;
5856 }
5857 return read(reader);
5858}
5859
5861{
5862 if (!writeTag(writer)) {
5863 return false;
5864 }
5865 if (!writeArgs(writer)) {
5866 return false;
5867 }
5868 return true;
5869}
5870
5872{
5873 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5874 return false;
5875 }
5876 return true;
5877}
5878
5880{
5881 return true;
5882}
5883
5885{
5886 if (!readTag(reader)) {
5887 return false;
5888 }
5889 if (!readArgs(reader)) {
5890 return false;
5891 }
5892 return true;
5893}
5894
5896{
5897 std::string tag = reader.readTag(s_tag_len);
5898 if (reader.isError()) {
5899 return false;
5900 }
5901 if (tag != s_tag) {
5902 reader.fail();
5903 return false;
5904 }
5905 return true;
5906}
5907
5909{
5910 if (!reader.noMore()) {
5911 reader.fail();
5912 return false;
5913 }
5914 return true;
5915}
5916
5918{
5919 yarp::os::idl::WireWriter writer(connection);
5920 return write(writer);
5921}
5922
5924{
5925 yarp::os::idl::WireReader reader(connection);
5926 return read(reader);
5927}
5928
5930{
5931 if (!writer.isNull()) {
5932 if (!writer.writeListHeader(s_reply_len)) {
5933 return false;
5934 }
5935 if (!writer.write(return_helper)) {
5936 return false;
5937 }
5938 }
5939 return true;
5940}
5941
5943{
5944 if (!reader.readListReturn()) {
5945 return false;
5946 }
5947 if (reader.noMore()) {
5948 reader.fail();
5949 return false;
5950 }
5951 if (!reader.read(return_helper)) {
5952 reader.fail();
5953 return false;
5954 }
5955 return true;
5956}
5957
5962
5963// setDepthAccuracyRPC helper class implementation
5968
5970{
5971 return cmd.write(connection);
5972}
5973
5975{
5976 return reply.read(connection);
5977}
5978
5983
5985{
5986 yarp::os::idl::WireWriter writer(connection);
5987 if (!writer.writeListHeader(s_cmd_len)) {
5988 return false;
5989 }
5990 return write(writer);
5991}
5992
5994{
5995 yarp::os::idl::WireReader reader(connection);
5996 if (!reader.readListHeader()) {
5997 reader.fail();
5998 return false;
5999 }
6000 return read(reader);
6001}
6002
6004{
6005 if (!writeTag(writer)) {
6006 return false;
6007 }
6008 if (!writeArgs(writer)) {
6009 return false;
6010 }
6011 return true;
6012}
6013
6015{
6016 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6017 return false;
6018 }
6019 return true;
6020}
6021
6023{
6024 if (!writer.writeFloat64(accuracy)) {
6025 return false;
6026 }
6027 return true;
6028}
6029
6031{
6032 if (!readTag(reader)) {
6033 return false;
6034 }
6035 if (!readArgs(reader)) {
6036 return false;
6037 }
6038 return true;
6039}
6040
6042{
6043 std::string tag = reader.readTag(s_tag_len);
6044 if (reader.isError()) {
6045 return false;
6046 }
6047 if (tag != s_tag) {
6048 reader.fail();
6049 return false;
6050 }
6051 return true;
6052}
6053
6055{
6056 if (reader.noMore()) {
6057 reader.fail();
6058 return false;
6059 }
6060 if (!reader.readFloat64(accuracy)) {
6061 reader.fail();
6062 return false;
6063 }
6064 if (!reader.noMore()) {
6065 reader.fail();
6066 return false;
6067 }
6068 return true;
6069}
6070
6072{
6073 yarp::os::idl::WireWriter writer(connection);
6074 return write(writer);
6075}
6076
6078{
6079 yarp::os::idl::WireReader reader(connection);
6080 return read(reader);
6081}
6082
6084{
6085 if (!writer.isNull()) {
6086 if (!writer.write(return_helper)) {
6087 return false;
6088 }
6089 }
6090 return true;
6091}
6092
6094{
6095 if (reader.noMore()) {
6096 reader.fail();
6097 return false;
6098 }
6099 if (!reader.read(return_helper)) {
6100 reader.fail();
6101 return false;
6102 }
6103 return true;
6104}
6105
6110
6111// getDepthClipPlanesRPC helper class implementation
6113{
6114 return cmd.write(connection);
6115}
6116
6121
6123{
6124 yarp::os::idl::WireWriter writer(connection);
6125 if (!writer.writeListHeader(s_cmd_len)) {
6126 return false;
6127 }
6128 return write(writer);
6129}
6130
6132{
6133 yarp::os::idl::WireReader reader(connection);
6134 if (!reader.readListHeader()) {
6135 reader.fail();
6136 return false;
6137 }
6138 return read(reader);
6139}
6140
6142{
6143 if (!writeTag(writer)) {
6144 return false;
6145 }
6146 if (!writeArgs(writer)) {
6147 return false;
6148 }
6149 return true;
6150}
6151
6153{
6154 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6155 return false;
6156 }
6157 return true;
6158}
6159
6161{
6162 return true;
6163}
6164
6166{
6167 if (!readTag(reader)) {
6168 return false;
6169 }
6170 if (!readArgs(reader)) {
6171 return false;
6172 }
6173 return true;
6174}
6175
6177{
6178 std::string tag = reader.readTag(s_tag_len);
6179 if (reader.isError()) {
6180 return false;
6181 }
6182 if (tag != s_tag) {
6183 reader.fail();
6184 return false;
6185 }
6186 return true;
6187}
6188
6190{
6191 if (!reader.noMore()) {
6192 reader.fail();
6193 return false;
6194 }
6195 return true;
6196}
6197
6199{
6200 yarp::os::idl::WireWriter writer(connection);
6201 return write(writer);
6202}
6203
6205{
6206 yarp::os::idl::WireReader reader(connection);
6207 return read(reader);
6208}
6209
6211{
6212 if (!writer.isNull()) {
6213 if (!writer.writeListHeader(s_reply_len)) {
6214 return false;
6215 }
6216 if (!writer.write(return_helper)) {
6217 return false;
6218 }
6219 }
6220 return true;
6221}
6222
6224{
6225 if (!reader.readListReturn()) {
6226 return false;
6227 }
6228 if (reader.noMore()) {
6229 reader.fail();
6230 return false;
6231 }
6232 if (!reader.read(return_helper)) {
6233 reader.fail();
6234 return false;
6235 }
6236 return true;
6237}
6238
6243
6244// setDepthClipPlanesRPC helper class implementation
6246 cmd{nearPlane, farPlane}
6247{
6248}
6249
6251{
6252 return cmd.write(connection);
6253}
6254
6259
6260RGBDSensorMsgs_setDepthClipPlanesRPC_helper::Command::Command(const double nearPlane, const double farPlane) :
6261 nearPlane{nearPlane},
6262 farPlane{farPlane}
6263{
6264}
6265
6267{
6268 yarp::os::idl::WireWriter writer(connection);
6269 if (!writer.writeListHeader(s_cmd_len)) {
6270 return false;
6271 }
6272 return write(writer);
6273}
6274
6276{
6277 yarp::os::idl::WireReader reader(connection);
6278 if (!reader.readListHeader()) {
6279 reader.fail();
6280 return false;
6281 }
6282 return read(reader);
6283}
6284
6286{
6287 if (!writeTag(writer)) {
6288 return false;
6289 }
6290 if (!writeArgs(writer)) {
6291 return false;
6292 }
6293 return true;
6294}
6295
6297{
6298 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6299 return false;
6300 }
6301 return true;
6302}
6303
6305{
6306 if (!writer.writeFloat64(nearPlane)) {
6307 return false;
6308 }
6309 if (!writer.writeFloat64(farPlane)) {
6310 return false;
6311 }
6312 return true;
6313}
6314
6316{
6317 if (!readTag(reader)) {
6318 return false;
6319 }
6320 if (!readArgs(reader)) {
6321 return false;
6322 }
6323 return true;
6324}
6325
6327{
6328 std::string tag = reader.readTag(s_tag_len);
6329 if (reader.isError()) {
6330 return false;
6331 }
6332 if (tag != s_tag) {
6333 reader.fail();
6334 return false;
6335 }
6336 return true;
6337}
6338
6340{
6341 if (reader.noMore()) {
6342 reader.fail();
6343 return false;
6344 }
6345 if (!reader.readFloat64(nearPlane)) {
6346 reader.fail();
6347 return false;
6348 }
6349 if (reader.noMore()) {
6350 reader.fail();
6351 return false;
6352 }
6353 if (!reader.readFloat64(farPlane)) {
6354 reader.fail();
6355 return false;
6356 }
6357 if (!reader.noMore()) {
6358 reader.fail();
6359 return false;
6360 }
6361 return true;
6362}
6363
6365{
6366 yarp::os::idl::WireWriter writer(connection);
6367 return write(writer);
6368}
6369
6371{
6372 yarp::os::idl::WireReader reader(connection);
6373 return read(reader);
6374}
6375
6377{
6378 if (!writer.isNull()) {
6379 if (!writer.write(return_helper)) {
6380 return false;
6381 }
6382 }
6383 return true;
6384}
6385
6387{
6388 if (reader.noMore()) {
6389 reader.fail();
6390 return false;
6391 }
6392 if (!reader.read(return_helper)) {
6393 reader.fail();
6394 return false;
6395 }
6396 return true;
6397}
6398
6403
6404// getDepthMirroringRPC helper class implementation
6406{
6407 return cmd.write(connection);
6408}
6409
6411{
6412 return reply.read(connection);
6413}
6414
6416{
6417 yarp::os::idl::WireWriter writer(connection);
6418 if (!writer.writeListHeader(s_cmd_len)) {
6419 return false;
6420 }
6421 return write(writer);
6422}
6423
6425{
6426 yarp::os::idl::WireReader reader(connection);
6427 if (!reader.readListHeader()) {
6428 reader.fail();
6429 return false;
6430 }
6431 return read(reader);
6432}
6433
6435{
6436 if (!writeTag(writer)) {
6437 return false;
6438 }
6439 if (!writeArgs(writer)) {
6440 return false;
6441 }
6442 return true;
6443}
6444
6446{
6447 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6448 return false;
6449 }
6450 return true;
6451}
6452
6454{
6455 return true;
6456}
6457
6459{
6460 if (!readTag(reader)) {
6461 return false;
6462 }
6463 if (!readArgs(reader)) {
6464 return false;
6465 }
6466 return true;
6467}
6468
6470{
6471 std::string tag = reader.readTag(s_tag_len);
6472 if (reader.isError()) {
6473 return false;
6474 }
6475 if (tag != s_tag) {
6476 reader.fail();
6477 return false;
6478 }
6479 return true;
6480}
6481
6483{
6484 if (!reader.noMore()) {
6485 reader.fail();
6486 return false;
6487 }
6488 return true;
6489}
6490
6492{
6493 yarp::os::idl::WireWriter writer(connection);
6494 return write(writer);
6495}
6496
6498{
6499 yarp::os::idl::WireReader reader(connection);
6500 return read(reader);
6501}
6502
6504{
6505 if (!writer.isNull()) {
6506 if (!writer.writeListHeader(s_reply_len)) {
6507 return false;
6508 }
6509 if (!writer.write(return_helper)) {
6510 return false;
6511 }
6512 }
6513 return true;
6514}
6515
6517{
6518 if (!reader.readListReturn()) {
6519 return false;
6520 }
6521 if (reader.noMore()) {
6522 reader.fail();
6523 return false;
6524 }
6525 if (!reader.read(return_helper)) {
6526 reader.fail();
6527 return false;
6528 }
6529 return true;
6530}
6531
6536
6537// setDepthMirroringRPC helper class implementation
6542
6544{
6545 return cmd.write(connection);
6546}
6547
6549{
6550 return reply.read(connection);
6551}
6552
6554 mirror{mirror}
6555{
6556}
6557
6559{
6560 yarp::os::idl::WireWriter writer(connection);
6561 if (!writer.writeListHeader(s_cmd_len)) {
6562 return false;
6563 }
6564 return write(writer);
6565}
6566
6568{
6569 yarp::os::idl::WireReader reader(connection);
6570 if (!reader.readListHeader()) {
6571 reader.fail();
6572 return false;
6573 }
6574 return read(reader);
6575}
6576
6578{
6579 if (!writeTag(writer)) {
6580 return false;
6581 }
6582 if (!writeArgs(writer)) {
6583 return false;
6584 }
6585 return true;
6586}
6587
6589{
6590 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6591 return false;
6592 }
6593 return true;
6594}
6595
6597{
6598 if (!writer.writeBool(mirror)) {
6599 return false;
6600 }
6601 return true;
6602}
6603
6605{
6606 if (!readTag(reader)) {
6607 return false;
6608 }
6609 if (!readArgs(reader)) {
6610 return false;
6611 }
6612 return true;
6613}
6614
6616{
6617 std::string tag = reader.readTag(s_tag_len);
6618 if (reader.isError()) {
6619 return false;
6620 }
6621 if (tag != s_tag) {
6622 reader.fail();
6623 return false;
6624 }
6625 return true;
6626}
6627
6629{
6630 if (reader.noMore()) {
6631 reader.fail();
6632 return false;
6633 }
6634 if (!reader.readBool(mirror)) {
6635 reader.fail();
6636 return false;
6637 }
6638 if (!reader.noMore()) {
6639 reader.fail();
6640 return false;
6641 }
6642 return true;
6643}
6644
6646{
6647 yarp::os::idl::WireWriter writer(connection);
6648 return write(writer);
6649}
6650
6652{
6653 yarp::os::idl::WireReader reader(connection);
6654 return read(reader);
6655}
6656
6658{
6659 if (!writer.isNull()) {
6660 if (!writer.write(return_helper)) {
6661 return false;
6662 }
6663 }
6664 return true;
6665}
6666
6668{
6669 if (reader.noMore()) {
6670 reader.fail();
6671 return false;
6672 }
6673 if (!reader.read(return_helper)) {
6674 reader.fail();
6675 return false;
6676 }
6677 return true;
6678}
6679
6684
6685// getDepthIntrinsicParamRPC helper class implementation
6687{
6688 return cmd.write(connection);
6689}
6690
6695
6697{
6698 yarp::os::idl::WireWriter writer(connection);
6699 if (!writer.writeListHeader(s_cmd_len)) {
6700 return false;
6701 }
6702 return write(writer);
6703}
6704
6706{
6707 yarp::os::idl::WireReader reader(connection);
6708 if (!reader.readListHeader()) {
6709 reader.fail();
6710 return false;
6711 }
6712 return read(reader);
6713}
6714
6716{
6717 if (!writeTag(writer)) {
6718 return false;
6719 }
6720 if (!writeArgs(writer)) {
6721 return false;
6722 }
6723 return true;
6724}
6725
6727{
6728 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6729 return false;
6730 }
6731 return true;
6732}
6733
6735{
6736 return true;
6737}
6738
6740{
6741 if (!readTag(reader)) {
6742 return false;
6743 }
6744 if (!readArgs(reader)) {
6745 return false;
6746 }
6747 return true;
6748}
6749
6751{
6752 std::string tag = reader.readTag(s_tag_len);
6753 if (reader.isError()) {
6754 return false;
6755 }
6756 if (tag != s_tag) {
6757 reader.fail();
6758 return false;
6759 }
6760 return true;
6761}
6762
6764{
6765 if (!reader.noMore()) {
6766 reader.fail();
6767 return false;
6768 }
6769 return true;
6770}
6771
6773{
6774 yarp::os::idl::WireWriter writer(connection);
6775 return write(writer);
6776}
6777
6779{
6780 yarp::os::idl::WireReader reader(connection);
6781 return read(reader);
6782}
6783
6785{
6786 if (!writer.isNull()) {
6787 if (!writer.writeListHeader(s_reply_len)) {
6788 return false;
6789 }
6790 if (!writer.write(return_helper)) {
6791 return false;
6792 }
6793 }
6794 return true;
6795}
6796
6798{
6799 if (!reader.readListReturn()) {
6800 return false;
6801 }
6802 if (reader.noMore()) {
6803 reader.fail();
6804 return false;
6805 }
6806 if (!reader.read(return_helper)) {
6807 reader.fail();
6808 return false;
6809 }
6810 return true;
6811}
6812
6817
6818// getCameraDescriptionRPC helper class implementation
6820{
6821 return cmd.write(connection);
6822}
6823
6828
6830{
6831 yarp::os::idl::WireWriter writer(connection);
6832 if (!writer.writeListHeader(s_cmd_len)) {
6833 return false;
6834 }
6835 return write(writer);
6836}
6837
6839{
6840 yarp::os::idl::WireReader reader(connection);
6841 if (!reader.readListHeader()) {
6842 reader.fail();
6843 return false;
6844 }
6845 return read(reader);
6846}
6847
6849{
6850 if (!writeTag(writer)) {
6851 return false;
6852 }
6853 if (!writeArgs(writer)) {
6854 return false;
6855 }
6856 return true;
6857}
6858
6860{
6861 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6862 return false;
6863 }
6864 return true;
6865}
6866
6868{
6869 return true;
6870}
6871
6873{
6874 if (!readTag(reader)) {
6875 return false;
6876 }
6877 if (!readArgs(reader)) {
6878 return false;
6879 }
6880 return true;
6881}
6882
6884{
6885 std::string tag = reader.readTag(s_tag_len);
6886 if (reader.isError()) {
6887 return false;
6888 }
6889 if (tag != s_tag) {
6890 reader.fail();
6891 return false;
6892 }
6893 return true;
6894}
6895
6897{
6898 if (!reader.noMore()) {
6899 reader.fail();
6900 return false;
6901 }
6902 return true;
6903}
6904
6906{
6907 yarp::os::idl::WireWriter writer(connection);
6908 return write(writer);
6909}
6910
6912{
6913 yarp::os::idl::WireReader reader(connection);
6914 return read(reader);
6915}
6916
6918{
6919 if (!writer.isNull()) {
6920 if (!writer.writeListHeader(s_reply_len)) {
6921 return false;
6922 }
6923 if (!writer.write(return_helper)) {
6924 return false;
6925 }
6926 }
6927 return true;
6928}
6929
6931{
6932 if (!reader.readListReturn()) {
6933 return false;
6934 }
6935 if (reader.noMore()) {
6936 reader.fail();
6937 return false;
6938 }
6939 if (!reader.read(return_helper)) {
6940 reader.fail();
6941 return false;
6942 }
6943 return true;
6944}
6945
6950
6951// hasFeatureRPC helper class implementation
6956
6958{
6959 return cmd.write(connection);
6960}
6961
6963{
6964 return reply.read(connection);
6965}
6966
6971
6973{
6974 yarp::os::idl::WireWriter writer(connection);
6975 if (!writer.writeListHeader(s_cmd_len)) {
6976 return false;
6977 }
6978 return write(writer);
6979}
6980
6982{
6983 yarp::os::idl::WireReader reader(connection);
6984 if (!reader.readListHeader()) {
6985 reader.fail();
6986 return false;
6987 }
6988 return read(reader);
6989}
6990
6992{
6993 if (!writeTag(writer)) {
6994 return false;
6995 }
6996 if (!writeArgs(writer)) {
6997 return false;
6998 }
6999 return true;
7000}
7001
7003{
7004 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7005 return false;
7006 }
7007 return true;
7008}
7009
7011{
7012 if (!writer.writeI32(feature)) {
7013 return false;
7014 }
7015 return true;
7016}
7017
7019{
7020 if (!readTag(reader)) {
7021 return false;
7022 }
7023 if (!readArgs(reader)) {
7024 return false;
7025 }
7026 return true;
7027}
7028
7030{
7031 std::string tag = reader.readTag(s_tag_len);
7032 if (reader.isError()) {
7033 return false;
7034 }
7035 if (tag != s_tag) {
7036 reader.fail();
7037 return false;
7038 }
7039 return true;
7040}
7041
7043{
7044 if (reader.noMore()) {
7045 reader.fail();
7046 return false;
7047 }
7048 if (!reader.readI32(feature)) {
7049 reader.fail();
7050 return false;
7051 }
7052 if (!reader.noMore()) {
7053 reader.fail();
7054 return false;
7055 }
7056 return true;
7057}
7058
7060{
7061 yarp::os::idl::WireWriter writer(connection);
7062 return write(writer);
7063}
7064
7066{
7067 yarp::os::idl::WireReader reader(connection);
7068 return read(reader);
7069}
7070
7072{
7073 if (!writer.isNull()) {
7074 if (!writer.writeListHeader(s_reply_len)) {
7075 return false;
7076 }
7077 if (!writer.write(return_helper)) {
7078 return false;
7079 }
7080 }
7081 return true;
7082}
7083
7085{
7086 if (!reader.readListReturn()) {
7087 return false;
7088 }
7089 if (reader.noMore()) {
7090 reader.fail();
7091 return false;
7092 }
7093 if (!reader.read(return_helper)) {
7094 reader.fail();
7095 return false;
7096 }
7097 return true;
7098}
7099
7104
7105// setFeature1RPC helper class implementation
7107 cmd{feature, value}
7108{
7109}
7110
7112{
7113 return cmd.write(connection);
7114}
7115
7117{
7118 return reply.read(connection);
7119}
7120
7123 value{value}
7124{
7125}
7126
7128{
7129 yarp::os::idl::WireWriter writer(connection);
7130 if (!writer.writeListHeader(s_cmd_len)) {
7131 return false;
7132 }
7133 return write(writer);
7134}
7135
7137{
7138 yarp::os::idl::WireReader reader(connection);
7139 if (!reader.readListHeader()) {
7140 reader.fail();
7141 return false;
7142 }
7143 return read(reader);
7144}
7145
7147{
7148 if (!writeTag(writer)) {
7149 return false;
7150 }
7151 if (!writeArgs(writer)) {
7152 return false;
7153 }
7154 return true;
7155}
7156
7158{
7159 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7160 return false;
7161 }
7162 return true;
7163}
7164
7166{
7167 if (!writer.writeI32(feature)) {
7168 return false;
7169 }
7170 if (!writer.writeFloat64(value)) {
7171 return false;
7172 }
7173 return true;
7174}
7175
7177{
7178 if (!readTag(reader)) {
7179 return false;
7180 }
7181 if (!readArgs(reader)) {
7182 return false;
7183 }
7184 return true;
7185}
7186
7188{
7189 std::string tag = reader.readTag(s_tag_len);
7190 if (reader.isError()) {
7191 return false;
7192 }
7193 if (tag != s_tag) {
7194 reader.fail();
7195 return false;
7196 }
7197 return true;
7198}
7199
7201{
7202 if (reader.noMore()) {
7203 reader.fail();
7204 return false;
7205 }
7206 if (!reader.readI32(feature)) {
7207 reader.fail();
7208 return false;
7209 }
7210 if (reader.noMore()) {
7211 reader.fail();
7212 return false;
7213 }
7214 if (!reader.readFloat64(value)) {
7215 reader.fail();
7216 return false;
7217 }
7218 if (!reader.noMore()) {
7219 reader.fail();
7220 return false;
7221 }
7222 return true;
7223}
7224
7226{
7227 yarp::os::idl::WireWriter writer(connection);
7228 return write(writer);
7229}
7230
7232{
7233 yarp::os::idl::WireReader reader(connection);
7234 return read(reader);
7235}
7236
7238{
7239 if (!writer.isNull()) {
7240 if (!writer.write(return_helper)) {
7241 return false;
7242 }
7243 }
7244 return true;
7245}
7246
7248{
7249 if (reader.noMore()) {
7250 reader.fail();
7251 return false;
7252 }
7253 if (!reader.read(return_helper)) {
7254 reader.fail();
7255 return false;
7256 }
7257 return true;
7258}
7259
7264
7265// getFeature1RPC helper class implementation
7270
7272{
7273 return cmd.write(connection);
7274}
7275
7277{
7278 return reply.read(connection);
7279}
7280
7285
7287{
7288 yarp::os::idl::WireWriter writer(connection);
7289 if (!writer.writeListHeader(s_cmd_len)) {
7290 return false;
7291 }
7292 return write(writer);
7293}
7294
7296{
7297 yarp::os::idl::WireReader reader(connection);
7298 if (!reader.readListHeader()) {
7299 reader.fail();
7300 return false;
7301 }
7302 return read(reader);
7303}
7304
7306{
7307 if (!writeTag(writer)) {
7308 return false;
7309 }
7310 if (!writeArgs(writer)) {
7311 return false;
7312 }
7313 return true;
7314}
7315
7317{
7318 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7319 return false;
7320 }
7321 return true;
7322}
7323
7325{
7326 if (!writer.writeI32(feature)) {
7327 return false;
7328 }
7329 return true;
7330}
7331
7333{
7334 if (!readTag(reader)) {
7335 return false;
7336 }
7337 if (!readArgs(reader)) {
7338 return false;
7339 }
7340 return true;
7341}
7342
7344{
7345 std::string tag = reader.readTag(s_tag_len);
7346 if (reader.isError()) {
7347 return false;
7348 }
7349 if (tag != s_tag) {
7350 reader.fail();
7351 return false;
7352 }
7353 return true;
7354}
7355
7357{
7358 if (reader.noMore()) {
7359 reader.fail();
7360 return false;
7361 }
7362 if (!reader.readI32(feature)) {
7363 reader.fail();
7364 return false;
7365 }
7366 if (!reader.noMore()) {
7367 reader.fail();
7368 return false;
7369 }
7370 return true;
7371}
7372
7374{
7375 yarp::os::idl::WireWriter writer(connection);
7376 return write(writer);
7377}
7378
7380{
7381 yarp::os::idl::WireReader reader(connection);
7382 return read(reader);
7383}
7384
7386{
7387 if (!writer.isNull()) {
7388 if (!writer.writeListHeader(s_reply_len)) {
7389 return false;
7390 }
7391 if (!writer.write(return_helper)) {
7392 return false;
7393 }
7394 }
7395 return true;
7396}
7397
7399{
7400 if (!reader.readListReturn()) {
7401 return false;
7402 }
7403 if (reader.noMore()) {
7404 reader.fail();
7405 return false;
7406 }
7407 if (!reader.read(return_helper)) {
7408 reader.fail();
7409 return false;
7410 }
7411 return true;
7412}
7413
7418
7419// setFeature2RPC helper class implementation
7420RGBDSensorMsgs_setFeature2RPC_helper::RGBDSensorMsgs_setFeature2RPC_helper(const std::int32_t feature, const double value1, const double value2) :
7421 cmd{feature, value1, value2}
7422{
7423}
7424
7426{
7427 return cmd.write(connection);
7428}
7429
7431{
7432 return reply.read(connection);
7433}
7434
7435RGBDSensorMsgs_setFeature2RPC_helper::Command::Command(const std::int32_t feature, const double value1, const double value2) :
7437 value1{value1},
7438 value2{value2}
7439{
7440}
7441
7443{
7444 yarp::os::idl::WireWriter writer(connection);
7445 if (!writer.writeListHeader(s_cmd_len)) {
7446 return false;
7447 }
7448 return write(writer);
7449}
7450
7452{
7453 yarp::os::idl::WireReader reader(connection);
7454 if (!reader.readListHeader()) {
7455 reader.fail();
7456 return false;
7457 }
7458 return read(reader);
7459}
7460
7462{
7463 if (!writeTag(writer)) {
7464 return false;
7465 }
7466 if (!writeArgs(writer)) {
7467 return false;
7468 }
7469 return true;
7470}
7471
7473{
7474 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7475 return false;
7476 }
7477 return true;
7478}
7479
7481{
7482 if (!writer.writeI32(feature)) {
7483 return false;
7484 }
7485 if (!writer.writeFloat64(value1)) {
7486 return false;
7487 }
7488 if (!writer.writeFloat64(value2)) {
7489 return false;
7490 }
7491 return true;
7492}
7493
7495{
7496 if (!readTag(reader)) {
7497 return false;
7498 }
7499 if (!readArgs(reader)) {
7500 return false;
7501 }
7502 return true;
7503}
7504
7506{
7507 std::string tag = reader.readTag(s_tag_len);
7508 if (reader.isError()) {
7509 return false;
7510 }
7511 if (tag != s_tag) {
7512 reader.fail();
7513 return false;
7514 }
7515 return true;
7516}
7517
7519{
7520 if (reader.noMore()) {
7521 reader.fail();
7522 return false;
7523 }
7524 if (!reader.readI32(feature)) {
7525 reader.fail();
7526 return false;
7527 }
7528 if (reader.noMore()) {
7529 reader.fail();
7530 return false;
7531 }
7532 if (!reader.readFloat64(value1)) {
7533 reader.fail();
7534 return false;
7535 }
7536 if (reader.noMore()) {
7537 reader.fail();
7538 return false;
7539 }
7540 if (!reader.readFloat64(value2)) {
7541 reader.fail();
7542 return false;
7543 }
7544 if (!reader.noMore()) {
7545 reader.fail();
7546 return false;
7547 }
7548 return true;
7549}
7550
7552{
7553 yarp::os::idl::WireWriter writer(connection);
7554 return write(writer);
7555}
7556
7558{
7559 yarp::os::idl::WireReader reader(connection);
7560 return read(reader);
7561}
7562
7564{
7565 if (!writer.isNull()) {
7566 if (!writer.write(return_helper)) {
7567 return false;
7568 }
7569 }
7570 return true;
7571}
7572
7574{
7575 if (reader.noMore()) {
7576 reader.fail();
7577 return false;
7578 }
7579 if (!reader.read(return_helper)) {
7580 reader.fail();
7581 return false;
7582 }
7583 return true;
7584}
7585
7590
7591// getFeature2RPC helper class implementation
7596
7598{
7599 return cmd.write(connection);
7600}
7601
7603{
7604 return reply.read(connection);
7605}
7606
7611
7613{
7614 yarp::os::idl::WireWriter writer(connection);
7615 if (!writer.writeListHeader(s_cmd_len)) {
7616 return false;
7617 }
7618 return write(writer);
7619}
7620
7622{
7623 yarp::os::idl::WireReader reader(connection);
7624 if (!reader.readListHeader()) {
7625 reader.fail();
7626 return false;
7627 }
7628 return read(reader);
7629}
7630
7632{
7633 if (!writeTag(writer)) {
7634 return false;
7635 }
7636 if (!writeArgs(writer)) {
7637 return false;
7638 }
7639 return true;
7640}
7641
7643{
7644 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7645 return false;
7646 }
7647 return true;
7648}
7649
7651{
7652 if (!writer.writeI32(feature)) {
7653 return false;
7654 }
7655 return true;
7656}
7657
7659{
7660 if (!readTag(reader)) {
7661 return false;
7662 }
7663 if (!readArgs(reader)) {
7664 return false;
7665 }
7666 return true;
7667}
7668
7670{
7671 std::string tag = reader.readTag(s_tag_len);
7672 if (reader.isError()) {
7673 return false;
7674 }
7675 if (tag != s_tag) {
7676 reader.fail();
7677 return false;
7678 }
7679 return true;
7680}
7681
7683{
7684 if (reader.noMore()) {
7685 reader.fail();
7686 return false;
7687 }
7688 if (!reader.readI32(feature)) {
7689 reader.fail();
7690 return false;
7691 }
7692 if (!reader.noMore()) {
7693 reader.fail();
7694 return false;
7695 }
7696 return true;
7697}
7698
7700{
7701 yarp::os::idl::WireWriter writer(connection);
7702 return write(writer);
7703}
7704
7706{
7707 yarp::os::idl::WireReader reader(connection);
7708 return read(reader);
7709}
7710
7712{
7713 if (!writer.isNull()) {
7714 if (!writer.writeListHeader(s_reply_len)) {
7715 return false;
7716 }
7717 if (!writer.write(return_helper)) {
7718 return false;
7719 }
7720 }
7721 return true;
7722}
7723
7725{
7726 if (!reader.readListReturn()) {
7727 return false;
7728 }
7729 if (reader.noMore()) {
7730 reader.fail();
7731 return false;
7732 }
7733 if (!reader.read(return_helper)) {
7734 reader.fail();
7735 return false;
7736 }
7737 return true;
7738}
7739
7744
7745// hasOnOffRPC helper class implementation
7750
7752{
7753 return cmd.write(connection);
7754}
7755
7757{
7758 return reply.read(connection);
7759}
7760
7765
7767{
7768 yarp::os::idl::WireWriter writer(connection);
7769 if (!writer.writeListHeader(s_cmd_len)) {
7770 return false;
7771 }
7772 return write(writer);
7773}
7774
7776{
7777 yarp::os::idl::WireReader reader(connection);
7778 if (!reader.readListHeader()) {
7779 reader.fail();
7780 return false;
7781 }
7782 return read(reader);
7783}
7784
7786{
7787 if (!writeTag(writer)) {
7788 return false;
7789 }
7790 if (!writeArgs(writer)) {
7791 return false;
7792 }
7793 return true;
7794}
7795
7797{
7798 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7799 return false;
7800 }
7801 return true;
7802}
7803
7805{
7806 if (!writer.writeI32(feature)) {
7807 return false;
7808 }
7809 return true;
7810}
7811
7813{
7814 if (!readTag(reader)) {
7815 return false;
7816 }
7817 if (!readArgs(reader)) {
7818 return false;
7819 }
7820 return true;
7821}
7822
7824{
7825 std::string tag = reader.readTag(s_tag_len);
7826 if (reader.isError()) {
7827 return false;
7828 }
7829 if (tag != s_tag) {
7830 reader.fail();
7831 return false;
7832 }
7833 return true;
7834}
7835
7837{
7838 if (reader.noMore()) {
7839 reader.fail();
7840 return false;
7841 }
7842 if (!reader.readI32(feature)) {
7843 reader.fail();
7844 return false;
7845 }
7846 if (!reader.noMore()) {
7847 reader.fail();
7848 return false;
7849 }
7850 return true;
7851}
7852
7854{
7855 yarp::os::idl::WireWriter writer(connection);
7856 return write(writer);
7857}
7858
7860{
7861 yarp::os::idl::WireReader reader(connection);
7862 return read(reader);
7863}
7864
7866{
7867 if (!writer.isNull()) {
7868 if (!writer.writeListHeader(s_reply_len)) {
7869 return false;
7870 }
7871 if (!writer.write(return_helper)) {
7872 return false;
7873 }
7874 }
7875 return true;
7876}
7877
7879{
7880 if (!reader.readListReturn()) {
7881 return false;
7882 }
7883 if (reader.noMore()) {
7884 reader.fail();
7885 return false;
7886 }
7887 if (!reader.read(return_helper)) {
7888 reader.fail();
7889 return false;
7890 }
7891 return true;
7892}
7893
7898
7899// setActiveRPC helper class implementation
7901 cmd{feature, onoff}
7902{
7903}
7904
7906{
7907 return cmd.write(connection);
7908}
7909
7911{
7912 return reply.read(connection);
7913}
7914
7917 onoff{onoff}
7918{
7919}
7920
7922{
7923 yarp::os::idl::WireWriter writer(connection);
7924 if (!writer.writeListHeader(s_cmd_len)) {
7925 return false;
7926 }
7927 return write(writer);
7928}
7929
7931{
7932 yarp::os::idl::WireReader reader(connection);
7933 if (!reader.readListHeader()) {
7934 reader.fail();
7935 return false;
7936 }
7937 return read(reader);
7938}
7939
7941{
7942 if (!writeTag(writer)) {
7943 return false;
7944 }
7945 if (!writeArgs(writer)) {
7946 return false;
7947 }
7948 return true;
7949}
7950
7952{
7953 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7954 return false;
7955 }
7956 return true;
7957}
7958
7960{
7961 if (!writer.writeI32(feature)) {
7962 return false;
7963 }
7964 if (!writer.writeBool(onoff)) {
7965 return false;
7966 }
7967 return true;
7968}
7969
7971{
7972 if (!readTag(reader)) {
7973 return false;
7974 }
7975 if (!readArgs(reader)) {
7976 return false;
7977 }
7978 return true;
7979}
7980
7982{
7983 std::string tag = reader.readTag(s_tag_len);
7984 if (reader.isError()) {
7985 return false;
7986 }
7987 if (tag != s_tag) {
7988 reader.fail();
7989 return false;
7990 }
7991 return true;
7992}
7993
7995{
7996 if (reader.noMore()) {
7997 reader.fail();
7998 return false;
7999 }
8000 if (!reader.readI32(feature)) {
8001 reader.fail();
8002 return false;
8003 }
8004 if (reader.noMore()) {
8005 reader.fail();
8006 return false;
8007 }
8008 if (!reader.readBool(onoff)) {
8009 reader.fail();
8010 return false;
8011 }
8012 if (!reader.noMore()) {
8013 reader.fail();
8014 return false;
8015 }
8016 return true;
8017}
8018
8020{
8021 yarp::os::idl::WireWriter writer(connection);
8022 return write(writer);
8023}
8024
8026{
8027 yarp::os::idl::WireReader reader(connection);
8028 return read(reader);
8029}
8030
8032{
8033 if (!writer.isNull()) {
8034 if (!writer.write(return_helper)) {
8035 return false;
8036 }
8037 }
8038 return true;
8039}
8040
8042{
8043 if (reader.noMore()) {
8044 reader.fail();
8045 return false;
8046 }
8047 if (!reader.read(return_helper)) {
8048 reader.fail();
8049 return false;
8050 }
8051 return true;
8052}
8053
8058
8059// getActiveRPC helper class implementation
8064
8066{
8067 return cmd.write(connection);
8068}
8069
8071{
8072 return reply.read(connection);
8073}
8074
8079
8081{
8082 yarp::os::idl::WireWriter writer(connection);
8083 if (!writer.writeListHeader(s_cmd_len)) {
8084 return false;
8085 }
8086 return write(writer);
8087}
8088
8090{
8091 yarp::os::idl::WireReader reader(connection);
8092 if (!reader.readListHeader()) {
8093 reader.fail();
8094 return false;
8095 }
8096 return read(reader);
8097}
8098
8100{
8101 if (!writeTag(writer)) {
8102 return false;
8103 }
8104 if (!writeArgs(writer)) {
8105 return false;
8106 }
8107 return true;
8108}
8109
8111{
8112 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8113 return false;
8114 }
8115 return true;
8116}
8117
8119{
8120 if (!writer.writeI32(feature)) {
8121 return false;
8122 }
8123 return true;
8124}
8125
8127{
8128 if (!readTag(reader)) {
8129 return false;
8130 }
8131 if (!readArgs(reader)) {
8132 return false;
8133 }
8134 return true;
8135}
8136
8138{
8139 std::string tag = reader.readTag(s_tag_len);
8140 if (reader.isError()) {
8141 return false;
8142 }
8143 if (tag != s_tag) {
8144 reader.fail();
8145 return false;
8146 }
8147 return true;
8148}
8149
8151{
8152 if (reader.noMore()) {
8153 reader.fail();
8154 return false;
8155 }
8156 if (!reader.readI32(feature)) {
8157 reader.fail();
8158 return false;
8159 }
8160 if (!reader.noMore()) {
8161 reader.fail();
8162 return false;
8163 }
8164 return true;
8165}
8166
8168{
8169 yarp::os::idl::WireWriter writer(connection);
8170 return write(writer);
8171}
8172
8174{
8175 yarp::os::idl::WireReader reader(connection);
8176 return read(reader);
8177}
8178
8180{
8181 if (!writer.isNull()) {
8182 if (!writer.writeListHeader(s_reply_len)) {
8183 return false;
8184 }
8185 if (!writer.write(return_helper)) {
8186 return false;
8187 }
8188 }
8189 return true;
8190}
8191
8193{
8194 if (!reader.readListReturn()) {
8195 return false;
8196 }
8197 if (reader.noMore()) {
8198 reader.fail();
8199 return false;
8200 }
8201 if (!reader.read(return_helper)) {
8202 reader.fail();
8203 return false;
8204 }
8205 return true;
8206}
8207
8212
8213// hasAutoRPC helper class implementation
8218
8220{
8221 return cmd.write(connection);
8222}
8223
8225{
8226 return reply.read(connection);
8227}
8228
8233
8235{
8236 yarp::os::idl::WireWriter writer(connection);
8237 if (!writer.writeListHeader(s_cmd_len)) {
8238 return false;
8239 }
8240 return write(writer);
8241}
8242
8244{
8245 yarp::os::idl::WireReader reader(connection);
8246 if (!reader.readListHeader()) {
8247 reader.fail();
8248 return false;
8249 }
8250 return read(reader);
8251}
8252
8254{
8255 if (!writeTag(writer)) {
8256 return false;
8257 }
8258 if (!writeArgs(writer)) {
8259 return false;
8260 }
8261 return true;
8262}
8263
8265{
8266 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8267 return false;
8268 }
8269 return true;
8270}
8271
8273{
8274 if (!writer.writeI32(feature)) {
8275 return false;
8276 }
8277 return true;
8278}
8279
8281{
8282 if (!readTag(reader)) {
8283 return false;
8284 }
8285 if (!readArgs(reader)) {
8286 return false;
8287 }
8288 return true;
8289}
8290
8292{
8293 std::string tag = reader.readTag(s_tag_len);
8294 if (reader.isError()) {
8295 return false;
8296 }
8297 if (tag != s_tag) {
8298 reader.fail();
8299 return false;
8300 }
8301 return true;
8302}
8303
8305{
8306 if (reader.noMore()) {
8307 reader.fail();
8308 return false;
8309 }
8310 if (!reader.readI32(feature)) {
8311 reader.fail();
8312 return false;
8313 }
8314 if (!reader.noMore()) {
8315 reader.fail();
8316 return false;
8317 }
8318 return true;
8319}
8320
8322{
8323 yarp::os::idl::WireWriter writer(connection);
8324 return write(writer);
8325}
8326
8328{
8329 yarp::os::idl::WireReader reader(connection);
8330 return read(reader);
8331}
8332
8334{
8335 if (!writer.isNull()) {
8336 if (!writer.writeListHeader(s_reply_len)) {
8337 return false;
8338 }
8339 if (!writer.write(return_helper)) {
8340 return false;
8341 }
8342 }
8343 return true;
8344}
8345
8347{
8348 if (!reader.readListReturn()) {
8349 return false;
8350 }
8351 if (reader.noMore()) {
8352 reader.fail();
8353 return false;
8354 }
8355 if (!reader.read(return_helper)) {
8356 reader.fail();
8357 return false;
8358 }
8359 return true;
8360}
8361
8366
8367// hasManualRPC helper class implementation
8372
8374{
8375 return cmd.write(connection);
8376}
8377
8379{
8380 return reply.read(connection);
8381}
8382
8387
8389{
8390 yarp::os::idl::WireWriter writer(connection);
8391 if (!writer.writeListHeader(s_cmd_len)) {
8392 return false;
8393 }
8394 return write(writer);
8395}
8396
8398{
8399 yarp::os::idl::WireReader reader(connection);
8400 if (!reader.readListHeader()) {
8401 reader.fail();
8402 return false;
8403 }
8404 return read(reader);
8405}
8406
8408{
8409 if (!writeTag(writer)) {
8410 return false;
8411 }
8412 if (!writeArgs(writer)) {
8413 return false;
8414 }
8415 return true;
8416}
8417
8419{
8420 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8421 return false;
8422 }
8423 return true;
8424}
8425
8427{
8428 if (!writer.writeI32(feature)) {
8429 return false;
8430 }
8431 return true;
8432}
8433
8435{
8436 if (!readTag(reader)) {
8437 return false;
8438 }
8439 if (!readArgs(reader)) {
8440 return false;
8441 }
8442 return true;
8443}
8444
8446{
8447 std::string tag = reader.readTag(s_tag_len);
8448 if (reader.isError()) {
8449 return false;
8450 }
8451 if (tag != s_tag) {
8452 reader.fail();
8453 return false;
8454 }
8455 return true;
8456}
8457
8459{
8460 if (reader.noMore()) {
8461 reader.fail();
8462 return false;
8463 }
8464 if (!reader.readI32(feature)) {
8465 reader.fail();
8466 return false;
8467 }
8468 if (!reader.noMore()) {
8469 reader.fail();
8470 return false;
8471 }
8472 return true;
8473}
8474
8476{
8477 yarp::os::idl::WireWriter writer(connection);
8478 return write(writer);
8479}
8480
8482{
8483 yarp::os::idl::WireReader reader(connection);
8484 return read(reader);
8485}
8486
8488{
8489 if (!writer.isNull()) {
8490 if (!writer.writeListHeader(s_reply_len)) {
8491 return false;
8492 }
8493 if (!writer.write(return_helper)) {
8494 return false;
8495 }
8496 }
8497 return true;
8498}
8499
8501{
8502 if (!reader.readListReturn()) {
8503 return false;
8504 }
8505 if (reader.noMore()) {
8506 reader.fail();
8507 return false;
8508 }
8509 if (!reader.read(return_helper)) {
8510 reader.fail();
8511 return false;
8512 }
8513 return true;
8514}
8515
8520
8521// hasOnePushRPC helper class implementation
8526
8528{
8529 return cmd.write(connection);
8530}
8531
8533{
8534 return reply.read(connection);
8535}
8536
8541
8543{
8544 yarp::os::idl::WireWriter writer(connection);
8545 if (!writer.writeListHeader(s_cmd_len)) {
8546 return false;
8547 }
8548 return write(writer);
8549}
8550
8552{
8553 yarp::os::idl::WireReader reader(connection);
8554 if (!reader.readListHeader()) {
8555 reader.fail();
8556 return false;
8557 }
8558 return read(reader);
8559}
8560
8562{
8563 if (!writeTag(writer)) {
8564 return false;
8565 }
8566 if (!writeArgs(writer)) {
8567 return false;
8568 }
8569 return true;
8570}
8571
8573{
8574 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8575 return false;
8576 }
8577 return true;
8578}
8579
8581{
8582 if (!writer.writeI32(feature)) {
8583 return false;
8584 }
8585 return true;
8586}
8587
8589{
8590 if (!readTag(reader)) {
8591 return false;
8592 }
8593 if (!readArgs(reader)) {
8594 return false;
8595 }
8596 return true;
8597}
8598
8600{
8601 std::string tag = reader.readTag(s_tag_len);
8602 if (reader.isError()) {
8603 return false;
8604 }
8605 if (tag != s_tag) {
8606 reader.fail();
8607 return false;
8608 }
8609 return true;
8610}
8611
8613{
8614 if (reader.noMore()) {
8615 reader.fail();
8616 return false;
8617 }
8618 if (!reader.readI32(feature)) {
8619 reader.fail();
8620 return false;
8621 }
8622 if (!reader.noMore()) {
8623 reader.fail();
8624 return false;
8625 }
8626 return true;
8627}
8628
8630{
8631 yarp::os::idl::WireWriter writer(connection);
8632 return write(writer);
8633}
8634
8636{
8637 yarp::os::idl::WireReader reader(connection);
8638 return read(reader);
8639}
8640
8642{
8643 if (!writer.isNull()) {
8644 if (!writer.writeListHeader(s_reply_len)) {
8645 return false;
8646 }
8647 if (!writer.write(return_helper)) {
8648 return false;
8649 }
8650 }
8651 return true;
8652}
8653
8655{
8656 if (!reader.readListReturn()) {
8657 return false;
8658 }
8659 if (reader.noMore()) {
8660 reader.fail();
8661 return false;
8662 }
8663 if (!reader.read(return_helper)) {
8664 reader.fail();
8665 return false;
8666 }
8667 return true;
8668}
8669
8674
8675// setModeRPC helper class implementation
8680
8682{
8683 return cmd.write(connection);
8684}
8685
8687{
8688 return reply.read(connection);
8689}
8690
8696
8698{
8699 yarp::os::idl::WireWriter writer(connection);
8700 if (!writer.writeListHeader(s_cmd_len)) {
8701 return false;
8702 }
8703 return write(writer);
8704}
8705
8707{
8708 yarp::os::idl::WireReader reader(connection);
8709 if (!reader.readListHeader()) {
8710 reader.fail();
8711 return false;
8712 }
8713 return read(reader);
8714}
8715
8717{
8718 if (!writeTag(writer)) {
8719 return false;
8720 }
8721 if (!writeArgs(writer)) {
8722 return false;
8723 }
8724 return true;
8725}
8726
8728{
8729 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8730 return false;
8731 }
8732 return true;
8733}
8734
8736{
8737 if (!writer.writeI32(feature)) {
8738 return false;
8739 }
8740 if (!writer.writeI32(static_cast<int32_t>(mode))) {
8741 return false;
8742 }
8743 return true;
8744}
8745
8747{
8748 if (!readTag(reader)) {
8749 return false;
8750 }
8751 if (!readArgs(reader)) {
8752 return false;
8753 }
8754 return true;
8755}
8756
8758{
8759 std::string tag = reader.readTag(s_tag_len);
8760 if (reader.isError()) {
8761 return false;
8762 }
8763 if (tag != s_tag) {
8764 reader.fail();
8765 return false;
8766 }
8767 return true;
8768}
8769
8771{
8772 if (reader.noMore()) {
8773 reader.fail();
8774 return false;
8775 }
8776 if (!reader.readI32(feature)) {
8777 reader.fail();
8778 return false;
8779 }
8780 if (reader.noMore()) {
8781 reader.fail();
8782 return false;
8783 }
8784 int32_t _ecast;
8785 if (!reader.readI32(_ecast)) {
8786 reader.fail();
8787 return false;
8788 }
8789 mode = static_cast<yarp::dev::FeatureMode>(_ecast);
8790 if (!reader.noMore()) {
8791 reader.fail();
8792 return false;
8793 }
8794 return true;
8795}
8796
8798{
8799 yarp::os::idl::WireWriter writer(connection);
8800 return write(writer);
8801}
8802
8804{
8805 yarp::os::idl::WireReader reader(connection);
8806 return read(reader);
8807}
8808
8810{
8811 if (!writer.isNull()) {
8812 if (!writer.write(return_helper)) {
8813 return false;
8814 }
8815 }
8816 return true;
8817}
8818
8820{
8821 if (reader.noMore()) {
8822 reader.fail();
8823 return false;
8824 }
8825 if (!reader.read(return_helper)) {
8826 reader.fail();
8827 return false;
8828 }
8829 return true;
8830}
8831
8836
8837// getModeRPC helper class implementation
8842
8844{
8845 return cmd.write(connection);
8846}
8847
8849{
8850 return reply.read(connection);
8851}
8852
8857
8859{
8860 yarp::os::idl::WireWriter writer(connection);
8861 if (!writer.writeListHeader(s_cmd_len)) {
8862 return false;
8863 }
8864 return write(writer);
8865}
8866
8868{
8869 yarp::os::idl::WireReader reader(connection);
8870 if (!reader.readListHeader()) {
8871 reader.fail();
8872 return false;
8873 }
8874 return read(reader);
8875}
8876
8878{
8879 if (!writeTag(writer)) {
8880 return false;
8881 }
8882 if (!writeArgs(writer)) {
8883 return false;
8884 }
8885 return true;
8886}
8887
8889{
8890 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8891 return false;
8892 }
8893 return true;
8894}
8895
8897{
8898 if (!writer.writeI32(feature)) {
8899 return false;
8900 }
8901 return true;
8902}
8903
8905{
8906 if (!readTag(reader)) {
8907 return false;
8908 }
8909 if (!readArgs(reader)) {
8910 return false;
8911 }
8912 return true;
8913}
8914
8916{
8917 std::string tag = reader.readTag(s_tag_len);
8918 if (reader.isError()) {
8919 return false;
8920 }
8921 if (tag != s_tag) {
8922 reader.fail();
8923 return false;
8924 }
8925 return true;
8926}
8927
8929{
8930 if (reader.noMore()) {
8931 reader.fail();
8932 return false;
8933 }
8934 if (!reader.readI32(feature)) {
8935 reader.fail();
8936 return false;
8937 }
8938 if (!reader.noMore()) {
8939 reader.fail();
8940 return false;
8941 }
8942 return true;
8943}
8944
8946{
8947 yarp::os::idl::WireWriter writer(connection);
8948 return write(writer);
8949}
8950
8952{
8953 yarp::os::idl::WireReader reader(connection);
8954 return read(reader);
8955}
8956
8958{
8959 if (!writer.isNull()) {
8960 if (!writer.writeListHeader(s_reply_len)) {
8961 return false;
8962 }
8963 if (!writer.write(return_helper)) {
8964 return false;
8965 }
8966 }
8967 return true;
8968}
8969
8971{
8972 if (!reader.readListReturn()) {
8973 return false;
8974 }
8975 if (reader.noMore()) {
8976 reader.fail();
8977 return false;
8978 }
8979 if (!reader.read(return_helper)) {
8980 reader.fail();
8981 return false;
8982 }
8983 return true;
8984}
8985
8990
8991// setOnePushRPC helper class implementation
8996
8998{
8999 return cmd.write(connection);
9000}
9001
9003{
9004 return reply.read(connection);
9005}
9006
9011
9013{
9014 yarp::os::idl::WireWriter writer(connection);
9015 if (!writer.writeListHeader(s_cmd_len)) {
9016 return false;
9017 }
9018 return write(writer);
9019}
9020
9022{
9023 yarp::os::idl::WireReader reader(connection);
9024 if (!reader.readListHeader()) {
9025 reader.fail();
9026 return false;
9027 }
9028 return read(reader);
9029}
9030
9032{
9033 if (!writeTag(writer)) {
9034 return false;
9035 }
9036 if (!writeArgs(writer)) {
9037 return false;
9038 }
9039 return true;
9040}
9041
9043{
9044 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
9045 return false;
9046 }
9047 return true;
9048}
9049
9051{
9052 if (!writer.writeI32(feature)) {
9053 return false;
9054 }
9055 return true;
9056}
9057
9059{
9060 if (!readTag(reader)) {
9061 return false;
9062 }
9063 if (!readArgs(reader)) {
9064 return false;
9065 }
9066 return true;
9067}
9068
9070{
9071 std::string tag = reader.readTag(s_tag_len);
9072 if (reader.isError()) {
9073 return false;
9074 }
9075 if (tag != s_tag) {
9076 reader.fail();
9077 return false;
9078 }
9079 return true;
9080}
9081
9083{
9084 if (reader.noMore()) {
9085 reader.fail();
9086 return false;
9087 }
9088 if (!reader.readI32(feature)) {
9089 reader.fail();
9090 return false;
9091 }
9092 if (!reader.noMore()) {
9093 reader.fail();
9094 return false;
9095 }
9096 return true;
9097}
9098
9100{
9101 yarp::os::idl::WireWriter writer(connection);
9102 return write(writer);
9103}
9104
9106{
9107 yarp::os::idl::WireReader reader(connection);
9108 return read(reader);
9109}
9110
9112{
9113 if (!writer.isNull()) {
9114 if (!writer.write(return_helper)) {
9115 return false;
9116 }
9117 }
9118 return true;
9119}
9120
9122{
9123 if (reader.noMore()) {
9124 reader.fail();
9125 return false;
9126 }
9127 if (!reader.read(return_helper)) {
9128 reader.fail();
9129 return false;
9130 }
9131 return true;
9132}
9133
9138
9139// Constructor
9141{
9142 yarp().setOwner(*this);
9143}
9144
9146{
9147 if (!yarp().canWrite()) {
9149 }
9151 bool ok = yarp().write(helper, helper);
9152 if (!ok) {
9153 IRGBDMsgs_return_getExtrinsic failed_reply{};
9155 return failed_reply;
9156 }
9157 return helper.reply.return_helper;
9158}
9159
9161{
9162 if (!yarp().canWrite()) {
9163 yError("Missing server method '%s'?", RGBDSensorMsgs_getLastErrorMsgRPC_helper::s_prototype);
9164 }
9166 bool ok = yarp().write(helper, helper);
9167 if (!ok) {
9168 IRGBDMsgs_return_getLastErrorMsg failed_reply{};
9170 return failed_reply;
9171 }
9172 return helper.reply.return_helper;
9173}
9174
9176{
9177 if (!yarp().canWrite()) {
9178 yError("Missing server method '%s'?", RGBDSensorMsgs_getRgbImageRPC_helper::s_prototype);
9179 }
9181 bool ok = yarp().write(helper, helper);
9182 if (!ok) {
9183 IRGBDMsgs_return_getRgbImage failed_reply{};
9185 return failed_reply;
9186 }
9187 return helper.reply.return_helper;
9188}
9189
9191{
9192 if (!yarp().canWrite()) {
9193 yError("Missing server method '%s'?", RGBDSensorMsgs_getDepthImageRPC_helper::s_prototype);
9194 }
9196 bool ok = yarp().write(helper, helper);
9197 if (!ok) {
9198 IRGBDMsgs_return_getDepthImage failed_reply{};
9200 return failed_reply;
9201 }
9202 return helper.reply.return_helper;
9203}
9204
9206{
9207 if (!yarp().canWrite()) {
9208 yError("Missing server method '%s'?", RGBDSensorMsgs_getImagesRPC_helper::s_prototype);
9209 }
9211 bool ok = yarp().write(helper, helper);
9212 if (!ok) {
9213 IRGBDMsgs_return_getImages failed_reply{};
9215 return failed_reply;
9216 }
9217 return helper.reply.return_helper;
9218}
9219
9221{
9222 if (!yarp().canWrite()) {
9223 yError("Missing server method '%s'?", RGBDSensorMsgs_getSensorStatusRPC_helper::s_prototype);
9224 }
9226 bool ok = yarp().write(helper, helper);
9227 if (!ok) {
9228 IRGBDMsgs_return_getSensorStatus failed_reply{};
9230 return failed_reply;
9231 }
9232 return helper.reply.return_helper;
9233}
9234
9236{
9237 if (!yarp().canWrite()) {
9238 yError("Missing server method '%s'?", RGBDSensorMsgs_getRgbWidthRPC_helper::s_prototype);
9239 }
9241 bool ok = yarp().write(helper, helper);
9242 if (!ok) {
9245 return failed_reply;
9246 }
9247 return helper.reply.return_helper;
9248}
9249
9251{
9252 if (!yarp().canWrite()) {
9253 yError("Missing server method '%s'?", RGBDSensorMsgs_getRgbHeightRPC_helper::s_prototype);
9254 }
9256 bool ok = yarp().write(helper, helper);
9257 if (!ok) {
9260 return failed_reply;
9261 }
9262 return helper.reply.return_helper;
9263}
9264
9266{
9267 if (!yarp().canWrite()) {
9269 }
9271 bool ok = yarp().write(helper, helper);
9272 if (!ok) {
9275 return failed_reply;
9276 }
9277 return helper.reply.return_helper;
9278}
9279
9281{
9282 if (!yarp().canWrite()) {
9283 yError("Missing server method '%s'?", RGBDSensorMsgs_getRgbResolutionRPC_helper::s_prototype);
9284 }
9286 bool ok = yarp().write(helper, helper);
9287 if (!ok) {
9290 return failed_reply;
9291 }
9292 return helper.reply.return_helper;
9293}
9294
9295yarp::dev::ReturnValue RGBDSensorMsgs::setRgbResolutionRPC(const std::int32_t width, const std::int32_t height)
9296{
9297 if (!yarp().canWrite()) {
9298 yError("Missing server method '%s'?", RGBDSensorMsgs_setRgbResolutionRPC_helper::s_prototype);
9299 }
9300 RGBDSensorMsgs_setRgbResolutionRPC_helper helper{width, height};
9301 bool ok = yarp().write(helper, helper);
9303}
9304
9306{
9307 if (!yarp().canWrite()) {
9308 yError("Missing server method '%s'?", RGBDSensorMsgs_getRgbFOVRPC_helper::s_prototype);
9309 }
9311 bool ok = yarp().write(helper, helper);
9312 if (!ok) {
9315 return failed_reply;
9316 }
9317 return helper.reply.return_helper;
9318}
9319
9320yarp::dev::ReturnValue RGBDSensorMsgs::setRgbFOVRPC(const double horizontalFov, const double verticalFov)
9321{
9322 if (!yarp().canWrite()) {
9323 yError("Missing server method '%s'?", RGBDSensorMsgs_setRgbFOVRPC_helper::s_prototype);
9324 }
9325 RGBDSensorMsgs_setRgbFOVRPC_helper helper{horizontalFov, verticalFov};
9326 bool ok = yarp().write(helper, helper);
9328}
9329
9331{
9332 if (!yarp().canWrite()) {
9334 }
9336 bool ok = yarp().write(helper, helper);
9337 if (!ok) {
9340 return failed_reply;
9341 }
9342 return helper.reply.return_helper;
9343}
9344
9346{
9347 if (!yarp().canWrite()) {
9348 yError("Missing server method '%s'?", RGBDSensorMsgs_getRgbMirroringRPC_helper::s_prototype);
9349 }
9351 bool ok = yarp().write(helper, helper);
9352 if (!ok) {
9355 return failed_reply;
9356 }
9357 return helper.reply.return_helper;
9358}
9359
9361{
9362 if (!yarp().canWrite()) {
9363 yError("Missing server method '%s'?", RGBDSensorMsgs_setRgbMirroringRPC_helper::s_prototype);
9364 }
9366 bool ok = yarp().write(helper, helper);
9368}
9369
9371{
9372 if (!yarp().canWrite()) {
9373 yError("Missing server method '%s'?", RGBDSensorMsgs_getDepthWidthRPC_helper::s_prototype);
9374 }
9376 bool ok = yarp().write(helper, helper);
9377 if (!ok) {
9380 return failed_reply;
9381 }
9382 return helper.reply.return_helper;
9383}
9384
9386{
9387 if (!yarp().canWrite()) {
9388 yError("Missing server method '%s'?", RGBDSensorMsgs_getDepthHeightRPC_helper::s_prototype);
9389 }
9391 bool ok = yarp().write(helper, helper);
9392 if (!ok) {
9395 return failed_reply;
9396 }
9397 return helper.reply.return_helper;
9398}
9399
9401{
9402 if (!yarp().canWrite()) {
9404 }
9406 bool ok = yarp().write(helper, helper);
9407 if (!ok) {
9410 return failed_reply;
9411 }
9412 return helper.reply.return_helper;
9413}
9414
9415yarp::dev::ReturnValue RGBDSensorMsgs::setDepthResolutionRPC(const std::int32_t width, const std::int32_t height)
9416{
9417 if (!yarp().canWrite()) {
9419 }
9420 RGBDSensorMsgs_setDepthResolutionRPC_helper helper{width, height};
9421 bool ok = yarp().write(helper, helper);
9423}
9424
9426{
9427 if (!yarp().canWrite()) {
9428 yError("Missing server method '%s'?", RGBDSensorMsgs_getDepthFOVRPC_helper::s_prototype);
9429 }
9431 bool ok = yarp().write(helper, helper);
9432 if (!ok) {
9435 return failed_reply;
9436 }
9437 return helper.reply.return_helper;
9438}
9439
9440yarp::dev::ReturnValue RGBDSensorMsgs::setDepthFOVRPC(const double horizontalFov, const double verticalFov)
9441{
9442 if (!yarp().canWrite()) {
9443 yError("Missing server method '%s'?", RGBDSensorMsgs_setDepthFOVRPC_helper::s_prototype);
9444 }
9445 RGBDSensorMsgs_setDepthFOVRPC_helper helper{horizontalFov, verticalFov};
9446 bool ok = yarp().write(helper, helper);
9448}
9449
9451{
9452 if (!yarp().canWrite()) {
9453 yError("Missing server method '%s'?", RGBDSensorMsgs_getDepthAccuracyRPC_helper::s_prototype);
9454 }
9456 bool ok = yarp().write(helper, helper);
9457 if (!ok) {
9460 return failed_reply;
9461 }
9462 return helper.reply.return_helper;
9463}
9464
9466{
9467 if (!yarp().canWrite()) {
9468 yError("Missing server method '%s'?", RGBDSensorMsgs_setDepthAccuracyRPC_helper::s_prototype);
9469 }
9471 bool ok = yarp().write(helper, helper);
9473}
9474
9476{
9477 if (!yarp().canWrite()) {
9479 }
9481 bool ok = yarp().write(helper, helper);
9482 if (!ok) {
9485 return failed_reply;
9486 }
9487 return helper.reply.return_helper;
9488}
9489
9490yarp::dev::ReturnValue RGBDSensorMsgs::setDepthClipPlanesRPC(const double nearPlane, const double farPlane)
9491{
9492 if (!yarp().canWrite()) {
9494 }
9495 RGBDSensorMsgs_setDepthClipPlanesRPC_helper helper{nearPlane, farPlane};
9496 bool ok = yarp().write(helper, helper);
9498}
9499
9501{
9502 if (!yarp().canWrite()) {
9504 }
9506 bool ok = yarp().write(helper, helper);
9507 if (!ok) {
9510 return failed_reply;
9511 }
9512 return helper.reply.return_helper;
9513}
9514
9516{
9517 if (!yarp().canWrite()) {
9519 }
9521 bool ok = yarp().write(helper, helper);
9523}
9524
9526{
9527 if (!yarp().canWrite()) {
9529 }
9531 bool ok = yarp().write(helper, helper);
9532 if (!ok) {
9535 return failed_reply;
9536 }
9537 return helper.reply.return_helper;
9538}
9539
9541{
9542 if (!yarp().canWrite()) {
9544 }
9546 bool ok = yarp().write(helper, helper);
9547 if (!ok) {
9550 return failed_reply;
9551 }
9552 return helper.reply.return_helper;
9553}
9554
9556{
9557 if (!yarp().canWrite()) {
9558 yError("Missing server method '%s'?", RGBDSensorMsgs_hasFeatureRPC_helper::s_prototype);
9559 }
9561 bool ok = yarp().write(helper, helper);
9562 if (!ok) {
9565 return failed_reply;
9566 }
9567 return helper.reply.return_helper;
9568}
9569
9571{
9572 if (!yarp().canWrite()) {
9573 yError("Missing server method '%s'?", RGBDSensorMsgs_setFeature1RPC_helper::s_prototype);
9574 }
9576 bool ok = yarp().write(helper, helper);
9578}
9579
9581{
9582 if (!yarp().canWrite()) {
9583 yError("Missing server method '%s'?", RGBDSensorMsgs_getFeature1RPC_helper::s_prototype);
9584 }
9586 bool ok = yarp().write(helper, helper);
9587 if (!ok) {
9590 return failed_reply;
9591 }
9592 return helper.reply.return_helper;
9593}
9594
9595yarp::dev::ReturnValue RGBDSensorMsgs::setFeature2RPC(const std::int32_t feature, const double value1, const double value2)
9596{
9597 if (!yarp().canWrite()) {
9598 yError("Missing server method '%s'?", RGBDSensorMsgs_setFeature2RPC_helper::s_prototype);
9599 }
9600 RGBDSensorMsgs_setFeature2RPC_helper helper{feature, value1, value2};
9601 bool ok = yarp().write(helper, helper);
9603}
9604
9606{
9607 if (!yarp().canWrite()) {
9608 yError("Missing server method '%s'?", RGBDSensorMsgs_getFeature2RPC_helper::s_prototype);
9609 }
9611 bool ok = yarp().write(helper, helper);
9612 if (!ok) {
9615 return failed_reply;
9616 }
9617 return helper.reply.return_helper;
9618}
9619
9621{
9622 if (!yarp().canWrite()) {
9623 yError("Missing server method '%s'?", RGBDSensorMsgs_hasOnOffRPC_helper::s_prototype);
9624 }
9626 bool ok = yarp().write(helper, helper);
9627 if (!ok) {
9630 return failed_reply;
9631 }
9632 return helper.reply.return_helper;
9633}
9634
9636{
9637 if (!yarp().canWrite()) {
9638 yError("Missing server method '%s'?", RGBDSensorMsgs_setActiveRPC_helper::s_prototype);
9639 }
9641 bool ok = yarp().write(helper, helper);
9643}
9644
9646{
9647 if (!yarp().canWrite()) {
9648 yError("Missing server method '%s'?", RGBDSensorMsgs_getActiveRPC_helper::s_prototype);
9649 }
9651 bool ok = yarp().write(helper, helper);
9652 if (!ok) {
9655 return failed_reply;
9656 }
9657 return helper.reply.return_helper;
9658}
9659
9661{
9662 if (!yarp().canWrite()) {
9663 yError("Missing server method '%s'?", RGBDSensorMsgs_hasAutoRPC_helper::s_prototype);
9664 }
9666 bool ok = yarp().write(helper, helper);
9667 if (!ok) {
9670 return failed_reply;
9671 }
9672 return helper.reply.return_helper;
9673}
9674
9676{
9677 if (!yarp().canWrite()) {
9678 yError("Missing server method '%s'?", RGBDSensorMsgs_hasManualRPC_helper::s_prototype);
9679 }
9681 bool ok = yarp().write(helper, helper);
9682 if (!ok) {
9685 return failed_reply;
9686 }
9687 return helper.reply.return_helper;
9688}
9689
9691{
9692 if (!yarp().canWrite()) {
9693 yError("Missing server method '%s'?", RGBDSensorMsgs_hasOnePushRPC_helper::s_prototype);
9694 }
9696 bool ok = yarp().write(helper, helper);
9697 if (!ok) {
9700 return failed_reply;
9701 }
9702 return helper.reply.return_helper;
9703}
9704
9706{
9707 if (!yarp().canWrite()) {
9708 yError("Missing server method '%s'?", RGBDSensorMsgs_setModeRPC_helper::s_prototype);
9709 }
9711 bool ok = yarp().write(helper, helper);
9713}
9714
9716{
9717 if (!yarp().canWrite()) {
9718 yError("Missing server method '%s'?", RGBDSensorMsgs_getModeRPC_helper::s_prototype);
9719 }
9721 bool ok = yarp().write(helper, helper);
9722 if (!ok) {
9725 return failed_reply;
9726 }
9727 return helper.reply.return_helper;
9728}
9729
9731{
9732 if (!yarp().canWrite()) {
9733 yError("Missing server method '%s'?", RGBDSensorMsgs_setOnePushRPC_helper::s_prototype);
9734 }
9736 bool ok = yarp().write(helper, helper);
9738}
9739
9740// help method
9741std::vector<std::string> RGBDSensorMsgs::help(const std::string& functionName)
9742{
9743 bool showAll = (functionName == "--all");
9744 std::vector<std::string> helpString;
9745 if (showAll) {
9746 helpString.emplace_back("*** Available commands:");
9748 helpString.emplace_back(RGBDSensorMsgs_getLastErrorMsgRPC_helper::s_tag);
9749 helpString.emplace_back(RGBDSensorMsgs_getRgbImageRPC_helper::s_tag);
9750 helpString.emplace_back(RGBDSensorMsgs_getDepthImageRPC_helper::s_tag);
9751 helpString.emplace_back(RGBDSensorMsgs_getImagesRPC_helper::s_tag);
9752 helpString.emplace_back(RGBDSensorMsgs_getSensorStatusRPC_helper::s_tag);
9753 helpString.emplace_back(RGBDSensorMsgs_getRgbWidthRPC_helper::s_tag);
9754 helpString.emplace_back(RGBDSensorMsgs_getRgbHeightRPC_helper::s_tag);
9756 helpString.emplace_back(RGBDSensorMsgs_getRgbResolutionRPC_helper::s_tag);
9757 helpString.emplace_back(RGBDSensorMsgs_setRgbResolutionRPC_helper::s_tag);
9758 helpString.emplace_back(RGBDSensorMsgs_getRgbFOVRPC_helper::s_tag);
9759 helpString.emplace_back(RGBDSensorMsgs_setRgbFOVRPC_helper::s_tag);
9761 helpString.emplace_back(RGBDSensorMsgs_getRgbMirroringRPC_helper::s_tag);
9762 helpString.emplace_back(RGBDSensorMsgs_setRgbMirroringRPC_helper::s_tag);
9763 helpString.emplace_back(RGBDSensorMsgs_getDepthWidthRPC_helper::s_tag);
9764 helpString.emplace_back(RGBDSensorMsgs_getDepthHeightRPC_helper::s_tag);
9767 helpString.emplace_back(RGBDSensorMsgs_getDepthFOVRPC_helper::s_tag);
9768 helpString.emplace_back(RGBDSensorMsgs_setDepthFOVRPC_helper::s_tag);
9769 helpString.emplace_back(RGBDSensorMsgs_getDepthAccuracyRPC_helper::s_tag);
9770 helpString.emplace_back(RGBDSensorMsgs_setDepthAccuracyRPC_helper::s_tag);
9777 helpString.emplace_back(RGBDSensorMsgs_hasFeatureRPC_helper::s_tag);
9778 helpString.emplace_back(RGBDSensorMsgs_setFeature1RPC_helper::s_tag);
9779 helpString.emplace_back(RGBDSensorMsgs_getFeature1RPC_helper::s_tag);
9780 helpString.emplace_back(RGBDSensorMsgs_setFeature2RPC_helper::s_tag);
9781 helpString.emplace_back(RGBDSensorMsgs_getFeature2RPC_helper::s_tag);
9782 helpString.emplace_back(RGBDSensorMsgs_hasOnOffRPC_helper::s_tag);
9783 helpString.emplace_back(RGBDSensorMsgs_setActiveRPC_helper::s_tag);
9784 helpString.emplace_back(RGBDSensorMsgs_getActiveRPC_helper::s_tag);
9785 helpString.emplace_back(RGBDSensorMsgs_hasAutoRPC_helper::s_tag);
9786 helpString.emplace_back(RGBDSensorMsgs_hasManualRPC_helper::s_tag);
9787 helpString.emplace_back(RGBDSensorMsgs_hasOnePushRPC_helper::s_tag);
9788 helpString.emplace_back(RGBDSensorMsgs_setModeRPC_helper::s_tag);
9789 helpString.emplace_back(RGBDSensorMsgs_getModeRPC_helper::s_tag);
9790 helpString.emplace_back(RGBDSensorMsgs_setOnePushRPC_helper::s_tag);
9791 helpString.emplace_back("help");
9792 } else {
9795 }
9798 }
9799 if (functionName == RGBDSensorMsgs_getRgbImageRPC_helper::s_tag) {
9801 }
9804 }
9805 if (functionName == RGBDSensorMsgs_getImagesRPC_helper::s_tag) {
9806 helpString.emplace_back(RGBDSensorMsgs_getImagesRPC_helper::s_prototype);
9807 }
9810 }
9811 if (functionName == RGBDSensorMsgs_getRgbWidthRPC_helper::s_tag) {
9813 }
9816 }
9819 }
9822 }
9825 }
9826 if (functionName == RGBDSensorMsgs_getRgbFOVRPC_helper::s_tag) {
9827 helpString.emplace_back(RGBDSensorMsgs_getRgbFOVRPC_helper::s_prototype);
9828 }
9829 if (functionName == RGBDSensorMsgs_setRgbFOVRPC_helper::s_tag) {
9830 helpString.emplace_back(RGBDSensorMsgs_setRgbFOVRPC_helper::s_prototype);
9831 }
9834 }
9837 }
9840 }
9843 }
9846 }
9849 }
9852 }
9853 if (functionName == RGBDSensorMsgs_getDepthFOVRPC_helper::s_tag) {
9855 }
9856 if (functionName == RGBDSensorMsgs_setDepthFOVRPC_helper::s_tag) {
9858 }
9861 }
9864 }
9867 }
9870 }
9873 }
9876 }
9879 }
9882 }
9883 if (functionName == RGBDSensorMsgs_hasFeatureRPC_helper::s_tag) {
9884 helpString.emplace_back(RGBDSensorMsgs_hasFeatureRPC_helper::s_prototype);
9885 }
9886 if (functionName == RGBDSensorMsgs_setFeature1RPC_helper::s_tag) {
9888 }
9889 if (functionName == RGBDSensorMsgs_getFeature1RPC_helper::s_tag) {
9891 }
9892 if (functionName == RGBDSensorMsgs_setFeature2RPC_helper::s_tag) {
9894 }
9895 if (functionName == RGBDSensorMsgs_getFeature2RPC_helper::s_tag) {
9897 }
9898 if (functionName == RGBDSensorMsgs_hasOnOffRPC_helper::s_tag) {
9899 helpString.emplace_back(RGBDSensorMsgs_hasOnOffRPC_helper::s_prototype);
9900 }
9901 if (functionName == RGBDSensorMsgs_setActiveRPC_helper::s_tag) {
9902 helpString.emplace_back(RGBDSensorMsgs_setActiveRPC_helper::s_prototype);
9903 }
9904 if (functionName == RGBDSensorMsgs_getActiveRPC_helper::s_tag) {
9905 helpString.emplace_back(RGBDSensorMsgs_getActiveRPC_helper::s_prototype);
9906 }
9907 if (functionName == RGBDSensorMsgs_hasAutoRPC_helper::s_tag) {
9908 helpString.emplace_back(RGBDSensorMsgs_hasAutoRPC_helper::s_prototype);
9909 }
9910 if (functionName == RGBDSensorMsgs_hasManualRPC_helper::s_tag) {
9911 helpString.emplace_back(RGBDSensorMsgs_hasManualRPC_helper::s_prototype);
9912 }
9913 if (functionName == RGBDSensorMsgs_hasOnePushRPC_helper::s_tag) {
9914 helpString.emplace_back(RGBDSensorMsgs_hasOnePushRPC_helper::s_prototype);
9915 }
9916 if (functionName == RGBDSensorMsgs_setModeRPC_helper::s_tag) {
9917 helpString.emplace_back(RGBDSensorMsgs_setModeRPC_helper::s_prototype);
9918 }
9919 if (functionName == RGBDSensorMsgs_getModeRPC_helper::s_tag) {
9920 helpString.emplace_back(RGBDSensorMsgs_getModeRPC_helper::s_prototype);
9921 }
9922 if (functionName == RGBDSensorMsgs_setOnePushRPC_helper::s_tag) {
9923 helpString.emplace_back(RGBDSensorMsgs_setOnePushRPC_helper::s_prototype);
9924 }
9925 if (functionName == "help") {
9926 helpString.emplace_back("std::vector<std::string> help(const std::string& functionName = \"--all\")");
9927 helpString.emplace_back("Return list of available commands, or help message for a specific function");
9928 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");
9929 helpString.emplace_back("@return list of strings (one string per line)");
9930 }
9931 }
9932 if (helpString.empty()) {
9933 helpString.emplace_back("Command not found");
9934 }
9935 return helpString;
9936}
9937
9938// read from ConnectionReader
9940{
9941 constexpr size_t max_tag_len = 1;
9942 size_t tag_len = 1;
9943
9944 yarp::os::idl::WireReader reader(connection);
9945 reader.expectAccept();
9946 if (!reader.readListHeader()) {
9947 reader.fail();
9948 return false;
9949 }
9950
9951 std::string tag = reader.readTag(1);
9952 bool direct = (tag == "__direct__");
9953 if (direct) {
9954 tag = reader.readTag(1);
9955 }
9956 while (tag_len <= max_tag_len && !reader.isError()) {
9957 if(tag == "getRemoteProtocolVersion") {
9958 if (!reader.noMore()) {
9959 yError("Reader invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
9960 reader.fail();
9961 return false;
9962 }
9963
9964 auto proto = getLocalProtocolVersion();
9965
9966 yarp::os::idl::WireWriter writer(reader);
9967 if (!writer.writeListHeader(1)) {
9968 yWarning("Writer invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
9969 return false;}
9970 if (!writer.write(proto)) {
9971 yWarning("Writer invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
9972 return false;
9973 }
9974 reader.accept();
9975 return true;
9976 }
9979 if (!helper.cmd.readArgs(reader)) {
9980 return false;
9981 }
9982
9983 helper.call(this);
9984
9985 yarp::os::idl::WireWriter writer(reader);
9986 if (!helper.reply.write(writer)) {
9987 return false;
9988 }
9989 reader.accept();
9990 return true;
9991 }
9994 if (!helper.cmd.readArgs(reader)) {
9995 return false;
9996 }
9997
9998 helper.call(this);
9999
10000 yarp::os::idl::WireWriter writer(reader);
10001 if (!helper.reply.write(writer)) {
10002 return false;
10003 }
10004 reader.accept();
10005 return true;
10006 }
10009 if (!helper.cmd.readArgs(reader)) {
10010 return false;
10011 }
10012
10013 helper.call(this);
10014
10015 yarp::os::idl::WireWriter writer(reader);
10016 if (!helper.reply.write(writer)) {
10017 return false;
10018 }
10019 reader.accept();
10020 return true;
10021 }
10024 if (!helper.cmd.readArgs(reader)) {
10025 return false;
10026 }
10027
10028 helper.call(this);
10029
10030 yarp::os::idl::WireWriter writer(reader);
10031 if (!helper.reply.write(writer)) {
10032 return false;
10033 }
10034 reader.accept();
10035 return true;
10036 }
10039 if (!helper.cmd.readArgs(reader)) {
10040 return false;
10041 }
10042
10043 helper.call(this);
10044
10045 yarp::os::idl::WireWriter writer(reader);
10046 if (!helper.reply.write(writer)) {
10047 return false;
10048 }
10049 reader.accept();
10050 return true;
10051 }
10054 if (!helper.cmd.readArgs(reader)) {
10055 return false;
10056 }
10057
10058 helper.call(this);
10059
10060 yarp::os::idl::WireWriter writer(reader);
10061 if (!helper.reply.write(writer)) {
10062 return false;
10063 }
10064 reader.accept();
10065 return true;
10066 }
10069 if (!helper.cmd.readArgs(reader)) {
10070 return false;
10071 }
10072
10073 helper.call(this);
10074
10075 yarp::os::idl::WireWriter writer(reader);
10076 if (!helper.reply.write(writer)) {
10077 return false;
10078 }
10079 reader.accept();
10080 return true;
10081 }
10084 if (!helper.cmd.readArgs(reader)) {
10085 return false;
10086 }
10087
10088 helper.call(this);
10089
10090 yarp::os::idl::WireWriter writer(reader);
10091 if (!helper.reply.write(writer)) {
10092 return false;
10093 }
10094 reader.accept();
10095 return true;
10096 }
10099 if (!helper.cmd.readArgs(reader)) {
10100 return false;
10101 }
10102
10103 helper.call(this);
10104
10105 yarp::os::idl::WireWriter writer(reader);
10106 if (!helper.reply.write(writer)) {
10107 return false;
10108 }
10109 reader.accept();
10110 return true;
10111 }
10114 if (!helper.cmd.readArgs(reader)) {
10115 return false;
10116 }
10117
10118 helper.call(this);
10119
10120 yarp::os::idl::WireWriter writer(reader);
10121 if (!helper.reply.write(writer)) {
10122 return false;
10123 }
10124 reader.accept();
10125 return true;
10126 }
10129 if (!helper.cmd.readArgs(reader)) {
10130 return false;
10131 }
10132
10133 helper.call(this);
10134
10135 yarp::os::idl::WireWriter writer(reader);
10136 if (!helper.reply.write(writer)) {
10137 return false;
10138 }
10139 reader.accept();
10140 return true;
10141 }
10144 if (!helper.cmd.readArgs(reader)) {
10145 return false;
10146 }
10147
10148 helper.call(this);
10149
10150 yarp::os::idl::WireWriter writer(reader);
10151 if (!helper.reply.write(writer)) {
10152 return false;
10153 }
10154 reader.accept();
10155 return true;
10156 }
10159 if (!helper.cmd.readArgs(reader)) {
10160 return false;
10161 }
10162
10163 helper.call(this);
10164
10165 yarp::os::idl::WireWriter writer(reader);
10166 if (!helper.reply.write(writer)) {
10167 return false;
10168 }
10169 reader.accept();
10170 return true;
10171 }
10174 if (!helper.cmd.readArgs(reader)) {
10175 return false;
10176 }
10177
10178 helper.call(this);
10179
10180 yarp::os::idl::WireWriter writer(reader);
10181 if (!helper.reply.write(writer)) {
10182 return false;
10183 }
10184 reader.accept();
10185 return true;
10186 }
10189 if (!helper.cmd.readArgs(reader)) {
10190 return false;
10191 }
10192
10193 helper.call(this);
10194
10195 yarp::os::idl::WireWriter writer(reader);
10196 if (!helper.reply.write(writer)) {
10197 return false;
10198 }
10199 reader.accept();
10200 return true;
10201 }
10204 if (!helper.cmd.readArgs(reader)) {
10205 return false;
10206 }
10207
10208 helper.call(this);
10209
10210 yarp::os::idl::WireWriter writer(reader);
10211 if (!helper.reply.write(writer)) {
10212 return false;
10213 }
10214 reader.accept();
10215 return true;
10216 }
10219 if (!helper.cmd.readArgs(reader)) {
10220 return false;
10221 }
10222
10223 helper.call(this);
10224
10225 yarp::os::idl::WireWriter writer(reader);
10226 if (!helper.reply.write(writer)) {
10227 return false;
10228 }
10229 reader.accept();
10230 return true;
10231 }
10234 if (!helper.cmd.readArgs(reader)) {
10235 return false;
10236 }
10237
10238 helper.call(this);
10239
10240 yarp::os::idl::WireWriter writer(reader);
10241 if (!helper.reply.write(writer)) {
10242 return false;
10243 }
10244 reader.accept();
10245 return true;
10246 }
10249 if (!helper.cmd.readArgs(reader)) {
10250 return false;
10251 }
10252
10253 helper.call(this);
10254
10255 yarp::os::idl::WireWriter writer(reader);
10256 if (!helper.reply.write(writer)) {
10257 return false;
10258 }
10259 reader.accept();
10260 return true;
10261 }
10264 if (!helper.cmd.readArgs(reader)) {
10265 return false;
10266 }
10267
10268 helper.call(this);
10269
10270 yarp::os::idl::WireWriter writer(reader);
10271 if (!helper.reply.write(writer)) {
10272 return false;
10273 }
10274 reader.accept();
10275 return true;
10276 }
10279 if (!helper.cmd.readArgs(reader)) {
10280 return false;
10281 }
10282
10283 helper.call(this);
10284
10285 yarp::os::idl::WireWriter writer(reader);
10286 if (!helper.reply.write(writer)) {
10287 return false;
10288 }
10289 reader.accept();
10290 return true;
10291 }
10294 if (!helper.cmd.readArgs(reader)) {
10295 return false;
10296 }
10297
10298 helper.call(this);
10299
10300 yarp::os::idl::WireWriter writer(reader);
10301 if (!helper.reply.write(writer)) {
10302 return false;
10303 }
10304 reader.accept();
10305 return true;
10306 }
10309 if (!helper.cmd.readArgs(reader)) {
10310 return false;
10311 }
10312
10313 helper.call(this);
10314
10315 yarp::os::idl::WireWriter writer(reader);
10316 if (!helper.reply.write(writer)) {
10317 return false;
10318 }
10319 reader.accept();
10320 return true;
10321 }
10324 if (!helper.cmd.readArgs(reader)) {
10325 return false;
10326 }
10327
10328 helper.call(this);
10329
10330 yarp::os::idl::WireWriter writer(reader);
10331 if (!helper.reply.write(writer)) {
10332 return false;
10333 }
10334 reader.accept();
10335 return true;
10336 }
10339 if (!helper.cmd.readArgs(reader)) {
10340 return false;
10341 }
10342
10343 helper.call(this);
10344
10345 yarp::os::idl::WireWriter writer(reader);
10346 if (!helper.reply.write(writer)) {
10347 return false;
10348 }
10349 reader.accept();
10350 return true;
10351 }
10354 if (!helper.cmd.readArgs(reader)) {
10355 return false;
10356 }
10357
10358 helper.call(this);
10359
10360 yarp::os::idl::WireWriter writer(reader);
10361 if (!helper.reply.write(writer)) {
10362 return false;
10363 }
10364 reader.accept();
10365 return true;
10366 }
10369 if (!helper.cmd.readArgs(reader)) {
10370 return false;
10371 }
10372
10373 helper.call(this);
10374
10375 yarp::os::idl::WireWriter writer(reader);
10376 if (!helper.reply.write(writer)) {
10377 return false;
10378 }
10379 reader.accept();
10380 return true;
10381 }
10384 if (!helper.cmd.readArgs(reader)) {
10385 return false;
10386 }
10387
10388 helper.call(this);
10389
10390 yarp::os::idl::WireWriter writer(reader);
10391 if (!helper.reply.write(writer)) {
10392 return false;
10393 }
10394 reader.accept();
10395 return true;
10396 }
10399 if (!helper.cmd.readArgs(reader)) {
10400 return false;
10401 }
10402
10403 helper.call(this);
10404
10405 yarp::os::idl::WireWriter writer(reader);
10406 if (!helper.reply.write(writer)) {
10407 return false;
10408 }
10409 reader.accept();
10410 return true;
10411 }
10414 if (!helper.cmd.readArgs(reader)) {
10415 return false;
10416 }
10417
10418 helper.call(this);
10419
10420 yarp::os::idl::WireWriter writer(reader);
10421 if (!helper.reply.write(writer)) {
10422 return false;
10423 }
10424 reader.accept();
10425 return true;
10426 }
10429 if (!helper.cmd.readArgs(reader)) {
10430 return false;
10431 }
10432
10433 helper.call(this);
10434
10435 yarp::os::idl::WireWriter writer(reader);
10436 if (!helper.reply.write(writer)) {
10437 return false;
10438 }
10439 reader.accept();
10440 return true;
10441 }
10444 if (!helper.cmd.readArgs(reader)) {
10445 return false;
10446 }
10447
10448 helper.call(this);
10449
10450 yarp::os::idl::WireWriter writer(reader);
10451 if (!helper.reply.write(writer)) {
10452 return false;
10453 }
10454 reader.accept();
10455 return true;
10456 }
10459 if (!helper.cmd.readArgs(reader)) {
10460 return false;
10461 }
10462
10463 helper.call(this);
10464
10465 yarp::os::idl::WireWriter writer(reader);
10466 if (!helper.reply.write(writer)) {
10467 return false;
10468 }
10469 reader.accept();
10470 return true;
10471 }
10474 if (!helper.cmd.readArgs(reader)) {
10475 return false;
10476 }
10477
10478 helper.call(this);
10479
10480 yarp::os::idl::WireWriter writer(reader);
10481 if (!helper.reply.write(writer)) {
10482 return false;
10483 }
10484 reader.accept();
10485 return true;
10486 }
10489 if (!helper.cmd.readArgs(reader)) {
10490 return false;
10491 }
10492
10493 helper.call(this);
10494
10495 yarp::os::idl::WireWriter writer(reader);
10496 if (!helper.reply.write(writer)) {
10497 return false;
10498 }
10499 reader.accept();
10500 return true;
10501 }
10504 if (!helper.cmd.readArgs(reader)) {
10505 return false;
10506 }
10507
10508 helper.call(this);
10509
10510 yarp::os::idl::WireWriter writer(reader);
10511 if (!helper.reply.write(writer)) {
10512 return false;
10513 }
10514 reader.accept();
10515 return true;
10516 }
10519 if (!helper.cmd.readArgs(reader)) {
10520 return false;
10521 }
10522
10523 helper.call(this);
10524
10525 yarp::os::idl::WireWriter writer(reader);
10526 if (!helper.reply.write(writer)) {
10527 return false;
10528 }
10529 reader.accept();
10530 return true;
10531 }
10534 if (!helper.cmd.readArgs(reader)) {
10535 return false;
10536 }
10537
10538 helper.call(this);
10539
10540 yarp::os::idl::WireWriter writer(reader);
10541 if (!helper.reply.write(writer)) {
10542 return false;
10543 }
10544 reader.accept();
10545 return true;
10546 }
10549 if (!helper.cmd.readArgs(reader)) {
10550 return false;
10551 }
10552
10553 helper.call(this);
10554
10555 yarp::os::idl::WireWriter writer(reader);
10556 if (!helper.reply.write(writer)) {
10557 return false;
10558 }
10559 reader.accept();
10560 return true;
10561 }
10564 if (!helper.cmd.readArgs(reader)) {
10565 return false;
10566 }
10567
10568 helper.call(this);
10569
10570 yarp::os::idl::WireWriter writer(reader);
10571 if (!helper.reply.write(writer)) {
10572 return false;
10573 }
10574 reader.accept();
10575 return true;
10576 }
10579 if (!helper.cmd.readArgs(reader)) {
10580 return false;
10581 }
10582
10583 helper.call(this);
10584
10585 yarp::os::idl::WireWriter writer(reader);
10586 if (!helper.reply.write(writer)) {
10587 return false;
10588 }
10589 reader.accept();
10590 return true;
10591 }
10594 if (!helper.cmd.readArgs(reader)) {
10595 return false;
10596 }
10597
10598 helper.call(this);
10599
10600 yarp::os::idl::WireWriter writer(reader);
10601 if (!helper.reply.write(writer)) {
10602 return false;
10603 }
10604 reader.accept();
10605 return true;
10606 }
10609 if (!helper.cmd.readArgs(reader)) {
10610 return false;
10611 }
10612
10613 helper.call(this);
10614
10615 yarp::os::idl::WireWriter writer(reader);
10616 if (!helper.reply.write(writer)) {
10617 return false;
10618 }
10619 reader.accept();
10620 return true;
10621 }
10624 if (!helper.cmd.readArgs(reader)) {
10625 return false;
10626 }
10627
10628 helper.call(this);
10629
10630 yarp::os::idl::WireWriter writer(reader);
10631 if (!helper.reply.write(writer)) {
10632 return false;
10633 }
10634 reader.accept();
10635 return true;
10636 }
10637 if (tag == "help") {
10638 std::string functionName;
10639 if (!reader.readString(functionName)) {
10640 functionName = "--all";
10641 }
10642 auto help_strings = help(functionName);
10643 yarp::os::idl::WireWriter writer(reader);
10644 if (!writer.isNull()) {
10645 if (!writer.writeListHeader(2)) {
10646 return false;
10647 }
10648 if (!writer.writeTag("many", 1, 0)) {
10649 return false;
10650 }
10651 if (!writer.writeListBegin(0, help_strings.size())) {
10652 return false;
10653 }
10654 for (const auto& help_string : help_strings) {
10655 if (!writer.writeString(help_string)) {
10656 return false;
10657 }
10658 }
10659 if (!writer.writeListEnd()) {
10660 return false;
10661 }
10662 }
10663 reader.accept();
10664 return true;
10665 }
10666 if (reader.noMore()) {
10667 reader.fail();
10668 return false;
10669 }
10670 std::string next_tag = reader.readTag(1);
10671 if (next_tag.empty()) {
10672 break;
10673 }
10674 tag.append("_").append(next_tag);
10675 tag_len = std::count(tag.begin(), tag.end(), '_') + 1;
10676 }
10677 return false;
10678}
FeatureMode mode
#define yError(...)
Definition Log.h:361
#define __YFUNCTION__
Definition Log.h:24
#define yWarning(...)
Definition Log.h:340
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool readTag(yarp::os::idl::WireReader &reader)
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 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.
IFrameGrabberControlMsgs_return_getActive return_helper
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
IFrameGrabberControlMsgs_return_getActive(*)(const std::int32_t) funcptr_t
static constexpr const char * s_help
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_prototype
static constexpr const char * s_tag
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 readTag(yarp::os::idl::WireReader &reader)
bool readArgs(yarp::os::idl::WireReader &reader)
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.
IFrameGrabberControlMsgs_return_getCameraDescription return_helper
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
IFrameGrabberControlMsgs_return_getCameraDescription(*)() 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 writeArgs(const yarp::os::idl::WireWriter &writer) const
bool readArgs(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 readTag(yarp::os::idl::WireReader &reader)
IDepthVisualParamsMsgs_return_getDepthAccuracy return_helper
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
IDepthVisualParamsMsgs_return_getDepthAccuracy(*)() 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 readTag(yarp::os::idl::WireReader &reader)
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 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.
IDepthVisualParamsMsgs_return_getDepthClipPlanes return_helper
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
IDepthVisualParamsMsgs_return_getDepthClipPlanes(*)() 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 readArgs(yarp::os::idl::WireReader &reader)
bool writeTag(const yarp::os::idl::WireWriter &writer) const
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 write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
IDepthVisualParamsMsgs_return_getDepthFOV return_helper
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
IDepthVisualParamsMsgs_return_getDepthFOV(*)() funcptr_t
static constexpr const char * s_help
static constexpr const char * s_prototype
static constexpr const char * s_tag
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 readTag(yarp::os::idl::WireReader &reader)
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 readArgs(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
IDepthVisualParamsMsgs_return_getDepthHeight return_helper
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.
IDepthVisualParamsMsgs_return_getDepthHeight(*)() funcptr_t
static constexpr const char * s_help
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_prototype
static constexpr const char * s_tag
bool readArgs(yarp::os::idl::WireReader &reader)
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool readTag(yarp::os::idl::WireReader &reader)
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.
IRGBDMsgs_return_getDepthImage return_helper
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_tag
IRGBDMsgs_return_getDepthImage(*)() funcptr_t
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_help
bool read(yarp::os::ConnectionReader &connection) override
Read this object from 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 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.
IDepthVisualParamsMsgs_return_getDepthIntrinsicParam return_helper
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
IDepthVisualParamsMsgs_return_getDepthIntrinsicParam(*)() funcptr_t
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 readTag(yarp::os::idl::WireReader &reader)
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 read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
IDepthVisualParamsMsgs_return_getDepthMirroring return_helper
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.
IDepthVisualParamsMsgs_return_getDepthMirroring(*)() funcptr_t
static constexpr const char * s_prototype
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 write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool readArgs(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.
IDepthVisualParamsMsgs_return_getDepthResolution return_helper
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.
IDepthVisualParamsMsgs_return_getDepthResolution(*)() 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 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 writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
IDepthVisualParamsMsgs_return_getDepthWidth return_helper
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.
static constexpr const char * s_prototype
static constexpr const char * s_help
IDepthVisualParamsMsgs_return_getDepthWidth(*)() funcptr_t
static constexpr const char * s_tag
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 writeTag(const yarp::os::idl::WireWriter &writer) const
bool readTag(yarp::os::idl::WireReader &reader)
bool readArgs(yarp::os::idl::WireReader &reader)
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.
IRGBDMsgs_return_getExtrinsic(*)() 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.
static constexpr const char * s_prototype
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object 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 writeTag(const yarp::os::idl::WireWriter &writer) const
IFrameGrabberControlMsgs_return_getFeature1 return_helper
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.
static constexpr const char * s_prototype
static constexpr const char * s_help
IFrameGrabberControlMsgs_return_getFeature1(*)(const std::int32_t) funcptr_t
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_tag
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 readTag(yarp::os::idl::WireReader &reader)
bool readArgs(yarp::os::idl::WireReader &reader)
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.
IFrameGrabberControlMsgs_return_getFeature2 return_helper
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_prototype
static constexpr const char * s_help
IFrameGrabberControlMsgs_return_getFeature2(*)(const std::int32_t) funcptr_t
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_tag
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool readTag(yarp::os::idl::WireReader &reader)
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 readArgs(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.
static constexpr const char * s_prototype
IRGBDMsgs_return_getImages(*)() funcptr_t
static constexpr const char * s_help
static constexpr size_t s_reply_len
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_tag
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool readArgs(yarp::os::idl::WireReader &reader)
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 writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
IRGBDMsgs_return_getLastErrorMsg return_helper
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to 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_prototype
IRGBDMsgs_return_getLastErrorMsg(*)() funcptr_t
static constexpr const char * s_tag
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 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.
IFrameGrabberControlMsgs_return_getMode return_helper
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr size_t s_cmd_len
static constexpr size_t s_tag_len
static constexpr const char * s_prototype
void call(RGBDSensorMsgs *ptr)
static constexpr const char * s_tag
static constexpr const char * s_help
IFrameGrabberControlMsgs_return_getMode(*)(const std::int32_t) funcptr_t
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr size_t s_reply_len
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.
yarp::os::ApplicationNetworkProtocolVersion helper_proto
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 write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool readTag(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from 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.
IRGBVisualParamsMsgs_return_getRgbFOV return_helper
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.
IRGBVisualParamsMsgs_return_getRgbFOV(*)() funcptr_t
static constexpr const char * s_prototype
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_tag
static constexpr const char * s_help
static constexpr size_t s_reply_len
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 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)
IRGBVisualParamsMsgs_return_getRgbHeight return_helper
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 read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
IRGBVisualParamsMsgs_return_getRgbHeight(*)() funcptr_t
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 writeArgs(const yarp::os::idl::WireWriter &writer) const
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 writeTag(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 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.
static constexpr const char * s_prototype
static constexpr const char * s_tag
IRGBDMsgs_return_getRgbImage(*)() funcptr_t
static constexpr const char * s_help
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool readArgs(yarp::os::idl::WireReader &reader)
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool readTag(yarp::os::idl::WireReader &reader)
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
IRGBVisualParamsMsgs_return_getRgbIntrinsicParam return_helper
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.
IRGBVisualParamsMsgs_return_getRgbIntrinsicParam(*)() funcptr_t
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool readTag(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 readArgs(yarp::os::idl::WireReader &reader)
bool writeTag(const yarp::os::idl::WireWriter &writer) const
IRGBVisualParamsMsgs_return_getRgbMirroring return_helper
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_tag
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_help
IRGBVisualParamsMsgs_return_getRgbMirroring(*)() funcptr_t
static constexpr const char * s_prototype
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
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 readTag(yarp::os::idl::WireReader &reader)
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
IRGBVisualParamsMsgs_return_getRgbResolution return_helper
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_prototype
IRGBVisualParamsMsgs_return_getRgbResolution(*)() 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 read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
IRGBVisualParamsMsgs_return_getRgbSupportedCfg return_helper
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.
IRGBVisualParamsMsgs_return_getRgbSupportedCfg(*)() funcptr_t
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 readTag(yarp::os::idl::WireReader &reader)
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 readArgs(yarp::os::idl::WireReader &reader)
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.
IRGBVisualParamsMsgs_return_getRgbWidth return_helper
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_prototype
IRGBVisualParamsMsgs_return_getRgbWidth(*)() funcptr_t
static constexpr const char * s_tag
static constexpr const char * s_help
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 read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool readArgs(yarp::os::idl::WireReader &reader)
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 write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
IRGBDMsgs_return_getSensorStatus return_helper
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_tag
IRGBDMsgs_return_getSensorStatus(*)() funcptr_t
static constexpr const char * s_help
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 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 readTag(yarp::os::idl::WireReader &reader)
bool readArgs(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
IFrameGrabberControlMsgs_return_hasAuto return_helper
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr size_t s_reply_len
IFrameGrabberControlMsgs_return_hasAuto(*)(const std::int32_t) funcptr_t
static constexpr const char * s_tag
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr size_t s_cmd_len
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr size_t s_tag_len
static constexpr const char * s_prototype
static constexpr const char * s_help
void call(RGBDSensorMsgs *ptr)
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 readArgs(yarp::os::idl::WireReader &reader)
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool readTag(yarp::os::idl::WireReader &reader)
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
IFrameGrabberControlMsgs_return_hasFeature return_helper
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_tag
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.
IFrameGrabberControlMsgs_return_hasFeature(*)(const std::int32_t) funcptr_t
static constexpr const char * s_prototype
static constexpr const char * s_help
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 readArgs(yarp::os::idl::WireReader &reader)
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.
IFrameGrabberControlMsgs_return_hasManual return_helper
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_tag
IFrameGrabberControlMsgs_return_hasManual(*)(const std::int32_t) funcptr_t
static constexpr const char * s_help
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 write(yarp::os::ConnectionWriter &connection) const override
Write this object to 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 readTag(yarp::os::idl::WireReader &reader)
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
IFrameGrabberControlMsgs_return_hasOnOff return_helper
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_prototype
static constexpr const char * s_help
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr size_t s_reply_len
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
IFrameGrabberControlMsgs_return_hasOnOff(*)(const std::int32_t) funcptr_t
static constexpr const char * s_tag
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 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.
IFrameGrabberControlMsgs_return_hasOnePush return_helper
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
IFrameGrabberControlMsgs_return_hasOnePush(*)(const std::int32_t) funcptr_t
static constexpr const char * s_tag
static constexpr const char * s_help
bool read(yarp::os::ConnectionReader &connection) override
Read this object from 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 readTag(yarp::os::idl::WireReader &reader)
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 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.
static constexpr const char * s_help
static constexpr const char * s_prototype
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
yarp::dev::ReturnValue(*)(const std::int32_t, const bool) funcptr_t
static constexpr const char * s_tag
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 readArgs(yarp::os::idl::WireReader &reader)
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 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.
yarp::dev::ReturnValue(*)(const double) funcptr_t
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_prototype
bool readTag(yarp::os::idl::WireReader &reader)
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 readArgs(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.
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.
yarp::dev::ReturnValue(*)(const double, const double) funcptr_t
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 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.
static constexpr const char * s_prototype
yarp::dev::ReturnValue(*)(const double, const double) funcptr_t
static constexpr const char * s_tag
static constexpr const char * s_help
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 readTag(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from 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.
yarp::dev::ReturnValue(*)(const bool) funcptr_t
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_prototype
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool readArgs(yarp::os::idl::WireReader &reader)
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 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.
yarp::dev::ReturnValue(*)(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 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 readTag(yarp::os::idl::WireReader &reader)
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 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_prototype
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_tag
static constexpr const char * s_help
yarp::dev::ReturnValue(*)(const std::int32_t, const double) 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 readTag(yarp::os::idl::WireReader &reader)
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 write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
yarp::dev::ReturnValue(*)(const std::int32_t, const double, const double) funcptr_t
static constexpr const char * s_prototype
static constexpr const char * s_tag
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.
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 writeTag(const yarp::os::idl::WireWriter &writer) const
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.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_tag
void call(RGBDSensorMsgs *ptr)
static constexpr size_t s_tag_len
static constexpr const char * s_help
static constexpr size_t s_cmd_len
yarp::dev::ReturnValue(*)(const std::int32_t, const yarp::dev::FeatureMode) funcptr_t
static constexpr const char * s_prototype
static constexpr size_t s_reply_len
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 readArgs(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool readTag(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 write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_prototype
static constexpr const char * s_tag
static constexpr const char * s_help
yarp::dev::ReturnValue(*)(const std::int32_t) funcptr_t
bool read(yarp::os::ConnectionReader &connection) override
Read this object from 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.
bool readArgs(yarp::os::idl::WireReader &reader)
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 write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_tag
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
yarp::dev::ReturnValue(*)(const double, const double) funcptr_t
static constexpr const char * s_help
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_prototype
static constexpr size_t s_reply_len
bool readArgs(yarp::os::idl::WireReader &reader)
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 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.
yarp::dev::ReturnValue(*)(const bool) funcptr_t
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 write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool readTag(yarp::os::idl::WireReader &reader)
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 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_prototype
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
yarp::dev::ReturnValue(*)(const std::int32_t, const std::int32_t) funcptr_t
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
virtual IFrameGrabberControlMsgs_return_getCameraDescription getCameraDescriptionRPC()
virtual IRGBDMsgs_return_getExtrinsic getExtrinsicParamRPC()
virtual IRGBVisualParamsMsgs_return_getRgbIntrinsicParam getRgbIntrinsicParamRPC()
virtual yarp::dev::ReturnValue setFeature2RPC(const std::int32_t feature, const double value1, const double value2)
virtual yarp::dev::ReturnValue setRgbResolutionRPC(const std::int32_t width, const std::int32_t height)
virtual IRGBDMsgs_return_getLastErrorMsg getLastErrorMsgRPC()
virtual yarp::dev::ReturnValue setRgbMirroringRPC(const bool mirror)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
virtual IFrameGrabberControlMsgs_return_hasOnOff hasOnOffRPC(const std::int32_t feature)
virtual IDepthVisualParamsMsgs_return_getDepthHeight getDepthHeightRPC()
virtual IFrameGrabberControlMsgs_return_getMode getModeRPC(const std::int32_t feature)
virtual IDepthVisualParamsMsgs_return_getDepthWidth getDepthWidthRPC()
virtual yarp::dev::ReturnValue setRgbFOVRPC(const double horizontalFov, const double verticalFov)
virtual yarp::dev::ReturnValue setDepthClipPlanesRPC(const double nearPlane, const double farPlane)
virtual yarp::os::ApplicationNetworkProtocolVersion getRemoteProtocolVersion()
virtual IRGBDMsgs_return_getRgbImage getRgbImageRPC()
virtual IRGBVisualParamsMsgs_return_getRgbSupportedCfg getRgbSupportedConfigurationsRPC()
virtual IFrameGrabberControlMsgs_return_getFeature1 getFeature1RPC(const std::int32_t feature)
virtual IDepthVisualParamsMsgs_return_getDepthClipPlanes getDepthClipPlanesRPC()
virtual IDepthVisualParamsMsgs_return_getDepthIntrinsicParam getDepthIntrinsicParamRPC()
virtual IRGBVisualParamsMsgs_return_getRgbMirroring getRgbMirroringRPC()
virtual IDepthVisualParamsMsgs_return_getDepthFOV getDepthFOVRPC()
virtual IRGBVisualParamsMsgs_return_getRgbFOV getRgbFOVRPC()
virtual IRGBDMsgs_return_getImages getImagesRPC()
virtual std::vector< std::string > help(const std::string &functionName="--all")
virtual IRGBVisualParamsMsgs_return_getRgbResolution getRgbResolutionRPC()
virtual IFrameGrabberControlMsgs_return_hasFeature hasFeatureRPC(const std::int32_t feature)
virtual yarp::dev::ReturnValue setOnePushRPC(const std::int32_t feature)
virtual IFrameGrabberControlMsgs_return_hasManual hasManualRPC(const std::int32_t feature)
virtual yarp::dev::ReturnValue setModeRPC(const std::int32_t feature, const yarp::dev::FeatureMode mode)
virtual yarp::dev::ReturnValue setFeature1RPC(const std::int32_t feature, const double value)
virtual IDepthVisualParamsMsgs_return_getDepthAccuracy getDepthAccuracyRPC()
virtual yarp::dev::ReturnValue setDepthFOVRPC(const double horizontalFov, const double verticalFov)
virtual yarp::dev::ReturnValue setDepthMirroringRPC(const bool mirror)
virtual yarp::dev::ReturnValue setActiveRPC(const std::int32_t feature, const bool onoff)
virtual IRGBVisualParamsMsgs_return_getRgbHeight getRgbHeightRPC()
virtual IFrameGrabberControlMsgs_return_getFeature2 getFeature2RPC(const std::int32_t feature)
virtual IDepthVisualParamsMsgs_return_getDepthResolution getDepthResolutionRPC()
virtual yarp::dev::ReturnValue setDepthResolutionRPC(const std::int32_t width, const std::int32_t height)
virtual yarp::dev::ReturnValue setDepthAccuracyRPC(const double accuracy)
virtual IDepthVisualParamsMsgs_return_getDepthMirroring getDepthMirroringRPC()
virtual IFrameGrabberControlMsgs_return_getActive getActiveRPC(const std::int32_t feature)
virtual bool checkProtocolVersion()
virtual IRGBVisualParamsMsgs_return_getRgbWidth getRgbWidthRPC()
virtual IFrameGrabberControlMsgs_return_hasAuto hasAutoRPC(const std::int32_t feature)
virtual IRGBDMsgs_return_getDepthImage getDepthImageRPC()
virtual yarp::os::ApplicationNetworkProtocolVersion getLocalProtocolVersion()
virtual IRGBDMsgs_return_getSensorStatus getSensorStatusRPC()
virtual IFrameGrabberControlMsgs_return_hasOnePush hasOnePushRPC(const std::int32_t feature)
@ return_value_error_nws_nwc_communication_error
Method is not (yet) implemented.
An interface for reading from a network connection.
An interface for writing to a network connection.
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)
bool readFloat64(yarp::conf::float64_t &x)
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 writeFloat64(yarp::conf::float64_t x, bool skip_tag=false) const
bool writeString(const std::string &str, bool skip_tag=false) const
bool writeListBegin(int tag, size_t len) const
#define yCError(component,...)
#define YARP_LOG_COMPONENT(name,...)
The main, catch-all namespace for YARP.
Definition dirs.h:16
constexpr char accuracy[]
#define YARP_VERSION_PATCH
Definition version.h:12
#define YARP_VERSION_MAJOR
Definition version.h:10
#define YARP_VERSION_MINOR
Definition version.h:11