YARP
Yet Another Robot Platform
 
Loading...
Searching...
No Matches
FrameGrabberMsgs.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 Compiler (0.14.1-yarped)
7//
8// This is an automatically generated file.
9// It could get re-generated if the ALLOW_IDL_GENERATION flag is on.
10
11#include <yarp/conf/version.h>
12#include <FrameGrabberMsgs.h>
14#include <yarp/os/LogStream.h>
15
17
18#include <algorithm>
19
20namespace
21{
22 YARP_LOG_COMPONENT(SERVICE_LOG_COMPONENT, "FrameGrabberMsgs")
23}
24
25//FrameGrabberMsgs_getRemoteProtocolVersion_helper declaration
36
38{
39 yarp::os::idl::WireWriter writer(connection);
40 if (!writer.writeListHeader(1)) {
41 return false;
42 }
43 if (!writer.writeString("getRemoteProtocolVersion")) {
44 return false;
45 }
46 return true;
47}
48
49bool FrameGrabberMsgs_getRemoteProtocolVersion_helper ::read(yarp::os::ConnectionReader & connection)
50 {
51 yarp::os::idl::WireReader reader(connection);
52 if (!reader.readListHeader()) {
53 reader.fail();
54 return false;
55 }
56
57 if (!helper_proto.read(connection)) {
58 reader.fail();
59 return false;
60 }
61 return true;
62}
63
64//ProtocolVersion, client side
66 {
67 if(!yarp().canWrite()) {
68 yError(" Missing server method FrameGrabberMsgs::getRemoteProtocolVersion");
69 }
71 bool ok = yarp().write(helper, helper);
72 if (ok) {
73 return helper.helper_proto;}
74 else {
76 return failureproto;}
77}
78
79//ProtocolVersion, client side
81 {
82 auto locproto = this->getLocalProtocolVersion();
83 auto remproto = this->getRemoteProtocolVersion();
84 if (remproto.protocol_version != locproto.protocol_version)
85 {
86 yCError(SERVICE_LOG_COMPONENT) << "Invalid communication protocol.";
87 yCError(SERVICE_LOG_COMPONENT) << "Local Protocol Version: " << locproto.toString();
88 yCError(SERVICE_LOG_COMPONENT) << "Remote Protocol Version: " << remproto.toString();
89 return false;
90 }
91 return true;
92}
93
94//ProtocolVersion, server side
96{
98 //myproto.protocol_version using default value = 0
99 //to change this value add the following line to the .thrift file:
100 //const i16 protocol_version = <your_number_here>
101 myproto.protocol_version = 0;
105 return myproto;
106}
107
108// getHeightRPC helper class declaration
110 public yarp::os::Portable
111{
112public:
114 bool write(yarp::os::ConnectionWriter& connection) const override;
115 bool read(yarp::os::ConnectionReader& connection) override;
116
117 class Command :
119 {
120 public:
121 Command() = default;
122 ~Command() override = default;
123
124 bool write(yarp::os::ConnectionWriter& connection) const override;
125 bool read(yarp::os::ConnectionReader& connection) override;
126
127 bool write(const yarp::os::idl::WireWriter& writer) const override;
128 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
129 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
130
131 bool read(yarp::os::idl::WireReader& reader) override;
134 };
135
136 class Reply :
138 {
139 public:
140 Reply() = default;
141 ~Reply() override = default;
142
143 bool write(yarp::os::ConnectionWriter& connection) const override;
144 bool read(yarp::os::ConnectionReader& connection) override;
145
146 bool write(const yarp::os::idl::WireWriter& writer) const override;
147 bool read(yarp::os::idl::WireReader& reader) override;
148
150 };
151
153 void call(FrameGrabberMsgs* ptr);
154
157
158 static constexpr const char* s_tag{"getHeightRPC"};
159 static constexpr size_t s_tag_len{1};
160 static constexpr size_t s_cmd_len{1};
161 static constexpr size_t s_reply_len{2};
162 static constexpr const char* s_prototype{"IFrameGrabberImageOf_return_getHeight FrameGrabberMsgs::getHeightRPC()"};
163 static constexpr const char* s_help{""};
164};
165
166// getWidthRPC helper class declaration
168 public yarp::os::Portable
169{
170public:
172 bool write(yarp::os::ConnectionWriter& connection) const override;
173 bool read(yarp::os::ConnectionReader& connection) override;
174
175 class Command :
177 {
178 public:
179 Command() = default;
180 ~Command() override = default;
181
182 bool write(yarp::os::ConnectionWriter& connection) const override;
183 bool read(yarp::os::ConnectionReader& connection) override;
184
185 bool write(const yarp::os::idl::WireWriter& writer) const override;
186 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
187 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
188
189 bool read(yarp::os::idl::WireReader& reader) override;
192 };
193
194 class Reply :
196 {
197 public:
198 Reply() = default;
199 ~Reply() override = default;
200
201 bool write(yarp::os::ConnectionWriter& connection) const override;
202 bool read(yarp::os::ConnectionReader& connection) override;
203
204 bool write(const yarp::os::idl::WireWriter& writer) const override;
205 bool read(yarp::os::idl::WireReader& reader) override;
206
208 };
209
211 void call(FrameGrabberMsgs* ptr);
212
215
216 static constexpr const char* s_tag{"getWidthRPC"};
217 static constexpr size_t s_tag_len{1};
218 static constexpr size_t s_cmd_len{1};
219 static constexpr size_t s_reply_len{2};
220 static constexpr const char* s_prototype{"IFrameGrabberImageOf_return_getWidth FrameGrabberMsgs::getWidthRPC()"};
221 static constexpr const char* s_help{""};
222};
223
224// getImageRPC helper class declaration
226 public yarp::os::Portable
227{
228public:
230 bool write(yarp::os::ConnectionWriter& connection) const override;
231 bool read(yarp::os::ConnectionReader& connection) override;
232
233 class Command :
235 {
236 public:
237 Command() = default;
238 ~Command() override = default;
239
240 bool write(yarp::os::ConnectionWriter& connection) const override;
241 bool read(yarp::os::ConnectionReader& connection) override;
242
243 bool write(const yarp::os::idl::WireWriter& writer) const override;
244 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
245 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
246
247 bool read(yarp::os::idl::WireReader& reader) override;
250 };
251
252 class Reply :
254 {
255 public:
256 Reply() = default;
257 ~Reply() override = default;
258
259 bool write(yarp::os::ConnectionWriter& connection) const override;
260 bool read(yarp::os::ConnectionReader& connection) override;
261
262 bool write(const yarp::os::idl::WireWriter& writer) const override;
263 bool read(yarp::os::idl::WireReader& reader) override;
264
266 };
267
269 void call(FrameGrabberMsgs* ptr);
270
273
274 static constexpr const char* s_tag{"getImageRPC"};
275 static constexpr size_t s_tag_len{1};
276 static constexpr size_t s_cmd_len{1};
277 static constexpr size_t s_reply_len{2};
278 static constexpr const char* s_prototype{"IFrameGrabberImageOf_return_getImage FrameGrabberMsgs::getImageRPC()"};
279 static constexpr const char* s_help{""};
280};
281
282// getImageCropRPC helper class declaration
284 public yarp::os::Portable
285{
286public:
288 FrameGrabberMsgs_getImageCropRPC_helper(const yarp::dev::cropType_id_t type, const std::vector<yarp::dev::vertex_t>& vertices);
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(const yarp::dev::cropType_id_t type, const std::vector<yarp::dev::vertex_t>& vertices);
298
299 ~Command() override = default;
300
301 bool write(yarp::os::ConnectionWriter& connection) const override;
302 bool read(yarp::os::ConnectionReader& connection) override;
303
304 bool write(const yarp::os::idl::WireWriter& writer) const override;
305 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
306 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
307
308 bool read(yarp::os::idl::WireReader& reader) override;
311
313 std::vector<yarp::dev::vertex_t> vertices{};
314 };
315
316 class Reply :
318 {
319 public:
320 Reply() = default;
321 ~Reply() override = default;
322
323 bool write(yarp::os::ConnectionWriter& connection) const override;
324 bool read(yarp::os::ConnectionReader& connection) override;
325
326 bool write(const yarp::os::idl::WireWriter& writer) const override;
327 bool read(yarp::os::idl::WireReader& reader) override;
328
330 };
331
332 using funcptr_t = IFrameGrabberImageOf_return_getImageCrop (*)(const yarp::dev::cropType_id_t, const std::vector<yarp::dev::vertex_t>&);
333 void call(FrameGrabberMsgs* ptr);
334
337
338 static constexpr const char* s_tag{"getImageCropRPC"};
339 static constexpr size_t s_tag_len{1};
340 static constexpr size_t s_cmd_len{3};
341 static constexpr size_t s_reply_len{2};
342 static constexpr const char* s_prototype{"IFrameGrabberImageOf_return_getImageCrop FrameGrabberMsgs::getImageCropRPC(const yarp::dev::cropType_id_t type, const std::vector<yarp::dev::vertex_t>& vertices)"};
343 static constexpr const char* s_help{""};
344};
345
346// getRgbWidthRPC helper class declaration
348 public yarp::os::Portable
349{
350public:
352 bool write(yarp::os::ConnectionWriter& connection) const override;
353 bool read(yarp::os::ConnectionReader& connection) override;
354
355 class Command :
357 {
358 public:
359 Command() = default;
360 ~Command() override = default;
361
362 bool write(yarp::os::ConnectionWriter& connection) const override;
363 bool read(yarp::os::ConnectionReader& connection) override;
364
365 bool write(const yarp::os::idl::WireWriter& writer) const override;
366 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
367 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
368
369 bool read(yarp::os::idl::WireReader& reader) override;
372 };
373
374 class Reply :
376 {
377 public:
378 Reply() = default;
379 ~Reply() override = default;
380
381 bool write(yarp::os::ConnectionWriter& connection) const override;
382 bool read(yarp::os::ConnectionReader& connection) override;
383
384 bool write(const yarp::os::idl::WireWriter& writer) const override;
385 bool read(yarp::os::idl::WireReader& reader) override;
386
388 };
389
391 void call(FrameGrabberMsgs* ptr);
392
395
396 static constexpr const char* s_tag{"getRgbWidthRPC"};
397 static constexpr size_t s_tag_len{1};
398 static constexpr size_t s_cmd_len{1};
399 static constexpr size_t s_reply_len{2};
400 static constexpr const char* s_prototype{"IRGBVisualParamsMsgs_return_getRgbWidth FrameGrabberMsgs::getRgbWidthRPC()"};
401 static constexpr const char* s_help{""};
402};
403
404// getRgbHeightRPC helper class declaration
406 public yarp::os::Portable
407{
408public:
410 bool write(yarp::os::ConnectionWriter& connection) const override;
411 bool read(yarp::os::ConnectionReader& connection) override;
412
413 class Command :
415 {
416 public:
417 Command() = default;
418 ~Command() override = default;
419
420 bool write(yarp::os::ConnectionWriter& connection) const override;
421 bool read(yarp::os::ConnectionReader& connection) override;
422
423 bool write(const yarp::os::idl::WireWriter& writer) const override;
424 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
425 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
426
427 bool read(yarp::os::idl::WireReader& reader) override;
430 };
431
432 class Reply :
434 {
435 public:
436 Reply() = default;
437 ~Reply() override = default;
438
439 bool write(yarp::os::ConnectionWriter& connection) const override;
440 bool read(yarp::os::ConnectionReader& connection) override;
441
442 bool write(const yarp::os::idl::WireWriter& writer) const override;
443 bool read(yarp::os::idl::WireReader& reader) override;
444
446 };
447
449 void call(FrameGrabberMsgs* ptr);
450
453
454 static constexpr const char* s_tag{"getRgbHeightRPC"};
455 static constexpr size_t s_tag_len{1};
456 static constexpr size_t s_cmd_len{1};
457 static constexpr size_t s_reply_len{2};
458 static constexpr const char* s_prototype{"IRGBVisualParamsMsgs_return_getRgbHeight FrameGrabberMsgs::getRgbHeightRPC()"};
459 static constexpr const char* s_help{""};
460};
461
462// getRgbSupportedConfigurationsRPC helper class declaration
464 public yarp::os::Portable
465{
466public:
468 bool write(yarp::os::ConnectionWriter& connection) const override;
469 bool read(yarp::os::ConnectionReader& connection) override;
470
471 class Command :
473 {
474 public:
475 Command() = default;
476 ~Command() override = default;
477
478 bool write(yarp::os::ConnectionWriter& connection) const override;
479 bool read(yarp::os::ConnectionReader& connection) override;
480
481 bool write(const yarp::os::idl::WireWriter& writer) const override;
482 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
483 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
484
485 bool read(yarp::os::idl::WireReader& reader) override;
488 };
489
490 class Reply :
492 {
493 public:
494 Reply() = default;
495 ~Reply() override = default;
496
497 bool write(yarp::os::ConnectionWriter& connection) const override;
498 bool read(yarp::os::ConnectionReader& connection) override;
499
500 bool write(const yarp::os::idl::WireWriter& writer) const override;
501 bool read(yarp::os::idl::WireReader& reader) override;
502
504 };
505
507 void call(FrameGrabberMsgs* ptr);
508
511
512 static constexpr const char* s_tag{"getRgbSupportedConfigurationsRPC"};
513 static constexpr size_t s_tag_len{1};
514 static constexpr size_t s_cmd_len{1};
515 static constexpr size_t s_reply_len{2};
516 static constexpr const char* s_prototype{"IRGBVisualParamsMsgs_return_getRgbSupportedCfg FrameGrabberMsgs::getRgbSupportedConfigurationsRPC()"};
517 static constexpr const char* s_help{""};
518};
519
520// getRgbResolutionRPC helper class declaration
522 public yarp::os::Portable
523{
524public:
526 bool write(yarp::os::ConnectionWriter& connection) const override;
527 bool read(yarp::os::ConnectionReader& connection) override;
528
529 class Command :
531 {
532 public:
533 Command() = default;
534 ~Command() override = default;
535
536 bool write(yarp::os::ConnectionWriter& connection) const override;
537 bool read(yarp::os::ConnectionReader& connection) override;
538
539 bool write(const yarp::os::idl::WireWriter& writer) const override;
540 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
541 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
542
543 bool read(yarp::os::idl::WireReader& reader) override;
546 };
547
548 class Reply :
550 {
551 public:
552 Reply() = default;
553 ~Reply() override = default;
554
555 bool write(yarp::os::ConnectionWriter& connection) const override;
556 bool read(yarp::os::ConnectionReader& connection) override;
557
558 bool write(const yarp::os::idl::WireWriter& writer) const override;
559 bool read(yarp::os::idl::WireReader& reader) override;
560
562 };
563
565 void call(FrameGrabberMsgs* ptr);
566
569
570 static constexpr const char* s_tag{"getRgbResolutionRPC"};
571 static constexpr size_t s_tag_len{1};
572 static constexpr size_t s_cmd_len{1};
573 static constexpr size_t s_reply_len{3};
574 static constexpr const char* s_prototype{"IRGBVisualParamsMsgs_return_getRgbResolution FrameGrabberMsgs::getRgbResolutionRPC()"};
575 static constexpr const char* s_help{""};
576};
577
578// setRgbResolutionRPC helper class declaration
580 public yarp::os::Portable
581{
582public:
584 FrameGrabberMsgs_setRgbResolutionRPC_helper(const std::int32_t width, const std::int32_t height);
585 bool write(yarp::os::ConnectionWriter& connection) const override;
586 bool read(yarp::os::ConnectionReader& connection) override;
587
588 class Command :
590 {
591 public:
592 Command() = default;
593 Command(const std::int32_t width, const std::int32_t height);
594
595 ~Command() override = default;
596
597 bool write(yarp::os::ConnectionWriter& connection) const override;
598 bool read(yarp::os::ConnectionReader& connection) override;
599
600 bool write(const yarp::os::idl::WireWriter& writer) const override;
601 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
602 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
603
604 bool read(yarp::os::idl::WireReader& reader) override;
607
608 std::int32_t width{0};
609 std::int32_t height{0};
610 };
611
612 class Reply :
614 {
615 public:
616 Reply() = default;
617 ~Reply() override = default;
618
619 bool write(yarp::os::ConnectionWriter& connection) const override;
620 bool read(yarp::os::ConnectionReader& connection) override;
621
622 bool write(const yarp::os::idl::WireWriter& writer) const override;
623 bool read(yarp::os::idl::WireReader& reader) override;
624
626 };
627
628 using funcptr_t = yarp::dev::ReturnValue (*)(const std::int32_t, const std::int32_t);
629 void call(FrameGrabberMsgs* ptr);
630
633
634 static constexpr const char* s_tag{"setRgbResolutionRPC"};
635 static constexpr size_t s_tag_len{1};
636 static constexpr size_t s_cmd_len{3};
637 static constexpr size_t s_reply_len{1};
638 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setRgbResolutionRPC(const std::int32_t width, const std::int32_t height)"};
639 static constexpr const char* s_help{""};
640};
641
642// getRgbFOVRPC helper class declaration
644 public yarp::os::Portable
645{
646public:
648 bool write(yarp::os::ConnectionWriter& connection) const override;
649 bool read(yarp::os::ConnectionReader& connection) override;
650
651 class Command :
653 {
654 public:
655 Command() = default;
656 ~Command() override = default;
657
658 bool write(yarp::os::ConnectionWriter& connection) const override;
659 bool read(yarp::os::ConnectionReader& connection) override;
660
661 bool write(const yarp::os::idl::WireWriter& writer) const override;
662 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
663 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
664
665 bool read(yarp::os::idl::WireReader& reader) override;
668 };
669
670 class Reply :
672 {
673 public:
674 Reply() = default;
675 ~Reply() override = default;
676
677 bool write(yarp::os::ConnectionWriter& connection) const override;
678 bool read(yarp::os::ConnectionReader& connection) override;
679
680 bool write(const yarp::os::idl::WireWriter& writer) const override;
681 bool read(yarp::os::idl::WireReader& reader) override;
682
684 };
685
687 void call(FrameGrabberMsgs* ptr);
688
691
692 static constexpr const char* s_tag{"getRgbFOVRPC"};
693 static constexpr size_t s_tag_len{1};
694 static constexpr size_t s_cmd_len{1};
695 static constexpr size_t s_reply_len{3};
696 static constexpr const char* s_prototype{"IRGBVisualParamsMsgs_return_getRgbFOV FrameGrabberMsgs::getRgbFOVRPC()"};
697 static constexpr const char* s_help{""};
698};
699
700// setRgbFOVRPC helper class declaration
702 public yarp::os::Portable
703{
704public:
706 FrameGrabberMsgs_setRgbFOVRPC_helper(const double horizontalFov, const double verticalFov);
707 bool write(yarp::os::ConnectionWriter& connection) const override;
708 bool read(yarp::os::ConnectionReader& connection) override;
709
710 class Command :
712 {
713 public:
714 Command() = default;
715 Command(const double horizontalFov, const double verticalFov);
716
717 ~Command() override = default;
718
719 bool write(yarp::os::ConnectionWriter& connection) const override;
720 bool read(yarp::os::ConnectionReader& connection) override;
721
722 bool write(const yarp::os::idl::WireWriter& writer) const override;
723 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
724 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
725
726 bool read(yarp::os::idl::WireReader& reader) override;
729
730 double horizontalFov{0.0};
731 double verticalFov{0.0};
732 };
733
734 class Reply :
736 {
737 public:
738 Reply() = default;
739 ~Reply() override = default;
740
741 bool write(yarp::os::ConnectionWriter& connection) const override;
742 bool read(yarp::os::ConnectionReader& connection) override;
743
744 bool write(const yarp::os::idl::WireWriter& writer) const override;
745 bool read(yarp::os::idl::WireReader& reader) override;
746
748 };
749
750 using funcptr_t = yarp::dev::ReturnValue (*)(const double, const double);
751 void call(FrameGrabberMsgs* ptr);
752
755
756 static constexpr const char* s_tag{"setRgbFOVRPC"};
757 static constexpr size_t s_tag_len{1};
758 static constexpr size_t s_cmd_len{3};
759 static constexpr size_t s_reply_len{1};
760 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setRgbFOVRPC(const double horizontalFov, const double verticalFov)"};
761 static constexpr const char* s_help{""};
762};
763
764// getRgbIntrinsicParamRPC helper class declaration
766 public yarp::os::Portable
767{
768public:
770 bool write(yarp::os::ConnectionWriter& connection) const override;
771 bool read(yarp::os::ConnectionReader& connection) override;
772
773 class Command :
775 {
776 public:
777 Command() = default;
778 ~Command() override = default;
779
780 bool write(yarp::os::ConnectionWriter& connection) const override;
781 bool read(yarp::os::ConnectionReader& connection) override;
782
783 bool write(const yarp::os::idl::WireWriter& writer) const override;
784 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
785 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
786
787 bool read(yarp::os::idl::WireReader& reader) override;
790 };
791
792 class Reply :
794 {
795 public:
796 Reply() = default;
797 ~Reply() override = default;
798
799 bool write(yarp::os::ConnectionWriter& connection) const override;
800 bool read(yarp::os::ConnectionReader& connection) override;
801
802 bool write(const yarp::os::idl::WireWriter& writer) const override;
803 bool read(yarp::os::idl::WireReader& reader) override;
804
806 };
807
809 void call(FrameGrabberMsgs* ptr);
810
813
814 static constexpr const char* s_tag{"getRgbIntrinsicParamRPC"};
815 static constexpr size_t s_tag_len{1};
816 static constexpr size_t s_cmd_len{1};
817 static constexpr size_t s_reply_len{2};
818 static constexpr const char* s_prototype{"IRGBVisualParamsMsgs_return_getRgbIntrinsicParam FrameGrabberMsgs::getRgbIntrinsicParamRPC()"};
819 static constexpr const char* s_help{""};
820};
821
822// getRgbMirroringRPC helper class declaration
824 public yarp::os::Portable
825{
826public:
828 bool write(yarp::os::ConnectionWriter& connection) const override;
829 bool read(yarp::os::ConnectionReader& connection) override;
830
831 class Command :
833 {
834 public:
835 Command() = default;
836 ~Command() override = default;
837
838 bool write(yarp::os::ConnectionWriter& connection) const override;
839 bool read(yarp::os::ConnectionReader& connection) override;
840
841 bool write(const yarp::os::idl::WireWriter& writer) const override;
842 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
843 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
844
845 bool read(yarp::os::idl::WireReader& reader) override;
848 };
849
850 class Reply :
852 {
853 public:
854 Reply() = default;
855 ~Reply() override = default;
856
857 bool write(yarp::os::ConnectionWriter& connection) const override;
858 bool read(yarp::os::ConnectionReader& connection) override;
859
860 bool write(const yarp::os::idl::WireWriter& writer) const override;
861 bool read(yarp::os::idl::WireReader& reader) override;
862
864 };
865
867 void call(FrameGrabberMsgs* ptr);
868
871
872 static constexpr const char* s_tag{"getRgbMirroringRPC"};
873 static constexpr size_t s_tag_len{1};
874 static constexpr size_t s_cmd_len{1};
875 static constexpr size_t s_reply_len{2};
876 static constexpr const char* s_prototype{"IRGBVisualParamsMsgs_return_getRgbMirroring FrameGrabberMsgs::getRgbMirroringRPC()"};
877 static constexpr const char* s_help{""};
878};
879
880// setRgbMirroringRPC helper class declaration
882 public yarp::os::Portable
883{
884public:
886 explicit FrameGrabberMsgs_setRgbMirroringRPC_helper(const bool mirror);
887 bool write(yarp::os::ConnectionWriter& connection) const override;
888 bool read(yarp::os::ConnectionReader& connection) override;
889
890 class Command :
892 {
893 public:
894 Command() = default;
895 explicit Command(const bool mirror);
896
897 ~Command() override = default;
898
899 bool write(yarp::os::ConnectionWriter& connection) const override;
900 bool read(yarp::os::ConnectionReader& connection) override;
901
902 bool write(const yarp::os::idl::WireWriter& writer) const override;
903 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
904 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
905
906 bool read(yarp::os::idl::WireReader& reader) override;
909
910 bool mirror{false};
911 };
912
913 class Reply :
915 {
916 public:
917 Reply() = default;
918 ~Reply() override = default;
919
920 bool write(yarp::os::ConnectionWriter& connection) const override;
921 bool read(yarp::os::ConnectionReader& connection) override;
922
923 bool write(const yarp::os::idl::WireWriter& writer) const override;
924 bool read(yarp::os::idl::WireReader& reader) override;
925
927 };
928
929 using funcptr_t = yarp::dev::ReturnValue (*)(const bool);
930 void call(FrameGrabberMsgs* ptr);
931
934
935 static constexpr const char* s_tag{"setRgbMirroringRPC"};
936 static constexpr size_t s_tag_len{1};
937 static constexpr size_t s_cmd_len{2};
938 static constexpr size_t s_reply_len{1};
939 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setRgbMirroringRPC(const bool mirror)"};
940 static constexpr const char* s_help{""};
941};
942
943// getCameraDescriptionRPC helper class declaration
945 public yarp::os::Portable
946{
947public:
949 bool write(yarp::os::ConnectionWriter& connection) const override;
950 bool read(yarp::os::ConnectionReader& connection) override;
951
952 class Command :
954 {
955 public:
956 Command() = default;
957 ~Command() override = default;
958
959 bool write(yarp::os::ConnectionWriter& connection) const override;
960 bool read(yarp::os::ConnectionReader& connection) override;
961
962 bool write(const yarp::os::idl::WireWriter& writer) const override;
963 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
964 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
965
966 bool read(yarp::os::idl::WireReader& reader) override;
969 };
970
971 class Reply :
973 {
974 public:
975 Reply() = default;
976 ~Reply() override = default;
977
978 bool write(yarp::os::ConnectionWriter& connection) const override;
979 bool read(yarp::os::ConnectionReader& connection) override;
980
981 bool write(const yarp::os::idl::WireWriter& writer) const override;
982 bool read(yarp::os::idl::WireReader& reader) override;
983
985 };
986
988 void call(FrameGrabberMsgs* ptr);
989
992
993 static constexpr const char* s_tag{"getCameraDescriptionRPC"};
994 static constexpr size_t s_tag_len{1};
995 static constexpr size_t s_cmd_len{1};
996 static constexpr size_t s_reply_len{3};
997 static constexpr const char* s_prototype{"IFrameGrabberControlMsgs_return_getCameraDescription FrameGrabberMsgs::getCameraDescriptionRPC()"};
998 static constexpr const char* s_help{""};
999};
1000
1001// hasFeatureRPC helper class declaration
1003 public yarp::os::Portable
1004{
1005public:
1007 explicit FrameGrabberMsgs_hasFeatureRPC_helper(const std::int32_t feature);
1008 bool write(yarp::os::ConnectionWriter& connection) const override;
1009 bool read(yarp::os::ConnectionReader& connection) override;
1010
1011 class Command :
1013 {
1014 public:
1015 Command() = default;
1016 explicit Command(const std::int32_t feature);
1017
1018 ~Command() override = default;
1019
1020 bool write(yarp::os::ConnectionWriter& connection) const override;
1021 bool read(yarp::os::ConnectionReader& connection) override;
1022
1023 bool write(const yarp::os::idl::WireWriter& writer) const override;
1024 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1025 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1026
1027 bool read(yarp::os::idl::WireReader& reader) override;
1028 bool readTag(yarp::os::idl::WireReader& reader);
1029 bool readArgs(yarp::os::idl::WireReader& reader);
1030
1031 std::int32_t feature{0};
1032 };
1033
1034 class Reply :
1036 {
1037 public:
1038 Reply() = default;
1039 ~Reply() override = default;
1040
1041 bool write(yarp::os::ConnectionWriter& connection) const override;
1042 bool read(yarp::os::ConnectionReader& connection) override;
1043
1044 bool write(const yarp::os::idl::WireWriter& writer) const override;
1045 bool read(yarp::os::idl::WireReader& reader) override;
1046
1048 };
1049
1051 void call(FrameGrabberMsgs* ptr);
1052
1055
1056 static constexpr const char* s_tag{"hasFeatureRPC"};
1057 static constexpr size_t s_tag_len{1};
1058 static constexpr size_t s_cmd_len{2};
1059 static constexpr size_t s_reply_len{2};
1060 static constexpr const char* s_prototype{"IFrameGrabberControlMsgs_return_hasFeature FrameGrabberMsgs::hasFeatureRPC(const std::int32_t feature)"};
1061 static constexpr const char* s_help{""};
1062};
1063
1064// setFeature1RPC helper class declaration
1066 public yarp::os::Portable
1067{
1068public:
1070 FrameGrabberMsgs_setFeature1RPC_helper(const std::int32_t feature, const double value);
1071 bool write(yarp::os::ConnectionWriter& connection) const override;
1072 bool read(yarp::os::ConnectionReader& connection) override;
1073
1074 class Command :
1076 {
1077 public:
1078 Command() = default;
1079 Command(const std::int32_t feature, const double value);
1080
1081 ~Command() override = default;
1082
1083 bool write(yarp::os::ConnectionWriter& connection) const override;
1084 bool read(yarp::os::ConnectionReader& connection) override;
1085
1086 bool write(const yarp::os::idl::WireWriter& writer) const override;
1087 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1088 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1089
1090 bool read(yarp::os::idl::WireReader& reader) override;
1091 bool readTag(yarp::os::idl::WireReader& reader);
1092 bool readArgs(yarp::os::idl::WireReader& reader);
1093
1094 std::int32_t feature{0};
1095 double value{0.0};
1096 };
1097
1098 class Reply :
1100 {
1101 public:
1102 Reply() = default;
1103 ~Reply() override = default;
1104
1105 bool write(yarp::os::ConnectionWriter& connection) const override;
1106 bool read(yarp::os::ConnectionReader& connection) override;
1107
1108 bool write(const yarp::os::idl::WireWriter& writer) const override;
1109 bool read(yarp::os::idl::WireReader& reader) override;
1110
1112 };
1113
1114 using funcptr_t = yarp::dev::ReturnValue (*)(const std::int32_t, const double);
1115 void call(FrameGrabberMsgs* ptr);
1116
1119
1120 static constexpr const char* s_tag{"setFeature1RPC"};
1121 static constexpr size_t s_tag_len{1};
1122 static constexpr size_t s_cmd_len{3};
1123 static constexpr size_t s_reply_len{1};
1124 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setFeature1RPC(const std::int32_t feature, const double value)"};
1125 static constexpr const char* s_help{""};
1126};
1127
1128// getFeature1RPC helper class declaration
1130 public yarp::os::Portable
1131{
1132public:
1134 explicit FrameGrabberMsgs_getFeature1RPC_helper(const std::int32_t feature);
1135 bool write(yarp::os::ConnectionWriter& connection) const override;
1136 bool read(yarp::os::ConnectionReader& connection) override;
1137
1138 class Command :
1140 {
1141 public:
1142 Command() = default;
1143 explicit Command(const std::int32_t feature);
1144
1145 ~Command() 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 writeTag(const yarp::os::idl::WireWriter& writer) const;
1152 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1153
1154 bool read(yarp::os::idl::WireReader& reader) override;
1155 bool readTag(yarp::os::idl::WireReader& reader);
1156 bool readArgs(yarp::os::idl::WireReader& reader);
1157
1158 std::int32_t feature{0};
1159 };
1160
1161 class Reply :
1163 {
1164 public:
1165 Reply() = default;
1166 ~Reply() override = default;
1167
1168 bool write(yarp::os::ConnectionWriter& connection) const override;
1169 bool read(yarp::os::ConnectionReader& connection) override;
1170
1171 bool write(const yarp::os::idl::WireWriter& writer) const override;
1172 bool read(yarp::os::idl::WireReader& reader) override;
1173
1175 };
1176
1178 void call(FrameGrabberMsgs* ptr);
1179
1182
1183 static constexpr const char* s_tag{"getFeature1RPC"};
1184 static constexpr size_t s_tag_len{1};
1185 static constexpr size_t s_cmd_len{2};
1186 static constexpr size_t s_reply_len{2};
1187 static constexpr const char* s_prototype{"IFrameGrabberControlMsgs_return_getFeature1 FrameGrabberMsgs::getFeature1RPC(const std::int32_t feature)"};
1188 static constexpr const char* s_help{""};
1189};
1190
1191// setFeature2RPC helper class declaration
1193 public yarp::os::Portable
1194{
1195public:
1197 FrameGrabberMsgs_setFeature2RPC_helper(const std::int32_t feature, const double value1, const double value2);
1198 bool write(yarp::os::ConnectionWriter& connection) const override;
1199 bool read(yarp::os::ConnectionReader& connection) override;
1200
1201 class Command :
1203 {
1204 public:
1205 Command() = default;
1206 Command(const std::int32_t feature, const double value1, const double value2);
1207
1208 ~Command() override = default;
1209
1210 bool write(yarp::os::ConnectionWriter& connection) const override;
1211 bool read(yarp::os::ConnectionReader& connection) override;
1212
1213 bool write(const yarp::os::idl::WireWriter& writer) const override;
1214 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1215 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1216
1217 bool read(yarp::os::idl::WireReader& reader) override;
1218 bool readTag(yarp::os::idl::WireReader& reader);
1219 bool readArgs(yarp::os::idl::WireReader& reader);
1220
1221 std::int32_t feature{0};
1222 double value1{0.0};
1223 double value2{0.0};
1224 };
1225
1226 class Reply :
1228 {
1229 public:
1230 Reply() = default;
1231 ~Reply() override = default;
1232
1233 bool write(yarp::os::ConnectionWriter& connection) const override;
1234 bool read(yarp::os::ConnectionReader& connection) override;
1235
1236 bool write(const yarp::os::idl::WireWriter& writer) const override;
1237 bool read(yarp::os::idl::WireReader& reader) override;
1238
1240 };
1241
1242 using funcptr_t = yarp::dev::ReturnValue (*)(const std::int32_t, const double, const double);
1243 void call(FrameGrabberMsgs* ptr);
1244
1247
1248 static constexpr const char* s_tag{"setFeature2RPC"};
1249 static constexpr size_t s_tag_len{1};
1250 static constexpr size_t s_cmd_len{4};
1251 static constexpr size_t s_reply_len{1};
1252 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setFeature2RPC(const std::int32_t feature, const double value1, const double value2)"};
1253 static constexpr const char* s_help{""};
1254};
1255
1256// getFeature2RPC helper class declaration
1258 public yarp::os::Portable
1259{
1260public:
1262 explicit FrameGrabberMsgs_getFeature2RPC_helper(const std::int32_t feature);
1263 bool write(yarp::os::ConnectionWriter& connection) const override;
1264 bool read(yarp::os::ConnectionReader& connection) override;
1265
1266 class Command :
1268 {
1269 public:
1270 Command() = default;
1271 explicit Command(const std::int32_t feature);
1272
1273 ~Command() override = default;
1274
1275 bool write(yarp::os::ConnectionWriter& connection) const override;
1276 bool read(yarp::os::ConnectionReader& connection) override;
1277
1278 bool write(const yarp::os::idl::WireWriter& writer) const override;
1279 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1280 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1281
1282 bool read(yarp::os::idl::WireReader& reader) override;
1283 bool readTag(yarp::os::idl::WireReader& reader);
1284 bool readArgs(yarp::os::idl::WireReader& reader);
1285
1286 std::int32_t feature{0};
1287 };
1288
1289 class Reply :
1291 {
1292 public:
1293 Reply() = default;
1294 ~Reply() override = default;
1295
1296 bool write(yarp::os::ConnectionWriter& connection) const override;
1297 bool read(yarp::os::ConnectionReader& connection) override;
1298
1299 bool write(const yarp::os::idl::WireWriter& writer) const override;
1300 bool read(yarp::os::idl::WireReader& reader) override;
1301
1303 };
1304
1306 void call(FrameGrabberMsgs* ptr);
1307
1310
1311 static constexpr const char* s_tag{"getFeature2RPC"};
1312 static constexpr size_t s_tag_len{1};
1313 static constexpr size_t s_cmd_len{2};
1314 static constexpr size_t s_reply_len{3};
1315 static constexpr const char* s_prototype{"IFrameGrabberControlMsgs_return_getFeature2 FrameGrabberMsgs::getFeature2RPC(const std::int32_t feature)"};
1316 static constexpr const char* s_help{""};
1317};
1318
1319// hasOnOffRPC helper class declaration
1321 public yarp::os::Portable
1322{
1323public:
1325 explicit FrameGrabberMsgs_hasOnOffRPC_helper(const std::int32_t feature);
1326 bool write(yarp::os::ConnectionWriter& connection) const override;
1327 bool read(yarp::os::ConnectionReader& connection) override;
1328
1329 class Command :
1331 {
1332 public:
1333 Command() = default;
1334 explicit Command(const std::int32_t feature);
1335
1336 ~Command() override = default;
1337
1338 bool write(yarp::os::ConnectionWriter& connection) const override;
1339 bool read(yarp::os::ConnectionReader& connection) override;
1340
1341 bool write(const yarp::os::idl::WireWriter& writer) const override;
1342 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1343 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1344
1345 bool read(yarp::os::idl::WireReader& reader) override;
1346 bool readTag(yarp::os::idl::WireReader& reader);
1347 bool readArgs(yarp::os::idl::WireReader& reader);
1348
1349 std::int32_t feature{0};
1350 };
1351
1352 class Reply :
1354 {
1355 public:
1356 Reply() = default;
1357 ~Reply() override = default;
1358
1359 bool write(yarp::os::ConnectionWriter& connection) const override;
1360 bool read(yarp::os::ConnectionReader& connection) override;
1361
1362 bool write(const yarp::os::idl::WireWriter& writer) const override;
1363 bool read(yarp::os::idl::WireReader& reader) override;
1364
1366 };
1367
1369 void call(FrameGrabberMsgs* ptr);
1370
1373
1374 static constexpr const char* s_tag{"hasOnOffRPC"};
1375 static constexpr size_t s_tag_len{1};
1376 static constexpr size_t s_cmd_len{2};
1377 static constexpr size_t s_reply_len{2};
1378 static constexpr const char* s_prototype{"IFrameGrabberControlMsgs_return_hasOnOff FrameGrabberMsgs::hasOnOffRPC(const std::int32_t feature)"};
1379 static constexpr const char* s_help{""};
1380};
1381
1382// setActiveRPC helper class declaration
1384 public yarp::os::Portable
1385{
1386public:
1388 FrameGrabberMsgs_setActiveRPC_helper(const std::int32_t feature, const bool onoff);
1389 bool write(yarp::os::ConnectionWriter& connection) const override;
1390 bool read(yarp::os::ConnectionReader& connection) override;
1391
1392 class Command :
1394 {
1395 public:
1396 Command() = default;
1397 Command(const std::int32_t feature, const bool onoff);
1398
1399 ~Command() override = default;
1400
1401 bool write(yarp::os::ConnectionWriter& connection) const override;
1402 bool read(yarp::os::ConnectionReader& connection) override;
1403
1404 bool write(const yarp::os::idl::WireWriter& writer) const override;
1405 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1406 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1407
1408 bool read(yarp::os::idl::WireReader& reader) override;
1409 bool readTag(yarp::os::idl::WireReader& reader);
1410 bool readArgs(yarp::os::idl::WireReader& reader);
1411
1412 std::int32_t feature{0};
1413 bool onoff{false};
1414 };
1415
1416 class Reply :
1418 {
1419 public:
1420 Reply() = default;
1421 ~Reply() override = default;
1422
1423 bool write(yarp::os::ConnectionWriter& connection) const override;
1424 bool read(yarp::os::ConnectionReader& connection) override;
1425
1426 bool write(const yarp::os::idl::WireWriter& writer) const override;
1427 bool read(yarp::os::idl::WireReader& reader) override;
1428
1430 };
1431
1432 using funcptr_t = yarp::dev::ReturnValue (*)(const std::int32_t, const bool);
1433 void call(FrameGrabberMsgs* ptr);
1434
1437
1438 static constexpr const char* s_tag{"setActiveRPC"};
1439 static constexpr size_t s_tag_len{1};
1440 static constexpr size_t s_cmd_len{3};
1441 static constexpr size_t s_reply_len{1};
1442 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setActiveRPC(const std::int32_t feature, const bool onoff)"};
1443 static constexpr const char* s_help{""};
1444};
1445
1446// getActiveRPC helper class declaration
1448 public yarp::os::Portable
1449{
1450public:
1452 explicit FrameGrabberMsgs_getActiveRPC_helper(const std::int32_t feature);
1453 bool write(yarp::os::ConnectionWriter& connection) const override;
1454 bool read(yarp::os::ConnectionReader& connection) override;
1455
1456 class Command :
1458 {
1459 public:
1460 Command() = default;
1461 explicit Command(const std::int32_t feature);
1462
1463 ~Command() override = default;
1464
1465 bool write(yarp::os::ConnectionWriter& connection) const override;
1466 bool read(yarp::os::ConnectionReader& connection) override;
1467
1468 bool write(const yarp::os::idl::WireWriter& writer) const override;
1469 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1470 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1471
1472 bool read(yarp::os::idl::WireReader& reader) override;
1473 bool readTag(yarp::os::idl::WireReader& reader);
1474 bool readArgs(yarp::os::idl::WireReader& reader);
1475
1476 std::int32_t feature{0};
1477 };
1478
1479 class Reply :
1481 {
1482 public:
1483 Reply() = default;
1484 ~Reply() override = default;
1485
1486 bool write(yarp::os::ConnectionWriter& connection) const override;
1487 bool read(yarp::os::ConnectionReader& connection) override;
1488
1489 bool write(const yarp::os::idl::WireWriter& writer) const override;
1490 bool read(yarp::os::idl::WireReader& reader) override;
1491
1493 };
1494
1496 void call(FrameGrabberMsgs* ptr);
1497
1500
1501 static constexpr const char* s_tag{"getActiveRPC"};
1502 static constexpr size_t s_tag_len{1};
1503 static constexpr size_t s_cmd_len{2};
1504 static constexpr size_t s_reply_len{2};
1505 static constexpr const char* s_prototype{"IFrameGrabberControlMsgs_return_getActive FrameGrabberMsgs::getActiveRPC(const std::int32_t feature)"};
1506 static constexpr const char* s_help{""};
1507};
1508
1509// hasAutoRPC helper class declaration
1511 public yarp::os::Portable
1512{
1513public:
1515 explicit FrameGrabberMsgs_hasAutoRPC_helper(const std::int32_t feature);
1516 bool write(yarp::os::ConnectionWriter& connection) const override;
1517 bool read(yarp::os::ConnectionReader& connection) override;
1518
1519 class Command :
1521 {
1522 public:
1523 Command() = default;
1524 explicit Command(const std::int32_t feature);
1525
1526 ~Command() override = default;
1527
1528 bool write(yarp::os::ConnectionWriter& connection) const override;
1529 bool read(yarp::os::ConnectionReader& connection) override;
1530
1531 bool write(const yarp::os::idl::WireWriter& writer) const override;
1532 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1533 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1534
1535 bool read(yarp::os::idl::WireReader& reader) override;
1536 bool readTag(yarp::os::idl::WireReader& reader);
1537 bool readArgs(yarp::os::idl::WireReader& reader);
1538
1539 std::int32_t feature{0};
1540 };
1541
1542 class Reply :
1544 {
1545 public:
1546 Reply() = default;
1547 ~Reply() override = default;
1548
1549 bool write(yarp::os::ConnectionWriter& connection) const override;
1550 bool read(yarp::os::ConnectionReader& connection) override;
1551
1552 bool write(const yarp::os::idl::WireWriter& writer) const override;
1553 bool read(yarp::os::idl::WireReader& reader) override;
1554
1556 };
1557
1559 void call(FrameGrabberMsgs* ptr);
1560
1563
1564 static constexpr const char* s_tag{"hasAutoRPC"};
1565 static constexpr size_t s_tag_len{1};
1566 static constexpr size_t s_cmd_len{2};
1567 static constexpr size_t s_reply_len{2};
1568 static constexpr const char* s_prototype{"IFrameGrabberControlMsgs_return_hasAuto FrameGrabberMsgs::hasAutoRPC(const std::int32_t feature)"};
1569 static constexpr const char* s_help{""};
1570};
1571
1572// hasManualRPC helper class declaration
1574 public yarp::os::Portable
1575{
1576public:
1578 explicit FrameGrabberMsgs_hasManualRPC_helper(const std::int32_t feature);
1579 bool write(yarp::os::ConnectionWriter& connection) const override;
1580 bool read(yarp::os::ConnectionReader& connection) override;
1581
1582 class Command :
1584 {
1585 public:
1586 Command() = default;
1587 explicit Command(const std::int32_t feature);
1588
1589 ~Command() override = default;
1590
1591 bool write(yarp::os::ConnectionWriter& connection) const override;
1592 bool read(yarp::os::ConnectionReader& connection) override;
1593
1594 bool write(const yarp::os::idl::WireWriter& writer) const override;
1595 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1596 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1597
1598 bool read(yarp::os::idl::WireReader& reader) override;
1599 bool readTag(yarp::os::idl::WireReader& reader);
1600 bool readArgs(yarp::os::idl::WireReader& reader);
1601
1602 std::int32_t feature{0};
1603 };
1604
1605 class Reply :
1607 {
1608 public:
1609 Reply() = default;
1610 ~Reply() 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 read(yarp::os::idl::WireReader& reader) override;
1617
1619 };
1620
1622 void call(FrameGrabberMsgs* ptr);
1623
1626
1627 static constexpr const char* s_tag{"hasManualRPC"};
1628 static constexpr size_t s_tag_len{1};
1629 static constexpr size_t s_cmd_len{2};
1630 static constexpr size_t s_reply_len{2};
1631 static constexpr const char* s_prototype{"IFrameGrabberControlMsgs_return_hasManual FrameGrabberMsgs::hasManualRPC(const std::int32_t feature)"};
1632 static constexpr const char* s_help{""};
1633};
1634
1635// hasOnePushRPC helper class declaration
1637 public yarp::os::Portable
1638{
1639public:
1641 explicit FrameGrabberMsgs_hasOnePushRPC_helper(const std::int32_t feature);
1642 bool write(yarp::os::ConnectionWriter& connection) const override;
1643 bool read(yarp::os::ConnectionReader& connection) override;
1644
1645 class Command :
1647 {
1648 public:
1649 Command() = default;
1650 explicit Command(const std::int32_t feature);
1651
1652 ~Command() override = default;
1653
1654 bool write(yarp::os::ConnectionWriter& connection) const override;
1655 bool read(yarp::os::ConnectionReader& connection) override;
1656
1657 bool write(const yarp::os::idl::WireWriter& writer) const override;
1658 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1659 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1660
1661 bool read(yarp::os::idl::WireReader& reader) override;
1662 bool readTag(yarp::os::idl::WireReader& reader);
1663 bool readArgs(yarp::os::idl::WireReader& reader);
1664
1665 std::int32_t feature{0};
1666 };
1667
1668 class Reply :
1670 {
1671 public:
1672 Reply() = default;
1673 ~Reply() override = default;
1674
1675 bool write(yarp::os::ConnectionWriter& connection) const override;
1676 bool read(yarp::os::ConnectionReader& connection) override;
1677
1678 bool write(const yarp::os::idl::WireWriter& writer) const override;
1679 bool read(yarp::os::idl::WireReader& reader) override;
1680
1682 };
1683
1685 void call(FrameGrabberMsgs* ptr);
1686
1689
1690 static constexpr const char* s_tag{"hasOnePushRPC"};
1691 static constexpr size_t s_tag_len{1};
1692 static constexpr size_t s_cmd_len{2};
1693 static constexpr size_t s_reply_len{2};
1694 static constexpr const char* s_prototype{"IFrameGrabberControlMsgs_return_hasOnePush FrameGrabberMsgs::hasOnePushRPC(const std::int32_t feature)"};
1695 static constexpr const char* s_help{""};
1696};
1697
1698// setModeRPC helper class declaration
1700 public yarp::os::Portable
1701{
1702public:
1705 bool write(yarp::os::ConnectionWriter& connection) const override;
1706 bool read(yarp::os::ConnectionReader& connection) override;
1707
1708 class Command :
1710 {
1711 public:
1712 Command() = default;
1713 Command(const std::int32_t feature, const yarp::dev::FeatureMode mode);
1714
1715 ~Command() override = default;
1716
1717 bool write(yarp::os::ConnectionWriter& connection) const override;
1718 bool read(yarp::os::ConnectionReader& connection) override;
1719
1720 bool write(const yarp::os::idl::WireWriter& writer) const override;
1721 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1722 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1723
1724 bool read(yarp::os::idl::WireReader& reader) override;
1725 bool readTag(yarp::os::idl::WireReader& reader);
1726 bool readArgs(yarp::os::idl::WireReader& reader);
1727
1728 std::int32_t feature{0};
1730 };
1731
1732 class Reply :
1734 {
1735 public:
1736 Reply() = default;
1737 ~Reply() override = default;
1738
1739 bool write(yarp::os::ConnectionWriter& connection) const override;
1740 bool read(yarp::os::ConnectionReader& connection) override;
1741
1742 bool write(const yarp::os::idl::WireWriter& writer) const override;
1743 bool read(yarp::os::idl::WireReader& reader) override;
1744
1746 };
1747
1748 using funcptr_t = yarp::dev::ReturnValue (*)(const std::int32_t, const yarp::dev::FeatureMode);
1749 void call(FrameGrabberMsgs* ptr);
1750
1753
1754 static constexpr const char* s_tag{"setModeRPC"};
1755 static constexpr size_t s_tag_len{1};
1756 static constexpr size_t s_cmd_len{3};
1757 static constexpr size_t s_reply_len{1};
1758 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setModeRPC(const std::int32_t feature, const yarp::dev::FeatureMode mode)"};
1759 static constexpr const char* s_help{""};
1760};
1761
1762// getModeRPC helper class declaration
1764 public yarp::os::Portable
1765{
1766public:
1768 explicit FrameGrabberMsgs_getModeRPC_helper(const std::int32_t feature);
1769 bool write(yarp::os::ConnectionWriter& connection) const override;
1770 bool read(yarp::os::ConnectionReader& connection) override;
1771
1772 class Command :
1774 {
1775 public:
1776 Command() = default;
1777 explicit Command(const std::int32_t feature);
1778
1779 ~Command() override = default;
1780
1781 bool write(yarp::os::ConnectionWriter& connection) const override;
1782 bool read(yarp::os::ConnectionReader& connection) override;
1783
1784 bool write(const yarp::os::idl::WireWriter& writer) const override;
1785 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1786 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1787
1788 bool read(yarp::os::idl::WireReader& reader) override;
1789 bool readTag(yarp::os::idl::WireReader& reader);
1790 bool readArgs(yarp::os::idl::WireReader& reader);
1791
1792 std::int32_t feature{0};
1793 };
1794
1795 class Reply :
1797 {
1798 public:
1799 Reply() = default;
1800 ~Reply() override = default;
1801
1802 bool write(yarp::os::ConnectionWriter& connection) const override;
1803 bool read(yarp::os::ConnectionReader& connection) override;
1804
1805 bool write(const yarp::os::idl::WireWriter& writer) const override;
1806 bool read(yarp::os::idl::WireReader& reader) override;
1807
1809 };
1810
1812 void call(FrameGrabberMsgs* ptr);
1813
1816
1817 static constexpr const char* s_tag{"getModeRPC"};
1818 static constexpr size_t s_tag_len{1};
1819 static constexpr size_t s_cmd_len{2};
1820 static constexpr size_t s_reply_len{2};
1821 static constexpr const char* s_prototype{"IFrameGrabberControlMsgs_return_getMode FrameGrabberMsgs::getModeRPC(const std::int32_t feature)"};
1822 static constexpr const char* s_help{""};
1823};
1824
1825// setOnePushRPC helper class declaration
1827 public yarp::os::Portable
1828{
1829public:
1831 explicit FrameGrabberMsgs_setOnePushRPC_helper(const std::int32_t feature);
1832 bool write(yarp::os::ConnectionWriter& connection) const override;
1833 bool read(yarp::os::ConnectionReader& connection) override;
1834
1835 class Command :
1837 {
1838 public:
1839 Command() = default;
1840 explicit Command(const std::int32_t feature);
1841
1842 ~Command() override = default;
1843
1844 bool write(yarp::os::ConnectionWriter& connection) const override;
1845 bool read(yarp::os::ConnectionReader& connection) override;
1846
1847 bool write(const yarp::os::idl::WireWriter& writer) const override;
1848 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1849 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1850
1851 bool read(yarp::os::idl::WireReader& reader) override;
1852 bool readTag(yarp::os::idl::WireReader& reader);
1853 bool readArgs(yarp::os::idl::WireReader& reader);
1854
1855 std::int32_t feature{0};
1856 };
1857
1858 class Reply :
1860 {
1861 public:
1862 Reply() = default;
1863 ~Reply() override = default;
1864
1865 bool write(yarp::os::ConnectionWriter& connection) const override;
1866 bool read(yarp::os::ConnectionReader& connection) override;
1867
1868 bool write(const yarp::os::idl::WireWriter& writer) const override;
1869 bool read(yarp::os::idl::WireReader& reader) override;
1870
1872 };
1873
1874 using funcptr_t = yarp::dev::ReturnValue (*)(const std::int32_t);
1875 void call(FrameGrabberMsgs* ptr);
1876
1879
1880 static constexpr const char* s_tag{"setOnePushRPC"};
1881 static constexpr size_t s_tag_len{1};
1882 static constexpr size_t s_cmd_len{2};
1883 static constexpr size_t s_reply_len{1};
1884 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setOnePushRPC(const std::int32_t feature)"};
1885 static constexpr const char* s_help{""};
1886};
1887
1888// getVideoModeMaskDC1394RPC helper class declaration
1890 public yarp::os::Portable
1891{
1892public:
1894 bool write(yarp::os::ConnectionWriter& connection) const override;
1895 bool read(yarp::os::ConnectionReader& connection) override;
1896
1897 class Command :
1899 {
1900 public:
1901 Command() = default;
1902 ~Command() override = default;
1903
1904 bool write(yarp::os::ConnectionWriter& connection) const override;
1905 bool read(yarp::os::ConnectionReader& connection) override;
1906
1907 bool write(const yarp::os::idl::WireWriter& writer) const override;
1908 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1909 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1910
1911 bool read(yarp::os::idl::WireReader& reader) override;
1912 bool readTag(yarp::os::idl::WireReader& reader);
1913 bool readArgs(yarp::os::idl::WireReader& reader);
1914 };
1915
1916 class Reply :
1918 {
1919 public:
1920 Reply() = default;
1921 ~Reply() override = default;
1922
1923 bool write(yarp::os::ConnectionWriter& connection) const override;
1924 bool read(yarp::os::ConnectionReader& connection) override;
1925
1926 bool write(const yarp::os::idl::WireWriter& writer) const override;
1927 bool read(yarp::os::idl::WireReader& reader) override;
1928
1930 };
1931
1933 void call(FrameGrabberMsgs* ptr);
1934
1937
1938 static constexpr const char* s_tag{"getVideoModeMaskDC1394RPC"};
1939 static constexpr size_t s_tag_len{1};
1940 static constexpr size_t s_cmd_len{1};
1941 static constexpr size_t s_reply_len{2};
1942 static constexpr const char* s_prototype{"IFrameGrabberControlDC1394Msgs_return_getVideoModeMaskDC1394 FrameGrabberMsgs::getVideoModeMaskDC1394RPC()"};
1943 static constexpr const char* s_help{""};
1944};
1945
1946// getVideoModeDC1394RPC helper class declaration
1948 public yarp::os::Portable
1949{
1950public:
1952 bool write(yarp::os::ConnectionWriter& connection) const override;
1953 bool read(yarp::os::ConnectionReader& connection) override;
1954
1955 class Command :
1957 {
1958 public:
1959 Command() = default;
1960 ~Command() override = default;
1961
1962 bool write(yarp::os::ConnectionWriter& connection) const override;
1963 bool read(yarp::os::ConnectionReader& connection) override;
1964
1965 bool write(const yarp::os::idl::WireWriter& writer) const override;
1966 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1967 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1968
1969 bool read(yarp::os::idl::WireReader& reader) override;
1970 bool readTag(yarp::os::idl::WireReader& reader);
1971 bool readArgs(yarp::os::idl::WireReader& reader);
1972 };
1973
1974 class Reply :
1976 {
1977 public:
1978 Reply() = default;
1979 ~Reply() override = default;
1980
1981 bool write(yarp::os::ConnectionWriter& connection) const override;
1982 bool read(yarp::os::ConnectionReader& connection) override;
1983
1984 bool write(const yarp::os::idl::WireWriter& writer) const override;
1985 bool read(yarp::os::idl::WireReader& reader) override;
1986
1988 };
1989
1991 void call(FrameGrabberMsgs* ptr);
1992
1995
1996 static constexpr const char* s_tag{"getVideoModeDC1394RPC"};
1997 static constexpr size_t s_tag_len{1};
1998 static constexpr size_t s_cmd_len{1};
1999 static constexpr size_t s_reply_len{2};
2000 static constexpr const char* s_prototype{"IFrameGrabberControlDC1394Msgs_return_getVideoModeDC1394 FrameGrabberMsgs::getVideoModeDC1394RPC()"};
2001 static constexpr const char* s_help{""};
2002};
2003
2004// setVideoModeDC1394RPC helper class declaration
2006 public yarp::os::Portable
2007{
2008public:
2010 explicit FrameGrabberMsgs_setVideoModeDC1394RPC_helper(const std::int32_t videomode);
2011 bool write(yarp::os::ConnectionWriter& connection) const override;
2012 bool read(yarp::os::ConnectionReader& connection) override;
2013
2014 class Command :
2016 {
2017 public:
2018 Command() = default;
2019 explicit Command(const std::int32_t videomode);
2020
2021 ~Command() override = default;
2022
2023 bool write(yarp::os::ConnectionWriter& connection) const override;
2024 bool read(yarp::os::ConnectionReader& connection) override;
2025
2026 bool write(const yarp::os::idl::WireWriter& writer) const override;
2027 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2028 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2029
2030 bool read(yarp::os::idl::WireReader& reader) override;
2031 bool readTag(yarp::os::idl::WireReader& reader);
2032 bool readArgs(yarp::os::idl::WireReader& reader);
2033
2034 std::int32_t videomode{0};
2035 };
2036
2037 class Reply :
2039 {
2040 public:
2041 Reply() = default;
2042 ~Reply() override = default;
2043
2044 bool write(yarp::os::ConnectionWriter& connection) const override;
2045 bool read(yarp::os::ConnectionReader& connection) override;
2046
2047 bool write(const yarp::os::idl::WireWriter& writer) const override;
2048 bool read(yarp::os::idl::WireReader& reader) override;
2049
2051 };
2052
2053 using funcptr_t = yarp::dev::ReturnValue (*)(const std::int32_t);
2054 void call(FrameGrabberMsgs* ptr);
2055
2058
2059 static constexpr const char* s_tag{"setVideoModeDC1394RPC"};
2060 static constexpr size_t s_tag_len{1};
2061 static constexpr size_t s_cmd_len{2};
2062 static constexpr size_t s_reply_len{1};
2063 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setVideoModeDC1394RPC(const std::int32_t videomode)"};
2064 static constexpr const char* s_help{""};
2065};
2066
2067// getFPSMaskDC1394RPC helper class declaration
2069 public yarp::os::Portable
2070{
2071public:
2073 bool write(yarp::os::ConnectionWriter& connection) const override;
2074 bool read(yarp::os::ConnectionReader& connection) override;
2075
2076 class Command :
2078 {
2079 public:
2080 Command() = default;
2081 ~Command() override = default;
2082
2083 bool write(yarp::os::ConnectionWriter& connection) const override;
2084 bool read(yarp::os::ConnectionReader& connection) override;
2085
2086 bool write(const yarp::os::idl::WireWriter& writer) const override;
2087 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2088 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2089
2090 bool read(yarp::os::idl::WireReader& reader) override;
2091 bool readTag(yarp::os::idl::WireReader& reader);
2092 bool readArgs(yarp::os::idl::WireReader& reader);
2093 };
2094
2095 class Reply :
2097 {
2098 public:
2099 Reply() = default;
2100 ~Reply() override = default;
2101
2102 bool write(yarp::os::ConnectionWriter& connection) const override;
2103 bool read(yarp::os::ConnectionReader& connection) override;
2104
2105 bool write(const yarp::os::idl::WireWriter& writer) const override;
2106 bool read(yarp::os::idl::WireReader& reader) override;
2107
2109 };
2110
2112 void call(FrameGrabberMsgs* ptr);
2113
2116
2117 static constexpr const char* s_tag{"getFPSMaskDC1394RPC"};
2118 static constexpr size_t s_tag_len{1};
2119 static constexpr size_t s_cmd_len{1};
2120 static constexpr size_t s_reply_len{2};
2121 static constexpr const char* s_prototype{"IFrameGrabberControlDC1394Msgs_return_getFPSMaskDC1394 FrameGrabberMsgs::getFPSMaskDC1394RPC()"};
2122 static constexpr const char* s_help{""};
2123};
2124
2125// getFPSDC1394RPC helper class declaration
2127 public yarp::os::Portable
2128{
2129public:
2131 bool write(yarp::os::ConnectionWriter& connection) const override;
2132 bool read(yarp::os::ConnectionReader& connection) override;
2133
2134 class Command :
2136 {
2137 public:
2138 Command() = default;
2139 ~Command() override = default;
2140
2141 bool write(yarp::os::ConnectionWriter& connection) const override;
2142 bool read(yarp::os::ConnectionReader& connection) override;
2143
2144 bool write(const yarp::os::idl::WireWriter& writer) const override;
2145 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2146 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2147
2148 bool read(yarp::os::idl::WireReader& reader) override;
2149 bool readTag(yarp::os::idl::WireReader& reader);
2150 bool readArgs(yarp::os::idl::WireReader& reader);
2151 };
2152
2153 class Reply :
2155 {
2156 public:
2157 Reply() = default;
2158 ~Reply() override = default;
2159
2160 bool write(yarp::os::ConnectionWriter& connection) const override;
2161 bool read(yarp::os::ConnectionReader& connection) override;
2162
2163 bool write(const yarp::os::idl::WireWriter& writer) const override;
2164 bool read(yarp::os::idl::WireReader& reader) override;
2165
2167 };
2168
2170 void call(FrameGrabberMsgs* ptr);
2171
2174
2175 static constexpr const char* s_tag{"getFPSDC1394RPC"};
2176 static constexpr size_t s_tag_len{1};
2177 static constexpr size_t s_cmd_len{1};
2178 static constexpr size_t s_reply_len{2};
2179 static constexpr const char* s_prototype{"IFrameGrabberControlDC1394Msgs_return_getFPSDC1394 FrameGrabberMsgs::getFPSDC1394RPC()"};
2180 static constexpr const char* s_help{""};
2181};
2182
2183// setFPSDC1394RPC helper class declaration
2185 public yarp::os::Portable
2186{
2187public:
2189 explicit FrameGrabberMsgs_setFPSDC1394RPC_helper(const std::int32_t fps);
2190 bool write(yarp::os::ConnectionWriter& connection) const override;
2191 bool read(yarp::os::ConnectionReader& connection) override;
2192
2193 class Command :
2195 {
2196 public:
2197 Command() = default;
2198 explicit Command(const std::int32_t fps);
2199
2200 ~Command() override = default;
2201
2202 bool write(yarp::os::ConnectionWriter& connection) const override;
2203 bool read(yarp::os::ConnectionReader& connection) override;
2204
2205 bool write(const yarp::os::idl::WireWriter& writer) const override;
2206 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2207 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2208
2209 bool read(yarp::os::idl::WireReader& reader) override;
2210 bool readTag(yarp::os::idl::WireReader& reader);
2211 bool readArgs(yarp::os::idl::WireReader& reader);
2212
2213 std::int32_t fps{0};
2214 };
2215
2216 class Reply :
2218 {
2219 public:
2220 Reply() = default;
2221 ~Reply() override = default;
2222
2223 bool write(yarp::os::ConnectionWriter& connection) const override;
2224 bool read(yarp::os::ConnectionReader& connection) override;
2225
2226 bool write(const yarp::os::idl::WireWriter& writer) const override;
2227 bool read(yarp::os::idl::WireReader& reader) override;
2228
2230 };
2231
2232 using funcptr_t = yarp::dev::ReturnValue (*)(const std::int32_t);
2233 void call(FrameGrabberMsgs* ptr);
2234
2237
2238 static constexpr const char* s_tag{"setFPSDC1394RPC"};
2239 static constexpr size_t s_tag_len{1};
2240 static constexpr size_t s_cmd_len{2};
2241 static constexpr size_t s_reply_len{1};
2242 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setFPSDC1394RPC(const std::int32_t fps)"};
2243 static constexpr const char* s_help{""};
2244};
2245
2246// getISOSpeedDC1394RPC helper class declaration
2248 public yarp::os::Portable
2249{
2250public:
2252 bool write(yarp::os::ConnectionWriter& connection) const override;
2253 bool read(yarp::os::ConnectionReader& connection) override;
2254
2255 class Command :
2257 {
2258 public:
2259 Command() = default;
2260 ~Command() override = default;
2261
2262 bool write(yarp::os::ConnectionWriter& connection) const override;
2263 bool read(yarp::os::ConnectionReader& connection) override;
2264
2265 bool write(const yarp::os::idl::WireWriter& writer) const override;
2266 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2267 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2268
2269 bool read(yarp::os::idl::WireReader& reader) override;
2270 bool readTag(yarp::os::idl::WireReader& reader);
2271 bool readArgs(yarp::os::idl::WireReader& reader);
2272 };
2273
2274 class Reply :
2276 {
2277 public:
2278 Reply() = default;
2279 ~Reply() override = default;
2280
2281 bool write(yarp::os::ConnectionWriter& connection) const override;
2282 bool read(yarp::os::ConnectionReader& connection) override;
2283
2284 bool write(const yarp::os::idl::WireWriter& writer) const override;
2285 bool read(yarp::os::idl::WireReader& reader) override;
2286
2288 };
2289
2291 void call(FrameGrabberMsgs* ptr);
2292
2295
2296 static constexpr const char* s_tag{"getISOSpeedDC1394RPC"};
2297 static constexpr size_t s_tag_len{1};
2298 static constexpr size_t s_cmd_len{1};
2299 static constexpr size_t s_reply_len{2};
2300 static constexpr const char* s_prototype{"IFrameGrabberControlDC1394Msgs_return_getISOSpeedDC1394 FrameGrabberMsgs::getISOSpeedDC1394RPC()"};
2301 static constexpr const char* s_help{""};
2302};
2303
2304// setISOSpeedDC1394RPC helper class declaration
2306 public yarp::os::Portable
2307{
2308public:
2310 explicit FrameGrabberMsgs_setISOSpeedDC1394RPC_helper(const std::int32_t speed);
2311 bool write(yarp::os::ConnectionWriter& connection) const override;
2312 bool read(yarp::os::ConnectionReader& connection) override;
2313
2314 class Command :
2316 {
2317 public:
2318 Command() = default;
2319 explicit Command(const std::int32_t speed);
2320
2321 ~Command() override = default;
2322
2323 bool write(yarp::os::ConnectionWriter& connection) const override;
2324 bool read(yarp::os::ConnectionReader& connection) override;
2325
2326 bool write(const yarp::os::idl::WireWriter& writer) const override;
2327 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2328 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2329
2330 bool read(yarp::os::idl::WireReader& reader) override;
2331 bool readTag(yarp::os::idl::WireReader& reader);
2332 bool readArgs(yarp::os::idl::WireReader& reader);
2333
2334 std::int32_t speed{0};
2335 };
2336
2337 class Reply :
2339 {
2340 public:
2341 Reply() = default;
2342 ~Reply() override = default;
2343
2344 bool write(yarp::os::ConnectionWriter& connection) const override;
2345 bool read(yarp::os::ConnectionReader& connection) override;
2346
2347 bool write(const yarp::os::idl::WireWriter& writer) const override;
2348 bool read(yarp::os::idl::WireReader& reader) override;
2349
2351 };
2352
2353 using funcptr_t = yarp::dev::ReturnValue (*)(const std::int32_t);
2354 void call(FrameGrabberMsgs* ptr);
2355
2358
2359 static constexpr const char* s_tag{"setISOSpeedDC1394RPC"};
2360 static constexpr size_t s_tag_len{1};
2361 static constexpr size_t s_cmd_len{2};
2362 static constexpr size_t s_reply_len{1};
2363 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setISOSpeedDC1394RPC(const std::int32_t speed)"};
2364 static constexpr const char* s_help{""};
2365};
2366
2367// getColorCodingMaskDC1394RPC helper class declaration
2369 public yarp::os::Portable
2370{
2371public:
2373 explicit FrameGrabberMsgs_getColorCodingMaskDC1394RPC_helper(const std::int32_t videomode);
2374 bool write(yarp::os::ConnectionWriter& connection) const override;
2375 bool read(yarp::os::ConnectionReader& connection) override;
2376
2377 class Command :
2379 {
2380 public:
2381 Command() = default;
2382 explicit Command(const std::int32_t videomode);
2383
2384 ~Command() override = default;
2385
2386 bool write(yarp::os::ConnectionWriter& connection) const override;
2387 bool read(yarp::os::ConnectionReader& connection) override;
2388
2389 bool write(const yarp::os::idl::WireWriter& writer) const override;
2390 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2391 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2392
2393 bool read(yarp::os::idl::WireReader& reader) override;
2394 bool readTag(yarp::os::idl::WireReader& reader);
2395 bool readArgs(yarp::os::idl::WireReader& reader);
2396
2397 std::int32_t videomode{0};
2398 };
2399
2400 class Reply :
2402 {
2403 public:
2404 Reply() = default;
2405 ~Reply() override = default;
2406
2407 bool write(yarp::os::ConnectionWriter& connection) const override;
2408 bool read(yarp::os::ConnectionReader& connection) override;
2409
2410 bool write(const yarp::os::idl::WireWriter& writer) const override;
2411 bool read(yarp::os::idl::WireReader& reader) override;
2412
2414 };
2415
2417 void call(FrameGrabberMsgs* ptr);
2418
2421
2422 static constexpr const char* s_tag{"getColorCodingMaskDC1394RPC"};
2423 static constexpr size_t s_tag_len{1};
2424 static constexpr size_t s_cmd_len{2};
2425 static constexpr size_t s_reply_len{2};
2426 static constexpr const char* s_prototype{"IFrameGrabberControlDC1394Msgs_return_getColorCodingMaskDC1394 FrameGrabberMsgs::getColorCodingMaskDC1394RPC(const std::int32_t videomode)"};
2427 static constexpr const char* s_help{""};
2428};
2429
2430// getColorCodingDC1394RPC helper class declaration
2432 public yarp::os::Portable
2433{
2434public:
2436 bool write(yarp::os::ConnectionWriter& connection) const override;
2437 bool read(yarp::os::ConnectionReader& connection) override;
2438
2439 class Command :
2441 {
2442 public:
2443 Command() = default;
2444 ~Command() override = default;
2445
2446 bool write(yarp::os::ConnectionWriter& connection) const override;
2447 bool read(yarp::os::ConnectionReader& connection) override;
2448
2449 bool write(const yarp::os::idl::WireWriter& writer) const override;
2450 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2451 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2452
2453 bool read(yarp::os::idl::WireReader& reader) override;
2454 bool readTag(yarp::os::idl::WireReader& reader);
2455 bool readArgs(yarp::os::idl::WireReader& reader);
2456 };
2457
2458 class Reply :
2460 {
2461 public:
2462 Reply() = default;
2463 ~Reply() override = default;
2464
2465 bool write(yarp::os::ConnectionWriter& connection) const override;
2466 bool read(yarp::os::ConnectionReader& connection) override;
2467
2468 bool write(const yarp::os::idl::WireWriter& writer) const override;
2469 bool read(yarp::os::idl::WireReader& reader) override;
2470
2472 };
2473
2475 void call(FrameGrabberMsgs* ptr);
2476
2479
2480 static constexpr const char* s_tag{"getColorCodingDC1394RPC"};
2481 static constexpr size_t s_tag_len{1};
2482 static constexpr size_t s_cmd_len{1};
2483 static constexpr size_t s_reply_len{2};
2484 static constexpr const char* s_prototype{"IFrameGrabberControlDC1394Msgs_return_getColorCodingDC1394 FrameGrabberMsgs::getColorCodingDC1394RPC()"};
2485 static constexpr const char* s_help{""};
2486};
2487
2488// setColorCodingDC1394RPC helper class declaration
2490 public yarp::os::Portable
2491{
2492public:
2494 explicit FrameGrabberMsgs_setColorCodingDC1394RPC_helper(const std::int32_t coding);
2495 bool write(yarp::os::ConnectionWriter& connection) const override;
2496 bool read(yarp::os::ConnectionReader& connection) override;
2497
2498 class Command :
2500 {
2501 public:
2502 Command() = default;
2503 explicit Command(const std::int32_t coding);
2504
2505 ~Command() override = default;
2506
2507 bool write(yarp::os::ConnectionWriter& connection) const override;
2508 bool read(yarp::os::ConnectionReader& connection) override;
2509
2510 bool write(const yarp::os::idl::WireWriter& writer) const override;
2511 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2512 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2513
2514 bool read(yarp::os::idl::WireReader& reader) override;
2515 bool readTag(yarp::os::idl::WireReader& reader);
2516 bool readArgs(yarp::os::idl::WireReader& reader);
2517
2518 std::int32_t coding{0};
2519 };
2520
2521 class Reply :
2523 {
2524 public:
2525 Reply() = default;
2526 ~Reply() override = default;
2527
2528 bool write(yarp::os::ConnectionWriter& connection) const override;
2529 bool read(yarp::os::ConnectionReader& connection) override;
2530
2531 bool write(const yarp::os::idl::WireWriter& writer) const override;
2532 bool read(yarp::os::idl::WireReader& reader) override;
2533
2535 };
2536
2537 using funcptr_t = yarp::dev::ReturnValue (*)(const std::int32_t);
2538 void call(FrameGrabberMsgs* ptr);
2539
2542
2543 static constexpr const char* s_tag{"setColorCodingDC1394RPC"};
2544 static constexpr size_t s_tag_len{1};
2545 static constexpr size_t s_cmd_len{2};
2546 static constexpr size_t s_reply_len{1};
2547 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setColorCodingDC1394RPC(const std::int32_t coding)"};
2548 static constexpr const char* s_help{""};
2549};
2550
2551// getFormat7MaxWindowDC1394RPC helper class declaration
2553 public yarp::os::Portable
2554{
2555public:
2557 bool write(yarp::os::ConnectionWriter& connection) const override;
2558 bool read(yarp::os::ConnectionReader& connection) override;
2559
2560 class Command :
2562 {
2563 public:
2564 Command() = default;
2565 ~Command() override = default;
2566
2567 bool write(yarp::os::ConnectionWriter& connection) const override;
2568 bool read(yarp::os::ConnectionReader& connection) override;
2569
2570 bool write(const yarp::os::idl::WireWriter& writer) const override;
2571 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2572 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2573
2574 bool read(yarp::os::idl::WireReader& reader) override;
2575 bool readTag(yarp::os::idl::WireReader& reader);
2576 bool readArgs(yarp::os::idl::WireReader& reader);
2577 };
2578
2579 class Reply :
2581 {
2582 public:
2583 Reply() = default;
2584 ~Reply() override = default;
2585
2586 bool write(yarp::os::ConnectionWriter& connection) const override;
2587 bool read(yarp::os::ConnectionReader& connection) override;
2588
2589 bool write(const yarp::os::idl::WireWriter& writer) const override;
2590 bool read(yarp::os::idl::WireReader& reader) override;
2591
2593 };
2594
2596 void call(FrameGrabberMsgs* ptr);
2597
2600
2601 static constexpr const char* s_tag{"getFormat7MaxWindowDC1394RPC"};
2602 static constexpr size_t s_tag_len{1};
2603 static constexpr size_t s_cmd_len{1};
2604 static constexpr size_t s_reply_len{7};
2605 static constexpr const char* s_prototype{"IFrameGrabberControlDC1394Msgs_return_getFormat7MaxWindowDC1394 FrameGrabberMsgs::getFormat7MaxWindowDC1394RPC()"};
2606 static constexpr const char* s_help{""};
2607};
2608
2609// getFormat7WindowDC1394RPC helper class declaration
2611 public yarp::os::Portable
2612{
2613public:
2615 bool write(yarp::os::ConnectionWriter& connection) const override;
2616 bool read(yarp::os::ConnectionReader& connection) override;
2617
2618 class Command :
2620 {
2621 public:
2622 Command() = default;
2623 ~Command() override = default;
2624
2625 bool write(yarp::os::ConnectionWriter& connection) const override;
2626 bool read(yarp::os::ConnectionReader& connection) override;
2627
2628 bool write(const yarp::os::idl::WireWriter& writer) const override;
2629 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2630 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2631
2632 bool read(yarp::os::idl::WireReader& reader) override;
2633 bool readTag(yarp::os::idl::WireReader& reader);
2634 bool readArgs(yarp::os::idl::WireReader& reader);
2635 };
2636
2637 class Reply :
2639 {
2640 public:
2641 Reply() = default;
2642 ~Reply() override = default;
2643
2644 bool write(yarp::os::ConnectionWriter& connection) const override;
2645 bool read(yarp::os::ConnectionReader& connection) override;
2646
2647 bool write(const yarp::os::idl::WireWriter& writer) const override;
2648 bool read(yarp::os::idl::WireReader& reader) override;
2649
2651 };
2652
2654 void call(FrameGrabberMsgs* ptr);
2655
2658
2659 static constexpr const char* s_tag{"getFormat7WindowDC1394RPC"};
2660 static constexpr size_t s_tag_len{1};
2661 static constexpr size_t s_cmd_len{1};
2662 static constexpr size_t s_reply_len{5};
2663 static constexpr const char* s_prototype{"IFrameGrabberControlDC1394Msgs_return_getFormat7WindowDC1394 FrameGrabberMsgs::getFormat7WindowDC1394RPC()"};
2664 static constexpr const char* s_help{""};
2665};
2666
2667// setFormat7WindowDC1394RPC helper class declaration
2669 public yarp::os::Portable
2670{
2671public:
2673 FrameGrabberMsgs_setFormat7WindowDC1394RPC_helper(const std::int32_t xdim, const std::int32_t ydim, const std::int32_t x0, const std::int32_t y0);
2674 bool write(yarp::os::ConnectionWriter& connection) const override;
2675 bool read(yarp::os::ConnectionReader& connection) override;
2676
2677 class Command :
2679 {
2680 public:
2681 Command() = default;
2682 Command(const std::int32_t xdim, const std::int32_t ydim, const std::int32_t x0, const std::int32_t y0);
2683
2684 ~Command() override = default;
2685
2686 bool write(yarp::os::ConnectionWriter& connection) const override;
2687 bool read(yarp::os::ConnectionReader& connection) override;
2688
2689 bool write(const yarp::os::idl::WireWriter& writer) const override;
2690 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2691 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2692
2693 bool read(yarp::os::idl::WireReader& reader) override;
2694 bool readTag(yarp::os::idl::WireReader& reader);
2695 bool readArgs(yarp::os::idl::WireReader& reader);
2696
2697 std::int32_t xdim{0};
2698 std::int32_t ydim{0};
2699 std::int32_t x0{0};
2700 std::int32_t y0{0};
2701 };
2702
2703 class Reply :
2705 {
2706 public:
2707 Reply() = default;
2708 ~Reply() override = default;
2709
2710 bool write(yarp::os::ConnectionWriter& connection) const override;
2711 bool read(yarp::os::ConnectionReader& connection) override;
2712
2713 bool write(const yarp::os::idl::WireWriter& writer) const override;
2714 bool read(yarp::os::idl::WireReader& reader) override;
2715
2717 };
2718
2719 using funcptr_t = yarp::dev::ReturnValue (*)(const std::int32_t, const std::int32_t, const std::int32_t, const std::int32_t);
2720 void call(FrameGrabberMsgs* ptr);
2721
2724
2725 static constexpr const char* s_tag{"setFormat7WindowDC1394RPC"};
2726 static constexpr size_t s_tag_len{1};
2727 static constexpr size_t s_cmd_len{5};
2728 static constexpr size_t s_reply_len{1};
2729 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setFormat7WindowDC1394RPC(const std::int32_t xdim, const std::int32_t ydim, const std::int32_t x0, const std::int32_t y0)"};
2730 static constexpr const char* s_help{""};
2731};
2732
2733// setOperationModeDC1394RPC helper class declaration
2735 public yarp::os::Portable
2736{
2737public:
2739 explicit FrameGrabberMsgs_setOperationModeDC1394RPC_helper(const bool b1394b);
2740 bool write(yarp::os::ConnectionWriter& connection) const override;
2741 bool read(yarp::os::ConnectionReader& connection) override;
2742
2743 class Command :
2745 {
2746 public:
2747 Command() = default;
2748 explicit Command(const bool b1394b);
2749
2750 ~Command() override = default;
2751
2752 bool write(yarp::os::ConnectionWriter& connection) const override;
2753 bool read(yarp::os::ConnectionReader& connection) override;
2754
2755 bool write(const yarp::os::idl::WireWriter& writer) const override;
2756 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2757 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2758
2759 bool read(yarp::os::idl::WireReader& reader) override;
2760 bool readTag(yarp::os::idl::WireReader& reader);
2761 bool readArgs(yarp::os::idl::WireReader& reader);
2762
2763 bool b1394b{false};
2764 };
2765
2766 class Reply :
2768 {
2769 public:
2770 Reply() = default;
2771 ~Reply() override = default;
2772
2773 bool write(yarp::os::ConnectionWriter& connection) const override;
2774 bool read(yarp::os::ConnectionReader& connection) override;
2775
2776 bool write(const yarp::os::idl::WireWriter& writer) const override;
2777 bool read(yarp::os::idl::WireReader& reader) override;
2778
2780 };
2781
2782 using funcptr_t = yarp::dev::ReturnValue (*)(const bool);
2783 void call(FrameGrabberMsgs* ptr);
2784
2787
2788 static constexpr const char* s_tag{"setOperationModeDC1394RPC"};
2789 static constexpr size_t s_tag_len{1};
2790 static constexpr size_t s_cmd_len{2};
2791 static constexpr size_t s_reply_len{1};
2792 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setOperationModeDC1394RPC(const bool b1394b)"};
2793 static constexpr const char* s_help{""};
2794};
2795
2796// getOperationModeDC1394RPC helper class declaration
2798 public yarp::os::Portable
2799{
2800public:
2802 bool write(yarp::os::ConnectionWriter& connection) const override;
2803 bool read(yarp::os::ConnectionReader& connection) override;
2804
2805 class Command :
2807 {
2808 public:
2809 Command() = default;
2810 ~Command() override = default;
2811
2812 bool write(yarp::os::ConnectionWriter& connection) const override;
2813 bool read(yarp::os::ConnectionReader& connection) override;
2814
2815 bool write(const yarp::os::idl::WireWriter& writer) const override;
2816 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2817 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2818
2819 bool read(yarp::os::idl::WireReader& reader) override;
2820 bool readTag(yarp::os::idl::WireReader& reader);
2821 bool readArgs(yarp::os::idl::WireReader& reader);
2822 };
2823
2824 class Reply :
2826 {
2827 public:
2828 Reply() = default;
2829 ~Reply() override = default;
2830
2831 bool write(yarp::os::ConnectionWriter& connection) const override;
2832 bool read(yarp::os::ConnectionReader& connection) override;
2833
2834 bool write(const yarp::os::idl::WireWriter& writer) const override;
2835 bool read(yarp::os::idl::WireReader& reader) override;
2836
2838 };
2839
2841 void call(FrameGrabberMsgs* ptr);
2842
2845
2846 static constexpr const char* s_tag{"getOperationModeDC1394RPC"};
2847 static constexpr size_t s_tag_len{1};
2848 static constexpr size_t s_cmd_len{1};
2849 static constexpr size_t s_reply_len{2};
2850 static constexpr const char* s_prototype{"IFrameGrabberControlDC1394Msgs_return_getOperationModeDC1394 FrameGrabberMsgs::getOperationModeDC1394RPC()"};
2851 static constexpr const char* s_help{""};
2852};
2853
2854// setTransmissionDC1394RPC helper class declaration
2856 public yarp::os::Portable
2857{
2858public:
2860 explicit FrameGrabberMsgs_setTransmissionDC1394RPC_helper(const bool bTxON);
2861 bool write(yarp::os::ConnectionWriter& connection) const override;
2862 bool read(yarp::os::ConnectionReader& connection) override;
2863
2864 class Command :
2866 {
2867 public:
2868 Command() = default;
2869 explicit Command(const bool bTxON);
2870
2871 ~Command() override = default;
2872
2873 bool write(yarp::os::ConnectionWriter& connection) const override;
2874 bool read(yarp::os::ConnectionReader& connection) override;
2875
2876 bool write(const yarp::os::idl::WireWriter& writer) const override;
2877 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2878 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2879
2880 bool read(yarp::os::idl::WireReader& reader) override;
2881 bool readTag(yarp::os::idl::WireReader& reader);
2882 bool readArgs(yarp::os::idl::WireReader& reader);
2883
2884 bool bTxON{false};
2885 };
2886
2887 class Reply :
2889 {
2890 public:
2891 Reply() = default;
2892 ~Reply() override = default;
2893
2894 bool write(yarp::os::ConnectionWriter& connection) const override;
2895 bool read(yarp::os::ConnectionReader& connection) override;
2896
2897 bool write(const yarp::os::idl::WireWriter& writer) const override;
2898 bool read(yarp::os::idl::WireReader& reader) override;
2899
2901 };
2902
2903 using funcptr_t = yarp::dev::ReturnValue (*)(const bool);
2904 void call(FrameGrabberMsgs* ptr);
2905
2908
2909 static constexpr const char* s_tag{"setTransmissionDC1394RPC"};
2910 static constexpr size_t s_tag_len{1};
2911 static constexpr size_t s_cmd_len{2};
2912 static constexpr size_t s_reply_len{1};
2913 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setTransmissionDC1394RPC(const bool bTxON)"};
2914 static constexpr const char* s_help{""};
2915};
2916
2917// getTransmissionDC1394RPC helper class declaration
2919 public yarp::os::Portable
2920{
2921public:
2923 bool write(yarp::os::ConnectionWriter& connection) const override;
2924 bool read(yarp::os::ConnectionReader& connection) override;
2925
2926 class Command :
2928 {
2929 public:
2930 Command() = default;
2931 ~Command() override = default;
2932
2933 bool write(yarp::os::ConnectionWriter& connection) const override;
2934 bool read(yarp::os::ConnectionReader& connection) override;
2935
2936 bool write(const yarp::os::idl::WireWriter& writer) const override;
2937 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2938 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2939
2940 bool read(yarp::os::idl::WireReader& reader) override;
2941 bool readTag(yarp::os::idl::WireReader& reader);
2942 bool readArgs(yarp::os::idl::WireReader& reader);
2943 };
2944
2945 class Reply :
2947 {
2948 public:
2949 Reply() = default;
2950 ~Reply() override = default;
2951
2952 bool write(yarp::os::ConnectionWriter& connection) const override;
2953 bool read(yarp::os::ConnectionReader& connection) override;
2954
2955 bool write(const yarp::os::idl::WireWriter& writer) const override;
2956 bool read(yarp::os::idl::WireReader& reader) override;
2957
2959 };
2960
2962 void call(FrameGrabberMsgs* ptr);
2963
2966
2967 static constexpr const char* s_tag{"getTransmissionDC1394RPC"};
2968 static constexpr size_t s_tag_len{1};
2969 static constexpr size_t s_cmd_len{1};
2970 static constexpr size_t s_reply_len{2};
2971 static constexpr const char* s_prototype{"IFrameGrabberControlDC1394Msgs_return_getTransmissionDC1394 FrameGrabberMsgs::getTransmissionDC1394RPC()"};
2972 static constexpr const char* s_help{""};
2973};
2974
2975// setBroadcastDC1394RPC helper class declaration
2977 public yarp::os::Portable
2978{
2979public:
2981 explicit FrameGrabberMsgs_setBroadcastDC1394RPC_helper(const bool onoff);
2982 bool write(yarp::os::ConnectionWriter& connection) const override;
2983 bool read(yarp::os::ConnectionReader& connection) override;
2984
2985 class Command :
2987 {
2988 public:
2989 Command() = default;
2990 explicit Command(const bool onoff);
2991
2992 ~Command() override = default;
2993
2994 bool write(yarp::os::ConnectionWriter& connection) const override;
2995 bool read(yarp::os::ConnectionReader& connection) override;
2996
2997 bool write(const yarp::os::idl::WireWriter& writer) const override;
2998 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2999 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
3000
3001 bool read(yarp::os::idl::WireReader& reader) override;
3002 bool readTag(yarp::os::idl::WireReader& reader);
3003 bool readArgs(yarp::os::idl::WireReader& reader);
3004
3005 bool onoff{false};
3006 };
3007
3008 class Reply :
3010 {
3011 public:
3012 Reply() = default;
3013 ~Reply() override = default;
3014
3015 bool write(yarp::os::ConnectionWriter& connection) const override;
3016 bool read(yarp::os::ConnectionReader& connection) override;
3017
3018 bool write(const yarp::os::idl::WireWriter& writer) const override;
3019 bool read(yarp::os::idl::WireReader& reader) override;
3020
3022 };
3023
3024 using funcptr_t = yarp::dev::ReturnValue (*)(const bool);
3025 void call(FrameGrabberMsgs* ptr);
3026
3029
3030 static constexpr const char* s_tag{"setBroadcastDC1394RPC"};
3031 static constexpr size_t s_tag_len{1};
3032 static constexpr size_t s_cmd_len{2};
3033 static constexpr size_t s_reply_len{1};
3034 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setBroadcastDC1394RPC(const bool onoff)"};
3035 static constexpr const char* s_help{""};
3036};
3037
3038// setDefaultsDC1394RPC helper class declaration
3040 public yarp::os::Portable
3041{
3042public:
3044 bool write(yarp::os::ConnectionWriter& connection) const override;
3045 bool read(yarp::os::ConnectionReader& connection) override;
3046
3047 class Command :
3049 {
3050 public:
3051 Command() = default;
3052 ~Command() override = default;
3053
3054 bool write(yarp::os::ConnectionWriter& connection) const override;
3055 bool read(yarp::os::ConnectionReader& connection) override;
3056
3057 bool write(const yarp::os::idl::WireWriter& writer) const override;
3058 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
3059 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
3060
3061 bool read(yarp::os::idl::WireReader& reader) override;
3062 bool readTag(yarp::os::idl::WireReader& reader);
3063 bool readArgs(yarp::os::idl::WireReader& reader);
3064 };
3065
3066 class Reply :
3068 {
3069 public:
3070 Reply() = default;
3071 ~Reply() override = default;
3072
3073 bool write(yarp::os::ConnectionWriter& connection) const override;
3074 bool read(yarp::os::ConnectionReader& connection) override;
3075
3076 bool write(const yarp::os::idl::WireWriter& writer) const override;
3077 bool read(yarp::os::idl::WireReader& reader) override;
3078
3080 };
3081
3083 void call(FrameGrabberMsgs* ptr);
3084
3087
3088 static constexpr const char* s_tag{"setDefaultsDC1394RPC"};
3089 static constexpr size_t s_tag_len{1};
3090 static constexpr size_t s_cmd_len{1};
3091 static constexpr size_t s_reply_len{1};
3092 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setDefaultsDC1394RPC()"};
3093 static constexpr const char* s_help{""};
3094};
3095
3096// setResetDC1394RPC helper class declaration
3098 public yarp::os::Portable
3099{
3100public:
3102 bool write(yarp::os::ConnectionWriter& connection) const override;
3103 bool read(yarp::os::ConnectionReader& connection) override;
3104
3105 class Command :
3107 {
3108 public:
3109 Command() = default;
3110 ~Command() override = default;
3111
3112 bool write(yarp::os::ConnectionWriter& connection) const override;
3113 bool read(yarp::os::ConnectionReader& connection) override;
3114
3115 bool write(const yarp::os::idl::WireWriter& writer) const override;
3116 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
3117 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
3118
3119 bool read(yarp::os::idl::WireReader& reader) override;
3120 bool readTag(yarp::os::idl::WireReader& reader);
3121 bool readArgs(yarp::os::idl::WireReader& reader);
3122 };
3123
3124 class Reply :
3126 {
3127 public:
3128 Reply() = default;
3129 ~Reply() override = default;
3130
3131 bool write(yarp::os::ConnectionWriter& connection) const override;
3132 bool read(yarp::os::ConnectionReader& connection) override;
3133
3134 bool write(const yarp::os::idl::WireWriter& writer) const override;
3135 bool read(yarp::os::idl::WireReader& reader) override;
3136
3138 };
3139
3141 void call(FrameGrabberMsgs* ptr);
3142
3145
3146 static constexpr const char* s_tag{"setResetDC1394RPC"};
3147 static constexpr size_t s_tag_len{1};
3148 static constexpr size_t s_cmd_len{1};
3149 static constexpr size_t s_reply_len{1};
3150 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setResetDC1394RPC()"};
3151 static constexpr const char* s_help{""};
3152};
3153
3154// setPowerDC1394RPC helper class declaration
3156 public yarp::os::Portable
3157{
3158public:
3160 explicit FrameGrabberMsgs_setPowerDC1394RPC_helper(const bool onoff);
3161 bool write(yarp::os::ConnectionWriter& connection) const override;
3162 bool read(yarp::os::ConnectionReader& connection) override;
3163
3164 class Command :
3166 {
3167 public:
3168 Command() = default;
3169 explicit Command(const bool onoff);
3170
3171 ~Command() override = default;
3172
3173 bool write(yarp::os::ConnectionWriter& connection) const override;
3174 bool read(yarp::os::ConnectionReader& connection) override;
3175
3176 bool write(const yarp::os::idl::WireWriter& writer) const override;
3177 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
3178 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
3179
3180 bool read(yarp::os::idl::WireReader& reader) override;
3181 bool readTag(yarp::os::idl::WireReader& reader);
3182 bool readArgs(yarp::os::idl::WireReader& reader);
3183
3184 bool onoff{false};
3185 };
3186
3187 class Reply :
3189 {
3190 public:
3191 Reply() = default;
3192 ~Reply() override = default;
3193
3194 bool write(yarp::os::ConnectionWriter& connection) const override;
3195 bool read(yarp::os::ConnectionReader& connection) override;
3196
3197 bool write(const yarp::os::idl::WireWriter& writer) const override;
3198 bool read(yarp::os::idl::WireReader& reader) override;
3199
3201 };
3202
3203 using funcptr_t = yarp::dev::ReturnValue (*)(const bool);
3204 void call(FrameGrabberMsgs* ptr);
3205
3208
3209 static constexpr const char* s_tag{"setPowerDC1394RPC"};
3210 static constexpr size_t s_tag_len{1};
3211 static constexpr size_t s_cmd_len{2};
3212 static constexpr size_t s_reply_len{1};
3213 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setPowerDC1394RPC(const bool onoff)"};
3214 static constexpr const char* s_help{""};
3215};
3216
3217// setCaptureDC1394RPC helper class declaration
3219 public yarp::os::Portable
3220{
3221public:
3223 explicit FrameGrabberMsgs_setCaptureDC1394RPC_helper(const bool bON);
3224 bool write(yarp::os::ConnectionWriter& connection) const override;
3225 bool read(yarp::os::ConnectionReader& connection) override;
3226
3227 class Command :
3229 {
3230 public:
3231 Command() = default;
3232 explicit Command(const bool bON);
3233
3234 ~Command() override = default;
3235
3236 bool write(yarp::os::ConnectionWriter& connection) const override;
3237 bool read(yarp::os::ConnectionReader& connection) override;
3238
3239 bool write(const yarp::os::idl::WireWriter& writer) const override;
3240 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
3241 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
3242
3243 bool read(yarp::os::idl::WireReader& reader) override;
3244 bool readTag(yarp::os::idl::WireReader& reader);
3245 bool readArgs(yarp::os::idl::WireReader& reader);
3246
3247 bool bON{false};
3248 };
3249
3250 class Reply :
3252 {
3253 public:
3254 Reply() = default;
3255 ~Reply() override = default;
3256
3257 bool write(yarp::os::ConnectionWriter& connection) const override;
3258 bool read(yarp::os::ConnectionReader& connection) override;
3259
3260 bool write(const yarp::os::idl::WireWriter& writer) const override;
3261 bool read(yarp::os::idl::WireReader& reader) override;
3262
3264 };
3265
3266 using funcptr_t = yarp::dev::ReturnValue (*)(const bool);
3267 void call(FrameGrabberMsgs* ptr);
3268
3271
3272 static constexpr const char* s_tag{"setCaptureDC1394RPC"};
3273 static constexpr size_t s_tag_len{1};
3274 static constexpr size_t s_cmd_len{2};
3275 static constexpr size_t s_reply_len{1};
3276 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setCaptureDC1394RPC(const bool bON)"};
3277 static constexpr const char* s_help{""};
3278};
3279
3280// getBytesPerPacketDC1394RPC helper class declaration
3282 public yarp::os::Portable
3283{
3284public:
3286 bool write(yarp::os::ConnectionWriter& connection) const override;
3287 bool read(yarp::os::ConnectionReader& connection) override;
3288
3289 class Command :
3291 {
3292 public:
3293 Command() = default;
3294 ~Command() override = default;
3295
3296 bool write(yarp::os::ConnectionWriter& connection) const override;
3297 bool read(yarp::os::ConnectionReader& connection) override;
3298
3299 bool write(const yarp::os::idl::WireWriter& writer) const override;
3300 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
3301 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
3302
3303 bool read(yarp::os::idl::WireReader& reader) override;
3304 bool readTag(yarp::os::idl::WireReader& reader);
3305 bool readArgs(yarp::os::idl::WireReader& reader);
3306 };
3307
3308 class Reply :
3310 {
3311 public:
3312 Reply() = default;
3313 ~Reply() override = default;
3314
3315 bool write(yarp::os::ConnectionWriter& connection) const override;
3316 bool read(yarp::os::ConnectionReader& connection) override;
3317
3318 bool write(const yarp::os::idl::WireWriter& writer) const override;
3319 bool read(yarp::os::idl::WireReader& reader) override;
3320
3322 };
3323
3325 void call(FrameGrabberMsgs* ptr);
3326
3329
3330 static constexpr const char* s_tag{"getBytesPerPacketDC1394RPC"};
3331 static constexpr size_t s_tag_len{1};
3332 static constexpr size_t s_cmd_len{1};
3333 static constexpr size_t s_reply_len{2};
3334 static constexpr const char* s_prototype{"IFrameGrabberControlDC1394Msgs_return_getBytesPerPacketDC1394 FrameGrabberMsgs::getBytesPerPacketDC1394RPC()"};
3335 static constexpr const char* s_help{""};
3336};
3337
3338// setBytesPerPacketDC1394RPC helper class declaration
3340 public yarp::os::Portable
3341{
3342public:
3344 explicit FrameGrabberMsgs_setBytesPerPacketDC1394RPC_helper(const std::int32_t bpp);
3345 bool write(yarp::os::ConnectionWriter& connection) const override;
3346 bool read(yarp::os::ConnectionReader& connection) override;
3347
3348 class Command :
3350 {
3351 public:
3352 Command() = default;
3353 explicit Command(const std::int32_t bpp);
3354
3355 ~Command() override = default;
3356
3357 bool write(yarp::os::ConnectionWriter& connection) const override;
3358 bool read(yarp::os::ConnectionReader& connection) override;
3359
3360 bool write(const yarp::os::idl::WireWriter& writer) const override;
3361 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
3362 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
3363
3364 bool read(yarp::os::idl::WireReader& reader) override;
3365 bool readTag(yarp::os::idl::WireReader& reader);
3366 bool readArgs(yarp::os::idl::WireReader& reader);
3367
3368 std::int32_t bpp{0};
3369 };
3370
3371 class Reply :
3373 {
3374 public:
3375 Reply() = default;
3376 ~Reply() override = default;
3377
3378 bool write(yarp::os::ConnectionWriter& connection) const override;
3379 bool read(yarp::os::ConnectionReader& connection) override;
3380
3381 bool write(const yarp::os::idl::WireWriter& writer) const override;
3382 bool read(yarp::os::idl::WireReader& reader) override;
3383
3385 };
3386
3387 using funcptr_t = yarp::dev::ReturnValue (*)(const std::int32_t);
3388 void call(FrameGrabberMsgs* ptr);
3389
3392
3393 static constexpr const char* s_tag{"setBytesPerPacketDC1394RPC"};
3394 static constexpr size_t s_tag_len{1};
3395 static constexpr size_t s_cmd_len{2};
3396 static constexpr size_t s_reply_len{1};
3397 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setBytesPerPacketDC1394RPC(const std::int32_t bpp)"};
3398 static constexpr const char* s_help{""};
3399};
3400
3401// getHeightRPC helper class implementation
3403{
3404 return cmd.write(connection);
3405}
3406
3408{
3409 return reply.read(connection);
3410}
3411
3413{
3414 yarp::os::idl::WireWriter writer(connection);
3415 if (!writer.writeListHeader(s_cmd_len)) {
3416 return false;
3417 }
3418 return write(writer);
3419}
3420
3422{
3423 yarp::os::idl::WireReader reader(connection);
3424 if (!reader.readListHeader()) {
3425 reader.fail();
3426 return false;
3427 }
3428 return read(reader);
3429}
3430
3432{
3433 if (!writeTag(writer)) {
3434 return false;
3435 }
3436 if (!writeArgs(writer)) {
3437 return false;
3438 }
3439 return true;
3440}
3441
3443{
3444 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3445 return false;
3446 }
3447 return true;
3448}
3449
3451{
3452 return true;
3453}
3454
3456{
3457 if (!readTag(reader)) {
3458 return false;
3459 }
3460 if (!readArgs(reader)) {
3461 return false;
3462 }
3463 return true;
3464}
3465
3467{
3468 std::string tag = reader.readTag(s_tag_len);
3469 if (reader.isError()) {
3470 return false;
3471 }
3472 if (tag != s_tag) {
3473 reader.fail();
3474 return false;
3475 }
3476 return true;
3477}
3478
3480{
3481 if (!reader.noMore()) {
3482 reader.fail();
3483 return false;
3484 }
3485 return true;
3486}
3487
3489{
3490 yarp::os::idl::WireWriter writer(connection);
3491 return write(writer);
3492}
3493
3495{
3496 yarp::os::idl::WireReader reader(connection);
3497 return read(reader);
3498}
3499
3501{
3502 if (!writer.isNull()) {
3503 if (!writer.writeListHeader(s_reply_len)) {
3504 return false;
3505 }
3506 if (!writer.write(return_helper)) {
3507 return false;
3508 }
3509 }
3510 return true;
3511}
3512
3514{
3515 if (!reader.readListReturn()) {
3516 return false;
3517 }
3518 if (reader.noMore()) {
3519 reader.fail();
3520 return false;
3521 }
3522 if (!reader.read(return_helper)) {
3523 reader.fail();
3524 return false;
3525 }
3526 return true;
3527}
3528
3533
3534// getWidthRPC helper class implementation
3536{
3537 return cmd.write(connection);
3538}
3539
3541{
3542 return reply.read(connection);
3543}
3544
3546{
3547 yarp::os::idl::WireWriter writer(connection);
3548 if (!writer.writeListHeader(s_cmd_len)) {
3549 return false;
3550 }
3551 return write(writer);
3552}
3553
3555{
3556 yarp::os::idl::WireReader reader(connection);
3557 if (!reader.readListHeader()) {
3558 reader.fail();
3559 return false;
3560 }
3561 return read(reader);
3562}
3563
3565{
3566 if (!writeTag(writer)) {
3567 return false;
3568 }
3569 if (!writeArgs(writer)) {
3570 return false;
3571 }
3572 return true;
3573}
3574
3576{
3577 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3578 return false;
3579 }
3580 return true;
3581}
3582
3584{
3585 return true;
3586}
3587
3589{
3590 if (!readTag(reader)) {
3591 return false;
3592 }
3593 if (!readArgs(reader)) {
3594 return false;
3595 }
3596 return true;
3597}
3598
3600{
3601 std::string tag = reader.readTag(s_tag_len);
3602 if (reader.isError()) {
3603 return false;
3604 }
3605 if (tag != s_tag) {
3606 reader.fail();
3607 return false;
3608 }
3609 return true;
3610}
3611
3613{
3614 if (!reader.noMore()) {
3615 reader.fail();
3616 return false;
3617 }
3618 return true;
3619}
3620
3622{
3623 yarp::os::idl::WireWriter writer(connection);
3624 return write(writer);
3625}
3626
3628{
3629 yarp::os::idl::WireReader reader(connection);
3630 return read(reader);
3631}
3632
3634{
3635 if (!writer.isNull()) {
3636 if (!writer.writeListHeader(s_reply_len)) {
3637 return false;
3638 }
3639 if (!writer.write(return_helper)) {
3640 return false;
3641 }
3642 }
3643 return true;
3644}
3645
3647{
3648 if (!reader.readListReturn()) {
3649 return false;
3650 }
3651 if (reader.noMore()) {
3652 reader.fail();
3653 return false;
3654 }
3655 if (!reader.read(return_helper)) {
3656 reader.fail();
3657 return false;
3658 }
3659 return true;
3660}
3661
3666
3667// getImageRPC helper class implementation
3669{
3670 return cmd.write(connection);
3671}
3672
3674{
3675 return reply.read(connection);
3676}
3677
3679{
3680 yarp::os::idl::WireWriter writer(connection);
3681 if (!writer.writeListHeader(s_cmd_len)) {
3682 return false;
3683 }
3684 return write(writer);
3685}
3686
3688{
3689 yarp::os::idl::WireReader reader(connection);
3690 if (!reader.readListHeader()) {
3691 reader.fail();
3692 return false;
3693 }
3694 return read(reader);
3695}
3696
3698{
3699 if (!writeTag(writer)) {
3700 return false;
3701 }
3702 if (!writeArgs(writer)) {
3703 return false;
3704 }
3705 return true;
3706}
3707
3709{
3710 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3711 return false;
3712 }
3713 return true;
3714}
3715
3717{
3718 return true;
3719}
3720
3722{
3723 if (!readTag(reader)) {
3724 return false;
3725 }
3726 if (!readArgs(reader)) {
3727 return false;
3728 }
3729 return true;
3730}
3731
3733{
3734 std::string tag = reader.readTag(s_tag_len);
3735 if (reader.isError()) {
3736 return false;
3737 }
3738 if (tag != s_tag) {
3739 reader.fail();
3740 return false;
3741 }
3742 return true;
3743}
3744
3746{
3747 if (!reader.noMore()) {
3748 reader.fail();
3749 return false;
3750 }
3751 return true;
3752}
3753
3755{
3756 yarp::os::idl::WireWriter writer(connection);
3757 return write(writer);
3758}
3759
3761{
3762 yarp::os::idl::WireReader reader(connection);
3763 return read(reader);
3764}
3765
3767{
3768 if (!writer.isNull()) {
3769 if (!writer.writeListHeader(s_reply_len)) {
3770 return false;
3771 }
3772 if (!writer.write(return_helper)) {
3773 return false;
3774 }
3775 }
3776 return true;
3777}
3778
3780{
3781 if (!reader.readListReturn()) {
3782 return false;
3783 }
3784 if (reader.noMore()) {
3785 reader.fail();
3786 return false;
3787 }
3788 if (!reader.read(return_helper)) {
3789 reader.fail();
3790 return false;
3791 }
3792 return true;
3793}
3794
3799
3800// getImageCropRPC helper class implementation
3802 cmd{type, vertices}
3803{
3804}
3805
3807{
3808 return cmd.write(connection);
3809}
3810
3812{
3813 return reply.read(connection);
3814}
3815
3816FrameGrabberMsgs_getImageCropRPC_helper::Command::Command(const yarp::dev::cropType_id_t type, const std::vector<yarp::dev::vertex_t>& vertices) :
3817 type{type},
3818 vertices{vertices}
3819{
3820}
3821
3823{
3824 yarp::os::idl::WireWriter writer(connection);
3825 if (!writer.writeListHeader(s_cmd_len)) {
3826 return false;
3827 }
3828 return write(writer);
3829}
3830
3832{
3833 yarp::os::idl::WireReader reader(connection);
3834 if (!reader.readListHeader()) {
3835 reader.fail();
3836 return false;
3837 }
3838 return read(reader);
3839}
3840
3842{
3843 if (!writeTag(writer)) {
3844 return false;
3845 }
3846 if (!writeArgs(writer)) {
3847 return false;
3848 }
3849 return true;
3850}
3851
3853{
3854 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3855 return false;
3856 }
3857 return true;
3858}
3859
3861{
3862 if (!writer.writeI32(static_cast<int32_t>(type))) {
3863 return false;
3864 }
3865 if (!writer.writeListBegin(BOTTLE_TAG_LIST, vertices.size())) {
3866 return false;
3867 }
3868 for (const auto& _item : vertices) {
3869 if (!writer.writeNested(_item)) {
3870 return false;
3871 }
3872 }
3873 if (!writer.writeListEnd()) {
3874 return false;
3875 }
3876 return true;
3877}
3878
3880{
3881 if (!readTag(reader)) {
3882 return false;
3883 }
3884 if (!readArgs(reader)) {
3885 return false;
3886 }
3887 return true;
3888}
3889
3891{
3892 std::string tag = reader.readTag(s_tag_len);
3893 if (reader.isError()) {
3894 return false;
3895 }
3896 if (tag != s_tag) {
3897 reader.fail();
3898 return false;
3899 }
3900 return true;
3901}
3902
3904{
3905 if (reader.noMore()) {
3906 reader.fail();
3907 return false;
3908 }
3909 int32_t _ecast;
3910 if (!reader.readI32(_ecast)) {
3911 reader.fail();
3912 return false;
3913 }
3914 type = static_cast<yarp::dev::cropType_id_t>(_ecast);
3915 if (reader.noMore()) {
3916 reader.fail();
3917 return false;
3918 }
3919 size_t _csize;
3921 reader.readListBegin(_etype, _csize);
3922 // WireReader removes BOTTLE_TAG_LIST from the tag
3923 constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
3924 if constexpr (expected_tag != 0) {
3925 if (_csize != 0 && _etype.code != expected_tag) {
3926 return false;
3927 }
3928 }
3929 vertices.resize(_csize);
3930 for (size_t _i = 0; _i < _csize; ++_i) {
3931 if (reader.noMore()) {
3932 reader.fail();
3933 return false;
3934 }
3935 if (!reader.readNested(vertices[_i])) {
3936 reader.fail();
3937 return false;
3938 }
3939 }
3940 reader.readListEnd();
3941 if (!reader.noMore()) {
3942 reader.fail();
3943 return false;
3944 }
3945 return true;
3946}
3947
3949{
3950 yarp::os::idl::WireWriter writer(connection);
3951 return write(writer);
3952}
3953
3955{
3956 yarp::os::idl::WireReader reader(connection);
3957 return read(reader);
3958}
3959
3961{
3962 if (!writer.isNull()) {
3963 if (!writer.writeListHeader(s_reply_len)) {
3964 return false;
3965 }
3966 if (!writer.write(return_helper)) {
3967 return false;
3968 }
3969 }
3970 return true;
3971}
3972
3974{
3975 if (!reader.readListReturn()) {
3976 return false;
3977 }
3978 if (reader.noMore()) {
3979 reader.fail();
3980 return false;
3981 }
3982 if (!reader.read(return_helper)) {
3983 reader.fail();
3984 return false;
3985 }
3986 return true;
3987}
3988
3993
3994// getRgbWidthRPC helper class implementation
3996{
3997 return cmd.write(connection);
3998}
3999
4001{
4002 return reply.read(connection);
4003}
4004
4006{
4007 yarp::os::idl::WireWriter writer(connection);
4008 if (!writer.writeListHeader(s_cmd_len)) {
4009 return false;
4010 }
4011 return write(writer);
4012}
4013
4015{
4016 yarp::os::idl::WireReader reader(connection);
4017 if (!reader.readListHeader()) {
4018 reader.fail();
4019 return false;
4020 }
4021 return read(reader);
4022}
4023
4025{
4026 if (!writeTag(writer)) {
4027 return false;
4028 }
4029 if (!writeArgs(writer)) {
4030 return false;
4031 }
4032 return true;
4033}
4034
4036{
4037 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4038 return false;
4039 }
4040 return true;
4041}
4042
4044{
4045 return true;
4046}
4047
4049{
4050 if (!readTag(reader)) {
4051 return false;
4052 }
4053 if (!readArgs(reader)) {
4054 return false;
4055 }
4056 return true;
4057}
4058
4060{
4061 std::string tag = reader.readTag(s_tag_len);
4062 if (reader.isError()) {
4063 return false;
4064 }
4065 if (tag != s_tag) {
4066 reader.fail();
4067 return false;
4068 }
4069 return true;
4070}
4071
4073{
4074 if (!reader.noMore()) {
4075 reader.fail();
4076 return false;
4077 }
4078 return true;
4079}
4080
4082{
4083 yarp::os::idl::WireWriter writer(connection);
4084 return write(writer);
4085}
4086
4088{
4089 yarp::os::idl::WireReader reader(connection);
4090 return read(reader);
4091}
4092
4094{
4095 if (!writer.isNull()) {
4096 if (!writer.writeListHeader(s_reply_len)) {
4097 return false;
4098 }
4099 if (!writer.write(return_helper)) {
4100 return false;
4101 }
4102 }
4103 return true;
4104}
4105
4107{
4108 if (!reader.readListReturn()) {
4109 return false;
4110 }
4111 if (reader.noMore()) {
4112 reader.fail();
4113 return false;
4114 }
4115 if (!reader.read(return_helper)) {
4116 reader.fail();
4117 return false;
4118 }
4119 return true;
4120}
4121
4126
4127// getRgbHeightRPC helper class implementation
4129{
4130 return cmd.write(connection);
4131}
4132
4134{
4135 return reply.read(connection);
4136}
4137
4139{
4140 yarp::os::idl::WireWriter writer(connection);
4141 if (!writer.writeListHeader(s_cmd_len)) {
4142 return false;
4143 }
4144 return write(writer);
4145}
4146
4148{
4149 yarp::os::idl::WireReader reader(connection);
4150 if (!reader.readListHeader()) {
4151 reader.fail();
4152 return false;
4153 }
4154 return read(reader);
4155}
4156
4158{
4159 if (!writeTag(writer)) {
4160 return false;
4161 }
4162 if (!writeArgs(writer)) {
4163 return false;
4164 }
4165 return true;
4166}
4167
4169{
4170 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4171 return false;
4172 }
4173 return true;
4174}
4175
4177{
4178 return true;
4179}
4180
4182{
4183 if (!readTag(reader)) {
4184 return false;
4185 }
4186 if (!readArgs(reader)) {
4187 return false;
4188 }
4189 return true;
4190}
4191
4193{
4194 std::string tag = reader.readTag(s_tag_len);
4195 if (reader.isError()) {
4196 return false;
4197 }
4198 if (tag != s_tag) {
4199 reader.fail();
4200 return false;
4201 }
4202 return true;
4203}
4204
4206{
4207 if (!reader.noMore()) {
4208 reader.fail();
4209 return false;
4210 }
4211 return true;
4212}
4213
4215{
4216 yarp::os::idl::WireWriter writer(connection);
4217 return write(writer);
4218}
4219
4221{
4222 yarp::os::idl::WireReader reader(connection);
4223 return read(reader);
4224}
4225
4227{
4228 if (!writer.isNull()) {
4229 if (!writer.writeListHeader(s_reply_len)) {
4230 return false;
4231 }
4232 if (!writer.write(return_helper)) {
4233 return false;
4234 }
4235 }
4236 return true;
4237}
4238
4240{
4241 if (!reader.readListReturn()) {
4242 return false;
4243 }
4244 if (reader.noMore()) {
4245 reader.fail();
4246 return false;
4247 }
4248 if (!reader.read(return_helper)) {
4249 reader.fail();
4250 return false;
4251 }
4252 return true;
4253}
4254
4259
4260// getRgbSupportedConfigurationsRPC helper class implementation
4265
4270
4272{
4273 yarp::os::idl::WireWriter writer(connection);
4274 if (!writer.writeListHeader(s_cmd_len)) {
4275 return false;
4276 }
4277 return write(writer);
4278}
4279
4281{
4282 yarp::os::idl::WireReader reader(connection);
4283 if (!reader.readListHeader()) {
4284 reader.fail();
4285 return false;
4286 }
4287 return read(reader);
4288}
4289
4291{
4292 if (!writeTag(writer)) {
4293 return false;
4294 }
4295 if (!writeArgs(writer)) {
4296 return false;
4297 }
4298 return true;
4299}
4300
4302{
4303 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4304 return false;
4305 }
4306 return true;
4307}
4308
4310{
4311 return true;
4312}
4313
4315{
4316 if (!readTag(reader)) {
4317 return false;
4318 }
4319 if (!readArgs(reader)) {
4320 return false;
4321 }
4322 return true;
4323}
4324
4326{
4327 std::string tag = reader.readTag(s_tag_len);
4328 if (reader.isError()) {
4329 return false;
4330 }
4331 if (tag != s_tag) {
4332 reader.fail();
4333 return false;
4334 }
4335 return true;
4336}
4337
4339{
4340 if (!reader.noMore()) {
4341 reader.fail();
4342 return false;
4343 }
4344 return true;
4345}
4346
4352
4358
4360{
4361 if (!writer.isNull()) {
4362 if (!writer.writeListHeader(s_reply_len)) {
4363 return false;
4364 }
4365 if (!writer.write(return_helper)) {
4366 return false;
4367 }
4368 }
4369 return true;
4370}
4371
4373{
4374 if (!reader.readListReturn()) {
4375 return false;
4376 }
4377 if (reader.noMore()) {
4378 reader.fail();
4379 return false;
4380 }
4381 if (!reader.read(return_helper)) {
4382 reader.fail();
4383 return false;
4384 }
4385 return true;
4386}
4387
4392
4393// getRgbResolutionRPC helper class implementation
4395{
4396 return cmd.write(connection);
4397}
4398
4403
4405{
4406 yarp::os::idl::WireWriter writer(connection);
4407 if (!writer.writeListHeader(s_cmd_len)) {
4408 return false;
4409 }
4410 return write(writer);
4411}
4412
4414{
4415 yarp::os::idl::WireReader reader(connection);
4416 if (!reader.readListHeader()) {
4417 reader.fail();
4418 return false;
4419 }
4420 return read(reader);
4421}
4422
4424{
4425 if (!writeTag(writer)) {
4426 return false;
4427 }
4428 if (!writeArgs(writer)) {
4429 return false;
4430 }
4431 return true;
4432}
4433
4435{
4436 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4437 return false;
4438 }
4439 return true;
4440}
4441
4443{
4444 return true;
4445}
4446
4448{
4449 if (!readTag(reader)) {
4450 return false;
4451 }
4452 if (!readArgs(reader)) {
4453 return false;
4454 }
4455 return true;
4456}
4457
4459{
4460 std::string tag = reader.readTag(s_tag_len);
4461 if (reader.isError()) {
4462 return false;
4463 }
4464 if (tag != s_tag) {
4465 reader.fail();
4466 return false;
4467 }
4468 return true;
4469}
4470
4472{
4473 if (!reader.noMore()) {
4474 reader.fail();
4475 return false;
4476 }
4477 return true;
4478}
4479
4481{
4482 yarp::os::idl::WireWriter writer(connection);
4483 return write(writer);
4484}
4485
4487{
4488 yarp::os::idl::WireReader reader(connection);
4489 return read(reader);
4490}
4491
4493{
4494 if (!writer.isNull()) {
4495 if (!writer.writeListHeader(s_reply_len)) {
4496 return false;
4497 }
4498 if (!writer.write(return_helper)) {
4499 return false;
4500 }
4501 }
4502 return true;
4503}
4504
4506{
4507 if (!reader.readListReturn()) {
4508 return false;
4509 }
4510 if (reader.noMore()) {
4511 reader.fail();
4512 return false;
4513 }
4514 if (!reader.read(return_helper)) {
4515 reader.fail();
4516 return false;
4517 }
4518 return true;
4519}
4520
4525
4526// setRgbResolutionRPC helper class implementation
4528 cmd{width, height}
4529{
4530}
4531
4533{
4534 return cmd.write(connection);
4535}
4536
4541
4542FrameGrabberMsgs_setRgbResolutionRPC_helper::Command::Command(const std::int32_t width, const std::int32_t height) :
4543 width{width},
4544 height{height}
4545{
4546}
4547
4549{
4550 yarp::os::idl::WireWriter writer(connection);
4551 if (!writer.writeListHeader(s_cmd_len)) {
4552 return false;
4553 }
4554 return write(writer);
4555}
4556
4558{
4559 yarp::os::idl::WireReader reader(connection);
4560 if (!reader.readListHeader()) {
4561 reader.fail();
4562 return false;
4563 }
4564 return read(reader);
4565}
4566
4568{
4569 if (!writeTag(writer)) {
4570 return false;
4571 }
4572 if (!writeArgs(writer)) {
4573 return false;
4574 }
4575 return true;
4576}
4577
4579{
4580 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4581 return false;
4582 }
4583 return true;
4584}
4585
4587{
4588 if (!writer.writeI32(width)) {
4589 return false;
4590 }
4591 if (!writer.writeI32(height)) {
4592 return false;
4593 }
4594 return true;
4595}
4596
4598{
4599 if (!readTag(reader)) {
4600 return false;
4601 }
4602 if (!readArgs(reader)) {
4603 return false;
4604 }
4605 return true;
4606}
4607
4609{
4610 std::string tag = reader.readTag(s_tag_len);
4611 if (reader.isError()) {
4612 return false;
4613 }
4614 if (tag != s_tag) {
4615 reader.fail();
4616 return false;
4617 }
4618 return true;
4619}
4620
4622{
4623 if (reader.noMore()) {
4624 reader.fail();
4625 return false;
4626 }
4627 if (!reader.readI32(width)) {
4628 reader.fail();
4629 return false;
4630 }
4631 if (reader.noMore()) {
4632 reader.fail();
4633 return false;
4634 }
4635 if (!reader.readI32(height)) {
4636 reader.fail();
4637 return false;
4638 }
4639 if (!reader.noMore()) {
4640 reader.fail();
4641 return false;
4642 }
4643 return true;
4644}
4645
4647{
4648 yarp::os::idl::WireWriter writer(connection);
4649 return write(writer);
4650}
4651
4653{
4654 yarp::os::idl::WireReader reader(connection);
4655 return read(reader);
4656}
4657
4659{
4660 if (!writer.isNull()) {
4661 if (!writer.write(return_helper)) {
4662 return false;
4663 }
4664 }
4665 return true;
4666}
4667
4669{
4670 if (reader.noMore()) {
4671 reader.fail();
4672 return false;
4673 }
4674 if (!reader.read(return_helper)) {
4675 reader.fail();
4676 return false;
4677 }
4678 return true;
4679}
4680
4685
4686// getRgbFOVRPC helper class implementation
4688{
4689 return cmd.write(connection);
4690}
4691
4693{
4694 return reply.read(connection);
4695}
4696
4698{
4699 yarp::os::idl::WireWriter writer(connection);
4700 if (!writer.writeListHeader(s_cmd_len)) {
4701 return false;
4702 }
4703 return write(writer);
4704}
4705
4707{
4708 yarp::os::idl::WireReader reader(connection);
4709 if (!reader.readListHeader()) {
4710 reader.fail();
4711 return false;
4712 }
4713 return read(reader);
4714}
4715
4717{
4718 if (!writeTag(writer)) {
4719 return false;
4720 }
4721 if (!writeArgs(writer)) {
4722 return false;
4723 }
4724 return true;
4725}
4726
4728{
4729 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4730 return false;
4731 }
4732 return true;
4733}
4734
4736{
4737 return true;
4738}
4739
4741{
4742 if (!readTag(reader)) {
4743 return false;
4744 }
4745 if (!readArgs(reader)) {
4746 return false;
4747 }
4748 return true;
4749}
4750
4752{
4753 std::string tag = reader.readTag(s_tag_len);
4754 if (reader.isError()) {
4755 return false;
4756 }
4757 if (tag != s_tag) {
4758 reader.fail();
4759 return false;
4760 }
4761 return true;
4762}
4763
4765{
4766 if (!reader.noMore()) {
4767 reader.fail();
4768 return false;
4769 }
4770 return true;
4771}
4772
4774{
4775 yarp::os::idl::WireWriter writer(connection);
4776 return write(writer);
4777}
4778
4780{
4781 yarp::os::idl::WireReader reader(connection);
4782 return read(reader);
4783}
4784
4786{
4787 if (!writer.isNull()) {
4788 if (!writer.writeListHeader(s_reply_len)) {
4789 return false;
4790 }
4791 if (!writer.write(return_helper)) {
4792 return false;
4793 }
4794 }
4795 return true;
4796}
4797
4799{
4800 if (!reader.readListReturn()) {
4801 return false;
4802 }
4803 if (reader.noMore()) {
4804 reader.fail();
4805 return false;
4806 }
4807 if (!reader.read(return_helper)) {
4808 reader.fail();
4809 return false;
4810 }
4811 return true;
4812}
4813
4818
4819// setRgbFOVRPC helper class implementation
4820FrameGrabberMsgs_setRgbFOVRPC_helper::FrameGrabberMsgs_setRgbFOVRPC_helper(const double horizontalFov, const double verticalFov) :
4821 cmd{horizontalFov, verticalFov}
4822{
4823}
4824
4826{
4827 return cmd.write(connection);
4828}
4829
4831{
4832 return reply.read(connection);
4833}
4834
4835FrameGrabberMsgs_setRgbFOVRPC_helper::Command::Command(const double horizontalFov, const double verticalFov) :
4836 horizontalFov{horizontalFov},
4837 verticalFov{verticalFov}
4838{
4839}
4840
4842{
4843 yarp::os::idl::WireWriter writer(connection);
4844 if (!writer.writeListHeader(s_cmd_len)) {
4845 return false;
4846 }
4847 return write(writer);
4848}
4849
4851{
4852 yarp::os::idl::WireReader reader(connection);
4853 if (!reader.readListHeader()) {
4854 reader.fail();
4855 return false;
4856 }
4857 return read(reader);
4858}
4859
4861{
4862 if (!writeTag(writer)) {
4863 return false;
4864 }
4865 if (!writeArgs(writer)) {
4866 return false;
4867 }
4868 return true;
4869}
4870
4872{
4873 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4874 return false;
4875 }
4876 return true;
4877}
4878
4880{
4881 if (!writer.writeFloat64(horizontalFov)) {
4882 return false;
4883 }
4884 if (!writer.writeFloat64(verticalFov)) {
4885 return false;
4886 }
4887 return true;
4888}
4889
4891{
4892 if (!readTag(reader)) {
4893 return false;
4894 }
4895 if (!readArgs(reader)) {
4896 return false;
4897 }
4898 return true;
4899}
4900
4902{
4903 std::string tag = reader.readTag(s_tag_len);
4904 if (reader.isError()) {
4905 return false;
4906 }
4907 if (tag != s_tag) {
4908 reader.fail();
4909 return false;
4910 }
4911 return true;
4912}
4913
4915{
4916 if (reader.noMore()) {
4917 reader.fail();
4918 return false;
4919 }
4920 if (!reader.readFloat64(horizontalFov)) {
4921 reader.fail();
4922 return false;
4923 }
4924 if (reader.noMore()) {
4925 reader.fail();
4926 return false;
4927 }
4928 if (!reader.readFloat64(verticalFov)) {
4929 reader.fail();
4930 return false;
4931 }
4932 if (!reader.noMore()) {
4933 reader.fail();
4934 return false;
4935 }
4936 return true;
4937}
4938
4940{
4941 yarp::os::idl::WireWriter writer(connection);
4942 return write(writer);
4943}
4944
4946{
4947 yarp::os::idl::WireReader reader(connection);
4948 return read(reader);
4949}
4950
4952{
4953 if (!writer.isNull()) {
4954 if (!writer.write(return_helper)) {
4955 return false;
4956 }
4957 }
4958 return true;
4959}
4960
4962{
4963 if (reader.noMore()) {
4964 reader.fail();
4965 return false;
4966 }
4967 if (!reader.read(return_helper)) {
4968 reader.fail();
4969 return false;
4970 }
4971 return true;
4972}
4973
4978
4979// getRgbIntrinsicParamRPC helper class implementation
4981{
4982 return cmd.write(connection);
4983}
4984
4989
4991{
4992 yarp::os::idl::WireWriter writer(connection);
4993 if (!writer.writeListHeader(s_cmd_len)) {
4994 return false;
4995 }
4996 return write(writer);
4997}
4998
5000{
5001 yarp::os::idl::WireReader reader(connection);
5002 if (!reader.readListHeader()) {
5003 reader.fail();
5004 return false;
5005 }
5006 return read(reader);
5007}
5008
5010{
5011 if (!writeTag(writer)) {
5012 return false;
5013 }
5014 if (!writeArgs(writer)) {
5015 return false;
5016 }
5017 return true;
5018}
5019
5021{
5022 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5023 return false;
5024 }
5025 return true;
5026}
5027
5029{
5030 return true;
5031}
5032
5034{
5035 if (!readTag(reader)) {
5036 return false;
5037 }
5038 if (!readArgs(reader)) {
5039 return false;
5040 }
5041 return true;
5042}
5043
5045{
5046 std::string tag = reader.readTag(s_tag_len);
5047 if (reader.isError()) {
5048 return false;
5049 }
5050 if (tag != s_tag) {
5051 reader.fail();
5052 return false;
5053 }
5054 return true;
5055}
5056
5058{
5059 if (!reader.noMore()) {
5060 reader.fail();
5061 return false;
5062 }
5063 return true;
5064}
5065
5067{
5068 yarp::os::idl::WireWriter writer(connection);
5069 return write(writer);
5070}
5071
5073{
5074 yarp::os::idl::WireReader reader(connection);
5075 return read(reader);
5076}
5077
5079{
5080 if (!writer.isNull()) {
5081 if (!writer.writeListHeader(s_reply_len)) {
5082 return false;
5083 }
5084 if (!writer.write(return_helper)) {
5085 return false;
5086 }
5087 }
5088 return true;
5089}
5090
5092{
5093 if (!reader.readListReturn()) {
5094 return false;
5095 }
5096 if (reader.noMore()) {
5097 reader.fail();
5098 return false;
5099 }
5100 if (!reader.read(return_helper)) {
5101 reader.fail();
5102 return false;
5103 }
5104 return true;
5105}
5106
5111
5112// getRgbMirroringRPC helper class implementation
5114{
5115 return cmd.write(connection);
5116}
5117
5119{
5120 return reply.read(connection);
5121}
5122
5124{
5125 yarp::os::idl::WireWriter writer(connection);
5126 if (!writer.writeListHeader(s_cmd_len)) {
5127 return false;
5128 }
5129 return write(writer);
5130}
5131
5133{
5134 yarp::os::idl::WireReader reader(connection);
5135 if (!reader.readListHeader()) {
5136 reader.fail();
5137 return false;
5138 }
5139 return read(reader);
5140}
5141
5143{
5144 if (!writeTag(writer)) {
5145 return false;
5146 }
5147 if (!writeArgs(writer)) {
5148 return false;
5149 }
5150 return true;
5151}
5152
5154{
5155 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5156 return false;
5157 }
5158 return true;
5159}
5160
5162{
5163 return true;
5164}
5165
5167{
5168 if (!readTag(reader)) {
5169 return false;
5170 }
5171 if (!readArgs(reader)) {
5172 return false;
5173 }
5174 return true;
5175}
5176
5178{
5179 std::string tag = reader.readTag(s_tag_len);
5180 if (reader.isError()) {
5181 return false;
5182 }
5183 if (tag != s_tag) {
5184 reader.fail();
5185 return false;
5186 }
5187 return true;
5188}
5189
5191{
5192 if (!reader.noMore()) {
5193 reader.fail();
5194 return false;
5195 }
5196 return true;
5197}
5198
5200{
5201 yarp::os::idl::WireWriter writer(connection);
5202 return write(writer);
5203}
5204
5206{
5207 yarp::os::idl::WireReader reader(connection);
5208 return read(reader);
5209}
5210
5212{
5213 if (!writer.isNull()) {
5214 if (!writer.writeListHeader(s_reply_len)) {
5215 return false;
5216 }
5217 if (!writer.write(return_helper)) {
5218 return false;
5219 }
5220 }
5221 return true;
5222}
5223
5225{
5226 if (!reader.readListReturn()) {
5227 return false;
5228 }
5229 if (reader.noMore()) {
5230 reader.fail();
5231 return false;
5232 }
5233 if (!reader.read(return_helper)) {
5234 reader.fail();
5235 return false;
5236 }
5237 return true;
5238}
5239
5244
5245// setRgbMirroringRPC helper class implementation
5250
5252{
5253 return cmd.write(connection);
5254}
5255
5257{
5258 return reply.read(connection);
5259}
5260
5262 mirror{mirror}
5263{
5264}
5265
5267{
5268 yarp::os::idl::WireWriter writer(connection);
5269 if (!writer.writeListHeader(s_cmd_len)) {
5270 return false;
5271 }
5272 return write(writer);
5273}
5274
5276{
5277 yarp::os::idl::WireReader reader(connection);
5278 if (!reader.readListHeader()) {
5279 reader.fail();
5280 return false;
5281 }
5282 return read(reader);
5283}
5284
5286{
5287 if (!writeTag(writer)) {
5288 return false;
5289 }
5290 if (!writeArgs(writer)) {
5291 return false;
5292 }
5293 return true;
5294}
5295
5297{
5298 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5299 return false;
5300 }
5301 return true;
5302}
5303
5305{
5306 if (!writer.writeBool(mirror)) {
5307 return false;
5308 }
5309 return true;
5310}
5311
5313{
5314 if (!readTag(reader)) {
5315 return false;
5316 }
5317 if (!readArgs(reader)) {
5318 return false;
5319 }
5320 return true;
5321}
5322
5324{
5325 std::string tag = reader.readTag(s_tag_len);
5326 if (reader.isError()) {
5327 return false;
5328 }
5329 if (tag != s_tag) {
5330 reader.fail();
5331 return false;
5332 }
5333 return true;
5334}
5335
5337{
5338 if (reader.noMore()) {
5339 reader.fail();
5340 return false;
5341 }
5342 if (!reader.readBool(mirror)) {
5343 reader.fail();
5344 return false;
5345 }
5346 if (!reader.noMore()) {
5347 reader.fail();
5348 return false;
5349 }
5350 return true;
5351}
5352
5354{
5355 yarp::os::idl::WireWriter writer(connection);
5356 return write(writer);
5357}
5358
5360{
5361 yarp::os::idl::WireReader reader(connection);
5362 return read(reader);
5363}
5364
5366{
5367 if (!writer.isNull()) {
5368 if (!writer.write(return_helper)) {
5369 return false;
5370 }
5371 }
5372 return true;
5373}
5374
5376{
5377 if (reader.noMore()) {
5378 reader.fail();
5379 return false;
5380 }
5381 if (!reader.read(return_helper)) {
5382 reader.fail();
5383 return false;
5384 }
5385 return true;
5386}
5387
5392
5393// getCameraDescriptionRPC helper class implementation
5395{
5396 return cmd.write(connection);
5397}
5398
5403
5405{
5406 yarp::os::idl::WireWriter writer(connection);
5407 if (!writer.writeListHeader(s_cmd_len)) {
5408 return false;
5409 }
5410 return write(writer);
5411}
5412
5414{
5415 yarp::os::idl::WireReader reader(connection);
5416 if (!reader.readListHeader()) {
5417 reader.fail();
5418 return false;
5419 }
5420 return read(reader);
5421}
5422
5424{
5425 if (!writeTag(writer)) {
5426 return false;
5427 }
5428 if (!writeArgs(writer)) {
5429 return false;
5430 }
5431 return true;
5432}
5433
5435{
5436 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5437 return false;
5438 }
5439 return true;
5440}
5441
5443{
5444 return true;
5445}
5446
5448{
5449 if (!readTag(reader)) {
5450 return false;
5451 }
5452 if (!readArgs(reader)) {
5453 return false;
5454 }
5455 return true;
5456}
5457
5459{
5460 std::string tag = reader.readTag(s_tag_len);
5461 if (reader.isError()) {
5462 return false;
5463 }
5464 if (tag != s_tag) {
5465 reader.fail();
5466 return false;
5467 }
5468 return true;
5469}
5470
5472{
5473 if (!reader.noMore()) {
5474 reader.fail();
5475 return false;
5476 }
5477 return true;
5478}
5479
5481{
5482 yarp::os::idl::WireWriter writer(connection);
5483 return write(writer);
5484}
5485
5487{
5488 yarp::os::idl::WireReader reader(connection);
5489 return read(reader);
5490}
5491
5493{
5494 if (!writer.isNull()) {
5495 if (!writer.writeListHeader(s_reply_len)) {
5496 return false;
5497 }
5498 if (!writer.write(return_helper)) {
5499 return false;
5500 }
5501 }
5502 return true;
5503}
5504
5506{
5507 if (!reader.readListReturn()) {
5508 return false;
5509 }
5510 if (reader.noMore()) {
5511 reader.fail();
5512 return false;
5513 }
5514 if (!reader.read(return_helper)) {
5515 reader.fail();
5516 return false;
5517 }
5518 return true;
5519}
5520
5525
5526// hasFeatureRPC helper class implementation
5531
5533{
5534 return cmd.write(connection);
5535}
5536
5538{
5539 return reply.read(connection);
5540}
5541
5546
5548{
5549 yarp::os::idl::WireWriter writer(connection);
5550 if (!writer.writeListHeader(s_cmd_len)) {
5551 return false;
5552 }
5553 return write(writer);
5554}
5555
5557{
5558 yarp::os::idl::WireReader reader(connection);
5559 if (!reader.readListHeader()) {
5560 reader.fail();
5561 return false;
5562 }
5563 return read(reader);
5564}
5565
5567{
5568 if (!writeTag(writer)) {
5569 return false;
5570 }
5571 if (!writeArgs(writer)) {
5572 return false;
5573 }
5574 return true;
5575}
5576
5578{
5579 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5580 return false;
5581 }
5582 return true;
5583}
5584
5586{
5587 if (!writer.writeI32(feature)) {
5588 return false;
5589 }
5590 return true;
5591}
5592
5594{
5595 if (!readTag(reader)) {
5596 return false;
5597 }
5598 if (!readArgs(reader)) {
5599 return false;
5600 }
5601 return true;
5602}
5603
5605{
5606 std::string tag = reader.readTag(s_tag_len);
5607 if (reader.isError()) {
5608 return false;
5609 }
5610 if (tag != s_tag) {
5611 reader.fail();
5612 return false;
5613 }
5614 return true;
5615}
5616
5618{
5619 if (reader.noMore()) {
5620 reader.fail();
5621 return false;
5622 }
5623 if (!reader.readI32(feature)) {
5624 reader.fail();
5625 return false;
5626 }
5627 if (!reader.noMore()) {
5628 reader.fail();
5629 return false;
5630 }
5631 return true;
5632}
5633
5635{
5636 yarp::os::idl::WireWriter writer(connection);
5637 return write(writer);
5638}
5639
5641{
5642 yarp::os::idl::WireReader reader(connection);
5643 return read(reader);
5644}
5645
5647{
5648 if (!writer.isNull()) {
5649 if (!writer.writeListHeader(s_reply_len)) {
5650 return false;
5651 }
5652 if (!writer.write(return_helper)) {
5653 return false;
5654 }
5655 }
5656 return true;
5657}
5658
5660{
5661 if (!reader.readListReturn()) {
5662 return false;
5663 }
5664 if (reader.noMore()) {
5665 reader.fail();
5666 return false;
5667 }
5668 if (!reader.read(return_helper)) {
5669 reader.fail();
5670 return false;
5671 }
5672 return true;
5673}
5674
5679
5680// setFeature1RPC helper class implementation
5682 cmd{feature, value}
5683{
5684}
5685
5687{
5688 return cmd.write(connection);
5689}
5690
5692{
5693 return reply.read(connection);
5694}
5695
5698 value{value}
5699{
5700}
5701
5703{
5704 yarp::os::idl::WireWriter writer(connection);
5705 if (!writer.writeListHeader(s_cmd_len)) {
5706 return false;
5707 }
5708 return write(writer);
5709}
5710
5712{
5713 yarp::os::idl::WireReader reader(connection);
5714 if (!reader.readListHeader()) {
5715 reader.fail();
5716 return false;
5717 }
5718 return read(reader);
5719}
5720
5722{
5723 if (!writeTag(writer)) {
5724 return false;
5725 }
5726 if (!writeArgs(writer)) {
5727 return false;
5728 }
5729 return true;
5730}
5731
5733{
5734 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5735 return false;
5736 }
5737 return true;
5738}
5739
5741{
5742 if (!writer.writeI32(feature)) {
5743 return false;
5744 }
5745 if (!writer.writeFloat64(value)) {
5746 return false;
5747 }
5748 return true;
5749}
5750
5752{
5753 if (!readTag(reader)) {
5754 return false;
5755 }
5756 if (!readArgs(reader)) {
5757 return false;
5758 }
5759 return true;
5760}
5761
5763{
5764 std::string tag = reader.readTag(s_tag_len);
5765 if (reader.isError()) {
5766 return false;
5767 }
5768 if (tag != s_tag) {
5769 reader.fail();
5770 return false;
5771 }
5772 return true;
5773}
5774
5776{
5777 if (reader.noMore()) {
5778 reader.fail();
5779 return false;
5780 }
5781 if (!reader.readI32(feature)) {
5782 reader.fail();
5783 return false;
5784 }
5785 if (reader.noMore()) {
5786 reader.fail();
5787 return false;
5788 }
5789 if (!reader.readFloat64(value)) {
5790 reader.fail();
5791 return false;
5792 }
5793 if (!reader.noMore()) {
5794 reader.fail();
5795 return false;
5796 }
5797 return true;
5798}
5799
5801{
5802 yarp::os::idl::WireWriter writer(connection);
5803 return write(writer);
5804}
5805
5807{
5808 yarp::os::idl::WireReader reader(connection);
5809 return read(reader);
5810}
5811
5813{
5814 if (!writer.isNull()) {
5815 if (!writer.write(return_helper)) {
5816 return false;
5817 }
5818 }
5819 return true;
5820}
5821
5823{
5824 if (reader.noMore()) {
5825 reader.fail();
5826 return false;
5827 }
5828 if (!reader.read(return_helper)) {
5829 reader.fail();
5830 return false;
5831 }
5832 return true;
5833}
5834
5839
5840// getFeature1RPC helper class implementation
5845
5847{
5848 return cmd.write(connection);
5849}
5850
5852{
5853 return reply.read(connection);
5854}
5855
5860
5862{
5863 yarp::os::idl::WireWriter writer(connection);
5864 if (!writer.writeListHeader(s_cmd_len)) {
5865 return false;
5866 }
5867 return write(writer);
5868}
5869
5871{
5872 yarp::os::idl::WireReader reader(connection);
5873 if (!reader.readListHeader()) {
5874 reader.fail();
5875 return false;
5876 }
5877 return read(reader);
5878}
5879
5881{
5882 if (!writeTag(writer)) {
5883 return false;
5884 }
5885 if (!writeArgs(writer)) {
5886 return false;
5887 }
5888 return true;
5889}
5890
5892{
5893 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5894 return false;
5895 }
5896 return true;
5897}
5898
5900{
5901 if (!writer.writeI32(feature)) {
5902 return false;
5903 }
5904 return true;
5905}
5906
5908{
5909 if (!readTag(reader)) {
5910 return false;
5911 }
5912 if (!readArgs(reader)) {
5913 return false;
5914 }
5915 return true;
5916}
5917
5919{
5920 std::string tag = reader.readTag(s_tag_len);
5921 if (reader.isError()) {
5922 return false;
5923 }
5924 if (tag != s_tag) {
5925 reader.fail();
5926 return false;
5927 }
5928 return true;
5929}
5930
5932{
5933 if (reader.noMore()) {
5934 reader.fail();
5935 return false;
5936 }
5937 if (!reader.readI32(feature)) {
5938 reader.fail();
5939 return false;
5940 }
5941 if (!reader.noMore()) {
5942 reader.fail();
5943 return false;
5944 }
5945 return true;
5946}
5947
5949{
5950 yarp::os::idl::WireWriter writer(connection);
5951 return write(writer);
5952}
5953
5955{
5956 yarp::os::idl::WireReader reader(connection);
5957 return read(reader);
5958}
5959
5961{
5962 if (!writer.isNull()) {
5963 if (!writer.writeListHeader(s_reply_len)) {
5964 return false;
5965 }
5966 if (!writer.write(return_helper)) {
5967 return false;
5968 }
5969 }
5970 return true;
5971}
5972
5974{
5975 if (!reader.readListReturn()) {
5976 return false;
5977 }
5978 if (reader.noMore()) {
5979 reader.fail();
5980 return false;
5981 }
5982 if (!reader.read(return_helper)) {
5983 reader.fail();
5984 return false;
5985 }
5986 return true;
5987}
5988
5993
5994// setFeature2RPC helper class implementation
5995FrameGrabberMsgs_setFeature2RPC_helper::FrameGrabberMsgs_setFeature2RPC_helper(const std::int32_t feature, const double value1, const double value2) :
5996 cmd{feature, value1, value2}
5997{
5998}
5999
6001{
6002 return cmd.write(connection);
6003}
6004
6006{
6007 return reply.read(connection);
6008}
6009
6010FrameGrabberMsgs_setFeature2RPC_helper::Command::Command(const std::int32_t feature, const double value1, const double value2) :
6012 value1{value1},
6013 value2{value2}
6014{
6015}
6016
6018{
6019 yarp::os::idl::WireWriter writer(connection);
6020 if (!writer.writeListHeader(s_cmd_len)) {
6021 return false;
6022 }
6023 return write(writer);
6024}
6025
6027{
6028 yarp::os::idl::WireReader reader(connection);
6029 if (!reader.readListHeader()) {
6030 reader.fail();
6031 return false;
6032 }
6033 return read(reader);
6034}
6035
6037{
6038 if (!writeTag(writer)) {
6039 return false;
6040 }
6041 if (!writeArgs(writer)) {
6042 return false;
6043 }
6044 return true;
6045}
6046
6048{
6049 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6050 return false;
6051 }
6052 return true;
6053}
6054
6056{
6057 if (!writer.writeI32(feature)) {
6058 return false;
6059 }
6060 if (!writer.writeFloat64(value1)) {
6061 return false;
6062 }
6063 if (!writer.writeFloat64(value2)) {
6064 return false;
6065 }
6066 return true;
6067}
6068
6070{
6071 if (!readTag(reader)) {
6072 return false;
6073 }
6074 if (!readArgs(reader)) {
6075 return false;
6076 }
6077 return true;
6078}
6079
6081{
6082 std::string tag = reader.readTag(s_tag_len);
6083 if (reader.isError()) {
6084 return false;
6085 }
6086 if (tag != s_tag) {
6087 reader.fail();
6088 return false;
6089 }
6090 return true;
6091}
6092
6094{
6095 if (reader.noMore()) {
6096 reader.fail();
6097 return false;
6098 }
6099 if (!reader.readI32(feature)) {
6100 reader.fail();
6101 return false;
6102 }
6103 if (reader.noMore()) {
6104 reader.fail();
6105 return false;
6106 }
6107 if (!reader.readFloat64(value1)) {
6108 reader.fail();
6109 return false;
6110 }
6111 if (reader.noMore()) {
6112 reader.fail();
6113 return false;
6114 }
6115 if (!reader.readFloat64(value2)) {
6116 reader.fail();
6117 return false;
6118 }
6119 if (!reader.noMore()) {
6120 reader.fail();
6121 return false;
6122 }
6123 return true;
6124}
6125
6127{
6128 yarp::os::idl::WireWriter writer(connection);
6129 return write(writer);
6130}
6131
6133{
6134 yarp::os::idl::WireReader reader(connection);
6135 return read(reader);
6136}
6137
6139{
6140 if (!writer.isNull()) {
6141 if (!writer.write(return_helper)) {
6142 return false;
6143 }
6144 }
6145 return true;
6146}
6147
6149{
6150 if (reader.noMore()) {
6151 reader.fail();
6152 return false;
6153 }
6154 if (!reader.read(return_helper)) {
6155 reader.fail();
6156 return false;
6157 }
6158 return true;
6159}
6160
6165
6166// getFeature2RPC helper class implementation
6171
6173{
6174 return cmd.write(connection);
6175}
6176
6178{
6179 return reply.read(connection);
6180}
6181
6186
6188{
6189 yarp::os::idl::WireWriter writer(connection);
6190 if (!writer.writeListHeader(s_cmd_len)) {
6191 return false;
6192 }
6193 return write(writer);
6194}
6195
6197{
6198 yarp::os::idl::WireReader reader(connection);
6199 if (!reader.readListHeader()) {
6200 reader.fail();
6201 return false;
6202 }
6203 return read(reader);
6204}
6205
6207{
6208 if (!writeTag(writer)) {
6209 return false;
6210 }
6211 if (!writeArgs(writer)) {
6212 return false;
6213 }
6214 return true;
6215}
6216
6218{
6219 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6220 return false;
6221 }
6222 return true;
6223}
6224
6226{
6227 if (!writer.writeI32(feature)) {
6228 return false;
6229 }
6230 return true;
6231}
6232
6234{
6235 if (!readTag(reader)) {
6236 return false;
6237 }
6238 if (!readArgs(reader)) {
6239 return false;
6240 }
6241 return true;
6242}
6243
6245{
6246 std::string tag = reader.readTag(s_tag_len);
6247 if (reader.isError()) {
6248 return false;
6249 }
6250 if (tag != s_tag) {
6251 reader.fail();
6252 return false;
6253 }
6254 return true;
6255}
6256
6258{
6259 if (reader.noMore()) {
6260 reader.fail();
6261 return false;
6262 }
6263 if (!reader.readI32(feature)) {
6264 reader.fail();
6265 return false;
6266 }
6267 if (!reader.noMore()) {
6268 reader.fail();
6269 return false;
6270 }
6271 return true;
6272}
6273
6275{
6276 yarp::os::idl::WireWriter writer(connection);
6277 return write(writer);
6278}
6279
6281{
6282 yarp::os::idl::WireReader reader(connection);
6283 return read(reader);
6284}
6285
6287{
6288 if (!writer.isNull()) {
6289 if (!writer.writeListHeader(s_reply_len)) {
6290 return false;
6291 }
6292 if (!writer.write(return_helper)) {
6293 return false;
6294 }
6295 }
6296 return true;
6297}
6298
6300{
6301 if (!reader.readListReturn()) {
6302 return false;
6303 }
6304 if (reader.noMore()) {
6305 reader.fail();
6306 return false;
6307 }
6308 if (!reader.read(return_helper)) {
6309 reader.fail();
6310 return false;
6311 }
6312 return true;
6313}
6314
6319
6320// hasOnOffRPC helper class implementation
6325
6327{
6328 return cmd.write(connection);
6329}
6330
6332{
6333 return reply.read(connection);
6334}
6335
6340
6342{
6343 yarp::os::idl::WireWriter writer(connection);
6344 if (!writer.writeListHeader(s_cmd_len)) {
6345 return false;
6346 }
6347 return write(writer);
6348}
6349
6351{
6352 yarp::os::idl::WireReader reader(connection);
6353 if (!reader.readListHeader()) {
6354 reader.fail();
6355 return false;
6356 }
6357 return read(reader);
6358}
6359
6361{
6362 if (!writeTag(writer)) {
6363 return false;
6364 }
6365 if (!writeArgs(writer)) {
6366 return false;
6367 }
6368 return true;
6369}
6370
6372{
6373 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6374 return false;
6375 }
6376 return true;
6377}
6378
6380{
6381 if (!writer.writeI32(feature)) {
6382 return false;
6383 }
6384 return true;
6385}
6386
6388{
6389 if (!readTag(reader)) {
6390 return false;
6391 }
6392 if (!readArgs(reader)) {
6393 return false;
6394 }
6395 return true;
6396}
6397
6399{
6400 std::string tag = reader.readTag(s_tag_len);
6401 if (reader.isError()) {
6402 return false;
6403 }
6404 if (tag != s_tag) {
6405 reader.fail();
6406 return false;
6407 }
6408 return true;
6409}
6410
6412{
6413 if (reader.noMore()) {
6414 reader.fail();
6415 return false;
6416 }
6417 if (!reader.readI32(feature)) {
6418 reader.fail();
6419 return false;
6420 }
6421 if (!reader.noMore()) {
6422 reader.fail();
6423 return false;
6424 }
6425 return true;
6426}
6427
6429{
6430 yarp::os::idl::WireWriter writer(connection);
6431 return write(writer);
6432}
6433
6435{
6436 yarp::os::idl::WireReader reader(connection);
6437 return read(reader);
6438}
6439
6441{
6442 if (!writer.isNull()) {
6443 if (!writer.writeListHeader(s_reply_len)) {
6444 return false;
6445 }
6446 if (!writer.write(return_helper)) {
6447 return false;
6448 }
6449 }
6450 return true;
6451}
6452
6454{
6455 if (!reader.readListReturn()) {
6456 return false;
6457 }
6458 if (reader.noMore()) {
6459 reader.fail();
6460 return false;
6461 }
6462 if (!reader.read(return_helper)) {
6463 reader.fail();
6464 return false;
6465 }
6466 return true;
6467}
6468
6473
6474// setActiveRPC helper class implementation
6476 cmd{feature, onoff}
6477{
6478}
6479
6481{
6482 return cmd.write(connection);
6483}
6484
6486{
6487 return reply.read(connection);
6488}
6489
6492 onoff{onoff}
6493{
6494}
6495
6497{
6498 yarp::os::idl::WireWriter writer(connection);
6499 if (!writer.writeListHeader(s_cmd_len)) {
6500 return false;
6501 }
6502 return write(writer);
6503}
6504
6506{
6507 yarp::os::idl::WireReader reader(connection);
6508 if (!reader.readListHeader()) {
6509 reader.fail();
6510 return false;
6511 }
6512 return read(reader);
6513}
6514
6516{
6517 if (!writeTag(writer)) {
6518 return false;
6519 }
6520 if (!writeArgs(writer)) {
6521 return false;
6522 }
6523 return true;
6524}
6525
6527{
6528 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6529 return false;
6530 }
6531 return true;
6532}
6533
6535{
6536 if (!writer.writeI32(feature)) {
6537 return false;
6538 }
6539 if (!writer.writeBool(onoff)) {
6540 return false;
6541 }
6542 return true;
6543}
6544
6546{
6547 if (!readTag(reader)) {
6548 return false;
6549 }
6550 if (!readArgs(reader)) {
6551 return false;
6552 }
6553 return true;
6554}
6555
6557{
6558 std::string tag = reader.readTag(s_tag_len);
6559 if (reader.isError()) {
6560 return false;
6561 }
6562 if (tag != s_tag) {
6563 reader.fail();
6564 return false;
6565 }
6566 return true;
6567}
6568
6570{
6571 if (reader.noMore()) {
6572 reader.fail();
6573 return false;
6574 }
6575 if (!reader.readI32(feature)) {
6576 reader.fail();
6577 return false;
6578 }
6579 if (reader.noMore()) {
6580 reader.fail();
6581 return false;
6582 }
6583 if (!reader.readBool(onoff)) {
6584 reader.fail();
6585 return false;
6586 }
6587 if (!reader.noMore()) {
6588 reader.fail();
6589 return false;
6590 }
6591 return true;
6592}
6593
6595{
6596 yarp::os::idl::WireWriter writer(connection);
6597 return write(writer);
6598}
6599
6601{
6602 yarp::os::idl::WireReader reader(connection);
6603 return read(reader);
6604}
6605
6607{
6608 if (!writer.isNull()) {
6609 if (!writer.write(return_helper)) {
6610 return false;
6611 }
6612 }
6613 return true;
6614}
6615
6617{
6618 if (reader.noMore()) {
6619 reader.fail();
6620 return false;
6621 }
6622 if (!reader.read(return_helper)) {
6623 reader.fail();
6624 return false;
6625 }
6626 return true;
6627}
6628
6633
6634// getActiveRPC helper class implementation
6639
6641{
6642 return cmd.write(connection);
6643}
6644
6646{
6647 return reply.read(connection);
6648}
6649
6654
6656{
6657 yarp::os::idl::WireWriter writer(connection);
6658 if (!writer.writeListHeader(s_cmd_len)) {
6659 return false;
6660 }
6661 return write(writer);
6662}
6663
6665{
6666 yarp::os::idl::WireReader reader(connection);
6667 if (!reader.readListHeader()) {
6668 reader.fail();
6669 return false;
6670 }
6671 return read(reader);
6672}
6673
6675{
6676 if (!writeTag(writer)) {
6677 return false;
6678 }
6679 if (!writeArgs(writer)) {
6680 return false;
6681 }
6682 return true;
6683}
6684
6686{
6687 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6688 return false;
6689 }
6690 return true;
6691}
6692
6694{
6695 if (!writer.writeI32(feature)) {
6696 return false;
6697 }
6698 return true;
6699}
6700
6702{
6703 if (!readTag(reader)) {
6704 return false;
6705 }
6706 if (!readArgs(reader)) {
6707 return false;
6708 }
6709 return true;
6710}
6711
6713{
6714 std::string tag = reader.readTag(s_tag_len);
6715 if (reader.isError()) {
6716 return false;
6717 }
6718 if (tag != s_tag) {
6719 reader.fail();
6720 return false;
6721 }
6722 return true;
6723}
6724
6726{
6727 if (reader.noMore()) {
6728 reader.fail();
6729 return false;
6730 }
6731 if (!reader.readI32(feature)) {
6732 reader.fail();
6733 return false;
6734 }
6735 if (!reader.noMore()) {
6736 reader.fail();
6737 return false;
6738 }
6739 return true;
6740}
6741
6743{
6744 yarp::os::idl::WireWriter writer(connection);
6745 return write(writer);
6746}
6747
6749{
6750 yarp::os::idl::WireReader reader(connection);
6751 return read(reader);
6752}
6753
6755{
6756 if (!writer.isNull()) {
6757 if (!writer.writeListHeader(s_reply_len)) {
6758 return false;
6759 }
6760 if (!writer.write(return_helper)) {
6761 return false;
6762 }
6763 }
6764 return true;
6765}
6766
6768{
6769 if (!reader.readListReturn()) {
6770 return false;
6771 }
6772 if (reader.noMore()) {
6773 reader.fail();
6774 return false;
6775 }
6776 if (!reader.read(return_helper)) {
6777 reader.fail();
6778 return false;
6779 }
6780 return true;
6781}
6782
6787
6788// hasAutoRPC helper class implementation
6793
6795{
6796 return cmd.write(connection);
6797}
6798
6800{
6801 return reply.read(connection);
6802}
6803
6808
6810{
6811 yarp::os::idl::WireWriter writer(connection);
6812 if (!writer.writeListHeader(s_cmd_len)) {
6813 return false;
6814 }
6815 return write(writer);
6816}
6817
6819{
6820 yarp::os::idl::WireReader reader(connection);
6821 if (!reader.readListHeader()) {
6822 reader.fail();
6823 return false;
6824 }
6825 return read(reader);
6826}
6827
6829{
6830 if (!writeTag(writer)) {
6831 return false;
6832 }
6833 if (!writeArgs(writer)) {
6834 return false;
6835 }
6836 return true;
6837}
6838
6840{
6841 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6842 return false;
6843 }
6844 return true;
6845}
6846
6848{
6849 if (!writer.writeI32(feature)) {
6850 return false;
6851 }
6852 return true;
6853}
6854
6856{
6857 if (!readTag(reader)) {
6858 return false;
6859 }
6860 if (!readArgs(reader)) {
6861 return false;
6862 }
6863 return true;
6864}
6865
6867{
6868 std::string tag = reader.readTag(s_tag_len);
6869 if (reader.isError()) {
6870 return false;
6871 }
6872 if (tag != s_tag) {
6873 reader.fail();
6874 return false;
6875 }
6876 return true;
6877}
6878
6880{
6881 if (reader.noMore()) {
6882 reader.fail();
6883 return false;
6884 }
6885 if (!reader.readI32(feature)) {
6886 reader.fail();
6887 return false;
6888 }
6889 if (!reader.noMore()) {
6890 reader.fail();
6891 return false;
6892 }
6893 return true;
6894}
6895
6897{
6898 yarp::os::idl::WireWriter writer(connection);
6899 return write(writer);
6900}
6901
6903{
6904 yarp::os::idl::WireReader reader(connection);
6905 return read(reader);
6906}
6907
6909{
6910 if (!writer.isNull()) {
6911 if (!writer.writeListHeader(s_reply_len)) {
6912 return false;
6913 }
6914 if (!writer.write(return_helper)) {
6915 return false;
6916 }
6917 }
6918 return true;
6919}
6920
6922{
6923 if (!reader.readListReturn()) {
6924 return false;
6925 }
6926 if (reader.noMore()) {
6927 reader.fail();
6928 return false;
6929 }
6930 if (!reader.read(return_helper)) {
6931 reader.fail();
6932 return false;
6933 }
6934 return true;
6935}
6936
6941
6942// hasManualRPC helper class implementation
6947
6949{
6950 return cmd.write(connection);
6951}
6952
6954{
6955 return reply.read(connection);
6956}
6957
6962
6964{
6965 yarp::os::idl::WireWriter writer(connection);
6966 if (!writer.writeListHeader(s_cmd_len)) {
6967 return false;
6968 }
6969 return write(writer);
6970}
6971
6973{
6974 yarp::os::idl::WireReader reader(connection);
6975 if (!reader.readListHeader()) {
6976 reader.fail();
6977 return false;
6978 }
6979 return read(reader);
6980}
6981
6983{
6984 if (!writeTag(writer)) {
6985 return false;
6986 }
6987 if (!writeArgs(writer)) {
6988 return false;
6989 }
6990 return true;
6991}
6992
6994{
6995 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6996 return false;
6997 }
6998 return true;
6999}
7000
7002{
7003 if (!writer.writeI32(feature)) {
7004 return false;
7005 }
7006 return true;
7007}
7008
7010{
7011 if (!readTag(reader)) {
7012 return false;
7013 }
7014 if (!readArgs(reader)) {
7015 return false;
7016 }
7017 return true;
7018}
7019
7021{
7022 std::string tag = reader.readTag(s_tag_len);
7023 if (reader.isError()) {
7024 return false;
7025 }
7026 if (tag != s_tag) {
7027 reader.fail();
7028 return false;
7029 }
7030 return true;
7031}
7032
7034{
7035 if (reader.noMore()) {
7036 reader.fail();
7037 return false;
7038 }
7039 if (!reader.readI32(feature)) {
7040 reader.fail();
7041 return false;
7042 }
7043 if (!reader.noMore()) {
7044 reader.fail();
7045 return false;
7046 }
7047 return true;
7048}
7049
7051{
7052 yarp::os::idl::WireWriter writer(connection);
7053 return write(writer);
7054}
7055
7057{
7058 yarp::os::idl::WireReader reader(connection);
7059 return read(reader);
7060}
7061
7063{
7064 if (!writer.isNull()) {
7065 if (!writer.writeListHeader(s_reply_len)) {
7066 return false;
7067 }
7068 if (!writer.write(return_helper)) {
7069 return false;
7070 }
7071 }
7072 return true;
7073}
7074
7076{
7077 if (!reader.readListReturn()) {
7078 return false;
7079 }
7080 if (reader.noMore()) {
7081 reader.fail();
7082 return false;
7083 }
7084 if (!reader.read(return_helper)) {
7085 reader.fail();
7086 return false;
7087 }
7088 return true;
7089}
7090
7095
7096// hasOnePushRPC helper class implementation
7101
7103{
7104 return cmd.write(connection);
7105}
7106
7108{
7109 return reply.read(connection);
7110}
7111
7116
7118{
7119 yarp::os::idl::WireWriter writer(connection);
7120 if (!writer.writeListHeader(s_cmd_len)) {
7121 return false;
7122 }
7123 return write(writer);
7124}
7125
7127{
7128 yarp::os::idl::WireReader reader(connection);
7129 if (!reader.readListHeader()) {
7130 reader.fail();
7131 return false;
7132 }
7133 return read(reader);
7134}
7135
7137{
7138 if (!writeTag(writer)) {
7139 return false;
7140 }
7141 if (!writeArgs(writer)) {
7142 return false;
7143 }
7144 return true;
7145}
7146
7148{
7149 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7150 return false;
7151 }
7152 return true;
7153}
7154
7156{
7157 if (!writer.writeI32(feature)) {
7158 return false;
7159 }
7160 return true;
7161}
7162
7164{
7165 if (!readTag(reader)) {
7166 return false;
7167 }
7168 if (!readArgs(reader)) {
7169 return false;
7170 }
7171 return true;
7172}
7173
7175{
7176 std::string tag = reader.readTag(s_tag_len);
7177 if (reader.isError()) {
7178 return false;
7179 }
7180 if (tag != s_tag) {
7181 reader.fail();
7182 return false;
7183 }
7184 return true;
7185}
7186
7188{
7189 if (reader.noMore()) {
7190 reader.fail();
7191 return false;
7192 }
7193 if (!reader.readI32(feature)) {
7194 reader.fail();
7195 return false;
7196 }
7197 if (!reader.noMore()) {
7198 reader.fail();
7199 return false;
7200 }
7201 return true;
7202}
7203
7205{
7206 yarp::os::idl::WireWriter writer(connection);
7207 return write(writer);
7208}
7209
7211{
7212 yarp::os::idl::WireReader reader(connection);
7213 return read(reader);
7214}
7215
7217{
7218 if (!writer.isNull()) {
7219 if (!writer.writeListHeader(s_reply_len)) {
7220 return false;
7221 }
7222 if (!writer.write(return_helper)) {
7223 return false;
7224 }
7225 }
7226 return true;
7227}
7228
7230{
7231 if (!reader.readListReturn()) {
7232 return false;
7233 }
7234 if (reader.noMore()) {
7235 reader.fail();
7236 return false;
7237 }
7238 if (!reader.read(return_helper)) {
7239 reader.fail();
7240 return false;
7241 }
7242 return true;
7243}
7244
7249
7250// setModeRPC helper class implementation
7255
7257{
7258 return cmd.write(connection);
7259}
7260
7262{
7263 return reply.read(connection);
7264}
7265
7271
7273{
7274 yarp::os::idl::WireWriter writer(connection);
7275 if (!writer.writeListHeader(s_cmd_len)) {
7276 return false;
7277 }
7278 return write(writer);
7279}
7280
7282{
7283 yarp::os::idl::WireReader reader(connection);
7284 if (!reader.readListHeader()) {
7285 reader.fail();
7286 return false;
7287 }
7288 return read(reader);
7289}
7290
7292{
7293 if (!writeTag(writer)) {
7294 return false;
7295 }
7296 if (!writeArgs(writer)) {
7297 return false;
7298 }
7299 return true;
7300}
7301
7303{
7304 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7305 return false;
7306 }
7307 return true;
7308}
7309
7311{
7312 if (!writer.writeI32(feature)) {
7313 return false;
7314 }
7315 if (!writer.writeI32(static_cast<int32_t>(mode))) {
7316 return false;
7317 }
7318 return true;
7319}
7320
7322{
7323 if (!readTag(reader)) {
7324 return false;
7325 }
7326 if (!readArgs(reader)) {
7327 return false;
7328 }
7329 return true;
7330}
7331
7333{
7334 std::string tag = reader.readTag(s_tag_len);
7335 if (reader.isError()) {
7336 return false;
7337 }
7338 if (tag != s_tag) {
7339 reader.fail();
7340 return false;
7341 }
7342 return true;
7343}
7344
7346{
7347 if (reader.noMore()) {
7348 reader.fail();
7349 return false;
7350 }
7351 if (!reader.readI32(feature)) {
7352 reader.fail();
7353 return false;
7354 }
7355 if (reader.noMore()) {
7356 reader.fail();
7357 return false;
7358 }
7359 int32_t _ecast;
7360 if (!reader.readI32(_ecast)) {
7361 reader.fail();
7362 return false;
7363 }
7364 mode = static_cast<yarp::dev::FeatureMode>(_ecast);
7365 if (!reader.noMore()) {
7366 reader.fail();
7367 return false;
7368 }
7369 return true;
7370}
7371
7373{
7374 yarp::os::idl::WireWriter writer(connection);
7375 return write(writer);
7376}
7377
7379{
7380 yarp::os::idl::WireReader reader(connection);
7381 return read(reader);
7382}
7383
7385{
7386 if (!writer.isNull()) {
7387 if (!writer.write(return_helper)) {
7388 return false;
7389 }
7390 }
7391 return true;
7392}
7393
7395{
7396 if (reader.noMore()) {
7397 reader.fail();
7398 return false;
7399 }
7400 if (!reader.read(return_helper)) {
7401 reader.fail();
7402 return false;
7403 }
7404 return true;
7405}
7406
7411
7412// getModeRPC helper class implementation
7417
7419{
7420 return cmd.write(connection);
7421}
7422
7424{
7425 return reply.read(connection);
7426}
7427
7432
7434{
7435 yarp::os::idl::WireWriter writer(connection);
7436 if (!writer.writeListHeader(s_cmd_len)) {
7437 return false;
7438 }
7439 return write(writer);
7440}
7441
7443{
7444 yarp::os::idl::WireReader reader(connection);
7445 if (!reader.readListHeader()) {
7446 reader.fail();
7447 return false;
7448 }
7449 return read(reader);
7450}
7451
7453{
7454 if (!writeTag(writer)) {
7455 return false;
7456 }
7457 if (!writeArgs(writer)) {
7458 return false;
7459 }
7460 return true;
7461}
7462
7464{
7465 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7466 return false;
7467 }
7468 return true;
7469}
7470
7472{
7473 if (!writer.writeI32(feature)) {
7474 return false;
7475 }
7476 return true;
7477}
7478
7480{
7481 if (!readTag(reader)) {
7482 return false;
7483 }
7484 if (!readArgs(reader)) {
7485 return false;
7486 }
7487 return true;
7488}
7489
7491{
7492 std::string tag = reader.readTag(s_tag_len);
7493 if (reader.isError()) {
7494 return false;
7495 }
7496 if (tag != s_tag) {
7497 reader.fail();
7498 return false;
7499 }
7500 return true;
7501}
7502
7504{
7505 if (reader.noMore()) {
7506 reader.fail();
7507 return false;
7508 }
7509 if (!reader.readI32(feature)) {
7510 reader.fail();
7511 return false;
7512 }
7513 if (!reader.noMore()) {
7514 reader.fail();
7515 return false;
7516 }
7517 return true;
7518}
7519
7521{
7522 yarp::os::idl::WireWriter writer(connection);
7523 return write(writer);
7524}
7525
7527{
7528 yarp::os::idl::WireReader reader(connection);
7529 return read(reader);
7530}
7531
7533{
7534 if (!writer.isNull()) {
7535 if (!writer.writeListHeader(s_reply_len)) {
7536 return false;
7537 }
7538 if (!writer.write(return_helper)) {
7539 return false;
7540 }
7541 }
7542 return true;
7543}
7544
7546{
7547 if (!reader.readListReturn()) {
7548 return false;
7549 }
7550 if (reader.noMore()) {
7551 reader.fail();
7552 return false;
7553 }
7554 if (!reader.read(return_helper)) {
7555 reader.fail();
7556 return false;
7557 }
7558 return true;
7559}
7560
7565
7566// setOnePushRPC helper class implementation
7571
7573{
7574 return cmd.write(connection);
7575}
7576
7578{
7579 return reply.read(connection);
7580}
7581
7586
7588{
7589 yarp::os::idl::WireWriter writer(connection);
7590 if (!writer.writeListHeader(s_cmd_len)) {
7591 return false;
7592 }
7593 return write(writer);
7594}
7595
7597{
7598 yarp::os::idl::WireReader reader(connection);
7599 if (!reader.readListHeader()) {
7600 reader.fail();
7601 return false;
7602 }
7603 return read(reader);
7604}
7605
7607{
7608 if (!writeTag(writer)) {
7609 return false;
7610 }
7611 if (!writeArgs(writer)) {
7612 return false;
7613 }
7614 return true;
7615}
7616
7618{
7619 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7620 return false;
7621 }
7622 return true;
7623}
7624
7626{
7627 if (!writer.writeI32(feature)) {
7628 return false;
7629 }
7630 return true;
7631}
7632
7634{
7635 if (!readTag(reader)) {
7636 return false;
7637 }
7638 if (!readArgs(reader)) {
7639 return false;
7640 }
7641 return true;
7642}
7643
7645{
7646 std::string tag = reader.readTag(s_tag_len);
7647 if (reader.isError()) {
7648 return false;
7649 }
7650 if (tag != s_tag) {
7651 reader.fail();
7652 return false;
7653 }
7654 return true;
7655}
7656
7658{
7659 if (reader.noMore()) {
7660 reader.fail();
7661 return false;
7662 }
7663 if (!reader.readI32(feature)) {
7664 reader.fail();
7665 return false;
7666 }
7667 if (!reader.noMore()) {
7668 reader.fail();
7669 return false;
7670 }
7671 return true;
7672}
7673
7675{
7676 yarp::os::idl::WireWriter writer(connection);
7677 return write(writer);
7678}
7679
7681{
7682 yarp::os::idl::WireReader reader(connection);
7683 return read(reader);
7684}
7685
7687{
7688 if (!writer.isNull()) {
7689 if (!writer.write(return_helper)) {
7690 return false;
7691 }
7692 }
7693 return true;
7694}
7695
7697{
7698 if (reader.noMore()) {
7699 reader.fail();
7700 return false;
7701 }
7702 if (!reader.read(return_helper)) {
7703 reader.fail();
7704 return false;
7705 }
7706 return true;
7707}
7708
7713
7714// getVideoModeMaskDC1394RPC helper class implementation
7716{
7717 return cmd.write(connection);
7718}
7719
7724
7726{
7727 yarp::os::idl::WireWriter writer(connection);
7728 if (!writer.writeListHeader(s_cmd_len)) {
7729 return false;
7730 }
7731 return write(writer);
7732}
7733
7735{
7736 yarp::os::idl::WireReader reader(connection);
7737 if (!reader.readListHeader()) {
7738 reader.fail();
7739 return false;
7740 }
7741 return read(reader);
7742}
7743
7745{
7746 if (!writeTag(writer)) {
7747 return false;
7748 }
7749 if (!writeArgs(writer)) {
7750 return false;
7751 }
7752 return true;
7753}
7754
7756{
7757 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7758 return false;
7759 }
7760 return true;
7761}
7762
7764{
7765 return true;
7766}
7767
7769{
7770 if (!readTag(reader)) {
7771 return false;
7772 }
7773 if (!readArgs(reader)) {
7774 return false;
7775 }
7776 return true;
7777}
7778
7780{
7781 std::string tag = reader.readTag(s_tag_len);
7782 if (reader.isError()) {
7783 return false;
7784 }
7785 if (tag != s_tag) {
7786 reader.fail();
7787 return false;
7788 }
7789 return true;
7790}
7791
7793{
7794 if (!reader.noMore()) {
7795 reader.fail();
7796 return false;
7797 }
7798 return true;
7799}
7800
7802{
7803 yarp::os::idl::WireWriter writer(connection);
7804 return write(writer);
7805}
7806
7812
7814{
7815 if (!writer.isNull()) {
7816 if (!writer.writeListHeader(s_reply_len)) {
7817 return false;
7818 }
7819 if (!writer.write(return_helper)) {
7820 return false;
7821 }
7822 }
7823 return true;
7824}
7825
7827{
7828 if (!reader.readListReturn()) {
7829 return false;
7830 }
7831 if (reader.noMore()) {
7832 reader.fail();
7833 return false;
7834 }
7835 if (!reader.read(return_helper)) {
7836 reader.fail();
7837 return false;
7838 }
7839 return true;
7840}
7841
7846
7847// getVideoModeDC1394RPC helper class implementation
7849{
7850 return cmd.write(connection);
7851}
7852
7857
7859{
7860 yarp::os::idl::WireWriter writer(connection);
7861 if (!writer.writeListHeader(s_cmd_len)) {
7862 return false;
7863 }
7864 return write(writer);
7865}
7866
7868{
7869 yarp::os::idl::WireReader reader(connection);
7870 if (!reader.readListHeader()) {
7871 reader.fail();
7872 return false;
7873 }
7874 return read(reader);
7875}
7876
7878{
7879 if (!writeTag(writer)) {
7880 return false;
7881 }
7882 if (!writeArgs(writer)) {
7883 return false;
7884 }
7885 return true;
7886}
7887
7889{
7890 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7891 return false;
7892 }
7893 return true;
7894}
7895
7897{
7898 return true;
7899}
7900
7902{
7903 if (!readTag(reader)) {
7904 return false;
7905 }
7906 if (!readArgs(reader)) {
7907 return false;
7908 }
7909 return true;
7910}
7911
7913{
7914 std::string tag = reader.readTag(s_tag_len);
7915 if (reader.isError()) {
7916 return false;
7917 }
7918 if (tag != s_tag) {
7919 reader.fail();
7920 return false;
7921 }
7922 return true;
7923}
7924
7926{
7927 if (!reader.noMore()) {
7928 reader.fail();
7929 return false;
7930 }
7931 return true;
7932}
7933
7935{
7936 yarp::os::idl::WireWriter writer(connection);
7937 return write(writer);
7938}
7939
7941{
7942 yarp::os::idl::WireReader reader(connection);
7943 return read(reader);
7944}
7945
7947{
7948 if (!writer.isNull()) {
7949 if (!writer.writeListHeader(s_reply_len)) {
7950 return false;
7951 }
7952 if (!writer.write(return_helper)) {
7953 return false;
7954 }
7955 }
7956 return true;
7957}
7958
7960{
7961 if (!reader.readListReturn()) {
7962 return false;
7963 }
7964 if (reader.noMore()) {
7965 reader.fail();
7966 return false;
7967 }
7968 if (!reader.read(return_helper)) {
7969 reader.fail();
7970 return false;
7971 }
7972 return true;
7973}
7974
7979
7980// setVideoModeDC1394RPC helper class implementation
7985
7987{
7988 return cmd.write(connection);
7989}
7990
7995
7997 videomode{videomode}
7998{
7999}
8000
8002{
8003 yarp::os::idl::WireWriter writer(connection);
8004 if (!writer.writeListHeader(s_cmd_len)) {
8005 return false;
8006 }
8007 return write(writer);
8008}
8009
8011{
8012 yarp::os::idl::WireReader reader(connection);
8013 if (!reader.readListHeader()) {
8014 reader.fail();
8015 return false;
8016 }
8017 return read(reader);
8018}
8019
8021{
8022 if (!writeTag(writer)) {
8023 return false;
8024 }
8025 if (!writeArgs(writer)) {
8026 return false;
8027 }
8028 return true;
8029}
8030
8032{
8033 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8034 return false;
8035 }
8036 return true;
8037}
8038
8040{
8041 if (!writer.writeI32(videomode)) {
8042 return false;
8043 }
8044 return true;
8045}
8046
8048{
8049 if (!readTag(reader)) {
8050 return false;
8051 }
8052 if (!readArgs(reader)) {
8053 return false;
8054 }
8055 return true;
8056}
8057
8059{
8060 std::string tag = reader.readTag(s_tag_len);
8061 if (reader.isError()) {
8062 return false;
8063 }
8064 if (tag != s_tag) {
8065 reader.fail();
8066 return false;
8067 }
8068 return true;
8069}
8070
8072{
8073 if (reader.noMore()) {
8074 reader.fail();
8075 return false;
8076 }
8077 if (!reader.readI32(videomode)) {
8078 reader.fail();
8079 return false;
8080 }
8081 if (!reader.noMore()) {
8082 reader.fail();
8083 return false;
8084 }
8085 return true;
8086}
8087
8089{
8090 yarp::os::idl::WireWriter writer(connection);
8091 return write(writer);
8092}
8093
8095{
8096 yarp::os::idl::WireReader reader(connection);
8097 return read(reader);
8098}
8099
8101{
8102 if (!writer.isNull()) {
8103 if (!writer.write(return_helper)) {
8104 return false;
8105 }
8106 }
8107 return true;
8108}
8109
8111{
8112 if (reader.noMore()) {
8113 reader.fail();
8114 return false;
8115 }
8116 if (!reader.read(return_helper)) {
8117 reader.fail();
8118 return false;
8119 }
8120 return true;
8121}
8122
8127
8128// getFPSMaskDC1394RPC helper class implementation
8130{
8131 return cmd.write(connection);
8132}
8133
8138
8140{
8141 yarp::os::idl::WireWriter writer(connection);
8142 if (!writer.writeListHeader(s_cmd_len)) {
8143 return false;
8144 }
8145 return write(writer);
8146}
8147
8149{
8150 yarp::os::idl::WireReader reader(connection);
8151 if (!reader.readListHeader()) {
8152 reader.fail();
8153 return false;
8154 }
8155 return read(reader);
8156}
8157
8159{
8160 if (!writeTag(writer)) {
8161 return false;
8162 }
8163 if (!writeArgs(writer)) {
8164 return false;
8165 }
8166 return true;
8167}
8168
8170{
8171 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8172 return false;
8173 }
8174 return true;
8175}
8176
8178{
8179 return true;
8180}
8181
8183{
8184 if (!readTag(reader)) {
8185 return false;
8186 }
8187 if (!readArgs(reader)) {
8188 return false;
8189 }
8190 return true;
8191}
8192
8194{
8195 std::string tag = reader.readTag(s_tag_len);
8196 if (reader.isError()) {
8197 return false;
8198 }
8199 if (tag != s_tag) {
8200 reader.fail();
8201 return false;
8202 }
8203 return true;
8204}
8205
8207{
8208 if (!reader.noMore()) {
8209 reader.fail();
8210 return false;
8211 }
8212 return true;
8213}
8214
8216{
8217 yarp::os::idl::WireWriter writer(connection);
8218 return write(writer);
8219}
8220
8222{
8223 yarp::os::idl::WireReader reader(connection);
8224 return read(reader);
8225}
8226
8228{
8229 if (!writer.isNull()) {
8230 if (!writer.writeListHeader(s_reply_len)) {
8231 return false;
8232 }
8233 if (!writer.write(return_helper)) {
8234 return false;
8235 }
8236 }
8237 return true;
8238}
8239
8241{
8242 if (!reader.readListReturn()) {
8243 return false;
8244 }
8245 if (reader.noMore()) {
8246 reader.fail();
8247 return false;
8248 }
8249 if (!reader.read(return_helper)) {
8250 reader.fail();
8251 return false;
8252 }
8253 return true;
8254}
8255
8260
8261// getFPSDC1394RPC helper class implementation
8263{
8264 return cmd.write(connection);
8265}
8266
8268{
8269 return reply.read(connection);
8270}
8271
8273{
8274 yarp::os::idl::WireWriter writer(connection);
8275 if (!writer.writeListHeader(s_cmd_len)) {
8276 return false;
8277 }
8278 return write(writer);
8279}
8280
8282{
8283 yarp::os::idl::WireReader reader(connection);
8284 if (!reader.readListHeader()) {
8285 reader.fail();
8286 return false;
8287 }
8288 return read(reader);
8289}
8290
8292{
8293 if (!writeTag(writer)) {
8294 return false;
8295 }
8296 if (!writeArgs(writer)) {
8297 return false;
8298 }
8299 return true;
8300}
8301
8303{
8304 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8305 return false;
8306 }
8307 return true;
8308}
8309
8311{
8312 return true;
8313}
8314
8316{
8317 if (!readTag(reader)) {
8318 return false;
8319 }
8320 if (!readArgs(reader)) {
8321 return false;
8322 }
8323 return true;
8324}
8325
8327{
8328 std::string tag = reader.readTag(s_tag_len);
8329 if (reader.isError()) {
8330 return false;
8331 }
8332 if (tag != s_tag) {
8333 reader.fail();
8334 return false;
8335 }
8336 return true;
8337}
8338
8340{
8341 if (!reader.noMore()) {
8342 reader.fail();
8343 return false;
8344 }
8345 return true;
8346}
8347
8349{
8350 yarp::os::idl::WireWriter writer(connection);
8351 return write(writer);
8352}
8353
8355{
8356 yarp::os::idl::WireReader reader(connection);
8357 return read(reader);
8358}
8359
8361{
8362 if (!writer.isNull()) {
8363 if (!writer.writeListHeader(s_reply_len)) {
8364 return false;
8365 }
8366 if (!writer.write(return_helper)) {
8367 return false;
8368 }
8369 }
8370 return true;
8371}
8372
8374{
8375 if (!reader.readListReturn()) {
8376 return false;
8377 }
8378 if (reader.noMore()) {
8379 reader.fail();
8380 return false;
8381 }
8382 if (!reader.read(return_helper)) {
8383 reader.fail();
8384 return false;
8385 }
8386 return true;
8387}
8388
8393
8394// setFPSDC1394RPC helper class implementation
8399
8401{
8402 return cmd.write(connection);
8403}
8404
8406{
8407 return reply.read(connection);
8408}
8409
8414
8416{
8417 yarp::os::idl::WireWriter writer(connection);
8418 if (!writer.writeListHeader(s_cmd_len)) {
8419 return false;
8420 }
8421 return write(writer);
8422}
8423
8425{
8426 yarp::os::idl::WireReader reader(connection);
8427 if (!reader.readListHeader()) {
8428 reader.fail();
8429 return false;
8430 }
8431 return read(reader);
8432}
8433
8435{
8436 if (!writeTag(writer)) {
8437 return false;
8438 }
8439 if (!writeArgs(writer)) {
8440 return false;
8441 }
8442 return true;
8443}
8444
8446{
8447 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8448 return false;
8449 }
8450 return true;
8451}
8452
8454{
8455 if (!writer.writeI32(fps)) {
8456 return false;
8457 }
8458 return true;
8459}
8460
8462{
8463 if (!readTag(reader)) {
8464 return false;
8465 }
8466 if (!readArgs(reader)) {
8467 return false;
8468 }
8469 return true;
8470}
8471
8473{
8474 std::string tag = reader.readTag(s_tag_len);
8475 if (reader.isError()) {
8476 return false;
8477 }
8478 if (tag != s_tag) {
8479 reader.fail();
8480 return false;
8481 }
8482 return true;
8483}
8484
8486{
8487 if (reader.noMore()) {
8488 reader.fail();
8489 return false;
8490 }
8491 if (!reader.readI32(fps)) {
8492 reader.fail();
8493 return false;
8494 }
8495 if (!reader.noMore()) {
8496 reader.fail();
8497 return false;
8498 }
8499 return true;
8500}
8501
8503{
8504 yarp::os::idl::WireWriter writer(connection);
8505 return write(writer);
8506}
8507
8509{
8510 yarp::os::idl::WireReader reader(connection);
8511 return read(reader);
8512}
8513
8515{
8516 if (!writer.isNull()) {
8517 if (!writer.write(return_helper)) {
8518 return false;
8519 }
8520 }
8521 return true;
8522}
8523
8525{
8526 if (reader.noMore()) {
8527 reader.fail();
8528 return false;
8529 }
8530 if (!reader.read(return_helper)) {
8531 reader.fail();
8532 return false;
8533 }
8534 return true;
8535}
8536
8541
8542// getISOSpeedDC1394RPC helper class implementation
8544{
8545 return cmd.write(connection);
8546}
8547
8552
8554{
8555 yarp::os::idl::WireWriter writer(connection);
8556 if (!writer.writeListHeader(s_cmd_len)) {
8557 return false;
8558 }
8559 return write(writer);
8560}
8561
8563{
8564 yarp::os::idl::WireReader reader(connection);
8565 if (!reader.readListHeader()) {
8566 reader.fail();
8567 return false;
8568 }
8569 return read(reader);
8570}
8571
8573{
8574 if (!writeTag(writer)) {
8575 return false;
8576 }
8577 if (!writeArgs(writer)) {
8578 return false;
8579 }
8580 return true;
8581}
8582
8584{
8585 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8586 return false;
8587 }
8588 return true;
8589}
8590
8592{
8593 return true;
8594}
8595
8597{
8598 if (!readTag(reader)) {
8599 return false;
8600 }
8601 if (!readArgs(reader)) {
8602 return false;
8603 }
8604 return true;
8605}
8606
8608{
8609 std::string tag = reader.readTag(s_tag_len);
8610 if (reader.isError()) {
8611 return false;
8612 }
8613 if (tag != s_tag) {
8614 reader.fail();
8615 return false;
8616 }
8617 return true;
8618}
8619
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// setISOSpeedDC1394RPC helper class implementation
8680
8682{
8683 return cmd.write(connection);
8684}
8685
8690
8692 speed{speed}
8693{
8694}
8695
8697{
8698 yarp::os::idl::WireWriter writer(connection);
8699 if (!writer.writeListHeader(s_cmd_len)) {
8700 return false;
8701 }
8702 return write(writer);
8703}
8704
8706{
8707 yarp::os::idl::WireReader reader(connection);
8708 if (!reader.readListHeader()) {
8709 reader.fail();
8710 return false;
8711 }
8712 return read(reader);
8713}
8714
8716{
8717 if (!writeTag(writer)) {
8718 return false;
8719 }
8720 if (!writeArgs(writer)) {
8721 return false;
8722 }
8723 return true;
8724}
8725
8727{
8728 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8729 return false;
8730 }
8731 return true;
8732}
8733
8735{
8736 if (!writer.writeI32(speed)) {
8737 return false;
8738 }
8739 return true;
8740}
8741
8743{
8744 if (!readTag(reader)) {
8745 return false;
8746 }
8747 if (!readArgs(reader)) {
8748 return false;
8749 }
8750 return true;
8751}
8752
8754{
8755 std::string tag = reader.readTag(s_tag_len);
8756 if (reader.isError()) {
8757 return false;
8758 }
8759 if (tag != s_tag) {
8760 reader.fail();
8761 return false;
8762 }
8763 return true;
8764}
8765
8767{
8768 if (reader.noMore()) {
8769 reader.fail();
8770 return false;
8771 }
8772 if (!reader.readI32(speed)) {
8773 reader.fail();
8774 return false;
8775 }
8776 if (!reader.noMore()) {
8777 reader.fail();
8778 return false;
8779 }
8780 return true;
8781}
8782
8784{
8785 yarp::os::idl::WireWriter writer(connection);
8786 return write(writer);
8787}
8788
8790{
8791 yarp::os::idl::WireReader reader(connection);
8792 return read(reader);
8793}
8794
8796{
8797 if (!writer.isNull()) {
8798 if (!writer.write(return_helper)) {
8799 return false;
8800 }
8801 }
8802 return true;
8803}
8804
8806{
8807 if (reader.noMore()) {
8808 reader.fail();
8809 return false;
8810 }
8811 if (!reader.read(return_helper)) {
8812 reader.fail();
8813 return false;
8814 }
8815 return true;
8816}
8817
8822
8823// getColorCodingMaskDC1394RPC helper class implementation
8828
8830{
8831 return cmd.write(connection);
8832}
8833
8838
8840 videomode{videomode}
8841{
8842}
8843
8845{
8846 yarp::os::idl::WireWriter writer(connection);
8847 if (!writer.writeListHeader(s_cmd_len)) {
8848 return false;
8849 }
8850 return write(writer);
8851}
8852
8854{
8855 yarp::os::idl::WireReader reader(connection);
8856 if (!reader.readListHeader()) {
8857 reader.fail();
8858 return false;
8859 }
8860 return read(reader);
8861}
8862
8864{
8865 if (!writeTag(writer)) {
8866 return false;
8867 }
8868 if (!writeArgs(writer)) {
8869 return false;
8870 }
8871 return true;
8872}
8873
8875{
8876 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8877 return false;
8878 }
8879 return true;
8880}
8881
8883{
8884 if (!writer.writeI32(videomode)) {
8885 return false;
8886 }
8887 return true;
8888}
8889
8891{
8892 if (!readTag(reader)) {
8893 return false;
8894 }
8895 if (!readArgs(reader)) {
8896 return false;
8897 }
8898 return true;
8899}
8900
8902{
8903 std::string tag = reader.readTag(s_tag_len);
8904 if (reader.isError()) {
8905 return false;
8906 }
8907 if (tag != s_tag) {
8908 reader.fail();
8909 return false;
8910 }
8911 return true;
8912}
8913
8915{
8916 if (reader.noMore()) {
8917 reader.fail();
8918 return false;
8919 }
8920 if (!reader.readI32(videomode)) {
8921 reader.fail();
8922 return false;
8923 }
8924 if (!reader.noMore()) {
8925 reader.fail();
8926 return false;
8927 }
8928 return true;
8929}
8930
8932{
8933 yarp::os::idl::WireWriter writer(connection);
8934 return write(writer);
8935}
8936
8942
8944{
8945 if (!writer.isNull()) {
8946 if (!writer.writeListHeader(s_reply_len)) {
8947 return false;
8948 }
8949 if (!writer.write(return_helper)) {
8950 return false;
8951 }
8952 }
8953 return true;
8954}
8955
8957{
8958 if (!reader.readListReturn()) {
8959 return false;
8960 }
8961 if (reader.noMore()) {
8962 reader.fail();
8963 return false;
8964 }
8965 if (!reader.read(return_helper)) {
8966 reader.fail();
8967 return false;
8968 }
8969 return true;
8970}
8971
8976
8977// getColorCodingDC1394RPC helper class implementation
8979{
8980 return cmd.write(connection);
8981}
8982
8987
8989{
8990 yarp::os::idl::WireWriter writer(connection);
8991 if (!writer.writeListHeader(s_cmd_len)) {
8992 return false;
8993 }
8994 return write(writer);
8995}
8996
8998{
8999 yarp::os::idl::WireReader reader(connection);
9000 if (!reader.readListHeader()) {
9001 reader.fail();
9002 return false;
9003 }
9004 return read(reader);
9005}
9006
9008{
9009 if (!writeTag(writer)) {
9010 return false;
9011 }
9012 if (!writeArgs(writer)) {
9013 return false;
9014 }
9015 return true;
9016}
9017
9019{
9020 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
9021 return false;
9022 }
9023 return true;
9024}
9025
9027{
9028 return true;
9029}
9030
9032{
9033 if (!readTag(reader)) {
9034 return false;
9035 }
9036 if (!readArgs(reader)) {
9037 return false;
9038 }
9039 return true;
9040}
9041
9043{
9044 std::string tag = reader.readTag(s_tag_len);
9045 if (reader.isError()) {
9046 return false;
9047 }
9048 if (tag != s_tag) {
9049 reader.fail();
9050 return false;
9051 }
9052 return true;
9053}
9054
9056{
9057 if (!reader.noMore()) {
9058 reader.fail();
9059 return false;
9060 }
9061 return true;
9062}
9063
9065{
9066 yarp::os::idl::WireWriter writer(connection);
9067 return write(writer);
9068}
9069
9071{
9072 yarp::os::idl::WireReader reader(connection);
9073 return read(reader);
9074}
9075
9077{
9078 if (!writer.isNull()) {
9079 if (!writer.writeListHeader(s_reply_len)) {
9080 return false;
9081 }
9082 if (!writer.write(return_helper)) {
9083 return false;
9084 }
9085 }
9086 return true;
9087}
9088
9090{
9091 if (!reader.readListReturn()) {
9092 return false;
9093 }
9094 if (reader.noMore()) {
9095 reader.fail();
9096 return false;
9097 }
9098 if (!reader.read(return_helper)) {
9099 reader.fail();
9100 return false;
9101 }
9102 return true;
9103}
9104
9109
9110// setColorCodingDC1394RPC helper class implementation
9115
9117{
9118 return cmd.write(connection);
9119}
9120
9125
9127 coding{coding}
9128{
9129}
9130
9132{
9133 yarp::os::idl::WireWriter writer(connection);
9134 if (!writer.writeListHeader(s_cmd_len)) {
9135 return false;
9136 }
9137 return write(writer);
9138}
9139
9141{
9142 yarp::os::idl::WireReader reader(connection);
9143 if (!reader.readListHeader()) {
9144 reader.fail();
9145 return false;
9146 }
9147 return read(reader);
9148}
9149
9151{
9152 if (!writeTag(writer)) {
9153 return false;
9154 }
9155 if (!writeArgs(writer)) {
9156 return false;
9157 }
9158 return true;
9159}
9160
9162{
9163 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
9164 return false;
9165 }
9166 return true;
9167}
9168
9170{
9171 if (!writer.writeI32(coding)) {
9172 return false;
9173 }
9174 return true;
9175}
9176
9178{
9179 if (!readTag(reader)) {
9180 return false;
9181 }
9182 if (!readArgs(reader)) {
9183 return false;
9184 }
9185 return true;
9186}
9187
9189{
9190 std::string tag = reader.readTag(s_tag_len);
9191 if (reader.isError()) {
9192 return false;
9193 }
9194 if (tag != s_tag) {
9195 reader.fail();
9196 return false;
9197 }
9198 return true;
9199}
9200
9202{
9203 if (reader.noMore()) {
9204 reader.fail();
9205 return false;
9206 }
9207 if (!reader.readI32(coding)) {
9208 reader.fail();
9209 return false;
9210 }
9211 if (!reader.noMore()) {
9212 reader.fail();
9213 return false;
9214 }
9215 return true;
9216}
9217
9219{
9220 yarp::os::idl::WireWriter writer(connection);
9221 return write(writer);
9222}
9223
9225{
9226 yarp::os::idl::WireReader reader(connection);
9227 return read(reader);
9228}
9229
9231{
9232 if (!writer.isNull()) {
9233 if (!writer.write(return_helper)) {
9234 return false;
9235 }
9236 }
9237 return true;
9238}
9239
9241{
9242 if (reader.noMore()) {
9243 reader.fail();
9244 return false;
9245 }
9246 if (!reader.read(return_helper)) {
9247 reader.fail();
9248 return false;
9249 }
9250 return true;
9251}
9252
9257
9258// getFormat7MaxWindowDC1394RPC helper class implementation
9263
9268
9270{
9271 yarp::os::idl::WireWriter writer(connection);
9272 if (!writer.writeListHeader(s_cmd_len)) {
9273 return false;
9274 }
9275 return write(writer);
9276}
9277
9279{
9280 yarp::os::idl::WireReader reader(connection);
9281 if (!reader.readListHeader()) {
9282 reader.fail();
9283 return false;
9284 }
9285 return read(reader);
9286}
9287
9289{
9290 if (!writeTag(writer)) {
9291 return false;
9292 }
9293 if (!writeArgs(writer)) {
9294 return false;
9295 }
9296 return true;
9297}
9298
9300{
9301 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
9302 return false;
9303 }
9304 return true;
9305}
9306
9308{
9309 return true;
9310}
9311
9313{
9314 if (!readTag(reader)) {
9315 return false;
9316 }
9317 if (!readArgs(reader)) {
9318 return false;
9319 }
9320 return true;
9321}
9322
9324{
9325 std::string tag = reader.readTag(s_tag_len);
9326 if (reader.isError()) {
9327 return false;
9328 }
9329 if (tag != s_tag) {
9330 reader.fail();
9331 return false;
9332 }
9333 return true;
9334}
9335
9337{
9338 if (!reader.noMore()) {
9339 reader.fail();
9340 return false;
9341 }
9342 return true;
9343}
9344
9346{
9347 yarp::os::idl::WireWriter writer(connection);
9348 return write(writer);
9349}
9350
9356
9358{
9359 if (!writer.isNull()) {
9360 if (!writer.writeListHeader(s_reply_len)) {
9361 return false;
9362 }
9363 if (!writer.write(return_helper)) {
9364 return false;
9365 }
9366 }
9367 return true;
9368}
9369
9371{
9372 if (!reader.readListReturn()) {
9373 return false;
9374 }
9375 if (reader.noMore()) {
9376 reader.fail();
9377 return false;
9378 }
9379 if (!reader.read(return_helper)) {
9380 reader.fail();
9381 return false;
9382 }
9383 return true;
9384}
9385
9390
9391// getFormat7WindowDC1394RPC helper class implementation
9393{
9394 return cmd.write(connection);
9395}
9396
9401
9403{
9404 yarp::os::idl::WireWriter writer(connection);
9405 if (!writer.writeListHeader(s_cmd_len)) {
9406 return false;
9407 }
9408 return write(writer);
9409}
9410
9412{
9413 yarp::os::idl::WireReader reader(connection);
9414 if (!reader.readListHeader()) {
9415 reader.fail();
9416 return false;
9417 }
9418 return read(reader);
9419}
9420
9422{
9423 if (!writeTag(writer)) {
9424 return false;
9425 }
9426 if (!writeArgs(writer)) {
9427 return false;
9428 }
9429 return true;
9430}
9431
9433{
9434 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
9435 return false;
9436 }
9437 return true;
9438}
9439
9441{
9442 return true;
9443}
9444
9446{
9447 if (!readTag(reader)) {
9448 return false;
9449 }
9450 if (!readArgs(reader)) {
9451 return false;
9452 }
9453 return true;
9454}
9455
9457{
9458 std::string tag = reader.readTag(s_tag_len);
9459 if (reader.isError()) {
9460 return false;
9461 }
9462 if (tag != s_tag) {
9463 reader.fail();
9464 return false;
9465 }
9466 return true;
9467}
9468
9470{
9471 if (!reader.noMore()) {
9472 reader.fail();
9473 return false;
9474 }
9475 return true;
9476}
9477
9479{
9480 yarp::os::idl::WireWriter writer(connection);
9481 return write(writer);
9482}
9483
9489
9491{
9492 if (!writer.isNull()) {
9493 if (!writer.writeListHeader(s_reply_len)) {
9494 return false;
9495 }
9496 if (!writer.write(return_helper)) {
9497 return false;
9498 }
9499 }
9500 return true;
9501}
9502
9504{
9505 if (!reader.readListReturn()) {
9506 return false;
9507 }
9508 if (reader.noMore()) {
9509 reader.fail();
9510 return false;
9511 }
9512 if (!reader.read(return_helper)) {
9513 reader.fail();
9514 return false;
9515 }
9516 return true;
9517}
9518
9523
9524// setFormat7WindowDC1394RPC helper class implementation
9525FrameGrabberMsgs_setFormat7WindowDC1394RPC_helper::FrameGrabberMsgs_setFormat7WindowDC1394RPC_helper(const std::int32_t xdim, const std::int32_t ydim, const std::int32_t x0, const std::int32_t y0) :
9526 cmd{xdim, ydim, x0, y0}
9527{
9528}
9529
9531{
9532 return cmd.write(connection);
9533}
9534
9539
9540FrameGrabberMsgs_setFormat7WindowDC1394RPC_helper::Command::Command(const std::int32_t xdim, const std::int32_t ydim, const std::int32_t x0, const std::int32_t y0) :
9541 xdim{xdim},
9542 ydim{ydim},
9543 x0{x0},
9544 y0{y0}
9545{
9546}
9547
9549{
9550 yarp::os::idl::WireWriter writer(connection);
9551 if (!writer.writeListHeader(s_cmd_len)) {
9552 return false;
9553 }
9554 return write(writer);
9555}
9556
9558{
9559 yarp::os::idl::WireReader reader(connection);
9560 if (!reader.readListHeader()) {
9561 reader.fail();
9562 return false;
9563 }
9564 return read(reader);
9565}
9566
9568{
9569 if (!writeTag(writer)) {
9570 return false;
9571 }
9572 if (!writeArgs(writer)) {
9573 return false;
9574 }
9575 return true;
9576}
9577
9579{
9580 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
9581 return false;
9582 }
9583 return true;
9584}
9585
9587{
9588 if (!writer.writeI32(xdim)) {
9589 return false;
9590 }
9591 if (!writer.writeI32(ydim)) {
9592 return false;
9593 }
9594 if (!writer.writeI32(x0)) {
9595 return false;
9596 }
9597 if (!writer.writeI32(y0)) {
9598 return false;
9599 }
9600 return true;
9601}
9602
9604{
9605 if (!readTag(reader)) {
9606 return false;
9607 }
9608 if (!readArgs(reader)) {
9609 return false;
9610 }
9611 return true;
9612}
9613
9615{
9616 std::string tag = reader.readTag(s_tag_len);
9617 if (reader.isError()) {
9618 return false;
9619 }
9620 if (tag != s_tag) {
9621 reader.fail();
9622 return false;
9623 }
9624 return true;
9625}
9626
9628{
9629 if (reader.noMore()) {
9630 reader.fail();
9631 return false;
9632 }
9633 if (!reader.readI32(xdim)) {
9634 reader.fail();
9635 return false;
9636 }
9637 if (reader.noMore()) {
9638 reader.fail();
9639 return false;
9640 }
9641 if (!reader.readI32(ydim)) {
9642 reader.fail();
9643 return false;
9644 }
9645 if (reader.noMore()) {
9646 reader.fail();
9647 return false;
9648 }
9649 if (!reader.readI32(x0)) {
9650 reader.fail();
9651 return false;
9652 }
9653 if (reader.noMore()) {
9654 reader.fail();
9655 return false;
9656 }
9657 if (!reader.readI32(y0)) {
9658 reader.fail();
9659 return false;
9660 }
9661 if (!reader.noMore()) {
9662 reader.fail();
9663 return false;
9664 }
9665 return true;
9666}
9667
9669{
9670 yarp::os::idl::WireWriter writer(connection);
9671 return write(writer);
9672}
9673
9679
9681{
9682 if (!writer.isNull()) {
9683 if (!writer.write(return_helper)) {
9684 return false;
9685 }
9686 }
9687 return true;
9688}
9689
9691{
9692 if (reader.noMore()) {
9693 reader.fail();
9694 return false;
9695 }
9696 if (!reader.read(return_helper)) {
9697 reader.fail();
9698 return false;
9699 }
9700 return true;
9701}
9702
9707
9708// setOperationModeDC1394RPC helper class implementation
9713
9715{
9716 return cmd.write(connection);
9717}
9718
9723
9725 b1394b{b1394b}
9726{
9727}
9728
9730{
9731 yarp::os::idl::WireWriter writer(connection);
9732 if (!writer.writeListHeader(s_cmd_len)) {
9733 return false;
9734 }
9735 return write(writer);
9736}
9737
9739{
9740 yarp::os::idl::WireReader reader(connection);
9741 if (!reader.readListHeader()) {
9742 reader.fail();
9743 return false;
9744 }
9745 return read(reader);
9746}
9747
9749{
9750 if (!writeTag(writer)) {
9751 return false;
9752 }
9753 if (!writeArgs(writer)) {
9754 return false;
9755 }
9756 return true;
9757}
9758
9760{
9761 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
9762 return false;
9763 }
9764 return true;
9765}
9766
9768{
9769 if (!writer.writeBool(b1394b)) {
9770 return false;
9771 }
9772 return true;
9773}
9774
9776{
9777 if (!readTag(reader)) {
9778 return false;
9779 }
9780 if (!readArgs(reader)) {
9781 return false;
9782 }
9783 return true;
9784}
9785
9787{
9788 std::string tag = reader.readTag(s_tag_len);
9789 if (reader.isError()) {
9790 return false;
9791 }
9792 if (tag != s_tag) {
9793 reader.fail();
9794 return false;
9795 }
9796 return true;
9797}
9798
9800{
9801 if (reader.noMore()) {
9802 reader.fail();
9803 return false;
9804 }
9805 if (!reader.readBool(b1394b)) {
9806 reader.fail();
9807 return false;
9808 }
9809 if (!reader.noMore()) {
9810 reader.fail();
9811 return false;
9812 }
9813 return true;
9814}
9815
9817{
9818 yarp::os::idl::WireWriter writer(connection);
9819 return write(writer);
9820}
9821
9827
9829{
9830 if (!writer.isNull()) {
9831 if (!writer.write(return_helper)) {
9832 return false;
9833 }
9834 }
9835 return true;
9836}
9837
9839{
9840 if (reader.noMore()) {
9841 reader.fail();
9842 return false;
9843 }
9844 if (!reader.read(return_helper)) {
9845 reader.fail();
9846 return false;
9847 }
9848 return true;
9849}
9850
9855
9856// getOperationModeDC1394RPC helper class implementation
9858{
9859 return cmd.write(connection);
9860}
9861
9866
9868{
9869 yarp::os::idl::WireWriter writer(connection);
9870 if (!writer.writeListHeader(s_cmd_len)) {
9871 return false;
9872 }
9873 return write(writer);
9874}
9875
9877{
9878 yarp::os::idl::WireReader reader(connection);
9879 if (!reader.readListHeader()) {
9880 reader.fail();
9881 return false;
9882 }
9883 return read(reader);
9884}
9885
9887{
9888 if (!writeTag(writer)) {
9889 return false;
9890 }
9891 if (!writeArgs(writer)) {
9892 return false;
9893 }
9894 return true;
9895}
9896
9898{
9899 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
9900 return false;
9901 }
9902 return true;
9903}
9904
9906{
9907 return true;
9908}
9909
9911{
9912 if (!readTag(reader)) {
9913 return false;
9914 }
9915 if (!readArgs(reader)) {
9916 return false;
9917 }
9918 return true;
9919}
9920
9922{
9923 std::string tag = reader.readTag(s_tag_len);
9924 if (reader.isError()) {
9925 return false;
9926 }
9927 if (tag != s_tag) {
9928 reader.fail();
9929 return false;
9930 }
9931 return true;
9932}
9933
9935{
9936 if (!reader.noMore()) {
9937 reader.fail();
9938 return false;
9939 }
9940 return true;
9941}
9942
9944{
9945 yarp::os::idl::WireWriter writer(connection);
9946 return write(writer);
9947}
9948
9954
9956{
9957 if (!writer.isNull()) {
9958 if (!writer.writeListHeader(s_reply_len)) {
9959 return false;
9960 }
9961 if (!writer.write(return_helper)) {
9962 return false;
9963 }
9964 }
9965 return true;
9966}
9967
9969{
9970 if (!reader.readListReturn()) {
9971 return false;
9972 }
9973 if (reader.noMore()) {
9974 reader.fail();
9975 return false;
9976 }
9977 if (!reader.read(return_helper)) {
9978 reader.fail();
9979 return false;
9980 }
9981 return true;
9982}
9983
9988
9989// setTransmissionDC1394RPC helper class implementation
9994
9996{
9997 return cmd.write(connection);
9998}
9999
10001{
10002 return reply.read(connection);
10003}
10004
10006 bTxON{bTxON}
10007{
10008}
10009
10011{
10012 yarp::os::idl::WireWriter writer(connection);
10013 if (!writer.writeListHeader(s_cmd_len)) {
10014 return false;
10015 }
10016 return write(writer);
10017}
10018
10020{
10021 yarp::os::idl::WireReader reader(connection);
10022 if (!reader.readListHeader()) {
10023 reader.fail();
10024 return false;
10025 }
10026 return read(reader);
10027}
10028
10030{
10031 if (!writeTag(writer)) {
10032 return false;
10033 }
10034 if (!writeArgs(writer)) {
10035 return false;
10036 }
10037 return true;
10038}
10039
10041{
10042 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
10043 return false;
10044 }
10045 return true;
10046}
10047
10049{
10050 if (!writer.writeBool(bTxON)) {
10051 return false;
10052 }
10053 return true;
10054}
10055
10057{
10058 if (!readTag(reader)) {
10059 return false;
10060 }
10061 if (!readArgs(reader)) {
10062 return false;
10063 }
10064 return true;
10065}
10066
10068{
10069 std::string tag = reader.readTag(s_tag_len);
10070 if (reader.isError()) {
10071 return false;
10072 }
10073 if (tag != s_tag) {
10074 reader.fail();
10075 return false;
10076 }
10077 return true;
10078}
10079
10081{
10082 if (reader.noMore()) {
10083 reader.fail();
10084 return false;
10085 }
10086 if (!reader.readBool(bTxON)) {
10087 reader.fail();
10088 return false;
10089 }
10090 if (!reader.noMore()) {
10091 reader.fail();
10092 return false;
10093 }
10094 return true;
10095}
10096
10098{
10099 yarp::os::idl::WireWriter writer(connection);
10100 return write(writer);
10101}
10102
10104{
10105 yarp::os::idl::WireReader reader(connection);
10106 return read(reader);
10107}
10108
10110{
10111 if (!writer.isNull()) {
10112 if (!writer.write(return_helper)) {
10113 return false;
10114 }
10115 }
10116 return true;
10117}
10118
10120{
10121 if (reader.noMore()) {
10122 reader.fail();
10123 return false;
10124 }
10125 if (!reader.read(return_helper)) {
10126 reader.fail();
10127 return false;
10128 }
10129 return true;
10130}
10131
10136
10137// getTransmissionDC1394RPC helper class implementation
10139{
10140 return cmd.write(connection);
10141}
10142
10144{
10145 return reply.read(connection);
10146}
10147
10149{
10150 yarp::os::idl::WireWriter writer(connection);
10151 if (!writer.writeListHeader(s_cmd_len)) {
10152 return false;
10153 }
10154 return write(writer);
10155}
10156
10158{
10159 yarp::os::idl::WireReader reader(connection);
10160 if (!reader.readListHeader()) {
10161 reader.fail();
10162 return false;
10163 }
10164 return read(reader);
10165}
10166
10168{
10169 if (!writeTag(writer)) {
10170 return false;
10171 }
10172 if (!writeArgs(writer)) {
10173 return false;
10174 }
10175 return true;
10176}
10177
10179{
10180 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
10181 return false;
10182 }
10183 return true;
10184}
10185
10187{
10188 return true;
10189}
10190
10192{
10193 if (!readTag(reader)) {
10194 return false;
10195 }
10196 if (!readArgs(reader)) {
10197 return false;
10198 }
10199 return true;
10200}
10201
10203{
10204 std::string tag = reader.readTag(s_tag_len);
10205 if (reader.isError()) {
10206 return false;
10207 }
10208 if (tag != s_tag) {
10209 reader.fail();
10210 return false;
10211 }
10212 return true;
10213}
10214
10216{
10217 if (!reader.noMore()) {
10218 reader.fail();
10219 return false;
10220 }
10221 return true;
10222}
10223
10225{
10226 yarp::os::idl::WireWriter writer(connection);
10227 return write(writer);
10228}
10229
10231{
10232 yarp::os::idl::WireReader reader(connection);
10233 return read(reader);
10234}
10235
10237{
10238 if (!writer.isNull()) {
10239 if (!writer.writeListHeader(s_reply_len)) {
10240 return false;
10241 }
10242 if (!writer.write(return_helper)) {
10243 return false;
10244 }
10245 }
10246 return true;
10247}
10248
10250{
10251 if (!reader.readListReturn()) {
10252 return false;
10253 }
10254 if (reader.noMore()) {
10255 reader.fail();
10256 return false;
10257 }
10258 if (!reader.read(return_helper)) {
10259 reader.fail();
10260 return false;
10261 }
10262 return true;
10263}
10264
10269
10270// setBroadcastDC1394RPC helper class implementation
10275
10277{
10278 return cmd.write(connection);
10279}
10280
10282{
10283 return reply.read(connection);
10284}
10285
10287 onoff{onoff}
10288{
10289}
10290
10292{
10293 yarp::os::idl::WireWriter writer(connection);
10294 if (!writer.writeListHeader(s_cmd_len)) {
10295 return false;
10296 }
10297 return write(writer);
10298}
10299
10301{
10302 yarp::os::idl::WireReader reader(connection);
10303 if (!reader.readListHeader()) {
10304 reader.fail();
10305 return false;
10306 }
10307 return read(reader);
10308}
10309
10311{
10312 if (!writeTag(writer)) {
10313 return false;
10314 }
10315 if (!writeArgs(writer)) {
10316 return false;
10317 }
10318 return true;
10319}
10320
10322{
10323 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
10324 return false;
10325 }
10326 return true;
10327}
10328
10330{
10331 if (!writer.writeBool(onoff)) {
10332 return false;
10333 }
10334 return true;
10335}
10336
10338{
10339 if (!readTag(reader)) {
10340 return false;
10341 }
10342 if (!readArgs(reader)) {
10343 return false;
10344 }
10345 return true;
10346}
10347
10349{
10350 std::string tag = reader.readTag(s_tag_len);
10351 if (reader.isError()) {
10352 return false;
10353 }
10354 if (tag != s_tag) {
10355 reader.fail();
10356 return false;
10357 }
10358 return true;
10359}
10360
10362{
10363 if (reader.noMore()) {
10364 reader.fail();
10365 return false;
10366 }
10367 if (!reader.readBool(onoff)) {
10368 reader.fail();
10369 return false;
10370 }
10371 if (!reader.noMore()) {
10372 reader.fail();
10373 return false;
10374 }
10375 return true;
10376}
10377
10379{
10380 yarp::os::idl::WireWriter writer(connection);
10381 return write(writer);
10382}
10383
10385{
10386 yarp::os::idl::WireReader reader(connection);
10387 return read(reader);
10388}
10389
10391{
10392 if (!writer.isNull()) {
10393 if (!writer.write(return_helper)) {
10394 return false;
10395 }
10396 }
10397 return true;
10398}
10399
10401{
10402 if (reader.noMore()) {
10403 reader.fail();
10404 return false;
10405 }
10406 if (!reader.read(return_helper)) {
10407 reader.fail();
10408 return false;
10409 }
10410 return true;
10411}
10412
10417
10418// setDefaultsDC1394RPC helper class implementation
10420{
10421 return cmd.write(connection);
10422}
10423
10425{
10426 return reply.read(connection);
10427}
10428
10430{
10431 yarp::os::idl::WireWriter writer(connection);
10432 if (!writer.writeListHeader(s_cmd_len)) {
10433 return false;
10434 }
10435 return write(writer);
10436}
10437
10439{
10440 yarp::os::idl::WireReader reader(connection);
10441 if (!reader.readListHeader()) {
10442 reader.fail();
10443 return false;
10444 }
10445 return read(reader);
10446}
10447
10449{
10450 if (!writeTag(writer)) {
10451 return false;
10452 }
10453 if (!writeArgs(writer)) {
10454 return false;
10455 }
10456 return true;
10457}
10458
10460{
10461 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
10462 return false;
10463 }
10464 return true;
10465}
10466
10468{
10469 return true;
10470}
10471
10473{
10474 if (!readTag(reader)) {
10475 return false;
10476 }
10477 if (!readArgs(reader)) {
10478 return false;
10479 }
10480 return true;
10481}
10482
10484{
10485 std::string tag = reader.readTag(s_tag_len);
10486 if (reader.isError()) {
10487 return false;
10488 }
10489 if (tag != s_tag) {
10490 reader.fail();
10491 return false;
10492 }
10493 return true;
10494}
10495
10497{
10498 if (!reader.noMore()) {
10499 reader.fail();
10500 return false;
10501 }
10502 return true;
10503}
10504
10506{
10507 yarp::os::idl::WireWriter writer(connection);
10508 return write(writer);
10509}
10510
10512{
10513 yarp::os::idl::WireReader reader(connection);
10514 return read(reader);
10515}
10516
10518{
10519 if (!writer.isNull()) {
10520 if (!writer.write(return_helper)) {
10521 return false;
10522 }
10523 }
10524 return true;
10525}
10526
10528{
10529 if (reader.noMore()) {
10530 reader.fail();
10531 return false;
10532 }
10533 if (!reader.read(return_helper)) {
10534 reader.fail();
10535 return false;
10536 }
10537 return true;
10538}
10539
10544
10545// setResetDC1394RPC helper class implementation
10547{
10548 return cmd.write(connection);
10549}
10550
10552{
10553 return reply.read(connection);
10554}
10555
10557{
10558 yarp::os::idl::WireWriter writer(connection);
10559 if (!writer.writeListHeader(s_cmd_len)) {
10560 return false;
10561 }
10562 return write(writer);
10563}
10564
10566{
10567 yarp::os::idl::WireReader reader(connection);
10568 if (!reader.readListHeader()) {
10569 reader.fail();
10570 return false;
10571 }
10572 return read(reader);
10573}
10574
10576{
10577 if (!writeTag(writer)) {
10578 return false;
10579 }
10580 if (!writeArgs(writer)) {
10581 return false;
10582 }
10583 return true;
10584}
10585
10587{
10588 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
10589 return false;
10590 }
10591 return true;
10592}
10593
10595{
10596 return true;
10597}
10598
10600{
10601 if (!readTag(reader)) {
10602 return false;
10603 }
10604 if (!readArgs(reader)) {
10605 return false;
10606 }
10607 return true;
10608}
10609
10611{
10612 std::string tag = reader.readTag(s_tag_len);
10613 if (reader.isError()) {
10614 return false;
10615 }
10616 if (tag != s_tag) {
10617 reader.fail();
10618 return false;
10619 }
10620 return true;
10621}
10622
10624{
10625 if (!reader.noMore()) {
10626 reader.fail();
10627 return false;
10628 }
10629 return true;
10630}
10631
10633{
10634 yarp::os::idl::WireWriter writer(connection);
10635 return write(writer);
10636}
10637
10639{
10640 yarp::os::idl::WireReader reader(connection);
10641 return read(reader);
10642}
10643
10645{
10646 if (!writer.isNull()) {
10647 if (!writer.write(return_helper)) {
10648 return false;
10649 }
10650 }
10651 return true;
10652}
10653
10655{
10656 if (reader.noMore()) {
10657 reader.fail();
10658 return false;
10659 }
10660 if (!reader.read(return_helper)) {
10661 reader.fail();
10662 return false;
10663 }
10664 return true;
10665}
10666
10671
10672// setPowerDC1394RPC helper class implementation
10677
10679{
10680 return cmd.write(connection);
10681}
10682
10684{
10685 return reply.read(connection);
10686}
10687
10689 onoff{onoff}
10690{
10691}
10692
10694{
10695 yarp::os::idl::WireWriter writer(connection);
10696 if (!writer.writeListHeader(s_cmd_len)) {
10697 return false;
10698 }
10699 return write(writer);
10700}
10701
10703{
10704 yarp::os::idl::WireReader reader(connection);
10705 if (!reader.readListHeader()) {
10706 reader.fail();
10707 return false;
10708 }
10709 return read(reader);
10710}
10711
10713{
10714 if (!writeTag(writer)) {
10715 return false;
10716 }
10717 if (!writeArgs(writer)) {
10718 return false;
10719 }
10720 return true;
10721}
10722
10724{
10725 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
10726 return false;
10727 }
10728 return true;
10729}
10730
10732{
10733 if (!writer.writeBool(onoff)) {
10734 return false;
10735 }
10736 return true;
10737}
10738
10740{
10741 if (!readTag(reader)) {
10742 return false;
10743 }
10744 if (!readArgs(reader)) {
10745 return false;
10746 }
10747 return true;
10748}
10749
10751{
10752 std::string tag = reader.readTag(s_tag_len);
10753 if (reader.isError()) {
10754 return false;
10755 }
10756 if (tag != s_tag) {
10757 reader.fail();
10758 return false;
10759 }
10760 return true;
10761}
10762
10764{
10765 if (reader.noMore()) {
10766 reader.fail();
10767 return false;
10768 }
10769 if (!reader.readBool(onoff)) {
10770 reader.fail();
10771 return false;
10772 }
10773 if (!reader.noMore()) {
10774 reader.fail();
10775 return false;
10776 }
10777 return true;
10778}
10779
10781{
10782 yarp::os::idl::WireWriter writer(connection);
10783 return write(writer);
10784}
10785
10787{
10788 yarp::os::idl::WireReader reader(connection);
10789 return read(reader);
10790}
10791
10793{
10794 if (!writer.isNull()) {
10795 if (!writer.write(return_helper)) {
10796 return false;
10797 }
10798 }
10799 return true;
10800}
10801
10803{
10804 if (reader.noMore()) {
10805 reader.fail();
10806 return false;
10807 }
10808 if (!reader.read(return_helper)) {
10809 reader.fail();
10810 return false;
10811 }
10812 return true;
10813}
10814
10819
10820// setCaptureDC1394RPC helper class implementation
10825
10827{
10828 return cmd.write(connection);
10829}
10830
10832{
10833 return reply.read(connection);
10834}
10835
10837 bON{bON}
10838{
10839}
10840
10842{
10843 yarp::os::idl::WireWriter writer(connection);
10844 if (!writer.writeListHeader(s_cmd_len)) {
10845 return false;
10846 }
10847 return write(writer);
10848}
10849
10851{
10852 yarp::os::idl::WireReader reader(connection);
10853 if (!reader.readListHeader()) {
10854 reader.fail();
10855 return false;
10856 }
10857 return read(reader);
10858}
10859
10861{
10862 if (!writeTag(writer)) {
10863 return false;
10864 }
10865 if (!writeArgs(writer)) {
10866 return false;
10867 }
10868 return true;
10869}
10870
10872{
10873 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
10874 return false;
10875 }
10876 return true;
10877}
10878
10880{
10881 if (!writer.writeBool(bON)) {
10882 return false;
10883 }
10884 return true;
10885}
10886
10888{
10889 if (!readTag(reader)) {
10890 return false;
10891 }
10892 if (!readArgs(reader)) {
10893 return false;
10894 }
10895 return true;
10896}
10897
10899{
10900 std::string tag = reader.readTag(s_tag_len);
10901 if (reader.isError()) {
10902 return false;
10903 }
10904 if (tag != s_tag) {
10905 reader.fail();
10906 return false;
10907 }
10908 return true;
10909}
10910
10912{
10913 if (reader.noMore()) {
10914 reader.fail();
10915 return false;
10916 }
10917 if (!reader.readBool(bON)) {
10918 reader.fail();
10919 return false;
10920 }
10921 if (!reader.noMore()) {
10922 reader.fail();
10923 return false;
10924 }
10925 return true;
10926}
10927
10929{
10930 yarp::os::idl::WireWriter writer(connection);
10931 return write(writer);
10932}
10933
10935{
10936 yarp::os::idl::WireReader reader(connection);
10937 return read(reader);
10938}
10939
10941{
10942 if (!writer.isNull()) {
10943 if (!writer.write(return_helper)) {
10944 return false;
10945 }
10946 }
10947 return true;
10948}
10949
10951{
10952 if (reader.noMore()) {
10953 reader.fail();
10954 return false;
10955 }
10956 if (!reader.read(return_helper)) {
10957 reader.fail();
10958 return false;
10959 }
10960 return true;
10961}
10962
10967
10968// getBytesPerPacketDC1394RPC helper class implementation
10970{
10971 return cmd.write(connection);
10972}
10973
10978
10980{
10981 yarp::os::idl::WireWriter writer(connection);
10982 if (!writer.writeListHeader(s_cmd_len)) {
10983 return false;
10984 }
10985 return write(writer);
10986}
10987
10989{
10990 yarp::os::idl::WireReader reader(connection);
10991 if (!reader.readListHeader()) {
10992 reader.fail();
10993 return false;
10994 }
10995 return read(reader);
10996}
10997
10999{
11000 if (!writeTag(writer)) {
11001 return false;
11002 }
11003 if (!writeArgs(writer)) {
11004 return false;
11005 }
11006 return true;
11007}
11008
11010{
11011 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
11012 return false;
11013 }
11014 return true;
11015}
11016
11018{
11019 return true;
11020}
11021
11023{
11024 if (!readTag(reader)) {
11025 return false;
11026 }
11027 if (!readArgs(reader)) {
11028 return false;
11029 }
11030 return true;
11031}
11032
11034{
11035 std::string tag = reader.readTag(s_tag_len);
11036 if (reader.isError()) {
11037 return false;
11038 }
11039 if (tag != s_tag) {
11040 reader.fail();
11041 return false;
11042 }
11043 return true;
11044}
11045
11047{
11048 if (!reader.noMore()) {
11049 reader.fail();
11050 return false;
11051 }
11052 return true;
11053}
11054
11056{
11057 yarp::os::idl::WireWriter writer(connection);
11058 return write(writer);
11059}
11060
11062{
11063 yarp::os::idl::WireReader reader(connection);
11064 return read(reader);
11065}
11066
11068{
11069 if (!writer.isNull()) {
11070 if (!writer.writeListHeader(s_reply_len)) {
11071 return false;
11072 }
11073 if (!writer.write(return_helper)) {
11074 return false;
11075 }
11076 }
11077 return true;
11078}
11079
11081{
11082 if (!reader.readListReturn()) {
11083 return false;
11084 }
11085 if (reader.noMore()) {
11086 reader.fail();
11087 return false;
11088 }
11089 if (!reader.read(return_helper)) {
11090 reader.fail();
11091 return false;
11092 }
11093 return true;
11094}
11095
11100
11101// setBytesPerPacketDC1394RPC helper class implementation
11106
11108{
11109 return cmd.write(connection);
11110}
11111
11116
11121
11123{
11124 yarp::os::idl::WireWriter writer(connection);
11125 if (!writer.writeListHeader(s_cmd_len)) {
11126 return false;
11127 }
11128 return write(writer);
11129}
11130
11132{
11133 yarp::os::idl::WireReader reader(connection);
11134 if (!reader.readListHeader()) {
11135 reader.fail();
11136 return false;
11137 }
11138 return read(reader);
11139}
11140
11142{
11143 if (!writeTag(writer)) {
11144 return false;
11145 }
11146 if (!writeArgs(writer)) {
11147 return false;
11148 }
11149 return true;
11150}
11151
11153{
11154 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
11155 return false;
11156 }
11157 return true;
11158}
11159
11161{
11162 if (!writer.writeI32(bpp)) {
11163 return false;
11164 }
11165 return true;
11166}
11167
11169{
11170 if (!readTag(reader)) {
11171 return false;
11172 }
11173 if (!readArgs(reader)) {
11174 return false;
11175 }
11176 return true;
11177}
11178
11180{
11181 std::string tag = reader.readTag(s_tag_len);
11182 if (reader.isError()) {
11183 return false;
11184 }
11185 if (tag != s_tag) {
11186 reader.fail();
11187 return false;
11188 }
11189 return true;
11190}
11191
11193{
11194 if (reader.noMore()) {
11195 reader.fail();
11196 return false;
11197 }
11198 if (!reader.readI32(bpp)) {
11199 reader.fail();
11200 return false;
11201 }
11202 if (!reader.noMore()) {
11203 reader.fail();
11204 return false;
11205 }
11206 return true;
11207}
11208
11210{
11211 yarp::os::idl::WireWriter writer(connection);
11212 return write(writer);
11213}
11214
11216{
11217 yarp::os::idl::WireReader reader(connection);
11218 return read(reader);
11219}
11220
11222{
11223 if (!writer.isNull()) {
11224 if (!writer.write(return_helper)) {
11225 return false;
11226 }
11227 }
11228 return true;
11229}
11230
11232{
11233 if (reader.noMore()) {
11234 reader.fail();
11235 return false;
11236 }
11237 if (!reader.read(return_helper)) {
11238 reader.fail();
11239 return false;
11240 }
11241 return true;
11242}
11243
11248
11249// Constructor
11251{
11252 yarp().setOwner(*this);
11253}
11254
11256{
11257 if (!yarp().canWrite()) {
11258 yError("Missing server method '%s'?", FrameGrabberMsgs_getHeightRPC_helper::s_prototype);
11259 }
11261 bool ok = yarp().write(helper, helper);
11262 return ok ? helper.reply.return_helper : IFrameGrabberImageOf_return_getHeight{};
11263}
11264
11266{
11267 if (!yarp().canWrite()) {
11268 yError("Missing server method '%s'?", FrameGrabberMsgs_getWidthRPC_helper::s_prototype);
11269 }
11271 bool ok = yarp().write(helper, helper);
11272 return ok ? helper.reply.return_helper : IFrameGrabberImageOf_return_getWidth{};
11273}
11274
11276{
11277 if (!yarp().canWrite()) {
11278 yError("Missing server method '%s'?", FrameGrabberMsgs_getImageRPC_helper::s_prototype);
11279 }
11281 bool ok = yarp().write(helper, helper);
11282 return ok ? helper.reply.return_helper : IFrameGrabberImageOf_return_getImage{};
11283}
11284
11286{
11287 if (!yarp().canWrite()) {
11288 yError("Missing server method '%s'?", FrameGrabberMsgs_getImageCropRPC_helper::s_prototype);
11289 }
11290 FrameGrabberMsgs_getImageCropRPC_helper helper{type, vertices};
11291 bool ok = yarp().write(helper, helper);
11292 return ok ? helper.reply.return_helper : IFrameGrabberImageOf_return_getImageCrop{};
11293}
11294
11296{
11297 if (!yarp().canWrite()) {
11298 yError("Missing server method '%s'?", FrameGrabberMsgs_getRgbWidthRPC_helper::s_prototype);
11299 }
11301 bool ok = yarp().write(helper, helper);
11302 return ok ? helper.reply.return_helper : IRGBVisualParamsMsgs_return_getRgbWidth{};
11303}
11304
11306{
11307 if (!yarp().canWrite()) {
11308 yError("Missing server method '%s'?", FrameGrabberMsgs_getRgbHeightRPC_helper::s_prototype);
11309 }
11311 bool ok = yarp().write(helper, helper);
11312 return ok ? helper.reply.return_helper : IRGBVisualParamsMsgs_return_getRgbHeight{};
11313}
11314
11316{
11317 if (!yarp().canWrite()) {
11319 }
11321 bool ok = yarp().write(helper, helper);
11322 return ok ? helper.reply.return_helper : IRGBVisualParamsMsgs_return_getRgbSupportedCfg{};
11323}
11324
11326{
11327 if (!yarp().canWrite()) {
11329 }
11331 bool ok = yarp().write(helper, helper);
11332 return ok ? helper.reply.return_helper : IRGBVisualParamsMsgs_return_getRgbResolution{};
11333}
11334
11335yarp::dev::ReturnValue FrameGrabberMsgs::setRgbResolutionRPC(const std::int32_t width, const std::int32_t height)
11336{
11337 if (!yarp().canWrite()) {
11339 }
11340 FrameGrabberMsgs_setRgbResolutionRPC_helper helper{width, height};
11341 bool ok = yarp().write(helper, helper);
11342 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11343}
11344
11346{
11347 if (!yarp().canWrite()) {
11348 yError("Missing server method '%s'?", FrameGrabberMsgs_getRgbFOVRPC_helper::s_prototype);
11349 }
11351 bool ok = yarp().write(helper, helper);
11352 return ok ? helper.reply.return_helper : IRGBVisualParamsMsgs_return_getRgbFOV{};
11353}
11354
11355yarp::dev::ReturnValue FrameGrabberMsgs::setRgbFOVRPC(const double horizontalFov, const double verticalFov)
11356{
11357 if (!yarp().canWrite()) {
11358 yError("Missing server method '%s'?", FrameGrabberMsgs_setRgbFOVRPC_helper::s_prototype);
11359 }
11360 FrameGrabberMsgs_setRgbFOVRPC_helper helper{horizontalFov, verticalFov};
11361 bool ok = yarp().write(helper, helper);
11362 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11363}
11364
11366{
11367 if (!yarp().canWrite()) {
11369 }
11371 bool ok = yarp().write(helper, helper);
11372 return ok ? helper.reply.return_helper : IRGBVisualParamsMsgs_return_getRgbIntrinsicParam{};
11373}
11374
11376{
11377 if (!yarp().canWrite()) {
11379 }
11381 bool ok = yarp().write(helper, helper);
11382 return ok ? helper.reply.return_helper : IRGBVisualParamsMsgs_return_getRgbMirroring{};
11383}
11384
11386{
11387 if (!yarp().canWrite()) {
11389 }
11391 bool ok = yarp().write(helper, helper);
11392 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11393}
11394
11396{
11397 if (!yarp().canWrite()) {
11399 }
11401 bool ok = yarp().write(helper, helper);
11402 return ok ? helper.reply.return_helper : IFrameGrabberControlMsgs_return_getCameraDescription{};
11403}
11404
11406{
11407 if (!yarp().canWrite()) {
11408 yError("Missing server method '%s'?", FrameGrabberMsgs_hasFeatureRPC_helper::s_prototype);
11409 }
11411 bool ok = yarp().write(helper, helper);
11412 return ok ? helper.reply.return_helper : IFrameGrabberControlMsgs_return_hasFeature{};
11413}
11414
11416{
11417 if (!yarp().canWrite()) {
11418 yError("Missing server method '%s'?", FrameGrabberMsgs_setFeature1RPC_helper::s_prototype);
11419 }
11421 bool ok = yarp().write(helper, helper);
11422 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11423}
11424
11426{
11427 if (!yarp().canWrite()) {
11428 yError("Missing server method '%s'?", FrameGrabberMsgs_getFeature1RPC_helper::s_prototype);
11429 }
11431 bool ok = yarp().write(helper, helper);
11432 return ok ? helper.reply.return_helper : IFrameGrabberControlMsgs_return_getFeature1{};
11433}
11434
11435yarp::dev::ReturnValue FrameGrabberMsgs::setFeature2RPC(const std::int32_t feature, const double value1, const double value2)
11436{
11437 if (!yarp().canWrite()) {
11438 yError("Missing server method '%s'?", FrameGrabberMsgs_setFeature2RPC_helper::s_prototype);
11439 }
11440 FrameGrabberMsgs_setFeature2RPC_helper helper{feature, value1, value2};
11441 bool ok = yarp().write(helper, helper);
11442 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11443}
11444
11446{
11447 if (!yarp().canWrite()) {
11448 yError("Missing server method '%s'?", FrameGrabberMsgs_getFeature2RPC_helper::s_prototype);
11449 }
11451 bool ok = yarp().write(helper, helper);
11452 return ok ? helper.reply.return_helper : IFrameGrabberControlMsgs_return_getFeature2{};
11453}
11454
11456{
11457 if (!yarp().canWrite()) {
11458 yError("Missing server method '%s'?", FrameGrabberMsgs_hasOnOffRPC_helper::s_prototype);
11459 }
11461 bool ok = yarp().write(helper, helper);
11462 return ok ? helper.reply.return_helper : IFrameGrabberControlMsgs_return_hasOnOff{};
11463}
11464
11466{
11467 if (!yarp().canWrite()) {
11468 yError("Missing server method '%s'?", FrameGrabberMsgs_setActiveRPC_helper::s_prototype);
11469 }
11471 bool ok = yarp().write(helper, helper);
11472 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11473}
11474
11476{
11477 if (!yarp().canWrite()) {
11478 yError("Missing server method '%s'?", FrameGrabberMsgs_getActiveRPC_helper::s_prototype);
11479 }
11481 bool ok = yarp().write(helper, helper);
11482 return ok ? helper.reply.return_helper : IFrameGrabberControlMsgs_return_getActive{};
11483}
11484
11486{
11487 if (!yarp().canWrite()) {
11488 yError("Missing server method '%s'?", FrameGrabberMsgs_hasAutoRPC_helper::s_prototype);
11489 }
11491 bool ok = yarp().write(helper, helper);
11492 return ok ? helper.reply.return_helper : IFrameGrabberControlMsgs_return_hasAuto{};
11493}
11494
11496{
11497 if (!yarp().canWrite()) {
11498 yError("Missing server method '%s'?", FrameGrabberMsgs_hasManualRPC_helper::s_prototype);
11499 }
11501 bool ok = yarp().write(helper, helper);
11502 return ok ? helper.reply.return_helper : IFrameGrabberControlMsgs_return_hasManual{};
11503}
11504
11506{
11507 if (!yarp().canWrite()) {
11508 yError("Missing server method '%s'?", FrameGrabberMsgs_hasOnePushRPC_helper::s_prototype);
11509 }
11511 bool ok = yarp().write(helper, helper);
11512 return ok ? helper.reply.return_helper : IFrameGrabberControlMsgs_return_hasOnePush{};
11513}
11514
11516{
11517 if (!yarp().canWrite()) {
11518 yError("Missing server method '%s'?", FrameGrabberMsgs_setModeRPC_helper::s_prototype);
11519 }
11521 bool ok = yarp().write(helper, helper);
11522 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11523}
11524
11526{
11527 if (!yarp().canWrite()) {
11528 yError("Missing server method '%s'?", FrameGrabberMsgs_getModeRPC_helper::s_prototype);
11529 }
11531 bool ok = yarp().write(helper, helper);
11532 return ok ? helper.reply.return_helper : IFrameGrabberControlMsgs_return_getMode{};
11533}
11534
11536{
11537 if (!yarp().canWrite()) {
11538 yError("Missing server method '%s'?", FrameGrabberMsgs_setOnePushRPC_helper::s_prototype);
11539 }
11541 bool ok = yarp().write(helper, helper);
11542 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11543}
11544
11546{
11547 if (!yarp().canWrite()) {
11549 }
11551 bool ok = yarp().write(helper, helper);
11552 return ok ? helper.reply.return_helper : IFrameGrabberControlDC1394Msgs_return_getVideoModeMaskDC1394{};
11553}
11554
11556{
11557 if (!yarp().canWrite()) {
11559 }
11561 bool ok = yarp().write(helper, helper);
11562 return ok ? helper.reply.return_helper : IFrameGrabberControlDC1394Msgs_return_getVideoModeDC1394{};
11563}
11564
11566{
11567 if (!yarp().canWrite()) {
11569 }
11571 bool ok = yarp().write(helper, helper);
11572 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11573}
11574
11576{
11577 if (!yarp().canWrite()) {
11579 }
11581 bool ok = yarp().write(helper, helper);
11582 return ok ? helper.reply.return_helper : IFrameGrabberControlDC1394Msgs_return_getFPSMaskDC1394{};
11583}
11584
11586{
11587 if (!yarp().canWrite()) {
11588 yError("Missing server method '%s'?", FrameGrabberMsgs_getFPSDC1394RPC_helper::s_prototype);
11589 }
11591 bool ok = yarp().write(helper, helper);
11592 return ok ? helper.reply.return_helper : IFrameGrabberControlDC1394Msgs_return_getFPSDC1394{};
11593}
11594
11596{
11597 if (!yarp().canWrite()) {
11598 yError("Missing server method '%s'?", FrameGrabberMsgs_setFPSDC1394RPC_helper::s_prototype);
11599 }
11601 bool ok = yarp().write(helper, helper);
11602 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11603}
11604
11606{
11607 if (!yarp().canWrite()) {
11609 }
11611 bool ok = yarp().write(helper, helper);
11612 return ok ? helper.reply.return_helper : IFrameGrabberControlDC1394Msgs_return_getISOSpeedDC1394{};
11613}
11614
11616{
11617 if (!yarp().canWrite()) {
11619 }
11621 bool ok = yarp().write(helper, helper);
11622 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11623}
11624
11626{
11627 if (!yarp().canWrite()) {
11629 }
11631 bool ok = yarp().write(helper, helper);
11632 return ok ? helper.reply.return_helper : IFrameGrabberControlDC1394Msgs_return_getColorCodingMaskDC1394{};
11633}
11634
11636{
11637 if (!yarp().canWrite()) {
11639 }
11641 bool ok = yarp().write(helper, helper);
11642 return ok ? helper.reply.return_helper : IFrameGrabberControlDC1394Msgs_return_getColorCodingDC1394{};
11643}
11644
11646{
11647 if (!yarp().canWrite()) {
11649 }
11651 bool ok = yarp().write(helper, helper);
11652 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11653}
11654
11656{
11657 if (!yarp().canWrite()) {
11659 }
11661 bool ok = yarp().write(helper, helper);
11662 return ok ? helper.reply.return_helper : IFrameGrabberControlDC1394Msgs_return_getFormat7MaxWindowDC1394{};
11663}
11664
11666{
11667 if (!yarp().canWrite()) {
11669 }
11671 bool ok = yarp().write(helper, helper);
11672 return ok ? helper.reply.return_helper : IFrameGrabberControlDC1394Msgs_return_getFormat7WindowDC1394{};
11673}
11674
11675yarp::dev::ReturnValue FrameGrabberMsgs::setFormat7WindowDC1394RPC(const std::int32_t xdim, const std::int32_t ydim, const std::int32_t x0, const std::int32_t y0)
11676{
11677 if (!yarp().canWrite()) {
11679 }
11680 FrameGrabberMsgs_setFormat7WindowDC1394RPC_helper helper{xdim, ydim, x0, y0};
11681 bool ok = yarp().write(helper, helper);
11682 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11683}
11684
11686{
11687 if (!yarp().canWrite()) {
11689 }
11691 bool ok = yarp().write(helper, helper);
11692 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11693}
11694
11696{
11697 if (!yarp().canWrite()) {
11699 }
11701 bool ok = yarp().write(helper, helper);
11702 return ok ? helper.reply.return_helper : IFrameGrabberControlDC1394Msgs_return_getOperationModeDC1394{};
11703}
11704
11706{
11707 if (!yarp().canWrite()) {
11709 }
11711 bool ok = yarp().write(helper, helper);
11712 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11713}
11714
11716{
11717 if (!yarp().canWrite()) {
11719 }
11721 bool ok = yarp().write(helper, helper);
11722 return ok ? helper.reply.return_helper : IFrameGrabberControlDC1394Msgs_return_getTransmissionDC1394{};
11723}
11724
11726{
11727 if (!yarp().canWrite()) {
11729 }
11731 bool ok = yarp().write(helper, helper);
11732 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11733}
11734
11736{
11737 if (!yarp().canWrite()) {
11739 }
11741 bool ok = yarp().write(helper, helper);
11742 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11743}
11744
11746{
11747 if (!yarp().canWrite()) {
11748 yError("Missing server method '%s'?", FrameGrabberMsgs_setResetDC1394RPC_helper::s_prototype);
11749 }
11751 bool ok = yarp().write(helper, helper);
11752 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11753}
11754
11756{
11757 if (!yarp().canWrite()) {
11758 yError("Missing server method '%s'?", FrameGrabberMsgs_setPowerDC1394RPC_helper::s_prototype);
11759 }
11761 bool ok = yarp().write(helper, helper);
11762 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11763}
11764
11766{
11767 if (!yarp().canWrite()) {
11769 }
11771 bool ok = yarp().write(helper, helper);
11772 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11773}
11774
11776{
11777 if (!yarp().canWrite()) {
11779 }
11781 bool ok = yarp().write(helper, helper);
11782 return ok ? helper.reply.return_helper : IFrameGrabberControlDC1394Msgs_return_getBytesPerPacketDC1394{};
11783}
11784
11786{
11787 if (!yarp().canWrite()) {
11789 }
11791 bool ok = yarp().write(helper, helper);
11792 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11793}
11794
11795// help method
11796std::vector<std::string> FrameGrabberMsgs::help(const std::string& functionName)
11797{
11798 bool showAll = (functionName == "--all");
11799 std::vector<std::string> helpString;
11800 if (showAll) {
11801 helpString.emplace_back("*** Available commands:");
11802 helpString.emplace_back(FrameGrabberMsgs_getHeightRPC_helper::s_tag);
11803 helpString.emplace_back(FrameGrabberMsgs_getWidthRPC_helper::s_tag);
11804 helpString.emplace_back(FrameGrabberMsgs_getImageRPC_helper::s_tag);
11805 helpString.emplace_back(FrameGrabberMsgs_getImageCropRPC_helper::s_tag);
11806 helpString.emplace_back(FrameGrabberMsgs_getRgbWidthRPC_helper::s_tag);
11807 helpString.emplace_back(FrameGrabberMsgs_getRgbHeightRPC_helper::s_tag);
11811 helpString.emplace_back(FrameGrabberMsgs_getRgbFOVRPC_helper::s_tag);
11812 helpString.emplace_back(FrameGrabberMsgs_setRgbFOVRPC_helper::s_tag);
11817 helpString.emplace_back(FrameGrabberMsgs_hasFeatureRPC_helper::s_tag);
11818 helpString.emplace_back(FrameGrabberMsgs_setFeature1RPC_helper::s_tag);
11819 helpString.emplace_back(FrameGrabberMsgs_getFeature1RPC_helper::s_tag);
11820 helpString.emplace_back(FrameGrabberMsgs_setFeature2RPC_helper::s_tag);
11821 helpString.emplace_back(FrameGrabberMsgs_getFeature2RPC_helper::s_tag);
11822 helpString.emplace_back(FrameGrabberMsgs_hasOnOffRPC_helper::s_tag);
11823 helpString.emplace_back(FrameGrabberMsgs_setActiveRPC_helper::s_tag);
11824 helpString.emplace_back(FrameGrabberMsgs_getActiveRPC_helper::s_tag);
11825 helpString.emplace_back(FrameGrabberMsgs_hasAutoRPC_helper::s_tag);
11826 helpString.emplace_back(FrameGrabberMsgs_hasManualRPC_helper::s_tag);
11827 helpString.emplace_back(FrameGrabberMsgs_hasOnePushRPC_helper::s_tag);
11828 helpString.emplace_back(FrameGrabberMsgs_setModeRPC_helper::s_tag);
11829 helpString.emplace_back(FrameGrabberMsgs_getModeRPC_helper::s_tag);
11830 helpString.emplace_back(FrameGrabberMsgs_setOnePushRPC_helper::s_tag);
11835 helpString.emplace_back(FrameGrabberMsgs_getFPSDC1394RPC_helper::s_tag);
11836 helpString.emplace_back(FrameGrabberMsgs_setFPSDC1394RPC_helper::s_tag);
11851 helpString.emplace_back(FrameGrabberMsgs_setResetDC1394RPC_helper::s_tag);
11852 helpString.emplace_back(FrameGrabberMsgs_setPowerDC1394RPC_helper::s_tag);
11856 helpString.emplace_back("help");
11857 } else {
11858 if (functionName == FrameGrabberMsgs_getHeightRPC_helper::s_tag) {
11860 }
11861 if (functionName == FrameGrabberMsgs_getWidthRPC_helper::s_tag) {
11862 helpString.emplace_back(FrameGrabberMsgs_getWidthRPC_helper::s_prototype);
11863 }
11864 if (functionName == FrameGrabberMsgs_getImageRPC_helper::s_tag) {
11865 helpString.emplace_back(FrameGrabberMsgs_getImageRPC_helper::s_prototype);
11866 }
11869 }
11872 }
11875 }
11878 }
11881 }
11884 }
11885 if (functionName == FrameGrabberMsgs_getRgbFOVRPC_helper::s_tag) {
11887 }
11888 if (functionName == FrameGrabberMsgs_setRgbFOVRPC_helper::s_tag) {
11890 }
11893 }
11896 }
11899 }
11902 }
11905 }
11908 }
11911 }
11914 }
11917 }
11918 if (functionName == FrameGrabberMsgs_hasOnOffRPC_helper::s_tag) {
11919 helpString.emplace_back(FrameGrabberMsgs_hasOnOffRPC_helper::s_prototype);
11920 }
11921 if (functionName == FrameGrabberMsgs_setActiveRPC_helper::s_tag) {
11923 }
11924 if (functionName == FrameGrabberMsgs_getActiveRPC_helper::s_tag) {
11926 }
11927 if (functionName == FrameGrabberMsgs_hasAutoRPC_helper::s_tag) {
11928 helpString.emplace_back(FrameGrabberMsgs_hasAutoRPC_helper::s_prototype);
11929 }
11930 if (functionName == FrameGrabberMsgs_hasManualRPC_helper::s_tag) {
11932 }
11935 }
11936 if (functionName == FrameGrabberMsgs_setModeRPC_helper::s_tag) {
11937 helpString.emplace_back(FrameGrabberMsgs_setModeRPC_helper::s_prototype);
11938 }
11939 if (functionName == FrameGrabberMsgs_getModeRPC_helper::s_tag) {
11940 helpString.emplace_back(FrameGrabberMsgs_getModeRPC_helper::s_prototype);
11941 }
11944 }
11947 }
11950 }
11953 }
11956 }
11959 }
11962 }
11965 }
11968 }
11971 }
11974 }
11977 }
11980 }
11983 }
11986 }
11989 }
11992 }
11995 }
11998 }
12001 }
12004 }
12007 }
12010 }
12013 }
12016 }
12019 }
12020 if (functionName == "help") {
12021 helpString.emplace_back("std::vector<std::string> help(const std::string& functionName = \"--all\")");
12022 helpString.emplace_back("Return list of available commands, or help message for a specific function");
12023 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");
12024 helpString.emplace_back("@return list of strings (one string per line)");
12025 }
12026 }
12027 if (helpString.empty()) {
12028 helpString.emplace_back("Command not found");
12029 }
12030 return helpString;
12031}
12032
12033// read from ConnectionReader
12035{
12036 constexpr size_t max_tag_len = 1;
12037 size_t tag_len = 1;
12038
12039 yarp::os::idl::WireReader reader(connection);
12040 reader.expectAccept();
12041 if (!reader.readListHeader()) {
12042 reader.fail();
12043 return false;
12044 }
12045
12046 std::string tag = reader.readTag(1);
12047 bool direct = (tag == "__direct__");
12048 if (direct) {
12049 tag = reader.readTag(1);
12050 }
12051 while (tag_len <= max_tag_len && !reader.isError()) {
12052 if(tag == "getRemoteProtocolVersion") {
12053 if (!reader.noMore()) {
12054 yError("Reader invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
12055 reader.fail();
12056 return false;
12057 }
12058
12059 auto proto = getLocalProtocolVersion();
12060
12061 yarp::os::idl::WireWriter writer(reader);
12062 if (!writer.writeListHeader(1)) {
12063 yWarning("Writer invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
12064 return false;}
12065 if (!writer.write(proto)) {
12066 yWarning("Writer invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
12067 return false;
12068 }
12069 reader.accept();
12070 return true;
12071 }
12074 if (!helper.cmd.readArgs(reader)) {
12075 return false;
12076 }
12077
12078 helper.call(this);
12079
12080 yarp::os::idl::WireWriter writer(reader);
12081 if (!helper.reply.write(writer)) {
12082 return false;
12083 }
12084 reader.accept();
12085 return true;
12086 }
12089 if (!helper.cmd.readArgs(reader)) {
12090 return false;
12091 }
12092
12093 helper.call(this);
12094
12095 yarp::os::idl::WireWriter writer(reader);
12096 if (!helper.reply.write(writer)) {
12097 return false;
12098 }
12099 reader.accept();
12100 return true;
12101 }
12104 if (!helper.cmd.readArgs(reader)) {
12105 return false;
12106 }
12107
12108 helper.call(this);
12109
12110 yarp::os::idl::WireWriter writer(reader);
12111 if (!helper.reply.write(writer)) {
12112 return false;
12113 }
12114 reader.accept();
12115 return true;
12116 }
12119 if (!helper.cmd.readArgs(reader)) {
12120 return false;
12121 }
12122
12123 helper.call(this);
12124
12125 yarp::os::idl::WireWriter writer(reader);
12126 if (!helper.reply.write(writer)) {
12127 return false;
12128 }
12129 reader.accept();
12130 return true;
12131 }
12134 if (!helper.cmd.readArgs(reader)) {
12135 return false;
12136 }
12137
12138 helper.call(this);
12139
12140 yarp::os::idl::WireWriter writer(reader);
12141 if (!helper.reply.write(writer)) {
12142 return false;
12143 }
12144 reader.accept();
12145 return true;
12146 }
12149 if (!helper.cmd.readArgs(reader)) {
12150 return false;
12151 }
12152
12153 helper.call(this);
12154
12155 yarp::os::idl::WireWriter writer(reader);
12156 if (!helper.reply.write(writer)) {
12157 return false;
12158 }
12159 reader.accept();
12160 return true;
12161 }
12164 if (!helper.cmd.readArgs(reader)) {
12165 return false;
12166 }
12167
12168 helper.call(this);
12169
12170 yarp::os::idl::WireWriter writer(reader);
12171 if (!helper.reply.write(writer)) {
12172 return false;
12173 }
12174 reader.accept();
12175 return true;
12176 }
12179 if (!helper.cmd.readArgs(reader)) {
12180 return false;
12181 }
12182
12183 helper.call(this);
12184
12185 yarp::os::idl::WireWriter writer(reader);
12186 if (!helper.reply.write(writer)) {
12187 return false;
12188 }
12189 reader.accept();
12190 return true;
12191 }
12194 if (!helper.cmd.readArgs(reader)) {
12195 return false;
12196 }
12197
12198 helper.call(this);
12199
12200 yarp::os::idl::WireWriter writer(reader);
12201 if (!helper.reply.write(writer)) {
12202 return false;
12203 }
12204 reader.accept();
12205 return true;
12206 }
12209 if (!helper.cmd.readArgs(reader)) {
12210 return false;
12211 }
12212
12213 helper.call(this);
12214
12215 yarp::os::idl::WireWriter writer(reader);
12216 if (!helper.reply.write(writer)) {
12217 return false;
12218 }
12219 reader.accept();
12220 return true;
12221 }
12224 if (!helper.cmd.readArgs(reader)) {
12225 return false;
12226 }
12227
12228 helper.call(this);
12229
12230 yarp::os::idl::WireWriter writer(reader);
12231 if (!helper.reply.write(writer)) {
12232 return false;
12233 }
12234 reader.accept();
12235 return true;
12236 }
12239 if (!helper.cmd.readArgs(reader)) {
12240 return false;
12241 }
12242
12243 helper.call(this);
12244
12245 yarp::os::idl::WireWriter writer(reader);
12246 if (!helper.reply.write(writer)) {
12247 return false;
12248 }
12249 reader.accept();
12250 return true;
12251 }
12254 if (!helper.cmd.readArgs(reader)) {
12255 return false;
12256 }
12257
12258 helper.call(this);
12259
12260 yarp::os::idl::WireWriter writer(reader);
12261 if (!helper.reply.write(writer)) {
12262 return false;
12263 }
12264 reader.accept();
12265 return true;
12266 }
12269 if (!helper.cmd.readArgs(reader)) {
12270 return false;
12271 }
12272
12273 helper.call(this);
12274
12275 yarp::os::idl::WireWriter writer(reader);
12276 if (!helper.reply.write(writer)) {
12277 return false;
12278 }
12279 reader.accept();
12280 return true;
12281 }
12284 if (!helper.cmd.readArgs(reader)) {
12285 return false;
12286 }
12287
12288 helper.call(this);
12289
12290 yarp::os::idl::WireWriter writer(reader);
12291 if (!helper.reply.write(writer)) {
12292 return false;
12293 }
12294 reader.accept();
12295 return true;
12296 }
12299 if (!helper.cmd.readArgs(reader)) {
12300 return false;
12301 }
12302
12303 helper.call(this);
12304
12305 yarp::os::idl::WireWriter writer(reader);
12306 if (!helper.reply.write(writer)) {
12307 return false;
12308 }
12309 reader.accept();
12310 return true;
12311 }
12314 if (!helper.cmd.readArgs(reader)) {
12315 return false;
12316 }
12317
12318 helper.call(this);
12319
12320 yarp::os::idl::WireWriter writer(reader);
12321 if (!helper.reply.write(writer)) {
12322 return false;
12323 }
12324 reader.accept();
12325 return true;
12326 }
12329 if (!helper.cmd.readArgs(reader)) {
12330 return false;
12331 }
12332
12333 helper.call(this);
12334
12335 yarp::os::idl::WireWriter writer(reader);
12336 if (!helper.reply.write(writer)) {
12337 return false;
12338 }
12339 reader.accept();
12340 return true;
12341 }
12344 if (!helper.cmd.readArgs(reader)) {
12345 return false;
12346 }
12347
12348 helper.call(this);
12349
12350 yarp::os::idl::WireWriter writer(reader);
12351 if (!helper.reply.write(writer)) {
12352 return false;
12353 }
12354 reader.accept();
12355 return true;
12356 }
12359 if (!helper.cmd.readArgs(reader)) {
12360 return false;
12361 }
12362
12363 helper.call(this);
12364
12365 yarp::os::idl::WireWriter writer(reader);
12366 if (!helper.reply.write(writer)) {
12367 return false;
12368 }
12369 reader.accept();
12370 return true;
12371 }
12374 if (!helper.cmd.readArgs(reader)) {
12375 return false;
12376 }
12377
12378 helper.call(this);
12379
12380 yarp::os::idl::WireWriter writer(reader);
12381 if (!helper.reply.write(writer)) {
12382 return false;
12383 }
12384 reader.accept();
12385 return true;
12386 }
12389 if (!helper.cmd.readArgs(reader)) {
12390 return false;
12391 }
12392
12393 helper.call(this);
12394
12395 yarp::os::idl::WireWriter writer(reader);
12396 if (!helper.reply.write(writer)) {
12397 return false;
12398 }
12399 reader.accept();
12400 return true;
12401 }
12404 if (!helper.cmd.readArgs(reader)) {
12405 return false;
12406 }
12407
12408 helper.call(this);
12409
12410 yarp::os::idl::WireWriter writer(reader);
12411 if (!helper.reply.write(writer)) {
12412 return false;
12413 }
12414 reader.accept();
12415 return true;
12416 }
12419 if (!helper.cmd.readArgs(reader)) {
12420 return false;
12421 }
12422
12423 helper.call(this);
12424
12425 yarp::os::idl::WireWriter writer(reader);
12426 if (!helper.reply.write(writer)) {
12427 return false;
12428 }
12429 reader.accept();
12430 return true;
12431 }
12434 if (!helper.cmd.readArgs(reader)) {
12435 return false;
12436 }
12437
12438 helper.call(this);
12439
12440 yarp::os::idl::WireWriter writer(reader);
12441 if (!helper.reply.write(writer)) {
12442 return false;
12443 }
12444 reader.accept();
12445 return true;
12446 }
12449 if (!helper.cmd.readArgs(reader)) {
12450 return false;
12451 }
12452
12453 helper.call(this);
12454
12455 yarp::os::idl::WireWriter writer(reader);
12456 if (!helper.reply.write(writer)) {
12457 return false;
12458 }
12459 reader.accept();
12460 return true;
12461 }
12464 if (!helper.cmd.readArgs(reader)) {
12465 return false;
12466 }
12467
12468 helper.call(this);
12469
12470 yarp::os::idl::WireWriter writer(reader);
12471 if (!helper.reply.write(writer)) {
12472 return false;
12473 }
12474 reader.accept();
12475 return true;
12476 }
12479 if (!helper.cmd.readArgs(reader)) {
12480 return false;
12481 }
12482
12483 helper.call(this);
12484
12485 yarp::os::idl::WireWriter writer(reader);
12486 if (!helper.reply.write(writer)) {
12487 return false;
12488 }
12489 reader.accept();
12490 return true;
12491 }
12494 if (!helper.cmd.readArgs(reader)) {
12495 return false;
12496 }
12497
12498 helper.call(this);
12499
12500 yarp::os::idl::WireWriter writer(reader);
12501 if (!helper.reply.write(writer)) {
12502 return false;
12503 }
12504 reader.accept();
12505 return true;
12506 }
12509 if (!helper.cmd.readArgs(reader)) {
12510 return false;
12511 }
12512
12513 helper.call(this);
12514
12515 yarp::os::idl::WireWriter writer(reader);
12516 if (!helper.reply.write(writer)) {
12517 return false;
12518 }
12519 reader.accept();
12520 return true;
12521 }
12524 if (!helper.cmd.readArgs(reader)) {
12525 return false;
12526 }
12527
12528 helper.call(this);
12529
12530 yarp::os::idl::WireWriter writer(reader);
12531 if (!helper.reply.write(writer)) {
12532 return false;
12533 }
12534 reader.accept();
12535 return true;
12536 }
12539 if (!helper.cmd.readArgs(reader)) {
12540 return false;
12541 }
12542
12543 helper.call(this);
12544
12545 yarp::os::idl::WireWriter writer(reader);
12546 if (!helper.reply.write(writer)) {
12547 return false;
12548 }
12549 reader.accept();
12550 return true;
12551 }
12554 if (!helper.cmd.readArgs(reader)) {
12555 return false;
12556 }
12557
12558 helper.call(this);
12559
12560 yarp::os::idl::WireWriter writer(reader);
12561 if (!helper.reply.write(writer)) {
12562 return false;
12563 }
12564 reader.accept();
12565 return true;
12566 }
12569 if (!helper.cmd.readArgs(reader)) {
12570 return false;
12571 }
12572
12573 helper.call(this);
12574
12575 yarp::os::idl::WireWriter writer(reader);
12576 if (!helper.reply.write(writer)) {
12577 return false;
12578 }
12579 reader.accept();
12580 return true;
12581 }
12584 if (!helper.cmd.readArgs(reader)) {
12585 return false;
12586 }
12587
12588 helper.call(this);
12589
12590 yarp::os::idl::WireWriter writer(reader);
12591 if (!helper.reply.write(writer)) {
12592 return false;
12593 }
12594 reader.accept();
12595 return true;
12596 }
12599 if (!helper.cmd.readArgs(reader)) {
12600 return false;
12601 }
12602
12603 helper.call(this);
12604
12605 yarp::os::idl::WireWriter writer(reader);
12606 if (!helper.reply.write(writer)) {
12607 return false;
12608 }
12609 reader.accept();
12610 return true;
12611 }
12614 if (!helper.cmd.readArgs(reader)) {
12615 return false;
12616 }
12617
12618 helper.call(this);
12619
12620 yarp::os::idl::WireWriter writer(reader);
12621 if (!helper.reply.write(writer)) {
12622 return false;
12623 }
12624 reader.accept();
12625 return true;
12626 }
12629 if (!helper.cmd.readArgs(reader)) {
12630 return false;
12631 }
12632
12633 helper.call(this);
12634
12635 yarp::os::idl::WireWriter writer(reader);
12636 if (!helper.reply.write(writer)) {
12637 return false;
12638 }
12639 reader.accept();
12640 return true;
12641 }
12644 if (!helper.cmd.readArgs(reader)) {
12645 return false;
12646 }
12647
12648 helper.call(this);
12649
12650 yarp::os::idl::WireWriter writer(reader);
12651 if (!helper.reply.write(writer)) {
12652 return false;
12653 }
12654 reader.accept();
12655 return true;
12656 }
12659 if (!helper.cmd.readArgs(reader)) {
12660 return false;
12661 }
12662
12663 helper.call(this);
12664
12665 yarp::os::idl::WireWriter writer(reader);
12666 if (!helper.reply.write(writer)) {
12667 return false;
12668 }
12669 reader.accept();
12670 return true;
12671 }
12674 if (!helper.cmd.readArgs(reader)) {
12675 return false;
12676 }
12677
12678 helper.call(this);
12679
12680 yarp::os::idl::WireWriter writer(reader);
12681 if (!helper.reply.write(writer)) {
12682 return false;
12683 }
12684 reader.accept();
12685 return true;
12686 }
12689 if (!helper.cmd.readArgs(reader)) {
12690 return false;
12691 }
12692
12693 helper.call(this);
12694
12695 yarp::os::idl::WireWriter writer(reader);
12696 if (!helper.reply.write(writer)) {
12697 return false;
12698 }
12699 reader.accept();
12700 return true;
12701 }
12704 if (!helper.cmd.readArgs(reader)) {
12705 return false;
12706 }
12707
12708 helper.call(this);
12709
12710 yarp::os::idl::WireWriter writer(reader);
12711 if (!helper.reply.write(writer)) {
12712 return false;
12713 }
12714 reader.accept();
12715 return true;
12716 }
12719 if (!helper.cmd.readArgs(reader)) {
12720 return false;
12721 }
12722
12723 helper.call(this);
12724
12725 yarp::os::idl::WireWriter writer(reader);
12726 if (!helper.reply.write(writer)) {
12727 return false;
12728 }
12729 reader.accept();
12730 return true;
12731 }
12734 if (!helper.cmd.readArgs(reader)) {
12735 return false;
12736 }
12737
12738 helper.call(this);
12739
12740 yarp::os::idl::WireWriter writer(reader);
12741 if (!helper.reply.write(writer)) {
12742 return false;
12743 }
12744 reader.accept();
12745 return true;
12746 }
12749 if (!helper.cmd.readArgs(reader)) {
12750 return false;
12751 }
12752
12753 helper.call(this);
12754
12755 yarp::os::idl::WireWriter writer(reader);
12756 if (!helper.reply.write(writer)) {
12757 return false;
12758 }
12759 reader.accept();
12760 return true;
12761 }
12764 if (!helper.cmd.readArgs(reader)) {
12765 return false;
12766 }
12767
12768 helper.call(this);
12769
12770 yarp::os::idl::WireWriter writer(reader);
12771 if (!helper.reply.write(writer)) {
12772 return false;
12773 }
12774 reader.accept();
12775 return true;
12776 }
12779 if (!helper.cmd.readArgs(reader)) {
12780 return false;
12781 }
12782
12783 helper.call(this);
12784
12785 yarp::os::idl::WireWriter writer(reader);
12786 if (!helper.reply.write(writer)) {
12787 return false;
12788 }
12789 reader.accept();
12790 return true;
12791 }
12794 if (!helper.cmd.readArgs(reader)) {
12795 return false;
12796 }
12797
12798 helper.call(this);
12799
12800 yarp::os::idl::WireWriter writer(reader);
12801 if (!helper.reply.write(writer)) {
12802 return false;
12803 }
12804 reader.accept();
12805 return true;
12806 }
12809 if (!helper.cmd.readArgs(reader)) {
12810 return false;
12811 }
12812
12813 helper.call(this);
12814
12815 yarp::os::idl::WireWriter writer(reader);
12816 if (!helper.reply.write(writer)) {
12817 return false;
12818 }
12819 reader.accept();
12820 return true;
12821 }
12824 if (!helper.cmd.readArgs(reader)) {
12825 return false;
12826 }
12827
12828 helper.call(this);
12829
12830 yarp::os::idl::WireWriter writer(reader);
12831 if (!helper.reply.write(writer)) {
12832 return false;
12833 }
12834 reader.accept();
12835 return true;
12836 }
12839 if (!helper.cmd.readArgs(reader)) {
12840 return false;
12841 }
12842
12843 helper.call(this);
12844
12845 yarp::os::idl::WireWriter writer(reader);
12846 if (!helper.reply.write(writer)) {
12847 return false;
12848 }
12849 reader.accept();
12850 return true;
12851 }
12854 if (!helper.cmd.readArgs(reader)) {
12855 return false;
12856 }
12857
12858 helper.call(this);
12859
12860 yarp::os::idl::WireWriter writer(reader);
12861 if (!helper.reply.write(writer)) {
12862 return false;
12863 }
12864 reader.accept();
12865 return true;
12866 }
12869 if (!helper.cmd.readArgs(reader)) {
12870 return false;
12871 }
12872
12873 helper.call(this);
12874
12875 yarp::os::idl::WireWriter writer(reader);
12876 if (!helper.reply.write(writer)) {
12877 return false;
12878 }
12879 reader.accept();
12880 return true;
12881 }
12882 if (tag == "help") {
12883 std::string functionName;
12884 if (!reader.readString(functionName)) {
12885 functionName = "--all";
12886 }
12887 auto help_strings = help(functionName);
12888 yarp::os::idl::WireWriter writer(reader);
12889 if (!writer.isNull()) {
12890 if (!writer.writeListHeader(2)) {
12891 return false;
12892 }
12893 if (!writer.writeTag("many", 1, 0)) {
12894 return false;
12895 }
12896 if (!writer.writeListBegin(0, help_strings.size())) {
12897 return false;
12898 }
12899 for (const auto& help_string : help_strings) {
12900 if (!writer.writeString(help_string)) {
12901 return false;
12902 }
12903 }
12904 if (!writer.writeListEnd()) {
12905 return false;
12906 }
12907 }
12908 reader.accept();
12909 return true;
12910 }
12911 if (reader.noMore()) {
12912 reader.fail();
12913 return false;
12914 }
12915 std::string next_tag = reader.readTag(1);
12916 if (next_tag.empty()) {
12917 break;
12918 }
12919 tag.append("_").append(next_tag);
12920 tag_len = std::count(tag.begin(), tag.end(), '_') + 1;
12921 }
12922 return false;
12923}
#define BOTTLE_TAG_LIST
Definition Bottle.h:29
FeatureMode mode
#define yError(...)
Definition Log.h:361
#define __YFUNCTION__
Definition Log.h:24
#define yWarning(...)
Definition Log.h:340
bool readTag(yarp::os::idl::WireReader &reader)
bool writeArgs(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 writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
IFrameGrabberControlMsgs_return_getActive 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 read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_prototype
IFrameGrabberControlMsgs_return_getActive(*)(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_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 write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
IFrameGrabberControlDC1394Msgs_return_getBytesPerPacketDC1394 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.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
IFrameGrabberControlDC1394Msgs_return_getBytesPerPacketDC1394(*)() funcptr_t
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool 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_getCameraDescription return_helper
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
IFrameGrabberControlMsgs_return_getCameraDescription(*)() 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
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.
IFrameGrabberControlDC1394Msgs_return_getColorCodingDC1394 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.
IFrameGrabberControlDC1394Msgs_return_getColorCodingDC1394(*)() 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 write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
IFrameGrabberControlDC1394Msgs_return_getColorCodingMaskDC1394 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.
IFrameGrabberControlDC1394Msgs_return_getColorCodingMaskDC1394(*)(const std::int32_t) funcptr_t
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)
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.
IFrameGrabberControlDC1394Msgs_return_getFPSDC1394 return_helper
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
IFrameGrabberControlDC1394Msgs_return_getFPSDC1394(*)() 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 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 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 read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
IFrameGrabberControlDC1394Msgs_return_getFPSMaskDC1394 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.
IFrameGrabberControlDC1394Msgs_return_getFPSMaskDC1394(*)() funcptr_t
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 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.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
IFrameGrabberControlMsgs_return_getFeature1 return_helper
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
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_prototype
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool readArgs(yarp::os::idl::WireReader &reader)
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool readTag(yarp::os::idl::WireReader &reader)
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
IFrameGrabberControlMsgs_return_getFeature2 return_helper
IFrameGrabberControlMsgs_return_getFeature2(*)(const std::int32_t) funcptr_t
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 writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
IFrameGrabberControlDC1394Msgs_return_getFormat7MaxWindowDC1394 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.
IFrameGrabberControlDC1394Msgs_return_getFormat7MaxWindowDC1394(*)() funcptr_t
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 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.
IFrameGrabberControlDC1394Msgs_return_getFormat7WindowDC1394 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.
IFrameGrabberControlDC1394Msgs_return_getFormat7WindowDC1394(*)() funcptr_t
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool readTag(yarp::os::idl::WireReader &reader)
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.
IFrameGrabberImageOf_return_getHeight return_helper
static constexpr const char * s_help
static constexpr const char * s_tag
static constexpr const char * s_prototype
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
IFrameGrabberImageOf_return_getHeight(*)() 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 readTag(yarp::os::idl::WireReader &reader)
bool readArgs(yarp::os::idl::WireReader &reader)
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.
IFrameGrabberControlDC1394Msgs_return_getISOSpeedDC1394 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.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
IFrameGrabberControlDC1394Msgs_return_getISOSpeedDC1394(*)() 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 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 readArgs(yarp::os::idl::WireReader &reader)
IFrameGrabberImageOf_return_getImageCrop 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.
IFrameGrabberImageOf_return_getImageCrop(*)(const yarp::dev::cropType_id_t, const std::vector< yarp::dev::vertex_t > &) funcptr_t
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 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 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 write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
IFrameGrabberImageOf_return_getImage 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_tag
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_help
IFrameGrabberImageOf_return_getImage(*)() funcptr_t
static constexpr const char * s_prototype
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 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 write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
IFrameGrabberControlMsgs_return_getMode 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.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_prototype
IFrameGrabberControlMsgs_return_getMode(*)(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.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
IFrameGrabberControlDC1394Msgs_return_getOperationModeDC1394 return_helper
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
IFrameGrabberControlDC1394Msgs_return_getOperationModeDC1394(*)() 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 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::os::ApplicationNetworkProtocolVersion helper_proto
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
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool readArgs(yarp::os::idl::WireReader &reader)
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool 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.
IRGBVisualParamsMsgs_return_getRgbFOV(*)() 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
static constexpr const char * s_help
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 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
IRGBVisualParamsMsgs_return_getRgbHeight 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
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.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
IRGBVisualParamsMsgs_return_getRgbIntrinsicParam 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_getRgbIntrinsicParam(*)() funcptr_t
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 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
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
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.
IRGBVisualParamsMsgs_return_getRgbMirroring(*)() funcptr_t
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool 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 read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
IRGBVisualParamsMsgs_return_getRgbResolution return_helper
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
IRGBVisualParamsMsgs_return_getRgbResolution(*)() 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 read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
IRGBVisualParamsMsgs_return_getRgbSupportedCfg return_helper
IRGBVisualParamsMsgs_return_getRgbSupportedCfg(*)() 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 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 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.
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
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
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 write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
IFrameGrabberControlDC1394Msgs_return_getTransmissionDC1394 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.
IFrameGrabberControlDC1394Msgs_return_getTransmissionDC1394(*)() funcptr_t
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool 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.
IFrameGrabberControlDC1394Msgs_return_getVideoModeDC1394 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.
IFrameGrabberControlDC1394Msgs_return_getVideoModeDC1394(*)() funcptr_t
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
IFrameGrabberControlDC1394Msgs_return_getVideoModeMaskDC1394 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.
IFrameGrabberControlDC1394Msgs_return_getVideoModeMaskDC1394(*)() 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 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 writeTag(const yarp::os::idl::WireWriter &writer) const
bool readArgs(yarp::os::idl::WireReader &reader)
IFrameGrabberImageOf_return_getWidth 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.
IFrameGrabberImageOf_return_getWidth(*)() funcptr_t
static constexpr const char * s_tag
static constexpr const char * s_prototype
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.
bool readTag(yarp::os::idl::WireReader &reader)
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 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.
IFrameGrabberControlMsgs_return_hasAuto 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.
IFrameGrabberControlMsgs_return_hasAuto(*)(const std::int32_t) funcptr_t
static constexpr const char * s_prototype
static constexpr const char * s_tag
static constexpr const char * s_help
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 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)
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.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_tag
IFrameGrabberControlMsgs_return_hasFeature(*)(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_help
static constexpr const char * s_prototype
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 writeArgs(const yarp::os::idl::WireWriter &writer) const
bool readTag(yarp::os::idl::WireReader &reader)
IFrameGrabberControlMsgs_return_hasManual 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.
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.
static constexpr const char * s_help
IFrameGrabberControlMsgs_return_hasManual(*)(const std::int32_t) funcptr_t
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 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.
IFrameGrabberControlMsgs_return_hasOnOff 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
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
IFrameGrabberControlMsgs_return_hasOnOff(*)(const std::int32_t) funcptr_t
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 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
bool readTag(yarp::os::idl::WireReader &reader)
IFrameGrabberControlMsgs_return_hasOnePush 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.
IFrameGrabberControlMsgs_return_hasOnePush(*)(const std::int32_t) funcptr_t
static constexpr const char * s_prototype
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_help
bool writeArgs(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 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 read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_prototype
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_help
yarp::dev::ReturnValue(*)(const std::int32_t, const bool) funcptr_t
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
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 writeArgs(const yarp::os::idl::WireWriter &writer) const
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool 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 writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
yarp::dev::ReturnValue(*)(const std::int32_t) 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 write(yarp::os::ConnectionWriter &connection) const override
Write this object to 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 readTag(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
yarp::dev::ReturnValue(*)(const bool) 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 writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
yarp::dev::ReturnValue(*)(const std::int32_t) funcptr_t
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool 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 write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool 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 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.
static constexpr const char * s_prototype
yarp::dev::ReturnValue(*)(const std::int32_t) 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 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 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.
static constexpr const char * s_prototype
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 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 writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_prototype
yarp::dev::ReturnValue(*)(const std::int32_t, const double, const double) funcptr_t
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
yarp::dev::ReturnValue(*)(const std::int32_t, const std::int32_t, const std::int32_t, const std::int32_t) funcptr_t
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool readArgs(yarp::os::idl::WireReader &reader)
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.
yarp::dev::ReturnValue(*)(const std::int32_t) 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 writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool readArgs(yarp::os::idl::WireReader &reader)
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool 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.
static constexpr const char * s_tag
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_help
yarp::dev::ReturnValue(*)(const std::int32_t, const yarp::dev::FeatureMode) funcptr_t
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
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 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 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.
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) funcptr_t
static constexpr const char * s_tag
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool 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
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 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.
yarp::dev::ReturnValue(*)(const bool) funcptr_t
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 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 write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool 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 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 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
yarp::dev::ReturnValue(*)(const double, const double) funcptr_t
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
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 write(yarp::os::ConnectionWriter &connection) const override
Write this object to 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 read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
yarp::dev::ReturnValue(*)(const bool) 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 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 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.
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 writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
yarp::dev::ReturnValue(*)(const bool) 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 write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
yarp::dev::ReturnValue(*)(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.
virtual IFrameGrabberControlMsgs_return_getActive getActiveRPC(const std::int32_t feature)
virtual yarp::dev::ReturnValue setColorCodingDC1394RPC(const std::int32_t coding)
virtual yarp::dev::ReturnValue setRgbFOVRPC(const double horizontalFov, const double verticalFov)
virtual yarp::dev::ReturnValue setFeature2RPC(const std::int32_t feature, const double value1, const double value2)
virtual yarp::dev::ReturnValue setOnePushRPC(const std::int32_t feature)
virtual yarp::dev::ReturnValue setFormat7WindowDC1394RPC(const std::int32_t xdim, const std::int32_t ydim, const std::int32_t x0, const std::int32_t y0)
virtual yarp::dev::ReturnValue setVideoModeDC1394RPC(const std::int32_t videomode)
virtual yarp::dev::ReturnValue setBytesPerPacketDC1394RPC(const std::int32_t bpp)
virtual IFrameGrabberControlDC1394Msgs_return_getFormat7MaxWindowDC1394 getFormat7MaxWindowDC1394RPC()
virtual IFrameGrabberImageOf_return_getHeight getHeightRPC()
virtual IRGBVisualParamsMsgs_return_getRgbHeight getRgbHeightRPC()
virtual bool checkProtocolVersion()
virtual IFrameGrabberControlDC1394Msgs_return_getOperationModeDC1394 getOperationModeDC1394RPC()
virtual std::vector< std::string > help(const std::string &functionName="--all")
virtual yarp::dev::ReturnValue setFPSDC1394RPC(const std::int32_t fps)
virtual IFrameGrabberControlDC1394Msgs_return_getTransmissionDC1394 getTransmissionDC1394RPC()
virtual yarp::os::ApplicationNetworkProtocolVersion getRemoteProtocolVersion()
virtual IFrameGrabberImageOf_return_getImage getImageRPC()
virtual yarp::dev::ReturnValue setPowerDC1394RPC(const bool onoff)
virtual IFrameGrabberControlDC1394Msgs_return_getISOSpeedDC1394 getISOSpeedDC1394RPC()
virtual IFrameGrabberControlMsgs_return_getFeature2 getFeature2RPC(const std::int32_t feature)
virtual IFrameGrabberControlMsgs_return_hasFeature hasFeatureRPC(const std::int32_t feature)
virtual yarp::dev::ReturnValue setTransmissionDC1394RPC(const bool bTxON)
virtual IFrameGrabberControlMsgs_return_getFeature1 getFeature1RPC(const std::int32_t feature)
virtual IFrameGrabberControlMsgs_return_getCameraDescription getCameraDescriptionRPC()
virtual IFrameGrabberImageOf_return_getWidth getWidthRPC()
virtual yarp::dev::ReturnValue setRgbResolutionRPC(const std::int32_t width, const std::int32_t height)
virtual yarp::dev::ReturnValue setDefaultsDC1394RPC()
virtual IRGBVisualParamsMsgs_return_getRgbResolution getRgbResolutionRPC()
virtual IFrameGrabberControlDC1394Msgs_return_getFPSMaskDC1394 getFPSMaskDC1394RPC()
virtual IFrameGrabberControlDC1394Msgs_return_getVideoModeMaskDC1394 getVideoModeMaskDC1394RPC()
virtual IFrameGrabberControlDC1394Msgs_return_getColorCodingMaskDC1394 getColorCodingMaskDC1394RPC(const std::int32_t videomode)
virtual yarp::dev::ReturnValue setOperationModeDC1394RPC(const bool b1394b)
virtual IRGBVisualParamsMsgs_return_getRgbSupportedCfg getRgbSupportedConfigurationsRPC()
virtual yarp::os::ApplicationNetworkProtocolVersion getLocalProtocolVersion()
virtual yarp::dev::ReturnValue setISOSpeedDC1394RPC(const std::int32_t speed)
virtual IFrameGrabberControlDC1394Msgs_return_getFPSDC1394 getFPSDC1394RPC()
virtual IFrameGrabberImageOf_return_getImageCrop getImageCropRPC(const yarp::dev::cropType_id_t type, const std::vector< yarp::dev::vertex_t > &vertices)
virtual yarp::dev::ReturnValue setCaptureDC1394RPC(const bool bON)
virtual IFrameGrabberControlMsgs_return_hasAuto hasAutoRPC(const std::int32_t feature)
virtual IRGBVisualParamsMsgs_return_getRgbMirroring getRgbMirroringRPC()
virtual IRGBVisualParamsMsgs_return_getRgbFOV getRgbFOVRPC()
virtual yarp::dev::ReturnValue setFeature1RPC(const std::int32_t feature, const double value)
virtual IFrameGrabberControlMsgs_return_getMode getModeRPC(const std::int32_t feature)
virtual IRGBVisualParamsMsgs_return_getRgbIntrinsicParam getRgbIntrinsicParamRPC()
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
virtual IRGBVisualParamsMsgs_return_getRgbWidth getRgbWidthRPC()
virtual yarp::dev::ReturnValue setRgbMirroringRPC(const bool mirror)
virtual IFrameGrabberControlDC1394Msgs_return_getVideoModeDC1394 getVideoModeDC1394RPC()
virtual yarp::dev::ReturnValue setBroadcastDC1394RPC(const bool onoff)
virtual IFrameGrabberControlDC1394Msgs_return_getColorCodingDC1394 getColorCodingDC1394RPC()
virtual yarp::dev::ReturnValue setResetDC1394RPC()
virtual IFrameGrabberControlMsgs_return_hasOnOff hasOnOffRPC(const std::int32_t feature)
virtual IFrameGrabberControlDC1394Msgs_return_getFormat7WindowDC1394 getFormat7WindowDC1394RPC()
virtual IFrameGrabberControlMsgs_return_hasManual hasManualRPC(const std::int32_t feature)
virtual IFrameGrabberControlMsgs_return_hasOnePush hasOnePushRPC(const std::int32_t feature)
virtual IFrameGrabberControlDC1394Msgs_return_getBytesPerPacketDC1394 getBytesPerPacketDC1394RPC()
virtual yarp::dev::ReturnValue setModeRPC(const std::int32_t feature, const yarp::dev::FeatureMode mode)
virtual yarp::dev::ReturnValue setActiveRPC(const std::int32_t feature, const bool onoff)
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 readNested(WirePortable &obj)
bool readString(std::string &str, bool *is_vocab=nullptr)
void readListBegin(yarp::os::idl::WireState &nstate, size_t &len)
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 state.
Definition WireState.h:17
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 writeNested(const WirePortable &obj) 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
#define YARP_VERSION_PATCH
Definition version.h:12
#define YARP_VERSION_MAJOR
Definition version.h:10
#define YARP_VERSION_MINOR
Definition version.h:11