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 (based on compiler 0.14.1-yarped)
7// yarpidl_thrift version 2.0 - 11/11/2026
8// Protocol version: protocol_version=0, yarp_major=4, yarp_minor=0, yarp_patch=2
9// This is an automatically generated file.
10// It could get re-generated if the ALLOW_IDL_GENERATION flag is on.
11
12#include <yarp/conf/version.h>
13#include <FrameGrabberMsgs.h>
15#include <yarp/os/LogStream.h>
16
18
19#include <algorithm>
20
21namespace
22{
23 YARP_LOG_COMPONENT(SERVICE_LOG_COMPONENT, "FrameGrabberMsgs")
24}
25
26//FrameGrabberMsgs_getRemoteProtocolVersion_helper declaration
37
39{
40 yarp::os::idl::WireWriter writer(connection);
41 if (!writer.writeListHeader(1)) {
42 return false;
43 }
44 if (!writer.writeString("getRemoteProtocolVersion")) {
45 return false;
46 }
47 return true;
48}
49
50bool FrameGrabberMsgs_getRemoteProtocolVersion_helper ::read(yarp::os::ConnectionReader & connection)
51 {
52 yarp::os::idl::WireReader reader(connection);
53 if (!reader.readListHeader()) {
54 reader.fail();
55 return false;
56 }
57
58 if (!helper_proto.read(connection)) {
59 reader.fail();
60 return false;
61 }
62 return true;
63}
64
65//ProtocolVersion, client side
67 {
68 if(!yarp().canWrite()) {
69 yError(" Missing server method FrameGrabberMsgs::getRemoteProtocolVersion");
70 }
72 bool ok = yarp().write(helper, helper);
73 if (ok) {
74 return helper.helper_proto;}
75 else {
77 return failureproto;}
78}
79
80//ProtocolVersion, client side
82 {
83 auto locproto = this->getLocalProtocolVersion();
84 auto remproto = this->getRemoteProtocolVersion();
85 if (remproto.protocol_version != locproto.protocol_version)
86 {
87 yCError(SERVICE_LOG_COMPONENT) << "Invalid communication protocol.";
88 yCError(SERVICE_LOG_COMPONENT) << "Local Protocol Version: " << locproto.toString();
89 yCError(SERVICE_LOG_COMPONENT) << "Remote Protocol Version: " << remproto.toString();
90 return false;
91 }
92 return true;
93}
94
95//ProtocolVersion, server side
97{
99 //myproto.protocol_version using default value = 0
100 //to change this value add the following line to the .thrift file:
101 //const i16 protocol_version = <your_number_here>
102 myproto.protocol_version = 0;
106 return myproto;
107}
108
109// getHeightRPC helper class declaration
111 public yarp::os::Portable
112{
113public:
115 bool write(yarp::os::ConnectionWriter& connection) const override;
116 bool read(yarp::os::ConnectionReader& connection) override;
117
118 class Command :
120 {
121 public:
122 Command() = default;
123 ~Command() override = default;
124
125 bool write(yarp::os::ConnectionWriter& connection) const override;
126 bool read(yarp::os::ConnectionReader& connection) override;
127
128 bool write(const yarp::os::idl::WireWriter& writer) const override;
129 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
130 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
131
132 bool read(yarp::os::idl::WireReader& reader) override;
135 };
136
137 class Reply :
139 {
140 public:
141 Reply() = default;
142 ~Reply() override = default;
143
144 bool write(yarp::os::ConnectionWriter& connection) const override;
145 bool read(yarp::os::ConnectionReader& connection) override;
146
147 bool write(const yarp::os::idl::WireWriter& writer) const override;
148 bool read(yarp::os::idl::WireReader& reader) override;
149
151 };
152
154 void call(FrameGrabberMsgs* ptr);
155
158
159 static constexpr const char* s_tag{"getHeightRPC"};
160 static constexpr size_t s_tag_len{1};
161 static constexpr size_t s_cmd_len{1};
162 static constexpr size_t s_reply_len{2};
163 static constexpr const char* s_prototype{"IFrameGrabberImageOf_return_getHeight FrameGrabberMsgs::getHeightRPC()"};
164 static constexpr const char* s_help{""};
165};
166
167// getWidthRPC helper class declaration
169 public yarp::os::Portable
170{
171public:
173 bool write(yarp::os::ConnectionWriter& connection) const override;
174 bool read(yarp::os::ConnectionReader& connection) override;
175
176 class Command :
178 {
179 public:
180 Command() = default;
181 ~Command() override = default;
182
183 bool write(yarp::os::ConnectionWriter& connection) const override;
184 bool read(yarp::os::ConnectionReader& connection) override;
185
186 bool write(const yarp::os::idl::WireWriter& writer) const override;
187 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
188 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
189
190 bool read(yarp::os::idl::WireReader& reader) override;
193 };
194
195 class Reply :
197 {
198 public:
199 Reply() = default;
200 ~Reply() override = default;
201
202 bool write(yarp::os::ConnectionWriter& connection) const override;
203 bool read(yarp::os::ConnectionReader& connection) override;
204
205 bool write(const yarp::os::idl::WireWriter& writer) const override;
206 bool read(yarp::os::idl::WireReader& reader) override;
207
209 };
210
212 void call(FrameGrabberMsgs* ptr);
213
216
217 static constexpr const char* s_tag{"getWidthRPC"};
218 static constexpr size_t s_tag_len{1};
219 static constexpr size_t s_cmd_len{1};
220 static constexpr size_t s_reply_len{2};
221 static constexpr const char* s_prototype{"IFrameGrabberImageOf_return_getWidth FrameGrabberMsgs::getWidthRPC()"};
222 static constexpr const char* s_help{""};
223};
224
225// getImageRPC helper class declaration
227 public yarp::os::Portable
228{
229public:
231 bool write(yarp::os::ConnectionWriter& connection) const override;
232 bool read(yarp::os::ConnectionReader& connection) override;
233
234 class Command :
236 {
237 public:
238 Command() = default;
239 ~Command() override = default;
240
241 bool write(yarp::os::ConnectionWriter& connection) const override;
242 bool read(yarp::os::ConnectionReader& connection) override;
243
244 bool write(const yarp::os::idl::WireWriter& writer) const override;
245 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
246 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
247
248 bool read(yarp::os::idl::WireReader& reader) override;
251 };
252
253 class Reply :
255 {
256 public:
257 Reply() = default;
258 ~Reply() override = default;
259
260 bool write(yarp::os::ConnectionWriter& connection) const override;
261 bool read(yarp::os::ConnectionReader& connection) override;
262
263 bool write(const yarp::os::idl::WireWriter& writer) const override;
264 bool read(yarp::os::idl::WireReader& reader) override;
265
267 };
268
270 void call(FrameGrabberMsgs* ptr);
271
274
275 static constexpr const char* s_tag{"getImageRPC"};
276 static constexpr size_t s_tag_len{1};
277 static constexpr size_t s_cmd_len{1};
278 static constexpr size_t s_reply_len{2};
279 static constexpr const char* s_prototype{"IFrameGrabberImageOf_return_getImage FrameGrabberMsgs::getImageRPC()"};
280 static constexpr const char* s_help{""};
281};
282
283// getImageCropRPC helper class declaration
285 public yarp::os::Portable
286{
287public:
289 FrameGrabberMsgs_getImageCropRPC_helper(const yarp::dev::cropType_id_t type, const std::vector<yarp::dev::VertexData>& vertices);
290 bool write(yarp::os::ConnectionWriter& connection) const override;
291 bool read(yarp::os::ConnectionReader& connection) override;
292
293 class Command :
295 {
296 public:
297 Command() = default;
298 Command(const yarp::dev::cropType_id_t type, const std::vector<yarp::dev::VertexData>& vertices);
299
300 ~Command() override = default;
301
302 bool write(yarp::os::ConnectionWriter& connection) const override;
303 bool read(yarp::os::ConnectionReader& connection) override;
304
305 bool write(const yarp::os::idl::WireWriter& writer) const override;
306 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
307 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
308
309 bool read(yarp::os::idl::WireReader& reader) override;
312
314 std::vector<yarp::dev::VertexData> vertices{};
315 };
316
317 class Reply :
319 {
320 public:
321 Reply() = default;
322 ~Reply() override = default;
323
324 bool write(yarp::os::ConnectionWriter& connection) const override;
325 bool read(yarp::os::ConnectionReader& connection) override;
326
327 bool write(const yarp::os::idl::WireWriter& writer) const override;
328 bool read(yarp::os::idl::WireReader& reader) override;
329
331 };
332
333 using funcptr_t = IFrameGrabberImageOf_return_getImageCrop (*)(const yarp::dev::cropType_id_t, const std::vector<yarp::dev::VertexData>&);
334 void call(FrameGrabberMsgs* ptr);
335
338
339 static constexpr const char* s_tag{"getImageCropRPC"};
340 static constexpr size_t s_tag_len{1};
341 static constexpr size_t s_cmd_len{3};
342 static constexpr size_t s_reply_len{2};
343 static constexpr const char* s_prototype{"IFrameGrabberImageOf_return_getImageCrop FrameGrabberMsgs::getImageCropRPC(const yarp::dev::cropType_id_t type, const std::vector<yarp::dev::VertexData>& vertices)"};
344 static constexpr const char* s_help{""};
345};
346
347// getRgbWidthRPC helper class declaration
349 public yarp::os::Portable
350{
351public:
353 bool write(yarp::os::ConnectionWriter& connection) const override;
354 bool read(yarp::os::ConnectionReader& connection) override;
355
356 class Command :
358 {
359 public:
360 Command() = default;
361 ~Command() override = default;
362
363 bool write(yarp::os::ConnectionWriter& connection) const override;
364 bool read(yarp::os::ConnectionReader& connection) override;
365
366 bool write(const yarp::os::idl::WireWriter& writer) const override;
367 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
368 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
369
370 bool read(yarp::os::idl::WireReader& reader) override;
373 };
374
375 class Reply :
377 {
378 public:
379 Reply() = default;
380 ~Reply() override = default;
381
382 bool write(yarp::os::ConnectionWriter& connection) const override;
383 bool read(yarp::os::ConnectionReader& connection) override;
384
385 bool write(const yarp::os::idl::WireWriter& writer) const override;
386 bool read(yarp::os::idl::WireReader& reader) override;
387
389 };
390
392 void call(FrameGrabberMsgs* ptr);
393
396
397 static constexpr const char* s_tag{"getRgbWidthRPC"};
398 static constexpr size_t s_tag_len{1};
399 static constexpr size_t s_cmd_len{1};
400 static constexpr size_t s_reply_len{2};
401 static constexpr const char* s_prototype{"IRGBVisualParamsMsgs_return_getRgbWidth FrameGrabberMsgs::getRgbWidthRPC()"};
402 static constexpr const char* s_help{""};
403};
404
405// getRgbHeightRPC helper class declaration
407 public yarp::os::Portable
408{
409public:
411 bool write(yarp::os::ConnectionWriter& connection) const override;
412 bool read(yarp::os::ConnectionReader& connection) override;
413
414 class Command :
416 {
417 public:
418 Command() = default;
419 ~Command() override = default;
420
421 bool write(yarp::os::ConnectionWriter& connection) const override;
422 bool read(yarp::os::ConnectionReader& connection) override;
423
424 bool write(const yarp::os::idl::WireWriter& writer) const override;
425 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
426 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
427
428 bool read(yarp::os::idl::WireReader& reader) override;
431 };
432
433 class Reply :
435 {
436 public:
437 Reply() = default;
438 ~Reply() override = default;
439
440 bool write(yarp::os::ConnectionWriter& connection) const override;
441 bool read(yarp::os::ConnectionReader& connection) override;
442
443 bool write(const yarp::os::idl::WireWriter& writer) const override;
444 bool read(yarp::os::idl::WireReader& reader) override;
445
447 };
448
450 void call(FrameGrabberMsgs* ptr);
451
454
455 static constexpr const char* s_tag{"getRgbHeightRPC"};
456 static constexpr size_t s_tag_len{1};
457 static constexpr size_t s_cmd_len{1};
458 static constexpr size_t s_reply_len{2};
459 static constexpr const char* s_prototype{"IRGBVisualParamsMsgs_return_getRgbHeight FrameGrabberMsgs::getRgbHeightRPC()"};
460 static constexpr const char* s_help{""};
461};
462
463// getRgbSupportedConfigurationsRPC helper class declaration
465 public yarp::os::Portable
466{
467public:
469 bool write(yarp::os::ConnectionWriter& connection) const override;
470 bool read(yarp::os::ConnectionReader& connection) override;
471
472 class Command :
474 {
475 public:
476 Command() = default;
477 ~Command() override = default;
478
479 bool write(yarp::os::ConnectionWriter& connection) const override;
480 bool read(yarp::os::ConnectionReader& connection) override;
481
482 bool write(const yarp::os::idl::WireWriter& writer) const override;
483 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
484 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
485
486 bool read(yarp::os::idl::WireReader& reader) override;
489 };
490
491 class Reply :
493 {
494 public:
495 Reply() = default;
496 ~Reply() override = default;
497
498 bool write(yarp::os::ConnectionWriter& connection) const override;
499 bool read(yarp::os::ConnectionReader& connection) override;
500
501 bool write(const yarp::os::idl::WireWriter& writer) const override;
502 bool read(yarp::os::idl::WireReader& reader) override;
503
505 };
506
508 void call(FrameGrabberMsgs* ptr);
509
512
513 static constexpr const char* s_tag{"getRgbSupportedConfigurationsRPC"};
514 static constexpr size_t s_tag_len{1};
515 static constexpr size_t s_cmd_len{1};
516 static constexpr size_t s_reply_len{2};
517 static constexpr const char* s_prototype{"IRGBVisualParamsMsgs_return_getRgbSupportedCfg FrameGrabberMsgs::getRgbSupportedConfigurationsRPC()"};
518 static constexpr const char* s_help{""};
519};
520
521// getRgbResolutionRPC helper class declaration
523 public yarp::os::Portable
524{
525public:
527 bool write(yarp::os::ConnectionWriter& connection) const override;
528 bool read(yarp::os::ConnectionReader& connection) override;
529
530 class Command :
532 {
533 public:
534 Command() = default;
535 ~Command() override = default;
536
537 bool write(yarp::os::ConnectionWriter& connection) const override;
538 bool read(yarp::os::ConnectionReader& connection) override;
539
540 bool write(const yarp::os::idl::WireWriter& writer) const override;
541 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
542 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
543
544 bool read(yarp::os::idl::WireReader& reader) override;
547 };
548
549 class Reply :
551 {
552 public:
553 Reply() = default;
554 ~Reply() override = default;
555
556 bool write(yarp::os::ConnectionWriter& connection) const override;
557 bool read(yarp::os::ConnectionReader& connection) override;
558
559 bool write(const yarp::os::idl::WireWriter& writer) const override;
560 bool read(yarp::os::idl::WireReader& reader) override;
561
563 };
564
566 void call(FrameGrabberMsgs* ptr);
567
570
571 static constexpr const char* s_tag{"getRgbResolutionRPC"};
572 static constexpr size_t s_tag_len{1};
573 static constexpr size_t s_cmd_len{1};
574 static constexpr size_t s_reply_len{3};
575 static constexpr const char* s_prototype{"IRGBVisualParamsMsgs_return_getRgbResolution FrameGrabberMsgs::getRgbResolutionRPC()"};
576 static constexpr const char* s_help{""};
577};
578
579// setRgbResolutionRPC helper class declaration
581 public yarp::os::Portable
582{
583public:
585 FrameGrabberMsgs_setRgbResolutionRPC_helper(const std::int32_t width, const std::int32_t height);
586 bool write(yarp::os::ConnectionWriter& connection) const override;
587 bool read(yarp::os::ConnectionReader& connection) override;
588
589 class Command :
591 {
592 public:
593 Command() = default;
594 Command(const std::int32_t width, const std::int32_t height);
595
596 ~Command() override = default;
597
598 bool write(yarp::os::ConnectionWriter& connection) const override;
599 bool read(yarp::os::ConnectionReader& connection) override;
600
601 bool write(const yarp::os::idl::WireWriter& writer) const override;
602 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
603 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
604
605 bool read(yarp::os::idl::WireReader& reader) override;
608
609 std::int32_t width{0};
610 std::int32_t height{0};
611 };
612
613 class Reply :
615 {
616 public:
617 Reply() = default;
618 ~Reply() override = default;
619
620 bool write(yarp::os::ConnectionWriter& connection) const override;
621 bool read(yarp::os::ConnectionReader& connection) override;
622
623 bool write(const yarp::os::idl::WireWriter& writer) const override;
624 bool read(yarp::os::idl::WireReader& reader) override;
625
627 };
628
629 using funcptr_t = yarp::dev::ReturnValue (*)(const std::int32_t, const std::int32_t);
630 void call(FrameGrabberMsgs* ptr);
631
634
635 static constexpr const char* s_tag{"setRgbResolutionRPC"};
636 static constexpr size_t s_tag_len{1};
637 static constexpr size_t s_cmd_len{3};
638 static constexpr size_t s_reply_len{1};
639 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setRgbResolutionRPC(const std::int32_t width, const std::int32_t height)"};
640 static constexpr const char* s_help{""};
641};
642
643// getRgbFOVRPC helper class declaration
645 public yarp::os::Portable
646{
647public:
649 bool write(yarp::os::ConnectionWriter& connection) const override;
650 bool read(yarp::os::ConnectionReader& connection) override;
651
652 class Command :
654 {
655 public:
656 Command() = default;
657 ~Command() override = default;
658
659 bool write(yarp::os::ConnectionWriter& connection) const override;
660 bool read(yarp::os::ConnectionReader& connection) override;
661
662 bool write(const yarp::os::idl::WireWriter& writer) const override;
663 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
664 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
665
666 bool read(yarp::os::idl::WireReader& reader) override;
669 };
670
671 class Reply :
673 {
674 public:
675 Reply() = default;
676 ~Reply() override = default;
677
678 bool write(yarp::os::ConnectionWriter& connection) const override;
679 bool read(yarp::os::ConnectionReader& connection) override;
680
681 bool write(const yarp::os::idl::WireWriter& writer) const override;
682 bool read(yarp::os::idl::WireReader& reader) override;
683
685 };
686
688 void call(FrameGrabberMsgs* ptr);
689
692
693 static constexpr const char* s_tag{"getRgbFOVRPC"};
694 static constexpr size_t s_tag_len{1};
695 static constexpr size_t s_cmd_len{1};
696 static constexpr size_t s_reply_len{3};
697 static constexpr const char* s_prototype{"IRGBVisualParamsMsgs_return_getRgbFOV FrameGrabberMsgs::getRgbFOVRPC()"};
698 static constexpr const char* s_help{""};
699};
700
701// setRgbFOVRPC helper class declaration
703 public yarp::os::Portable
704{
705public:
707 FrameGrabberMsgs_setRgbFOVRPC_helper(const double horizontalFov, const double verticalFov);
708 bool write(yarp::os::ConnectionWriter& connection) const override;
709 bool read(yarp::os::ConnectionReader& connection) override;
710
711 class Command :
713 {
714 public:
715 Command() = default;
716 Command(const double horizontalFov, const double verticalFov);
717
718 ~Command() override = default;
719
720 bool write(yarp::os::ConnectionWriter& connection) const override;
721 bool read(yarp::os::ConnectionReader& connection) override;
722
723 bool write(const yarp::os::idl::WireWriter& writer) const override;
724 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
725 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
726
727 bool read(yarp::os::idl::WireReader& reader) override;
730
731 double horizontalFov{0.0};
732 double verticalFov{0.0};
733 };
734
735 class Reply :
737 {
738 public:
739 Reply() = default;
740 ~Reply() override = default;
741
742 bool write(yarp::os::ConnectionWriter& connection) const override;
743 bool read(yarp::os::ConnectionReader& connection) override;
744
745 bool write(const yarp::os::idl::WireWriter& writer) const override;
746 bool read(yarp::os::idl::WireReader& reader) override;
747
749 };
750
751 using funcptr_t = yarp::dev::ReturnValue (*)(const double, const double);
752 void call(FrameGrabberMsgs* ptr);
753
756
757 static constexpr const char* s_tag{"setRgbFOVRPC"};
758 static constexpr size_t s_tag_len{1};
759 static constexpr size_t s_cmd_len{3};
760 static constexpr size_t s_reply_len{1};
761 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setRgbFOVRPC(const double horizontalFov, const double verticalFov)"};
762 static constexpr const char* s_help{""};
763};
764
765// getRgbIntrinsicParamRPC helper class declaration
767 public yarp::os::Portable
768{
769public:
771 bool write(yarp::os::ConnectionWriter& connection) const override;
772 bool read(yarp::os::ConnectionReader& connection) override;
773
774 class Command :
776 {
777 public:
778 Command() = default;
779 ~Command() override = default;
780
781 bool write(yarp::os::ConnectionWriter& connection) const override;
782 bool read(yarp::os::ConnectionReader& connection) override;
783
784 bool write(const yarp::os::idl::WireWriter& writer) const override;
785 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
786 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
787
788 bool read(yarp::os::idl::WireReader& reader) override;
791 };
792
793 class Reply :
795 {
796 public:
797 Reply() = default;
798 ~Reply() override = default;
799
800 bool write(yarp::os::ConnectionWriter& connection) const override;
801 bool read(yarp::os::ConnectionReader& connection) override;
802
803 bool write(const yarp::os::idl::WireWriter& writer) const override;
804 bool read(yarp::os::idl::WireReader& reader) override;
805
807 };
808
810 void call(FrameGrabberMsgs* ptr);
811
814
815 static constexpr const char* s_tag{"getRgbIntrinsicParamRPC"};
816 static constexpr size_t s_tag_len{1};
817 static constexpr size_t s_cmd_len{1};
818 static constexpr size_t s_reply_len{2};
819 static constexpr const char* s_prototype{"IRGBVisualParamsMsgs_return_getRgbIntrinsicParam FrameGrabberMsgs::getRgbIntrinsicParamRPC()"};
820 static constexpr const char* s_help{""};
821};
822
823// getRgbMirroringRPC helper class declaration
825 public yarp::os::Portable
826{
827public:
829 bool write(yarp::os::ConnectionWriter& connection) const override;
830 bool read(yarp::os::ConnectionReader& connection) override;
831
832 class Command :
834 {
835 public:
836 Command() = default;
837 ~Command() override = default;
838
839 bool write(yarp::os::ConnectionWriter& connection) const override;
840 bool read(yarp::os::ConnectionReader& connection) override;
841
842 bool write(const yarp::os::idl::WireWriter& writer) const override;
843 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
844 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
845
846 bool read(yarp::os::idl::WireReader& reader) override;
849 };
850
851 class Reply :
853 {
854 public:
855 Reply() = default;
856 ~Reply() override = default;
857
858 bool write(yarp::os::ConnectionWriter& connection) const override;
859 bool read(yarp::os::ConnectionReader& connection) override;
860
861 bool write(const yarp::os::idl::WireWriter& writer) const override;
862 bool read(yarp::os::idl::WireReader& reader) override;
863
865 };
866
868 void call(FrameGrabberMsgs* ptr);
869
872
873 static constexpr const char* s_tag{"getRgbMirroringRPC"};
874 static constexpr size_t s_tag_len{1};
875 static constexpr size_t s_cmd_len{1};
876 static constexpr size_t s_reply_len{2};
877 static constexpr const char* s_prototype{"IRGBVisualParamsMsgs_return_getRgbMirroring FrameGrabberMsgs::getRgbMirroringRPC()"};
878 static constexpr const char* s_help{""};
879};
880
881// setRgbMirroringRPC helper class declaration
883 public yarp::os::Portable
884{
885public:
887 explicit FrameGrabberMsgs_setRgbMirroringRPC_helper(const bool mirror);
888 bool write(yarp::os::ConnectionWriter& connection) const override;
889 bool read(yarp::os::ConnectionReader& connection) override;
890
891 class Command :
893 {
894 public:
895 Command() = default;
896 explicit Command(const bool mirror);
897
898 ~Command() override = default;
899
900 bool write(yarp::os::ConnectionWriter& connection) const override;
901 bool read(yarp::os::ConnectionReader& connection) override;
902
903 bool write(const yarp::os::idl::WireWriter& writer) const override;
904 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
905 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
906
907 bool read(yarp::os::idl::WireReader& reader) override;
910
911 bool mirror{false};
912 };
913
914 class Reply :
916 {
917 public:
918 Reply() = default;
919 ~Reply() override = default;
920
921 bool write(yarp::os::ConnectionWriter& connection) const override;
922 bool read(yarp::os::ConnectionReader& connection) override;
923
924 bool write(const yarp::os::idl::WireWriter& writer) const override;
925 bool read(yarp::os::idl::WireReader& reader) override;
926
928 };
929
930 using funcptr_t = yarp::dev::ReturnValue (*)(const bool);
931 void call(FrameGrabberMsgs* ptr);
932
935
936 static constexpr const char* s_tag{"setRgbMirroringRPC"};
937 static constexpr size_t s_tag_len{1};
938 static constexpr size_t s_cmd_len{2};
939 static constexpr size_t s_reply_len{1};
940 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setRgbMirroringRPC(const bool mirror)"};
941 static constexpr const char* s_help{""};
942};
943
944// getCameraDescriptionRPC helper class declaration
946 public yarp::os::Portable
947{
948public:
950 bool write(yarp::os::ConnectionWriter& connection) const override;
951 bool read(yarp::os::ConnectionReader& connection) override;
952
953 class Command :
955 {
956 public:
957 Command() = default;
958 ~Command() override = default;
959
960 bool write(yarp::os::ConnectionWriter& connection) const override;
961 bool read(yarp::os::ConnectionReader& connection) override;
962
963 bool write(const yarp::os::idl::WireWriter& writer) const override;
964 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
965 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
966
967 bool read(yarp::os::idl::WireReader& reader) override;
970 };
971
972 class Reply :
974 {
975 public:
976 Reply() = default;
977 ~Reply() override = default;
978
979 bool write(yarp::os::ConnectionWriter& connection) const override;
980 bool read(yarp::os::ConnectionReader& connection) override;
981
982 bool write(const yarp::os::idl::WireWriter& writer) const override;
983 bool read(yarp::os::idl::WireReader& reader) override;
984
986 };
987
989 void call(FrameGrabberMsgs* ptr);
990
993
994 static constexpr const char* s_tag{"getCameraDescriptionRPC"};
995 static constexpr size_t s_tag_len{1};
996 static constexpr size_t s_cmd_len{1};
997 static constexpr size_t s_reply_len{3};
998 static constexpr const char* s_prototype{"IFrameGrabberControlMsgs_return_getCameraDescription FrameGrabberMsgs::getCameraDescriptionRPC()"};
999 static constexpr const char* s_help{""};
1000};
1001
1002// hasFeatureRPC helper class declaration
1004 public yarp::os::Portable
1005{
1006public:
1008 explicit FrameGrabberMsgs_hasFeatureRPC_helper(const std::int32_t feature);
1009 bool write(yarp::os::ConnectionWriter& connection) const override;
1010 bool read(yarp::os::ConnectionReader& connection) override;
1011
1012 class Command :
1014 {
1015 public:
1016 Command() = default;
1017 explicit Command(const std::int32_t feature);
1018
1019 ~Command() override = default;
1020
1021 bool write(yarp::os::ConnectionWriter& connection) const override;
1022 bool read(yarp::os::ConnectionReader& connection) override;
1023
1024 bool write(const yarp::os::idl::WireWriter& writer) const override;
1025 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1026 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1027
1028 bool read(yarp::os::idl::WireReader& reader) override;
1029 bool readTag(yarp::os::idl::WireReader& reader);
1030 bool readArgs(yarp::os::idl::WireReader& reader);
1031
1032 std::int32_t feature{0};
1033 };
1034
1035 class Reply :
1037 {
1038 public:
1039 Reply() = default;
1040 ~Reply() override = default;
1041
1042 bool write(yarp::os::ConnectionWriter& connection) const override;
1043 bool read(yarp::os::ConnectionReader& connection) override;
1044
1045 bool write(const yarp::os::idl::WireWriter& writer) const override;
1046 bool read(yarp::os::idl::WireReader& reader) override;
1047
1049 };
1050
1052 void call(FrameGrabberMsgs* ptr);
1053
1056
1057 static constexpr const char* s_tag{"hasFeatureRPC"};
1058 static constexpr size_t s_tag_len{1};
1059 static constexpr size_t s_cmd_len{2};
1060 static constexpr size_t s_reply_len{2};
1061 static constexpr const char* s_prototype{"IFrameGrabberControlMsgs_return_hasFeature FrameGrabberMsgs::hasFeatureRPC(const std::int32_t feature)"};
1062 static constexpr const char* s_help{""};
1063};
1064
1065// setFeature1RPC helper class declaration
1067 public yarp::os::Portable
1068{
1069public:
1071 FrameGrabberMsgs_setFeature1RPC_helper(const std::int32_t feature, const double value);
1072 bool write(yarp::os::ConnectionWriter& connection) const override;
1073 bool read(yarp::os::ConnectionReader& connection) override;
1074
1075 class Command :
1077 {
1078 public:
1079 Command() = default;
1080 Command(const std::int32_t feature, const double value);
1081
1082 ~Command() override = default;
1083
1084 bool write(yarp::os::ConnectionWriter& connection) const override;
1085 bool read(yarp::os::ConnectionReader& connection) override;
1086
1087 bool write(const yarp::os::idl::WireWriter& writer) const override;
1088 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1089 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1090
1091 bool read(yarp::os::idl::WireReader& reader) override;
1092 bool readTag(yarp::os::idl::WireReader& reader);
1093 bool readArgs(yarp::os::idl::WireReader& reader);
1094
1095 std::int32_t feature{0};
1096 double value{0.0};
1097 };
1098
1099 class Reply :
1101 {
1102 public:
1103 Reply() = default;
1104 ~Reply() override = default;
1105
1106 bool write(yarp::os::ConnectionWriter& connection) const override;
1107 bool read(yarp::os::ConnectionReader& connection) override;
1108
1109 bool write(const yarp::os::idl::WireWriter& writer) const override;
1110 bool read(yarp::os::idl::WireReader& reader) override;
1111
1113 };
1114
1115 using funcptr_t = yarp::dev::ReturnValue (*)(const std::int32_t, const double);
1116 void call(FrameGrabberMsgs* ptr);
1117
1120
1121 static constexpr const char* s_tag{"setFeature1RPC"};
1122 static constexpr size_t s_tag_len{1};
1123 static constexpr size_t s_cmd_len{3};
1124 static constexpr size_t s_reply_len{1};
1125 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setFeature1RPC(const std::int32_t feature, const double value)"};
1126 static constexpr const char* s_help{""};
1127};
1128
1129// getFeature1RPC helper class declaration
1131 public yarp::os::Portable
1132{
1133public:
1135 explicit FrameGrabberMsgs_getFeature1RPC_helper(const std::int32_t feature);
1136 bool write(yarp::os::ConnectionWriter& connection) const override;
1137 bool read(yarp::os::ConnectionReader& connection) override;
1138
1139 class Command :
1141 {
1142 public:
1143 Command() = default;
1144 explicit Command(const std::int32_t feature);
1145
1146 ~Command() override = default;
1147
1148 bool write(yarp::os::ConnectionWriter& connection) const override;
1149 bool read(yarp::os::ConnectionReader& connection) override;
1150
1151 bool write(const yarp::os::idl::WireWriter& writer) const override;
1152 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1153 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1154
1155 bool read(yarp::os::idl::WireReader& reader) override;
1156 bool readTag(yarp::os::idl::WireReader& reader);
1157 bool readArgs(yarp::os::idl::WireReader& reader);
1158
1159 std::int32_t feature{0};
1160 };
1161
1162 class Reply :
1164 {
1165 public:
1166 Reply() = default;
1167 ~Reply() override = default;
1168
1169 bool write(yarp::os::ConnectionWriter& connection) const override;
1170 bool read(yarp::os::ConnectionReader& connection) override;
1171
1172 bool write(const yarp::os::idl::WireWriter& writer) const override;
1173 bool read(yarp::os::idl::WireReader& reader) override;
1174
1176 };
1177
1179 void call(FrameGrabberMsgs* ptr);
1180
1183
1184 static constexpr const char* s_tag{"getFeature1RPC"};
1185 static constexpr size_t s_tag_len{1};
1186 static constexpr size_t s_cmd_len{2};
1187 static constexpr size_t s_reply_len{2};
1188 static constexpr const char* s_prototype{"IFrameGrabberControlMsgs_return_getFeature1 FrameGrabberMsgs::getFeature1RPC(const std::int32_t feature)"};
1189 static constexpr const char* s_help{""};
1190};
1191
1192// setFeature2RPC helper class declaration
1194 public yarp::os::Portable
1195{
1196public:
1198 FrameGrabberMsgs_setFeature2RPC_helper(const std::int32_t feature, const double value1, const double value2);
1199 bool write(yarp::os::ConnectionWriter& connection) const override;
1200 bool read(yarp::os::ConnectionReader& connection) override;
1201
1202 class Command :
1204 {
1205 public:
1206 Command() = default;
1207 Command(const std::int32_t feature, const double value1, const double value2);
1208
1209 ~Command() override = default;
1210
1211 bool write(yarp::os::ConnectionWriter& connection) const override;
1212 bool read(yarp::os::ConnectionReader& connection) override;
1213
1214 bool write(const yarp::os::idl::WireWriter& writer) const override;
1215 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1216 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1217
1218 bool read(yarp::os::idl::WireReader& reader) override;
1219 bool readTag(yarp::os::idl::WireReader& reader);
1220 bool readArgs(yarp::os::idl::WireReader& reader);
1221
1222 std::int32_t feature{0};
1223 double value1{0.0};
1224 double value2{0.0};
1225 };
1226
1227 class Reply :
1229 {
1230 public:
1231 Reply() = default;
1232 ~Reply() override = default;
1233
1234 bool write(yarp::os::ConnectionWriter& connection) const override;
1235 bool read(yarp::os::ConnectionReader& connection) override;
1236
1237 bool write(const yarp::os::idl::WireWriter& writer) const override;
1238 bool read(yarp::os::idl::WireReader& reader) override;
1239
1241 };
1242
1243 using funcptr_t = yarp::dev::ReturnValue (*)(const std::int32_t, const double, const double);
1244 void call(FrameGrabberMsgs* ptr);
1245
1248
1249 static constexpr const char* s_tag{"setFeature2RPC"};
1250 static constexpr size_t s_tag_len{1};
1251 static constexpr size_t s_cmd_len{4};
1252 static constexpr size_t s_reply_len{1};
1253 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setFeature2RPC(const std::int32_t feature, const double value1, const double value2)"};
1254 static constexpr const char* s_help{""};
1255};
1256
1257// getFeature2RPC helper class declaration
1259 public yarp::os::Portable
1260{
1261public:
1263 explicit FrameGrabberMsgs_getFeature2RPC_helper(const std::int32_t feature);
1264 bool write(yarp::os::ConnectionWriter& connection) const override;
1265 bool read(yarp::os::ConnectionReader& connection) override;
1266
1267 class Command :
1269 {
1270 public:
1271 Command() = default;
1272 explicit Command(const std::int32_t feature);
1273
1274 ~Command() override = default;
1275
1276 bool write(yarp::os::ConnectionWriter& connection) const override;
1277 bool read(yarp::os::ConnectionReader& connection) override;
1278
1279 bool write(const yarp::os::idl::WireWriter& writer) const override;
1280 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1281 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1282
1283 bool read(yarp::os::idl::WireReader& reader) override;
1284 bool readTag(yarp::os::idl::WireReader& reader);
1285 bool readArgs(yarp::os::idl::WireReader& reader);
1286
1287 std::int32_t feature{0};
1288 };
1289
1290 class Reply :
1292 {
1293 public:
1294 Reply() = default;
1295 ~Reply() override = default;
1296
1297 bool write(yarp::os::ConnectionWriter& connection) const override;
1298 bool read(yarp::os::ConnectionReader& connection) override;
1299
1300 bool write(const yarp::os::idl::WireWriter& writer) const override;
1301 bool read(yarp::os::idl::WireReader& reader) override;
1302
1304 };
1305
1307 void call(FrameGrabberMsgs* ptr);
1308
1311
1312 static constexpr const char* s_tag{"getFeature2RPC"};
1313 static constexpr size_t s_tag_len{1};
1314 static constexpr size_t s_cmd_len{2};
1315 static constexpr size_t s_reply_len{3};
1316 static constexpr const char* s_prototype{"IFrameGrabberControlMsgs_return_getFeature2 FrameGrabberMsgs::getFeature2RPC(const std::int32_t feature)"};
1317 static constexpr const char* s_help{""};
1318};
1319
1320// hasOnOffRPC helper class declaration
1322 public yarp::os::Portable
1323{
1324public:
1326 explicit FrameGrabberMsgs_hasOnOffRPC_helper(const std::int32_t feature);
1327 bool write(yarp::os::ConnectionWriter& connection) const override;
1328 bool read(yarp::os::ConnectionReader& connection) override;
1329
1330 class Command :
1332 {
1333 public:
1334 Command() = default;
1335 explicit Command(const std::int32_t feature);
1336
1337 ~Command() override = default;
1338
1339 bool write(yarp::os::ConnectionWriter& connection) const override;
1340 bool read(yarp::os::ConnectionReader& connection) override;
1341
1342 bool write(const yarp::os::idl::WireWriter& writer) const override;
1343 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1344 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1345
1346 bool read(yarp::os::idl::WireReader& reader) override;
1347 bool readTag(yarp::os::idl::WireReader& reader);
1348 bool readArgs(yarp::os::idl::WireReader& reader);
1349
1350 std::int32_t feature{0};
1351 };
1352
1353 class Reply :
1355 {
1356 public:
1357 Reply() = default;
1358 ~Reply() override = default;
1359
1360 bool write(yarp::os::ConnectionWriter& connection) const override;
1361 bool read(yarp::os::ConnectionReader& connection) override;
1362
1363 bool write(const yarp::os::idl::WireWriter& writer) const override;
1364 bool read(yarp::os::idl::WireReader& reader) override;
1365
1367 };
1368
1370 void call(FrameGrabberMsgs* ptr);
1371
1374
1375 static constexpr const char* s_tag{"hasOnOffRPC"};
1376 static constexpr size_t s_tag_len{1};
1377 static constexpr size_t s_cmd_len{2};
1378 static constexpr size_t s_reply_len{2};
1379 static constexpr const char* s_prototype{"IFrameGrabberControlMsgs_return_hasOnOff FrameGrabberMsgs::hasOnOffRPC(const std::int32_t feature)"};
1380 static constexpr const char* s_help{""};
1381};
1382
1383// setActiveRPC helper class declaration
1385 public yarp::os::Portable
1386{
1387public:
1389 FrameGrabberMsgs_setActiveRPC_helper(const std::int32_t feature, const bool onoff);
1390 bool write(yarp::os::ConnectionWriter& connection) const override;
1391 bool read(yarp::os::ConnectionReader& connection) override;
1392
1393 class Command :
1395 {
1396 public:
1397 Command() = default;
1398 Command(const std::int32_t feature, const bool onoff);
1399
1400 ~Command() override = default;
1401
1402 bool write(yarp::os::ConnectionWriter& connection) const override;
1403 bool read(yarp::os::ConnectionReader& connection) override;
1404
1405 bool write(const yarp::os::idl::WireWriter& writer) const override;
1406 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1407 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1408
1409 bool read(yarp::os::idl::WireReader& reader) override;
1410 bool readTag(yarp::os::idl::WireReader& reader);
1411 bool readArgs(yarp::os::idl::WireReader& reader);
1412
1413 std::int32_t feature{0};
1414 bool onoff{false};
1415 };
1416
1417 class Reply :
1419 {
1420 public:
1421 Reply() = default;
1422 ~Reply() override = default;
1423
1424 bool write(yarp::os::ConnectionWriter& connection) const override;
1425 bool read(yarp::os::ConnectionReader& connection) override;
1426
1427 bool write(const yarp::os::idl::WireWriter& writer) const override;
1428 bool read(yarp::os::idl::WireReader& reader) override;
1429
1431 };
1432
1433 using funcptr_t = yarp::dev::ReturnValue (*)(const std::int32_t, const bool);
1434 void call(FrameGrabberMsgs* ptr);
1435
1438
1439 static constexpr const char* s_tag{"setActiveRPC"};
1440 static constexpr size_t s_tag_len{1};
1441 static constexpr size_t s_cmd_len{3};
1442 static constexpr size_t s_reply_len{1};
1443 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setActiveRPC(const std::int32_t feature, const bool onoff)"};
1444 static constexpr const char* s_help{""};
1445};
1446
1447// getActiveRPC helper class declaration
1449 public yarp::os::Portable
1450{
1451public:
1453 explicit FrameGrabberMsgs_getActiveRPC_helper(const std::int32_t feature);
1454 bool write(yarp::os::ConnectionWriter& connection) const override;
1455 bool read(yarp::os::ConnectionReader& connection) override;
1456
1457 class Command :
1459 {
1460 public:
1461 Command() = default;
1462 explicit Command(const std::int32_t feature);
1463
1464 ~Command() override = default;
1465
1466 bool write(yarp::os::ConnectionWriter& connection) const override;
1467 bool read(yarp::os::ConnectionReader& connection) override;
1468
1469 bool write(const yarp::os::idl::WireWriter& writer) const override;
1470 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1471 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1472
1473 bool read(yarp::os::idl::WireReader& reader) override;
1474 bool readTag(yarp::os::idl::WireReader& reader);
1475 bool readArgs(yarp::os::idl::WireReader& reader);
1476
1477 std::int32_t feature{0};
1478 };
1479
1480 class Reply :
1482 {
1483 public:
1484 Reply() = default;
1485 ~Reply() override = default;
1486
1487 bool write(yarp::os::ConnectionWriter& connection) const override;
1488 bool read(yarp::os::ConnectionReader& connection) override;
1489
1490 bool write(const yarp::os::idl::WireWriter& writer) const override;
1491 bool read(yarp::os::idl::WireReader& reader) override;
1492
1494 };
1495
1497 void call(FrameGrabberMsgs* ptr);
1498
1501
1502 static constexpr const char* s_tag{"getActiveRPC"};
1503 static constexpr size_t s_tag_len{1};
1504 static constexpr size_t s_cmd_len{2};
1505 static constexpr size_t s_reply_len{2};
1506 static constexpr const char* s_prototype{"IFrameGrabberControlMsgs_return_getActive FrameGrabberMsgs::getActiveRPC(const std::int32_t feature)"};
1507 static constexpr const char* s_help{""};
1508};
1509
1510// hasAutoRPC helper class declaration
1512 public yarp::os::Portable
1513{
1514public:
1516 explicit FrameGrabberMsgs_hasAutoRPC_helper(const std::int32_t feature);
1517 bool write(yarp::os::ConnectionWriter& connection) const override;
1518 bool read(yarp::os::ConnectionReader& connection) override;
1519
1520 class Command :
1522 {
1523 public:
1524 Command() = default;
1525 explicit Command(const std::int32_t feature);
1526
1527 ~Command() override = default;
1528
1529 bool write(yarp::os::ConnectionWriter& connection) const override;
1530 bool read(yarp::os::ConnectionReader& connection) override;
1531
1532 bool write(const yarp::os::idl::WireWriter& writer) const override;
1533 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1534 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1535
1536 bool read(yarp::os::idl::WireReader& reader) override;
1537 bool readTag(yarp::os::idl::WireReader& reader);
1538 bool readArgs(yarp::os::idl::WireReader& reader);
1539
1540 std::int32_t feature{0};
1541 };
1542
1543 class Reply :
1545 {
1546 public:
1547 Reply() = default;
1548 ~Reply() override = default;
1549
1550 bool write(yarp::os::ConnectionWriter& connection) const override;
1551 bool read(yarp::os::ConnectionReader& connection) override;
1552
1553 bool write(const yarp::os::idl::WireWriter& writer) const override;
1554 bool read(yarp::os::idl::WireReader& reader) override;
1555
1557 };
1558
1560 void call(FrameGrabberMsgs* ptr);
1561
1564
1565 static constexpr const char* s_tag{"hasAutoRPC"};
1566 static constexpr size_t s_tag_len{1};
1567 static constexpr size_t s_cmd_len{2};
1568 static constexpr size_t s_reply_len{2};
1569 static constexpr const char* s_prototype{"IFrameGrabberControlMsgs_return_hasAuto FrameGrabberMsgs::hasAutoRPC(const std::int32_t feature)"};
1570 static constexpr const char* s_help{""};
1571};
1572
1573// hasManualRPC helper class declaration
1575 public yarp::os::Portable
1576{
1577public:
1579 explicit FrameGrabberMsgs_hasManualRPC_helper(const std::int32_t feature);
1580 bool write(yarp::os::ConnectionWriter& connection) const override;
1581 bool read(yarp::os::ConnectionReader& connection) override;
1582
1583 class Command :
1585 {
1586 public:
1587 Command() = default;
1588 explicit Command(const std::int32_t feature);
1589
1590 ~Command() override = default;
1591
1592 bool write(yarp::os::ConnectionWriter& connection) const override;
1593 bool read(yarp::os::ConnectionReader& connection) override;
1594
1595 bool write(const yarp::os::idl::WireWriter& writer) const override;
1596 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1597 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1598
1599 bool read(yarp::os::idl::WireReader& reader) override;
1600 bool readTag(yarp::os::idl::WireReader& reader);
1601 bool readArgs(yarp::os::idl::WireReader& reader);
1602
1603 std::int32_t feature{0};
1604 };
1605
1606 class Reply :
1608 {
1609 public:
1610 Reply() = default;
1611 ~Reply() override = default;
1612
1613 bool write(yarp::os::ConnectionWriter& connection) const override;
1614 bool read(yarp::os::ConnectionReader& connection) override;
1615
1616 bool write(const yarp::os::idl::WireWriter& writer) const override;
1617 bool read(yarp::os::idl::WireReader& reader) override;
1618
1620 };
1621
1623 void call(FrameGrabberMsgs* ptr);
1624
1627
1628 static constexpr const char* s_tag{"hasManualRPC"};
1629 static constexpr size_t s_tag_len{1};
1630 static constexpr size_t s_cmd_len{2};
1631 static constexpr size_t s_reply_len{2};
1632 static constexpr const char* s_prototype{"IFrameGrabberControlMsgs_return_hasManual FrameGrabberMsgs::hasManualRPC(const std::int32_t feature)"};
1633 static constexpr const char* s_help{""};
1634};
1635
1636// hasOnePushRPC helper class declaration
1638 public yarp::os::Portable
1639{
1640public:
1642 explicit FrameGrabberMsgs_hasOnePushRPC_helper(const std::int32_t feature);
1643 bool write(yarp::os::ConnectionWriter& connection) const override;
1644 bool read(yarp::os::ConnectionReader& connection) override;
1645
1646 class Command :
1648 {
1649 public:
1650 Command() = default;
1651 explicit Command(const std::int32_t feature);
1652
1653 ~Command() override = default;
1654
1655 bool write(yarp::os::ConnectionWriter& connection) const override;
1656 bool read(yarp::os::ConnectionReader& connection) override;
1657
1658 bool write(const yarp::os::idl::WireWriter& writer) const override;
1659 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1660 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1661
1662 bool read(yarp::os::idl::WireReader& reader) override;
1663 bool readTag(yarp::os::idl::WireReader& reader);
1664 bool readArgs(yarp::os::idl::WireReader& reader);
1665
1666 std::int32_t feature{0};
1667 };
1668
1669 class Reply :
1671 {
1672 public:
1673 Reply() = default;
1674 ~Reply() override = default;
1675
1676 bool write(yarp::os::ConnectionWriter& connection) const override;
1677 bool read(yarp::os::ConnectionReader& connection) override;
1678
1679 bool write(const yarp::os::idl::WireWriter& writer) const override;
1680 bool read(yarp::os::idl::WireReader& reader) override;
1681
1683 };
1684
1686 void call(FrameGrabberMsgs* ptr);
1687
1690
1691 static constexpr const char* s_tag{"hasOnePushRPC"};
1692 static constexpr size_t s_tag_len{1};
1693 static constexpr size_t s_cmd_len{2};
1694 static constexpr size_t s_reply_len{2};
1695 static constexpr const char* s_prototype{"IFrameGrabberControlMsgs_return_hasOnePush FrameGrabberMsgs::hasOnePushRPC(const std::int32_t feature)"};
1696 static constexpr const char* s_help{""};
1697};
1698
1699// setModeRPC helper class declaration
1701 public yarp::os::Portable
1702{
1703public:
1706 bool write(yarp::os::ConnectionWriter& connection) const override;
1707 bool read(yarp::os::ConnectionReader& connection) override;
1708
1709 class Command :
1711 {
1712 public:
1713 Command() = default;
1714 Command(const std::int32_t feature, const yarp::dev::FeatureMode mode);
1715
1716 ~Command() override = default;
1717
1718 bool write(yarp::os::ConnectionWriter& connection) const override;
1719 bool read(yarp::os::ConnectionReader& connection) override;
1720
1721 bool write(const yarp::os::idl::WireWriter& writer) const override;
1722 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1723 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1724
1725 bool read(yarp::os::idl::WireReader& reader) override;
1726 bool readTag(yarp::os::idl::WireReader& reader);
1727 bool readArgs(yarp::os::idl::WireReader& reader);
1728
1729 std::int32_t feature{0};
1731 };
1732
1733 class Reply :
1735 {
1736 public:
1737 Reply() = default;
1738 ~Reply() override = default;
1739
1740 bool write(yarp::os::ConnectionWriter& connection) const override;
1741 bool read(yarp::os::ConnectionReader& connection) override;
1742
1743 bool write(const yarp::os::idl::WireWriter& writer) const override;
1744 bool read(yarp::os::idl::WireReader& reader) override;
1745
1747 };
1748
1749 using funcptr_t = yarp::dev::ReturnValue (*)(const std::int32_t, const yarp::dev::FeatureMode);
1750 void call(FrameGrabberMsgs* ptr);
1751
1754
1755 static constexpr const char* s_tag{"setModeRPC"};
1756 static constexpr size_t s_tag_len{1};
1757 static constexpr size_t s_cmd_len{3};
1758 static constexpr size_t s_reply_len{1};
1759 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setModeRPC(const std::int32_t feature, const yarp::dev::FeatureMode mode)"};
1760 static constexpr const char* s_help{""};
1761};
1762
1763// getModeRPC helper class declaration
1765 public yarp::os::Portable
1766{
1767public:
1769 explicit FrameGrabberMsgs_getModeRPC_helper(const std::int32_t feature);
1770 bool write(yarp::os::ConnectionWriter& connection) const override;
1771 bool read(yarp::os::ConnectionReader& connection) override;
1772
1773 class Command :
1775 {
1776 public:
1777 Command() = default;
1778 explicit Command(const std::int32_t feature);
1779
1780 ~Command() override = default;
1781
1782 bool write(yarp::os::ConnectionWriter& connection) const override;
1783 bool read(yarp::os::ConnectionReader& connection) override;
1784
1785 bool write(const yarp::os::idl::WireWriter& writer) const override;
1786 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1787 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1788
1789 bool read(yarp::os::idl::WireReader& reader) override;
1790 bool readTag(yarp::os::idl::WireReader& reader);
1791 bool readArgs(yarp::os::idl::WireReader& reader);
1792
1793 std::int32_t feature{0};
1794 };
1795
1796 class Reply :
1798 {
1799 public:
1800 Reply() = default;
1801 ~Reply() override = default;
1802
1803 bool write(yarp::os::ConnectionWriter& connection) const override;
1804 bool read(yarp::os::ConnectionReader& connection) override;
1805
1806 bool write(const yarp::os::idl::WireWriter& writer) const override;
1807 bool read(yarp::os::idl::WireReader& reader) override;
1808
1810 };
1811
1813 void call(FrameGrabberMsgs* ptr);
1814
1817
1818 static constexpr const char* s_tag{"getModeRPC"};
1819 static constexpr size_t s_tag_len{1};
1820 static constexpr size_t s_cmd_len{2};
1821 static constexpr size_t s_reply_len{2};
1822 static constexpr const char* s_prototype{"IFrameGrabberControlMsgs_return_getMode FrameGrabberMsgs::getModeRPC(const std::int32_t feature)"};
1823 static constexpr const char* s_help{""};
1824};
1825
1826// setOnePushRPC helper class declaration
1828 public yarp::os::Portable
1829{
1830public:
1832 explicit FrameGrabberMsgs_setOnePushRPC_helper(const std::int32_t feature);
1833 bool write(yarp::os::ConnectionWriter& connection) const override;
1834 bool read(yarp::os::ConnectionReader& connection) override;
1835
1836 class Command :
1838 {
1839 public:
1840 Command() = default;
1841 explicit Command(const std::int32_t feature);
1842
1843 ~Command() override = default;
1844
1845 bool write(yarp::os::ConnectionWriter& connection) const override;
1846 bool read(yarp::os::ConnectionReader& connection) override;
1847
1848 bool write(const yarp::os::idl::WireWriter& writer) const override;
1849 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1850 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1851
1852 bool read(yarp::os::idl::WireReader& reader) override;
1853 bool readTag(yarp::os::idl::WireReader& reader);
1854 bool readArgs(yarp::os::idl::WireReader& reader);
1855
1856 std::int32_t feature{0};
1857 };
1858
1859 class Reply :
1861 {
1862 public:
1863 Reply() = default;
1864 ~Reply() override = default;
1865
1866 bool write(yarp::os::ConnectionWriter& connection) const override;
1867 bool read(yarp::os::ConnectionReader& connection) override;
1868
1869 bool write(const yarp::os::idl::WireWriter& writer) const override;
1870 bool read(yarp::os::idl::WireReader& reader) override;
1871
1873 };
1874
1875 using funcptr_t = yarp::dev::ReturnValue (*)(const std::int32_t);
1876 void call(FrameGrabberMsgs* ptr);
1877
1880
1881 static constexpr const char* s_tag{"setOnePushRPC"};
1882 static constexpr size_t s_tag_len{1};
1883 static constexpr size_t s_cmd_len{2};
1884 static constexpr size_t s_reply_len{1};
1885 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setOnePushRPC(const std::int32_t feature)"};
1886 static constexpr const char* s_help{""};
1887};
1888
1889// getVideoModeMaskDC1394RPC helper class declaration
1891 public yarp::os::Portable
1892{
1893public:
1895 bool write(yarp::os::ConnectionWriter& connection) const override;
1896 bool read(yarp::os::ConnectionReader& connection) override;
1897
1898 class Command :
1900 {
1901 public:
1902 Command() = default;
1903 ~Command() override = default;
1904
1905 bool write(yarp::os::ConnectionWriter& connection) const override;
1906 bool read(yarp::os::ConnectionReader& connection) override;
1907
1908 bool write(const yarp::os::idl::WireWriter& writer) const override;
1909 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1910 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1911
1912 bool read(yarp::os::idl::WireReader& reader) override;
1913 bool readTag(yarp::os::idl::WireReader& reader);
1914 bool readArgs(yarp::os::idl::WireReader& reader);
1915 };
1916
1917 class Reply :
1919 {
1920 public:
1921 Reply() = default;
1922 ~Reply() override = default;
1923
1924 bool write(yarp::os::ConnectionWriter& connection) const override;
1925 bool read(yarp::os::ConnectionReader& connection) override;
1926
1927 bool write(const yarp::os::idl::WireWriter& writer) const override;
1928 bool read(yarp::os::idl::WireReader& reader) override;
1929
1931 };
1932
1934 void call(FrameGrabberMsgs* ptr);
1935
1938
1939 static constexpr const char* s_tag{"getVideoModeMaskDC1394RPC"};
1940 static constexpr size_t s_tag_len{1};
1941 static constexpr size_t s_cmd_len{1};
1942 static constexpr size_t s_reply_len{2};
1943 static constexpr const char* s_prototype{"IFrameGrabberControlDC1394Msgs_return_getVideoModeMaskDC1394 FrameGrabberMsgs::getVideoModeMaskDC1394RPC()"};
1944 static constexpr const char* s_help{""};
1945};
1946
1947// getVideoModeDC1394RPC helper class declaration
1949 public yarp::os::Portable
1950{
1951public:
1953 bool write(yarp::os::ConnectionWriter& connection) const override;
1954 bool read(yarp::os::ConnectionReader& connection) override;
1955
1956 class Command :
1958 {
1959 public:
1960 Command() = default;
1961 ~Command() override = default;
1962
1963 bool write(yarp::os::ConnectionWriter& connection) const override;
1964 bool read(yarp::os::ConnectionReader& connection) override;
1965
1966 bool write(const yarp::os::idl::WireWriter& writer) const override;
1967 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1968 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1969
1970 bool read(yarp::os::idl::WireReader& reader) override;
1971 bool readTag(yarp::os::idl::WireReader& reader);
1972 bool readArgs(yarp::os::idl::WireReader& reader);
1973 };
1974
1975 class Reply :
1977 {
1978 public:
1979 Reply() = default;
1980 ~Reply() override = default;
1981
1982 bool write(yarp::os::ConnectionWriter& connection) const override;
1983 bool read(yarp::os::ConnectionReader& connection) override;
1984
1985 bool write(const yarp::os::idl::WireWriter& writer) const override;
1986 bool read(yarp::os::idl::WireReader& reader) override;
1987
1989 };
1990
1992 void call(FrameGrabberMsgs* ptr);
1993
1996
1997 static constexpr const char* s_tag{"getVideoModeDC1394RPC"};
1998 static constexpr size_t s_tag_len{1};
1999 static constexpr size_t s_cmd_len{1};
2000 static constexpr size_t s_reply_len{2};
2001 static constexpr const char* s_prototype{"IFrameGrabberControlDC1394Msgs_return_getVideoModeDC1394 FrameGrabberMsgs::getVideoModeDC1394RPC()"};
2002 static constexpr const char* s_help{""};
2003};
2004
2005// setVideoModeDC1394RPC helper class declaration
2007 public yarp::os::Portable
2008{
2009public:
2011 explicit FrameGrabberMsgs_setVideoModeDC1394RPC_helper(const std::int32_t videomode);
2012 bool write(yarp::os::ConnectionWriter& connection) const override;
2013 bool read(yarp::os::ConnectionReader& connection) override;
2014
2015 class Command :
2017 {
2018 public:
2019 Command() = default;
2020 explicit Command(const std::int32_t videomode);
2021
2022 ~Command() override = default;
2023
2024 bool write(yarp::os::ConnectionWriter& connection) const override;
2025 bool read(yarp::os::ConnectionReader& connection) override;
2026
2027 bool write(const yarp::os::idl::WireWriter& writer) const override;
2028 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2029 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2030
2031 bool read(yarp::os::idl::WireReader& reader) override;
2032 bool readTag(yarp::os::idl::WireReader& reader);
2033 bool readArgs(yarp::os::idl::WireReader& reader);
2034
2035 std::int32_t videomode{0};
2036 };
2037
2038 class Reply :
2040 {
2041 public:
2042 Reply() = default;
2043 ~Reply() override = default;
2044
2045 bool write(yarp::os::ConnectionWriter& connection) const override;
2046 bool read(yarp::os::ConnectionReader& connection) override;
2047
2048 bool write(const yarp::os::idl::WireWriter& writer) const override;
2049 bool read(yarp::os::idl::WireReader& reader) override;
2050
2052 };
2053
2054 using funcptr_t = yarp::dev::ReturnValue (*)(const std::int32_t);
2055 void call(FrameGrabberMsgs* ptr);
2056
2059
2060 static constexpr const char* s_tag{"setVideoModeDC1394RPC"};
2061 static constexpr size_t s_tag_len{1};
2062 static constexpr size_t s_cmd_len{2};
2063 static constexpr size_t s_reply_len{1};
2064 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setVideoModeDC1394RPC(const std::int32_t videomode)"};
2065 static constexpr const char* s_help{""};
2066};
2067
2068// getFPSMaskDC1394RPC helper class declaration
2070 public yarp::os::Portable
2071{
2072public:
2074 bool write(yarp::os::ConnectionWriter& connection) const override;
2075 bool read(yarp::os::ConnectionReader& connection) override;
2076
2077 class Command :
2079 {
2080 public:
2081 Command() = default;
2082 ~Command() override = default;
2083
2084 bool write(yarp::os::ConnectionWriter& connection) const override;
2085 bool read(yarp::os::ConnectionReader& connection) override;
2086
2087 bool write(const yarp::os::idl::WireWriter& writer) const override;
2088 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2089 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2090
2091 bool read(yarp::os::idl::WireReader& reader) override;
2092 bool readTag(yarp::os::idl::WireReader& reader);
2093 bool readArgs(yarp::os::idl::WireReader& reader);
2094 };
2095
2096 class Reply :
2098 {
2099 public:
2100 Reply() = default;
2101 ~Reply() override = default;
2102
2103 bool write(yarp::os::ConnectionWriter& connection) const override;
2104 bool read(yarp::os::ConnectionReader& connection) override;
2105
2106 bool write(const yarp::os::idl::WireWriter& writer) const override;
2107 bool read(yarp::os::idl::WireReader& reader) override;
2108
2110 };
2111
2113 void call(FrameGrabberMsgs* ptr);
2114
2117
2118 static constexpr const char* s_tag{"getFPSMaskDC1394RPC"};
2119 static constexpr size_t s_tag_len{1};
2120 static constexpr size_t s_cmd_len{1};
2121 static constexpr size_t s_reply_len{2};
2122 static constexpr const char* s_prototype{"IFrameGrabberControlDC1394Msgs_return_getFPSMaskDC1394 FrameGrabberMsgs::getFPSMaskDC1394RPC()"};
2123 static constexpr const char* s_help{""};
2124};
2125
2126// getFPSDC1394RPC helper class declaration
2128 public yarp::os::Portable
2129{
2130public:
2132 bool write(yarp::os::ConnectionWriter& connection) const override;
2133 bool read(yarp::os::ConnectionReader& connection) override;
2134
2135 class Command :
2137 {
2138 public:
2139 Command() = default;
2140 ~Command() override = default;
2141
2142 bool write(yarp::os::ConnectionWriter& connection) const override;
2143 bool read(yarp::os::ConnectionReader& connection) override;
2144
2145 bool write(const yarp::os::idl::WireWriter& writer) const override;
2146 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2147 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2148
2149 bool read(yarp::os::idl::WireReader& reader) override;
2150 bool readTag(yarp::os::idl::WireReader& reader);
2151 bool readArgs(yarp::os::idl::WireReader& reader);
2152 };
2153
2154 class Reply :
2156 {
2157 public:
2158 Reply() = default;
2159 ~Reply() override = default;
2160
2161 bool write(yarp::os::ConnectionWriter& connection) const override;
2162 bool read(yarp::os::ConnectionReader& connection) override;
2163
2164 bool write(const yarp::os::idl::WireWriter& writer) const override;
2165 bool read(yarp::os::idl::WireReader& reader) override;
2166
2168 };
2169
2171 void call(FrameGrabberMsgs* ptr);
2172
2175
2176 static constexpr const char* s_tag{"getFPSDC1394RPC"};
2177 static constexpr size_t s_tag_len{1};
2178 static constexpr size_t s_cmd_len{1};
2179 static constexpr size_t s_reply_len{2};
2180 static constexpr const char* s_prototype{"IFrameGrabberControlDC1394Msgs_return_getFPSDC1394 FrameGrabberMsgs::getFPSDC1394RPC()"};
2181 static constexpr const char* s_help{""};
2182};
2183
2184// setFPSDC1394RPC helper class declaration
2186 public yarp::os::Portable
2187{
2188public:
2190 explicit FrameGrabberMsgs_setFPSDC1394RPC_helper(const std::int32_t fps);
2191 bool write(yarp::os::ConnectionWriter& connection) const override;
2192 bool read(yarp::os::ConnectionReader& connection) override;
2193
2194 class Command :
2196 {
2197 public:
2198 Command() = default;
2199 explicit Command(const std::int32_t fps);
2200
2201 ~Command() override = default;
2202
2203 bool write(yarp::os::ConnectionWriter& connection) const override;
2204 bool read(yarp::os::ConnectionReader& connection) override;
2205
2206 bool write(const yarp::os::idl::WireWriter& writer) const override;
2207 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2208 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2209
2210 bool read(yarp::os::idl::WireReader& reader) override;
2211 bool readTag(yarp::os::idl::WireReader& reader);
2212 bool readArgs(yarp::os::idl::WireReader& reader);
2213
2214 std::int32_t fps{0};
2215 };
2216
2217 class Reply :
2219 {
2220 public:
2221 Reply() = default;
2222 ~Reply() override = default;
2223
2224 bool write(yarp::os::ConnectionWriter& connection) const override;
2225 bool read(yarp::os::ConnectionReader& connection) override;
2226
2227 bool write(const yarp::os::idl::WireWriter& writer) const override;
2228 bool read(yarp::os::idl::WireReader& reader) override;
2229
2231 };
2232
2233 using funcptr_t = yarp::dev::ReturnValue (*)(const std::int32_t);
2234 void call(FrameGrabberMsgs* ptr);
2235
2238
2239 static constexpr const char* s_tag{"setFPSDC1394RPC"};
2240 static constexpr size_t s_tag_len{1};
2241 static constexpr size_t s_cmd_len{2};
2242 static constexpr size_t s_reply_len{1};
2243 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setFPSDC1394RPC(const std::int32_t fps)"};
2244 static constexpr const char* s_help{""};
2245};
2246
2247// getISOSpeedDC1394RPC helper class declaration
2249 public yarp::os::Portable
2250{
2251public:
2253 bool write(yarp::os::ConnectionWriter& connection) const override;
2254 bool read(yarp::os::ConnectionReader& connection) override;
2255
2256 class Command :
2258 {
2259 public:
2260 Command() = default;
2261 ~Command() override = default;
2262
2263 bool write(yarp::os::ConnectionWriter& connection) const override;
2264 bool read(yarp::os::ConnectionReader& connection) override;
2265
2266 bool write(const yarp::os::idl::WireWriter& writer) const override;
2267 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2268 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2269
2270 bool read(yarp::os::idl::WireReader& reader) override;
2271 bool readTag(yarp::os::idl::WireReader& reader);
2272 bool readArgs(yarp::os::idl::WireReader& reader);
2273 };
2274
2275 class Reply :
2277 {
2278 public:
2279 Reply() = default;
2280 ~Reply() override = default;
2281
2282 bool write(yarp::os::ConnectionWriter& connection) const override;
2283 bool read(yarp::os::ConnectionReader& connection) override;
2284
2285 bool write(const yarp::os::idl::WireWriter& writer) const override;
2286 bool read(yarp::os::idl::WireReader& reader) override;
2287
2289 };
2290
2292 void call(FrameGrabberMsgs* ptr);
2293
2296
2297 static constexpr const char* s_tag{"getISOSpeedDC1394RPC"};
2298 static constexpr size_t s_tag_len{1};
2299 static constexpr size_t s_cmd_len{1};
2300 static constexpr size_t s_reply_len{2};
2301 static constexpr const char* s_prototype{"IFrameGrabberControlDC1394Msgs_return_getISOSpeedDC1394 FrameGrabberMsgs::getISOSpeedDC1394RPC()"};
2302 static constexpr const char* s_help{""};
2303};
2304
2305// setISOSpeedDC1394RPC helper class declaration
2307 public yarp::os::Portable
2308{
2309public:
2311 explicit FrameGrabberMsgs_setISOSpeedDC1394RPC_helper(const std::int32_t speed);
2312 bool write(yarp::os::ConnectionWriter& connection) const override;
2313 bool read(yarp::os::ConnectionReader& connection) override;
2314
2315 class Command :
2317 {
2318 public:
2319 Command() = default;
2320 explicit Command(const std::int32_t speed);
2321
2322 ~Command() override = default;
2323
2324 bool write(yarp::os::ConnectionWriter& connection) const override;
2325 bool read(yarp::os::ConnectionReader& connection) override;
2326
2327 bool write(const yarp::os::idl::WireWriter& writer) const override;
2328 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2329 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2330
2331 bool read(yarp::os::idl::WireReader& reader) override;
2332 bool readTag(yarp::os::idl::WireReader& reader);
2333 bool readArgs(yarp::os::idl::WireReader& reader);
2334
2335 std::int32_t speed{0};
2336 };
2337
2338 class Reply :
2340 {
2341 public:
2342 Reply() = default;
2343 ~Reply() override = default;
2344
2345 bool write(yarp::os::ConnectionWriter& connection) const override;
2346 bool read(yarp::os::ConnectionReader& connection) override;
2347
2348 bool write(const yarp::os::idl::WireWriter& writer) const override;
2349 bool read(yarp::os::idl::WireReader& reader) override;
2350
2352 };
2353
2354 using funcptr_t = yarp::dev::ReturnValue (*)(const std::int32_t);
2355 void call(FrameGrabberMsgs* ptr);
2356
2359
2360 static constexpr const char* s_tag{"setISOSpeedDC1394RPC"};
2361 static constexpr size_t s_tag_len{1};
2362 static constexpr size_t s_cmd_len{2};
2363 static constexpr size_t s_reply_len{1};
2364 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setISOSpeedDC1394RPC(const std::int32_t speed)"};
2365 static constexpr const char* s_help{""};
2366};
2367
2368// getColorCodingMaskDC1394RPC helper class declaration
2370 public yarp::os::Portable
2371{
2372public:
2374 explicit FrameGrabberMsgs_getColorCodingMaskDC1394RPC_helper(const std::int32_t videomode);
2375 bool write(yarp::os::ConnectionWriter& connection) const override;
2376 bool read(yarp::os::ConnectionReader& connection) override;
2377
2378 class Command :
2380 {
2381 public:
2382 Command() = default;
2383 explicit Command(const std::int32_t videomode);
2384
2385 ~Command() override = default;
2386
2387 bool write(yarp::os::ConnectionWriter& connection) const override;
2388 bool read(yarp::os::ConnectionReader& connection) override;
2389
2390 bool write(const yarp::os::idl::WireWriter& writer) const override;
2391 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2392 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2393
2394 bool read(yarp::os::idl::WireReader& reader) override;
2395 bool readTag(yarp::os::idl::WireReader& reader);
2396 bool readArgs(yarp::os::idl::WireReader& reader);
2397
2398 std::int32_t videomode{0};
2399 };
2400
2401 class Reply :
2403 {
2404 public:
2405 Reply() = default;
2406 ~Reply() override = default;
2407
2408 bool write(yarp::os::ConnectionWriter& connection) const override;
2409 bool read(yarp::os::ConnectionReader& connection) override;
2410
2411 bool write(const yarp::os::idl::WireWriter& writer) const override;
2412 bool read(yarp::os::idl::WireReader& reader) override;
2413
2415 };
2416
2418 void call(FrameGrabberMsgs* ptr);
2419
2422
2423 static constexpr const char* s_tag{"getColorCodingMaskDC1394RPC"};
2424 static constexpr size_t s_tag_len{1};
2425 static constexpr size_t s_cmd_len{2};
2426 static constexpr size_t s_reply_len{2};
2427 static constexpr const char* s_prototype{"IFrameGrabberControlDC1394Msgs_return_getColorCodingMaskDC1394 FrameGrabberMsgs::getColorCodingMaskDC1394RPC(const std::int32_t videomode)"};
2428 static constexpr const char* s_help{""};
2429};
2430
2431// getColorCodingDC1394RPC helper class declaration
2433 public yarp::os::Portable
2434{
2435public:
2437 bool write(yarp::os::ConnectionWriter& connection) const override;
2438 bool read(yarp::os::ConnectionReader& connection) override;
2439
2440 class Command :
2442 {
2443 public:
2444 Command() = default;
2445 ~Command() override = default;
2446
2447 bool write(yarp::os::ConnectionWriter& connection) const override;
2448 bool read(yarp::os::ConnectionReader& connection) override;
2449
2450 bool write(const yarp::os::idl::WireWriter& writer) const override;
2451 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2452 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2453
2454 bool read(yarp::os::idl::WireReader& reader) override;
2455 bool readTag(yarp::os::idl::WireReader& reader);
2456 bool readArgs(yarp::os::idl::WireReader& reader);
2457 };
2458
2459 class Reply :
2461 {
2462 public:
2463 Reply() = default;
2464 ~Reply() override = default;
2465
2466 bool write(yarp::os::ConnectionWriter& connection) const override;
2467 bool read(yarp::os::ConnectionReader& connection) override;
2468
2469 bool write(const yarp::os::idl::WireWriter& writer) const override;
2470 bool read(yarp::os::idl::WireReader& reader) override;
2471
2473 };
2474
2476 void call(FrameGrabberMsgs* ptr);
2477
2480
2481 static constexpr const char* s_tag{"getColorCodingDC1394RPC"};
2482 static constexpr size_t s_tag_len{1};
2483 static constexpr size_t s_cmd_len{1};
2484 static constexpr size_t s_reply_len{2};
2485 static constexpr const char* s_prototype{"IFrameGrabberControlDC1394Msgs_return_getColorCodingDC1394 FrameGrabberMsgs::getColorCodingDC1394RPC()"};
2486 static constexpr const char* s_help{""};
2487};
2488
2489// setColorCodingDC1394RPC helper class declaration
2491 public yarp::os::Portable
2492{
2493public:
2495 explicit FrameGrabberMsgs_setColorCodingDC1394RPC_helper(const std::int32_t coding);
2496 bool write(yarp::os::ConnectionWriter& connection) const override;
2497 bool read(yarp::os::ConnectionReader& connection) override;
2498
2499 class Command :
2501 {
2502 public:
2503 Command() = default;
2504 explicit Command(const std::int32_t coding);
2505
2506 ~Command() override = default;
2507
2508 bool write(yarp::os::ConnectionWriter& connection) const override;
2509 bool read(yarp::os::ConnectionReader& connection) override;
2510
2511 bool write(const yarp::os::idl::WireWriter& writer) const override;
2512 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2513 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2514
2515 bool read(yarp::os::idl::WireReader& reader) override;
2516 bool readTag(yarp::os::idl::WireReader& reader);
2517 bool readArgs(yarp::os::idl::WireReader& reader);
2518
2519 std::int32_t coding{0};
2520 };
2521
2522 class Reply :
2524 {
2525 public:
2526 Reply() = default;
2527 ~Reply() override = default;
2528
2529 bool write(yarp::os::ConnectionWriter& connection) const override;
2530 bool read(yarp::os::ConnectionReader& connection) override;
2531
2532 bool write(const yarp::os::idl::WireWriter& writer) const override;
2533 bool read(yarp::os::idl::WireReader& reader) override;
2534
2536 };
2537
2538 using funcptr_t = yarp::dev::ReturnValue (*)(const std::int32_t);
2539 void call(FrameGrabberMsgs* ptr);
2540
2543
2544 static constexpr const char* s_tag{"setColorCodingDC1394RPC"};
2545 static constexpr size_t s_tag_len{1};
2546 static constexpr size_t s_cmd_len{2};
2547 static constexpr size_t s_reply_len{1};
2548 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setColorCodingDC1394RPC(const std::int32_t coding)"};
2549 static constexpr const char* s_help{""};
2550};
2551
2552// getFormat7MaxWindowDC1394RPC helper class declaration
2554 public yarp::os::Portable
2555{
2556public:
2558 bool write(yarp::os::ConnectionWriter& connection) const override;
2559 bool read(yarp::os::ConnectionReader& connection) override;
2560
2561 class Command :
2563 {
2564 public:
2565 Command() = default;
2566 ~Command() override = default;
2567
2568 bool write(yarp::os::ConnectionWriter& connection) const override;
2569 bool read(yarp::os::ConnectionReader& connection) override;
2570
2571 bool write(const yarp::os::idl::WireWriter& writer) const override;
2572 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2573 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2574
2575 bool read(yarp::os::idl::WireReader& reader) override;
2576 bool readTag(yarp::os::idl::WireReader& reader);
2577 bool readArgs(yarp::os::idl::WireReader& reader);
2578 };
2579
2580 class Reply :
2582 {
2583 public:
2584 Reply() = default;
2585 ~Reply() override = default;
2586
2587 bool write(yarp::os::ConnectionWriter& connection) const override;
2588 bool read(yarp::os::ConnectionReader& connection) override;
2589
2590 bool write(const yarp::os::idl::WireWriter& writer) const override;
2591 bool read(yarp::os::idl::WireReader& reader) override;
2592
2594 };
2595
2597 void call(FrameGrabberMsgs* ptr);
2598
2601
2602 static constexpr const char* s_tag{"getFormat7MaxWindowDC1394RPC"};
2603 static constexpr size_t s_tag_len{1};
2604 static constexpr size_t s_cmd_len{1};
2605 static constexpr size_t s_reply_len{7};
2606 static constexpr const char* s_prototype{"IFrameGrabberControlDC1394Msgs_return_getFormat7MaxWindowDC1394 FrameGrabberMsgs::getFormat7MaxWindowDC1394RPC()"};
2607 static constexpr const char* s_help{""};
2608};
2609
2610// getFormat7WindowDC1394RPC helper class declaration
2612 public yarp::os::Portable
2613{
2614public:
2616 bool write(yarp::os::ConnectionWriter& connection) const override;
2617 bool read(yarp::os::ConnectionReader& connection) override;
2618
2619 class Command :
2621 {
2622 public:
2623 Command() = default;
2624 ~Command() override = default;
2625
2626 bool write(yarp::os::ConnectionWriter& connection) const override;
2627 bool read(yarp::os::ConnectionReader& connection) override;
2628
2629 bool write(const yarp::os::idl::WireWriter& writer) const override;
2630 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2631 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2632
2633 bool read(yarp::os::idl::WireReader& reader) override;
2634 bool readTag(yarp::os::idl::WireReader& reader);
2635 bool readArgs(yarp::os::idl::WireReader& reader);
2636 };
2637
2638 class Reply :
2640 {
2641 public:
2642 Reply() = default;
2643 ~Reply() override = default;
2644
2645 bool write(yarp::os::ConnectionWriter& connection) const override;
2646 bool read(yarp::os::ConnectionReader& connection) override;
2647
2648 bool write(const yarp::os::idl::WireWriter& writer) const override;
2649 bool read(yarp::os::idl::WireReader& reader) override;
2650
2652 };
2653
2655 void call(FrameGrabberMsgs* ptr);
2656
2659
2660 static constexpr const char* s_tag{"getFormat7WindowDC1394RPC"};
2661 static constexpr size_t s_tag_len{1};
2662 static constexpr size_t s_cmd_len{1};
2663 static constexpr size_t s_reply_len{5};
2664 static constexpr const char* s_prototype{"IFrameGrabberControlDC1394Msgs_return_getFormat7WindowDC1394 FrameGrabberMsgs::getFormat7WindowDC1394RPC()"};
2665 static constexpr const char* s_help{""};
2666};
2667
2668// setFormat7WindowDC1394RPC helper class declaration
2670 public yarp::os::Portable
2671{
2672public:
2674 FrameGrabberMsgs_setFormat7WindowDC1394RPC_helper(const std::int32_t xdim, const std::int32_t ydim, const std::int32_t x0, const std::int32_t y0);
2675 bool write(yarp::os::ConnectionWriter& connection) const override;
2676 bool read(yarp::os::ConnectionReader& connection) override;
2677
2678 class Command :
2680 {
2681 public:
2682 Command() = default;
2683 Command(const std::int32_t xdim, const std::int32_t ydim, const std::int32_t x0, const std::int32_t y0);
2684
2685 ~Command() override = default;
2686
2687 bool write(yarp::os::ConnectionWriter& connection) const override;
2688 bool read(yarp::os::ConnectionReader& connection) override;
2689
2690 bool write(const yarp::os::idl::WireWriter& writer) const override;
2691 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2692 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2693
2694 bool read(yarp::os::idl::WireReader& reader) override;
2695 bool readTag(yarp::os::idl::WireReader& reader);
2696 bool readArgs(yarp::os::idl::WireReader& reader);
2697
2698 std::int32_t xdim{0};
2699 std::int32_t ydim{0};
2700 std::int32_t x0{0};
2701 std::int32_t y0{0};
2702 };
2703
2704 class Reply :
2706 {
2707 public:
2708 Reply() = default;
2709 ~Reply() override = default;
2710
2711 bool write(yarp::os::ConnectionWriter& connection) const override;
2712 bool read(yarp::os::ConnectionReader& connection) override;
2713
2714 bool write(const yarp::os::idl::WireWriter& writer) const override;
2715 bool read(yarp::os::idl::WireReader& reader) override;
2716
2718 };
2719
2720 using funcptr_t = yarp::dev::ReturnValue (*)(const std::int32_t, const std::int32_t, const std::int32_t, const std::int32_t);
2721 void call(FrameGrabberMsgs* ptr);
2722
2725
2726 static constexpr const char* s_tag{"setFormat7WindowDC1394RPC"};
2727 static constexpr size_t s_tag_len{1};
2728 static constexpr size_t s_cmd_len{5};
2729 static constexpr size_t s_reply_len{1};
2730 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)"};
2731 static constexpr const char* s_help{""};
2732};
2733
2734// setOperationModeDC1394RPC helper class declaration
2736 public yarp::os::Portable
2737{
2738public:
2740 explicit FrameGrabberMsgs_setOperationModeDC1394RPC_helper(const bool b1394b);
2741 bool write(yarp::os::ConnectionWriter& connection) const override;
2742 bool read(yarp::os::ConnectionReader& connection) override;
2743
2744 class Command :
2746 {
2747 public:
2748 Command() = default;
2749 explicit Command(const bool b1394b);
2750
2751 ~Command() override = default;
2752
2753 bool write(yarp::os::ConnectionWriter& connection) const override;
2754 bool read(yarp::os::ConnectionReader& connection) override;
2755
2756 bool write(const yarp::os::idl::WireWriter& writer) const override;
2757 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2758 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2759
2760 bool read(yarp::os::idl::WireReader& reader) override;
2761 bool readTag(yarp::os::idl::WireReader& reader);
2762 bool readArgs(yarp::os::idl::WireReader& reader);
2763
2764 bool b1394b{false};
2765 };
2766
2767 class Reply :
2769 {
2770 public:
2771 Reply() = default;
2772 ~Reply() override = default;
2773
2774 bool write(yarp::os::ConnectionWriter& connection) const override;
2775 bool read(yarp::os::ConnectionReader& connection) override;
2776
2777 bool write(const yarp::os::idl::WireWriter& writer) const override;
2778 bool read(yarp::os::idl::WireReader& reader) override;
2779
2781 };
2782
2783 using funcptr_t = yarp::dev::ReturnValue (*)(const bool);
2784 void call(FrameGrabberMsgs* ptr);
2785
2788
2789 static constexpr const char* s_tag{"setOperationModeDC1394RPC"};
2790 static constexpr size_t s_tag_len{1};
2791 static constexpr size_t s_cmd_len{2};
2792 static constexpr size_t s_reply_len{1};
2793 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setOperationModeDC1394RPC(const bool b1394b)"};
2794 static constexpr const char* s_help{""};
2795};
2796
2797// getOperationModeDC1394RPC helper class declaration
2799 public yarp::os::Portable
2800{
2801public:
2803 bool write(yarp::os::ConnectionWriter& connection) const override;
2804 bool read(yarp::os::ConnectionReader& connection) override;
2805
2806 class Command :
2808 {
2809 public:
2810 Command() = default;
2811 ~Command() override = default;
2812
2813 bool write(yarp::os::ConnectionWriter& connection) const override;
2814 bool read(yarp::os::ConnectionReader& connection) override;
2815
2816 bool write(const yarp::os::idl::WireWriter& writer) const override;
2817 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2818 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2819
2820 bool read(yarp::os::idl::WireReader& reader) override;
2821 bool readTag(yarp::os::idl::WireReader& reader);
2822 bool readArgs(yarp::os::idl::WireReader& reader);
2823 };
2824
2825 class Reply :
2827 {
2828 public:
2829 Reply() = default;
2830 ~Reply() override = default;
2831
2832 bool write(yarp::os::ConnectionWriter& connection) const override;
2833 bool read(yarp::os::ConnectionReader& connection) override;
2834
2835 bool write(const yarp::os::idl::WireWriter& writer) const override;
2836 bool read(yarp::os::idl::WireReader& reader) override;
2837
2839 };
2840
2842 void call(FrameGrabberMsgs* ptr);
2843
2846
2847 static constexpr const char* s_tag{"getOperationModeDC1394RPC"};
2848 static constexpr size_t s_tag_len{1};
2849 static constexpr size_t s_cmd_len{1};
2850 static constexpr size_t s_reply_len{2};
2851 static constexpr const char* s_prototype{"IFrameGrabberControlDC1394Msgs_return_getOperationModeDC1394 FrameGrabberMsgs::getOperationModeDC1394RPC()"};
2852 static constexpr const char* s_help{""};
2853};
2854
2855// setTransmissionDC1394RPC helper class declaration
2857 public yarp::os::Portable
2858{
2859public:
2861 explicit FrameGrabberMsgs_setTransmissionDC1394RPC_helper(const bool bTxON);
2862 bool write(yarp::os::ConnectionWriter& connection) const override;
2863 bool read(yarp::os::ConnectionReader& connection) override;
2864
2865 class Command :
2867 {
2868 public:
2869 Command() = default;
2870 explicit Command(const bool bTxON);
2871
2872 ~Command() override = default;
2873
2874 bool write(yarp::os::ConnectionWriter& connection) const override;
2875 bool read(yarp::os::ConnectionReader& connection) override;
2876
2877 bool write(const yarp::os::idl::WireWriter& writer) const override;
2878 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2879 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2880
2881 bool read(yarp::os::idl::WireReader& reader) override;
2882 bool readTag(yarp::os::idl::WireReader& reader);
2883 bool readArgs(yarp::os::idl::WireReader& reader);
2884
2885 bool bTxON{false};
2886 };
2887
2888 class Reply :
2890 {
2891 public:
2892 Reply() = default;
2893 ~Reply() override = default;
2894
2895 bool write(yarp::os::ConnectionWriter& connection) const override;
2896 bool read(yarp::os::ConnectionReader& connection) override;
2897
2898 bool write(const yarp::os::idl::WireWriter& writer) const override;
2899 bool read(yarp::os::idl::WireReader& reader) override;
2900
2902 };
2903
2904 using funcptr_t = yarp::dev::ReturnValue (*)(const bool);
2905 void call(FrameGrabberMsgs* ptr);
2906
2909
2910 static constexpr const char* s_tag{"setTransmissionDC1394RPC"};
2911 static constexpr size_t s_tag_len{1};
2912 static constexpr size_t s_cmd_len{2};
2913 static constexpr size_t s_reply_len{1};
2914 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setTransmissionDC1394RPC(const bool bTxON)"};
2915 static constexpr const char* s_help{""};
2916};
2917
2918// getTransmissionDC1394RPC helper class declaration
2920 public yarp::os::Portable
2921{
2922public:
2924 bool write(yarp::os::ConnectionWriter& connection) const override;
2925 bool read(yarp::os::ConnectionReader& connection) override;
2926
2927 class Command :
2929 {
2930 public:
2931 Command() = default;
2932 ~Command() override = default;
2933
2934 bool write(yarp::os::ConnectionWriter& connection) const override;
2935 bool read(yarp::os::ConnectionReader& connection) override;
2936
2937 bool write(const yarp::os::idl::WireWriter& writer) const override;
2938 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2939 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2940
2941 bool read(yarp::os::idl::WireReader& reader) override;
2942 bool readTag(yarp::os::idl::WireReader& reader);
2943 bool readArgs(yarp::os::idl::WireReader& reader);
2944 };
2945
2946 class Reply :
2948 {
2949 public:
2950 Reply() = default;
2951 ~Reply() override = default;
2952
2953 bool write(yarp::os::ConnectionWriter& connection) const override;
2954 bool read(yarp::os::ConnectionReader& connection) override;
2955
2956 bool write(const yarp::os::idl::WireWriter& writer) const override;
2957 bool read(yarp::os::idl::WireReader& reader) override;
2958
2960 };
2961
2963 void call(FrameGrabberMsgs* ptr);
2964
2967
2968 static constexpr const char* s_tag{"getTransmissionDC1394RPC"};
2969 static constexpr size_t s_tag_len{1};
2970 static constexpr size_t s_cmd_len{1};
2971 static constexpr size_t s_reply_len{2};
2972 static constexpr const char* s_prototype{"IFrameGrabberControlDC1394Msgs_return_getTransmissionDC1394 FrameGrabberMsgs::getTransmissionDC1394RPC()"};
2973 static constexpr const char* s_help{""};
2974};
2975
2976// setBroadcastDC1394RPC helper class declaration
2978 public yarp::os::Portable
2979{
2980public:
2982 explicit FrameGrabberMsgs_setBroadcastDC1394RPC_helper(const bool onoff);
2983 bool write(yarp::os::ConnectionWriter& connection) const override;
2984 bool read(yarp::os::ConnectionReader& connection) override;
2985
2986 class Command :
2988 {
2989 public:
2990 Command() = default;
2991 explicit Command(const bool onoff);
2992
2993 ~Command() override = default;
2994
2995 bool write(yarp::os::ConnectionWriter& connection) const override;
2996 bool read(yarp::os::ConnectionReader& connection) override;
2997
2998 bool write(const yarp::os::idl::WireWriter& writer) const override;
2999 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
3000 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
3001
3002 bool read(yarp::os::idl::WireReader& reader) override;
3003 bool readTag(yarp::os::idl::WireReader& reader);
3004 bool readArgs(yarp::os::idl::WireReader& reader);
3005
3006 bool onoff{false};
3007 };
3008
3009 class Reply :
3011 {
3012 public:
3013 Reply() = default;
3014 ~Reply() override = default;
3015
3016 bool write(yarp::os::ConnectionWriter& connection) const override;
3017 bool read(yarp::os::ConnectionReader& connection) override;
3018
3019 bool write(const yarp::os::idl::WireWriter& writer) const override;
3020 bool read(yarp::os::idl::WireReader& reader) override;
3021
3023 };
3024
3025 using funcptr_t = yarp::dev::ReturnValue (*)(const bool);
3026 void call(FrameGrabberMsgs* ptr);
3027
3030
3031 static constexpr const char* s_tag{"setBroadcastDC1394RPC"};
3032 static constexpr size_t s_tag_len{1};
3033 static constexpr size_t s_cmd_len{2};
3034 static constexpr size_t s_reply_len{1};
3035 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setBroadcastDC1394RPC(const bool onoff)"};
3036 static constexpr const char* s_help{""};
3037};
3038
3039// setDefaultsDC1394RPC helper class declaration
3041 public yarp::os::Portable
3042{
3043public:
3045 bool write(yarp::os::ConnectionWriter& connection) const override;
3046 bool read(yarp::os::ConnectionReader& connection) override;
3047
3048 class Command :
3050 {
3051 public:
3052 Command() = default;
3053 ~Command() override = default;
3054
3055 bool write(yarp::os::ConnectionWriter& connection) const override;
3056 bool read(yarp::os::ConnectionReader& connection) override;
3057
3058 bool write(const yarp::os::idl::WireWriter& writer) const override;
3059 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
3060 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
3061
3062 bool read(yarp::os::idl::WireReader& reader) override;
3063 bool readTag(yarp::os::idl::WireReader& reader);
3064 bool readArgs(yarp::os::idl::WireReader& reader);
3065 };
3066
3067 class Reply :
3069 {
3070 public:
3071 Reply() = default;
3072 ~Reply() override = default;
3073
3074 bool write(yarp::os::ConnectionWriter& connection) const override;
3075 bool read(yarp::os::ConnectionReader& connection) override;
3076
3077 bool write(const yarp::os::idl::WireWriter& writer) const override;
3078 bool read(yarp::os::idl::WireReader& reader) override;
3079
3081 };
3082
3084 void call(FrameGrabberMsgs* ptr);
3085
3088
3089 static constexpr const char* s_tag{"setDefaultsDC1394RPC"};
3090 static constexpr size_t s_tag_len{1};
3091 static constexpr size_t s_cmd_len{1};
3092 static constexpr size_t s_reply_len{1};
3093 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setDefaultsDC1394RPC()"};
3094 static constexpr const char* s_help{""};
3095};
3096
3097// setResetDC1394RPC helper class declaration
3099 public yarp::os::Portable
3100{
3101public:
3103 bool write(yarp::os::ConnectionWriter& connection) const override;
3104 bool read(yarp::os::ConnectionReader& connection) override;
3105
3106 class Command :
3108 {
3109 public:
3110 Command() = default;
3111 ~Command() override = default;
3112
3113 bool write(yarp::os::ConnectionWriter& connection) const override;
3114 bool read(yarp::os::ConnectionReader& connection) override;
3115
3116 bool write(const yarp::os::idl::WireWriter& writer) const override;
3117 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
3118 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
3119
3120 bool read(yarp::os::idl::WireReader& reader) override;
3121 bool readTag(yarp::os::idl::WireReader& reader);
3122 bool readArgs(yarp::os::idl::WireReader& reader);
3123 };
3124
3125 class Reply :
3127 {
3128 public:
3129 Reply() = default;
3130 ~Reply() override = default;
3131
3132 bool write(yarp::os::ConnectionWriter& connection) const override;
3133 bool read(yarp::os::ConnectionReader& connection) override;
3134
3135 bool write(const yarp::os::idl::WireWriter& writer) const override;
3136 bool read(yarp::os::idl::WireReader& reader) override;
3137
3139 };
3140
3142 void call(FrameGrabberMsgs* ptr);
3143
3146
3147 static constexpr const char* s_tag{"setResetDC1394RPC"};
3148 static constexpr size_t s_tag_len{1};
3149 static constexpr size_t s_cmd_len{1};
3150 static constexpr size_t s_reply_len{1};
3151 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setResetDC1394RPC()"};
3152 static constexpr const char* s_help{""};
3153};
3154
3155// setPowerDC1394RPC helper class declaration
3157 public yarp::os::Portable
3158{
3159public:
3161 explicit FrameGrabberMsgs_setPowerDC1394RPC_helper(const bool onoff);
3162 bool write(yarp::os::ConnectionWriter& connection) const override;
3163 bool read(yarp::os::ConnectionReader& connection) override;
3164
3165 class Command :
3167 {
3168 public:
3169 Command() = default;
3170 explicit Command(const bool onoff);
3171
3172 ~Command() override = default;
3173
3174 bool write(yarp::os::ConnectionWriter& connection) const override;
3175 bool read(yarp::os::ConnectionReader& connection) override;
3176
3177 bool write(const yarp::os::idl::WireWriter& writer) const override;
3178 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
3179 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
3180
3181 bool read(yarp::os::idl::WireReader& reader) override;
3182 bool readTag(yarp::os::idl::WireReader& reader);
3183 bool readArgs(yarp::os::idl::WireReader& reader);
3184
3185 bool onoff{false};
3186 };
3187
3188 class Reply :
3190 {
3191 public:
3192 Reply() = default;
3193 ~Reply() override = default;
3194
3195 bool write(yarp::os::ConnectionWriter& connection) const override;
3196 bool read(yarp::os::ConnectionReader& connection) override;
3197
3198 bool write(const yarp::os::idl::WireWriter& writer) const override;
3199 bool read(yarp::os::idl::WireReader& reader) override;
3200
3202 };
3203
3204 using funcptr_t = yarp::dev::ReturnValue (*)(const bool);
3205 void call(FrameGrabberMsgs* ptr);
3206
3209
3210 static constexpr const char* s_tag{"setPowerDC1394RPC"};
3211 static constexpr size_t s_tag_len{1};
3212 static constexpr size_t s_cmd_len{2};
3213 static constexpr size_t s_reply_len{1};
3214 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setPowerDC1394RPC(const bool onoff)"};
3215 static constexpr const char* s_help{""};
3216};
3217
3218// setCaptureDC1394RPC helper class declaration
3220 public yarp::os::Portable
3221{
3222public:
3224 explicit FrameGrabberMsgs_setCaptureDC1394RPC_helper(const bool bON);
3225 bool write(yarp::os::ConnectionWriter& connection) const override;
3226 bool read(yarp::os::ConnectionReader& connection) override;
3227
3228 class Command :
3230 {
3231 public:
3232 Command() = default;
3233 explicit Command(const bool bON);
3234
3235 ~Command() override = default;
3236
3237 bool write(yarp::os::ConnectionWriter& connection) const override;
3238 bool read(yarp::os::ConnectionReader& connection) override;
3239
3240 bool write(const yarp::os::idl::WireWriter& writer) const override;
3241 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
3242 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
3243
3244 bool read(yarp::os::idl::WireReader& reader) override;
3245 bool readTag(yarp::os::idl::WireReader& reader);
3246 bool readArgs(yarp::os::idl::WireReader& reader);
3247
3248 bool bON{false};
3249 };
3250
3251 class Reply :
3253 {
3254 public:
3255 Reply() = default;
3256 ~Reply() override = default;
3257
3258 bool write(yarp::os::ConnectionWriter& connection) const override;
3259 bool read(yarp::os::ConnectionReader& connection) override;
3260
3261 bool write(const yarp::os::idl::WireWriter& writer) const override;
3262 bool read(yarp::os::idl::WireReader& reader) override;
3263
3265 };
3266
3267 using funcptr_t = yarp::dev::ReturnValue (*)(const bool);
3268 void call(FrameGrabberMsgs* ptr);
3269
3272
3273 static constexpr const char* s_tag{"setCaptureDC1394RPC"};
3274 static constexpr size_t s_tag_len{1};
3275 static constexpr size_t s_cmd_len{2};
3276 static constexpr size_t s_reply_len{1};
3277 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setCaptureDC1394RPC(const bool bON)"};
3278 static constexpr const char* s_help{""};
3279};
3280
3281// getBytesPerPacketDC1394RPC helper class declaration
3283 public yarp::os::Portable
3284{
3285public:
3287 bool write(yarp::os::ConnectionWriter& connection) const override;
3288 bool read(yarp::os::ConnectionReader& connection) override;
3289
3290 class Command :
3292 {
3293 public:
3294 Command() = default;
3295 ~Command() override = default;
3296
3297 bool write(yarp::os::ConnectionWriter& connection) const override;
3298 bool read(yarp::os::ConnectionReader& connection) override;
3299
3300 bool write(const yarp::os::idl::WireWriter& writer) const override;
3301 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
3302 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
3303
3304 bool read(yarp::os::idl::WireReader& reader) override;
3305 bool readTag(yarp::os::idl::WireReader& reader);
3306 bool readArgs(yarp::os::idl::WireReader& reader);
3307 };
3308
3309 class Reply :
3311 {
3312 public:
3313 Reply() = default;
3314 ~Reply() override = default;
3315
3316 bool write(yarp::os::ConnectionWriter& connection) const override;
3317 bool read(yarp::os::ConnectionReader& connection) override;
3318
3319 bool write(const yarp::os::idl::WireWriter& writer) const override;
3320 bool read(yarp::os::idl::WireReader& reader) override;
3321
3323 };
3324
3326 void call(FrameGrabberMsgs* ptr);
3327
3330
3331 static constexpr const char* s_tag{"getBytesPerPacketDC1394RPC"};
3332 static constexpr size_t s_tag_len{1};
3333 static constexpr size_t s_cmd_len{1};
3334 static constexpr size_t s_reply_len{2};
3335 static constexpr const char* s_prototype{"IFrameGrabberControlDC1394Msgs_return_getBytesPerPacketDC1394 FrameGrabberMsgs::getBytesPerPacketDC1394RPC()"};
3336 static constexpr const char* s_help{""};
3337};
3338
3339// setBytesPerPacketDC1394RPC helper class declaration
3341 public yarp::os::Portable
3342{
3343public:
3345 explicit FrameGrabberMsgs_setBytesPerPacketDC1394RPC_helper(const std::int32_t bpp);
3346 bool write(yarp::os::ConnectionWriter& connection) const override;
3347 bool read(yarp::os::ConnectionReader& connection) override;
3348
3349 class Command :
3351 {
3352 public:
3353 Command() = default;
3354 explicit Command(const std::int32_t bpp);
3355
3356 ~Command() override = default;
3357
3358 bool write(yarp::os::ConnectionWriter& connection) const override;
3359 bool read(yarp::os::ConnectionReader& connection) override;
3360
3361 bool write(const yarp::os::idl::WireWriter& writer) const override;
3362 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
3363 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
3364
3365 bool read(yarp::os::idl::WireReader& reader) override;
3366 bool readTag(yarp::os::idl::WireReader& reader);
3367 bool readArgs(yarp::os::idl::WireReader& reader);
3368
3369 std::int32_t bpp{0};
3370 };
3371
3372 class Reply :
3374 {
3375 public:
3376 Reply() = default;
3377 ~Reply() override = default;
3378
3379 bool write(yarp::os::ConnectionWriter& connection) const override;
3380 bool read(yarp::os::ConnectionReader& connection) override;
3381
3382 bool write(const yarp::os::idl::WireWriter& writer) const override;
3383 bool read(yarp::os::idl::WireReader& reader) override;
3384
3386 };
3387
3388 using funcptr_t = yarp::dev::ReturnValue (*)(const std::int32_t);
3389 void call(FrameGrabberMsgs* ptr);
3390
3393
3394 static constexpr const char* s_tag{"setBytesPerPacketDC1394RPC"};
3395 static constexpr size_t s_tag_len{1};
3396 static constexpr size_t s_cmd_len{2};
3397 static constexpr size_t s_reply_len{1};
3398 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameGrabberMsgs::setBytesPerPacketDC1394RPC(const std::int32_t bpp)"};
3399 static constexpr const char* s_help{""};
3400};
3401
3402// getHeightRPC helper class implementation
3404{
3405 return cmd.write(connection);
3406}
3407
3409{
3410 return reply.read(connection);
3411}
3412
3414{
3415 yarp::os::idl::WireWriter writer(connection);
3416 if (!writer.writeListHeader(s_cmd_len)) {
3417 return false;
3418 }
3419 return write(writer);
3420}
3421
3423{
3424 yarp::os::idl::WireReader reader(connection);
3425 if (!reader.readListHeader()) {
3426 reader.fail();
3427 return false;
3428 }
3429 return read(reader);
3430}
3431
3433{
3434 if (!writeTag(writer)) {
3435 return false;
3436 }
3437 if (!writeArgs(writer)) {
3438 return false;
3439 }
3440 return true;
3441}
3442
3444{
3445 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3446 return false;
3447 }
3448 return true;
3449}
3450
3452{
3453 return true;
3454}
3455
3457{
3458 if (!readTag(reader)) {
3459 return false;
3460 }
3461 if (!readArgs(reader)) {
3462 return false;
3463 }
3464 return true;
3465}
3466
3468{
3469 std::string tag = reader.readTag(s_tag_len);
3470 if (reader.isError()) {
3471 return false;
3472 }
3473 if (tag != s_tag) {
3474 reader.fail();
3475 return false;
3476 }
3477 return true;
3478}
3479
3481{
3482 if (!reader.noMore()) {
3483 reader.fail();
3484 return false;
3485 }
3486 return true;
3487}
3488
3490{
3491 yarp::os::idl::WireWriter writer(connection);
3492 return write(writer);
3493}
3494
3496{
3497 yarp::os::idl::WireReader reader(connection);
3498 return read(reader);
3499}
3500
3502{
3503 if (!writer.isNull()) {
3504 if (!writer.writeListHeader(s_reply_len)) {
3505 return false;
3506 }
3507 if (!writer.write(return_helper)) {
3508 return false;
3509 }
3510 }
3511 return true;
3512}
3513
3515{
3516 if (!reader.readListReturn()) {
3517 return false;
3518 }
3519 if (reader.noMore()) {
3520 reader.fail();
3521 return false;
3522 }
3523 if (!reader.read(return_helper)) {
3524 reader.fail();
3525 return false;
3526 }
3527 return true;
3528}
3529
3534
3535// getWidthRPC helper class implementation
3537{
3538 return cmd.write(connection);
3539}
3540
3542{
3543 return reply.read(connection);
3544}
3545
3547{
3548 yarp::os::idl::WireWriter writer(connection);
3549 if (!writer.writeListHeader(s_cmd_len)) {
3550 return false;
3551 }
3552 return write(writer);
3553}
3554
3556{
3557 yarp::os::idl::WireReader reader(connection);
3558 if (!reader.readListHeader()) {
3559 reader.fail();
3560 return false;
3561 }
3562 return read(reader);
3563}
3564
3566{
3567 if (!writeTag(writer)) {
3568 return false;
3569 }
3570 if (!writeArgs(writer)) {
3571 return false;
3572 }
3573 return true;
3574}
3575
3577{
3578 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3579 return false;
3580 }
3581 return true;
3582}
3583
3585{
3586 return true;
3587}
3588
3590{
3591 if (!readTag(reader)) {
3592 return false;
3593 }
3594 if (!readArgs(reader)) {
3595 return false;
3596 }
3597 return true;
3598}
3599
3601{
3602 std::string tag = reader.readTag(s_tag_len);
3603 if (reader.isError()) {
3604 return false;
3605 }
3606 if (tag != s_tag) {
3607 reader.fail();
3608 return false;
3609 }
3610 return true;
3611}
3612
3614{
3615 if (!reader.noMore()) {
3616 reader.fail();
3617 return false;
3618 }
3619 return true;
3620}
3621
3623{
3624 yarp::os::idl::WireWriter writer(connection);
3625 return write(writer);
3626}
3627
3629{
3630 yarp::os::idl::WireReader reader(connection);
3631 return read(reader);
3632}
3633
3635{
3636 if (!writer.isNull()) {
3637 if (!writer.writeListHeader(s_reply_len)) {
3638 return false;
3639 }
3640 if (!writer.write(return_helper)) {
3641 return false;
3642 }
3643 }
3644 return true;
3645}
3646
3648{
3649 if (!reader.readListReturn()) {
3650 return false;
3651 }
3652 if (reader.noMore()) {
3653 reader.fail();
3654 return false;
3655 }
3656 if (!reader.read(return_helper)) {
3657 reader.fail();
3658 return false;
3659 }
3660 return true;
3661}
3662
3667
3668// getImageRPC helper class implementation
3670{
3671 return cmd.write(connection);
3672}
3673
3675{
3676 return reply.read(connection);
3677}
3678
3680{
3681 yarp::os::idl::WireWriter writer(connection);
3682 if (!writer.writeListHeader(s_cmd_len)) {
3683 return false;
3684 }
3685 return write(writer);
3686}
3687
3689{
3690 yarp::os::idl::WireReader reader(connection);
3691 if (!reader.readListHeader()) {
3692 reader.fail();
3693 return false;
3694 }
3695 return read(reader);
3696}
3697
3699{
3700 if (!writeTag(writer)) {
3701 return false;
3702 }
3703 if (!writeArgs(writer)) {
3704 return false;
3705 }
3706 return true;
3707}
3708
3710{
3711 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3712 return false;
3713 }
3714 return true;
3715}
3716
3718{
3719 return true;
3720}
3721
3723{
3724 if (!readTag(reader)) {
3725 return false;
3726 }
3727 if (!readArgs(reader)) {
3728 return false;
3729 }
3730 return true;
3731}
3732
3734{
3735 std::string tag = reader.readTag(s_tag_len);
3736 if (reader.isError()) {
3737 return false;
3738 }
3739 if (tag != s_tag) {
3740 reader.fail();
3741 return false;
3742 }
3743 return true;
3744}
3745
3747{
3748 if (!reader.noMore()) {
3749 reader.fail();
3750 return false;
3751 }
3752 return true;
3753}
3754
3756{
3757 yarp::os::idl::WireWriter writer(connection);
3758 return write(writer);
3759}
3760
3762{
3763 yarp::os::idl::WireReader reader(connection);
3764 return read(reader);
3765}
3766
3768{
3769 if (!writer.isNull()) {
3770 if (!writer.writeListHeader(s_reply_len)) {
3771 return false;
3772 }
3773 if (!writer.write(return_helper)) {
3774 return false;
3775 }
3776 }
3777 return true;
3778}
3779
3781{
3782 if (!reader.readListReturn()) {
3783 return false;
3784 }
3785 if (reader.noMore()) {
3786 reader.fail();
3787 return false;
3788 }
3789 if (!reader.read(return_helper)) {
3790 reader.fail();
3791 return false;
3792 }
3793 return true;
3794}
3795
3800
3801// getImageCropRPC helper class implementation
3803 cmd{type, vertices}
3804{
3805}
3806
3808{
3809 return cmd.write(connection);
3810}
3811
3813{
3814 return reply.read(connection);
3815}
3816
3817FrameGrabberMsgs_getImageCropRPC_helper::Command::Command(const yarp::dev::cropType_id_t type, const std::vector<yarp::dev::VertexData>& vertices) :
3818 type{type},
3819 vertices{vertices}
3820{
3821}
3822
3824{
3825 yarp::os::idl::WireWriter writer(connection);
3826 if (!writer.writeListHeader(s_cmd_len)) {
3827 return false;
3828 }
3829 return write(writer);
3830}
3831
3833{
3834 yarp::os::idl::WireReader reader(connection);
3835 if (!reader.readListHeader()) {
3836 reader.fail();
3837 return false;
3838 }
3839 return read(reader);
3840}
3841
3843{
3844 if (!writeTag(writer)) {
3845 return false;
3846 }
3847 if (!writeArgs(writer)) {
3848 return false;
3849 }
3850 return true;
3851}
3852
3854{
3855 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3856 return false;
3857 }
3858 return true;
3859}
3860
3862{
3863 if (!writer.writeI32(static_cast<int32_t>(type))) {
3864 return false;
3865 }
3866 if (!writer.writeListBegin(BOTTLE_TAG_LIST, vertices.size())) {
3867 return false;
3868 }
3869 for (const auto& _item : vertices) {
3870 if (!writer.writeNested(_item)) {
3871 return false;
3872 }
3873 }
3874 if (!writer.writeListEnd()) {
3875 return false;
3876 }
3877 return true;
3878}
3879
3881{
3882 if (!readTag(reader)) {
3883 return false;
3884 }
3885 if (!readArgs(reader)) {
3886 return false;
3887 }
3888 return true;
3889}
3890
3892{
3893 std::string tag = reader.readTag(s_tag_len);
3894 if (reader.isError()) {
3895 return false;
3896 }
3897 if (tag != s_tag) {
3898 reader.fail();
3899 return false;
3900 }
3901 return true;
3902}
3903
3905{
3906 if (reader.noMore()) {
3907 reader.fail();
3908 return false;
3909 }
3910 int32_t _ecast;
3911 if (!reader.readI32(_ecast)) {
3912 reader.fail();
3913 return false;
3914 }
3915 type = static_cast<yarp::dev::cropType_id_t>(_ecast);
3916 if (reader.noMore()) {
3917 reader.fail();
3918 return false;
3919 }
3920 {
3921 size_t _csize;
3923 reader.readListBegin(_etype, _csize);
3924 // WireReader removes BOTTLE_TAG_LIST from the tag
3925 constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
3926 if constexpr (expected_tag != 0) {
3927 if (_csize != 0 && _etype.code != expected_tag) {
3928 return false;
3929 }
3930 }
3931 vertices.resize(_csize);
3932 for (size_t _i0 = 0; _i0 < _csize; ++_i0) {
3933 if (reader.noMore()) {
3934 reader.fail();
3935 return false;
3936 }
3937 if (!reader.readNested(vertices[_i0])) {
3938 reader.fail();
3939 return false;
3940 }
3941 }
3942 reader.readListEnd();
3943 }
3944 if (!reader.noMore()) {
3945 reader.fail();
3946 return false;
3947 }
3948 return true;
3949}
3950
3952{
3953 yarp::os::idl::WireWriter writer(connection);
3954 return write(writer);
3955}
3956
3958{
3959 yarp::os::idl::WireReader reader(connection);
3960 return read(reader);
3961}
3962
3964{
3965 if (!writer.isNull()) {
3966 if (!writer.writeListHeader(s_reply_len)) {
3967 return false;
3968 }
3969 if (!writer.write(return_helper)) {
3970 return false;
3971 }
3972 }
3973 return true;
3974}
3975
3977{
3978 if (!reader.readListReturn()) {
3979 return false;
3980 }
3981 if (reader.noMore()) {
3982 reader.fail();
3983 return false;
3984 }
3985 if (!reader.read(return_helper)) {
3986 reader.fail();
3987 return false;
3988 }
3989 return true;
3990}
3991
3996
3997// getRgbWidthRPC helper class implementation
3999{
4000 return cmd.write(connection);
4001}
4002
4004{
4005 return reply.read(connection);
4006}
4007
4009{
4010 yarp::os::idl::WireWriter writer(connection);
4011 if (!writer.writeListHeader(s_cmd_len)) {
4012 return false;
4013 }
4014 return write(writer);
4015}
4016
4018{
4019 yarp::os::idl::WireReader reader(connection);
4020 if (!reader.readListHeader()) {
4021 reader.fail();
4022 return false;
4023 }
4024 return read(reader);
4025}
4026
4028{
4029 if (!writeTag(writer)) {
4030 return false;
4031 }
4032 if (!writeArgs(writer)) {
4033 return false;
4034 }
4035 return true;
4036}
4037
4039{
4040 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4041 return false;
4042 }
4043 return true;
4044}
4045
4047{
4048 return true;
4049}
4050
4052{
4053 if (!readTag(reader)) {
4054 return false;
4055 }
4056 if (!readArgs(reader)) {
4057 return false;
4058 }
4059 return true;
4060}
4061
4063{
4064 std::string tag = reader.readTag(s_tag_len);
4065 if (reader.isError()) {
4066 return false;
4067 }
4068 if (tag != s_tag) {
4069 reader.fail();
4070 return false;
4071 }
4072 return true;
4073}
4074
4076{
4077 if (!reader.noMore()) {
4078 reader.fail();
4079 return false;
4080 }
4081 return true;
4082}
4083
4085{
4086 yarp::os::idl::WireWriter writer(connection);
4087 return write(writer);
4088}
4089
4091{
4092 yarp::os::idl::WireReader reader(connection);
4093 return read(reader);
4094}
4095
4097{
4098 if (!writer.isNull()) {
4099 if (!writer.writeListHeader(s_reply_len)) {
4100 return false;
4101 }
4102 if (!writer.write(return_helper)) {
4103 return false;
4104 }
4105 }
4106 return true;
4107}
4108
4110{
4111 if (!reader.readListReturn()) {
4112 return false;
4113 }
4114 if (reader.noMore()) {
4115 reader.fail();
4116 return false;
4117 }
4118 if (!reader.read(return_helper)) {
4119 reader.fail();
4120 return false;
4121 }
4122 return true;
4123}
4124
4129
4130// getRgbHeightRPC helper class implementation
4132{
4133 return cmd.write(connection);
4134}
4135
4137{
4138 return reply.read(connection);
4139}
4140
4142{
4143 yarp::os::idl::WireWriter writer(connection);
4144 if (!writer.writeListHeader(s_cmd_len)) {
4145 return false;
4146 }
4147 return write(writer);
4148}
4149
4151{
4152 yarp::os::idl::WireReader reader(connection);
4153 if (!reader.readListHeader()) {
4154 reader.fail();
4155 return false;
4156 }
4157 return read(reader);
4158}
4159
4161{
4162 if (!writeTag(writer)) {
4163 return false;
4164 }
4165 if (!writeArgs(writer)) {
4166 return false;
4167 }
4168 return true;
4169}
4170
4172{
4173 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4174 return false;
4175 }
4176 return true;
4177}
4178
4180{
4181 return true;
4182}
4183
4185{
4186 if (!readTag(reader)) {
4187 return false;
4188 }
4189 if (!readArgs(reader)) {
4190 return false;
4191 }
4192 return true;
4193}
4194
4196{
4197 std::string tag = reader.readTag(s_tag_len);
4198 if (reader.isError()) {
4199 return false;
4200 }
4201 if (tag != s_tag) {
4202 reader.fail();
4203 return false;
4204 }
4205 return true;
4206}
4207
4209{
4210 if (!reader.noMore()) {
4211 reader.fail();
4212 return false;
4213 }
4214 return true;
4215}
4216
4218{
4219 yarp::os::idl::WireWriter writer(connection);
4220 return write(writer);
4221}
4222
4224{
4225 yarp::os::idl::WireReader reader(connection);
4226 return read(reader);
4227}
4228
4230{
4231 if (!writer.isNull()) {
4232 if (!writer.writeListHeader(s_reply_len)) {
4233 return false;
4234 }
4235 if (!writer.write(return_helper)) {
4236 return false;
4237 }
4238 }
4239 return true;
4240}
4241
4243{
4244 if (!reader.readListReturn()) {
4245 return false;
4246 }
4247 if (reader.noMore()) {
4248 reader.fail();
4249 return false;
4250 }
4251 if (!reader.read(return_helper)) {
4252 reader.fail();
4253 return false;
4254 }
4255 return true;
4256}
4257
4262
4263// getRgbSupportedConfigurationsRPC helper class implementation
4268
4273
4275{
4276 yarp::os::idl::WireWriter writer(connection);
4277 if (!writer.writeListHeader(s_cmd_len)) {
4278 return false;
4279 }
4280 return write(writer);
4281}
4282
4284{
4285 yarp::os::idl::WireReader reader(connection);
4286 if (!reader.readListHeader()) {
4287 reader.fail();
4288 return false;
4289 }
4290 return read(reader);
4291}
4292
4294{
4295 if (!writeTag(writer)) {
4296 return false;
4297 }
4298 if (!writeArgs(writer)) {
4299 return false;
4300 }
4301 return true;
4302}
4303
4305{
4306 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4307 return false;
4308 }
4309 return true;
4310}
4311
4313{
4314 return true;
4315}
4316
4318{
4319 if (!readTag(reader)) {
4320 return false;
4321 }
4322 if (!readArgs(reader)) {
4323 return false;
4324 }
4325 return true;
4326}
4327
4329{
4330 std::string tag = reader.readTag(s_tag_len);
4331 if (reader.isError()) {
4332 return false;
4333 }
4334 if (tag != s_tag) {
4335 reader.fail();
4336 return false;
4337 }
4338 return true;
4339}
4340
4342{
4343 if (!reader.noMore()) {
4344 reader.fail();
4345 return false;
4346 }
4347 return true;
4348}
4349
4355
4361
4363{
4364 if (!writer.isNull()) {
4365 if (!writer.writeListHeader(s_reply_len)) {
4366 return false;
4367 }
4368 if (!writer.write(return_helper)) {
4369 return false;
4370 }
4371 }
4372 return true;
4373}
4374
4376{
4377 if (!reader.readListReturn()) {
4378 return false;
4379 }
4380 if (reader.noMore()) {
4381 reader.fail();
4382 return false;
4383 }
4384 if (!reader.read(return_helper)) {
4385 reader.fail();
4386 return false;
4387 }
4388 return true;
4389}
4390
4395
4396// getRgbResolutionRPC helper class implementation
4398{
4399 return cmd.write(connection);
4400}
4401
4406
4408{
4409 yarp::os::idl::WireWriter writer(connection);
4410 if (!writer.writeListHeader(s_cmd_len)) {
4411 return false;
4412 }
4413 return write(writer);
4414}
4415
4417{
4418 yarp::os::idl::WireReader reader(connection);
4419 if (!reader.readListHeader()) {
4420 reader.fail();
4421 return false;
4422 }
4423 return read(reader);
4424}
4425
4427{
4428 if (!writeTag(writer)) {
4429 return false;
4430 }
4431 if (!writeArgs(writer)) {
4432 return false;
4433 }
4434 return true;
4435}
4436
4438{
4439 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4440 return false;
4441 }
4442 return true;
4443}
4444
4446{
4447 return true;
4448}
4449
4451{
4452 if (!readTag(reader)) {
4453 return false;
4454 }
4455 if (!readArgs(reader)) {
4456 return false;
4457 }
4458 return true;
4459}
4460
4462{
4463 std::string tag = reader.readTag(s_tag_len);
4464 if (reader.isError()) {
4465 return false;
4466 }
4467 if (tag != s_tag) {
4468 reader.fail();
4469 return false;
4470 }
4471 return true;
4472}
4473
4475{
4476 if (!reader.noMore()) {
4477 reader.fail();
4478 return false;
4479 }
4480 return true;
4481}
4482
4484{
4485 yarp::os::idl::WireWriter writer(connection);
4486 return write(writer);
4487}
4488
4490{
4491 yarp::os::idl::WireReader reader(connection);
4492 return read(reader);
4493}
4494
4496{
4497 if (!writer.isNull()) {
4498 if (!writer.writeListHeader(s_reply_len)) {
4499 return false;
4500 }
4501 if (!writer.write(return_helper)) {
4502 return false;
4503 }
4504 }
4505 return true;
4506}
4507
4509{
4510 if (!reader.readListReturn()) {
4511 return false;
4512 }
4513 if (reader.noMore()) {
4514 reader.fail();
4515 return false;
4516 }
4517 if (!reader.read(return_helper)) {
4518 reader.fail();
4519 return false;
4520 }
4521 return true;
4522}
4523
4528
4529// setRgbResolutionRPC helper class implementation
4531 cmd{width, height}
4532{
4533}
4534
4536{
4537 return cmd.write(connection);
4538}
4539
4544
4545FrameGrabberMsgs_setRgbResolutionRPC_helper::Command::Command(const std::int32_t width, const std::int32_t height) :
4546 width{width},
4547 height{height}
4548{
4549}
4550
4552{
4553 yarp::os::idl::WireWriter writer(connection);
4554 if (!writer.writeListHeader(s_cmd_len)) {
4555 return false;
4556 }
4557 return write(writer);
4558}
4559
4561{
4562 yarp::os::idl::WireReader reader(connection);
4563 if (!reader.readListHeader()) {
4564 reader.fail();
4565 return false;
4566 }
4567 return read(reader);
4568}
4569
4571{
4572 if (!writeTag(writer)) {
4573 return false;
4574 }
4575 if (!writeArgs(writer)) {
4576 return false;
4577 }
4578 return true;
4579}
4580
4582{
4583 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4584 return false;
4585 }
4586 return true;
4587}
4588
4590{
4591 if (!writer.writeI32(width)) {
4592 return false;
4593 }
4594 if (!writer.writeI32(height)) {
4595 return false;
4596 }
4597 return true;
4598}
4599
4601{
4602 if (!readTag(reader)) {
4603 return false;
4604 }
4605 if (!readArgs(reader)) {
4606 return false;
4607 }
4608 return true;
4609}
4610
4612{
4613 std::string tag = reader.readTag(s_tag_len);
4614 if (reader.isError()) {
4615 return false;
4616 }
4617 if (tag != s_tag) {
4618 reader.fail();
4619 return false;
4620 }
4621 return true;
4622}
4623
4625{
4626 if (reader.noMore()) {
4627 reader.fail();
4628 return false;
4629 }
4630 if (!reader.readI32(width)) {
4631 reader.fail();
4632 return false;
4633 }
4634 if (reader.noMore()) {
4635 reader.fail();
4636 return false;
4637 }
4638 if (!reader.readI32(height)) {
4639 reader.fail();
4640 return false;
4641 }
4642 if (!reader.noMore()) {
4643 reader.fail();
4644 return false;
4645 }
4646 return true;
4647}
4648
4650{
4651 yarp::os::idl::WireWriter writer(connection);
4652 return write(writer);
4653}
4654
4656{
4657 yarp::os::idl::WireReader reader(connection);
4658 return read(reader);
4659}
4660
4662{
4663 if (!writer.isNull()) {
4664 if (!writer.write(return_helper)) {
4665 return false;
4666 }
4667 }
4668 return true;
4669}
4670
4672{
4673 if (reader.noMore()) {
4674 reader.fail();
4675 return false;
4676 }
4677 if (!reader.read(return_helper)) {
4678 reader.fail();
4679 return false;
4680 }
4681 return true;
4682}
4683
4688
4689// getRgbFOVRPC helper class implementation
4691{
4692 return cmd.write(connection);
4693}
4694
4696{
4697 return reply.read(connection);
4698}
4699
4701{
4702 yarp::os::idl::WireWriter writer(connection);
4703 if (!writer.writeListHeader(s_cmd_len)) {
4704 return false;
4705 }
4706 return write(writer);
4707}
4708
4710{
4711 yarp::os::idl::WireReader reader(connection);
4712 if (!reader.readListHeader()) {
4713 reader.fail();
4714 return false;
4715 }
4716 return read(reader);
4717}
4718
4720{
4721 if (!writeTag(writer)) {
4722 return false;
4723 }
4724 if (!writeArgs(writer)) {
4725 return false;
4726 }
4727 return true;
4728}
4729
4731{
4732 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4733 return false;
4734 }
4735 return true;
4736}
4737
4739{
4740 return true;
4741}
4742
4744{
4745 if (!readTag(reader)) {
4746 return false;
4747 }
4748 if (!readArgs(reader)) {
4749 return false;
4750 }
4751 return true;
4752}
4753
4755{
4756 std::string tag = reader.readTag(s_tag_len);
4757 if (reader.isError()) {
4758 return false;
4759 }
4760 if (tag != s_tag) {
4761 reader.fail();
4762 return false;
4763 }
4764 return true;
4765}
4766
4768{
4769 if (!reader.noMore()) {
4770 reader.fail();
4771 return false;
4772 }
4773 return true;
4774}
4775
4777{
4778 yarp::os::idl::WireWriter writer(connection);
4779 return write(writer);
4780}
4781
4783{
4784 yarp::os::idl::WireReader reader(connection);
4785 return read(reader);
4786}
4787
4789{
4790 if (!writer.isNull()) {
4791 if (!writer.writeListHeader(s_reply_len)) {
4792 return false;
4793 }
4794 if (!writer.write(return_helper)) {
4795 return false;
4796 }
4797 }
4798 return true;
4799}
4800
4802{
4803 if (!reader.readListReturn()) {
4804 return false;
4805 }
4806 if (reader.noMore()) {
4807 reader.fail();
4808 return false;
4809 }
4810 if (!reader.read(return_helper)) {
4811 reader.fail();
4812 return false;
4813 }
4814 return true;
4815}
4816
4821
4822// setRgbFOVRPC helper class implementation
4823FrameGrabberMsgs_setRgbFOVRPC_helper::FrameGrabberMsgs_setRgbFOVRPC_helper(const double horizontalFov, const double verticalFov) :
4824 cmd{horizontalFov, verticalFov}
4825{
4826}
4827
4829{
4830 return cmd.write(connection);
4831}
4832
4834{
4835 return reply.read(connection);
4836}
4837
4838FrameGrabberMsgs_setRgbFOVRPC_helper::Command::Command(const double horizontalFov, const double verticalFov) :
4839 horizontalFov{horizontalFov},
4840 verticalFov{verticalFov}
4841{
4842}
4843
4845{
4846 yarp::os::idl::WireWriter writer(connection);
4847 if (!writer.writeListHeader(s_cmd_len)) {
4848 return false;
4849 }
4850 return write(writer);
4851}
4852
4854{
4855 yarp::os::idl::WireReader reader(connection);
4856 if (!reader.readListHeader()) {
4857 reader.fail();
4858 return false;
4859 }
4860 return read(reader);
4861}
4862
4864{
4865 if (!writeTag(writer)) {
4866 return false;
4867 }
4868 if (!writeArgs(writer)) {
4869 return false;
4870 }
4871 return true;
4872}
4873
4875{
4876 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4877 return false;
4878 }
4879 return true;
4880}
4881
4883{
4884 if (!writer.writeFloat64(horizontalFov)) {
4885 return false;
4886 }
4887 if (!writer.writeFloat64(verticalFov)) {
4888 return false;
4889 }
4890 return true;
4891}
4892
4894{
4895 if (!readTag(reader)) {
4896 return false;
4897 }
4898 if (!readArgs(reader)) {
4899 return false;
4900 }
4901 return true;
4902}
4903
4905{
4906 std::string tag = reader.readTag(s_tag_len);
4907 if (reader.isError()) {
4908 return false;
4909 }
4910 if (tag != s_tag) {
4911 reader.fail();
4912 return false;
4913 }
4914 return true;
4915}
4916
4918{
4919 if (reader.noMore()) {
4920 reader.fail();
4921 return false;
4922 }
4923 if (!reader.readFloat64(horizontalFov)) {
4924 reader.fail();
4925 return false;
4926 }
4927 if (reader.noMore()) {
4928 reader.fail();
4929 return false;
4930 }
4931 if (!reader.readFloat64(verticalFov)) {
4932 reader.fail();
4933 return false;
4934 }
4935 if (!reader.noMore()) {
4936 reader.fail();
4937 return false;
4938 }
4939 return true;
4940}
4941
4943{
4944 yarp::os::idl::WireWriter writer(connection);
4945 return write(writer);
4946}
4947
4949{
4950 yarp::os::idl::WireReader reader(connection);
4951 return read(reader);
4952}
4953
4955{
4956 if (!writer.isNull()) {
4957 if (!writer.write(return_helper)) {
4958 return false;
4959 }
4960 }
4961 return true;
4962}
4963
4965{
4966 if (reader.noMore()) {
4967 reader.fail();
4968 return false;
4969 }
4970 if (!reader.read(return_helper)) {
4971 reader.fail();
4972 return false;
4973 }
4974 return true;
4975}
4976
4981
4982// getRgbIntrinsicParamRPC helper class implementation
4984{
4985 return cmd.write(connection);
4986}
4987
4992
4994{
4995 yarp::os::idl::WireWriter writer(connection);
4996 if (!writer.writeListHeader(s_cmd_len)) {
4997 return false;
4998 }
4999 return write(writer);
5000}
5001
5003{
5004 yarp::os::idl::WireReader reader(connection);
5005 if (!reader.readListHeader()) {
5006 reader.fail();
5007 return false;
5008 }
5009 return read(reader);
5010}
5011
5013{
5014 if (!writeTag(writer)) {
5015 return false;
5016 }
5017 if (!writeArgs(writer)) {
5018 return false;
5019 }
5020 return true;
5021}
5022
5024{
5025 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5026 return false;
5027 }
5028 return true;
5029}
5030
5032{
5033 return true;
5034}
5035
5037{
5038 if (!readTag(reader)) {
5039 return false;
5040 }
5041 if (!readArgs(reader)) {
5042 return false;
5043 }
5044 return true;
5045}
5046
5048{
5049 std::string tag = reader.readTag(s_tag_len);
5050 if (reader.isError()) {
5051 return false;
5052 }
5053 if (tag != s_tag) {
5054 reader.fail();
5055 return false;
5056 }
5057 return true;
5058}
5059
5061{
5062 if (!reader.noMore()) {
5063 reader.fail();
5064 return false;
5065 }
5066 return true;
5067}
5068
5070{
5071 yarp::os::idl::WireWriter writer(connection);
5072 return write(writer);
5073}
5074
5076{
5077 yarp::os::idl::WireReader reader(connection);
5078 return read(reader);
5079}
5080
5082{
5083 if (!writer.isNull()) {
5084 if (!writer.writeListHeader(s_reply_len)) {
5085 return false;
5086 }
5087 if (!writer.write(return_helper)) {
5088 return false;
5089 }
5090 }
5091 return true;
5092}
5093
5095{
5096 if (!reader.readListReturn()) {
5097 return false;
5098 }
5099 if (reader.noMore()) {
5100 reader.fail();
5101 return false;
5102 }
5103 if (!reader.read(return_helper)) {
5104 reader.fail();
5105 return false;
5106 }
5107 return true;
5108}
5109
5114
5115// getRgbMirroringRPC helper class implementation
5117{
5118 return cmd.write(connection);
5119}
5120
5122{
5123 return reply.read(connection);
5124}
5125
5127{
5128 yarp::os::idl::WireWriter writer(connection);
5129 if (!writer.writeListHeader(s_cmd_len)) {
5130 return false;
5131 }
5132 return write(writer);
5133}
5134
5136{
5137 yarp::os::idl::WireReader reader(connection);
5138 if (!reader.readListHeader()) {
5139 reader.fail();
5140 return false;
5141 }
5142 return read(reader);
5143}
5144
5146{
5147 if (!writeTag(writer)) {
5148 return false;
5149 }
5150 if (!writeArgs(writer)) {
5151 return false;
5152 }
5153 return true;
5154}
5155
5157{
5158 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5159 return false;
5160 }
5161 return true;
5162}
5163
5165{
5166 return true;
5167}
5168
5170{
5171 if (!readTag(reader)) {
5172 return false;
5173 }
5174 if (!readArgs(reader)) {
5175 return false;
5176 }
5177 return true;
5178}
5179
5181{
5182 std::string tag = reader.readTag(s_tag_len);
5183 if (reader.isError()) {
5184 return false;
5185 }
5186 if (tag != s_tag) {
5187 reader.fail();
5188 return false;
5189 }
5190 return true;
5191}
5192
5194{
5195 if (!reader.noMore()) {
5196 reader.fail();
5197 return false;
5198 }
5199 return true;
5200}
5201
5203{
5204 yarp::os::idl::WireWriter writer(connection);
5205 return write(writer);
5206}
5207
5209{
5210 yarp::os::idl::WireReader reader(connection);
5211 return read(reader);
5212}
5213
5215{
5216 if (!writer.isNull()) {
5217 if (!writer.writeListHeader(s_reply_len)) {
5218 return false;
5219 }
5220 if (!writer.write(return_helper)) {
5221 return false;
5222 }
5223 }
5224 return true;
5225}
5226
5228{
5229 if (!reader.readListReturn()) {
5230 return false;
5231 }
5232 if (reader.noMore()) {
5233 reader.fail();
5234 return false;
5235 }
5236 if (!reader.read(return_helper)) {
5237 reader.fail();
5238 return false;
5239 }
5240 return true;
5241}
5242
5247
5248// setRgbMirroringRPC helper class implementation
5253
5255{
5256 return cmd.write(connection);
5257}
5258
5260{
5261 return reply.read(connection);
5262}
5263
5265 mirror{mirror}
5266{
5267}
5268
5270{
5271 yarp::os::idl::WireWriter writer(connection);
5272 if (!writer.writeListHeader(s_cmd_len)) {
5273 return false;
5274 }
5275 return write(writer);
5276}
5277
5279{
5280 yarp::os::idl::WireReader reader(connection);
5281 if (!reader.readListHeader()) {
5282 reader.fail();
5283 return false;
5284 }
5285 return read(reader);
5286}
5287
5289{
5290 if (!writeTag(writer)) {
5291 return false;
5292 }
5293 if (!writeArgs(writer)) {
5294 return false;
5295 }
5296 return true;
5297}
5298
5300{
5301 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5302 return false;
5303 }
5304 return true;
5305}
5306
5308{
5309 if (!writer.writeBool(mirror)) {
5310 return false;
5311 }
5312 return true;
5313}
5314
5316{
5317 if (!readTag(reader)) {
5318 return false;
5319 }
5320 if (!readArgs(reader)) {
5321 return false;
5322 }
5323 return true;
5324}
5325
5327{
5328 std::string tag = reader.readTag(s_tag_len);
5329 if (reader.isError()) {
5330 return false;
5331 }
5332 if (tag != s_tag) {
5333 reader.fail();
5334 return false;
5335 }
5336 return true;
5337}
5338
5340{
5341 if (reader.noMore()) {
5342 reader.fail();
5343 return false;
5344 }
5345 if (!reader.readBool(mirror)) {
5346 reader.fail();
5347 return false;
5348 }
5349 if (!reader.noMore()) {
5350 reader.fail();
5351 return false;
5352 }
5353 return true;
5354}
5355
5357{
5358 yarp::os::idl::WireWriter writer(connection);
5359 return write(writer);
5360}
5361
5363{
5364 yarp::os::idl::WireReader reader(connection);
5365 return read(reader);
5366}
5367
5369{
5370 if (!writer.isNull()) {
5371 if (!writer.write(return_helper)) {
5372 return false;
5373 }
5374 }
5375 return true;
5376}
5377
5379{
5380 if (reader.noMore()) {
5381 reader.fail();
5382 return false;
5383 }
5384 if (!reader.read(return_helper)) {
5385 reader.fail();
5386 return false;
5387 }
5388 return true;
5389}
5390
5395
5396// getCameraDescriptionRPC helper class implementation
5398{
5399 return cmd.write(connection);
5400}
5401
5406
5408{
5409 yarp::os::idl::WireWriter writer(connection);
5410 if (!writer.writeListHeader(s_cmd_len)) {
5411 return false;
5412 }
5413 return write(writer);
5414}
5415
5417{
5418 yarp::os::idl::WireReader reader(connection);
5419 if (!reader.readListHeader()) {
5420 reader.fail();
5421 return false;
5422 }
5423 return read(reader);
5424}
5425
5427{
5428 if (!writeTag(writer)) {
5429 return false;
5430 }
5431 if (!writeArgs(writer)) {
5432 return false;
5433 }
5434 return true;
5435}
5436
5438{
5439 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5440 return false;
5441 }
5442 return true;
5443}
5444
5446{
5447 return true;
5448}
5449
5451{
5452 if (!readTag(reader)) {
5453 return false;
5454 }
5455 if (!readArgs(reader)) {
5456 return false;
5457 }
5458 return true;
5459}
5460
5462{
5463 std::string tag = reader.readTag(s_tag_len);
5464 if (reader.isError()) {
5465 return false;
5466 }
5467 if (tag != s_tag) {
5468 reader.fail();
5469 return false;
5470 }
5471 return true;
5472}
5473
5475{
5476 if (!reader.noMore()) {
5477 reader.fail();
5478 return false;
5479 }
5480 return true;
5481}
5482
5484{
5485 yarp::os::idl::WireWriter writer(connection);
5486 return write(writer);
5487}
5488
5490{
5491 yarp::os::idl::WireReader reader(connection);
5492 return read(reader);
5493}
5494
5496{
5497 if (!writer.isNull()) {
5498 if (!writer.writeListHeader(s_reply_len)) {
5499 return false;
5500 }
5501 if (!writer.write(return_helper)) {
5502 return false;
5503 }
5504 }
5505 return true;
5506}
5507
5509{
5510 if (!reader.readListReturn()) {
5511 return false;
5512 }
5513 if (reader.noMore()) {
5514 reader.fail();
5515 return false;
5516 }
5517 if (!reader.read(return_helper)) {
5518 reader.fail();
5519 return false;
5520 }
5521 return true;
5522}
5523
5528
5529// hasFeatureRPC helper class implementation
5534
5536{
5537 return cmd.write(connection);
5538}
5539
5541{
5542 return reply.read(connection);
5543}
5544
5549
5551{
5552 yarp::os::idl::WireWriter writer(connection);
5553 if (!writer.writeListHeader(s_cmd_len)) {
5554 return false;
5555 }
5556 return write(writer);
5557}
5558
5560{
5561 yarp::os::idl::WireReader reader(connection);
5562 if (!reader.readListHeader()) {
5563 reader.fail();
5564 return false;
5565 }
5566 return read(reader);
5567}
5568
5570{
5571 if (!writeTag(writer)) {
5572 return false;
5573 }
5574 if (!writeArgs(writer)) {
5575 return false;
5576 }
5577 return true;
5578}
5579
5581{
5582 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5583 return false;
5584 }
5585 return true;
5586}
5587
5589{
5590 if (!writer.writeI32(feature)) {
5591 return false;
5592 }
5593 return true;
5594}
5595
5597{
5598 if (!readTag(reader)) {
5599 return false;
5600 }
5601 if (!readArgs(reader)) {
5602 return false;
5603 }
5604 return true;
5605}
5606
5608{
5609 std::string tag = reader.readTag(s_tag_len);
5610 if (reader.isError()) {
5611 return false;
5612 }
5613 if (tag != s_tag) {
5614 reader.fail();
5615 return false;
5616 }
5617 return true;
5618}
5619
5621{
5622 if (reader.noMore()) {
5623 reader.fail();
5624 return false;
5625 }
5626 if (!reader.readI32(feature)) {
5627 reader.fail();
5628 return false;
5629 }
5630 if (!reader.noMore()) {
5631 reader.fail();
5632 return false;
5633 }
5634 return true;
5635}
5636
5638{
5639 yarp::os::idl::WireWriter writer(connection);
5640 return write(writer);
5641}
5642
5644{
5645 yarp::os::idl::WireReader reader(connection);
5646 return read(reader);
5647}
5648
5650{
5651 if (!writer.isNull()) {
5652 if (!writer.writeListHeader(s_reply_len)) {
5653 return false;
5654 }
5655 if (!writer.write(return_helper)) {
5656 return false;
5657 }
5658 }
5659 return true;
5660}
5661
5663{
5664 if (!reader.readListReturn()) {
5665 return false;
5666 }
5667 if (reader.noMore()) {
5668 reader.fail();
5669 return false;
5670 }
5671 if (!reader.read(return_helper)) {
5672 reader.fail();
5673 return false;
5674 }
5675 return true;
5676}
5677
5682
5683// setFeature1RPC helper class implementation
5685 cmd{feature, value}
5686{
5687}
5688
5690{
5691 return cmd.write(connection);
5692}
5693
5695{
5696 return reply.read(connection);
5697}
5698
5701 value{value}
5702{
5703}
5704
5706{
5707 yarp::os::idl::WireWriter writer(connection);
5708 if (!writer.writeListHeader(s_cmd_len)) {
5709 return false;
5710 }
5711 return write(writer);
5712}
5713
5715{
5716 yarp::os::idl::WireReader reader(connection);
5717 if (!reader.readListHeader()) {
5718 reader.fail();
5719 return false;
5720 }
5721 return read(reader);
5722}
5723
5725{
5726 if (!writeTag(writer)) {
5727 return false;
5728 }
5729 if (!writeArgs(writer)) {
5730 return false;
5731 }
5732 return true;
5733}
5734
5736{
5737 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5738 return false;
5739 }
5740 return true;
5741}
5742
5744{
5745 if (!writer.writeI32(feature)) {
5746 return false;
5747 }
5748 if (!writer.writeFloat64(value)) {
5749 return false;
5750 }
5751 return true;
5752}
5753
5755{
5756 if (!readTag(reader)) {
5757 return false;
5758 }
5759 if (!readArgs(reader)) {
5760 return false;
5761 }
5762 return true;
5763}
5764
5766{
5767 std::string tag = reader.readTag(s_tag_len);
5768 if (reader.isError()) {
5769 return false;
5770 }
5771 if (tag != s_tag) {
5772 reader.fail();
5773 return false;
5774 }
5775 return true;
5776}
5777
5779{
5780 if (reader.noMore()) {
5781 reader.fail();
5782 return false;
5783 }
5784 if (!reader.readI32(feature)) {
5785 reader.fail();
5786 return false;
5787 }
5788 if (reader.noMore()) {
5789 reader.fail();
5790 return false;
5791 }
5792 if (!reader.readFloat64(value)) {
5793 reader.fail();
5794 return false;
5795 }
5796 if (!reader.noMore()) {
5797 reader.fail();
5798 return false;
5799 }
5800 return true;
5801}
5802
5804{
5805 yarp::os::idl::WireWriter writer(connection);
5806 return write(writer);
5807}
5808
5810{
5811 yarp::os::idl::WireReader reader(connection);
5812 return read(reader);
5813}
5814
5816{
5817 if (!writer.isNull()) {
5818 if (!writer.write(return_helper)) {
5819 return false;
5820 }
5821 }
5822 return true;
5823}
5824
5826{
5827 if (reader.noMore()) {
5828 reader.fail();
5829 return false;
5830 }
5831 if (!reader.read(return_helper)) {
5832 reader.fail();
5833 return false;
5834 }
5835 return true;
5836}
5837
5842
5843// getFeature1RPC helper class implementation
5848
5850{
5851 return cmd.write(connection);
5852}
5853
5855{
5856 return reply.read(connection);
5857}
5858
5863
5865{
5866 yarp::os::idl::WireWriter writer(connection);
5867 if (!writer.writeListHeader(s_cmd_len)) {
5868 return false;
5869 }
5870 return write(writer);
5871}
5872
5874{
5875 yarp::os::idl::WireReader reader(connection);
5876 if (!reader.readListHeader()) {
5877 reader.fail();
5878 return false;
5879 }
5880 return read(reader);
5881}
5882
5884{
5885 if (!writeTag(writer)) {
5886 return false;
5887 }
5888 if (!writeArgs(writer)) {
5889 return false;
5890 }
5891 return true;
5892}
5893
5895{
5896 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5897 return false;
5898 }
5899 return true;
5900}
5901
5903{
5904 if (!writer.writeI32(feature)) {
5905 return false;
5906 }
5907 return true;
5908}
5909
5911{
5912 if (!readTag(reader)) {
5913 return false;
5914 }
5915 if (!readArgs(reader)) {
5916 return false;
5917 }
5918 return true;
5919}
5920
5922{
5923 std::string tag = reader.readTag(s_tag_len);
5924 if (reader.isError()) {
5925 return false;
5926 }
5927 if (tag != s_tag) {
5928 reader.fail();
5929 return false;
5930 }
5931 return true;
5932}
5933
5935{
5936 if (reader.noMore()) {
5937 reader.fail();
5938 return false;
5939 }
5940 if (!reader.readI32(feature)) {
5941 reader.fail();
5942 return false;
5943 }
5944 if (!reader.noMore()) {
5945 reader.fail();
5946 return false;
5947 }
5948 return true;
5949}
5950
5952{
5953 yarp::os::idl::WireWriter writer(connection);
5954 return write(writer);
5955}
5956
5958{
5959 yarp::os::idl::WireReader reader(connection);
5960 return read(reader);
5961}
5962
5964{
5965 if (!writer.isNull()) {
5966 if (!writer.writeListHeader(s_reply_len)) {
5967 return false;
5968 }
5969 if (!writer.write(return_helper)) {
5970 return false;
5971 }
5972 }
5973 return true;
5974}
5975
5977{
5978 if (!reader.readListReturn()) {
5979 return false;
5980 }
5981 if (reader.noMore()) {
5982 reader.fail();
5983 return false;
5984 }
5985 if (!reader.read(return_helper)) {
5986 reader.fail();
5987 return false;
5988 }
5989 return true;
5990}
5991
5996
5997// setFeature2RPC helper class implementation
5998FrameGrabberMsgs_setFeature2RPC_helper::FrameGrabberMsgs_setFeature2RPC_helper(const std::int32_t feature, const double value1, const double value2) :
5999 cmd{feature, value1, value2}
6000{
6001}
6002
6004{
6005 return cmd.write(connection);
6006}
6007
6009{
6010 return reply.read(connection);
6011}
6012
6013FrameGrabberMsgs_setFeature2RPC_helper::Command::Command(const std::int32_t feature, const double value1, const double value2) :
6015 value1{value1},
6016 value2{value2}
6017{
6018}
6019
6021{
6022 yarp::os::idl::WireWriter writer(connection);
6023 if (!writer.writeListHeader(s_cmd_len)) {
6024 return false;
6025 }
6026 return write(writer);
6027}
6028
6030{
6031 yarp::os::idl::WireReader reader(connection);
6032 if (!reader.readListHeader()) {
6033 reader.fail();
6034 return false;
6035 }
6036 return read(reader);
6037}
6038
6040{
6041 if (!writeTag(writer)) {
6042 return false;
6043 }
6044 if (!writeArgs(writer)) {
6045 return false;
6046 }
6047 return true;
6048}
6049
6051{
6052 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6053 return false;
6054 }
6055 return true;
6056}
6057
6059{
6060 if (!writer.writeI32(feature)) {
6061 return false;
6062 }
6063 if (!writer.writeFloat64(value1)) {
6064 return false;
6065 }
6066 if (!writer.writeFloat64(value2)) {
6067 return false;
6068 }
6069 return true;
6070}
6071
6073{
6074 if (!readTag(reader)) {
6075 return false;
6076 }
6077 if (!readArgs(reader)) {
6078 return false;
6079 }
6080 return true;
6081}
6082
6084{
6085 std::string tag = reader.readTag(s_tag_len);
6086 if (reader.isError()) {
6087 return false;
6088 }
6089 if (tag != s_tag) {
6090 reader.fail();
6091 return false;
6092 }
6093 return true;
6094}
6095
6097{
6098 if (reader.noMore()) {
6099 reader.fail();
6100 return false;
6101 }
6102 if (!reader.readI32(feature)) {
6103 reader.fail();
6104 return false;
6105 }
6106 if (reader.noMore()) {
6107 reader.fail();
6108 return false;
6109 }
6110 if (!reader.readFloat64(value1)) {
6111 reader.fail();
6112 return false;
6113 }
6114 if (reader.noMore()) {
6115 reader.fail();
6116 return false;
6117 }
6118 if (!reader.readFloat64(value2)) {
6119 reader.fail();
6120 return false;
6121 }
6122 if (!reader.noMore()) {
6123 reader.fail();
6124 return false;
6125 }
6126 return true;
6127}
6128
6130{
6131 yarp::os::idl::WireWriter writer(connection);
6132 return write(writer);
6133}
6134
6136{
6137 yarp::os::idl::WireReader reader(connection);
6138 return read(reader);
6139}
6140
6142{
6143 if (!writer.isNull()) {
6144 if (!writer.write(return_helper)) {
6145 return false;
6146 }
6147 }
6148 return true;
6149}
6150
6152{
6153 if (reader.noMore()) {
6154 reader.fail();
6155 return false;
6156 }
6157 if (!reader.read(return_helper)) {
6158 reader.fail();
6159 return false;
6160 }
6161 return true;
6162}
6163
6168
6169// getFeature2RPC helper class implementation
6174
6176{
6177 return cmd.write(connection);
6178}
6179
6181{
6182 return reply.read(connection);
6183}
6184
6189
6191{
6192 yarp::os::idl::WireWriter writer(connection);
6193 if (!writer.writeListHeader(s_cmd_len)) {
6194 return false;
6195 }
6196 return write(writer);
6197}
6198
6200{
6201 yarp::os::idl::WireReader reader(connection);
6202 if (!reader.readListHeader()) {
6203 reader.fail();
6204 return false;
6205 }
6206 return read(reader);
6207}
6208
6210{
6211 if (!writeTag(writer)) {
6212 return false;
6213 }
6214 if (!writeArgs(writer)) {
6215 return false;
6216 }
6217 return true;
6218}
6219
6221{
6222 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6223 return false;
6224 }
6225 return true;
6226}
6227
6229{
6230 if (!writer.writeI32(feature)) {
6231 return false;
6232 }
6233 return true;
6234}
6235
6237{
6238 if (!readTag(reader)) {
6239 return false;
6240 }
6241 if (!readArgs(reader)) {
6242 return false;
6243 }
6244 return true;
6245}
6246
6248{
6249 std::string tag = reader.readTag(s_tag_len);
6250 if (reader.isError()) {
6251 return false;
6252 }
6253 if (tag != s_tag) {
6254 reader.fail();
6255 return false;
6256 }
6257 return true;
6258}
6259
6261{
6262 if (reader.noMore()) {
6263 reader.fail();
6264 return false;
6265 }
6266 if (!reader.readI32(feature)) {
6267 reader.fail();
6268 return false;
6269 }
6270 if (!reader.noMore()) {
6271 reader.fail();
6272 return false;
6273 }
6274 return true;
6275}
6276
6278{
6279 yarp::os::idl::WireWriter writer(connection);
6280 return write(writer);
6281}
6282
6284{
6285 yarp::os::idl::WireReader reader(connection);
6286 return read(reader);
6287}
6288
6290{
6291 if (!writer.isNull()) {
6292 if (!writer.writeListHeader(s_reply_len)) {
6293 return false;
6294 }
6295 if (!writer.write(return_helper)) {
6296 return false;
6297 }
6298 }
6299 return true;
6300}
6301
6303{
6304 if (!reader.readListReturn()) {
6305 return false;
6306 }
6307 if (reader.noMore()) {
6308 reader.fail();
6309 return false;
6310 }
6311 if (!reader.read(return_helper)) {
6312 reader.fail();
6313 return false;
6314 }
6315 return true;
6316}
6317
6322
6323// hasOnOffRPC helper class implementation
6328
6330{
6331 return cmd.write(connection);
6332}
6333
6335{
6336 return reply.read(connection);
6337}
6338
6343
6345{
6346 yarp::os::idl::WireWriter writer(connection);
6347 if (!writer.writeListHeader(s_cmd_len)) {
6348 return false;
6349 }
6350 return write(writer);
6351}
6352
6354{
6355 yarp::os::idl::WireReader reader(connection);
6356 if (!reader.readListHeader()) {
6357 reader.fail();
6358 return false;
6359 }
6360 return read(reader);
6361}
6362
6364{
6365 if (!writeTag(writer)) {
6366 return false;
6367 }
6368 if (!writeArgs(writer)) {
6369 return false;
6370 }
6371 return true;
6372}
6373
6375{
6376 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6377 return false;
6378 }
6379 return true;
6380}
6381
6383{
6384 if (!writer.writeI32(feature)) {
6385 return false;
6386 }
6387 return true;
6388}
6389
6391{
6392 if (!readTag(reader)) {
6393 return false;
6394 }
6395 if (!readArgs(reader)) {
6396 return false;
6397 }
6398 return true;
6399}
6400
6402{
6403 std::string tag = reader.readTag(s_tag_len);
6404 if (reader.isError()) {
6405 return false;
6406 }
6407 if (tag != s_tag) {
6408 reader.fail();
6409 return false;
6410 }
6411 return true;
6412}
6413
6415{
6416 if (reader.noMore()) {
6417 reader.fail();
6418 return false;
6419 }
6420 if (!reader.readI32(feature)) {
6421 reader.fail();
6422 return false;
6423 }
6424 if (!reader.noMore()) {
6425 reader.fail();
6426 return false;
6427 }
6428 return true;
6429}
6430
6432{
6433 yarp::os::idl::WireWriter writer(connection);
6434 return write(writer);
6435}
6436
6438{
6439 yarp::os::idl::WireReader reader(connection);
6440 return read(reader);
6441}
6442
6444{
6445 if (!writer.isNull()) {
6446 if (!writer.writeListHeader(s_reply_len)) {
6447 return false;
6448 }
6449 if (!writer.write(return_helper)) {
6450 return false;
6451 }
6452 }
6453 return true;
6454}
6455
6457{
6458 if (!reader.readListReturn()) {
6459 return false;
6460 }
6461 if (reader.noMore()) {
6462 reader.fail();
6463 return false;
6464 }
6465 if (!reader.read(return_helper)) {
6466 reader.fail();
6467 return false;
6468 }
6469 return true;
6470}
6471
6476
6477// setActiveRPC helper class implementation
6479 cmd{feature, onoff}
6480{
6481}
6482
6484{
6485 return cmd.write(connection);
6486}
6487
6489{
6490 return reply.read(connection);
6491}
6492
6495 onoff{onoff}
6496{
6497}
6498
6500{
6501 yarp::os::idl::WireWriter writer(connection);
6502 if (!writer.writeListHeader(s_cmd_len)) {
6503 return false;
6504 }
6505 return write(writer);
6506}
6507
6509{
6510 yarp::os::idl::WireReader reader(connection);
6511 if (!reader.readListHeader()) {
6512 reader.fail();
6513 return false;
6514 }
6515 return read(reader);
6516}
6517
6519{
6520 if (!writeTag(writer)) {
6521 return false;
6522 }
6523 if (!writeArgs(writer)) {
6524 return false;
6525 }
6526 return true;
6527}
6528
6530{
6531 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6532 return false;
6533 }
6534 return true;
6535}
6536
6538{
6539 if (!writer.writeI32(feature)) {
6540 return false;
6541 }
6542 if (!writer.writeBool(onoff)) {
6543 return false;
6544 }
6545 return true;
6546}
6547
6549{
6550 if (!readTag(reader)) {
6551 return false;
6552 }
6553 if (!readArgs(reader)) {
6554 return false;
6555 }
6556 return true;
6557}
6558
6560{
6561 std::string tag = reader.readTag(s_tag_len);
6562 if (reader.isError()) {
6563 return false;
6564 }
6565 if (tag != s_tag) {
6566 reader.fail();
6567 return false;
6568 }
6569 return true;
6570}
6571
6573{
6574 if (reader.noMore()) {
6575 reader.fail();
6576 return false;
6577 }
6578 if (!reader.readI32(feature)) {
6579 reader.fail();
6580 return false;
6581 }
6582 if (reader.noMore()) {
6583 reader.fail();
6584 return false;
6585 }
6586 if (!reader.readBool(onoff)) {
6587 reader.fail();
6588 return false;
6589 }
6590 if (!reader.noMore()) {
6591 reader.fail();
6592 return false;
6593 }
6594 return true;
6595}
6596
6598{
6599 yarp::os::idl::WireWriter writer(connection);
6600 return write(writer);
6601}
6602
6604{
6605 yarp::os::idl::WireReader reader(connection);
6606 return read(reader);
6607}
6608
6610{
6611 if (!writer.isNull()) {
6612 if (!writer.write(return_helper)) {
6613 return false;
6614 }
6615 }
6616 return true;
6617}
6618
6620{
6621 if (reader.noMore()) {
6622 reader.fail();
6623 return false;
6624 }
6625 if (!reader.read(return_helper)) {
6626 reader.fail();
6627 return false;
6628 }
6629 return true;
6630}
6631
6636
6637// getActiveRPC helper class implementation
6642
6644{
6645 return cmd.write(connection);
6646}
6647
6649{
6650 return reply.read(connection);
6651}
6652
6657
6659{
6660 yarp::os::idl::WireWriter writer(connection);
6661 if (!writer.writeListHeader(s_cmd_len)) {
6662 return false;
6663 }
6664 return write(writer);
6665}
6666
6668{
6669 yarp::os::idl::WireReader reader(connection);
6670 if (!reader.readListHeader()) {
6671 reader.fail();
6672 return false;
6673 }
6674 return read(reader);
6675}
6676
6678{
6679 if (!writeTag(writer)) {
6680 return false;
6681 }
6682 if (!writeArgs(writer)) {
6683 return false;
6684 }
6685 return true;
6686}
6687
6689{
6690 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6691 return false;
6692 }
6693 return true;
6694}
6695
6697{
6698 if (!writer.writeI32(feature)) {
6699 return false;
6700 }
6701 return true;
6702}
6703
6705{
6706 if (!readTag(reader)) {
6707 return false;
6708 }
6709 if (!readArgs(reader)) {
6710 return false;
6711 }
6712 return true;
6713}
6714
6716{
6717 std::string tag = reader.readTag(s_tag_len);
6718 if (reader.isError()) {
6719 return false;
6720 }
6721 if (tag != s_tag) {
6722 reader.fail();
6723 return false;
6724 }
6725 return true;
6726}
6727
6729{
6730 if (reader.noMore()) {
6731 reader.fail();
6732 return false;
6733 }
6734 if (!reader.readI32(feature)) {
6735 reader.fail();
6736 return false;
6737 }
6738 if (!reader.noMore()) {
6739 reader.fail();
6740 return false;
6741 }
6742 return true;
6743}
6744
6746{
6747 yarp::os::idl::WireWriter writer(connection);
6748 return write(writer);
6749}
6750
6752{
6753 yarp::os::idl::WireReader reader(connection);
6754 return read(reader);
6755}
6756
6758{
6759 if (!writer.isNull()) {
6760 if (!writer.writeListHeader(s_reply_len)) {
6761 return false;
6762 }
6763 if (!writer.write(return_helper)) {
6764 return false;
6765 }
6766 }
6767 return true;
6768}
6769
6771{
6772 if (!reader.readListReturn()) {
6773 return false;
6774 }
6775 if (reader.noMore()) {
6776 reader.fail();
6777 return false;
6778 }
6779 if (!reader.read(return_helper)) {
6780 reader.fail();
6781 return false;
6782 }
6783 return true;
6784}
6785
6790
6791// hasAutoRPC helper class implementation
6796
6798{
6799 return cmd.write(connection);
6800}
6801
6803{
6804 return reply.read(connection);
6805}
6806
6811
6813{
6814 yarp::os::idl::WireWriter writer(connection);
6815 if (!writer.writeListHeader(s_cmd_len)) {
6816 return false;
6817 }
6818 return write(writer);
6819}
6820
6822{
6823 yarp::os::idl::WireReader reader(connection);
6824 if (!reader.readListHeader()) {
6825 reader.fail();
6826 return false;
6827 }
6828 return read(reader);
6829}
6830
6832{
6833 if (!writeTag(writer)) {
6834 return false;
6835 }
6836 if (!writeArgs(writer)) {
6837 return false;
6838 }
6839 return true;
6840}
6841
6843{
6844 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6845 return false;
6846 }
6847 return true;
6848}
6849
6851{
6852 if (!writer.writeI32(feature)) {
6853 return false;
6854 }
6855 return true;
6856}
6857
6859{
6860 if (!readTag(reader)) {
6861 return false;
6862 }
6863 if (!readArgs(reader)) {
6864 return false;
6865 }
6866 return true;
6867}
6868
6870{
6871 std::string tag = reader.readTag(s_tag_len);
6872 if (reader.isError()) {
6873 return false;
6874 }
6875 if (tag != s_tag) {
6876 reader.fail();
6877 return false;
6878 }
6879 return true;
6880}
6881
6883{
6884 if (reader.noMore()) {
6885 reader.fail();
6886 return false;
6887 }
6888 if (!reader.readI32(feature)) {
6889 reader.fail();
6890 return false;
6891 }
6892 if (!reader.noMore()) {
6893 reader.fail();
6894 return false;
6895 }
6896 return true;
6897}
6898
6900{
6901 yarp::os::idl::WireWriter writer(connection);
6902 return write(writer);
6903}
6904
6906{
6907 yarp::os::idl::WireReader reader(connection);
6908 return read(reader);
6909}
6910
6912{
6913 if (!writer.isNull()) {
6914 if (!writer.writeListHeader(s_reply_len)) {
6915 return false;
6916 }
6917 if (!writer.write(return_helper)) {
6918 return false;
6919 }
6920 }
6921 return true;
6922}
6923
6925{
6926 if (!reader.readListReturn()) {
6927 return false;
6928 }
6929 if (reader.noMore()) {
6930 reader.fail();
6931 return false;
6932 }
6933 if (!reader.read(return_helper)) {
6934 reader.fail();
6935 return false;
6936 }
6937 return true;
6938}
6939
6944
6945// hasManualRPC helper class implementation
6950
6952{
6953 return cmd.write(connection);
6954}
6955
6957{
6958 return reply.read(connection);
6959}
6960
6965
6967{
6968 yarp::os::idl::WireWriter writer(connection);
6969 if (!writer.writeListHeader(s_cmd_len)) {
6970 return false;
6971 }
6972 return write(writer);
6973}
6974
6976{
6977 yarp::os::idl::WireReader reader(connection);
6978 if (!reader.readListHeader()) {
6979 reader.fail();
6980 return false;
6981 }
6982 return read(reader);
6983}
6984
6986{
6987 if (!writeTag(writer)) {
6988 return false;
6989 }
6990 if (!writeArgs(writer)) {
6991 return false;
6992 }
6993 return true;
6994}
6995
6997{
6998 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6999 return false;
7000 }
7001 return true;
7002}
7003
7005{
7006 if (!writer.writeI32(feature)) {
7007 return false;
7008 }
7009 return true;
7010}
7011
7013{
7014 if (!readTag(reader)) {
7015 return false;
7016 }
7017 if (!readArgs(reader)) {
7018 return false;
7019 }
7020 return true;
7021}
7022
7024{
7025 std::string tag = reader.readTag(s_tag_len);
7026 if (reader.isError()) {
7027 return false;
7028 }
7029 if (tag != s_tag) {
7030 reader.fail();
7031 return false;
7032 }
7033 return true;
7034}
7035
7037{
7038 if (reader.noMore()) {
7039 reader.fail();
7040 return false;
7041 }
7042 if (!reader.readI32(feature)) {
7043 reader.fail();
7044 return false;
7045 }
7046 if (!reader.noMore()) {
7047 reader.fail();
7048 return false;
7049 }
7050 return true;
7051}
7052
7054{
7055 yarp::os::idl::WireWriter writer(connection);
7056 return write(writer);
7057}
7058
7060{
7061 yarp::os::idl::WireReader reader(connection);
7062 return read(reader);
7063}
7064
7066{
7067 if (!writer.isNull()) {
7068 if (!writer.writeListHeader(s_reply_len)) {
7069 return false;
7070 }
7071 if (!writer.write(return_helper)) {
7072 return false;
7073 }
7074 }
7075 return true;
7076}
7077
7079{
7080 if (!reader.readListReturn()) {
7081 return false;
7082 }
7083 if (reader.noMore()) {
7084 reader.fail();
7085 return false;
7086 }
7087 if (!reader.read(return_helper)) {
7088 reader.fail();
7089 return false;
7090 }
7091 return true;
7092}
7093
7098
7099// hasOnePushRPC helper class implementation
7104
7106{
7107 return cmd.write(connection);
7108}
7109
7111{
7112 return reply.read(connection);
7113}
7114
7119
7121{
7122 yarp::os::idl::WireWriter writer(connection);
7123 if (!writer.writeListHeader(s_cmd_len)) {
7124 return false;
7125 }
7126 return write(writer);
7127}
7128
7130{
7131 yarp::os::idl::WireReader reader(connection);
7132 if (!reader.readListHeader()) {
7133 reader.fail();
7134 return false;
7135 }
7136 return read(reader);
7137}
7138
7140{
7141 if (!writeTag(writer)) {
7142 return false;
7143 }
7144 if (!writeArgs(writer)) {
7145 return false;
7146 }
7147 return true;
7148}
7149
7151{
7152 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7153 return false;
7154 }
7155 return true;
7156}
7157
7159{
7160 if (!writer.writeI32(feature)) {
7161 return false;
7162 }
7163 return true;
7164}
7165
7167{
7168 if (!readTag(reader)) {
7169 return false;
7170 }
7171 if (!readArgs(reader)) {
7172 return false;
7173 }
7174 return true;
7175}
7176
7178{
7179 std::string tag = reader.readTag(s_tag_len);
7180 if (reader.isError()) {
7181 return false;
7182 }
7183 if (tag != s_tag) {
7184 reader.fail();
7185 return false;
7186 }
7187 return true;
7188}
7189
7191{
7192 if (reader.noMore()) {
7193 reader.fail();
7194 return false;
7195 }
7196 if (!reader.readI32(feature)) {
7197 reader.fail();
7198 return false;
7199 }
7200 if (!reader.noMore()) {
7201 reader.fail();
7202 return false;
7203 }
7204 return true;
7205}
7206
7208{
7209 yarp::os::idl::WireWriter writer(connection);
7210 return write(writer);
7211}
7212
7214{
7215 yarp::os::idl::WireReader reader(connection);
7216 return read(reader);
7217}
7218
7220{
7221 if (!writer.isNull()) {
7222 if (!writer.writeListHeader(s_reply_len)) {
7223 return false;
7224 }
7225 if (!writer.write(return_helper)) {
7226 return false;
7227 }
7228 }
7229 return true;
7230}
7231
7233{
7234 if (!reader.readListReturn()) {
7235 return false;
7236 }
7237 if (reader.noMore()) {
7238 reader.fail();
7239 return false;
7240 }
7241 if (!reader.read(return_helper)) {
7242 reader.fail();
7243 return false;
7244 }
7245 return true;
7246}
7247
7252
7253// setModeRPC helper class implementation
7258
7260{
7261 return cmd.write(connection);
7262}
7263
7265{
7266 return reply.read(connection);
7267}
7268
7274
7276{
7277 yarp::os::idl::WireWriter writer(connection);
7278 if (!writer.writeListHeader(s_cmd_len)) {
7279 return false;
7280 }
7281 return write(writer);
7282}
7283
7285{
7286 yarp::os::idl::WireReader reader(connection);
7287 if (!reader.readListHeader()) {
7288 reader.fail();
7289 return false;
7290 }
7291 return read(reader);
7292}
7293
7295{
7296 if (!writeTag(writer)) {
7297 return false;
7298 }
7299 if (!writeArgs(writer)) {
7300 return false;
7301 }
7302 return true;
7303}
7304
7306{
7307 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7308 return false;
7309 }
7310 return true;
7311}
7312
7314{
7315 if (!writer.writeI32(feature)) {
7316 return false;
7317 }
7318 if (!writer.writeI32(static_cast<int32_t>(mode))) {
7319 return false;
7320 }
7321 return true;
7322}
7323
7325{
7326 if (!readTag(reader)) {
7327 return false;
7328 }
7329 if (!readArgs(reader)) {
7330 return false;
7331 }
7332 return true;
7333}
7334
7336{
7337 std::string tag = reader.readTag(s_tag_len);
7338 if (reader.isError()) {
7339 return false;
7340 }
7341 if (tag != s_tag) {
7342 reader.fail();
7343 return false;
7344 }
7345 return true;
7346}
7347
7349{
7350 if (reader.noMore()) {
7351 reader.fail();
7352 return false;
7353 }
7354 if (!reader.readI32(feature)) {
7355 reader.fail();
7356 return false;
7357 }
7358 if (reader.noMore()) {
7359 reader.fail();
7360 return false;
7361 }
7362 int32_t _ecast;
7363 if (!reader.readI32(_ecast)) {
7364 reader.fail();
7365 return false;
7366 }
7367 mode = static_cast<yarp::dev::FeatureMode>(_ecast);
7368 if (!reader.noMore()) {
7369 reader.fail();
7370 return false;
7371 }
7372 return true;
7373}
7374
7376{
7377 yarp::os::idl::WireWriter writer(connection);
7378 return write(writer);
7379}
7380
7382{
7383 yarp::os::idl::WireReader reader(connection);
7384 return read(reader);
7385}
7386
7388{
7389 if (!writer.isNull()) {
7390 if (!writer.write(return_helper)) {
7391 return false;
7392 }
7393 }
7394 return true;
7395}
7396
7398{
7399 if (reader.noMore()) {
7400 reader.fail();
7401 return false;
7402 }
7403 if (!reader.read(return_helper)) {
7404 reader.fail();
7405 return false;
7406 }
7407 return true;
7408}
7409
7414
7415// getModeRPC helper class implementation
7420
7422{
7423 return cmd.write(connection);
7424}
7425
7427{
7428 return reply.read(connection);
7429}
7430
7435
7437{
7438 yarp::os::idl::WireWriter writer(connection);
7439 if (!writer.writeListHeader(s_cmd_len)) {
7440 return false;
7441 }
7442 return write(writer);
7443}
7444
7446{
7447 yarp::os::idl::WireReader reader(connection);
7448 if (!reader.readListHeader()) {
7449 reader.fail();
7450 return false;
7451 }
7452 return read(reader);
7453}
7454
7456{
7457 if (!writeTag(writer)) {
7458 return false;
7459 }
7460 if (!writeArgs(writer)) {
7461 return false;
7462 }
7463 return true;
7464}
7465
7467{
7468 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7469 return false;
7470 }
7471 return true;
7472}
7473
7475{
7476 if (!writer.writeI32(feature)) {
7477 return false;
7478 }
7479 return true;
7480}
7481
7483{
7484 if (!readTag(reader)) {
7485 return false;
7486 }
7487 if (!readArgs(reader)) {
7488 return false;
7489 }
7490 return true;
7491}
7492
7494{
7495 std::string tag = reader.readTag(s_tag_len);
7496 if (reader.isError()) {
7497 return false;
7498 }
7499 if (tag != s_tag) {
7500 reader.fail();
7501 return false;
7502 }
7503 return true;
7504}
7505
7507{
7508 if (reader.noMore()) {
7509 reader.fail();
7510 return false;
7511 }
7512 if (!reader.readI32(feature)) {
7513 reader.fail();
7514 return false;
7515 }
7516 if (!reader.noMore()) {
7517 reader.fail();
7518 return false;
7519 }
7520 return true;
7521}
7522
7524{
7525 yarp::os::idl::WireWriter writer(connection);
7526 return write(writer);
7527}
7528
7530{
7531 yarp::os::idl::WireReader reader(connection);
7532 return read(reader);
7533}
7534
7536{
7537 if (!writer.isNull()) {
7538 if (!writer.writeListHeader(s_reply_len)) {
7539 return false;
7540 }
7541 if (!writer.write(return_helper)) {
7542 return false;
7543 }
7544 }
7545 return true;
7546}
7547
7549{
7550 if (!reader.readListReturn()) {
7551 return false;
7552 }
7553 if (reader.noMore()) {
7554 reader.fail();
7555 return false;
7556 }
7557 if (!reader.read(return_helper)) {
7558 reader.fail();
7559 return false;
7560 }
7561 return true;
7562}
7563
7568
7569// setOnePushRPC helper class implementation
7574
7576{
7577 return cmd.write(connection);
7578}
7579
7581{
7582 return reply.read(connection);
7583}
7584
7589
7591{
7592 yarp::os::idl::WireWriter writer(connection);
7593 if (!writer.writeListHeader(s_cmd_len)) {
7594 return false;
7595 }
7596 return write(writer);
7597}
7598
7600{
7601 yarp::os::idl::WireReader reader(connection);
7602 if (!reader.readListHeader()) {
7603 reader.fail();
7604 return false;
7605 }
7606 return read(reader);
7607}
7608
7610{
7611 if (!writeTag(writer)) {
7612 return false;
7613 }
7614 if (!writeArgs(writer)) {
7615 return false;
7616 }
7617 return true;
7618}
7619
7621{
7622 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7623 return false;
7624 }
7625 return true;
7626}
7627
7629{
7630 if (!writer.writeI32(feature)) {
7631 return false;
7632 }
7633 return true;
7634}
7635
7637{
7638 if (!readTag(reader)) {
7639 return false;
7640 }
7641 if (!readArgs(reader)) {
7642 return false;
7643 }
7644 return true;
7645}
7646
7648{
7649 std::string tag = reader.readTag(s_tag_len);
7650 if (reader.isError()) {
7651 return false;
7652 }
7653 if (tag != s_tag) {
7654 reader.fail();
7655 return false;
7656 }
7657 return true;
7658}
7659
7661{
7662 if (reader.noMore()) {
7663 reader.fail();
7664 return false;
7665 }
7666 if (!reader.readI32(feature)) {
7667 reader.fail();
7668 return false;
7669 }
7670 if (!reader.noMore()) {
7671 reader.fail();
7672 return false;
7673 }
7674 return true;
7675}
7676
7678{
7679 yarp::os::idl::WireWriter writer(connection);
7680 return write(writer);
7681}
7682
7684{
7685 yarp::os::idl::WireReader reader(connection);
7686 return read(reader);
7687}
7688
7690{
7691 if (!writer.isNull()) {
7692 if (!writer.write(return_helper)) {
7693 return false;
7694 }
7695 }
7696 return true;
7697}
7698
7700{
7701 if (reader.noMore()) {
7702 reader.fail();
7703 return false;
7704 }
7705 if (!reader.read(return_helper)) {
7706 reader.fail();
7707 return false;
7708 }
7709 return true;
7710}
7711
7716
7717// getVideoModeMaskDC1394RPC helper class implementation
7719{
7720 return cmd.write(connection);
7721}
7722
7727
7729{
7730 yarp::os::idl::WireWriter writer(connection);
7731 if (!writer.writeListHeader(s_cmd_len)) {
7732 return false;
7733 }
7734 return write(writer);
7735}
7736
7738{
7739 yarp::os::idl::WireReader reader(connection);
7740 if (!reader.readListHeader()) {
7741 reader.fail();
7742 return false;
7743 }
7744 return read(reader);
7745}
7746
7748{
7749 if (!writeTag(writer)) {
7750 return false;
7751 }
7752 if (!writeArgs(writer)) {
7753 return false;
7754 }
7755 return true;
7756}
7757
7759{
7760 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7761 return false;
7762 }
7763 return true;
7764}
7765
7767{
7768 return true;
7769}
7770
7772{
7773 if (!readTag(reader)) {
7774 return false;
7775 }
7776 if (!readArgs(reader)) {
7777 return false;
7778 }
7779 return true;
7780}
7781
7783{
7784 std::string tag = reader.readTag(s_tag_len);
7785 if (reader.isError()) {
7786 return false;
7787 }
7788 if (tag != s_tag) {
7789 reader.fail();
7790 return false;
7791 }
7792 return true;
7793}
7794
7796{
7797 if (!reader.noMore()) {
7798 reader.fail();
7799 return false;
7800 }
7801 return true;
7802}
7803
7805{
7806 yarp::os::idl::WireWriter writer(connection);
7807 return write(writer);
7808}
7809
7815
7817{
7818 if (!writer.isNull()) {
7819 if (!writer.writeListHeader(s_reply_len)) {
7820 return false;
7821 }
7822 if (!writer.write(return_helper)) {
7823 return false;
7824 }
7825 }
7826 return true;
7827}
7828
7830{
7831 if (!reader.readListReturn()) {
7832 return false;
7833 }
7834 if (reader.noMore()) {
7835 reader.fail();
7836 return false;
7837 }
7838 if (!reader.read(return_helper)) {
7839 reader.fail();
7840 return false;
7841 }
7842 return true;
7843}
7844
7849
7850// getVideoModeDC1394RPC helper class implementation
7852{
7853 return cmd.write(connection);
7854}
7855
7860
7862{
7863 yarp::os::idl::WireWriter writer(connection);
7864 if (!writer.writeListHeader(s_cmd_len)) {
7865 return false;
7866 }
7867 return write(writer);
7868}
7869
7871{
7872 yarp::os::idl::WireReader reader(connection);
7873 if (!reader.readListHeader()) {
7874 reader.fail();
7875 return false;
7876 }
7877 return read(reader);
7878}
7879
7881{
7882 if (!writeTag(writer)) {
7883 return false;
7884 }
7885 if (!writeArgs(writer)) {
7886 return false;
7887 }
7888 return true;
7889}
7890
7892{
7893 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7894 return false;
7895 }
7896 return true;
7897}
7898
7900{
7901 return true;
7902}
7903
7905{
7906 if (!readTag(reader)) {
7907 return false;
7908 }
7909 if (!readArgs(reader)) {
7910 return false;
7911 }
7912 return true;
7913}
7914
7916{
7917 std::string tag = reader.readTag(s_tag_len);
7918 if (reader.isError()) {
7919 return false;
7920 }
7921 if (tag != s_tag) {
7922 reader.fail();
7923 return false;
7924 }
7925 return true;
7926}
7927
7929{
7930 if (!reader.noMore()) {
7931 reader.fail();
7932 return false;
7933 }
7934 return true;
7935}
7936
7938{
7939 yarp::os::idl::WireWriter writer(connection);
7940 return write(writer);
7941}
7942
7944{
7945 yarp::os::idl::WireReader reader(connection);
7946 return read(reader);
7947}
7948
7950{
7951 if (!writer.isNull()) {
7952 if (!writer.writeListHeader(s_reply_len)) {
7953 return false;
7954 }
7955 if (!writer.write(return_helper)) {
7956 return false;
7957 }
7958 }
7959 return true;
7960}
7961
7963{
7964 if (!reader.readListReturn()) {
7965 return false;
7966 }
7967 if (reader.noMore()) {
7968 reader.fail();
7969 return false;
7970 }
7971 if (!reader.read(return_helper)) {
7972 reader.fail();
7973 return false;
7974 }
7975 return true;
7976}
7977
7982
7983// setVideoModeDC1394RPC helper class implementation
7988
7990{
7991 return cmd.write(connection);
7992}
7993
7998
8000 videomode{videomode}
8001{
8002}
8003
8005{
8006 yarp::os::idl::WireWriter writer(connection);
8007 if (!writer.writeListHeader(s_cmd_len)) {
8008 return false;
8009 }
8010 return write(writer);
8011}
8012
8014{
8015 yarp::os::idl::WireReader reader(connection);
8016 if (!reader.readListHeader()) {
8017 reader.fail();
8018 return false;
8019 }
8020 return read(reader);
8021}
8022
8024{
8025 if (!writeTag(writer)) {
8026 return false;
8027 }
8028 if (!writeArgs(writer)) {
8029 return false;
8030 }
8031 return true;
8032}
8033
8035{
8036 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8037 return false;
8038 }
8039 return true;
8040}
8041
8043{
8044 if (!writer.writeI32(videomode)) {
8045 return false;
8046 }
8047 return true;
8048}
8049
8051{
8052 if (!readTag(reader)) {
8053 return false;
8054 }
8055 if (!readArgs(reader)) {
8056 return false;
8057 }
8058 return true;
8059}
8060
8062{
8063 std::string tag = reader.readTag(s_tag_len);
8064 if (reader.isError()) {
8065 return false;
8066 }
8067 if (tag != s_tag) {
8068 reader.fail();
8069 return false;
8070 }
8071 return true;
8072}
8073
8075{
8076 if (reader.noMore()) {
8077 reader.fail();
8078 return false;
8079 }
8080 if (!reader.readI32(videomode)) {
8081 reader.fail();
8082 return false;
8083 }
8084 if (!reader.noMore()) {
8085 reader.fail();
8086 return false;
8087 }
8088 return true;
8089}
8090
8092{
8093 yarp::os::idl::WireWriter writer(connection);
8094 return write(writer);
8095}
8096
8098{
8099 yarp::os::idl::WireReader reader(connection);
8100 return read(reader);
8101}
8102
8104{
8105 if (!writer.isNull()) {
8106 if (!writer.write(return_helper)) {
8107 return false;
8108 }
8109 }
8110 return true;
8111}
8112
8114{
8115 if (reader.noMore()) {
8116 reader.fail();
8117 return false;
8118 }
8119 if (!reader.read(return_helper)) {
8120 reader.fail();
8121 return false;
8122 }
8123 return true;
8124}
8125
8130
8131// getFPSMaskDC1394RPC helper class implementation
8133{
8134 return cmd.write(connection);
8135}
8136
8141
8143{
8144 yarp::os::idl::WireWriter writer(connection);
8145 if (!writer.writeListHeader(s_cmd_len)) {
8146 return false;
8147 }
8148 return write(writer);
8149}
8150
8152{
8153 yarp::os::idl::WireReader reader(connection);
8154 if (!reader.readListHeader()) {
8155 reader.fail();
8156 return false;
8157 }
8158 return read(reader);
8159}
8160
8162{
8163 if (!writeTag(writer)) {
8164 return false;
8165 }
8166 if (!writeArgs(writer)) {
8167 return false;
8168 }
8169 return true;
8170}
8171
8173{
8174 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8175 return false;
8176 }
8177 return true;
8178}
8179
8181{
8182 return true;
8183}
8184
8186{
8187 if (!readTag(reader)) {
8188 return false;
8189 }
8190 if (!readArgs(reader)) {
8191 return false;
8192 }
8193 return true;
8194}
8195
8197{
8198 std::string tag = reader.readTag(s_tag_len);
8199 if (reader.isError()) {
8200 return false;
8201 }
8202 if (tag != s_tag) {
8203 reader.fail();
8204 return false;
8205 }
8206 return true;
8207}
8208
8210{
8211 if (!reader.noMore()) {
8212 reader.fail();
8213 return false;
8214 }
8215 return true;
8216}
8217
8219{
8220 yarp::os::idl::WireWriter writer(connection);
8221 return write(writer);
8222}
8223
8225{
8226 yarp::os::idl::WireReader reader(connection);
8227 return read(reader);
8228}
8229
8231{
8232 if (!writer.isNull()) {
8233 if (!writer.writeListHeader(s_reply_len)) {
8234 return false;
8235 }
8236 if (!writer.write(return_helper)) {
8237 return false;
8238 }
8239 }
8240 return true;
8241}
8242
8244{
8245 if (!reader.readListReturn()) {
8246 return false;
8247 }
8248 if (reader.noMore()) {
8249 reader.fail();
8250 return false;
8251 }
8252 if (!reader.read(return_helper)) {
8253 reader.fail();
8254 return false;
8255 }
8256 return true;
8257}
8258
8263
8264// getFPSDC1394RPC helper class implementation
8266{
8267 return cmd.write(connection);
8268}
8269
8271{
8272 return reply.read(connection);
8273}
8274
8276{
8277 yarp::os::idl::WireWriter writer(connection);
8278 if (!writer.writeListHeader(s_cmd_len)) {
8279 return false;
8280 }
8281 return write(writer);
8282}
8283
8285{
8286 yarp::os::idl::WireReader reader(connection);
8287 if (!reader.readListHeader()) {
8288 reader.fail();
8289 return false;
8290 }
8291 return read(reader);
8292}
8293
8295{
8296 if (!writeTag(writer)) {
8297 return false;
8298 }
8299 if (!writeArgs(writer)) {
8300 return false;
8301 }
8302 return true;
8303}
8304
8306{
8307 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8308 return false;
8309 }
8310 return true;
8311}
8312
8314{
8315 return true;
8316}
8317
8319{
8320 if (!readTag(reader)) {
8321 return false;
8322 }
8323 if (!readArgs(reader)) {
8324 return false;
8325 }
8326 return true;
8327}
8328
8330{
8331 std::string tag = reader.readTag(s_tag_len);
8332 if (reader.isError()) {
8333 return false;
8334 }
8335 if (tag != s_tag) {
8336 reader.fail();
8337 return false;
8338 }
8339 return true;
8340}
8341
8343{
8344 if (!reader.noMore()) {
8345 reader.fail();
8346 return false;
8347 }
8348 return true;
8349}
8350
8352{
8353 yarp::os::idl::WireWriter writer(connection);
8354 return write(writer);
8355}
8356
8358{
8359 yarp::os::idl::WireReader reader(connection);
8360 return read(reader);
8361}
8362
8364{
8365 if (!writer.isNull()) {
8366 if (!writer.writeListHeader(s_reply_len)) {
8367 return false;
8368 }
8369 if (!writer.write(return_helper)) {
8370 return false;
8371 }
8372 }
8373 return true;
8374}
8375
8377{
8378 if (!reader.readListReturn()) {
8379 return false;
8380 }
8381 if (reader.noMore()) {
8382 reader.fail();
8383 return false;
8384 }
8385 if (!reader.read(return_helper)) {
8386 reader.fail();
8387 return false;
8388 }
8389 return true;
8390}
8391
8396
8397// setFPSDC1394RPC helper class implementation
8402
8404{
8405 return cmd.write(connection);
8406}
8407
8409{
8410 return reply.read(connection);
8411}
8412
8417
8419{
8420 yarp::os::idl::WireWriter writer(connection);
8421 if (!writer.writeListHeader(s_cmd_len)) {
8422 return false;
8423 }
8424 return write(writer);
8425}
8426
8428{
8429 yarp::os::idl::WireReader reader(connection);
8430 if (!reader.readListHeader()) {
8431 reader.fail();
8432 return false;
8433 }
8434 return read(reader);
8435}
8436
8438{
8439 if (!writeTag(writer)) {
8440 return false;
8441 }
8442 if (!writeArgs(writer)) {
8443 return false;
8444 }
8445 return true;
8446}
8447
8449{
8450 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8451 return false;
8452 }
8453 return true;
8454}
8455
8457{
8458 if (!writer.writeI32(fps)) {
8459 return false;
8460 }
8461 return true;
8462}
8463
8465{
8466 if (!readTag(reader)) {
8467 return false;
8468 }
8469 if (!readArgs(reader)) {
8470 return false;
8471 }
8472 return true;
8473}
8474
8476{
8477 std::string tag = reader.readTag(s_tag_len);
8478 if (reader.isError()) {
8479 return false;
8480 }
8481 if (tag != s_tag) {
8482 reader.fail();
8483 return false;
8484 }
8485 return true;
8486}
8487
8489{
8490 if (reader.noMore()) {
8491 reader.fail();
8492 return false;
8493 }
8494 if (!reader.readI32(fps)) {
8495 reader.fail();
8496 return false;
8497 }
8498 if (!reader.noMore()) {
8499 reader.fail();
8500 return false;
8501 }
8502 return true;
8503}
8504
8506{
8507 yarp::os::idl::WireWriter writer(connection);
8508 return write(writer);
8509}
8510
8512{
8513 yarp::os::idl::WireReader reader(connection);
8514 return read(reader);
8515}
8516
8518{
8519 if (!writer.isNull()) {
8520 if (!writer.write(return_helper)) {
8521 return false;
8522 }
8523 }
8524 return true;
8525}
8526
8528{
8529 if (reader.noMore()) {
8530 reader.fail();
8531 return false;
8532 }
8533 if (!reader.read(return_helper)) {
8534 reader.fail();
8535 return false;
8536 }
8537 return true;
8538}
8539
8544
8545// getISOSpeedDC1394RPC helper class implementation
8547{
8548 return cmd.write(connection);
8549}
8550
8555
8557{
8558 yarp::os::idl::WireWriter writer(connection);
8559 if (!writer.writeListHeader(s_cmd_len)) {
8560 return false;
8561 }
8562 return write(writer);
8563}
8564
8566{
8567 yarp::os::idl::WireReader reader(connection);
8568 if (!reader.readListHeader()) {
8569 reader.fail();
8570 return false;
8571 }
8572 return read(reader);
8573}
8574
8576{
8577 if (!writeTag(writer)) {
8578 return false;
8579 }
8580 if (!writeArgs(writer)) {
8581 return false;
8582 }
8583 return true;
8584}
8585
8587{
8588 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8589 return false;
8590 }
8591 return true;
8592}
8593
8595{
8596 return true;
8597}
8598
8600{
8601 if (!readTag(reader)) {
8602 return false;
8603 }
8604 if (!readArgs(reader)) {
8605 return false;
8606 }
8607 return true;
8608}
8609
8611{
8612 std::string tag = reader.readTag(s_tag_len);
8613 if (reader.isError()) {
8614 return false;
8615 }
8616 if (tag != s_tag) {
8617 reader.fail();
8618 return false;
8619 }
8620 return true;
8621}
8622
8624{
8625 if (!reader.noMore()) {
8626 reader.fail();
8627 return false;
8628 }
8629 return true;
8630}
8631
8633{
8634 yarp::os::idl::WireWriter writer(connection);
8635 return write(writer);
8636}
8637
8639{
8640 yarp::os::idl::WireReader reader(connection);
8641 return read(reader);
8642}
8643
8645{
8646 if (!writer.isNull()) {
8647 if (!writer.writeListHeader(s_reply_len)) {
8648 return false;
8649 }
8650 if (!writer.write(return_helper)) {
8651 return false;
8652 }
8653 }
8654 return true;
8655}
8656
8658{
8659 if (!reader.readListReturn()) {
8660 return false;
8661 }
8662 if (reader.noMore()) {
8663 reader.fail();
8664 return false;
8665 }
8666 if (!reader.read(return_helper)) {
8667 reader.fail();
8668 return false;
8669 }
8670 return true;
8671}
8672
8677
8678// setISOSpeedDC1394RPC helper class implementation
8683
8685{
8686 return cmd.write(connection);
8687}
8688
8693
8695 speed{speed}
8696{
8697}
8698
8700{
8701 yarp::os::idl::WireWriter writer(connection);
8702 if (!writer.writeListHeader(s_cmd_len)) {
8703 return false;
8704 }
8705 return write(writer);
8706}
8707
8709{
8710 yarp::os::idl::WireReader reader(connection);
8711 if (!reader.readListHeader()) {
8712 reader.fail();
8713 return false;
8714 }
8715 return read(reader);
8716}
8717
8719{
8720 if (!writeTag(writer)) {
8721 return false;
8722 }
8723 if (!writeArgs(writer)) {
8724 return false;
8725 }
8726 return true;
8727}
8728
8730{
8731 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8732 return false;
8733 }
8734 return true;
8735}
8736
8738{
8739 if (!writer.writeI32(speed)) {
8740 return false;
8741 }
8742 return true;
8743}
8744
8746{
8747 if (!readTag(reader)) {
8748 return false;
8749 }
8750 if (!readArgs(reader)) {
8751 return false;
8752 }
8753 return true;
8754}
8755
8757{
8758 std::string tag = reader.readTag(s_tag_len);
8759 if (reader.isError()) {
8760 return false;
8761 }
8762 if (tag != s_tag) {
8763 reader.fail();
8764 return false;
8765 }
8766 return true;
8767}
8768
8770{
8771 if (reader.noMore()) {
8772 reader.fail();
8773 return false;
8774 }
8775 if (!reader.readI32(speed)) {
8776 reader.fail();
8777 return false;
8778 }
8779 if (!reader.noMore()) {
8780 reader.fail();
8781 return false;
8782 }
8783 return true;
8784}
8785
8787{
8788 yarp::os::idl::WireWriter writer(connection);
8789 return write(writer);
8790}
8791
8793{
8794 yarp::os::idl::WireReader reader(connection);
8795 return read(reader);
8796}
8797
8799{
8800 if (!writer.isNull()) {
8801 if (!writer.write(return_helper)) {
8802 return false;
8803 }
8804 }
8805 return true;
8806}
8807
8809{
8810 if (reader.noMore()) {
8811 reader.fail();
8812 return false;
8813 }
8814 if (!reader.read(return_helper)) {
8815 reader.fail();
8816 return false;
8817 }
8818 return true;
8819}
8820
8825
8826// getColorCodingMaskDC1394RPC helper class implementation
8831
8833{
8834 return cmd.write(connection);
8835}
8836
8841
8843 videomode{videomode}
8844{
8845}
8846
8848{
8849 yarp::os::idl::WireWriter writer(connection);
8850 if (!writer.writeListHeader(s_cmd_len)) {
8851 return false;
8852 }
8853 return write(writer);
8854}
8855
8857{
8858 yarp::os::idl::WireReader reader(connection);
8859 if (!reader.readListHeader()) {
8860 reader.fail();
8861 return false;
8862 }
8863 return read(reader);
8864}
8865
8867{
8868 if (!writeTag(writer)) {
8869 return false;
8870 }
8871 if (!writeArgs(writer)) {
8872 return false;
8873 }
8874 return true;
8875}
8876
8878{
8879 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8880 return false;
8881 }
8882 return true;
8883}
8884
8886{
8887 if (!writer.writeI32(videomode)) {
8888 return false;
8889 }
8890 return true;
8891}
8892
8894{
8895 if (!readTag(reader)) {
8896 return false;
8897 }
8898 if (!readArgs(reader)) {
8899 return false;
8900 }
8901 return true;
8902}
8903
8905{
8906 std::string tag = reader.readTag(s_tag_len);
8907 if (reader.isError()) {
8908 return false;
8909 }
8910 if (tag != s_tag) {
8911 reader.fail();
8912 return false;
8913 }
8914 return true;
8915}
8916
8918{
8919 if (reader.noMore()) {
8920 reader.fail();
8921 return false;
8922 }
8923 if (!reader.readI32(videomode)) {
8924 reader.fail();
8925 return false;
8926 }
8927 if (!reader.noMore()) {
8928 reader.fail();
8929 return false;
8930 }
8931 return true;
8932}
8933
8935{
8936 yarp::os::idl::WireWriter writer(connection);
8937 return write(writer);
8938}
8939
8945
8947{
8948 if (!writer.isNull()) {
8949 if (!writer.writeListHeader(s_reply_len)) {
8950 return false;
8951 }
8952 if (!writer.write(return_helper)) {
8953 return false;
8954 }
8955 }
8956 return true;
8957}
8958
8960{
8961 if (!reader.readListReturn()) {
8962 return false;
8963 }
8964 if (reader.noMore()) {
8965 reader.fail();
8966 return false;
8967 }
8968 if (!reader.read(return_helper)) {
8969 reader.fail();
8970 return false;
8971 }
8972 return true;
8973}
8974
8979
8980// getColorCodingDC1394RPC helper class implementation
8982{
8983 return cmd.write(connection);
8984}
8985
8990
8992{
8993 yarp::os::idl::WireWriter writer(connection);
8994 if (!writer.writeListHeader(s_cmd_len)) {
8995 return false;
8996 }
8997 return write(writer);
8998}
8999
9001{
9002 yarp::os::idl::WireReader reader(connection);
9003 if (!reader.readListHeader()) {
9004 reader.fail();
9005 return false;
9006 }
9007 return read(reader);
9008}
9009
9011{
9012 if (!writeTag(writer)) {
9013 return false;
9014 }
9015 if (!writeArgs(writer)) {
9016 return false;
9017 }
9018 return true;
9019}
9020
9022{
9023 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
9024 return false;
9025 }
9026 return true;
9027}
9028
9030{
9031 return true;
9032}
9033
9035{
9036 if (!readTag(reader)) {
9037 return false;
9038 }
9039 if (!readArgs(reader)) {
9040 return false;
9041 }
9042 return true;
9043}
9044
9046{
9047 std::string tag = reader.readTag(s_tag_len);
9048 if (reader.isError()) {
9049 return false;
9050 }
9051 if (tag != s_tag) {
9052 reader.fail();
9053 return false;
9054 }
9055 return true;
9056}
9057
9059{
9060 if (!reader.noMore()) {
9061 reader.fail();
9062 return false;
9063 }
9064 return true;
9065}
9066
9068{
9069 yarp::os::idl::WireWriter writer(connection);
9070 return write(writer);
9071}
9072
9074{
9075 yarp::os::idl::WireReader reader(connection);
9076 return read(reader);
9077}
9078
9080{
9081 if (!writer.isNull()) {
9082 if (!writer.writeListHeader(s_reply_len)) {
9083 return false;
9084 }
9085 if (!writer.write(return_helper)) {
9086 return false;
9087 }
9088 }
9089 return true;
9090}
9091
9093{
9094 if (!reader.readListReturn()) {
9095 return false;
9096 }
9097 if (reader.noMore()) {
9098 reader.fail();
9099 return false;
9100 }
9101 if (!reader.read(return_helper)) {
9102 reader.fail();
9103 return false;
9104 }
9105 return true;
9106}
9107
9112
9113// setColorCodingDC1394RPC helper class implementation
9118
9120{
9121 return cmd.write(connection);
9122}
9123
9128
9130 coding{coding}
9131{
9132}
9133
9135{
9136 yarp::os::idl::WireWriter writer(connection);
9137 if (!writer.writeListHeader(s_cmd_len)) {
9138 return false;
9139 }
9140 return write(writer);
9141}
9142
9144{
9145 yarp::os::idl::WireReader reader(connection);
9146 if (!reader.readListHeader()) {
9147 reader.fail();
9148 return false;
9149 }
9150 return read(reader);
9151}
9152
9154{
9155 if (!writeTag(writer)) {
9156 return false;
9157 }
9158 if (!writeArgs(writer)) {
9159 return false;
9160 }
9161 return true;
9162}
9163
9165{
9166 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
9167 return false;
9168 }
9169 return true;
9170}
9171
9173{
9174 if (!writer.writeI32(coding)) {
9175 return false;
9176 }
9177 return true;
9178}
9179
9181{
9182 if (!readTag(reader)) {
9183 return false;
9184 }
9185 if (!readArgs(reader)) {
9186 return false;
9187 }
9188 return true;
9189}
9190
9192{
9193 std::string tag = reader.readTag(s_tag_len);
9194 if (reader.isError()) {
9195 return false;
9196 }
9197 if (tag != s_tag) {
9198 reader.fail();
9199 return false;
9200 }
9201 return true;
9202}
9203
9205{
9206 if (reader.noMore()) {
9207 reader.fail();
9208 return false;
9209 }
9210 if (!reader.readI32(coding)) {
9211 reader.fail();
9212 return false;
9213 }
9214 if (!reader.noMore()) {
9215 reader.fail();
9216 return false;
9217 }
9218 return true;
9219}
9220
9222{
9223 yarp::os::idl::WireWriter writer(connection);
9224 return write(writer);
9225}
9226
9228{
9229 yarp::os::idl::WireReader reader(connection);
9230 return read(reader);
9231}
9232
9234{
9235 if (!writer.isNull()) {
9236 if (!writer.write(return_helper)) {
9237 return false;
9238 }
9239 }
9240 return true;
9241}
9242
9244{
9245 if (reader.noMore()) {
9246 reader.fail();
9247 return false;
9248 }
9249 if (!reader.read(return_helper)) {
9250 reader.fail();
9251 return false;
9252 }
9253 return true;
9254}
9255
9260
9261// getFormat7MaxWindowDC1394RPC helper class implementation
9266
9271
9273{
9274 yarp::os::idl::WireWriter writer(connection);
9275 if (!writer.writeListHeader(s_cmd_len)) {
9276 return false;
9277 }
9278 return write(writer);
9279}
9280
9282{
9283 yarp::os::idl::WireReader reader(connection);
9284 if (!reader.readListHeader()) {
9285 reader.fail();
9286 return false;
9287 }
9288 return read(reader);
9289}
9290
9292{
9293 if (!writeTag(writer)) {
9294 return false;
9295 }
9296 if (!writeArgs(writer)) {
9297 return false;
9298 }
9299 return true;
9300}
9301
9303{
9304 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
9305 return false;
9306 }
9307 return true;
9308}
9309
9311{
9312 return true;
9313}
9314
9316{
9317 if (!readTag(reader)) {
9318 return false;
9319 }
9320 if (!readArgs(reader)) {
9321 return false;
9322 }
9323 return true;
9324}
9325
9327{
9328 std::string tag = reader.readTag(s_tag_len);
9329 if (reader.isError()) {
9330 return false;
9331 }
9332 if (tag != s_tag) {
9333 reader.fail();
9334 return false;
9335 }
9336 return true;
9337}
9338
9340{
9341 if (!reader.noMore()) {
9342 reader.fail();
9343 return false;
9344 }
9345 return true;
9346}
9347
9349{
9350 yarp::os::idl::WireWriter writer(connection);
9351 return write(writer);
9352}
9353
9359
9361{
9362 if (!writer.isNull()) {
9363 if (!writer.writeListHeader(s_reply_len)) {
9364 return false;
9365 }
9366 if (!writer.write(return_helper)) {
9367 return false;
9368 }
9369 }
9370 return true;
9371}
9372
9374{
9375 if (!reader.readListReturn()) {
9376 return false;
9377 }
9378 if (reader.noMore()) {
9379 reader.fail();
9380 return false;
9381 }
9382 if (!reader.read(return_helper)) {
9383 reader.fail();
9384 return false;
9385 }
9386 return true;
9387}
9388
9393
9394// getFormat7WindowDC1394RPC helper class implementation
9396{
9397 return cmd.write(connection);
9398}
9399
9404
9406{
9407 yarp::os::idl::WireWriter writer(connection);
9408 if (!writer.writeListHeader(s_cmd_len)) {
9409 return false;
9410 }
9411 return write(writer);
9412}
9413
9415{
9416 yarp::os::idl::WireReader reader(connection);
9417 if (!reader.readListHeader()) {
9418 reader.fail();
9419 return false;
9420 }
9421 return read(reader);
9422}
9423
9425{
9426 if (!writeTag(writer)) {
9427 return false;
9428 }
9429 if (!writeArgs(writer)) {
9430 return false;
9431 }
9432 return true;
9433}
9434
9436{
9437 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
9438 return false;
9439 }
9440 return true;
9441}
9442
9444{
9445 return true;
9446}
9447
9449{
9450 if (!readTag(reader)) {
9451 return false;
9452 }
9453 if (!readArgs(reader)) {
9454 return false;
9455 }
9456 return true;
9457}
9458
9460{
9461 std::string tag = reader.readTag(s_tag_len);
9462 if (reader.isError()) {
9463 return false;
9464 }
9465 if (tag != s_tag) {
9466 reader.fail();
9467 return false;
9468 }
9469 return true;
9470}
9471
9473{
9474 if (!reader.noMore()) {
9475 reader.fail();
9476 return false;
9477 }
9478 return true;
9479}
9480
9482{
9483 yarp::os::idl::WireWriter writer(connection);
9484 return write(writer);
9485}
9486
9492
9494{
9495 if (!writer.isNull()) {
9496 if (!writer.writeListHeader(s_reply_len)) {
9497 return false;
9498 }
9499 if (!writer.write(return_helper)) {
9500 return false;
9501 }
9502 }
9503 return true;
9504}
9505
9507{
9508 if (!reader.readListReturn()) {
9509 return false;
9510 }
9511 if (reader.noMore()) {
9512 reader.fail();
9513 return false;
9514 }
9515 if (!reader.read(return_helper)) {
9516 reader.fail();
9517 return false;
9518 }
9519 return true;
9520}
9521
9526
9527// setFormat7WindowDC1394RPC helper class implementation
9528FrameGrabberMsgs_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) :
9529 cmd{xdim, ydim, x0, y0}
9530{
9531}
9532
9534{
9535 return cmd.write(connection);
9536}
9537
9542
9543FrameGrabberMsgs_setFormat7WindowDC1394RPC_helper::Command::Command(const std::int32_t xdim, const std::int32_t ydim, const std::int32_t x0, const std::int32_t y0) :
9544 xdim{xdim},
9545 ydim{ydim},
9546 x0{x0},
9547 y0{y0}
9548{
9549}
9550
9552{
9553 yarp::os::idl::WireWriter writer(connection);
9554 if (!writer.writeListHeader(s_cmd_len)) {
9555 return false;
9556 }
9557 return write(writer);
9558}
9559
9561{
9562 yarp::os::idl::WireReader reader(connection);
9563 if (!reader.readListHeader()) {
9564 reader.fail();
9565 return false;
9566 }
9567 return read(reader);
9568}
9569
9571{
9572 if (!writeTag(writer)) {
9573 return false;
9574 }
9575 if (!writeArgs(writer)) {
9576 return false;
9577 }
9578 return true;
9579}
9580
9582{
9583 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
9584 return false;
9585 }
9586 return true;
9587}
9588
9590{
9591 if (!writer.writeI32(xdim)) {
9592 return false;
9593 }
9594 if (!writer.writeI32(ydim)) {
9595 return false;
9596 }
9597 if (!writer.writeI32(x0)) {
9598 return false;
9599 }
9600 if (!writer.writeI32(y0)) {
9601 return false;
9602 }
9603 return true;
9604}
9605
9607{
9608 if (!readTag(reader)) {
9609 return false;
9610 }
9611 if (!readArgs(reader)) {
9612 return false;
9613 }
9614 return true;
9615}
9616
9618{
9619 std::string tag = reader.readTag(s_tag_len);
9620 if (reader.isError()) {
9621 return false;
9622 }
9623 if (tag != s_tag) {
9624 reader.fail();
9625 return false;
9626 }
9627 return true;
9628}
9629
9631{
9632 if (reader.noMore()) {
9633 reader.fail();
9634 return false;
9635 }
9636 if (!reader.readI32(xdim)) {
9637 reader.fail();
9638 return false;
9639 }
9640 if (reader.noMore()) {
9641 reader.fail();
9642 return false;
9643 }
9644 if (!reader.readI32(ydim)) {
9645 reader.fail();
9646 return false;
9647 }
9648 if (reader.noMore()) {
9649 reader.fail();
9650 return false;
9651 }
9652 if (!reader.readI32(x0)) {
9653 reader.fail();
9654 return false;
9655 }
9656 if (reader.noMore()) {
9657 reader.fail();
9658 return false;
9659 }
9660 if (!reader.readI32(y0)) {
9661 reader.fail();
9662 return false;
9663 }
9664 if (!reader.noMore()) {
9665 reader.fail();
9666 return false;
9667 }
9668 return true;
9669}
9670
9672{
9673 yarp::os::idl::WireWriter writer(connection);
9674 return write(writer);
9675}
9676
9682
9684{
9685 if (!writer.isNull()) {
9686 if (!writer.write(return_helper)) {
9687 return false;
9688 }
9689 }
9690 return true;
9691}
9692
9694{
9695 if (reader.noMore()) {
9696 reader.fail();
9697 return false;
9698 }
9699 if (!reader.read(return_helper)) {
9700 reader.fail();
9701 return false;
9702 }
9703 return true;
9704}
9705
9710
9711// setOperationModeDC1394RPC helper class implementation
9716
9718{
9719 return cmd.write(connection);
9720}
9721
9726
9728 b1394b{b1394b}
9729{
9730}
9731
9733{
9734 yarp::os::idl::WireWriter writer(connection);
9735 if (!writer.writeListHeader(s_cmd_len)) {
9736 return false;
9737 }
9738 return write(writer);
9739}
9740
9742{
9743 yarp::os::idl::WireReader reader(connection);
9744 if (!reader.readListHeader()) {
9745 reader.fail();
9746 return false;
9747 }
9748 return read(reader);
9749}
9750
9752{
9753 if (!writeTag(writer)) {
9754 return false;
9755 }
9756 if (!writeArgs(writer)) {
9757 return false;
9758 }
9759 return true;
9760}
9761
9763{
9764 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
9765 return false;
9766 }
9767 return true;
9768}
9769
9771{
9772 if (!writer.writeBool(b1394b)) {
9773 return false;
9774 }
9775 return true;
9776}
9777
9779{
9780 if (!readTag(reader)) {
9781 return false;
9782 }
9783 if (!readArgs(reader)) {
9784 return false;
9785 }
9786 return true;
9787}
9788
9790{
9791 std::string tag = reader.readTag(s_tag_len);
9792 if (reader.isError()) {
9793 return false;
9794 }
9795 if (tag != s_tag) {
9796 reader.fail();
9797 return false;
9798 }
9799 return true;
9800}
9801
9803{
9804 if (reader.noMore()) {
9805 reader.fail();
9806 return false;
9807 }
9808 if (!reader.readBool(b1394b)) {
9809 reader.fail();
9810 return false;
9811 }
9812 if (!reader.noMore()) {
9813 reader.fail();
9814 return false;
9815 }
9816 return true;
9817}
9818
9820{
9821 yarp::os::idl::WireWriter writer(connection);
9822 return write(writer);
9823}
9824
9830
9832{
9833 if (!writer.isNull()) {
9834 if (!writer.write(return_helper)) {
9835 return false;
9836 }
9837 }
9838 return true;
9839}
9840
9842{
9843 if (reader.noMore()) {
9844 reader.fail();
9845 return false;
9846 }
9847 if (!reader.read(return_helper)) {
9848 reader.fail();
9849 return false;
9850 }
9851 return true;
9852}
9853
9858
9859// getOperationModeDC1394RPC helper class implementation
9861{
9862 return cmd.write(connection);
9863}
9864
9869
9871{
9872 yarp::os::idl::WireWriter writer(connection);
9873 if (!writer.writeListHeader(s_cmd_len)) {
9874 return false;
9875 }
9876 return write(writer);
9877}
9878
9880{
9881 yarp::os::idl::WireReader reader(connection);
9882 if (!reader.readListHeader()) {
9883 reader.fail();
9884 return false;
9885 }
9886 return read(reader);
9887}
9888
9890{
9891 if (!writeTag(writer)) {
9892 return false;
9893 }
9894 if (!writeArgs(writer)) {
9895 return false;
9896 }
9897 return true;
9898}
9899
9901{
9902 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
9903 return false;
9904 }
9905 return true;
9906}
9907
9909{
9910 return true;
9911}
9912
9914{
9915 if (!readTag(reader)) {
9916 return false;
9917 }
9918 if (!readArgs(reader)) {
9919 return false;
9920 }
9921 return true;
9922}
9923
9925{
9926 std::string tag = reader.readTag(s_tag_len);
9927 if (reader.isError()) {
9928 return false;
9929 }
9930 if (tag != s_tag) {
9931 reader.fail();
9932 return false;
9933 }
9934 return true;
9935}
9936
9938{
9939 if (!reader.noMore()) {
9940 reader.fail();
9941 return false;
9942 }
9943 return true;
9944}
9945
9947{
9948 yarp::os::idl::WireWriter writer(connection);
9949 return write(writer);
9950}
9951
9957
9959{
9960 if (!writer.isNull()) {
9961 if (!writer.writeListHeader(s_reply_len)) {
9962 return false;
9963 }
9964 if (!writer.write(return_helper)) {
9965 return false;
9966 }
9967 }
9968 return true;
9969}
9970
9972{
9973 if (!reader.readListReturn()) {
9974 return false;
9975 }
9976 if (reader.noMore()) {
9977 reader.fail();
9978 return false;
9979 }
9980 if (!reader.read(return_helper)) {
9981 reader.fail();
9982 return false;
9983 }
9984 return true;
9985}
9986
9991
9992// setTransmissionDC1394RPC helper class implementation
9997
9999{
10000 return cmd.write(connection);
10001}
10002
10004{
10005 return reply.read(connection);
10006}
10007
10009 bTxON{bTxON}
10010{
10011}
10012
10014{
10015 yarp::os::idl::WireWriter writer(connection);
10016 if (!writer.writeListHeader(s_cmd_len)) {
10017 return false;
10018 }
10019 return write(writer);
10020}
10021
10023{
10024 yarp::os::idl::WireReader reader(connection);
10025 if (!reader.readListHeader()) {
10026 reader.fail();
10027 return false;
10028 }
10029 return read(reader);
10030}
10031
10033{
10034 if (!writeTag(writer)) {
10035 return false;
10036 }
10037 if (!writeArgs(writer)) {
10038 return false;
10039 }
10040 return true;
10041}
10042
10044{
10045 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
10046 return false;
10047 }
10048 return true;
10049}
10050
10052{
10053 if (!writer.writeBool(bTxON)) {
10054 return false;
10055 }
10056 return true;
10057}
10058
10060{
10061 if (!readTag(reader)) {
10062 return false;
10063 }
10064 if (!readArgs(reader)) {
10065 return false;
10066 }
10067 return true;
10068}
10069
10071{
10072 std::string tag = reader.readTag(s_tag_len);
10073 if (reader.isError()) {
10074 return false;
10075 }
10076 if (tag != s_tag) {
10077 reader.fail();
10078 return false;
10079 }
10080 return true;
10081}
10082
10084{
10085 if (reader.noMore()) {
10086 reader.fail();
10087 return false;
10088 }
10089 if (!reader.readBool(bTxON)) {
10090 reader.fail();
10091 return false;
10092 }
10093 if (!reader.noMore()) {
10094 reader.fail();
10095 return false;
10096 }
10097 return true;
10098}
10099
10101{
10102 yarp::os::idl::WireWriter writer(connection);
10103 return write(writer);
10104}
10105
10107{
10108 yarp::os::idl::WireReader reader(connection);
10109 return read(reader);
10110}
10111
10113{
10114 if (!writer.isNull()) {
10115 if (!writer.write(return_helper)) {
10116 return false;
10117 }
10118 }
10119 return true;
10120}
10121
10123{
10124 if (reader.noMore()) {
10125 reader.fail();
10126 return false;
10127 }
10128 if (!reader.read(return_helper)) {
10129 reader.fail();
10130 return false;
10131 }
10132 return true;
10133}
10134
10139
10140// getTransmissionDC1394RPC helper class implementation
10142{
10143 return cmd.write(connection);
10144}
10145
10147{
10148 return reply.read(connection);
10149}
10150
10152{
10153 yarp::os::idl::WireWriter writer(connection);
10154 if (!writer.writeListHeader(s_cmd_len)) {
10155 return false;
10156 }
10157 return write(writer);
10158}
10159
10161{
10162 yarp::os::idl::WireReader reader(connection);
10163 if (!reader.readListHeader()) {
10164 reader.fail();
10165 return false;
10166 }
10167 return read(reader);
10168}
10169
10171{
10172 if (!writeTag(writer)) {
10173 return false;
10174 }
10175 if (!writeArgs(writer)) {
10176 return false;
10177 }
10178 return true;
10179}
10180
10182{
10183 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
10184 return false;
10185 }
10186 return true;
10187}
10188
10190{
10191 return true;
10192}
10193
10195{
10196 if (!readTag(reader)) {
10197 return false;
10198 }
10199 if (!readArgs(reader)) {
10200 return false;
10201 }
10202 return true;
10203}
10204
10206{
10207 std::string tag = reader.readTag(s_tag_len);
10208 if (reader.isError()) {
10209 return false;
10210 }
10211 if (tag != s_tag) {
10212 reader.fail();
10213 return false;
10214 }
10215 return true;
10216}
10217
10219{
10220 if (!reader.noMore()) {
10221 reader.fail();
10222 return false;
10223 }
10224 return true;
10225}
10226
10228{
10229 yarp::os::idl::WireWriter writer(connection);
10230 return write(writer);
10231}
10232
10234{
10235 yarp::os::idl::WireReader reader(connection);
10236 return read(reader);
10237}
10238
10240{
10241 if (!writer.isNull()) {
10242 if (!writer.writeListHeader(s_reply_len)) {
10243 return false;
10244 }
10245 if (!writer.write(return_helper)) {
10246 return false;
10247 }
10248 }
10249 return true;
10250}
10251
10253{
10254 if (!reader.readListReturn()) {
10255 return false;
10256 }
10257 if (reader.noMore()) {
10258 reader.fail();
10259 return false;
10260 }
10261 if (!reader.read(return_helper)) {
10262 reader.fail();
10263 return false;
10264 }
10265 return true;
10266}
10267
10272
10273// setBroadcastDC1394RPC helper class implementation
10278
10280{
10281 return cmd.write(connection);
10282}
10283
10285{
10286 return reply.read(connection);
10287}
10288
10290 onoff{onoff}
10291{
10292}
10293
10295{
10296 yarp::os::idl::WireWriter writer(connection);
10297 if (!writer.writeListHeader(s_cmd_len)) {
10298 return false;
10299 }
10300 return write(writer);
10301}
10302
10304{
10305 yarp::os::idl::WireReader reader(connection);
10306 if (!reader.readListHeader()) {
10307 reader.fail();
10308 return false;
10309 }
10310 return read(reader);
10311}
10312
10314{
10315 if (!writeTag(writer)) {
10316 return false;
10317 }
10318 if (!writeArgs(writer)) {
10319 return false;
10320 }
10321 return true;
10322}
10323
10325{
10326 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
10327 return false;
10328 }
10329 return true;
10330}
10331
10333{
10334 if (!writer.writeBool(onoff)) {
10335 return false;
10336 }
10337 return true;
10338}
10339
10341{
10342 if (!readTag(reader)) {
10343 return false;
10344 }
10345 if (!readArgs(reader)) {
10346 return false;
10347 }
10348 return true;
10349}
10350
10352{
10353 std::string tag = reader.readTag(s_tag_len);
10354 if (reader.isError()) {
10355 return false;
10356 }
10357 if (tag != s_tag) {
10358 reader.fail();
10359 return false;
10360 }
10361 return true;
10362}
10363
10365{
10366 if (reader.noMore()) {
10367 reader.fail();
10368 return false;
10369 }
10370 if (!reader.readBool(onoff)) {
10371 reader.fail();
10372 return false;
10373 }
10374 if (!reader.noMore()) {
10375 reader.fail();
10376 return false;
10377 }
10378 return true;
10379}
10380
10382{
10383 yarp::os::idl::WireWriter writer(connection);
10384 return write(writer);
10385}
10386
10388{
10389 yarp::os::idl::WireReader reader(connection);
10390 return read(reader);
10391}
10392
10394{
10395 if (!writer.isNull()) {
10396 if (!writer.write(return_helper)) {
10397 return false;
10398 }
10399 }
10400 return true;
10401}
10402
10404{
10405 if (reader.noMore()) {
10406 reader.fail();
10407 return false;
10408 }
10409 if (!reader.read(return_helper)) {
10410 reader.fail();
10411 return false;
10412 }
10413 return true;
10414}
10415
10420
10421// setDefaultsDC1394RPC helper class implementation
10423{
10424 return cmd.write(connection);
10425}
10426
10428{
10429 return reply.read(connection);
10430}
10431
10433{
10434 yarp::os::idl::WireWriter writer(connection);
10435 if (!writer.writeListHeader(s_cmd_len)) {
10436 return false;
10437 }
10438 return write(writer);
10439}
10440
10442{
10443 yarp::os::idl::WireReader reader(connection);
10444 if (!reader.readListHeader()) {
10445 reader.fail();
10446 return false;
10447 }
10448 return read(reader);
10449}
10450
10452{
10453 if (!writeTag(writer)) {
10454 return false;
10455 }
10456 if (!writeArgs(writer)) {
10457 return false;
10458 }
10459 return true;
10460}
10461
10463{
10464 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
10465 return false;
10466 }
10467 return true;
10468}
10469
10471{
10472 return true;
10473}
10474
10476{
10477 if (!readTag(reader)) {
10478 return false;
10479 }
10480 if (!readArgs(reader)) {
10481 return false;
10482 }
10483 return true;
10484}
10485
10487{
10488 std::string tag = reader.readTag(s_tag_len);
10489 if (reader.isError()) {
10490 return false;
10491 }
10492 if (tag != s_tag) {
10493 reader.fail();
10494 return false;
10495 }
10496 return true;
10497}
10498
10500{
10501 if (!reader.noMore()) {
10502 reader.fail();
10503 return false;
10504 }
10505 return true;
10506}
10507
10509{
10510 yarp::os::idl::WireWriter writer(connection);
10511 return write(writer);
10512}
10513
10515{
10516 yarp::os::idl::WireReader reader(connection);
10517 return read(reader);
10518}
10519
10521{
10522 if (!writer.isNull()) {
10523 if (!writer.write(return_helper)) {
10524 return false;
10525 }
10526 }
10527 return true;
10528}
10529
10531{
10532 if (reader.noMore()) {
10533 reader.fail();
10534 return false;
10535 }
10536 if (!reader.read(return_helper)) {
10537 reader.fail();
10538 return false;
10539 }
10540 return true;
10541}
10542
10547
10548// setResetDC1394RPC helper class implementation
10550{
10551 return cmd.write(connection);
10552}
10553
10555{
10556 return reply.read(connection);
10557}
10558
10560{
10561 yarp::os::idl::WireWriter writer(connection);
10562 if (!writer.writeListHeader(s_cmd_len)) {
10563 return false;
10564 }
10565 return write(writer);
10566}
10567
10569{
10570 yarp::os::idl::WireReader reader(connection);
10571 if (!reader.readListHeader()) {
10572 reader.fail();
10573 return false;
10574 }
10575 return read(reader);
10576}
10577
10579{
10580 if (!writeTag(writer)) {
10581 return false;
10582 }
10583 if (!writeArgs(writer)) {
10584 return false;
10585 }
10586 return true;
10587}
10588
10590{
10591 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
10592 return false;
10593 }
10594 return true;
10595}
10596
10598{
10599 return true;
10600}
10601
10603{
10604 if (!readTag(reader)) {
10605 return false;
10606 }
10607 if (!readArgs(reader)) {
10608 return false;
10609 }
10610 return true;
10611}
10612
10614{
10615 std::string tag = reader.readTag(s_tag_len);
10616 if (reader.isError()) {
10617 return false;
10618 }
10619 if (tag != s_tag) {
10620 reader.fail();
10621 return false;
10622 }
10623 return true;
10624}
10625
10627{
10628 if (!reader.noMore()) {
10629 reader.fail();
10630 return false;
10631 }
10632 return true;
10633}
10634
10636{
10637 yarp::os::idl::WireWriter writer(connection);
10638 return write(writer);
10639}
10640
10642{
10643 yarp::os::idl::WireReader reader(connection);
10644 return read(reader);
10645}
10646
10648{
10649 if (!writer.isNull()) {
10650 if (!writer.write(return_helper)) {
10651 return false;
10652 }
10653 }
10654 return true;
10655}
10656
10658{
10659 if (reader.noMore()) {
10660 reader.fail();
10661 return false;
10662 }
10663 if (!reader.read(return_helper)) {
10664 reader.fail();
10665 return false;
10666 }
10667 return true;
10668}
10669
10674
10675// setPowerDC1394RPC helper class implementation
10680
10682{
10683 return cmd.write(connection);
10684}
10685
10687{
10688 return reply.read(connection);
10689}
10690
10692 onoff{onoff}
10693{
10694}
10695
10697{
10698 yarp::os::idl::WireWriter writer(connection);
10699 if (!writer.writeListHeader(s_cmd_len)) {
10700 return false;
10701 }
10702 return write(writer);
10703}
10704
10706{
10707 yarp::os::idl::WireReader reader(connection);
10708 if (!reader.readListHeader()) {
10709 reader.fail();
10710 return false;
10711 }
10712 return read(reader);
10713}
10714
10716{
10717 if (!writeTag(writer)) {
10718 return false;
10719 }
10720 if (!writeArgs(writer)) {
10721 return false;
10722 }
10723 return true;
10724}
10725
10727{
10728 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
10729 return false;
10730 }
10731 return true;
10732}
10733
10735{
10736 if (!writer.writeBool(onoff)) {
10737 return false;
10738 }
10739 return true;
10740}
10741
10743{
10744 if (!readTag(reader)) {
10745 return false;
10746 }
10747 if (!readArgs(reader)) {
10748 return false;
10749 }
10750 return true;
10751}
10752
10754{
10755 std::string tag = reader.readTag(s_tag_len);
10756 if (reader.isError()) {
10757 return false;
10758 }
10759 if (tag != s_tag) {
10760 reader.fail();
10761 return false;
10762 }
10763 return true;
10764}
10765
10767{
10768 if (reader.noMore()) {
10769 reader.fail();
10770 return false;
10771 }
10772 if (!reader.readBool(onoff)) {
10773 reader.fail();
10774 return false;
10775 }
10776 if (!reader.noMore()) {
10777 reader.fail();
10778 return false;
10779 }
10780 return true;
10781}
10782
10784{
10785 yarp::os::idl::WireWriter writer(connection);
10786 return write(writer);
10787}
10788
10790{
10791 yarp::os::idl::WireReader reader(connection);
10792 return read(reader);
10793}
10794
10796{
10797 if (!writer.isNull()) {
10798 if (!writer.write(return_helper)) {
10799 return false;
10800 }
10801 }
10802 return true;
10803}
10804
10806{
10807 if (reader.noMore()) {
10808 reader.fail();
10809 return false;
10810 }
10811 if (!reader.read(return_helper)) {
10812 reader.fail();
10813 return false;
10814 }
10815 return true;
10816}
10817
10822
10823// setCaptureDC1394RPC helper class implementation
10828
10830{
10831 return cmd.write(connection);
10832}
10833
10835{
10836 return reply.read(connection);
10837}
10838
10840 bON{bON}
10841{
10842}
10843
10845{
10846 yarp::os::idl::WireWriter writer(connection);
10847 if (!writer.writeListHeader(s_cmd_len)) {
10848 return false;
10849 }
10850 return write(writer);
10851}
10852
10854{
10855 yarp::os::idl::WireReader reader(connection);
10856 if (!reader.readListHeader()) {
10857 reader.fail();
10858 return false;
10859 }
10860 return read(reader);
10861}
10862
10864{
10865 if (!writeTag(writer)) {
10866 return false;
10867 }
10868 if (!writeArgs(writer)) {
10869 return false;
10870 }
10871 return true;
10872}
10873
10875{
10876 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
10877 return false;
10878 }
10879 return true;
10880}
10881
10883{
10884 if (!writer.writeBool(bON)) {
10885 return false;
10886 }
10887 return true;
10888}
10889
10891{
10892 if (!readTag(reader)) {
10893 return false;
10894 }
10895 if (!readArgs(reader)) {
10896 return false;
10897 }
10898 return true;
10899}
10900
10902{
10903 std::string tag = reader.readTag(s_tag_len);
10904 if (reader.isError()) {
10905 return false;
10906 }
10907 if (tag != s_tag) {
10908 reader.fail();
10909 return false;
10910 }
10911 return true;
10912}
10913
10915{
10916 if (reader.noMore()) {
10917 reader.fail();
10918 return false;
10919 }
10920 if (!reader.readBool(bON)) {
10921 reader.fail();
10922 return false;
10923 }
10924 if (!reader.noMore()) {
10925 reader.fail();
10926 return false;
10927 }
10928 return true;
10929}
10930
10932{
10933 yarp::os::idl::WireWriter writer(connection);
10934 return write(writer);
10935}
10936
10938{
10939 yarp::os::idl::WireReader reader(connection);
10940 return read(reader);
10941}
10942
10944{
10945 if (!writer.isNull()) {
10946 if (!writer.write(return_helper)) {
10947 return false;
10948 }
10949 }
10950 return true;
10951}
10952
10954{
10955 if (reader.noMore()) {
10956 reader.fail();
10957 return false;
10958 }
10959 if (!reader.read(return_helper)) {
10960 reader.fail();
10961 return false;
10962 }
10963 return true;
10964}
10965
10970
10971// getBytesPerPacketDC1394RPC helper class implementation
10973{
10974 return cmd.write(connection);
10975}
10976
10981
10983{
10984 yarp::os::idl::WireWriter writer(connection);
10985 if (!writer.writeListHeader(s_cmd_len)) {
10986 return false;
10987 }
10988 return write(writer);
10989}
10990
10992{
10993 yarp::os::idl::WireReader reader(connection);
10994 if (!reader.readListHeader()) {
10995 reader.fail();
10996 return false;
10997 }
10998 return read(reader);
10999}
11000
11002{
11003 if (!writeTag(writer)) {
11004 return false;
11005 }
11006 if (!writeArgs(writer)) {
11007 return false;
11008 }
11009 return true;
11010}
11011
11013{
11014 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
11015 return false;
11016 }
11017 return true;
11018}
11019
11021{
11022 return true;
11023}
11024
11026{
11027 if (!readTag(reader)) {
11028 return false;
11029 }
11030 if (!readArgs(reader)) {
11031 return false;
11032 }
11033 return true;
11034}
11035
11037{
11038 std::string tag = reader.readTag(s_tag_len);
11039 if (reader.isError()) {
11040 return false;
11041 }
11042 if (tag != s_tag) {
11043 reader.fail();
11044 return false;
11045 }
11046 return true;
11047}
11048
11050{
11051 if (!reader.noMore()) {
11052 reader.fail();
11053 return false;
11054 }
11055 return true;
11056}
11057
11059{
11060 yarp::os::idl::WireWriter writer(connection);
11061 return write(writer);
11062}
11063
11065{
11066 yarp::os::idl::WireReader reader(connection);
11067 return read(reader);
11068}
11069
11071{
11072 if (!writer.isNull()) {
11073 if (!writer.writeListHeader(s_reply_len)) {
11074 return false;
11075 }
11076 if (!writer.write(return_helper)) {
11077 return false;
11078 }
11079 }
11080 return true;
11081}
11082
11084{
11085 if (!reader.readListReturn()) {
11086 return false;
11087 }
11088 if (reader.noMore()) {
11089 reader.fail();
11090 return false;
11091 }
11092 if (!reader.read(return_helper)) {
11093 reader.fail();
11094 return false;
11095 }
11096 return true;
11097}
11098
11103
11104// setBytesPerPacketDC1394RPC helper class implementation
11109
11111{
11112 return cmd.write(connection);
11113}
11114
11119
11124
11126{
11127 yarp::os::idl::WireWriter writer(connection);
11128 if (!writer.writeListHeader(s_cmd_len)) {
11129 return false;
11130 }
11131 return write(writer);
11132}
11133
11135{
11136 yarp::os::idl::WireReader reader(connection);
11137 if (!reader.readListHeader()) {
11138 reader.fail();
11139 return false;
11140 }
11141 return read(reader);
11142}
11143
11145{
11146 if (!writeTag(writer)) {
11147 return false;
11148 }
11149 if (!writeArgs(writer)) {
11150 return false;
11151 }
11152 return true;
11153}
11154
11156{
11157 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
11158 return false;
11159 }
11160 return true;
11161}
11162
11164{
11165 if (!writer.writeI32(bpp)) {
11166 return false;
11167 }
11168 return true;
11169}
11170
11172{
11173 if (!readTag(reader)) {
11174 return false;
11175 }
11176 if (!readArgs(reader)) {
11177 return false;
11178 }
11179 return true;
11180}
11181
11183{
11184 std::string tag = reader.readTag(s_tag_len);
11185 if (reader.isError()) {
11186 return false;
11187 }
11188 if (tag != s_tag) {
11189 reader.fail();
11190 return false;
11191 }
11192 return true;
11193}
11194
11196{
11197 if (reader.noMore()) {
11198 reader.fail();
11199 return false;
11200 }
11201 if (!reader.readI32(bpp)) {
11202 reader.fail();
11203 return false;
11204 }
11205 if (!reader.noMore()) {
11206 reader.fail();
11207 return false;
11208 }
11209 return true;
11210}
11211
11213{
11214 yarp::os::idl::WireWriter writer(connection);
11215 return write(writer);
11216}
11217
11219{
11220 yarp::os::idl::WireReader reader(connection);
11221 return read(reader);
11222}
11223
11225{
11226 if (!writer.isNull()) {
11227 if (!writer.write(return_helper)) {
11228 return false;
11229 }
11230 }
11231 return true;
11232}
11233
11235{
11236 if (reader.noMore()) {
11237 reader.fail();
11238 return false;
11239 }
11240 if (!reader.read(return_helper)) {
11241 reader.fail();
11242 return false;
11243 }
11244 return true;
11245}
11246
11251
11252// Constructor
11254{
11255 yarp().setOwner(*this);
11256}
11257
11259{
11260 if (!yarp().canWrite()) {
11261 yError("Missing server method '%s'?", FrameGrabberMsgs_getHeightRPC_helper::s_prototype);
11262 }
11264 bool ok = yarp().write(helper, helper);
11265 if (!ok) {
11268 return failed_reply;
11269 }
11270 return helper.reply.return_helper;
11271}
11272
11274{
11275 if (!yarp().canWrite()) {
11276 yError("Missing server method '%s'?", FrameGrabberMsgs_getWidthRPC_helper::s_prototype);
11277 }
11279 bool ok = yarp().write(helper, helper);
11280 if (!ok) {
11283 return failed_reply;
11284 }
11285 return helper.reply.return_helper;
11286}
11287
11289{
11290 if (!yarp().canWrite()) {
11291 yError("Missing server method '%s'?", FrameGrabberMsgs_getImageRPC_helper::s_prototype);
11292 }
11294 bool ok = yarp().write(helper, helper);
11295 if (!ok) {
11298 return failed_reply;
11299 }
11300 return helper.reply.return_helper;
11301}
11302
11304{
11305 if (!yarp().canWrite()) {
11306 yError("Missing server method '%s'?", FrameGrabberMsgs_getImageCropRPC_helper::s_prototype);
11307 }
11308 FrameGrabberMsgs_getImageCropRPC_helper helper{type, vertices};
11309 bool ok = yarp().write(helper, helper);
11310 if (!ok) {
11313 return failed_reply;
11314 }
11315 return helper.reply.return_helper;
11316}
11317
11319{
11320 if (!yarp().canWrite()) {
11321 yError("Missing server method '%s'?", FrameGrabberMsgs_getRgbWidthRPC_helper::s_prototype);
11322 }
11324 bool ok = yarp().write(helper, helper);
11325 if (!ok) {
11328 return failed_reply;
11329 }
11330 return helper.reply.return_helper;
11331}
11332
11334{
11335 if (!yarp().canWrite()) {
11336 yError("Missing server method '%s'?", FrameGrabberMsgs_getRgbHeightRPC_helper::s_prototype);
11337 }
11339 bool ok = yarp().write(helper, helper);
11340 if (!ok) {
11343 return failed_reply;
11344 }
11345 return helper.reply.return_helper;
11346}
11347
11349{
11350 if (!yarp().canWrite()) {
11352 }
11354 bool ok = yarp().write(helper, helper);
11355 if (!ok) {
11358 return failed_reply;
11359 }
11360 return helper.reply.return_helper;
11361}
11362
11364{
11365 if (!yarp().canWrite()) {
11367 }
11369 bool ok = yarp().write(helper, helper);
11370 if (!ok) {
11373 return failed_reply;
11374 }
11375 return helper.reply.return_helper;
11376}
11377
11378yarp::dev::ReturnValue FrameGrabberMsgs::setRgbResolutionRPC(const std::int32_t width, const std::int32_t height)
11379{
11380 if (!yarp().canWrite()) {
11382 }
11383 FrameGrabberMsgs_setRgbResolutionRPC_helper helper{width, height};
11384 bool ok = yarp().write(helper, helper);
11386}
11387
11389{
11390 if (!yarp().canWrite()) {
11391 yError("Missing server method '%s'?", FrameGrabberMsgs_getRgbFOVRPC_helper::s_prototype);
11392 }
11394 bool ok = yarp().write(helper, helper);
11395 if (!ok) {
11398 return failed_reply;
11399 }
11400 return helper.reply.return_helper;
11401}
11402
11403yarp::dev::ReturnValue FrameGrabberMsgs::setRgbFOVRPC(const double horizontalFov, const double verticalFov)
11404{
11405 if (!yarp().canWrite()) {
11406 yError("Missing server method '%s'?", FrameGrabberMsgs_setRgbFOVRPC_helper::s_prototype);
11407 }
11408 FrameGrabberMsgs_setRgbFOVRPC_helper helper{horizontalFov, verticalFov};
11409 bool ok = yarp().write(helper, helper);
11411}
11412
11414{
11415 if (!yarp().canWrite()) {
11417 }
11419 bool ok = yarp().write(helper, helper);
11420 if (!ok) {
11423 return failed_reply;
11424 }
11425 return helper.reply.return_helper;
11426}
11427
11429{
11430 if (!yarp().canWrite()) {
11432 }
11434 bool ok = yarp().write(helper, helper);
11435 if (!ok) {
11438 return failed_reply;
11439 }
11440 return helper.reply.return_helper;
11441}
11442
11444{
11445 if (!yarp().canWrite()) {
11447 }
11449 bool ok = yarp().write(helper, helper);
11451}
11452
11454{
11455 if (!yarp().canWrite()) {
11457 }
11459 bool ok = yarp().write(helper, helper);
11460 if (!ok) {
11463 return failed_reply;
11464 }
11465 return helper.reply.return_helper;
11466}
11467
11469{
11470 if (!yarp().canWrite()) {
11471 yError("Missing server method '%s'?", FrameGrabberMsgs_hasFeatureRPC_helper::s_prototype);
11472 }
11474 bool ok = yarp().write(helper, helper);
11475 if (!ok) {
11478 return failed_reply;
11479 }
11480 return helper.reply.return_helper;
11481}
11482
11484{
11485 if (!yarp().canWrite()) {
11486 yError("Missing server method '%s'?", FrameGrabberMsgs_setFeature1RPC_helper::s_prototype);
11487 }
11489 bool ok = yarp().write(helper, helper);
11491}
11492
11494{
11495 if (!yarp().canWrite()) {
11496 yError("Missing server method '%s'?", FrameGrabberMsgs_getFeature1RPC_helper::s_prototype);
11497 }
11499 bool ok = yarp().write(helper, helper);
11500 if (!ok) {
11503 return failed_reply;
11504 }
11505 return helper.reply.return_helper;
11506}
11507
11508yarp::dev::ReturnValue FrameGrabberMsgs::setFeature2RPC(const std::int32_t feature, const double value1, const double value2)
11509{
11510 if (!yarp().canWrite()) {
11511 yError("Missing server method '%s'?", FrameGrabberMsgs_setFeature2RPC_helper::s_prototype);
11512 }
11513 FrameGrabberMsgs_setFeature2RPC_helper helper{feature, value1, value2};
11514 bool ok = yarp().write(helper, helper);
11516}
11517
11519{
11520 if (!yarp().canWrite()) {
11521 yError("Missing server method '%s'?", FrameGrabberMsgs_getFeature2RPC_helper::s_prototype);
11522 }
11524 bool ok = yarp().write(helper, helper);
11525 if (!ok) {
11528 return failed_reply;
11529 }
11530 return helper.reply.return_helper;
11531}
11532
11534{
11535 if (!yarp().canWrite()) {
11536 yError("Missing server method '%s'?", FrameGrabberMsgs_hasOnOffRPC_helper::s_prototype);
11537 }
11539 bool ok = yarp().write(helper, helper);
11540 if (!ok) {
11543 return failed_reply;
11544 }
11545 return helper.reply.return_helper;
11546}
11547
11549{
11550 if (!yarp().canWrite()) {
11551 yError("Missing server method '%s'?", FrameGrabberMsgs_setActiveRPC_helper::s_prototype);
11552 }
11554 bool ok = yarp().write(helper, helper);
11556}
11557
11559{
11560 if (!yarp().canWrite()) {
11561 yError("Missing server method '%s'?", FrameGrabberMsgs_getActiveRPC_helper::s_prototype);
11562 }
11564 bool ok = yarp().write(helper, helper);
11565 if (!ok) {
11568 return failed_reply;
11569 }
11570 return helper.reply.return_helper;
11571}
11572
11574{
11575 if (!yarp().canWrite()) {
11576 yError("Missing server method '%s'?", FrameGrabberMsgs_hasAutoRPC_helper::s_prototype);
11577 }
11579 bool ok = yarp().write(helper, helper);
11580 if (!ok) {
11583 return failed_reply;
11584 }
11585 return helper.reply.return_helper;
11586}
11587
11589{
11590 if (!yarp().canWrite()) {
11591 yError("Missing server method '%s'?", FrameGrabberMsgs_hasManualRPC_helper::s_prototype);
11592 }
11594 bool ok = yarp().write(helper, helper);
11595 if (!ok) {
11598 return failed_reply;
11599 }
11600 return helper.reply.return_helper;
11601}
11602
11604{
11605 if (!yarp().canWrite()) {
11606 yError("Missing server method '%s'?", FrameGrabberMsgs_hasOnePushRPC_helper::s_prototype);
11607 }
11609 bool ok = yarp().write(helper, helper);
11610 if (!ok) {
11613 return failed_reply;
11614 }
11615 return helper.reply.return_helper;
11616}
11617
11619{
11620 if (!yarp().canWrite()) {
11621 yError("Missing server method '%s'?", FrameGrabberMsgs_setModeRPC_helper::s_prototype);
11622 }
11624 bool ok = yarp().write(helper, helper);
11626}
11627
11629{
11630 if (!yarp().canWrite()) {
11631 yError("Missing server method '%s'?", FrameGrabberMsgs_getModeRPC_helper::s_prototype);
11632 }
11634 bool ok = yarp().write(helper, helper);
11635 if (!ok) {
11638 return failed_reply;
11639 }
11640 return helper.reply.return_helper;
11641}
11642
11644{
11645 if (!yarp().canWrite()) {
11646 yError("Missing server method '%s'?", FrameGrabberMsgs_setOnePushRPC_helper::s_prototype);
11647 }
11649 bool ok = yarp().write(helper, helper);
11651}
11652
11654{
11655 if (!yarp().canWrite()) {
11657 }
11659 bool ok = yarp().write(helper, helper);
11660 if (!ok) {
11663 return failed_reply;
11664 }
11665 return helper.reply.return_helper;
11666}
11667
11669{
11670 if (!yarp().canWrite()) {
11672 }
11674 bool ok = yarp().write(helper, helper);
11675 if (!ok) {
11678 return failed_reply;
11679 }
11680 return helper.reply.return_helper;
11681}
11682
11684{
11685 if (!yarp().canWrite()) {
11687 }
11689 bool ok = yarp().write(helper, helper);
11691}
11692
11694{
11695 if (!yarp().canWrite()) {
11697 }
11699 bool ok = yarp().write(helper, helper);
11700 if (!ok) {
11703 return failed_reply;
11704 }
11705 return helper.reply.return_helper;
11706}
11707
11709{
11710 if (!yarp().canWrite()) {
11711 yError("Missing server method '%s'?", FrameGrabberMsgs_getFPSDC1394RPC_helper::s_prototype);
11712 }
11714 bool ok = yarp().write(helper, helper);
11715 if (!ok) {
11718 return failed_reply;
11719 }
11720 return helper.reply.return_helper;
11721}
11722
11724{
11725 if (!yarp().canWrite()) {
11726 yError("Missing server method '%s'?", FrameGrabberMsgs_setFPSDC1394RPC_helper::s_prototype);
11727 }
11729 bool ok = yarp().write(helper, helper);
11731}
11732
11734{
11735 if (!yarp().canWrite()) {
11737 }
11739 bool ok = yarp().write(helper, helper);
11740 if (!ok) {
11743 return failed_reply;
11744 }
11745 return helper.reply.return_helper;
11746}
11747
11749{
11750 if (!yarp().canWrite()) {
11752 }
11754 bool ok = yarp().write(helper, helper);
11756}
11757
11759{
11760 if (!yarp().canWrite()) {
11762 }
11764 bool ok = yarp().write(helper, helper);
11765 if (!ok) {
11768 return failed_reply;
11769 }
11770 return helper.reply.return_helper;
11771}
11772
11774{
11775 if (!yarp().canWrite()) {
11777 }
11779 bool ok = yarp().write(helper, helper);
11780 if (!ok) {
11783 return failed_reply;
11784 }
11785 return helper.reply.return_helper;
11786}
11787
11789{
11790 if (!yarp().canWrite()) {
11792 }
11794 bool ok = yarp().write(helper, helper);
11796}
11797
11799{
11800 if (!yarp().canWrite()) {
11802 }
11804 bool ok = yarp().write(helper, helper);
11805 if (!ok) {
11808 return failed_reply;
11809 }
11810 return helper.reply.return_helper;
11811}
11812
11814{
11815 if (!yarp().canWrite()) {
11817 }
11819 bool ok = yarp().write(helper, helper);
11820 if (!ok) {
11823 return failed_reply;
11824 }
11825 return helper.reply.return_helper;
11826}
11827
11828yarp::dev::ReturnValue FrameGrabberMsgs::setFormat7WindowDC1394RPC(const std::int32_t xdim, const std::int32_t ydim, const std::int32_t x0, const std::int32_t y0)
11829{
11830 if (!yarp().canWrite()) {
11832 }
11833 FrameGrabberMsgs_setFormat7WindowDC1394RPC_helper helper{xdim, ydim, x0, y0};
11834 bool ok = yarp().write(helper, helper);
11836}
11837
11839{
11840 if (!yarp().canWrite()) {
11842 }
11844 bool ok = yarp().write(helper, helper);
11846}
11847
11849{
11850 if (!yarp().canWrite()) {
11852 }
11854 bool ok = yarp().write(helper, helper);
11855 if (!ok) {
11858 return failed_reply;
11859 }
11860 return helper.reply.return_helper;
11861}
11862
11864{
11865 if (!yarp().canWrite()) {
11867 }
11869 bool ok = yarp().write(helper, helper);
11871}
11872
11874{
11875 if (!yarp().canWrite()) {
11877 }
11879 bool ok = yarp().write(helper, helper);
11880 if (!ok) {
11883 return failed_reply;
11884 }
11885 return helper.reply.return_helper;
11886}
11887
11889{
11890 if (!yarp().canWrite()) {
11892 }
11894 bool ok = yarp().write(helper, helper);
11896}
11897
11899{
11900 if (!yarp().canWrite()) {
11902 }
11904 bool ok = yarp().write(helper, helper);
11906}
11907
11909{
11910 if (!yarp().canWrite()) {
11911 yError("Missing server method '%s'?", FrameGrabberMsgs_setResetDC1394RPC_helper::s_prototype);
11912 }
11914 bool ok = yarp().write(helper, helper);
11916}
11917
11919{
11920 if (!yarp().canWrite()) {
11921 yError("Missing server method '%s'?", FrameGrabberMsgs_setPowerDC1394RPC_helper::s_prototype);
11922 }
11924 bool ok = yarp().write(helper, helper);
11926}
11927
11929{
11930 if (!yarp().canWrite()) {
11932 }
11934 bool ok = yarp().write(helper, helper);
11936}
11937
11939{
11940 if (!yarp().canWrite()) {
11942 }
11944 bool ok = yarp().write(helper, helper);
11945 if (!ok) {
11948 return failed_reply;
11949 }
11950 return helper.reply.return_helper;
11951}
11952
11954{
11955 if (!yarp().canWrite()) {
11957 }
11959 bool ok = yarp().write(helper, helper);
11961}
11962
11963// help method
11964std::vector<std::string> FrameGrabberMsgs::help(const std::string& functionName)
11965{
11966 bool showAll = (functionName == "--all");
11967 std::vector<std::string> helpString;
11968 if (showAll) {
11969 helpString.emplace_back("*** Available commands:");
11970 helpString.emplace_back(FrameGrabberMsgs_getHeightRPC_helper::s_tag);
11971 helpString.emplace_back(FrameGrabberMsgs_getWidthRPC_helper::s_tag);
11972 helpString.emplace_back(FrameGrabberMsgs_getImageRPC_helper::s_tag);
11973 helpString.emplace_back(FrameGrabberMsgs_getImageCropRPC_helper::s_tag);
11974 helpString.emplace_back(FrameGrabberMsgs_getRgbWidthRPC_helper::s_tag);
11975 helpString.emplace_back(FrameGrabberMsgs_getRgbHeightRPC_helper::s_tag);
11979 helpString.emplace_back(FrameGrabberMsgs_getRgbFOVRPC_helper::s_tag);
11980 helpString.emplace_back(FrameGrabberMsgs_setRgbFOVRPC_helper::s_tag);
11985 helpString.emplace_back(FrameGrabberMsgs_hasFeatureRPC_helper::s_tag);
11986 helpString.emplace_back(FrameGrabberMsgs_setFeature1RPC_helper::s_tag);
11987 helpString.emplace_back(FrameGrabberMsgs_getFeature1RPC_helper::s_tag);
11988 helpString.emplace_back(FrameGrabberMsgs_setFeature2RPC_helper::s_tag);
11989 helpString.emplace_back(FrameGrabberMsgs_getFeature2RPC_helper::s_tag);
11990 helpString.emplace_back(FrameGrabberMsgs_hasOnOffRPC_helper::s_tag);
11991 helpString.emplace_back(FrameGrabberMsgs_setActiveRPC_helper::s_tag);
11992 helpString.emplace_back(FrameGrabberMsgs_getActiveRPC_helper::s_tag);
11993 helpString.emplace_back(FrameGrabberMsgs_hasAutoRPC_helper::s_tag);
11994 helpString.emplace_back(FrameGrabberMsgs_hasManualRPC_helper::s_tag);
11995 helpString.emplace_back(FrameGrabberMsgs_hasOnePushRPC_helper::s_tag);
11996 helpString.emplace_back(FrameGrabberMsgs_setModeRPC_helper::s_tag);
11997 helpString.emplace_back(FrameGrabberMsgs_getModeRPC_helper::s_tag);
11998 helpString.emplace_back(FrameGrabberMsgs_setOnePushRPC_helper::s_tag);
12003 helpString.emplace_back(FrameGrabberMsgs_getFPSDC1394RPC_helper::s_tag);
12004 helpString.emplace_back(FrameGrabberMsgs_setFPSDC1394RPC_helper::s_tag);
12019 helpString.emplace_back(FrameGrabberMsgs_setResetDC1394RPC_helper::s_tag);
12020 helpString.emplace_back(FrameGrabberMsgs_setPowerDC1394RPC_helper::s_tag);
12024 helpString.emplace_back("help");
12025 } else {
12026 if (functionName == FrameGrabberMsgs_getHeightRPC_helper::s_tag) {
12028 }
12029 if (functionName == FrameGrabberMsgs_getWidthRPC_helper::s_tag) {
12030 helpString.emplace_back(FrameGrabberMsgs_getWidthRPC_helper::s_prototype);
12031 }
12032 if (functionName == FrameGrabberMsgs_getImageRPC_helper::s_tag) {
12033 helpString.emplace_back(FrameGrabberMsgs_getImageRPC_helper::s_prototype);
12034 }
12037 }
12040 }
12043 }
12046 }
12049 }
12052 }
12053 if (functionName == FrameGrabberMsgs_getRgbFOVRPC_helper::s_tag) {
12055 }
12056 if (functionName == FrameGrabberMsgs_setRgbFOVRPC_helper::s_tag) {
12058 }
12061 }
12064 }
12067 }
12070 }
12073 }
12076 }
12079 }
12082 }
12085 }
12086 if (functionName == FrameGrabberMsgs_hasOnOffRPC_helper::s_tag) {
12087 helpString.emplace_back(FrameGrabberMsgs_hasOnOffRPC_helper::s_prototype);
12088 }
12089 if (functionName == FrameGrabberMsgs_setActiveRPC_helper::s_tag) {
12091 }
12092 if (functionName == FrameGrabberMsgs_getActiveRPC_helper::s_tag) {
12094 }
12095 if (functionName == FrameGrabberMsgs_hasAutoRPC_helper::s_tag) {
12096 helpString.emplace_back(FrameGrabberMsgs_hasAutoRPC_helper::s_prototype);
12097 }
12098 if (functionName == FrameGrabberMsgs_hasManualRPC_helper::s_tag) {
12100 }
12103 }
12104 if (functionName == FrameGrabberMsgs_setModeRPC_helper::s_tag) {
12105 helpString.emplace_back(FrameGrabberMsgs_setModeRPC_helper::s_prototype);
12106 }
12107 if (functionName == FrameGrabberMsgs_getModeRPC_helper::s_tag) {
12108 helpString.emplace_back(FrameGrabberMsgs_getModeRPC_helper::s_prototype);
12109 }
12112 }
12115 }
12118 }
12121 }
12124 }
12127 }
12130 }
12133 }
12136 }
12139 }
12142 }
12145 }
12148 }
12151 }
12154 }
12157 }
12160 }
12163 }
12166 }
12169 }
12172 }
12175 }
12178 }
12181 }
12184 }
12187 }
12188 if (functionName == "help") {
12189 helpString.emplace_back("std::vector<std::string> help(const std::string& functionName = \"--all\")");
12190 helpString.emplace_back("Return list of available commands, or help message for a specific function");
12191 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");
12192 helpString.emplace_back("@return list of strings (one string per line)");
12193 }
12194 }
12195 if (helpString.empty()) {
12196 helpString.emplace_back("Command not found");
12197 }
12198 return helpString;
12199}
12200
12201// read from ConnectionReader
12203{
12204 constexpr size_t max_tag_len = 1;
12205 size_t tag_len = 1;
12206
12207 yarp::os::idl::WireReader reader(connection);
12208 reader.expectAccept();
12209 if (!reader.readListHeader()) {
12210 reader.fail();
12211 return false;
12212 }
12213
12214 std::string tag = reader.readTag(1);
12215 bool direct = (tag == "__direct__");
12216 if (direct) {
12217 tag = reader.readTag(1);
12218 }
12219 while (tag_len <= max_tag_len && !reader.isError()) {
12220 if(tag == "getRemoteProtocolVersion") {
12221 if (!reader.noMore()) {
12222 yError("Reader invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
12223 reader.fail();
12224 return false;
12225 }
12226
12227 auto proto = getLocalProtocolVersion();
12228
12229 yarp::os::idl::WireWriter writer(reader);
12230 if (!writer.writeListHeader(1)) {
12231 yWarning("Writer invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
12232 return false;}
12233 if (!writer.write(proto)) {
12234 yWarning("Writer invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
12235 return false;
12236 }
12237 reader.accept();
12238 return true;
12239 }
12242 if (!helper.cmd.readArgs(reader)) {
12243 return false;
12244 }
12245
12246 helper.call(this);
12247
12248 yarp::os::idl::WireWriter writer(reader);
12249 if (!helper.reply.write(writer)) {
12250 return false;
12251 }
12252 reader.accept();
12253 return true;
12254 }
12257 if (!helper.cmd.readArgs(reader)) {
12258 return false;
12259 }
12260
12261 helper.call(this);
12262
12263 yarp::os::idl::WireWriter writer(reader);
12264 if (!helper.reply.write(writer)) {
12265 return false;
12266 }
12267 reader.accept();
12268 return true;
12269 }
12272 if (!helper.cmd.readArgs(reader)) {
12273 return false;
12274 }
12275
12276 helper.call(this);
12277
12278 yarp::os::idl::WireWriter writer(reader);
12279 if (!helper.reply.write(writer)) {
12280 return false;
12281 }
12282 reader.accept();
12283 return true;
12284 }
12287 if (!helper.cmd.readArgs(reader)) {
12288 return false;
12289 }
12290
12291 helper.call(this);
12292
12293 yarp::os::idl::WireWriter writer(reader);
12294 if (!helper.reply.write(writer)) {
12295 return false;
12296 }
12297 reader.accept();
12298 return true;
12299 }
12302 if (!helper.cmd.readArgs(reader)) {
12303 return false;
12304 }
12305
12306 helper.call(this);
12307
12308 yarp::os::idl::WireWriter writer(reader);
12309 if (!helper.reply.write(writer)) {
12310 return false;
12311 }
12312 reader.accept();
12313 return true;
12314 }
12317 if (!helper.cmd.readArgs(reader)) {
12318 return false;
12319 }
12320
12321 helper.call(this);
12322
12323 yarp::os::idl::WireWriter writer(reader);
12324 if (!helper.reply.write(writer)) {
12325 return false;
12326 }
12327 reader.accept();
12328 return true;
12329 }
12332 if (!helper.cmd.readArgs(reader)) {
12333 return false;
12334 }
12335
12336 helper.call(this);
12337
12338 yarp::os::idl::WireWriter writer(reader);
12339 if (!helper.reply.write(writer)) {
12340 return false;
12341 }
12342 reader.accept();
12343 return true;
12344 }
12347 if (!helper.cmd.readArgs(reader)) {
12348 return false;
12349 }
12350
12351 helper.call(this);
12352
12353 yarp::os::idl::WireWriter writer(reader);
12354 if (!helper.reply.write(writer)) {
12355 return false;
12356 }
12357 reader.accept();
12358 return true;
12359 }
12362 if (!helper.cmd.readArgs(reader)) {
12363 return false;
12364 }
12365
12366 helper.call(this);
12367
12368 yarp::os::idl::WireWriter writer(reader);
12369 if (!helper.reply.write(writer)) {
12370 return false;
12371 }
12372 reader.accept();
12373 return true;
12374 }
12377 if (!helper.cmd.readArgs(reader)) {
12378 return false;
12379 }
12380
12381 helper.call(this);
12382
12383 yarp::os::idl::WireWriter writer(reader);
12384 if (!helper.reply.write(writer)) {
12385 return false;
12386 }
12387 reader.accept();
12388 return true;
12389 }
12392 if (!helper.cmd.readArgs(reader)) {
12393 return false;
12394 }
12395
12396 helper.call(this);
12397
12398 yarp::os::idl::WireWriter writer(reader);
12399 if (!helper.reply.write(writer)) {
12400 return false;
12401 }
12402 reader.accept();
12403 return true;
12404 }
12407 if (!helper.cmd.readArgs(reader)) {
12408 return false;
12409 }
12410
12411 helper.call(this);
12412
12413 yarp::os::idl::WireWriter writer(reader);
12414 if (!helper.reply.write(writer)) {
12415 return false;
12416 }
12417 reader.accept();
12418 return true;
12419 }
12422 if (!helper.cmd.readArgs(reader)) {
12423 return false;
12424 }
12425
12426 helper.call(this);
12427
12428 yarp::os::idl::WireWriter writer(reader);
12429 if (!helper.reply.write(writer)) {
12430 return false;
12431 }
12432 reader.accept();
12433 return true;
12434 }
12437 if (!helper.cmd.readArgs(reader)) {
12438 return false;
12439 }
12440
12441 helper.call(this);
12442
12443 yarp::os::idl::WireWriter writer(reader);
12444 if (!helper.reply.write(writer)) {
12445 return false;
12446 }
12447 reader.accept();
12448 return true;
12449 }
12452 if (!helper.cmd.readArgs(reader)) {
12453 return false;
12454 }
12455
12456 helper.call(this);
12457
12458 yarp::os::idl::WireWriter writer(reader);
12459 if (!helper.reply.write(writer)) {
12460 return false;
12461 }
12462 reader.accept();
12463 return true;
12464 }
12467 if (!helper.cmd.readArgs(reader)) {
12468 return false;
12469 }
12470
12471 helper.call(this);
12472
12473 yarp::os::idl::WireWriter writer(reader);
12474 if (!helper.reply.write(writer)) {
12475 return false;
12476 }
12477 reader.accept();
12478 return true;
12479 }
12482 if (!helper.cmd.readArgs(reader)) {
12483 return false;
12484 }
12485
12486 helper.call(this);
12487
12488 yarp::os::idl::WireWriter writer(reader);
12489 if (!helper.reply.write(writer)) {
12490 return false;
12491 }
12492 reader.accept();
12493 return true;
12494 }
12497 if (!helper.cmd.readArgs(reader)) {
12498 return false;
12499 }
12500
12501 helper.call(this);
12502
12503 yarp::os::idl::WireWriter writer(reader);
12504 if (!helper.reply.write(writer)) {
12505 return false;
12506 }
12507 reader.accept();
12508 return true;
12509 }
12512 if (!helper.cmd.readArgs(reader)) {
12513 return false;
12514 }
12515
12516 helper.call(this);
12517
12518 yarp::os::idl::WireWriter writer(reader);
12519 if (!helper.reply.write(writer)) {
12520 return false;
12521 }
12522 reader.accept();
12523 return true;
12524 }
12527 if (!helper.cmd.readArgs(reader)) {
12528 return false;
12529 }
12530
12531 helper.call(this);
12532
12533 yarp::os::idl::WireWriter writer(reader);
12534 if (!helper.reply.write(writer)) {
12535 return false;
12536 }
12537 reader.accept();
12538 return true;
12539 }
12542 if (!helper.cmd.readArgs(reader)) {
12543 return false;
12544 }
12545
12546 helper.call(this);
12547
12548 yarp::os::idl::WireWriter writer(reader);
12549 if (!helper.reply.write(writer)) {
12550 return false;
12551 }
12552 reader.accept();
12553 return true;
12554 }
12557 if (!helper.cmd.readArgs(reader)) {
12558 return false;
12559 }
12560
12561 helper.call(this);
12562
12563 yarp::os::idl::WireWriter writer(reader);
12564 if (!helper.reply.write(writer)) {
12565 return false;
12566 }
12567 reader.accept();
12568 return true;
12569 }
12572 if (!helper.cmd.readArgs(reader)) {
12573 return false;
12574 }
12575
12576 helper.call(this);
12577
12578 yarp::os::idl::WireWriter writer(reader);
12579 if (!helper.reply.write(writer)) {
12580 return false;
12581 }
12582 reader.accept();
12583 return true;
12584 }
12587 if (!helper.cmd.readArgs(reader)) {
12588 return false;
12589 }
12590
12591 helper.call(this);
12592
12593 yarp::os::idl::WireWriter writer(reader);
12594 if (!helper.reply.write(writer)) {
12595 return false;
12596 }
12597 reader.accept();
12598 return true;
12599 }
12602 if (!helper.cmd.readArgs(reader)) {
12603 return false;
12604 }
12605
12606 helper.call(this);
12607
12608 yarp::os::idl::WireWriter writer(reader);
12609 if (!helper.reply.write(writer)) {
12610 return false;
12611 }
12612 reader.accept();
12613 return true;
12614 }
12617 if (!helper.cmd.readArgs(reader)) {
12618 return false;
12619 }
12620
12621 helper.call(this);
12622
12623 yarp::os::idl::WireWriter writer(reader);
12624 if (!helper.reply.write(writer)) {
12625 return false;
12626 }
12627 reader.accept();
12628 return true;
12629 }
12632 if (!helper.cmd.readArgs(reader)) {
12633 return false;
12634 }
12635
12636 helper.call(this);
12637
12638 yarp::os::idl::WireWriter writer(reader);
12639 if (!helper.reply.write(writer)) {
12640 return false;
12641 }
12642 reader.accept();
12643 return true;
12644 }
12647 if (!helper.cmd.readArgs(reader)) {
12648 return false;
12649 }
12650
12651 helper.call(this);
12652
12653 yarp::os::idl::WireWriter writer(reader);
12654 if (!helper.reply.write(writer)) {
12655 return false;
12656 }
12657 reader.accept();
12658 return true;
12659 }
12662 if (!helper.cmd.readArgs(reader)) {
12663 return false;
12664 }
12665
12666 helper.call(this);
12667
12668 yarp::os::idl::WireWriter writer(reader);
12669 if (!helper.reply.write(writer)) {
12670 return false;
12671 }
12672 reader.accept();
12673 return true;
12674 }
12677 if (!helper.cmd.readArgs(reader)) {
12678 return false;
12679 }
12680
12681 helper.call(this);
12682
12683 yarp::os::idl::WireWriter writer(reader);
12684 if (!helper.reply.write(writer)) {
12685 return false;
12686 }
12687 reader.accept();
12688 return true;
12689 }
12692 if (!helper.cmd.readArgs(reader)) {
12693 return false;
12694 }
12695
12696 helper.call(this);
12697
12698 yarp::os::idl::WireWriter writer(reader);
12699 if (!helper.reply.write(writer)) {
12700 return false;
12701 }
12702 reader.accept();
12703 return true;
12704 }
12707 if (!helper.cmd.readArgs(reader)) {
12708 return false;
12709 }
12710
12711 helper.call(this);
12712
12713 yarp::os::idl::WireWriter writer(reader);
12714 if (!helper.reply.write(writer)) {
12715 return false;
12716 }
12717 reader.accept();
12718 return true;
12719 }
12722 if (!helper.cmd.readArgs(reader)) {
12723 return false;
12724 }
12725
12726 helper.call(this);
12727
12728 yarp::os::idl::WireWriter writer(reader);
12729 if (!helper.reply.write(writer)) {
12730 return false;
12731 }
12732 reader.accept();
12733 return true;
12734 }
12737 if (!helper.cmd.readArgs(reader)) {
12738 return false;
12739 }
12740
12741 helper.call(this);
12742
12743 yarp::os::idl::WireWriter writer(reader);
12744 if (!helper.reply.write(writer)) {
12745 return false;
12746 }
12747 reader.accept();
12748 return true;
12749 }
12752 if (!helper.cmd.readArgs(reader)) {
12753 return false;
12754 }
12755
12756 helper.call(this);
12757
12758 yarp::os::idl::WireWriter writer(reader);
12759 if (!helper.reply.write(writer)) {
12760 return false;
12761 }
12762 reader.accept();
12763 return true;
12764 }
12767 if (!helper.cmd.readArgs(reader)) {
12768 return false;
12769 }
12770
12771 helper.call(this);
12772
12773 yarp::os::idl::WireWriter writer(reader);
12774 if (!helper.reply.write(writer)) {
12775 return false;
12776 }
12777 reader.accept();
12778 return true;
12779 }
12782 if (!helper.cmd.readArgs(reader)) {
12783 return false;
12784 }
12785
12786 helper.call(this);
12787
12788 yarp::os::idl::WireWriter writer(reader);
12789 if (!helper.reply.write(writer)) {
12790 return false;
12791 }
12792 reader.accept();
12793 return true;
12794 }
12797 if (!helper.cmd.readArgs(reader)) {
12798 return false;
12799 }
12800
12801 helper.call(this);
12802
12803 yarp::os::idl::WireWriter writer(reader);
12804 if (!helper.reply.write(writer)) {
12805 return false;
12806 }
12807 reader.accept();
12808 return true;
12809 }
12812 if (!helper.cmd.readArgs(reader)) {
12813 return false;
12814 }
12815
12816 helper.call(this);
12817
12818 yarp::os::idl::WireWriter writer(reader);
12819 if (!helper.reply.write(writer)) {
12820 return false;
12821 }
12822 reader.accept();
12823 return true;
12824 }
12827 if (!helper.cmd.readArgs(reader)) {
12828 return false;
12829 }
12830
12831 helper.call(this);
12832
12833 yarp::os::idl::WireWriter writer(reader);
12834 if (!helper.reply.write(writer)) {
12835 return false;
12836 }
12837 reader.accept();
12838 return true;
12839 }
12842 if (!helper.cmd.readArgs(reader)) {
12843 return false;
12844 }
12845
12846 helper.call(this);
12847
12848 yarp::os::idl::WireWriter writer(reader);
12849 if (!helper.reply.write(writer)) {
12850 return false;
12851 }
12852 reader.accept();
12853 return true;
12854 }
12857 if (!helper.cmd.readArgs(reader)) {
12858 return false;
12859 }
12860
12861 helper.call(this);
12862
12863 yarp::os::idl::WireWriter writer(reader);
12864 if (!helper.reply.write(writer)) {
12865 return false;
12866 }
12867 reader.accept();
12868 return true;
12869 }
12872 if (!helper.cmd.readArgs(reader)) {
12873 return false;
12874 }
12875
12876 helper.call(this);
12877
12878 yarp::os::idl::WireWriter writer(reader);
12879 if (!helper.reply.write(writer)) {
12880 return false;
12881 }
12882 reader.accept();
12883 return true;
12884 }
12887 if (!helper.cmd.readArgs(reader)) {
12888 return false;
12889 }
12890
12891 helper.call(this);
12892
12893 yarp::os::idl::WireWriter writer(reader);
12894 if (!helper.reply.write(writer)) {
12895 return false;
12896 }
12897 reader.accept();
12898 return true;
12899 }
12902 if (!helper.cmd.readArgs(reader)) {
12903 return false;
12904 }
12905
12906 helper.call(this);
12907
12908 yarp::os::idl::WireWriter writer(reader);
12909 if (!helper.reply.write(writer)) {
12910 return false;
12911 }
12912 reader.accept();
12913 return true;
12914 }
12917 if (!helper.cmd.readArgs(reader)) {
12918 return false;
12919 }
12920
12921 helper.call(this);
12922
12923 yarp::os::idl::WireWriter writer(reader);
12924 if (!helper.reply.write(writer)) {
12925 return false;
12926 }
12927 reader.accept();
12928 return true;
12929 }
12932 if (!helper.cmd.readArgs(reader)) {
12933 return false;
12934 }
12935
12936 helper.call(this);
12937
12938 yarp::os::idl::WireWriter writer(reader);
12939 if (!helper.reply.write(writer)) {
12940 return false;
12941 }
12942 reader.accept();
12943 return true;
12944 }
12947 if (!helper.cmd.readArgs(reader)) {
12948 return false;
12949 }
12950
12951 helper.call(this);
12952
12953 yarp::os::idl::WireWriter writer(reader);
12954 if (!helper.reply.write(writer)) {
12955 return false;
12956 }
12957 reader.accept();
12958 return true;
12959 }
12962 if (!helper.cmd.readArgs(reader)) {
12963 return false;
12964 }
12965
12966 helper.call(this);
12967
12968 yarp::os::idl::WireWriter writer(reader);
12969 if (!helper.reply.write(writer)) {
12970 return false;
12971 }
12972 reader.accept();
12973 return true;
12974 }
12977 if (!helper.cmd.readArgs(reader)) {
12978 return false;
12979 }
12980
12981 helper.call(this);
12982
12983 yarp::os::idl::WireWriter writer(reader);
12984 if (!helper.reply.write(writer)) {
12985 return false;
12986 }
12987 reader.accept();
12988 return true;
12989 }
12992 if (!helper.cmd.readArgs(reader)) {
12993 return false;
12994 }
12995
12996 helper.call(this);
12997
12998 yarp::os::idl::WireWriter writer(reader);
12999 if (!helper.reply.write(writer)) {
13000 return false;
13001 }
13002 reader.accept();
13003 return true;
13004 }
13007 if (!helper.cmd.readArgs(reader)) {
13008 return false;
13009 }
13010
13011 helper.call(this);
13012
13013 yarp::os::idl::WireWriter writer(reader);
13014 if (!helper.reply.write(writer)) {
13015 return false;
13016 }
13017 reader.accept();
13018 return true;
13019 }
13022 if (!helper.cmd.readArgs(reader)) {
13023 return false;
13024 }
13025
13026 helper.call(this);
13027
13028 yarp::os::idl::WireWriter writer(reader);
13029 if (!helper.reply.write(writer)) {
13030 return false;
13031 }
13032 reader.accept();
13033 return true;
13034 }
13037 if (!helper.cmd.readArgs(reader)) {
13038 return false;
13039 }
13040
13041 helper.call(this);
13042
13043 yarp::os::idl::WireWriter writer(reader);
13044 if (!helper.reply.write(writer)) {
13045 return false;
13046 }
13047 reader.accept();
13048 return true;
13049 }
13050 if (tag == "help") {
13051 std::string functionName;
13052 if (!reader.readString(functionName)) {
13053 functionName = "--all";
13054 }
13055 auto help_strings = help(functionName);
13056 yarp::os::idl::WireWriter writer(reader);
13057 if (!writer.isNull()) {
13058 if (!writer.writeListHeader(2)) {
13059 return false;
13060 }
13061 if (!writer.writeTag("many", 1, 0)) {
13062 return false;
13063 }
13064 if (!writer.writeListBegin(0, help_strings.size())) {
13065 return false;
13066 }
13067 for (const auto& help_string : help_strings) {
13068 if (!writer.writeString(help_string)) {
13069 return false;
13070 }
13071 }
13072 if (!writer.writeListEnd()) {
13073 return false;
13074 }
13075 }
13076 reader.accept();
13077 return true;
13078 }
13079 if (reader.noMore()) {
13080 reader.fail();
13081 return false;
13082 }
13083 std::string next_tag = reader.readTag(1);
13084 if (next_tag.empty()) {
13085 break;
13086 }
13087 tag.append("_").append(next_tag);
13088 tag_len = std::count(tag.begin(), tag.end(), '_') + 1;
13089 }
13090 return false;
13091}
#define BOTTLE_TAG_LIST
Definition Bottle.h:29
FeatureMode mode
#define yError(...)
Definition Log.h:361
#define __YFUNCTION__
Definition Log.h:24
#define yWarning(...)
Definition Log.h:340
bool readTag(yarp::os::idl::WireReader &reader)
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool readArgs(yarp::os::idl::WireReader &reader)
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
IFrameGrabberControlMsgs_return_getActive return_helper
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_tag
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_prototype
IFrameGrabberControlMsgs_return_getActive(*)(const std::int32_t) funcptr_t
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_help
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
IFrameGrabberControlDC1394Msgs_return_getBytesPerPacketDC1394 return_helper
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
IFrameGrabberControlDC1394Msgs_return_getBytesPerPacketDC1394(*)() funcptr_t
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
IFrameGrabberControlMsgs_return_getCameraDescription return_helper
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
IFrameGrabberControlMsgs_return_getCameraDescription(*)() funcptr_t
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
IFrameGrabberControlDC1394Msgs_return_getColorCodingDC1394 return_helper
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
IFrameGrabberControlDC1394Msgs_return_getColorCodingDC1394(*)() funcptr_t
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
IFrameGrabberControlDC1394Msgs_return_getColorCodingMaskDC1394 return_helper
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
IFrameGrabberControlDC1394Msgs_return_getColorCodingMaskDC1394(*)(const std::int32_t) funcptr_t
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool readTag(yarp::os::idl::WireReader &reader)
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool readArgs(yarp::os::idl::WireReader &reader)
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
IFrameGrabberControlDC1394Msgs_return_getFPSDC1394 return_helper
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
IFrameGrabberControlDC1394Msgs_return_getFPSDC1394(*)() funcptr_t
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_prototype
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool readTag(yarp::os::idl::WireReader &reader)
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool readArgs(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
IFrameGrabberControlDC1394Msgs_return_getFPSMaskDC1394 return_helper
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
IFrameGrabberControlDC1394Msgs_return_getFPSMaskDC1394(*)() funcptr_t
bool readTag(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool readArgs(yarp::os::idl::WireReader &reader)
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
IFrameGrabberControlMsgs_return_getFeature1 return_helper
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
IFrameGrabberControlMsgs_return_getFeature1(*)(const std::int32_t) funcptr_t
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_prototype
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool readArgs(yarp::os::idl::WireReader &reader)
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool readTag(yarp::os::idl::WireReader &reader)
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
IFrameGrabberControlMsgs_return_getFeature2 return_helper
IFrameGrabberControlMsgs_return_getFeature2(*)(const std::int32_t) funcptr_t
static constexpr const char * s_prototype
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
IFrameGrabberControlDC1394Msgs_return_getFormat7MaxWindowDC1394 return_helper
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
IFrameGrabberControlDC1394Msgs_return_getFormat7MaxWindowDC1394(*)() funcptr_t
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
IFrameGrabberControlDC1394Msgs_return_getFormat7WindowDC1394 return_helper
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
IFrameGrabberControlDC1394Msgs_return_getFormat7WindowDC1394(*)() funcptr_t
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool readTag(yarp::os::idl::WireReader &reader)
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool readArgs(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
IFrameGrabberImageOf_return_getHeight return_helper
static constexpr const char * s_help
static constexpr const char * s_tag
static constexpr const char * s_prototype
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
IFrameGrabberImageOf_return_getHeight(*)() funcptr_t
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool readTag(yarp::os::idl::WireReader &reader)
bool readArgs(yarp::os::idl::WireReader &reader)
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
IFrameGrabberControlDC1394Msgs_return_getISOSpeedDC1394 return_helper
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
IFrameGrabberControlDC1394Msgs_return_getISOSpeedDC1394(*)() funcptr_t
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool readTag(yarp::os::idl::WireReader &reader)
bool readArgs(yarp::os::idl::WireReader &reader)
std::vector< yarp::dev::VertexData > vertices
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.
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.
IFrameGrabberImageOf_return_getImageCrop(*)(const yarp::dev::cropType_id_t, const std::vector< yarp::dev::VertexData > &) 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 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 IFrameGrabberImageOf_return_getImageCrop getImageCropRPC(const yarp::dev::cropType_id_t type, const std::vector< yarp::dev::VertexData > &vertices)
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 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)
@ return_value_error_nws_nwc_communication_error
Method is not (yet) implemented.
An interface for reading from a network connection.
An interface for writing to a network connection.
This is a base class for objects that can be both read from and be written to the YARP network.
Definition Portable.h:25
yarp::os::WireLink & yarp()
Get YARP state associated with this object.
Definition Wire.h:28
A "tamed" Portable, that promises to serialize itself in an IDL-friendly way.
IDL-friendly connection reader.
Definition WireReader.h:27
bool 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