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:
1704 FrameGrabberMsgs_setModeRPC_helper(const std::int32_t feature, const yarp::dev::FeatureMode mode);
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 {
3920 size_t _csize;
3922 reader.readListBegin(_etype, _csize);
3923 // WireReader removes BOTTLE_TAG_LIST from the tag
3924 constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
3925 if constexpr (expected_tag != 0) {
3926 if (_csize != 0 && _etype.code != expected_tag) {
3927 return false;
3928 }
3929 }
3930 vertices.resize(_csize);
3931 for (size_t _i = 0; _i < _csize; ++_i) {
3932 if (reader.noMore()) {
3933 reader.fail();
3934 return false;
3935 }
3936 if (!reader.readNested(vertices[_i])) {
3937 reader.fail();
3938 return false;
3939 }
3940 }
3941 reader.readListEnd();
3942 }
3943 if (!reader.noMore()) {
3944 reader.fail();
3945 return false;
3946 }
3947 return true;
3948}
3949
3951{
3952 yarp::os::idl::WireWriter writer(connection);
3953 return write(writer);
3954}
3955
3957{
3958 yarp::os::idl::WireReader reader(connection);
3959 return read(reader);
3960}
3961
3963{
3964 if (!writer.isNull()) {
3965 if (!writer.writeListHeader(s_reply_len)) {
3966 return false;
3967 }
3968 if (!writer.write(return_helper)) {
3969 return false;
3970 }
3971 }
3972 return true;
3973}
3974
3976{
3977 if (!reader.readListReturn()) {
3978 return false;
3979 }
3980 if (reader.noMore()) {
3981 reader.fail();
3982 return false;
3983 }
3984 if (!reader.read(return_helper)) {
3985 reader.fail();
3986 return false;
3987 }
3988 return true;
3989}
3990
3995
3996// getRgbWidthRPC helper class implementation
3998{
3999 return cmd.write(connection);
4000}
4001
4003{
4004 return reply.read(connection);
4005}
4006
4008{
4009 yarp::os::idl::WireWriter writer(connection);
4010 if (!writer.writeListHeader(s_cmd_len)) {
4011 return false;
4012 }
4013 return write(writer);
4014}
4015
4017{
4018 yarp::os::idl::WireReader reader(connection);
4019 if (!reader.readListHeader()) {
4020 reader.fail();
4021 return false;
4022 }
4023 return read(reader);
4024}
4025
4027{
4028 if (!writeTag(writer)) {
4029 return false;
4030 }
4031 if (!writeArgs(writer)) {
4032 return false;
4033 }
4034 return true;
4035}
4036
4038{
4039 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4040 return false;
4041 }
4042 return true;
4043}
4044
4046{
4047 return true;
4048}
4049
4051{
4052 if (!readTag(reader)) {
4053 return false;
4054 }
4055 if (!readArgs(reader)) {
4056 return false;
4057 }
4058 return true;
4059}
4060
4062{
4063 std::string tag = reader.readTag(s_tag_len);
4064 if (reader.isError()) {
4065 return false;
4066 }
4067 if (tag != s_tag) {
4068 reader.fail();
4069 return false;
4070 }
4071 return true;
4072}
4073
4075{
4076 if (!reader.noMore()) {
4077 reader.fail();
4078 return false;
4079 }
4080 return true;
4081}
4082
4084{
4085 yarp::os::idl::WireWriter writer(connection);
4086 return write(writer);
4087}
4088
4090{
4091 yarp::os::idl::WireReader reader(connection);
4092 return read(reader);
4093}
4094
4096{
4097 if (!writer.isNull()) {
4098 if (!writer.writeListHeader(s_reply_len)) {
4099 return false;
4100 }
4101 if (!writer.write(return_helper)) {
4102 return false;
4103 }
4104 }
4105 return true;
4106}
4107
4109{
4110 if (!reader.readListReturn()) {
4111 return false;
4112 }
4113 if (reader.noMore()) {
4114 reader.fail();
4115 return false;
4116 }
4117 if (!reader.read(return_helper)) {
4118 reader.fail();
4119 return false;
4120 }
4121 return true;
4122}
4123
4128
4129// getRgbHeightRPC helper class implementation
4131{
4132 return cmd.write(connection);
4133}
4134
4136{
4137 return reply.read(connection);
4138}
4139
4141{
4142 yarp::os::idl::WireWriter writer(connection);
4143 if (!writer.writeListHeader(s_cmd_len)) {
4144 return false;
4145 }
4146 return write(writer);
4147}
4148
4150{
4151 yarp::os::idl::WireReader reader(connection);
4152 if (!reader.readListHeader()) {
4153 reader.fail();
4154 return false;
4155 }
4156 return read(reader);
4157}
4158
4160{
4161 if (!writeTag(writer)) {
4162 return false;
4163 }
4164 if (!writeArgs(writer)) {
4165 return false;
4166 }
4167 return true;
4168}
4169
4171{
4172 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4173 return false;
4174 }
4175 return true;
4176}
4177
4179{
4180 return true;
4181}
4182
4184{
4185 if (!readTag(reader)) {
4186 return false;
4187 }
4188 if (!readArgs(reader)) {
4189 return false;
4190 }
4191 return true;
4192}
4193
4195{
4196 std::string tag = reader.readTag(s_tag_len);
4197 if (reader.isError()) {
4198 return false;
4199 }
4200 if (tag != s_tag) {
4201 reader.fail();
4202 return false;
4203 }
4204 return true;
4205}
4206
4208{
4209 if (!reader.noMore()) {
4210 reader.fail();
4211 return false;
4212 }
4213 return true;
4214}
4215
4217{
4218 yarp::os::idl::WireWriter writer(connection);
4219 return write(writer);
4220}
4221
4223{
4224 yarp::os::idl::WireReader reader(connection);
4225 return read(reader);
4226}
4227
4229{
4230 if (!writer.isNull()) {
4231 if (!writer.writeListHeader(s_reply_len)) {
4232 return false;
4233 }
4234 if (!writer.write(return_helper)) {
4235 return false;
4236 }
4237 }
4238 return true;
4239}
4240
4242{
4243 if (!reader.readListReturn()) {
4244 return false;
4245 }
4246 if (reader.noMore()) {
4247 reader.fail();
4248 return false;
4249 }
4250 if (!reader.read(return_helper)) {
4251 reader.fail();
4252 return false;
4253 }
4254 return true;
4255}
4256
4261
4262// getRgbSupportedConfigurationsRPC helper class implementation
4267
4272
4274{
4275 yarp::os::idl::WireWriter writer(connection);
4276 if (!writer.writeListHeader(s_cmd_len)) {
4277 return false;
4278 }
4279 return write(writer);
4280}
4281
4283{
4284 yarp::os::idl::WireReader reader(connection);
4285 if (!reader.readListHeader()) {
4286 reader.fail();
4287 return false;
4288 }
4289 return read(reader);
4290}
4291
4293{
4294 if (!writeTag(writer)) {
4295 return false;
4296 }
4297 if (!writeArgs(writer)) {
4298 return false;
4299 }
4300 return true;
4301}
4302
4304{
4305 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4306 return false;
4307 }
4308 return true;
4309}
4310
4312{
4313 return true;
4314}
4315
4317{
4318 if (!readTag(reader)) {
4319 return false;
4320 }
4321 if (!readArgs(reader)) {
4322 return false;
4323 }
4324 return true;
4325}
4326
4328{
4329 std::string tag = reader.readTag(s_tag_len);
4330 if (reader.isError()) {
4331 return false;
4332 }
4333 if (tag != s_tag) {
4334 reader.fail();
4335 return false;
4336 }
4337 return true;
4338}
4339
4341{
4342 if (!reader.noMore()) {
4343 reader.fail();
4344 return false;
4345 }
4346 return true;
4347}
4348
4354
4360
4362{
4363 if (!writer.isNull()) {
4364 if (!writer.writeListHeader(s_reply_len)) {
4365 return false;
4366 }
4367 if (!writer.write(return_helper)) {
4368 return false;
4369 }
4370 }
4371 return true;
4372}
4373
4375{
4376 if (!reader.readListReturn()) {
4377 return false;
4378 }
4379 if (reader.noMore()) {
4380 reader.fail();
4381 return false;
4382 }
4383 if (!reader.read(return_helper)) {
4384 reader.fail();
4385 return false;
4386 }
4387 return true;
4388}
4389
4394
4395// getRgbResolutionRPC helper class implementation
4397{
4398 return cmd.write(connection);
4399}
4400
4405
4407{
4408 yarp::os::idl::WireWriter writer(connection);
4409 if (!writer.writeListHeader(s_cmd_len)) {
4410 return false;
4411 }
4412 return write(writer);
4413}
4414
4416{
4417 yarp::os::idl::WireReader reader(connection);
4418 if (!reader.readListHeader()) {
4419 reader.fail();
4420 return false;
4421 }
4422 return read(reader);
4423}
4424
4426{
4427 if (!writeTag(writer)) {
4428 return false;
4429 }
4430 if (!writeArgs(writer)) {
4431 return false;
4432 }
4433 return true;
4434}
4435
4437{
4438 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4439 return false;
4440 }
4441 return true;
4442}
4443
4445{
4446 return true;
4447}
4448
4450{
4451 if (!readTag(reader)) {
4452 return false;
4453 }
4454 if (!readArgs(reader)) {
4455 return false;
4456 }
4457 return true;
4458}
4459
4461{
4462 std::string tag = reader.readTag(s_tag_len);
4463 if (reader.isError()) {
4464 return false;
4465 }
4466 if (tag != s_tag) {
4467 reader.fail();
4468 return false;
4469 }
4470 return true;
4471}
4472
4474{
4475 if (!reader.noMore()) {
4476 reader.fail();
4477 return false;
4478 }
4479 return true;
4480}
4481
4483{
4484 yarp::os::idl::WireWriter writer(connection);
4485 return write(writer);
4486}
4487
4489{
4490 yarp::os::idl::WireReader reader(connection);
4491 return read(reader);
4492}
4493
4495{
4496 if (!writer.isNull()) {
4497 if (!writer.writeListHeader(s_reply_len)) {
4498 return false;
4499 }
4500 if (!writer.write(return_helper)) {
4501 return false;
4502 }
4503 }
4504 return true;
4505}
4506
4508{
4509 if (!reader.readListReturn()) {
4510 return false;
4511 }
4512 if (reader.noMore()) {
4513 reader.fail();
4514 return false;
4515 }
4516 if (!reader.read(return_helper)) {
4517 reader.fail();
4518 return false;
4519 }
4520 return true;
4521}
4522
4527
4528// setRgbResolutionRPC helper class implementation
4530 cmd{width, height}
4531{
4532}
4533
4535{
4536 return cmd.write(connection);
4537}
4538
4543
4544FrameGrabberMsgs_setRgbResolutionRPC_helper::Command::Command(const std::int32_t width, const std::int32_t height) :
4545 width{width},
4546 height{height}
4547{
4548}
4549
4551{
4552 yarp::os::idl::WireWriter writer(connection);
4553 if (!writer.writeListHeader(s_cmd_len)) {
4554 return false;
4555 }
4556 return write(writer);
4557}
4558
4560{
4561 yarp::os::idl::WireReader reader(connection);
4562 if (!reader.readListHeader()) {
4563 reader.fail();
4564 return false;
4565 }
4566 return read(reader);
4567}
4568
4570{
4571 if (!writeTag(writer)) {
4572 return false;
4573 }
4574 if (!writeArgs(writer)) {
4575 return false;
4576 }
4577 return true;
4578}
4579
4581{
4582 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4583 return false;
4584 }
4585 return true;
4586}
4587
4589{
4590 if (!writer.writeI32(width)) {
4591 return false;
4592 }
4593 if (!writer.writeI32(height)) {
4594 return false;
4595 }
4596 return true;
4597}
4598
4600{
4601 if (!readTag(reader)) {
4602 return false;
4603 }
4604 if (!readArgs(reader)) {
4605 return false;
4606 }
4607 return true;
4608}
4609
4611{
4612 std::string tag = reader.readTag(s_tag_len);
4613 if (reader.isError()) {
4614 return false;
4615 }
4616 if (tag != s_tag) {
4617 reader.fail();
4618 return false;
4619 }
4620 return true;
4621}
4622
4624{
4625 if (reader.noMore()) {
4626 reader.fail();
4627 return false;
4628 }
4629 if (!reader.readI32(width)) {
4630 reader.fail();
4631 return false;
4632 }
4633 if (reader.noMore()) {
4634 reader.fail();
4635 return false;
4636 }
4637 if (!reader.readI32(height)) {
4638 reader.fail();
4639 return false;
4640 }
4641 if (!reader.noMore()) {
4642 reader.fail();
4643 return false;
4644 }
4645 return true;
4646}
4647
4649{
4650 yarp::os::idl::WireWriter writer(connection);
4651 return write(writer);
4652}
4653
4655{
4656 yarp::os::idl::WireReader reader(connection);
4657 return read(reader);
4658}
4659
4661{
4662 if (!writer.isNull()) {
4663 if (!writer.write(return_helper)) {
4664 return false;
4665 }
4666 }
4667 return true;
4668}
4669
4671{
4672 if (reader.noMore()) {
4673 reader.fail();
4674 return false;
4675 }
4676 if (!reader.read(return_helper)) {
4677 reader.fail();
4678 return false;
4679 }
4680 return true;
4681}
4682
4687
4688// getRgbFOVRPC helper class implementation
4690{
4691 return cmd.write(connection);
4692}
4693
4695{
4696 return reply.read(connection);
4697}
4698
4700{
4701 yarp::os::idl::WireWriter writer(connection);
4702 if (!writer.writeListHeader(s_cmd_len)) {
4703 return false;
4704 }
4705 return write(writer);
4706}
4707
4709{
4710 yarp::os::idl::WireReader reader(connection);
4711 if (!reader.readListHeader()) {
4712 reader.fail();
4713 return false;
4714 }
4715 return read(reader);
4716}
4717
4719{
4720 if (!writeTag(writer)) {
4721 return false;
4722 }
4723 if (!writeArgs(writer)) {
4724 return false;
4725 }
4726 return true;
4727}
4728
4730{
4731 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4732 return false;
4733 }
4734 return true;
4735}
4736
4738{
4739 return true;
4740}
4741
4743{
4744 if (!readTag(reader)) {
4745 return false;
4746 }
4747 if (!readArgs(reader)) {
4748 return false;
4749 }
4750 return true;
4751}
4752
4754{
4755 std::string tag = reader.readTag(s_tag_len);
4756 if (reader.isError()) {
4757 return false;
4758 }
4759 if (tag != s_tag) {
4760 reader.fail();
4761 return false;
4762 }
4763 return true;
4764}
4765
4767{
4768 if (!reader.noMore()) {
4769 reader.fail();
4770 return false;
4771 }
4772 return true;
4773}
4774
4776{
4777 yarp::os::idl::WireWriter writer(connection);
4778 return write(writer);
4779}
4780
4782{
4783 yarp::os::idl::WireReader reader(connection);
4784 return read(reader);
4785}
4786
4788{
4789 if (!writer.isNull()) {
4790 if (!writer.writeListHeader(s_reply_len)) {
4791 return false;
4792 }
4793 if (!writer.write(return_helper)) {
4794 return false;
4795 }
4796 }
4797 return true;
4798}
4799
4801{
4802 if (!reader.readListReturn()) {
4803 return false;
4804 }
4805 if (reader.noMore()) {
4806 reader.fail();
4807 return false;
4808 }
4809 if (!reader.read(return_helper)) {
4810 reader.fail();
4811 return false;
4812 }
4813 return true;
4814}
4815
4820
4821// setRgbFOVRPC helper class implementation
4822FrameGrabberMsgs_setRgbFOVRPC_helper::FrameGrabberMsgs_setRgbFOVRPC_helper(const double horizontalFov, const double verticalFov) :
4823 cmd{horizontalFov, verticalFov}
4824{
4825}
4826
4828{
4829 return cmd.write(connection);
4830}
4831
4833{
4834 return reply.read(connection);
4835}
4836
4837FrameGrabberMsgs_setRgbFOVRPC_helper::Command::Command(const double horizontalFov, const double verticalFov) :
4838 horizontalFov{horizontalFov},
4839 verticalFov{verticalFov}
4840{
4841}
4842
4844{
4845 yarp::os::idl::WireWriter writer(connection);
4846 if (!writer.writeListHeader(s_cmd_len)) {
4847 return false;
4848 }
4849 return write(writer);
4850}
4851
4853{
4854 yarp::os::idl::WireReader reader(connection);
4855 if (!reader.readListHeader()) {
4856 reader.fail();
4857 return false;
4858 }
4859 return read(reader);
4860}
4861
4863{
4864 if (!writeTag(writer)) {
4865 return false;
4866 }
4867 if (!writeArgs(writer)) {
4868 return false;
4869 }
4870 return true;
4871}
4872
4874{
4875 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4876 return false;
4877 }
4878 return true;
4879}
4880
4882{
4883 if (!writer.writeFloat64(horizontalFov)) {
4884 return false;
4885 }
4886 if (!writer.writeFloat64(verticalFov)) {
4887 return false;
4888 }
4889 return true;
4890}
4891
4893{
4894 if (!readTag(reader)) {
4895 return false;
4896 }
4897 if (!readArgs(reader)) {
4898 return false;
4899 }
4900 return true;
4901}
4902
4904{
4905 std::string tag = reader.readTag(s_tag_len);
4906 if (reader.isError()) {
4907 return false;
4908 }
4909 if (tag != s_tag) {
4910 reader.fail();
4911 return false;
4912 }
4913 return true;
4914}
4915
4917{
4918 if (reader.noMore()) {
4919 reader.fail();
4920 return false;
4921 }
4922 if (!reader.readFloat64(horizontalFov)) {
4923 reader.fail();
4924 return false;
4925 }
4926 if (reader.noMore()) {
4927 reader.fail();
4928 return false;
4929 }
4930 if (!reader.readFloat64(verticalFov)) {
4931 reader.fail();
4932 return false;
4933 }
4934 if (!reader.noMore()) {
4935 reader.fail();
4936 return false;
4937 }
4938 return true;
4939}
4940
4942{
4943 yarp::os::idl::WireWriter writer(connection);
4944 return write(writer);
4945}
4946
4948{
4949 yarp::os::idl::WireReader reader(connection);
4950 return read(reader);
4951}
4952
4954{
4955 if (!writer.isNull()) {
4956 if (!writer.write(return_helper)) {
4957 return false;
4958 }
4959 }
4960 return true;
4961}
4962
4964{
4965 if (reader.noMore()) {
4966 reader.fail();
4967 return false;
4968 }
4969 if (!reader.read(return_helper)) {
4970 reader.fail();
4971 return false;
4972 }
4973 return true;
4974}
4975
4980
4981// getRgbIntrinsicParamRPC helper class implementation
4983{
4984 return cmd.write(connection);
4985}
4986
4991
4993{
4994 yarp::os::idl::WireWriter writer(connection);
4995 if (!writer.writeListHeader(s_cmd_len)) {
4996 return false;
4997 }
4998 return write(writer);
4999}
5000
5002{
5003 yarp::os::idl::WireReader reader(connection);
5004 if (!reader.readListHeader()) {
5005 reader.fail();
5006 return false;
5007 }
5008 return read(reader);
5009}
5010
5012{
5013 if (!writeTag(writer)) {
5014 return false;
5015 }
5016 if (!writeArgs(writer)) {
5017 return false;
5018 }
5019 return true;
5020}
5021
5023{
5024 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5025 return false;
5026 }
5027 return true;
5028}
5029
5031{
5032 return true;
5033}
5034
5036{
5037 if (!readTag(reader)) {
5038 return false;
5039 }
5040 if (!readArgs(reader)) {
5041 return false;
5042 }
5043 return true;
5044}
5045
5047{
5048 std::string tag = reader.readTag(s_tag_len);
5049 if (reader.isError()) {
5050 return false;
5051 }
5052 if (tag != s_tag) {
5053 reader.fail();
5054 return false;
5055 }
5056 return true;
5057}
5058
5060{
5061 if (!reader.noMore()) {
5062 reader.fail();
5063 return false;
5064 }
5065 return true;
5066}
5067
5069{
5070 yarp::os::idl::WireWriter writer(connection);
5071 return write(writer);
5072}
5073
5075{
5076 yarp::os::idl::WireReader reader(connection);
5077 return read(reader);
5078}
5079
5081{
5082 if (!writer.isNull()) {
5083 if (!writer.writeListHeader(s_reply_len)) {
5084 return false;
5085 }
5086 if (!writer.write(return_helper)) {
5087 return false;
5088 }
5089 }
5090 return true;
5091}
5092
5094{
5095 if (!reader.readListReturn()) {
5096 return false;
5097 }
5098 if (reader.noMore()) {
5099 reader.fail();
5100 return false;
5101 }
5102 if (!reader.read(return_helper)) {
5103 reader.fail();
5104 return false;
5105 }
5106 return true;
5107}
5108
5113
5114// getRgbMirroringRPC helper class implementation
5116{
5117 return cmd.write(connection);
5118}
5119
5121{
5122 return reply.read(connection);
5123}
5124
5126{
5127 yarp::os::idl::WireWriter writer(connection);
5128 if (!writer.writeListHeader(s_cmd_len)) {
5129 return false;
5130 }
5131 return write(writer);
5132}
5133
5135{
5136 yarp::os::idl::WireReader reader(connection);
5137 if (!reader.readListHeader()) {
5138 reader.fail();
5139 return false;
5140 }
5141 return read(reader);
5142}
5143
5145{
5146 if (!writeTag(writer)) {
5147 return false;
5148 }
5149 if (!writeArgs(writer)) {
5150 return false;
5151 }
5152 return true;
5153}
5154
5156{
5157 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5158 return false;
5159 }
5160 return true;
5161}
5162
5164{
5165 return true;
5166}
5167
5169{
5170 if (!readTag(reader)) {
5171 return false;
5172 }
5173 if (!readArgs(reader)) {
5174 return false;
5175 }
5176 return true;
5177}
5178
5180{
5181 std::string tag = reader.readTag(s_tag_len);
5182 if (reader.isError()) {
5183 return false;
5184 }
5185 if (tag != s_tag) {
5186 reader.fail();
5187 return false;
5188 }
5189 return true;
5190}
5191
5193{
5194 if (!reader.noMore()) {
5195 reader.fail();
5196 return false;
5197 }
5198 return true;
5199}
5200
5202{
5203 yarp::os::idl::WireWriter writer(connection);
5204 return write(writer);
5205}
5206
5208{
5209 yarp::os::idl::WireReader reader(connection);
5210 return read(reader);
5211}
5212
5214{
5215 if (!writer.isNull()) {
5216 if (!writer.writeListHeader(s_reply_len)) {
5217 return false;
5218 }
5219 if (!writer.write(return_helper)) {
5220 return false;
5221 }
5222 }
5223 return true;
5224}
5225
5227{
5228 if (!reader.readListReturn()) {
5229 return false;
5230 }
5231 if (reader.noMore()) {
5232 reader.fail();
5233 return false;
5234 }
5235 if (!reader.read(return_helper)) {
5236 reader.fail();
5237 return false;
5238 }
5239 return true;
5240}
5241
5246
5247// setRgbMirroringRPC helper class implementation
5252
5254{
5255 return cmd.write(connection);
5256}
5257
5259{
5260 return reply.read(connection);
5261}
5262
5264 mirror{mirror}
5265{
5266}
5267
5269{
5270 yarp::os::idl::WireWriter writer(connection);
5271 if (!writer.writeListHeader(s_cmd_len)) {
5272 return false;
5273 }
5274 return write(writer);
5275}
5276
5278{
5279 yarp::os::idl::WireReader reader(connection);
5280 if (!reader.readListHeader()) {
5281 reader.fail();
5282 return false;
5283 }
5284 return read(reader);
5285}
5286
5288{
5289 if (!writeTag(writer)) {
5290 return false;
5291 }
5292 if (!writeArgs(writer)) {
5293 return false;
5294 }
5295 return true;
5296}
5297
5299{
5300 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5301 return false;
5302 }
5303 return true;
5304}
5305
5307{
5308 if (!writer.writeBool(mirror)) {
5309 return false;
5310 }
5311 return true;
5312}
5313
5315{
5316 if (!readTag(reader)) {
5317 return false;
5318 }
5319 if (!readArgs(reader)) {
5320 return false;
5321 }
5322 return true;
5323}
5324
5326{
5327 std::string tag = reader.readTag(s_tag_len);
5328 if (reader.isError()) {
5329 return false;
5330 }
5331 if (tag != s_tag) {
5332 reader.fail();
5333 return false;
5334 }
5335 return true;
5336}
5337
5339{
5340 if (reader.noMore()) {
5341 reader.fail();
5342 return false;
5343 }
5344 if (!reader.readBool(mirror)) {
5345 reader.fail();
5346 return false;
5347 }
5348 if (!reader.noMore()) {
5349 reader.fail();
5350 return false;
5351 }
5352 return true;
5353}
5354
5356{
5357 yarp::os::idl::WireWriter writer(connection);
5358 return write(writer);
5359}
5360
5362{
5363 yarp::os::idl::WireReader reader(connection);
5364 return read(reader);
5365}
5366
5368{
5369 if (!writer.isNull()) {
5370 if (!writer.write(return_helper)) {
5371 return false;
5372 }
5373 }
5374 return true;
5375}
5376
5378{
5379 if (reader.noMore()) {
5380 reader.fail();
5381 return false;
5382 }
5383 if (!reader.read(return_helper)) {
5384 reader.fail();
5385 return false;
5386 }
5387 return true;
5388}
5389
5394
5395// getCameraDescriptionRPC helper class implementation
5397{
5398 return cmd.write(connection);
5399}
5400
5405
5407{
5408 yarp::os::idl::WireWriter writer(connection);
5409 if (!writer.writeListHeader(s_cmd_len)) {
5410 return false;
5411 }
5412 return write(writer);
5413}
5414
5416{
5417 yarp::os::idl::WireReader reader(connection);
5418 if (!reader.readListHeader()) {
5419 reader.fail();
5420 return false;
5421 }
5422 return read(reader);
5423}
5424
5426{
5427 if (!writeTag(writer)) {
5428 return false;
5429 }
5430 if (!writeArgs(writer)) {
5431 return false;
5432 }
5433 return true;
5434}
5435
5437{
5438 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5439 return false;
5440 }
5441 return true;
5442}
5443
5445{
5446 return true;
5447}
5448
5450{
5451 if (!readTag(reader)) {
5452 return false;
5453 }
5454 if (!readArgs(reader)) {
5455 return false;
5456 }
5457 return true;
5458}
5459
5461{
5462 std::string tag = reader.readTag(s_tag_len);
5463 if (reader.isError()) {
5464 return false;
5465 }
5466 if (tag != s_tag) {
5467 reader.fail();
5468 return false;
5469 }
5470 return true;
5471}
5472
5474{
5475 if (!reader.noMore()) {
5476 reader.fail();
5477 return false;
5478 }
5479 return true;
5480}
5481
5483{
5484 yarp::os::idl::WireWriter writer(connection);
5485 return write(writer);
5486}
5487
5489{
5490 yarp::os::idl::WireReader reader(connection);
5491 return read(reader);
5492}
5493
5495{
5496 if (!writer.isNull()) {
5497 if (!writer.writeListHeader(s_reply_len)) {
5498 return false;
5499 }
5500 if (!writer.write(return_helper)) {
5501 return false;
5502 }
5503 }
5504 return true;
5505}
5506
5508{
5509 if (!reader.readListReturn()) {
5510 return false;
5511 }
5512 if (reader.noMore()) {
5513 reader.fail();
5514 return false;
5515 }
5516 if (!reader.read(return_helper)) {
5517 reader.fail();
5518 return false;
5519 }
5520 return true;
5521}
5522
5527
5528// hasFeatureRPC helper class implementation
5530 cmd{feature}
5531{
5532}
5533
5535{
5536 return cmd.write(connection);
5537}
5538
5540{
5541 return reply.read(connection);
5542}
5543
5545 feature{feature}
5546{
5547}
5548
5550{
5551 yarp::os::idl::WireWriter writer(connection);
5552 if (!writer.writeListHeader(s_cmd_len)) {
5553 return false;
5554 }
5555 return write(writer);
5556}
5557
5559{
5560 yarp::os::idl::WireReader reader(connection);
5561 if (!reader.readListHeader()) {
5562 reader.fail();
5563 return false;
5564 }
5565 return read(reader);
5566}
5567
5569{
5570 if (!writeTag(writer)) {
5571 return false;
5572 }
5573 if (!writeArgs(writer)) {
5574 return false;
5575 }
5576 return true;
5577}
5578
5580{
5581 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5582 return false;
5583 }
5584 return true;
5585}
5586
5588{
5589 if (!writer.writeI32(feature)) {
5590 return false;
5591 }
5592 return true;
5593}
5594
5596{
5597 if (!readTag(reader)) {
5598 return false;
5599 }
5600 if (!readArgs(reader)) {
5601 return false;
5602 }
5603 return true;
5604}
5605
5607{
5608 std::string tag = reader.readTag(s_tag_len);
5609 if (reader.isError()) {
5610 return false;
5611 }
5612 if (tag != s_tag) {
5613 reader.fail();
5614 return false;
5615 }
5616 return true;
5617}
5618
5620{
5621 if (reader.noMore()) {
5622 reader.fail();
5623 return false;
5624 }
5625 if (!reader.readI32(feature)) {
5626 reader.fail();
5627 return false;
5628 }
5629 if (!reader.noMore()) {
5630 reader.fail();
5631 return false;
5632 }
5633 return true;
5634}
5635
5637{
5638 yarp::os::idl::WireWriter writer(connection);
5639 return write(writer);
5640}
5641
5643{
5644 yarp::os::idl::WireReader reader(connection);
5645 return read(reader);
5646}
5647
5649{
5650 if (!writer.isNull()) {
5651 if (!writer.writeListHeader(s_reply_len)) {
5652 return false;
5653 }
5654 if (!writer.write(return_helper)) {
5655 return false;
5656 }
5657 }
5658 return true;
5659}
5660
5662{
5663 if (!reader.readListReturn()) {
5664 return false;
5665 }
5666 if (reader.noMore()) {
5667 reader.fail();
5668 return false;
5669 }
5670 if (!reader.read(return_helper)) {
5671 reader.fail();
5672 return false;
5673 }
5674 return true;
5675}
5676
5681
5682// setFeature1RPC helper class implementation
5684 cmd{feature, value}
5685{
5686}
5687
5689{
5690 return cmd.write(connection);
5691}
5692
5694{
5695 return reply.read(connection);
5696}
5697
5698FrameGrabberMsgs_setFeature1RPC_helper::Command::Command(const std::int32_t feature, const double value) :
5699 feature{feature},
5700 value{value}
5701{
5702}
5703
5705{
5706 yarp::os::idl::WireWriter writer(connection);
5707 if (!writer.writeListHeader(s_cmd_len)) {
5708 return false;
5709 }
5710 return write(writer);
5711}
5712
5714{
5715 yarp::os::idl::WireReader reader(connection);
5716 if (!reader.readListHeader()) {
5717 reader.fail();
5718 return false;
5719 }
5720 return read(reader);
5721}
5722
5724{
5725 if (!writeTag(writer)) {
5726 return false;
5727 }
5728 if (!writeArgs(writer)) {
5729 return false;
5730 }
5731 return true;
5732}
5733
5735{
5736 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5737 return false;
5738 }
5739 return true;
5740}
5741
5743{
5744 if (!writer.writeI32(feature)) {
5745 return false;
5746 }
5747 if (!writer.writeFloat64(value)) {
5748 return false;
5749 }
5750 return true;
5751}
5752
5754{
5755 if (!readTag(reader)) {
5756 return false;
5757 }
5758 if (!readArgs(reader)) {
5759 return false;
5760 }
5761 return true;
5762}
5763
5765{
5766 std::string tag = reader.readTag(s_tag_len);
5767 if (reader.isError()) {
5768 return false;
5769 }
5770 if (tag != s_tag) {
5771 reader.fail();
5772 return false;
5773 }
5774 return true;
5775}
5776
5778{
5779 if (reader.noMore()) {
5780 reader.fail();
5781 return false;
5782 }
5783 if (!reader.readI32(feature)) {
5784 reader.fail();
5785 return false;
5786 }
5787 if (reader.noMore()) {
5788 reader.fail();
5789 return false;
5790 }
5791 if (!reader.readFloat64(value)) {
5792 reader.fail();
5793 return false;
5794 }
5795 if (!reader.noMore()) {
5796 reader.fail();
5797 return false;
5798 }
5799 return true;
5800}
5801
5803{
5804 yarp::os::idl::WireWriter writer(connection);
5805 return write(writer);
5806}
5807
5809{
5810 yarp::os::idl::WireReader reader(connection);
5811 return read(reader);
5812}
5813
5815{
5816 if (!writer.isNull()) {
5817 if (!writer.write(return_helper)) {
5818 return false;
5819 }
5820 }
5821 return true;
5822}
5823
5825{
5826 if (reader.noMore()) {
5827 reader.fail();
5828 return false;
5829 }
5830 if (!reader.read(return_helper)) {
5831 reader.fail();
5832 return false;
5833 }
5834 return true;
5835}
5836
5841
5842// getFeature1RPC helper class implementation
5844 cmd{feature}
5845{
5846}
5847
5849{
5850 return cmd.write(connection);
5851}
5852
5854{
5855 return reply.read(connection);
5856}
5857
5859 feature{feature}
5860{
5861}
5862
5864{
5865 yarp::os::idl::WireWriter writer(connection);
5866 if (!writer.writeListHeader(s_cmd_len)) {
5867 return false;
5868 }
5869 return write(writer);
5870}
5871
5873{
5874 yarp::os::idl::WireReader reader(connection);
5875 if (!reader.readListHeader()) {
5876 reader.fail();
5877 return false;
5878 }
5879 return read(reader);
5880}
5881
5883{
5884 if (!writeTag(writer)) {
5885 return false;
5886 }
5887 if (!writeArgs(writer)) {
5888 return false;
5889 }
5890 return true;
5891}
5892
5894{
5895 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5896 return false;
5897 }
5898 return true;
5899}
5900
5902{
5903 if (!writer.writeI32(feature)) {
5904 return false;
5905 }
5906 return true;
5907}
5908
5910{
5911 if (!readTag(reader)) {
5912 return false;
5913 }
5914 if (!readArgs(reader)) {
5915 return false;
5916 }
5917 return true;
5918}
5919
5921{
5922 std::string tag = reader.readTag(s_tag_len);
5923 if (reader.isError()) {
5924 return false;
5925 }
5926 if (tag != s_tag) {
5927 reader.fail();
5928 return false;
5929 }
5930 return true;
5931}
5932
5934{
5935 if (reader.noMore()) {
5936 reader.fail();
5937 return false;
5938 }
5939 if (!reader.readI32(feature)) {
5940 reader.fail();
5941 return false;
5942 }
5943 if (!reader.noMore()) {
5944 reader.fail();
5945 return false;
5946 }
5947 return true;
5948}
5949
5951{
5952 yarp::os::idl::WireWriter writer(connection);
5953 return write(writer);
5954}
5955
5957{
5958 yarp::os::idl::WireReader reader(connection);
5959 return read(reader);
5960}
5961
5963{
5964 if (!writer.isNull()) {
5965 if (!writer.writeListHeader(s_reply_len)) {
5966 return false;
5967 }
5968 if (!writer.write(return_helper)) {
5969 return false;
5970 }
5971 }
5972 return true;
5973}
5974
5976{
5977 if (!reader.readListReturn()) {
5978 return false;
5979 }
5980 if (reader.noMore()) {
5981 reader.fail();
5982 return false;
5983 }
5984 if (!reader.read(return_helper)) {
5985 reader.fail();
5986 return false;
5987 }
5988 return true;
5989}
5990
5995
5996// setFeature2RPC helper class implementation
5997FrameGrabberMsgs_setFeature2RPC_helper::FrameGrabberMsgs_setFeature2RPC_helper(const std::int32_t feature, const double value1, const double value2) :
5998 cmd{feature, value1, value2}
5999{
6000}
6001
6003{
6004 return cmd.write(connection);
6005}
6006
6008{
6009 return reply.read(connection);
6010}
6011
6012FrameGrabberMsgs_setFeature2RPC_helper::Command::Command(const std::int32_t feature, const double value1, const double value2) :
6013 feature{feature},
6014 value1{value1},
6015 value2{value2}
6016{
6017}
6018
6020{
6021 yarp::os::idl::WireWriter writer(connection);
6022 if (!writer.writeListHeader(s_cmd_len)) {
6023 return false;
6024 }
6025 return write(writer);
6026}
6027
6029{
6030 yarp::os::idl::WireReader reader(connection);
6031 if (!reader.readListHeader()) {
6032 reader.fail();
6033 return false;
6034 }
6035 return read(reader);
6036}
6037
6039{
6040 if (!writeTag(writer)) {
6041 return false;
6042 }
6043 if (!writeArgs(writer)) {
6044 return false;
6045 }
6046 return true;
6047}
6048
6050{
6051 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6052 return false;
6053 }
6054 return true;
6055}
6056
6058{
6059 if (!writer.writeI32(feature)) {
6060 return false;
6061 }
6062 if (!writer.writeFloat64(value1)) {
6063 return false;
6064 }
6065 if (!writer.writeFloat64(value2)) {
6066 return false;
6067 }
6068 return true;
6069}
6070
6072{
6073 if (!readTag(reader)) {
6074 return false;
6075 }
6076 if (!readArgs(reader)) {
6077 return false;
6078 }
6079 return true;
6080}
6081
6083{
6084 std::string tag = reader.readTag(s_tag_len);
6085 if (reader.isError()) {
6086 return false;
6087 }
6088 if (tag != s_tag) {
6089 reader.fail();
6090 return false;
6091 }
6092 return true;
6093}
6094
6096{
6097 if (reader.noMore()) {
6098 reader.fail();
6099 return false;
6100 }
6101 if (!reader.readI32(feature)) {
6102 reader.fail();
6103 return false;
6104 }
6105 if (reader.noMore()) {
6106 reader.fail();
6107 return false;
6108 }
6109 if (!reader.readFloat64(value1)) {
6110 reader.fail();
6111 return false;
6112 }
6113 if (reader.noMore()) {
6114 reader.fail();
6115 return false;
6116 }
6117 if (!reader.readFloat64(value2)) {
6118 reader.fail();
6119 return false;
6120 }
6121 if (!reader.noMore()) {
6122 reader.fail();
6123 return false;
6124 }
6125 return true;
6126}
6127
6129{
6130 yarp::os::idl::WireWriter writer(connection);
6131 return write(writer);
6132}
6133
6135{
6136 yarp::os::idl::WireReader reader(connection);
6137 return read(reader);
6138}
6139
6141{
6142 if (!writer.isNull()) {
6143 if (!writer.write(return_helper)) {
6144 return false;
6145 }
6146 }
6147 return true;
6148}
6149
6151{
6152 if (reader.noMore()) {
6153 reader.fail();
6154 return false;
6155 }
6156 if (!reader.read(return_helper)) {
6157 reader.fail();
6158 return false;
6159 }
6160 return true;
6161}
6162
6167
6168// getFeature2RPC helper class implementation
6170 cmd{feature}
6171{
6172}
6173
6175{
6176 return cmd.write(connection);
6177}
6178
6180{
6181 return reply.read(connection);
6182}
6183
6185 feature{feature}
6186{
6187}
6188
6190{
6191 yarp::os::idl::WireWriter writer(connection);
6192 if (!writer.writeListHeader(s_cmd_len)) {
6193 return false;
6194 }
6195 return write(writer);
6196}
6197
6199{
6200 yarp::os::idl::WireReader reader(connection);
6201 if (!reader.readListHeader()) {
6202 reader.fail();
6203 return false;
6204 }
6205 return read(reader);
6206}
6207
6209{
6210 if (!writeTag(writer)) {
6211 return false;
6212 }
6213 if (!writeArgs(writer)) {
6214 return false;
6215 }
6216 return true;
6217}
6218
6220{
6221 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6222 return false;
6223 }
6224 return true;
6225}
6226
6228{
6229 if (!writer.writeI32(feature)) {
6230 return false;
6231 }
6232 return true;
6233}
6234
6236{
6237 if (!readTag(reader)) {
6238 return false;
6239 }
6240 if (!readArgs(reader)) {
6241 return false;
6242 }
6243 return true;
6244}
6245
6247{
6248 std::string tag = reader.readTag(s_tag_len);
6249 if (reader.isError()) {
6250 return false;
6251 }
6252 if (tag != s_tag) {
6253 reader.fail();
6254 return false;
6255 }
6256 return true;
6257}
6258
6260{
6261 if (reader.noMore()) {
6262 reader.fail();
6263 return false;
6264 }
6265 if (!reader.readI32(feature)) {
6266 reader.fail();
6267 return false;
6268 }
6269 if (!reader.noMore()) {
6270 reader.fail();
6271 return false;
6272 }
6273 return true;
6274}
6275
6277{
6278 yarp::os::idl::WireWriter writer(connection);
6279 return write(writer);
6280}
6281
6283{
6284 yarp::os::idl::WireReader reader(connection);
6285 return read(reader);
6286}
6287
6289{
6290 if (!writer.isNull()) {
6291 if (!writer.writeListHeader(s_reply_len)) {
6292 return false;
6293 }
6294 if (!writer.write(return_helper)) {
6295 return false;
6296 }
6297 }
6298 return true;
6299}
6300
6302{
6303 if (!reader.readListReturn()) {
6304 return false;
6305 }
6306 if (reader.noMore()) {
6307 reader.fail();
6308 return false;
6309 }
6310 if (!reader.read(return_helper)) {
6311 reader.fail();
6312 return false;
6313 }
6314 return true;
6315}
6316
6321
6322// hasOnOffRPC helper class implementation
6324 cmd{feature}
6325{
6326}
6327
6329{
6330 return cmd.write(connection);
6331}
6332
6334{
6335 return reply.read(connection);
6336}
6337
6339 feature{feature}
6340{
6341}
6342
6344{
6345 yarp::os::idl::WireWriter writer(connection);
6346 if (!writer.writeListHeader(s_cmd_len)) {
6347 return false;
6348 }
6349 return write(writer);
6350}
6351
6353{
6354 yarp::os::idl::WireReader reader(connection);
6355 if (!reader.readListHeader()) {
6356 reader.fail();
6357 return false;
6358 }
6359 return read(reader);
6360}
6361
6363{
6364 if (!writeTag(writer)) {
6365 return false;
6366 }
6367 if (!writeArgs(writer)) {
6368 return false;
6369 }
6370 return true;
6371}
6372
6374{
6375 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6376 return false;
6377 }
6378 return true;
6379}
6380
6382{
6383 if (!writer.writeI32(feature)) {
6384 return false;
6385 }
6386 return true;
6387}
6388
6390{
6391 if (!readTag(reader)) {
6392 return false;
6393 }
6394 if (!readArgs(reader)) {
6395 return false;
6396 }
6397 return true;
6398}
6399
6401{
6402 std::string tag = reader.readTag(s_tag_len);
6403 if (reader.isError()) {
6404 return false;
6405 }
6406 if (tag != s_tag) {
6407 reader.fail();
6408 return false;
6409 }
6410 return true;
6411}
6412
6414{
6415 if (reader.noMore()) {
6416 reader.fail();
6417 return false;
6418 }
6419 if (!reader.readI32(feature)) {
6420 reader.fail();
6421 return false;
6422 }
6423 if (!reader.noMore()) {
6424 reader.fail();
6425 return false;
6426 }
6427 return true;
6428}
6429
6431{
6432 yarp::os::idl::WireWriter writer(connection);
6433 return write(writer);
6434}
6435
6437{
6438 yarp::os::idl::WireReader reader(connection);
6439 return read(reader);
6440}
6441
6443{
6444 if (!writer.isNull()) {
6445 if (!writer.writeListHeader(s_reply_len)) {
6446 return false;
6447 }
6448 if (!writer.write(return_helper)) {
6449 return false;
6450 }
6451 }
6452 return true;
6453}
6454
6456{
6457 if (!reader.readListReturn()) {
6458 return false;
6459 }
6460 if (reader.noMore()) {
6461 reader.fail();
6462 return false;
6463 }
6464 if (!reader.read(return_helper)) {
6465 reader.fail();
6466 return false;
6467 }
6468 return true;
6469}
6470
6475
6476// setActiveRPC helper class implementation
6478 cmd{feature, onoff}
6479{
6480}
6481
6483{
6484 return cmd.write(connection);
6485}
6486
6488{
6489 return reply.read(connection);
6490}
6491
6492FrameGrabberMsgs_setActiveRPC_helper::Command::Command(const std::int32_t feature, const bool onoff) :
6493 feature{feature},
6494 onoff{onoff}
6495{
6496}
6497
6499{
6500 yarp::os::idl::WireWriter writer(connection);
6501 if (!writer.writeListHeader(s_cmd_len)) {
6502 return false;
6503 }
6504 return write(writer);
6505}
6506
6508{
6509 yarp::os::idl::WireReader reader(connection);
6510 if (!reader.readListHeader()) {
6511 reader.fail();
6512 return false;
6513 }
6514 return read(reader);
6515}
6516
6518{
6519 if (!writeTag(writer)) {
6520 return false;
6521 }
6522 if (!writeArgs(writer)) {
6523 return false;
6524 }
6525 return true;
6526}
6527
6529{
6530 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6531 return false;
6532 }
6533 return true;
6534}
6535
6537{
6538 if (!writer.writeI32(feature)) {
6539 return false;
6540 }
6541 if (!writer.writeBool(onoff)) {
6542 return false;
6543 }
6544 return true;
6545}
6546
6548{
6549 if (!readTag(reader)) {
6550 return false;
6551 }
6552 if (!readArgs(reader)) {
6553 return false;
6554 }
6555 return true;
6556}
6557
6559{
6560 std::string tag = reader.readTag(s_tag_len);
6561 if (reader.isError()) {
6562 return false;
6563 }
6564 if (tag != s_tag) {
6565 reader.fail();
6566 return false;
6567 }
6568 return true;
6569}
6570
6572{
6573 if (reader.noMore()) {
6574 reader.fail();
6575 return false;
6576 }
6577 if (!reader.readI32(feature)) {
6578 reader.fail();
6579 return false;
6580 }
6581 if (reader.noMore()) {
6582 reader.fail();
6583 return false;
6584 }
6585 if (!reader.readBool(onoff)) {
6586 reader.fail();
6587 return false;
6588 }
6589 if (!reader.noMore()) {
6590 reader.fail();
6591 return false;
6592 }
6593 return true;
6594}
6595
6597{
6598 yarp::os::idl::WireWriter writer(connection);
6599 return write(writer);
6600}
6601
6603{
6604 yarp::os::idl::WireReader reader(connection);
6605 return read(reader);
6606}
6607
6609{
6610 if (!writer.isNull()) {
6611 if (!writer.write(return_helper)) {
6612 return false;
6613 }
6614 }
6615 return true;
6616}
6617
6619{
6620 if (reader.noMore()) {
6621 reader.fail();
6622 return false;
6623 }
6624 if (!reader.read(return_helper)) {
6625 reader.fail();
6626 return false;
6627 }
6628 return true;
6629}
6630
6635
6636// getActiveRPC helper class implementation
6638 cmd{feature}
6639{
6640}
6641
6643{
6644 return cmd.write(connection);
6645}
6646
6648{
6649 return reply.read(connection);
6650}
6651
6653 feature{feature}
6654{
6655}
6656
6658{
6659 yarp::os::idl::WireWriter writer(connection);
6660 if (!writer.writeListHeader(s_cmd_len)) {
6661 return false;
6662 }
6663 return write(writer);
6664}
6665
6667{
6668 yarp::os::idl::WireReader reader(connection);
6669 if (!reader.readListHeader()) {
6670 reader.fail();
6671 return false;
6672 }
6673 return read(reader);
6674}
6675
6677{
6678 if (!writeTag(writer)) {
6679 return false;
6680 }
6681 if (!writeArgs(writer)) {
6682 return false;
6683 }
6684 return true;
6685}
6686
6688{
6689 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6690 return false;
6691 }
6692 return true;
6693}
6694
6696{
6697 if (!writer.writeI32(feature)) {
6698 return false;
6699 }
6700 return true;
6701}
6702
6704{
6705 if (!readTag(reader)) {
6706 return false;
6707 }
6708 if (!readArgs(reader)) {
6709 return false;
6710 }
6711 return true;
6712}
6713
6715{
6716 std::string tag = reader.readTag(s_tag_len);
6717 if (reader.isError()) {
6718 return false;
6719 }
6720 if (tag != s_tag) {
6721 reader.fail();
6722 return false;
6723 }
6724 return true;
6725}
6726
6728{
6729 if (reader.noMore()) {
6730 reader.fail();
6731 return false;
6732 }
6733 if (!reader.readI32(feature)) {
6734 reader.fail();
6735 return false;
6736 }
6737 if (!reader.noMore()) {
6738 reader.fail();
6739 return false;
6740 }
6741 return true;
6742}
6743
6745{
6746 yarp::os::idl::WireWriter writer(connection);
6747 return write(writer);
6748}
6749
6751{
6752 yarp::os::idl::WireReader reader(connection);
6753 return read(reader);
6754}
6755
6757{
6758 if (!writer.isNull()) {
6759 if (!writer.writeListHeader(s_reply_len)) {
6760 return false;
6761 }
6762 if (!writer.write(return_helper)) {
6763 return false;
6764 }
6765 }
6766 return true;
6767}
6768
6770{
6771 if (!reader.readListReturn()) {
6772 return false;
6773 }
6774 if (reader.noMore()) {
6775 reader.fail();
6776 return false;
6777 }
6778 if (!reader.read(return_helper)) {
6779 reader.fail();
6780 return false;
6781 }
6782 return true;
6783}
6784
6789
6790// hasAutoRPC helper class implementation
6792 cmd{feature}
6793{
6794}
6795
6797{
6798 return cmd.write(connection);
6799}
6800
6802{
6803 return reply.read(connection);
6804}
6805
6807 feature{feature}
6808{
6809}
6810
6812{
6813 yarp::os::idl::WireWriter writer(connection);
6814 if (!writer.writeListHeader(s_cmd_len)) {
6815 return false;
6816 }
6817 return write(writer);
6818}
6819
6821{
6822 yarp::os::idl::WireReader reader(connection);
6823 if (!reader.readListHeader()) {
6824 reader.fail();
6825 return false;
6826 }
6827 return read(reader);
6828}
6829
6831{
6832 if (!writeTag(writer)) {
6833 return false;
6834 }
6835 if (!writeArgs(writer)) {
6836 return false;
6837 }
6838 return true;
6839}
6840
6842{
6843 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6844 return false;
6845 }
6846 return true;
6847}
6848
6850{
6851 if (!writer.writeI32(feature)) {
6852 return false;
6853 }
6854 return true;
6855}
6856
6858{
6859 if (!readTag(reader)) {
6860 return false;
6861 }
6862 if (!readArgs(reader)) {
6863 return false;
6864 }
6865 return true;
6866}
6867
6869{
6870 std::string tag = reader.readTag(s_tag_len);
6871 if (reader.isError()) {
6872 return false;
6873 }
6874 if (tag != s_tag) {
6875 reader.fail();
6876 return false;
6877 }
6878 return true;
6879}
6880
6882{
6883 if (reader.noMore()) {
6884 reader.fail();
6885 return false;
6886 }
6887 if (!reader.readI32(feature)) {
6888 reader.fail();
6889 return false;
6890 }
6891 if (!reader.noMore()) {
6892 reader.fail();
6893 return false;
6894 }
6895 return true;
6896}
6897
6899{
6900 yarp::os::idl::WireWriter writer(connection);
6901 return write(writer);
6902}
6903
6905{
6906 yarp::os::idl::WireReader reader(connection);
6907 return read(reader);
6908}
6909
6911{
6912 if (!writer.isNull()) {
6913 if (!writer.writeListHeader(s_reply_len)) {
6914 return false;
6915 }
6916 if (!writer.write(return_helper)) {
6917 return false;
6918 }
6919 }
6920 return true;
6921}
6922
6924{
6925 if (!reader.readListReturn()) {
6926 return false;
6927 }
6928 if (reader.noMore()) {
6929 reader.fail();
6930 return false;
6931 }
6932 if (!reader.read(return_helper)) {
6933 reader.fail();
6934 return false;
6935 }
6936 return true;
6937}
6938
6943
6944// hasManualRPC helper class implementation
6946 cmd{feature}
6947{
6948}
6949
6951{
6952 return cmd.write(connection);
6953}
6954
6956{
6957 return reply.read(connection);
6958}
6959
6961 feature{feature}
6962{
6963}
6964
6966{
6967 yarp::os::idl::WireWriter writer(connection);
6968 if (!writer.writeListHeader(s_cmd_len)) {
6969 return false;
6970 }
6971 return write(writer);
6972}
6973
6975{
6976 yarp::os::idl::WireReader reader(connection);
6977 if (!reader.readListHeader()) {
6978 reader.fail();
6979 return false;
6980 }
6981 return read(reader);
6982}
6983
6985{
6986 if (!writeTag(writer)) {
6987 return false;
6988 }
6989 if (!writeArgs(writer)) {
6990 return false;
6991 }
6992 return true;
6993}
6994
6996{
6997 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6998 return false;
6999 }
7000 return true;
7001}
7002
7004{
7005 if (!writer.writeI32(feature)) {
7006 return false;
7007 }
7008 return true;
7009}
7010
7012{
7013 if (!readTag(reader)) {
7014 return false;
7015 }
7016 if (!readArgs(reader)) {
7017 return false;
7018 }
7019 return true;
7020}
7021
7023{
7024 std::string tag = reader.readTag(s_tag_len);
7025 if (reader.isError()) {
7026 return false;
7027 }
7028 if (tag != s_tag) {
7029 reader.fail();
7030 return false;
7031 }
7032 return true;
7033}
7034
7036{
7037 if (reader.noMore()) {
7038 reader.fail();
7039 return false;
7040 }
7041 if (!reader.readI32(feature)) {
7042 reader.fail();
7043 return false;
7044 }
7045 if (!reader.noMore()) {
7046 reader.fail();
7047 return false;
7048 }
7049 return true;
7050}
7051
7053{
7054 yarp::os::idl::WireWriter writer(connection);
7055 return write(writer);
7056}
7057
7059{
7060 yarp::os::idl::WireReader reader(connection);
7061 return read(reader);
7062}
7063
7065{
7066 if (!writer.isNull()) {
7067 if (!writer.writeListHeader(s_reply_len)) {
7068 return false;
7069 }
7070 if (!writer.write(return_helper)) {
7071 return false;
7072 }
7073 }
7074 return true;
7075}
7076
7078{
7079 if (!reader.readListReturn()) {
7080 return false;
7081 }
7082 if (reader.noMore()) {
7083 reader.fail();
7084 return false;
7085 }
7086 if (!reader.read(return_helper)) {
7087 reader.fail();
7088 return false;
7089 }
7090 return true;
7091}
7092
7097
7098// hasOnePushRPC helper class implementation
7100 cmd{feature}
7101{
7102}
7103
7105{
7106 return cmd.write(connection);
7107}
7108
7110{
7111 return reply.read(connection);
7112}
7113
7115 feature{feature}
7116{
7117}
7118
7120{
7121 yarp::os::idl::WireWriter writer(connection);
7122 if (!writer.writeListHeader(s_cmd_len)) {
7123 return false;
7124 }
7125 return write(writer);
7126}
7127
7129{
7130 yarp::os::idl::WireReader reader(connection);
7131 if (!reader.readListHeader()) {
7132 reader.fail();
7133 return false;
7134 }
7135 return read(reader);
7136}
7137
7139{
7140 if (!writeTag(writer)) {
7141 return false;
7142 }
7143 if (!writeArgs(writer)) {
7144 return false;
7145 }
7146 return true;
7147}
7148
7150{
7151 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7152 return false;
7153 }
7154 return true;
7155}
7156
7158{
7159 if (!writer.writeI32(feature)) {
7160 return false;
7161 }
7162 return true;
7163}
7164
7166{
7167 if (!readTag(reader)) {
7168 return false;
7169 }
7170 if (!readArgs(reader)) {
7171 return false;
7172 }
7173 return true;
7174}
7175
7177{
7178 std::string tag = reader.readTag(s_tag_len);
7179 if (reader.isError()) {
7180 return false;
7181 }
7182 if (tag != s_tag) {
7183 reader.fail();
7184 return false;
7185 }
7186 return true;
7187}
7188
7190{
7191 if (reader.noMore()) {
7192 reader.fail();
7193 return false;
7194 }
7195 if (!reader.readI32(feature)) {
7196 reader.fail();
7197 return false;
7198 }
7199 if (!reader.noMore()) {
7200 reader.fail();
7201 return false;
7202 }
7203 return true;
7204}
7205
7207{
7208 yarp::os::idl::WireWriter writer(connection);
7209 return write(writer);
7210}
7211
7213{
7214 yarp::os::idl::WireReader reader(connection);
7215 return read(reader);
7216}
7217
7219{
7220 if (!writer.isNull()) {
7221 if (!writer.writeListHeader(s_reply_len)) {
7222 return false;
7223 }
7224 if (!writer.write(return_helper)) {
7225 return false;
7226 }
7227 }
7228 return true;
7229}
7230
7232{
7233 if (!reader.readListReturn()) {
7234 return false;
7235 }
7236 if (reader.noMore()) {
7237 reader.fail();
7238 return false;
7239 }
7240 if (!reader.read(return_helper)) {
7241 reader.fail();
7242 return false;
7243 }
7244 return true;
7245}
7246
7251
7252// setModeRPC helper class implementation
7254 cmd{feature, mode}
7255{
7256}
7257
7259{
7260 return cmd.write(connection);
7261}
7262
7264{
7265 return reply.read(connection);
7266}
7267
7269 feature{feature},
7270 mode{mode}
7271{
7272}
7273
7275{
7276 yarp::os::idl::WireWriter writer(connection);
7277 if (!writer.writeListHeader(s_cmd_len)) {
7278 return false;
7279 }
7280 return write(writer);
7281}
7282
7284{
7285 yarp::os::idl::WireReader reader(connection);
7286 if (!reader.readListHeader()) {
7287 reader.fail();
7288 return false;
7289 }
7290 return read(reader);
7291}
7292
7294{
7295 if (!writeTag(writer)) {
7296 return false;
7297 }
7298 if (!writeArgs(writer)) {
7299 return false;
7300 }
7301 return true;
7302}
7303
7305{
7306 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7307 return false;
7308 }
7309 return true;
7310}
7311
7313{
7314 if (!writer.writeI32(feature)) {
7315 return false;
7316 }
7317 if (!writer.writeI32(static_cast<int32_t>(mode))) {
7318 return false;
7319 }
7320 return true;
7321}
7322
7324{
7325 if (!readTag(reader)) {
7326 return false;
7327 }
7328 if (!readArgs(reader)) {
7329 return false;
7330 }
7331 return true;
7332}
7333
7335{
7336 std::string tag = reader.readTag(s_tag_len);
7337 if (reader.isError()) {
7338 return false;
7339 }
7340 if (tag != s_tag) {
7341 reader.fail();
7342 return false;
7343 }
7344 return true;
7345}
7346
7348{
7349 if (reader.noMore()) {
7350 reader.fail();
7351 return false;
7352 }
7353 if (!reader.readI32(feature)) {
7354 reader.fail();
7355 return false;
7356 }
7357 if (reader.noMore()) {
7358 reader.fail();
7359 return false;
7360 }
7361 int32_t _ecast;
7362 if (!reader.readI32(_ecast)) {
7363 reader.fail();
7364 return false;
7365 }
7366 mode = static_cast<yarp::dev::FeatureMode>(_ecast);
7367 if (!reader.noMore()) {
7368 reader.fail();
7369 return false;
7370 }
7371 return true;
7372}
7373
7375{
7376 yarp::os::idl::WireWriter writer(connection);
7377 return write(writer);
7378}
7379
7381{
7382 yarp::os::idl::WireReader reader(connection);
7383 return read(reader);
7384}
7385
7387{
7388 if (!writer.isNull()) {
7389 if (!writer.write(return_helper)) {
7390 return false;
7391 }
7392 }
7393 return true;
7394}
7395
7397{
7398 if (reader.noMore()) {
7399 reader.fail();
7400 return false;
7401 }
7402 if (!reader.read(return_helper)) {
7403 reader.fail();
7404 return false;
7405 }
7406 return true;
7407}
7408
7413
7414// getModeRPC helper class implementation
7416 cmd{feature}
7417{
7418}
7419
7421{
7422 return cmd.write(connection);
7423}
7424
7426{
7427 return reply.read(connection);
7428}
7429
7431 feature{feature}
7432{
7433}
7434
7436{
7437 yarp::os::idl::WireWriter writer(connection);
7438 if (!writer.writeListHeader(s_cmd_len)) {
7439 return false;
7440 }
7441 return write(writer);
7442}
7443
7445{
7446 yarp::os::idl::WireReader reader(connection);
7447 if (!reader.readListHeader()) {
7448 reader.fail();
7449 return false;
7450 }
7451 return read(reader);
7452}
7453
7455{
7456 if (!writeTag(writer)) {
7457 return false;
7458 }
7459 if (!writeArgs(writer)) {
7460 return false;
7461 }
7462 return true;
7463}
7464
7466{
7467 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7468 return false;
7469 }
7470 return true;
7471}
7472
7474{
7475 if (!writer.writeI32(feature)) {
7476 return false;
7477 }
7478 return true;
7479}
7480
7482{
7483 if (!readTag(reader)) {
7484 return false;
7485 }
7486 if (!readArgs(reader)) {
7487 return false;
7488 }
7489 return true;
7490}
7491
7493{
7494 std::string tag = reader.readTag(s_tag_len);
7495 if (reader.isError()) {
7496 return false;
7497 }
7498 if (tag != s_tag) {
7499 reader.fail();
7500 return false;
7501 }
7502 return true;
7503}
7504
7506{
7507 if (reader.noMore()) {
7508 reader.fail();
7509 return false;
7510 }
7511 if (!reader.readI32(feature)) {
7512 reader.fail();
7513 return false;
7514 }
7515 if (!reader.noMore()) {
7516 reader.fail();
7517 return false;
7518 }
7519 return true;
7520}
7521
7523{
7524 yarp::os::idl::WireWriter writer(connection);
7525 return write(writer);
7526}
7527
7529{
7530 yarp::os::idl::WireReader reader(connection);
7531 return read(reader);
7532}
7533
7535{
7536 if (!writer.isNull()) {
7537 if (!writer.writeListHeader(s_reply_len)) {
7538 return false;
7539 }
7540 if (!writer.write(return_helper)) {
7541 return false;
7542 }
7543 }
7544 return true;
7545}
7546
7548{
7549 if (!reader.readListReturn()) {
7550 return false;
7551 }
7552 if (reader.noMore()) {
7553 reader.fail();
7554 return false;
7555 }
7556 if (!reader.read(return_helper)) {
7557 reader.fail();
7558 return false;
7559 }
7560 return true;
7561}
7562
7567
7568// setOnePushRPC helper class implementation
7570 cmd{feature}
7571{
7572}
7573
7575{
7576 return cmd.write(connection);
7577}
7578
7580{
7581 return reply.read(connection);
7582}
7583
7585 feature{feature}
7586{
7587}
7588
7590{
7591 yarp::os::idl::WireWriter writer(connection);
7592 if (!writer.writeListHeader(s_cmd_len)) {
7593 return false;
7594 }
7595 return write(writer);
7596}
7597
7599{
7600 yarp::os::idl::WireReader reader(connection);
7601 if (!reader.readListHeader()) {
7602 reader.fail();
7603 return false;
7604 }
7605 return read(reader);
7606}
7607
7609{
7610 if (!writeTag(writer)) {
7611 return false;
7612 }
7613 if (!writeArgs(writer)) {
7614 return false;
7615 }
7616 return true;
7617}
7618
7620{
7621 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7622 return false;
7623 }
7624 return true;
7625}
7626
7628{
7629 if (!writer.writeI32(feature)) {
7630 return false;
7631 }
7632 return true;
7633}
7634
7636{
7637 if (!readTag(reader)) {
7638 return false;
7639 }
7640 if (!readArgs(reader)) {
7641 return false;
7642 }
7643 return true;
7644}
7645
7647{
7648 std::string tag = reader.readTag(s_tag_len);
7649 if (reader.isError()) {
7650 return false;
7651 }
7652 if (tag != s_tag) {
7653 reader.fail();
7654 return false;
7655 }
7656 return true;
7657}
7658
7660{
7661 if (reader.noMore()) {
7662 reader.fail();
7663 return false;
7664 }
7665 if (!reader.readI32(feature)) {
7666 reader.fail();
7667 return false;
7668 }
7669 if (!reader.noMore()) {
7670 reader.fail();
7671 return false;
7672 }
7673 return true;
7674}
7675
7677{
7678 yarp::os::idl::WireWriter writer(connection);
7679 return write(writer);
7680}
7681
7683{
7684 yarp::os::idl::WireReader reader(connection);
7685 return read(reader);
7686}
7687
7689{
7690 if (!writer.isNull()) {
7691 if (!writer.write(return_helper)) {
7692 return false;
7693 }
7694 }
7695 return true;
7696}
7697
7699{
7700 if (reader.noMore()) {
7701 reader.fail();
7702 return false;
7703 }
7704 if (!reader.read(return_helper)) {
7705 reader.fail();
7706 return false;
7707 }
7708 return true;
7709}
7710
7715
7716// getVideoModeMaskDC1394RPC helper class implementation
7718{
7719 return cmd.write(connection);
7720}
7721
7726
7728{
7729 yarp::os::idl::WireWriter writer(connection);
7730 if (!writer.writeListHeader(s_cmd_len)) {
7731 return false;
7732 }
7733 return write(writer);
7734}
7735
7737{
7738 yarp::os::idl::WireReader reader(connection);
7739 if (!reader.readListHeader()) {
7740 reader.fail();
7741 return false;
7742 }
7743 return read(reader);
7744}
7745
7747{
7748 if (!writeTag(writer)) {
7749 return false;
7750 }
7751 if (!writeArgs(writer)) {
7752 return false;
7753 }
7754 return true;
7755}
7756
7758{
7759 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7760 return false;
7761 }
7762 return true;
7763}
7764
7766{
7767 return true;
7768}
7769
7771{
7772 if (!readTag(reader)) {
7773 return false;
7774 }
7775 if (!readArgs(reader)) {
7776 return false;
7777 }
7778 return true;
7779}
7780
7782{
7783 std::string tag = reader.readTag(s_tag_len);
7784 if (reader.isError()) {
7785 return false;
7786 }
7787 if (tag != s_tag) {
7788 reader.fail();
7789 return false;
7790 }
7791 return true;
7792}
7793
7795{
7796 if (!reader.noMore()) {
7797 reader.fail();
7798 return false;
7799 }
7800 return true;
7801}
7802
7804{
7805 yarp::os::idl::WireWriter writer(connection);
7806 return write(writer);
7807}
7808
7814
7816{
7817 if (!writer.isNull()) {
7818 if (!writer.writeListHeader(s_reply_len)) {
7819 return false;
7820 }
7821 if (!writer.write(return_helper)) {
7822 return false;
7823 }
7824 }
7825 return true;
7826}
7827
7829{
7830 if (!reader.readListReturn()) {
7831 return false;
7832 }
7833 if (reader.noMore()) {
7834 reader.fail();
7835 return false;
7836 }
7837 if (!reader.read(return_helper)) {
7838 reader.fail();
7839 return false;
7840 }
7841 return true;
7842}
7843
7848
7849// getVideoModeDC1394RPC helper class implementation
7851{
7852 return cmd.write(connection);
7853}
7854
7859
7861{
7862 yarp::os::idl::WireWriter writer(connection);
7863 if (!writer.writeListHeader(s_cmd_len)) {
7864 return false;
7865 }
7866 return write(writer);
7867}
7868
7870{
7871 yarp::os::idl::WireReader reader(connection);
7872 if (!reader.readListHeader()) {
7873 reader.fail();
7874 return false;
7875 }
7876 return read(reader);
7877}
7878
7880{
7881 if (!writeTag(writer)) {
7882 return false;
7883 }
7884 if (!writeArgs(writer)) {
7885 return false;
7886 }
7887 return true;
7888}
7889
7891{
7892 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7893 return false;
7894 }
7895 return true;
7896}
7897
7899{
7900 return true;
7901}
7902
7904{
7905 if (!readTag(reader)) {
7906 return false;
7907 }
7908 if (!readArgs(reader)) {
7909 return false;
7910 }
7911 return true;
7912}
7913
7915{
7916 std::string tag = reader.readTag(s_tag_len);
7917 if (reader.isError()) {
7918 return false;
7919 }
7920 if (tag != s_tag) {
7921 reader.fail();
7922 return false;
7923 }
7924 return true;
7925}
7926
7928{
7929 if (!reader.noMore()) {
7930 reader.fail();
7931 return false;
7932 }
7933 return true;
7934}
7935
7937{
7938 yarp::os::idl::WireWriter writer(connection);
7939 return write(writer);
7940}
7941
7943{
7944 yarp::os::idl::WireReader reader(connection);
7945 return read(reader);
7946}
7947
7949{
7950 if (!writer.isNull()) {
7951 if (!writer.writeListHeader(s_reply_len)) {
7952 return false;
7953 }
7954 if (!writer.write(return_helper)) {
7955 return false;
7956 }
7957 }
7958 return true;
7959}
7960
7962{
7963 if (!reader.readListReturn()) {
7964 return false;
7965 }
7966 if (reader.noMore()) {
7967 reader.fail();
7968 return false;
7969 }
7970 if (!reader.read(return_helper)) {
7971 reader.fail();
7972 return false;
7973 }
7974 return true;
7975}
7976
7981
7982// setVideoModeDC1394RPC helper class implementation
7987
7989{
7990 return cmd.write(connection);
7991}
7992
7997
7999 videomode{videomode}
8000{
8001}
8002
8004{
8005 yarp::os::idl::WireWriter writer(connection);
8006 if (!writer.writeListHeader(s_cmd_len)) {
8007 return false;
8008 }
8009 return write(writer);
8010}
8011
8013{
8014 yarp::os::idl::WireReader reader(connection);
8015 if (!reader.readListHeader()) {
8016 reader.fail();
8017 return false;
8018 }
8019 return read(reader);
8020}
8021
8023{
8024 if (!writeTag(writer)) {
8025 return false;
8026 }
8027 if (!writeArgs(writer)) {
8028 return false;
8029 }
8030 return true;
8031}
8032
8034{
8035 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8036 return false;
8037 }
8038 return true;
8039}
8040
8042{
8043 if (!writer.writeI32(videomode)) {
8044 return false;
8045 }
8046 return true;
8047}
8048
8050{
8051 if (!readTag(reader)) {
8052 return false;
8053 }
8054 if (!readArgs(reader)) {
8055 return false;
8056 }
8057 return true;
8058}
8059
8061{
8062 std::string tag = reader.readTag(s_tag_len);
8063 if (reader.isError()) {
8064 return false;
8065 }
8066 if (tag != s_tag) {
8067 reader.fail();
8068 return false;
8069 }
8070 return true;
8071}
8072
8074{
8075 if (reader.noMore()) {
8076 reader.fail();
8077 return false;
8078 }
8079 if (!reader.readI32(videomode)) {
8080 reader.fail();
8081 return false;
8082 }
8083 if (!reader.noMore()) {
8084 reader.fail();
8085 return false;
8086 }
8087 return true;
8088}
8089
8091{
8092 yarp::os::idl::WireWriter writer(connection);
8093 return write(writer);
8094}
8095
8097{
8098 yarp::os::idl::WireReader reader(connection);
8099 return read(reader);
8100}
8101
8103{
8104 if (!writer.isNull()) {
8105 if (!writer.write(return_helper)) {
8106 return false;
8107 }
8108 }
8109 return true;
8110}
8111
8113{
8114 if (reader.noMore()) {
8115 reader.fail();
8116 return false;
8117 }
8118 if (!reader.read(return_helper)) {
8119 reader.fail();
8120 return false;
8121 }
8122 return true;
8123}
8124
8129
8130// getFPSMaskDC1394RPC helper class implementation
8132{
8133 return cmd.write(connection);
8134}
8135
8140
8142{
8143 yarp::os::idl::WireWriter writer(connection);
8144 if (!writer.writeListHeader(s_cmd_len)) {
8145 return false;
8146 }
8147 return write(writer);
8148}
8149
8151{
8152 yarp::os::idl::WireReader reader(connection);
8153 if (!reader.readListHeader()) {
8154 reader.fail();
8155 return false;
8156 }
8157 return read(reader);
8158}
8159
8161{
8162 if (!writeTag(writer)) {
8163 return false;
8164 }
8165 if (!writeArgs(writer)) {
8166 return false;
8167 }
8168 return true;
8169}
8170
8172{
8173 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8174 return false;
8175 }
8176 return true;
8177}
8178
8180{
8181 return true;
8182}
8183
8185{
8186 if (!readTag(reader)) {
8187 return false;
8188 }
8189 if (!readArgs(reader)) {
8190 return false;
8191 }
8192 return true;
8193}
8194
8196{
8197 std::string tag = reader.readTag(s_tag_len);
8198 if (reader.isError()) {
8199 return false;
8200 }
8201 if (tag != s_tag) {
8202 reader.fail();
8203 return false;
8204 }
8205 return true;
8206}
8207
8209{
8210 if (!reader.noMore()) {
8211 reader.fail();
8212 return false;
8213 }
8214 return true;
8215}
8216
8218{
8219 yarp::os::idl::WireWriter writer(connection);
8220 return write(writer);
8221}
8222
8224{
8225 yarp::os::idl::WireReader reader(connection);
8226 return read(reader);
8227}
8228
8230{
8231 if (!writer.isNull()) {
8232 if (!writer.writeListHeader(s_reply_len)) {
8233 return false;
8234 }
8235 if (!writer.write(return_helper)) {
8236 return false;
8237 }
8238 }
8239 return true;
8240}
8241
8243{
8244 if (!reader.readListReturn()) {
8245 return false;
8246 }
8247 if (reader.noMore()) {
8248 reader.fail();
8249 return false;
8250 }
8251 if (!reader.read(return_helper)) {
8252 reader.fail();
8253 return false;
8254 }
8255 return true;
8256}
8257
8262
8263// getFPSDC1394RPC helper class implementation
8265{
8266 return cmd.write(connection);
8267}
8268
8270{
8271 return reply.read(connection);
8272}
8273
8275{
8276 yarp::os::idl::WireWriter writer(connection);
8277 if (!writer.writeListHeader(s_cmd_len)) {
8278 return false;
8279 }
8280 return write(writer);
8281}
8282
8284{
8285 yarp::os::idl::WireReader reader(connection);
8286 if (!reader.readListHeader()) {
8287 reader.fail();
8288 return false;
8289 }
8290 return read(reader);
8291}
8292
8294{
8295 if (!writeTag(writer)) {
8296 return false;
8297 }
8298 if (!writeArgs(writer)) {
8299 return false;
8300 }
8301 return true;
8302}
8303
8305{
8306 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8307 return false;
8308 }
8309 return true;
8310}
8311
8313{
8314 return true;
8315}
8316
8318{
8319 if (!readTag(reader)) {
8320 return false;
8321 }
8322 if (!readArgs(reader)) {
8323 return false;
8324 }
8325 return true;
8326}
8327
8329{
8330 std::string tag = reader.readTag(s_tag_len);
8331 if (reader.isError()) {
8332 return false;
8333 }
8334 if (tag != s_tag) {
8335 reader.fail();
8336 return false;
8337 }
8338 return true;
8339}
8340
8342{
8343 if (!reader.noMore()) {
8344 reader.fail();
8345 return false;
8346 }
8347 return true;
8348}
8349
8351{
8352 yarp::os::idl::WireWriter writer(connection);
8353 return write(writer);
8354}
8355
8357{
8358 yarp::os::idl::WireReader reader(connection);
8359 return read(reader);
8360}
8361
8363{
8364 if (!writer.isNull()) {
8365 if (!writer.writeListHeader(s_reply_len)) {
8366 return false;
8367 }
8368 if (!writer.write(return_helper)) {
8369 return false;
8370 }
8371 }
8372 return true;
8373}
8374
8376{
8377 if (!reader.readListReturn()) {
8378 return false;
8379 }
8380 if (reader.noMore()) {
8381 reader.fail();
8382 return false;
8383 }
8384 if (!reader.read(return_helper)) {
8385 reader.fail();
8386 return false;
8387 }
8388 return true;
8389}
8390
8395
8396// setFPSDC1394RPC helper class implementation
8401
8403{
8404 return cmd.write(connection);
8405}
8406
8408{
8409 return reply.read(connection);
8410}
8411
8416
8418{
8419 yarp::os::idl::WireWriter writer(connection);
8420 if (!writer.writeListHeader(s_cmd_len)) {
8421 return false;
8422 }
8423 return write(writer);
8424}
8425
8427{
8428 yarp::os::idl::WireReader reader(connection);
8429 if (!reader.readListHeader()) {
8430 reader.fail();
8431 return false;
8432 }
8433 return read(reader);
8434}
8435
8437{
8438 if (!writeTag(writer)) {
8439 return false;
8440 }
8441 if (!writeArgs(writer)) {
8442 return false;
8443 }
8444 return true;
8445}
8446
8448{
8449 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8450 return false;
8451 }
8452 return true;
8453}
8454
8456{
8457 if (!writer.writeI32(fps)) {
8458 return false;
8459 }
8460 return true;
8461}
8462
8464{
8465 if (!readTag(reader)) {
8466 return false;
8467 }
8468 if (!readArgs(reader)) {
8469 return false;
8470 }
8471 return true;
8472}
8473
8475{
8476 std::string tag = reader.readTag(s_tag_len);
8477 if (reader.isError()) {
8478 return false;
8479 }
8480 if (tag != s_tag) {
8481 reader.fail();
8482 return false;
8483 }
8484 return true;
8485}
8486
8488{
8489 if (reader.noMore()) {
8490 reader.fail();
8491 return false;
8492 }
8493 if (!reader.readI32(fps)) {
8494 reader.fail();
8495 return false;
8496 }
8497 if (!reader.noMore()) {
8498 reader.fail();
8499 return false;
8500 }
8501 return true;
8502}
8503
8505{
8506 yarp::os::idl::WireWriter writer(connection);
8507 return write(writer);
8508}
8509
8511{
8512 yarp::os::idl::WireReader reader(connection);
8513 return read(reader);
8514}
8515
8517{
8518 if (!writer.isNull()) {
8519 if (!writer.write(return_helper)) {
8520 return false;
8521 }
8522 }
8523 return true;
8524}
8525
8527{
8528 if (reader.noMore()) {
8529 reader.fail();
8530 return false;
8531 }
8532 if (!reader.read(return_helper)) {
8533 reader.fail();
8534 return false;
8535 }
8536 return true;
8537}
8538
8543
8544// getISOSpeedDC1394RPC helper class implementation
8546{
8547 return cmd.write(connection);
8548}
8549
8554
8556{
8557 yarp::os::idl::WireWriter writer(connection);
8558 if (!writer.writeListHeader(s_cmd_len)) {
8559 return false;
8560 }
8561 return write(writer);
8562}
8563
8565{
8566 yarp::os::idl::WireReader reader(connection);
8567 if (!reader.readListHeader()) {
8568 reader.fail();
8569 return false;
8570 }
8571 return read(reader);
8572}
8573
8575{
8576 if (!writeTag(writer)) {
8577 return false;
8578 }
8579 if (!writeArgs(writer)) {
8580 return false;
8581 }
8582 return true;
8583}
8584
8586{
8587 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8588 return false;
8589 }
8590 return true;
8591}
8592
8594{
8595 return true;
8596}
8597
8599{
8600 if (!readTag(reader)) {
8601 return false;
8602 }
8603 if (!readArgs(reader)) {
8604 return false;
8605 }
8606 return true;
8607}
8608
8610{
8611 std::string tag = reader.readTag(s_tag_len);
8612 if (reader.isError()) {
8613 return false;
8614 }
8615 if (tag != s_tag) {
8616 reader.fail();
8617 return false;
8618 }
8619 return true;
8620}
8621
8623{
8624 if (!reader.noMore()) {
8625 reader.fail();
8626 return false;
8627 }
8628 return true;
8629}
8630
8632{
8633 yarp::os::idl::WireWriter writer(connection);
8634 return write(writer);
8635}
8636
8638{
8639 yarp::os::idl::WireReader reader(connection);
8640 return read(reader);
8641}
8642
8644{
8645 if (!writer.isNull()) {
8646 if (!writer.writeListHeader(s_reply_len)) {
8647 return false;
8648 }
8649 if (!writer.write(return_helper)) {
8650 return false;
8651 }
8652 }
8653 return true;
8654}
8655
8657{
8658 if (!reader.readListReturn()) {
8659 return false;
8660 }
8661 if (reader.noMore()) {
8662 reader.fail();
8663 return false;
8664 }
8665 if (!reader.read(return_helper)) {
8666 reader.fail();
8667 return false;
8668 }
8669 return true;
8670}
8671
8676
8677// setISOSpeedDC1394RPC helper class implementation
8682
8684{
8685 return cmd.write(connection);
8686}
8687
8692
8694 speed{speed}
8695{
8696}
8697
8699{
8700 yarp::os::idl::WireWriter writer(connection);
8701 if (!writer.writeListHeader(s_cmd_len)) {
8702 return false;
8703 }
8704 return write(writer);
8705}
8706
8708{
8709 yarp::os::idl::WireReader reader(connection);
8710 if (!reader.readListHeader()) {
8711 reader.fail();
8712 return false;
8713 }
8714 return read(reader);
8715}
8716
8718{
8719 if (!writeTag(writer)) {
8720 return false;
8721 }
8722 if (!writeArgs(writer)) {
8723 return false;
8724 }
8725 return true;
8726}
8727
8729{
8730 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8731 return false;
8732 }
8733 return true;
8734}
8735
8737{
8738 if (!writer.writeI32(speed)) {
8739 return false;
8740 }
8741 return true;
8742}
8743
8745{
8746 if (!readTag(reader)) {
8747 return false;
8748 }
8749 if (!readArgs(reader)) {
8750 return false;
8751 }
8752 return true;
8753}
8754
8756{
8757 std::string tag = reader.readTag(s_tag_len);
8758 if (reader.isError()) {
8759 return false;
8760 }
8761 if (tag != s_tag) {
8762 reader.fail();
8763 return false;
8764 }
8765 return true;
8766}
8767
8769{
8770 if (reader.noMore()) {
8771 reader.fail();
8772 return false;
8773 }
8774 if (!reader.readI32(speed)) {
8775 reader.fail();
8776 return false;
8777 }
8778 if (!reader.noMore()) {
8779 reader.fail();
8780 return false;
8781 }
8782 return true;
8783}
8784
8786{
8787 yarp::os::idl::WireWriter writer(connection);
8788 return write(writer);
8789}
8790
8792{
8793 yarp::os::idl::WireReader reader(connection);
8794 return read(reader);
8795}
8796
8798{
8799 if (!writer.isNull()) {
8800 if (!writer.write(return_helper)) {
8801 return false;
8802 }
8803 }
8804 return true;
8805}
8806
8808{
8809 if (reader.noMore()) {
8810 reader.fail();
8811 return false;
8812 }
8813 if (!reader.read(return_helper)) {
8814 reader.fail();
8815 return false;
8816 }
8817 return true;
8818}
8819
8824
8825// getColorCodingMaskDC1394RPC helper class implementation
8830
8832{
8833 return cmd.write(connection);
8834}
8835
8840
8842 videomode{videomode}
8843{
8844}
8845
8847{
8848 yarp::os::idl::WireWriter writer(connection);
8849 if (!writer.writeListHeader(s_cmd_len)) {
8850 return false;
8851 }
8852 return write(writer);
8853}
8854
8856{
8857 yarp::os::idl::WireReader reader(connection);
8858 if (!reader.readListHeader()) {
8859 reader.fail();
8860 return false;
8861 }
8862 return read(reader);
8863}
8864
8866{
8867 if (!writeTag(writer)) {
8868 return false;
8869 }
8870 if (!writeArgs(writer)) {
8871 return false;
8872 }
8873 return true;
8874}
8875
8877{
8878 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8879 return false;
8880 }
8881 return true;
8882}
8883
8885{
8886 if (!writer.writeI32(videomode)) {
8887 return false;
8888 }
8889 return true;
8890}
8891
8893{
8894 if (!readTag(reader)) {
8895 return false;
8896 }
8897 if (!readArgs(reader)) {
8898 return false;
8899 }
8900 return true;
8901}
8902
8904{
8905 std::string tag = reader.readTag(s_tag_len);
8906 if (reader.isError()) {
8907 return false;
8908 }
8909 if (tag != s_tag) {
8910 reader.fail();
8911 return false;
8912 }
8913 return true;
8914}
8915
8917{
8918 if (reader.noMore()) {
8919 reader.fail();
8920 return false;
8921 }
8922 if (!reader.readI32(videomode)) {
8923 reader.fail();
8924 return false;
8925 }
8926 if (!reader.noMore()) {
8927 reader.fail();
8928 return false;
8929 }
8930 return true;
8931}
8932
8934{
8935 yarp::os::idl::WireWriter writer(connection);
8936 return write(writer);
8937}
8938
8944
8946{
8947 if (!writer.isNull()) {
8948 if (!writer.writeListHeader(s_reply_len)) {
8949 return false;
8950 }
8951 if (!writer.write(return_helper)) {
8952 return false;
8953 }
8954 }
8955 return true;
8956}
8957
8959{
8960 if (!reader.readListReturn()) {
8961 return false;
8962 }
8963 if (reader.noMore()) {
8964 reader.fail();
8965 return false;
8966 }
8967 if (!reader.read(return_helper)) {
8968 reader.fail();
8969 return false;
8970 }
8971 return true;
8972}
8973
8978
8979// getColorCodingDC1394RPC helper class implementation
8981{
8982 return cmd.write(connection);
8983}
8984
8989
8991{
8992 yarp::os::idl::WireWriter writer(connection);
8993 if (!writer.writeListHeader(s_cmd_len)) {
8994 return false;
8995 }
8996 return write(writer);
8997}
8998
9000{
9001 yarp::os::idl::WireReader reader(connection);
9002 if (!reader.readListHeader()) {
9003 reader.fail();
9004 return false;
9005 }
9006 return read(reader);
9007}
9008
9010{
9011 if (!writeTag(writer)) {
9012 return false;
9013 }
9014 if (!writeArgs(writer)) {
9015 return false;
9016 }
9017 return true;
9018}
9019
9021{
9022 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
9023 return false;
9024 }
9025 return true;
9026}
9027
9029{
9030 return true;
9031}
9032
9034{
9035 if (!readTag(reader)) {
9036 return false;
9037 }
9038 if (!readArgs(reader)) {
9039 return false;
9040 }
9041 return true;
9042}
9043
9045{
9046 std::string tag = reader.readTag(s_tag_len);
9047 if (reader.isError()) {
9048 return false;
9049 }
9050 if (tag != s_tag) {
9051 reader.fail();
9052 return false;
9053 }
9054 return true;
9055}
9056
9058{
9059 if (!reader.noMore()) {
9060 reader.fail();
9061 return false;
9062 }
9063 return true;
9064}
9065
9067{
9068 yarp::os::idl::WireWriter writer(connection);
9069 return write(writer);
9070}
9071
9073{
9074 yarp::os::idl::WireReader reader(connection);
9075 return read(reader);
9076}
9077
9079{
9080 if (!writer.isNull()) {
9081 if (!writer.writeListHeader(s_reply_len)) {
9082 return false;
9083 }
9084 if (!writer.write(return_helper)) {
9085 return false;
9086 }
9087 }
9088 return true;
9089}
9090
9092{
9093 if (!reader.readListReturn()) {
9094 return false;
9095 }
9096 if (reader.noMore()) {
9097 reader.fail();
9098 return false;
9099 }
9100 if (!reader.read(return_helper)) {
9101 reader.fail();
9102 return false;
9103 }
9104 return true;
9105}
9106
9111
9112// setColorCodingDC1394RPC helper class implementation
9117
9119{
9120 return cmd.write(connection);
9121}
9122
9127
9129 coding{coding}
9130{
9131}
9132
9134{
9135 yarp::os::idl::WireWriter writer(connection);
9136 if (!writer.writeListHeader(s_cmd_len)) {
9137 return false;
9138 }
9139 return write(writer);
9140}
9141
9143{
9144 yarp::os::idl::WireReader reader(connection);
9145 if (!reader.readListHeader()) {
9146 reader.fail();
9147 return false;
9148 }
9149 return read(reader);
9150}
9151
9153{
9154 if (!writeTag(writer)) {
9155 return false;
9156 }
9157 if (!writeArgs(writer)) {
9158 return false;
9159 }
9160 return true;
9161}
9162
9164{
9165 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
9166 return false;
9167 }
9168 return true;
9169}
9170
9172{
9173 if (!writer.writeI32(coding)) {
9174 return false;
9175 }
9176 return true;
9177}
9178
9180{
9181 if (!readTag(reader)) {
9182 return false;
9183 }
9184 if (!readArgs(reader)) {
9185 return false;
9186 }
9187 return true;
9188}
9189
9191{
9192 std::string tag = reader.readTag(s_tag_len);
9193 if (reader.isError()) {
9194 return false;
9195 }
9196 if (tag != s_tag) {
9197 reader.fail();
9198 return false;
9199 }
9200 return true;
9201}
9202
9204{
9205 if (reader.noMore()) {
9206 reader.fail();
9207 return false;
9208 }
9209 if (!reader.readI32(coding)) {
9210 reader.fail();
9211 return false;
9212 }
9213 if (!reader.noMore()) {
9214 reader.fail();
9215 return false;
9216 }
9217 return true;
9218}
9219
9221{
9222 yarp::os::idl::WireWriter writer(connection);
9223 return write(writer);
9224}
9225
9227{
9228 yarp::os::idl::WireReader reader(connection);
9229 return read(reader);
9230}
9231
9233{
9234 if (!writer.isNull()) {
9235 if (!writer.write(return_helper)) {
9236 return false;
9237 }
9238 }
9239 return true;
9240}
9241
9243{
9244 if (reader.noMore()) {
9245 reader.fail();
9246 return false;
9247 }
9248 if (!reader.read(return_helper)) {
9249 reader.fail();
9250 return false;
9251 }
9252 return true;
9253}
9254
9259
9260// getFormat7MaxWindowDC1394RPC helper class implementation
9265
9270
9272{
9273 yarp::os::idl::WireWriter writer(connection);
9274 if (!writer.writeListHeader(s_cmd_len)) {
9275 return false;
9276 }
9277 return write(writer);
9278}
9279
9281{
9282 yarp::os::idl::WireReader reader(connection);
9283 if (!reader.readListHeader()) {
9284 reader.fail();
9285 return false;
9286 }
9287 return read(reader);
9288}
9289
9291{
9292 if (!writeTag(writer)) {
9293 return false;
9294 }
9295 if (!writeArgs(writer)) {
9296 return false;
9297 }
9298 return true;
9299}
9300
9302{
9303 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
9304 return false;
9305 }
9306 return true;
9307}
9308
9310{
9311 return true;
9312}
9313
9315{
9316 if (!readTag(reader)) {
9317 return false;
9318 }
9319 if (!readArgs(reader)) {
9320 return false;
9321 }
9322 return true;
9323}
9324
9326{
9327 std::string tag = reader.readTag(s_tag_len);
9328 if (reader.isError()) {
9329 return false;
9330 }
9331 if (tag != s_tag) {
9332 reader.fail();
9333 return false;
9334 }
9335 return true;
9336}
9337
9339{
9340 if (!reader.noMore()) {
9341 reader.fail();
9342 return false;
9343 }
9344 return true;
9345}
9346
9348{
9349 yarp::os::idl::WireWriter writer(connection);
9350 return write(writer);
9351}
9352
9358
9360{
9361 if (!writer.isNull()) {
9362 if (!writer.writeListHeader(s_reply_len)) {
9363 return false;
9364 }
9365 if (!writer.write(return_helper)) {
9366 return false;
9367 }
9368 }
9369 return true;
9370}
9371
9373{
9374 if (!reader.readListReturn()) {
9375 return false;
9376 }
9377 if (reader.noMore()) {
9378 reader.fail();
9379 return false;
9380 }
9381 if (!reader.read(return_helper)) {
9382 reader.fail();
9383 return false;
9384 }
9385 return true;
9386}
9387
9392
9393// getFormat7WindowDC1394RPC helper class implementation
9395{
9396 return cmd.write(connection);
9397}
9398
9403
9405{
9406 yarp::os::idl::WireWriter writer(connection);
9407 if (!writer.writeListHeader(s_cmd_len)) {
9408 return false;
9409 }
9410 return write(writer);
9411}
9412
9414{
9415 yarp::os::idl::WireReader reader(connection);
9416 if (!reader.readListHeader()) {
9417 reader.fail();
9418 return false;
9419 }
9420 return read(reader);
9421}
9422
9424{
9425 if (!writeTag(writer)) {
9426 return false;
9427 }
9428 if (!writeArgs(writer)) {
9429 return false;
9430 }
9431 return true;
9432}
9433
9435{
9436 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
9437 return false;
9438 }
9439 return true;
9440}
9441
9443{
9444 return true;
9445}
9446
9448{
9449 if (!readTag(reader)) {
9450 return false;
9451 }
9452 if (!readArgs(reader)) {
9453 return false;
9454 }
9455 return true;
9456}
9457
9459{
9460 std::string tag = reader.readTag(s_tag_len);
9461 if (reader.isError()) {
9462 return false;
9463 }
9464 if (tag != s_tag) {
9465 reader.fail();
9466 return false;
9467 }
9468 return true;
9469}
9470
9472{
9473 if (!reader.noMore()) {
9474 reader.fail();
9475 return false;
9476 }
9477 return true;
9478}
9479
9481{
9482 yarp::os::idl::WireWriter writer(connection);
9483 return write(writer);
9484}
9485
9491
9493{
9494 if (!writer.isNull()) {
9495 if (!writer.writeListHeader(s_reply_len)) {
9496 return false;
9497 }
9498 if (!writer.write(return_helper)) {
9499 return false;
9500 }
9501 }
9502 return true;
9503}
9504
9506{
9507 if (!reader.readListReturn()) {
9508 return false;
9509 }
9510 if (reader.noMore()) {
9511 reader.fail();
9512 return false;
9513 }
9514 if (!reader.read(return_helper)) {
9515 reader.fail();
9516 return false;
9517 }
9518 return true;
9519}
9520
9525
9526// setFormat7WindowDC1394RPC helper class implementation
9527FrameGrabberMsgs_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) :
9528 cmd{xdim, ydim, x0, y0}
9529{
9530}
9531
9533{
9534 return cmd.write(connection);
9535}
9536
9541
9542FrameGrabberMsgs_setFormat7WindowDC1394RPC_helper::Command::Command(const std::int32_t xdim, const std::int32_t ydim, const std::int32_t x0, const std::int32_t y0) :
9543 xdim{xdim},
9544 ydim{ydim},
9545 x0{x0},
9546 y0{y0}
9547{
9548}
9549
9551{
9552 yarp::os::idl::WireWriter writer(connection);
9553 if (!writer.writeListHeader(s_cmd_len)) {
9554 return false;
9555 }
9556 return write(writer);
9557}
9558
9560{
9561 yarp::os::idl::WireReader reader(connection);
9562 if (!reader.readListHeader()) {
9563 reader.fail();
9564 return false;
9565 }
9566 return read(reader);
9567}
9568
9570{
9571 if (!writeTag(writer)) {
9572 return false;
9573 }
9574 if (!writeArgs(writer)) {
9575 return false;
9576 }
9577 return true;
9578}
9579
9581{
9582 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
9583 return false;
9584 }
9585 return true;
9586}
9587
9589{
9590 if (!writer.writeI32(xdim)) {
9591 return false;
9592 }
9593 if (!writer.writeI32(ydim)) {
9594 return false;
9595 }
9596 if (!writer.writeI32(x0)) {
9597 return false;
9598 }
9599 if (!writer.writeI32(y0)) {
9600 return false;
9601 }
9602 return true;
9603}
9604
9606{
9607 if (!readTag(reader)) {
9608 return false;
9609 }
9610 if (!readArgs(reader)) {
9611 return false;
9612 }
9613 return true;
9614}
9615
9617{
9618 std::string tag = reader.readTag(s_tag_len);
9619 if (reader.isError()) {
9620 return false;
9621 }
9622 if (tag != s_tag) {
9623 reader.fail();
9624 return false;
9625 }
9626 return true;
9627}
9628
9630{
9631 if (reader.noMore()) {
9632 reader.fail();
9633 return false;
9634 }
9635 if (!reader.readI32(xdim)) {
9636 reader.fail();
9637 return false;
9638 }
9639 if (reader.noMore()) {
9640 reader.fail();
9641 return false;
9642 }
9643 if (!reader.readI32(ydim)) {
9644 reader.fail();
9645 return false;
9646 }
9647 if (reader.noMore()) {
9648 reader.fail();
9649 return false;
9650 }
9651 if (!reader.readI32(x0)) {
9652 reader.fail();
9653 return false;
9654 }
9655 if (reader.noMore()) {
9656 reader.fail();
9657 return false;
9658 }
9659 if (!reader.readI32(y0)) {
9660 reader.fail();
9661 return false;
9662 }
9663 if (!reader.noMore()) {
9664 reader.fail();
9665 return false;
9666 }
9667 return true;
9668}
9669
9671{
9672 yarp::os::idl::WireWriter writer(connection);
9673 return write(writer);
9674}
9675
9681
9683{
9684 if (!writer.isNull()) {
9685 if (!writer.write(return_helper)) {
9686 return false;
9687 }
9688 }
9689 return true;
9690}
9691
9693{
9694 if (reader.noMore()) {
9695 reader.fail();
9696 return false;
9697 }
9698 if (!reader.read(return_helper)) {
9699 reader.fail();
9700 return false;
9701 }
9702 return true;
9703}
9704
9709
9710// setOperationModeDC1394RPC helper class implementation
9715
9717{
9718 return cmd.write(connection);
9719}
9720
9725
9727 b1394b{b1394b}
9728{
9729}
9730
9732{
9733 yarp::os::idl::WireWriter writer(connection);
9734 if (!writer.writeListHeader(s_cmd_len)) {
9735 return false;
9736 }
9737 return write(writer);
9738}
9739
9741{
9742 yarp::os::idl::WireReader reader(connection);
9743 if (!reader.readListHeader()) {
9744 reader.fail();
9745 return false;
9746 }
9747 return read(reader);
9748}
9749
9751{
9752 if (!writeTag(writer)) {
9753 return false;
9754 }
9755 if (!writeArgs(writer)) {
9756 return false;
9757 }
9758 return true;
9759}
9760
9762{
9763 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
9764 return false;
9765 }
9766 return true;
9767}
9768
9770{
9771 if (!writer.writeBool(b1394b)) {
9772 return false;
9773 }
9774 return true;
9775}
9776
9778{
9779 if (!readTag(reader)) {
9780 return false;
9781 }
9782 if (!readArgs(reader)) {
9783 return false;
9784 }
9785 return true;
9786}
9787
9789{
9790 std::string tag = reader.readTag(s_tag_len);
9791 if (reader.isError()) {
9792 return false;
9793 }
9794 if (tag != s_tag) {
9795 reader.fail();
9796 return false;
9797 }
9798 return true;
9799}
9800
9802{
9803 if (reader.noMore()) {
9804 reader.fail();
9805 return false;
9806 }
9807 if (!reader.readBool(b1394b)) {
9808 reader.fail();
9809 return false;
9810 }
9811 if (!reader.noMore()) {
9812 reader.fail();
9813 return false;
9814 }
9815 return true;
9816}
9817
9819{
9820 yarp::os::idl::WireWriter writer(connection);
9821 return write(writer);
9822}
9823
9829
9831{
9832 if (!writer.isNull()) {
9833 if (!writer.write(return_helper)) {
9834 return false;
9835 }
9836 }
9837 return true;
9838}
9839
9841{
9842 if (reader.noMore()) {
9843 reader.fail();
9844 return false;
9845 }
9846 if (!reader.read(return_helper)) {
9847 reader.fail();
9848 return false;
9849 }
9850 return true;
9851}
9852
9857
9858// getOperationModeDC1394RPC helper class implementation
9860{
9861 return cmd.write(connection);
9862}
9863
9868
9870{
9871 yarp::os::idl::WireWriter writer(connection);
9872 if (!writer.writeListHeader(s_cmd_len)) {
9873 return false;
9874 }
9875 return write(writer);
9876}
9877
9879{
9880 yarp::os::idl::WireReader reader(connection);
9881 if (!reader.readListHeader()) {
9882 reader.fail();
9883 return false;
9884 }
9885 return read(reader);
9886}
9887
9889{
9890 if (!writeTag(writer)) {
9891 return false;
9892 }
9893 if (!writeArgs(writer)) {
9894 return false;
9895 }
9896 return true;
9897}
9898
9900{
9901 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
9902 return false;
9903 }
9904 return true;
9905}
9906
9908{
9909 return true;
9910}
9911
9913{
9914 if (!readTag(reader)) {
9915 return false;
9916 }
9917 if (!readArgs(reader)) {
9918 return false;
9919 }
9920 return true;
9921}
9922
9924{
9925 std::string tag = reader.readTag(s_tag_len);
9926 if (reader.isError()) {
9927 return false;
9928 }
9929 if (tag != s_tag) {
9930 reader.fail();
9931 return false;
9932 }
9933 return true;
9934}
9935
9937{
9938 if (!reader.noMore()) {
9939 reader.fail();
9940 return false;
9941 }
9942 return true;
9943}
9944
9946{
9947 yarp::os::idl::WireWriter writer(connection);
9948 return write(writer);
9949}
9950
9956
9958{
9959 if (!writer.isNull()) {
9960 if (!writer.writeListHeader(s_reply_len)) {
9961 return false;
9962 }
9963 if (!writer.write(return_helper)) {
9964 return false;
9965 }
9966 }
9967 return true;
9968}
9969
9971{
9972 if (!reader.readListReturn()) {
9973 return false;
9974 }
9975 if (reader.noMore()) {
9976 reader.fail();
9977 return false;
9978 }
9979 if (!reader.read(return_helper)) {
9980 reader.fail();
9981 return false;
9982 }
9983 return true;
9984}
9985
9990
9991// setTransmissionDC1394RPC helper class implementation
9996
9998{
9999 return cmd.write(connection);
10000}
10001
10003{
10004 return reply.read(connection);
10005}
10006
10008 bTxON{bTxON}
10009{
10010}
10011
10013{
10014 yarp::os::idl::WireWriter writer(connection);
10015 if (!writer.writeListHeader(s_cmd_len)) {
10016 return false;
10017 }
10018 return write(writer);
10019}
10020
10022{
10023 yarp::os::idl::WireReader reader(connection);
10024 if (!reader.readListHeader()) {
10025 reader.fail();
10026 return false;
10027 }
10028 return read(reader);
10029}
10030
10032{
10033 if (!writeTag(writer)) {
10034 return false;
10035 }
10036 if (!writeArgs(writer)) {
10037 return false;
10038 }
10039 return true;
10040}
10041
10043{
10044 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
10045 return false;
10046 }
10047 return true;
10048}
10049
10051{
10052 if (!writer.writeBool(bTxON)) {
10053 return false;
10054 }
10055 return true;
10056}
10057
10059{
10060 if (!readTag(reader)) {
10061 return false;
10062 }
10063 if (!readArgs(reader)) {
10064 return false;
10065 }
10066 return true;
10067}
10068
10070{
10071 std::string tag = reader.readTag(s_tag_len);
10072 if (reader.isError()) {
10073 return false;
10074 }
10075 if (tag != s_tag) {
10076 reader.fail();
10077 return false;
10078 }
10079 return true;
10080}
10081
10083{
10084 if (reader.noMore()) {
10085 reader.fail();
10086 return false;
10087 }
10088 if (!reader.readBool(bTxON)) {
10089 reader.fail();
10090 return false;
10091 }
10092 if (!reader.noMore()) {
10093 reader.fail();
10094 return false;
10095 }
10096 return true;
10097}
10098
10100{
10101 yarp::os::idl::WireWriter writer(connection);
10102 return write(writer);
10103}
10104
10106{
10107 yarp::os::idl::WireReader reader(connection);
10108 return read(reader);
10109}
10110
10112{
10113 if (!writer.isNull()) {
10114 if (!writer.write(return_helper)) {
10115 return false;
10116 }
10117 }
10118 return true;
10119}
10120
10122{
10123 if (reader.noMore()) {
10124 reader.fail();
10125 return false;
10126 }
10127 if (!reader.read(return_helper)) {
10128 reader.fail();
10129 return false;
10130 }
10131 return true;
10132}
10133
10138
10139// getTransmissionDC1394RPC helper class implementation
10141{
10142 return cmd.write(connection);
10143}
10144
10146{
10147 return reply.read(connection);
10148}
10149
10151{
10152 yarp::os::idl::WireWriter writer(connection);
10153 if (!writer.writeListHeader(s_cmd_len)) {
10154 return false;
10155 }
10156 return write(writer);
10157}
10158
10160{
10161 yarp::os::idl::WireReader reader(connection);
10162 if (!reader.readListHeader()) {
10163 reader.fail();
10164 return false;
10165 }
10166 return read(reader);
10167}
10168
10170{
10171 if (!writeTag(writer)) {
10172 return false;
10173 }
10174 if (!writeArgs(writer)) {
10175 return false;
10176 }
10177 return true;
10178}
10179
10181{
10182 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
10183 return false;
10184 }
10185 return true;
10186}
10187
10189{
10190 return true;
10191}
10192
10194{
10195 if (!readTag(reader)) {
10196 return false;
10197 }
10198 if (!readArgs(reader)) {
10199 return false;
10200 }
10201 return true;
10202}
10203
10205{
10206 std::string tag = reader.readTag(s_tag_len);
10207 if (reader.isError()) {
10208 return false;
10209 }
10210 if (tag != s_tag) {
10211 reader.fail();
10212 return false;
10213 }
10214 return true;
10215}
10216
10218{
10219 if (!reader.noMore()) {
10220 reader.fail();
10221 return false;
10222 }
10223 return true;
10224}
10225
10227{
10228 yarp::os::idl::WireWriter writer(connection);
10229 return write(writer);
10230}
10231
10233{
10234 yarp::os::idl::WireReader reader(connection);
10235 return read(reader);
10236}
10237
10239{
10240 if (!writer.isNull()) {
10241 if (!writer.writeListHeader(s_reply_len)) {
10242 return false;
10243 }
10244 if (!writer.write(return_helper)) {
10245 return false;
10246 }
10247 }
10248 return true;
10249}
10250
10252{
10253 if (!reader.readListReturn()) {
10254 return false;
10255 }
10256 if (reader.noMore()) {
10257 reader.fail();
10258 return false;
10259 }
10260 if (!reader.read(return_helper)) {
10261 reader.fail();
10262 return false;
10263 }
10264 return true;
10265}
10266
10271
10272// setBroadcastDC1394RPC helper class implementation
10277
10279{
10280 return cmd.write(connection);
10281}
10282
10284{
10285 return reply.read(connection);
10286}
10287
10289 onoff{onoff}
10290{
10291}
10292
10294{
10295 yarp::os::idl::WireWriter writer(connection);
10296 if (!writer.writeListHeader(s_cmd_len)) {
10297 return false;
10298 }
10299 return write(writer);
10300}
10301
10303{
10304 yarp::os::idl::WireReader reader(connection);
10305 if (!reader.readListHeader()) {
10306 reader.fail();
10307 return false;
10308 }
10309 return read(reader);
10310}
10311
10313{
10314 if (!writeTag(writer)) {
10315 return false;
10316 }
10317 if (!writeArgs(writer)) {
10318 return false;
10319 }
10320 return true;
10321}
10322
10324{
10325 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
10326 return false;
10327 }
10328 return true;
10329}
10330
10332{
10333 if (!writer.writeBool(onoff)) {
10334 return false;
10335 }
10336 return true;
10337}
10338
10340{
10341 if (!readTag(reader)) {
10342 return false;
10343 }
10344 if (!readArgs(reader)) {
10345 return false;
10346 }
10347 return true;
10348}
10349
10351{
10352 std::string tag = reader.readTag(s_tag_len);
10353 if (reader.isError()) {
10354 return false;
10355 }
10356 if (tag != s_tag) {
10357 reader.fail();
10358 return false;
10359 }
10360 return true;
10361}
10362
10364{
10365 if (reader.noMore()) {
10366 reader.fail();
10367 return false;
10368 }
10369 if (!reader.readBool(onoff)) {
10370 reader.fail();
10371 return false;
10372 }
10373 if (!reader.noMore()) {
10374 reader.fail();
10375 return false;
10376 }
10377 return true;
10378}
10379
10381{
10382 yarp::os::idl::WireWriter writer(connection);
10383 return write(writer);
10384}
10385
10387{
10388 yarp::os::idl::WireReader reader(connection);
10389 return read(reader);
10390}
10391
10393{
10394 if (!writer.isNull()) {
10395 if (!writer.write(return_helper)) {
10396 return false;
10397 }
10398 }
10399 return true;
10400}
10401
10403{
10404 if (reader.noMore()) {
10405 reader.fail();
10406 return false;
10407 }
10408 if (!reader.read(return_helper)) {
10409 reader.fail();
10410 return false;
10411 }
10412 return true;
10413}
10414
10419
10420// setDefaultsDC1394RPC helper class implementation
10422{
10423 return cmd.write(connection);
10424}
10425
10427{
10428 return reply.read(connection);
10429}
10430
10432{
10433 yarp::os::idl::WireWriter writer(connection);
10434 if (!writer.writeListHeader(s_cmd_len)) {
10435 return false;
10436 }
10437 return write(writer);
10438}
10439
10441{
10442 yarp::os::idl::WireReader reader(connection);
10443 if (!reader.readListHeader()) {
10444 reader.fail();
10445 return false;
10446 }
10447 return read(reader);
10448}
10449
10451{
10452 if (!writeTag(writer)) {
10453 return false;
10454 }
10455 if (!writeArgs(writer)) {
10456 return false;
10457 }
10458 return true;
10459}
10460
10462{
10463 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
10464 return false;
10465 }
10466 return true;
10467}
10468
10470{
10471 return true;
10472}
10473
10475{
10476 if (!readTag(reader)) {
10477 return false;
10478 }
10479 if (!readArgs(reader)) {
10480 return false;
10481 }
10482 return true;
10483}
10484
10486{
10487 std::string tag = reader.readTag(s_tag_len);
10488 if (reader.isError()) {
10489 return false;
10490 }
10491 if (tag != s_tag) {
10492 reader.fail();
10493 return false;
10494 }
10495 return true;
10496}
10497
10499{
10500 if (!reader.noMore()) {
10501 reader.fail();
10502 return false;
10503 }
10504 return true;
10505}
10506
10508{
10509 yarp::os::idl::WireWriter writer(connection);
10510 return write(writer);
10511}
10512
10514{
10515 yarp::os::idl::WireReader reader(connection);
10516 return read(reader);
10517}
10518
10520{
10521 if (!writer.isNull()) {
10522 if (!writer.write(return_helper)) {
10523 return false;
10524 }
10525 }
10526 return true;
10527}
10528
10530{
10531 if (reader.noMore()) {
10532 reader.fail();
10533 return false;
10534 }
10535 if (!reader.read(return_helper)) {
10536 reader.fail();
10537 return false;
10538 }
10539 return true;
10540}
10541
10546
10547// setResetDC1394RPC helper class implementation
10549{
10550 return cmd.write(connection);
10551}
10552
10554{
10555 return reply.read(connection);
10556}
10557
10559{
10560 yarp::os::idl::WireWriter writer(connection);
10561 if (!writer.writeListHeader(s_cmd_len)) {
10562 return false;
10563 }
10564 return write(writer);
10565}
10566
10568{
10569 yarp::os::idl::WireReader reader(connection);
10570 if (!reader.readListHeader()) {
10571 reader.fail();
10572 return false;
10573 }
10574 return read(reader);
10575}
10576
10578{
10579 if (!writeTag(writer)) {
10580 return false;
10581 }
10582 if (!writeArgs(writer)) {
10583 return false;
10584 }
10585 return true;
10586}
10587
10589{
10590 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
10591 return false;
10592 }
10593 return true;
10594}
10595
10597{
10598 return true;
10599}
10600
10602{
10603 if (!readTag(reader)) {
10604 return false;
10605 }
10606 if (!readArgs(reader)) {
10607 return false;
10608 }
10609 return true;
10610}
10611
10613{
10614 std::string tag = reader.readTag(s_tag_len);
10615 if (reader.isError()) {
10616 return false;
10617 }
10618 if (tag != s_tag) {
10619 reader.fail();
10620 return false;
10621 }
10622 return true;
10623}
10624
10626{
10627 if (!reader.noMore()) {
10628 reader.fail();
10629 return false;
10630 }
10631 return true;
10632}
10633
10635{
10636 yarp::os::idl::WireWriter writer(connection);
10637 return write(writer);
10638}
10639
10641{
10642 yarp::os::idl::WireReader reader(connection);
10643 return read(reader);
10644}
10645
10647{
10648 if (!writer.isNull()) {
10649 if (!writer.write(return_helper)) {
10650 return false;
10651 }
10652 }
10653 return true;
10654}
10655
10657{
10658 if (reader.noMore()) {
10659 reader.fail();
10660 return false;
10661 }
10662 if (!reader.read(return_helper)) {
10663 reader.fail();
10664 return false;
10665 }
10666 return true;
10667}
10668
10673
10674// setPowerDC1394RPC helper class implementation
10679
10681{
10682 return cmd.write(connection);
10683}
10684
10686{
10687 return reply.read(connection);
10688}
10689
10691 onoff{onoff}
10692{
10693}
10694
10696{
10697 yarp::os::idl::WireWriter writer(connection);
10698 if (!writer.writeListHeader(s_cmd_len)) {
10699 return false;
10700 }
10701 return write(writer);
10702}
10703
10705{
10706 yarp::os::idl::WireReader reader(connection);
10707 if (!reader.readListHeader()) {
10708 reader.fail();
10709 return false;
10710 }
10711 return read(reader);
10712}
10713
10715{
10716 if (!writeTag(writer)) {
10717 return false;
10718 }
10719 if (!writeArgs(writer)) {
10720 return false;
10721 }
10722 return true;
10723}
10724
10726{
10727 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
10728 return false;
10729 }
10730 return true;
10731}
10732
10734{
10735 if (!writer.writeBool(onoff)) {
10736 return false;
10737 }
10738 return true;
10739}
10740
10742{
10743 if (!readTag(reader)) {
10744 return false;
10745 }
10746 if (!readArgs(reader)) {
10747 return false;
10748 }
10749 return true;
10750}
10751
10753{
10754 std::string tag = reader.readTag(s_tag_len);
10755 if (reader.isError()) {
10756 return false;
10757 }
10758 if (tag != s_tag) {
10759 reader.fail();
10760 return false;
10761 }
10762 return true;
10763}
10764
10766{
10767 if (reader.noMore()) {
10768 reader.fail();
10769 return false;
10770 }
10771 if (!reader.readBool(onoff)) {
10772 reader.fail();
10773 return false;
10774 }
10775 if (!reader.noMore()) {
10776 reader.fail();
10777 return false;
10778 }
10779 return true;
10780}
10781
10783{
10784 yarp::os::idl::WireWriter writer(connection);
10785 return write(writer);
10786}
10787
10789{
10790 yarp::os::idl::WireReader reader(connection);
10791 return read(reader);
10792}
10793
10795{
10796 if (!writer.isNull()) {
10797 if (!writer.write(return_helper)) {
10798 return false;
10799 }
10800 }
10801 return true;
10802}
10803
10805{
10806 if (reader.noMore()) {
10807 reader.fail();
10808 return false;
10809 }
10810 if (!reader.read(return_helper)) {
10811 reader.fail();
10812 return false;
10813 }
10814 return true;
10815}
10816
10821
10822// setCaptureDC1394RPC helper class implementation
10827
10829{
10830 return cmd.write(connection);
10831}
10832
10834{
10835 return reply.read(connection);
10836}
10837
10839 bON{bON}
10840{
10841}
10842
10844{
10845 yarp::os::idl::WireWriter writer(connection);
10846 if (!writer.writeListHeader(s_cmd_len)) {
10847 return false;
10848 }
10849 return write(writer);
10850}
10851
10853{
10854 yarp::os::idl::WireReader reader(connection);
10855 if (!reader.readListHeader()) {
10856 reader.fail();
10857 return false;
10858 }
10859 return read(reader);
10860}
10861
10863{
10864 if (!writeTag(writer)) {
10865 return false;
10866 }
10867 if (!writeArgs(writer)) {
10868 return false;
10869 }
10870 return true;
10871}
10872
10874{
10875 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
10876 return false;
10877 }
10878 return true;
10879}
10880
10882{
10883 if (!writer.writeBool(bON)) {
10884 return false;
10885 }
10886 return true;
10887}
10888
10890{
10891 if (!readTag(reader)) {
10892 return false;
10893 }
10894 if (!readArgs(reader)) {
10895 return false;
10896 }
10897 return true;
10898}
10899
10901{
10902 std::string tag = reader.readTag(s_tag_len);
10903 if (reader.isError()) {
10904 return false;
10905 }
10906 if (tag != s_tag) {
10907 reader.fail();
10908 return false;
10909 }
10910 return true;
10911}
10912
10914{
10915 if (reader.noMore()) {
10916 reader.fail();
10917 return false;
10918 }
10919 if (!reader.readBool(bON)) {
10920 reader.fail();
10921 return false;
10922 }
10923 if (!reader.noMore()) {
10924 reader.fail();
10925 return false;
10926 }
10927 return true;
10928}
10929
10931{
10932 yarp::os::idl::WireWriter writer(connection);
10933 return write(writer);
10934}
10935
10937{
10938 yarp::os::idl::WireReader reader(connection);
10939 return read(reader);
10940}
10941
10943{
10944 if (!writer.isNull()) {
10945 if (!writer.write(return_helper)) {
10946 return false;
10947 }
10948 }
10949 return true;
10950}
10951
10953{
10954 if (reader.noMore()) {
10955 reader.fail();
10956 return false;
10957 }
10958 if (!reader.read(return_helper)) {
10959 reader.fail();
10960 return false;
10961 }
10962 return true;
10963}
10964
10969
10970// getBytesPerPacketDC1394RPC helper class implementation
10972{
10973 return cmd.write(connection);
10974}
10975
10980
10982{
10983 yarp::os::idl::WireWriter writer(connection);
10984 if (!writer.writeListHeader(s_cmd_len)) {
10985 return false;
10986 }
10987 return write(writer);
10988}
10989
10991{
10992 yarp::os::idl::WireReader reader(connection);
10993 if (!reader.readListHeader()) {
10994 reader.fail();
10995 return false;
10996 }
10997 return read(reader);
10998}
10999
11001{
11002 if (!writeTag(writer)) {
11003 return false;
11004 }
11005 if (!writeArgs(writer)) {
11006 return false;
11007 }
11008 return true;
11009}
11010
11012{
11013 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
11014 return false;
11015 }
11016 return true;
11017}
11018
11020{
11021 return true;
11022}
11023
11025{
11026 if (!readTag(reader)) {
11027 return false;
11028 }
11029 if (!readArgs(reader)) {
11030 return false;
11031 }
11032 return true;
11033}
11034
11036{
11037 std::string tag = reader.readTag(s_tag_len);
11038 if (reader.isError()) {
11039 return false;
11040 }
11041 if (tag != s_tag) {
11042 reader.fail();
11043 return false;
11044 }
11045 return true;
11046}
11047
11049{
11050 if (!reader.noMore()) {
11051 reader.fail();
11052 return false;
11053 }
11054 return true;
11055}
11056
11058{
11059 yarp::os::idl::WireWriter writer(connection);
11060 return write(writer);
11061}
11062
11064{
11065 yarp::os::idl::WireReader reader(connection);
11066 return read(reader);
11067}
11068
11070{
11071 if (!writer.isNull()) {
11072 if (!writer.writeListHeader(s_reply_len)) {
11073 return false;
11074 }
11075 if (!writer.write(return_helper)) {
11076 return false;
11077 }
11078 }
11079 return true;
11080}
11081
11083{
11084 if (!reader.readListReturn()) {
11085 return false;
11086 }
11087 if (reader.noMore()) {
11088 reader.fail();
11089 return false;
11090 }
11091 if (!reader.read(return_helper)) {
11092 reader.fail();
11093 return false;
11094 }
11095 return true;
11096}
11097
11102
11103// setBytesPerPacketDC1394RPC helper class implementation
11108
11110{
11111 return cmd.write(connection);
11112}
11113
11118
11123
11125{
11126 yarp::os::idl::WireWriter writer(connection);
11127 if (!writer.writeListHeader(s_cmd_len)) {
11128 return false;
11129 }
11130 return write(writer);
11131}
11132
11134{
11135 yarp::os::idl::WireReader reader(connection);
11136 if (!reader.readListHeader()) {
11137 reader.fail();
11138 return false;
11139 }
11140 return read(reader);
11141}
11142
11144{
11145 if (!writeTag(writer)) {
11146 return false;
11147 }
11148 if (!writeArgs(writer)) {
11149 return false;
11150 }
11151 return true;
11152}
11153
11155{
11156 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
11157 return false;
11158 }
11159 return true;
11160}
11161
11163{
11164 if (!writer.writeI32(bpp)) {
11165 return false;
11166 }
11167 return true;
11168}
11169
11171{
11172 if (!readTag(reader)) {
11173 return false;
11174 }
11175 if (!readArgs(reader)) {
11176 return false;
11177 }
11178 return true;
11179}
11180
11182{
11183 std::string tag = reader.readTag(s_tag_len);
11184 if (reader.isError()) {
11185 return false;
11186 }
11187 if (tag != s_tag) {
11188 reader.fail();
11189 return false;
11190 }
11191 return true;
11192}
11193
11195{
11196 if (reader.noMore()) {
11197 reader.fail();
11198 return false;
11199 }
11200 if (!reader.readI32(bpp)) {
11201 reader.fail();
11202 return false;
11203 }
11204 if (!reader.noMore()) {
11205 reader.fail();
11206 return false;
11207 }
11208 return true;
11209}
11210
11212{
11213 yarp::os::idl::WireWriter writer(connection);
11214 return write(writer);
11215}
11216
11218{
11219 yarp::os::idl::WireReader reader(connection);
11220 return read(reader);
11221}
11222
11224{
11225 if (!writer.isNull()) {
11226 if (!writer.write(return_helper)) {
11227 return false;
11228 }
11229 }
11230 return true;
11231}
11232
11234{
11235 if (reader.noMore()) {
11236 reader.fail();
11237 return false;
11238 }
11239 if (!reader.read(return_helper)) {
11240 reader.fail();
11241 return false;
11242 }
11243 return true;
11244}
11245
11250
11251// Constructor
11253{
11254 yarp().setOwner(*this);
11255}
11256
11258{
11259 if (!yarp().canWrite()) {
11260 yError("Missing server method '%s'?", FrameGrabberMsgs_getHeightRPC_helper::s_prototype);
11261 }
11263 bool ok = yarp().write(helper, helper);
11264 return ok ? helper.reply.return_helper : IFrameGrabberImageOf_return_getHeight{};
11265}
11266
11268{
11269 if (!yarp().canWrite()) {
11270 yError("Missing server method '%s'?", FrameGrabberMsgs_getWidthRPC_helper::s_prototype);
11271 }
11273 bool ok = yarp().write(helper, helper);
11274 return ok ? helper.reply.return_helper : IFrameGrabberImageOf_return_getWidth{};
11275}
11276
11278{
11279 if (!yarp().canWrite()) {
11280 yError("Missing server method '%s'?", FrameGrabberMsgs_getImageRPC_helper::s_prototype);
11281 }
11283 bool ok = yarp().write(helper, helper);
11284 return ok ? helper.reply.return_helper : IFrameGrabberImageOf_return_getImage{};
11285}
11286
11288{
11289 if (!yarp().canWrite()) {
11290 yError("Missing server method '%s'?", FrameGrabberMsgs_getImageCropRPC_helper::s_prototype);
11291 }
11292 FrameGrabberMsgs_getImageCropRPC_helper helper{type, vertices};
11293 bool ok = yarp().write(helper, helper);
11294 return ok ? helper.reply.return_helper : IFrameGrabberImageOf_return_getImageCrop{};
11295}
11296
11298{
11299 if (!yarp().canWrite()) {
11300 yError("Missing server method '%s'?", FrameGrabberMsgs_getRgbWidthRPC_helper::s_prototype);
11301 }
11303 bool ok = yarp().write(helper, helper);
11304 return ok ? helper.reply.return_helper : IRGBVisualParamsMsgs_return_getRgbWidth{};
11305}
11306
11308{
11309 if (!yarp().canWrite()) {
11310 yError("Missing server method '%s'?", FrameGrabberMsgs_getRgbHeightRPC_helper::s_prototype);
11311 }
11313 bool ok = yarp().write(helper, helper);
11314 return ok ? helper.reply.return_helper : IRGBVisualParamsMsgs_return_getRgbHeight{};
11315}
11316
11318{
11319 if (!yarp().canWrite()) {
11321 }
11323 bool ok = yarp().write(helper, helper);
11324 return ok ? helper.reply.return_helper : IRGBVisualParamsMsgs_return_getRgbSupportedCfg{};
11325}
11326
11328{
11329 if (!yarp().canWrite()) {
11331 }
11333 bool ok = yarp().write(helper, helper);
11334 return ok ? helper.reply.return_helper : IRGBVisualParamsMsgs_return_getRgbResolution{};
11335}
11336
11337yarp::dev::ReturnValue FrameGrabberMsgs::setRgbResolutionRPC(const std::int32_t width, const std::int32_t height)
11338{
11339 if (!yarp().canWrite()) {
11341 }
11342 FrameGrabberMsgs_setRgbResolutionRPC_helper helper{width, height};
11343 bool ok = yarp().write(helper, helper);
11344 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11345}
11346
11348{
11349 if (!yarp().canWrite()) {
11350 yError("Missing server method '%s'?", FrameGrabberMsgs_getRgbFOVRPC_helper::s_prototype);
11351 }
11353 bool ok = yarp().write(helper, helper);
11354 return ok ? helper.reply.return_helper : IRGBVisualParamsMsgs_return_getRgbFOV{};
11355}
11356
11357yarp::dev::ReturnValue FrameGrabberMsgs::setRgbFOVRPC(const double horizontalFov, const double verticalFov)
11358{
11359 if (!yarp().canWrite()) {
11360 yError("Missing server method '%s'?", FrameGrabberMsgs_setRgbFOVRPC_helper::s_prototype);
11361 }
11362 FrameGrabberMsgs_setRgbFOVRPC_helper helper{horizontalFov, verticalFov};
11363 bool ok = yarp().write(helper, helper);
11364 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11365}
11366
11368{
11369 if (!yarp().canWrite()) {
11371 }
11373 bool ok = yarp().write(helper, helper);
11374 return ok ? helper.reply.return_helper : IRGBVisualParamsMsgs_return_getRgbIntrinsicParam{};
11375}
11376
11378{
11379 if (!yarp().canWrite()) {
11381 }
11383 bool ok = yarp().write(helper, helper);
11384 return ok ? helper.reply.return_helper : IRGBVisualParamsMsgs_return_getRgbMirroring{};
11385}
11386
11388{
11389 if (!yarp().canWrite()) {
11391 }
11393 bool ok = yarp().write(helper, helper);
11394 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11395}
11396
11398{
11399 if (!yarp().canWrite()) {
11401 }
11403 bool ok = yarp().write(helper, helper);
11404 return ok ? helper.reply.return_helper : IFrameGrabberControlMsgs_return_getCameraDescription{};
11405}
11406
11408{
11409 if (!yarp().canWrite()) {
11410 yError("Missing server method '%s'?", FrameGrabberMsgs_hasFeatureRPC_helper::s_prototype);
11411 }
11413 bool ok = yarp().write(helper, helper);
11414 return ok ? helper.reply.return_helper : IFrameGrabberControlMsgs_return_hasFeature{};
11415}
11416
11417yarp::dev::ReturnValue FrameGrabberMsgs::setFeature1RPC(const std::int32_t feature, const double value)
11418{
11419 if (!yarp().canWrite()) {
11420 yError("Missing server method '%s'?", FrameGrabberMsgs_setFeature1RPC_helper::s_prototype);
11421 }
11422 FrameGrabberMsgs_setFeature1RPC_helper helper{feature, value};
11423 bool ok = yarp().write(helper, helper);
11424 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11425}
11426
11428{
11429 if (!yarp().canWrite()) {
11430 yError("Missing server method '%s'?", FrameGrabberMsgs_getFeature1RPC_helper::s_prototype);
11431 }
11433 bool ok = yarp().write(helper, helper);
11434 return ok ? helper.reply.return_helper : IFrameGrabberControlMsgs_return_getFeature1{};
11435}
11436
11437yarp::dev::ReturnValue FrameGrabberMsgs::setFeature2RPC(const std::int32_t feature, const double value1, const double value2)
11438{
11439 if (!yarp().canWrite()) {
11440 yError("Missing server method '%s'?", FrameGrabberMsgs_setFeature2RPC_helper::s_prototype);
11441 }
11442 FrameGrabberMsgs_setFeature2RPC_helper helper{feature, value1, value2};
11443 bool ok = yarp().write(helper, helper);
11444 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11445}
11446
11448{
11449 if (!yarp().canWrite()) {
11450 yError("Missing server method '%s'?", FrameGrabberMsgs_getFeature2RPC_helper::s_prototype);
11451 }
11453 bool ok = yarp().write(helper, helper);
11454 return ok ? helper.reply.return_helper : IFrameGrabberControlMsgs_return_getFeature2{};
11455}
11456
11458{
11459 if (!yarp().canWrite()) {
11460 yError("Missing server method '%s'?", FrameGrabberMsgs_hasOnOffRPC_helper::s_prototype);
11461 }
11463 bool ok = yarp().write(helper, helper);
11464 return ok ? helper.reply.return_helper : IFrameGrabberControlMsgs_return_hasOnOff{};
11465}
11466
11467yarp::dev::ReturnValue FrameGrabberMsgs::setActiveRPC(const std::int32_t feature, const bool onoff)
11468{
11469 if (!yarp().canWrite()) {
11470 yError("Missing server method '%s'?", FrameGrabberMsgs_setActiveRPC_helper::s_prototype);
11471 }
11472 FrameGrabberMsgs_setActiveRPC_helper helper{feature, onoff};
11473 bool ok = yarp().write(helper, helper);
11474 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11475}
11476
11478{
11479 if (!yarp().canWrite()) {
11480 yError("Missing server method '%s'?", FrameGrabberMsgs_getActiveRPC_helper::s_prototype);
11481 }
11483 bool ok = yarp().write(helper, helper);
11484 return ok ? helper.reply.return_helper : IFrameGrabberControlMsgs_return_getActive{};
11485}
11486
11488{
11489 if (!yarp().canWrite()) {
11490 yError("Missing server method '%s'?", FrameGrabberMsgs_hasAutoRPC_helper::s_prototype);
11491 }
11492 FrameGrabberMsgs_hasAutoRPC_helper helper{feature};
11493 bool ok = yarp().write(helper, helper);
11494 return ok ? helper.reply.return_helper : IFrameGrabberControlMsgs_return_hasAuto{};
11495}
11496
11498{
11499 if (!yarp().canWrite()) {
11500 yError("Missing server method '%s'?", FrameGrabberMsgs_hasManualRPC_helper::s_prototype);
11501 }
11503 bool ok = yarp().write(helper, helper);
11504 return ok ? helper.reply.return_helper : IFrameGrabberControlMsgs_return_hasManual{};
11505}
11506
11508{
11509 if (!yarp().canWrite()) {
11510 yError("Missing server method '%s'?", FrameGrabberMsgs_hasOnePushRPC_helper::s_prototype);
11511 }
11513 bool ok = yarp().write(helper, helper);
11514 return ok ? helper.reply.return_helper : IFrameGrabberControlMsgs_return_hasOnePush{};
11515}
11516
11518{
11519 if (!yarp().canWrite()) {
11520 yError("Missing server method '%s'?", FrameGrabberMsgs_setModeRPC_helper::s_prototype);
11521 }
11522 FrameGrabberMsgs_setModeRPC_helper helper{feature, mode};
11523 bool ok = yarp().write(helper, helper);
11524 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11525}
11526
11528{
11529 if (!yarp().canWrite()) {
11530 yError("Missing server method '%s'?", FrameGrabberMsgs_getModeRPC_helper::s_prototype);
11531 }
11532 FrameGrabberMsgs_getModeRPC_helper helper{feature};
11533 bool ok = yarp().write(helper, helper);
11534 return ok ? helper.reply.return_helper : IFrameGrabberControlMsgs_return_getMode{};
11535}
11536
11538{
11539 if (!yarp().canWrite()) {
11540 yError("Missing server method '%s'?", FrameGrabberMsgs_setOnePushRPC_helper::s_prototype);
11541 }
11543 bool ok = yarp().write(helper, helper);
11544 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11545}
11546
11548{
11549 if (!yarp().canWrite()) {
11551 }
11553 bool ok = yarp().write(helper, helper);
11554 return ok ? helper.reply.return_helper : IFrameGrabberControlDC1394Msgs_return_getVideoModeMaskDC1394{};
11555}
11556
11558{
11559 if (!yarp().canWrite()) {
11561 }
11563 bool ok = yarp().write(helper, helper);
11564 return ok ? helper.reply.return_helper : IFrameGrabberControlDC1394Msgs_return_getVideoModeDC1394{};
11565}
11566
11568{
11569 if (!yarp().canWrite()) {
11571 }
11573 bool ok = yarp().write(helper, helper);
11574 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11575}
11576
11578{
11579 if (!yarp().canWrite()) {
11581 }
11583 bool ok = yarp().write(helper, helper);
11584 return ok ? helper.reply.return_helper : IFrameGrabberControlDC1394Msgs_return_getFPSMaskDC1394{};
11585}
11586
11588{
11589 if (!yarp().canWrite()) {
11590 yError("Missing server method '%s'?", FrameGrabberMsgs_getFPSDC1394RPC_helper::s_prototype);
11591 }
11593 bool ok = yarp().write(helper, helper);
11594 return ok ? helper.reply.return_helper : IFrameGrabberControlDC1394Msgs_return_getFPSDC1394{};
11595}
11596
11598{
11599 if (!yarp().canWrite()) {
11600 yError("Missing server method '%s'?", FrameGrabberMsgs_setFPSDC1394RPC_helper::s_prototype);
11601 }
11603 bool ok = yarp().write(helper, helper);
11604 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11605}
11606
11608{
11609 if (!yarp().canWrite()) {
11611 }
11613 bool ok = yarp().write(helper, helper);
11614 return ok ? helper.reply.return_helper : IFrameGrabberControlDC1394Msgs_return_getISOSpeedDC1394{};
11615}
11616
11618{
11619 if (!yarp().canWrite()) {
11621 }
11623 bool ok = yarp().write(helper, helper);
11624 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11625}
11626
11628{
11629 if (!yarp().canWrite()) {
11631 }
11633 bool ok = yarp().write(helper, helper);
11634 return ok ? helper.reply.return_helper : IFrameGrabberControlDC1394Msgs_return_getColorCodingMaskDC1394{};
11635}
11636
11638{
11639 if (!yarp().canWrite()) {
11641 }
11643 bool ok = yarp().write(helper, helper);
11644 return ok ? helper.reply.return_helper : IFrameGrabberControlDC1394Msgs_return_getColorCodingDC1394{};
11645}
11646
11648{
11649 if (!yarp().canWrite()) {
11651 }
11653 bool ok = yarp().write(helper, helper);
11654 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11655}
11656
11658{
11659 if (!yarp().canWrite()) {
11661 }
11663 bool ok = yarp().write(helper, helper);
11664 return ok ? helper.reply.return_helper : IFrameGrabberControlDC1394Msgs_return_getFormat7MaxWindowDC1394{};
11665}
11666
11668{
11669 if (!yarp().canWrite()) {
11671 }
11673 bool ok = yarp().write(helper, helper);
11674 return ok ? helper.reply.return_helper : IFrameGrabberControlDC1394Msgs_return_getFormat7WindowDC1394{};
11675}
11676
11677yarp::dev::ReturnValue FrameGrabberMsgs::setFormat7WindowDC1394RPC(const std::int32_t xdim, const std::int32_t ydim, const std::int32_t x0, const std::int32_t y0)
11678{
11679 if (!yarp().canWrite()) {
11681 }
11682 FrameGrabberMsgs_setFormat7WindowDC1394RPC_helper helper{xdim, ydim, x0, y0};
11683 bool ok = yarp().write(helper, helper);
11684 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11685}
11686
11688{
11689 if (!yarp().canWrite()) {
11691 }
11693 bool ok = yarp().write(helper, helper);
11694 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11695}
11696
11698{
11699 if (!yarp().canWrite()) {
11701 }
11703 bool ok = yarp().write(helper, helper);
11704 return ok ? helper.reply.return_helper : IFrameGrabberControlDC1394Msgs_return_getOperationModeDC1394{};
11705}
11706
11708{
11709 if (!yarp().canWrite()) {
11711 }
11713 bool ok = yarp().write(helper, helper);
11714 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11715}
11716
11718{
11719 if (!yarp().canWrite()) {
11721 }
11723 bool ok = yarp().write(helper, helper);
11724 return ok ? helper.reply.return_helper : IFrameGrabberControlDC1394Msgs_return_getTransmissionDC1394{};
11725}
11726
11728{
11729 if (!yarp().canWrite()) {
11731 }
11733 bool ok = yarp().write(helper, helper);
11734 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11735}
11736
11738{
11739 if (!yarp().canWrite()) {
11741 }
11743 bool ok = yarp().write(helper, helper);
11744 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11745}
11746
11748{
11749 if (!yarp().canWrite()) {
11750 yError("Missing server method '%s'?", FrameGrabberMsgs_setResetDC1394RPC_helper::s_prototype);
11751 }
11753 bool ok = yarp().write(helper, helper);
11754 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11755}
11756
11758{
11759 if (!yarp().canWrite()) {
11760 yError("Missing server method '%s'?", FrameGrabberMsgs_setPowerDC1394RPC_helper::s_prototype);
11761 }
11763 bool ok = yarp().write(helper, helper);
11764 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11765}
11766
11768{
11769 if (!yarp().canWrite()) {
11771 }
11773 bool ok = yarp().write(helper, helper);
11774 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11775}
11776
11778{
11779 if (!yarp().canWrite()) {
11781 }
11783 bool ok = yarp().write(helper, helper);
11784 return ok ? helper.reply.return_helper : IFrameGrabberControlDC1394Msgs_return_getBytesPerPacketDC1394{};
11785}
11786
11788{
11789 if (!yarp().canWrite()) {
11791 }
11793 bool ok = yarp().write(helper, helper);
11794 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
11795}
11796
11797// help method
11798std::vector<std::string> FrameGrabberMsgs::help(const std::string& functionName)
11799{
11800 bool showAll = (functionName == "--all");
11801 std::vector<std::string> helpString;
11802 if (showAll) {
11803 helpString.emplace_back("*** Available commands:");
11804 helpString.emplace_back(FrameGrabberMsgs_getHeightRPC_helper::s_tag);
11805 helpString.emplace_back(FrameGrabberMsgs_getWidthRPC_helper::s_tag);
11806 helpString.emplace_back(FrameGrabberMsgs_getImageRPC_helper::s_tag);
11807 helpString.emplace_back(FrameGrabberMsgs_getImageCropRPC_helper::s_tag);
11808 helpString.emplace_back(FrameGrabberMsgs_getRgbWidthRPC_helper::s_tag);
11809 helpString.emplace_back(FrameGrabberMsgs_getRgbHeightRPC_helper::s_tag);
11813 helpString.emplace_back(FrameGrabberMsgs_getRgbFOVRPC_helper::s_tag);
11814 helpString.emplace_back(FrameGrabberMsgs_setRgbFOVRPC_helper::s_tag);
11819 helpString.emplace_back(FrameGrabberMsgs_hasFeatureRPC_helper::s_tag);
11820 helpString.emplace_back(FrameGrabberMsgs_setFeature1RPC_helper::s_tag);
11821 helpString.emplace_back(FrameGrabberMsgs_getFeature1RPC_helper::s_tag);
11822 helpString.emplace_back(FrameGrabberMsgs_setFeature2RPC_helper::s_tag);
11823 helpString.emplace_back(FrameGrabberMsgs_getFeature2RPC_helper::s_tag);
11824 helpString.emplace_back(FrameGrabberMsgs_hasOnOffRPC_helper::s_tag);
11825 helpString.emplace_back(FrameGrabberMsgs_setActiveRPC_helper::s_tag);
11826 helpString.emplace_back(FrameGrabberMsgs_getActiveRPC_helper::s_tag);
11827 helpString.emplace_back(FrameGrabberMsgs_hasAutoRPC_helper::s_tag);
11828 helpString.emplace_back(FrameGrabberMsgs_hasManualRPC_helper::s_tag);
11829 helpString.emplace_back(FrameGrabberMsgs_hasOnePushRPC_helper::s_tag);
11830 helpString.emplace_back(FrameGrabberMsgs_setModeRPC_helper::s_tag);
11831 helpString.emplace_back(FrameGrabberMsgs_getModeRPC_helper::s_tag);
11832 helpString.emplace_back(FrameGrabberMsgs_setOnePushRPC_helper::s_tag);
11837 helpString.emplace_back(FrameGrabberMsgs_getFPSDC1394RPC_helper::s_tag);
11838 helpString.emplace_back(FrameGrabberMsgs_setFPSDC1394RPC_helper::s_tag);
11853 helpString.emplace_back(FrameGrabberMsgs_setResetDC1394RPC_helper::s_tag);
11854 helpString.emplace_back(FrameGrabberMsgs_setPowerDC1394RPC_helper::s_tag);
11858 helpString.emplace_back("help");
11859 } else {
11860 if (functionName == FrameGrabberMsgs_getHeightRPC_helper::s_tag) {
11862 }
11863 if (functionName == FrameGrabberMsgs_getWidthRPC_helper::s_tag) {
11864 helpString.emplace_back(FrameGrabberMsgs_getWidthRPC_helper::s_prototype);
11865 }
11866 if (functionName == FrameGrabberMsgs_getImageRPC_helper::s_tag) {
11867 helpString.emplace_back(FrameGrabberMsgs_getImageRPC_helper::s_prototype);
11868 }
11871 }
11874 }
11877 }
11880 }
11883 }
11886 }
11887 if (functionName == FrameGrabberMsgs_getRgbFOVRPC_helper::s_tag) {
11889 }
11890 if (functionName == FrameGrabberMsgs_setRgbFOVRPC_helper::s_tag) {
11892 }
11895 }
11898 }
11901 }
11904 }
11907 }
11910 }
11913 }
11916 }
11919 }
11920 if (functionName == FrameGrabberMsgs_hasOnOffRPC_helper::s_tag) {
11921 helpString.emplace_back(FrameGrabberMsgs_hasOnOffRPC_helper::s_prototype);
11922 }
11923 if (functionName == FrameGrabberMsgs_setActiveRPC_helper::s_tag) {
11925 }
11926 if (functionName == FrameGrabberMsgs_getActiveRPC_helper::s_tag) {
11928 }
11929 if (functionName == FrameGrabberMsgs_hasAutoRPC_helper::s_tag) {
11930 helpString.emplace_back(FrameGrabberMsgs_hasAutoRPC_helper::s_prototype);
11931 }
11932 if (functionName == FrameGrabberMsgs_hasManualRPC_helper::s_tag) {
11934 }
11937 }
11938 if (functionName == FrameGrabberMsgs_setModeRPC_helper::s_tag) {
11939 helpString.emplace_back(FrameGrabberMsgs_setModeRPC_helper::s_prototype);
11940 }
11941 if (functionName == FrameGrabberMsgs_getModeRPC_helper::s_tag) {
11942 helpString.emplace_back(FrameGrabberMsgs_getModeRPC_helper::s_prototype);
11943 }
11946 }
11949 }
11952 }
11955 }
11958 }
11961 }
11964 }
11967 }
11970 }
11973 }
11976 }
11979 }
11982 }
11985 }
11988 }
11991 }
11994 }
11997 }
12000 }
12003 }
12006 }
12009 }
12012 }
12015 }
12018 }
12021 }
12022 if (functionName == "help") {
12023 helpString.emplace_back("std::vector<std::string> help(const std::string& functionName = \"--all\")");
12024 helpString.emplace_back("Return list of available commands, or help message for a specific function");
12025 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");
12026 helpString.emplace_back("@return list of strings (one string per line)");
12027 }
12028 }
12029 if (helpString.empty()) {
12030 helpString.emplace_back("Command not found");
12031 }
12032 return helpString;
12033}
12034
12035// read from ConnectionReader
12037{
12038 constexpr size_t max_tag_len = 1;
12039 size_t tag_len = 1;
12040
12041 yarp::os::idl::WireReader reader(connection);
12042 reader.expectAccept();
12043 if (!reader.readListHeader()) {
12044 reader.fail();
12045 return false;
12046 }
12047
12048 std::string tag = reader.readTag(1);
12049 bool direct = (tag == "__direct__");
12050 if (direct) {
12051 tag = reader.readTag(1);
12052 }
12053 while (tag_len <= max_tag_len && !reader.isError()) {
12054 if(tag == "getRemoteProtocolVersion") {
12055 if (!reader.noMore()) {
12056 yError("Reader invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
12057 reader.fail();
12058 return false;
12059 }
12060
12061 auto proto = getLocalProtocolVersion();
12062
12063 yarp::os::idl::WireWriter writer(reader);
12064 if (!writer.writeListHeader(1)) {
12065 yWarning("Writer invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
12066 return false;}
12067 if (!writer.write(proto)) {
12068 yWarning("Writer invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
12069 return false;
12070 }
12071 reader.accept();
12072 return true;
12073 }
12076 if (!helper.cmd.readArgs(reader)) {
12077 return false;
12078 }
12079
12080 helper.call(this);
12081
12082 yarp::os::idl::WireWriter writer(reader);
12083 if (!helper.reply.write(writer)) {
12084 return false;
12085 }
12086 reader.accept();
12087 return true;
12088 }
12091 if (!helper.cmd.readArgs(reader)) {
12092 return false;
12093 }
12094
12095 helper.call(this);
12096
12097 yarp::os::idl::WireWriter writer(reader);
12098 if (!helper.reply.write(writer)) {
12099 return false;
12100 }
12101 reader.accept();
12102 return true;
12103 }
12106 if (!helper.cmd.readArgs(reader)) {
12107 return false;
12108 }
12109
12110 helper.call(this);
12111
12112 yarp::os::idl::WireWriter writer(reader);
12113 if (!helper.reply.write(writer)) {
12114 return false;
12115 }
12116 reader.accept();
12117 return true;
12118 }
12121 if (!helper.cmd.readArgs(reader)) {
12122 return false;
12123 }
12124
12125 helper.call(this);
12126
12127 yarp::os::idl::WireWriter writer(reader);
12128 if (!helper.reply.write(writer)) {
12129 return false;
12130 }
12131 reader.accept();
12132 return true;
12133 }
12136 if (!helper.cmd.readArgs(reader)) {
12137 return false;
12138 }
12139
12140 helper.call(this);
12141
12142 yarp::os::idl::WireWriter writer(reader);
12143 if (!helper.reply.write(writer)) {
12144 return false;
12145 }
12146 reader.accept();
12147 return true;
12148 }
12151 if (!helper.cmd.readArgs(reader)) {
12152 return false;
12153 }
12154
12155 helper.call(this);
12156
12157 yarp::os::idl::WireWriter writer(reader);
12158 if (!helper.reply.write(writer)) {
12159 return false;
12160 }
12161 reader.accept();
12162 return true;
12163 }
12166 if (!helper.cmd.readArgs(reader)) {
12167 return false;
12168 }
12169
12170 helper.call(this);
12171
12172 yarp::os::idl::WireWriter writer(reader);
12173 if (!helper.reply.write(writer)) {
12174 return false;
12175 }
12176 reader.accept();
12177 return true;
12178 }
12181 if (!helper.cmd.readArgs(reader)) {
12182 return false;
12183 }
12184
12185 helper.call(this);
12186
12187 yarp::os::idl::WireWriter writer(reader);
12188 if (!helper.reply.write(writer)) {
12189 return false;
12190 }
12191 reader.accept();
12192 return true;
12193 }
12196 if (!helper.cmd.readArgs(reader)) {
12197 return false;
12198 }
12199
12200 helper.call(this);
12201
12202 yarp::os::idl::WireWriter writer(reader);
12203 if (!helper.reply.write(writer)) {
12204 return false;
12205 }
12206 reader.accept();
12207 return true;
12208 }
12211 if (!helper.cmd.readArgs(reader)) {
12212 return false;
12213 }
12214
12215 helper.call(this);
12216
12217 yarp::os::idl::WireWriter writer(reader);
12218 if (!helper.reply.write(writer)) {
12219 return false;
12220 }
12221 reader.accept();
12222 return true;
12223 }
12226 if (!helper.cmd.readArgs(reader)) {
12227 return false;
12228 }
12229
12230 helper.call(this);
12231
12232 yarp::os::idl::WireWriter writer(reader);
12233 if (!helper.reply.write(writer)) {
12234 return false;
12235 }
12236 reader.accept();
12237 return true;
12238 }
12241 if (!helper.cmd.readArgs(reader)) {
12242 return false;
12243 }
12244
12245 helper.call(this);
12246
12247 yarp::os::idl::WireWriter writer(reader);
12248 if (!helper.reply.write(writer)) {
12249 return false;
12250 }
12251 reader.accept();
12252 return true;
12253 }
12256 if (!helper.cmd.readArgs(reader)) {
12257 return false;
12258 }
12259
12260 helper.call(this);
12261
12262 yarp::os::idl::WireWriter writer(reader);
12263 if (!helper.reply.write(writer)) {
12264 return false;
12265 }
12266 reader.accept();
12267 return true;
12268 }
12271 if (!helper.cmd.readArgs(reader)) {
12272 return false;
12273 }
12274
12275 helper.call(this);
12276
12277 yarp::os::idl::WireWriter writer(reader);
12278 if (!helper.reply.write(writer)) {
12279 return false;
12280 }
12281 reader.accept();
12282 return true;
12283 }
12286 if (!helper.cmd.readArgs(reader)) {
12287 return false;
12288 }
12289
12290 helper.call(this);
12291
12292 yarp::os::idl::WireWriter writer(reader);
12293 if (!helper.reply.write(writer)) {
12294 return false;
12295 }
12296 reader.accept();
12297 return true;
12298 }
12301 if (!helper.cmd.readArgs(reader)) {
12302 return false;
12303 }
12304
12305 helper.call(this);
12306
12307 yarp::os::idl::WireWriter writer(reader);
12308 if (!helper.reply.write(writer)) {
12309 return false;
12310 }
12311 reader.accept();
12312 return true;
12313 }
12316 if (!helper.cmd.readArgs(reader)) {
12317 return false;
12318 }
12319
12320 helper.call(this);
12321
12322 yarp::os::idl::WireWriter writer(reader);
12323 if (!helper.reply.write(writer)) {
12324 return false;
12325 }
12326 reader.accept();
12327 return true;
12328 }
12331 if (!helper.cmd.readArgs(reader)) {
12332 return false;
12333 }
12334
12335 helper.call(this);
12336
12337 yarp::os::idl::WireWriter writer(reader);
12338 if (!helper.reply.write(writer)) {
12339 return false;
12340 }
12341 reader.accept();
12342 return true;
12343 }
12346 if (!helper.cmd.readArgs(reader)) {
12347 return false;
12348 }
12349
12350 helper.call(this);
12351
12352 yarp::os::idl::WireWriter writer(reader);
12353 if (!helper.reply.write(writer)) {
12354 return false;
12355 }
12356 reader.accept();
12357 return true;
12358 }
12361 if (!helper.cmd.readArgs(reader)) {
12362 return false;
12363 }
12364
12365 helper.call(this);
12366
12367 yarp::os::idl::WireWriter writer(reader);
12368 if (!helper.reply.write(writer)) {
12369 return false;
12370 }
12371 reader.accept();
12372 return true;
12373 }
12376 if (!helper.cmd.readArgs(reader)) {
12377 return false;
12378 }
12379
12380 helper.call(this);
12381
12382 yarp::os::idl::WireWriter writer(reader);
12383 if (!helper.reply.write(writer)) {
12384 return false;
12385 }
12386 reader.accept();
12387 return true;
12388 }
12391 if (!helper.cmd.readArgs(reader)) {
12392 return false;
12393 }
12394
12395 helper.call(this);
12396
12397 yarp::os::idl::WireWriter writer(reader);
12398 if (!helper.reply.write(writer)) {
12399 return false;
12400 }
12401 reader.accept();
12402 return true;
12403 }
12406 if (!helper.cmd.readArgs(reader)) {
12407 return false;
12408 }
12409
12410 helper.call(this);
12411
12412 yarp::os::idl::WireWriter writer(reader);
12413 if (!helper.reply.write(writer)) {
12414 return false;
12415 }
12416 reader.accept();
12417 return true;
12418 }
12421 if (!helper.cmd.readArgs(reader)) {
12422 return false;
12423 }
12424
12425 helper.call(this);
12426
12427 yarp::os::idl::WireWriter writer(reader);
12428 if (!helper.reply.write(writer)) {
12429 return false;
12430 }
12431 reader.accept();
12432 return true;
12433 }
12436 if (!helper.cmd.readArgs(reader)) {
12437 return false;
12438 }
12439
12440 helper.call(this);
12441
12442 yarp::os::idl::WireWriter writer(reader);
12443 if (!helper.reply.write(writer)) {
12444 return false;
12445 }
12446 reader.accept();
12447 return true;
12448 }
12451 if (!helper.cmd.readArgs(reader)) {
12452 return false;
12453 }
12454
12455 helper.call(this);
12456
12457 yarp::os::idl::WireWriter writer(reader);
12458 if (!helper.reply.write(writer)) {
12459 return false;
12460 }
12461 reader.accept();
12462 return true;
12463 }
12466 if (!helper.cmd.readArgs(reader)) {
12467 return false;
12468 }
12469
12470 helper.call(this);
12471
12472 yarp::os::idl::WireWriter writer(reader);
12473 if (!helper.reply.write(writer)) {
12474 return false;
12475 }
12476 reader.accept();
12477 return true;
12478 }
12481 if (!helper.cmd.readArgs(reader)) {
12482 return false;
12483 }
12484
12485 helper.call(this);
12486
12487 yarp::os::idl::WireWriter writer(reader);
12488 if (!helper.reply.write(writer)) {
12489 return false;
12490 }
12491 reader.accept();
12492 return true;
12493 }
12496 if (!helper.cmd.readArgs(reader)) {
12497 return false;
12498 }
12499
12500 helper.call(this);
12501
12502 yarp::os::idl::WireWriter writer(reader);
12503 if (!helper.reply.write(writer)) {
12504 return false;
12505 }
12506 reader.accept();
12507 return true;
12508 }
12511 if (!helper.cmd.readArgs(reader)) {
12512 return false;
12513 }
12514
12515 helper.call(this);
12516
12517 yarp::os::idl::WireWriter writer(reader);
12518 if (!helper.reply.write(writer)) {
12519 return false;
12520 }
12521 reader.accept();
12522 return true;
12523 }
12526 if (!helper.cmd.readArgs(reader)) {
12527 return false;
12528 }
12529
12530 helper.call(this);
12531
12532 yarp::os::idl::WireWriter writer(reader);
12533 if (!helper.reply.write(writer)) {
12534 return false;
12535 }
12536 reader.accept();
12537 return true;
12538 }
12541 if (!helper.cmd.readArgs(reader)) {
12542 return false;
12543 }
12544
12545 helper.call(this);
12546
12547 yarp::os::idl::WireWriter writer(reader);
12548 if (!helper.reply.write(writer)) {
12549 return false;
12550 }
12551 reader.accept();
12552 return true;
12553 }
12556 if (!helper.cmd.readArgs(reader)) {
12557 return false;
12558 }
12559
12560 helper.call(this);
12561
12562 yarp::os::idl::WireWriter writer(reader);
12563 if (!helper.reply.write(writer)) {
12564 return false;
12565 }
12566 reader.accept();
12567 return true;
12568 }
12571 if (!helper.cmd.readArgs(reader)) {
12572 return false;
12573 }
12574
12575 helper.call(this);
12576
12577 yarp::os::idl::WireWriter writer(reader);
12578 if (!helper.reply.write(writer)) {
12579 return false;
12580 }
12581 reader.accept();
12582 return true;
12583 }
12586 if (!helper.cmd.readArgs(reader)) {
12587 return false;
12588 }
12589
12590 helper.call(this);
12591
12592 yarp::os::idl::WireWriter writer(reader);
12593 if (!helper.reply.write(writer)) {
12594 return false;
12595 }
12596 reader.accept();
12597 return true;
12598 }
12601 if (!helper.cmd.readArgs(reader)) {
12602 return false;
12603 }
12604
12605 helper.call(this);
12606
12607 yarp::os::idl::WireWriter writer(reader);
12608 if (!helper.reply.write(writer)) {
12609 return false;
12610 }
12611 reader.accept();
12612 return true;
12613 }
12616 if (!helper.cmd.readArgs(reader)) {
12617 return false;
12618 }
12619
12620 helper.call(this);
12621
12622 yarp::os::idl::WireWriter writer(reader);
12623 if (!helper.reply.write(writer)) {
12624 return false;
12625 }
12626 reader.accept();
12627 return true;
12628 }
12631 if (!helper.cmd.readArgs(reader)) {
12632 return false;
12633 }
12634
12635 helper.call(this);
12636
12637 yarp::os::idl::WireWriter writer(reader);
12638 if (!helper.reply.write(writer)) {
12639 return false;
12640 }
12641 reader.accept();
12642 return true;
12643 }
12646 if (!helper.cmd.readArgs(reader)) {
12647 return false;
12648 }
12649
12650 helper.call(this);
12651
12652 yarp::os::idl::WireWriter writer(reader);
12653 if (!helper.reply.write(writer)) {
12654 return false;
12655 }
12656 reader.accept();
12657 return true;
12658 }
12661 if (!helper.cmd.readArgs(reader)) {
12662 return false;
12663 }
12664
12665 helper.call(this);
12666
12667 yarp::os::idl::WireWriter writer(reader);
12668 if (!helper.reply.write(writer)) {
12669 return false;
12670 }
12671 reader.accept();
12672 return true;
12673 }
12676 if (!helper.cmd.readArgs(reader)) {
12677 return false;
12678 }
12679
12680 helper.call(this);
12681
12682 yarp::os::idl::WireWriter writer(reader);
12683 if (!helper.reply.write(writer)) {
12684 return false;
12685 }
12686 reader.accept();
12687 return true;
12688 }
12691 if (!helper.cmd.readArgs(reader)) {
12692 return false;
12693 }
12694
12695 helper.call(this);
12696
12697 yarp::os::idl::WireWriter writer(reader);
12698 if (!helper.reply.write(writer)) {
12699 return false;
12700 }
12701 reader.accept();
12702 return true;
12703 }
12706 if (!helper.cmd.readArgs(reader)) {
12707 return false;
12708 }
12709
12710 helper.call(this);
12711
12712 yarp::os::idl::WireWriter writer(reader);
12713 if (!helper.reply.write(writer)) {
12714 return false;
12715 }
12716 reader.accept();
12717 return true;
12718 }
12721 if (!helper.cmd.readArgs(reader)) {
12722 return false;
12723 }
12724
12725 helper.call(this);
12726
12727 yarp::os::idl::WireWriter writer(reader);
12728 if (!helper.reply.write(writer)) {
12729 return false;
12730 }
12731 reader.accept();
12732 return true;
12733 }
12736 if (!helper.cmd.readArgs(reader)) {
12737 return false;
12738 }
12739
12740 helper.call(this);
12741
12742 yarp::os::idl::WireWriter writer(reader);
12743 if (!helper.reply.write(writer)) {
12744 return false;
12745 }
12746 reader.accept();
12747 return true;
12748 }
12751 if (!helper.cmd.readArgs(reader)) {
12752 return false;
12753 }
12754
12755 helper.call(this);
12756
12757 yarp::os::idl::WireWriter writer(reader);
12758 if (!helper.reply.write(writer)) {
12759 return false;
12760 }
12761 reader.accept();
12762 return true;
12763 }
12766 if (!helper.cmd.readArgs(reader)) {
12767 return false;
12768 }
12769
12770 helper.call(this);
12771
12772 yarp::os::idl::WireWriter writer(reader);
12773 if (!helper.reply.write(writer)) {
12774 return false;
12775 }
12776 reader.accept();
12777 return true;
12778 }
12781 if (!helper.cmd.readArgs(reader)) {
12782 return false;
12783 }
12784
12785 helper.call(this);
12786
12787 yarp::os::idl::WireWriter writer(reader);
12788 if (!helper.reply.write(writer)) {
12789 return false;
12790 }
12791 reader.accept();
12792 return true;
12793 }
12796 if (!helper.cmd.readArgs(reader)) {
12797 return false;
12798 }
12799
12800 helper.call(this);
12801
12802 yarp::os::idl::WireWriter writer(reader);
12803 if (!helper.reply.write(writer)) {
12804 return false;
12805 }
12806 reader.accept();
12807 return true;
12808 }
12811 if (!helper.cmd.readArgs(reader)) {
12812 return false;
12813 }
12814
12815 helper.call(this);
12816
12817 yarp::os::idl::WireWriter writer(reader);
12818 if (!helper.reply.write(writer)) {
12819 return false;
12820 }
12821 reader.accept();
12822 return true;
12823 }
12826 if (!helper.cmd.readArgs(reader)) {
12827 return false;
12828 }
12829
12830 helper.call(this);
12831
12832 yarp::os::idl::WireWriter writer(reader);
12833 if (!helper.reply.write(writer)) {
12834 return false;
12835 }
12836 reader.accept();
12837 return true;
12838 }
12841 if (!helper.cmd.readArgs(reader)) {
12842 return false;
12843 }
12844
12845 helper.call(this);
12846
12847 yarp::os::idl::WireWriter writer(reader);
12848 if (!helper.reply.write(writer)) {
12849 return false;
12850 }
12851 reader.accept();
12852 return true;
12853 }
12856 if (!helper.cmd.readArgs(reader)) {
12857 return false;
12858 }
12859
12860 helper.call(this);
12861
12862 yarp::os::idl::WireWriter writer(reader);
12863 if (!helper.reply.write(writer)) {
12864 return false;
12865 }
12866 reader.accept();
12867 return true;
12868 }
12871 if (!helper.cmd.readArgs(reader)) {
12872 return false;
12873 }
12874
12875 helper.call(this);
12876
12877 yarp::os::idl::WireWriter writer(reader);
12878 if (!helper.reply.write(writer)) {
12879 return false;
12880 }
12881 reader.accept();
12882 return true;
12883 }
12884 if (tag == "help") {
12885 std::string functionName;
12886 if (!reader.readString(functionName)) {
12887 functionName = "--all";
12888 }
12889 auto help_strings = help(functionName);
12890 yarp::os::idl::WireWriter writer(reader);
12891 if (!writer.isNull()) {
12892 if (!writer.writeListHeader(2)) {
12893 return false;
12894 }
12895 if (!writer.writeTag("many", 1, 0)) {
12896 return false;
12897 }
12898 if (!writer.writeListBegin(0, help_strings.size())) {
12899 return false;
12900 }
12901 for (const auto& help_string : help_strings) {
12902 if (!writer.writeString(help_string)) {
12903 return false;
12904 }
12905 }
12906 if (!writer.writeListEnd()) {
12907 return false;
12908 }
12909 }
12910 reader.accept();
12911 return true;
12912 }
12913 if (reader.noMore()) {
12914 reader.fail();
12915 return false;
12916 }
12917 std::string next_tag = reader.readTag(1);
12918 if (next_tag.empty()) {
12919 break;
12920 }
12921 tag.append("_").append(next_tag);
12922 tag_len = std::count(tag.begin(), tag.end(), '_') + 1;
12923 }
12924 return false;
12925}
#define BOTTLE_TAG_LIST
Definition Bottle.h:29
#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