YARP
Yet Another Robot Platform
 
Loading...
Searching...
No Matches
IRangefinder2DMsgs.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 <IRangefinder2DMsgs.h>
15#include <yarp/os/LogStream.h>
16
18
19#include <algorithm>
20
21namespace
22{
23 YARP_LOG_COMPONENT(SERVICE_LOG_COMPONENT, "IRangefinder2DMsgs")
24}
25
26//IRangefinder2DMsgs_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 IRangefinder2DMsgs_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 IRangefinder2DMsgs::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// getDeviceStatus_RPC 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(IRangefinder2DMsgs* ptr);
155
158
159 static constexpr const char* s_tag{"getDeviceStatus_RPC"};
160 static constexpr size_t s_tag_len{2};
161 static constexpr size_t s_cmd_len{2};
162 static constexpr size_t s_reply_len{2};
163 static constexpr const char* s_prototype{"return_getDeviceStatus IRangefinder2DMsgs::getDeviceStatus_RPC()"};
164 static constexpr const char* s_help{""};
165};
166
167// getDistanceRange_RPC 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(IRangefinder2DMsgs* ptr);
213
216
217 static constexpr const char* s_tag{"getDistanceRange_RPC"};
218 static constexpr size_t s_tag_len{2};
219 static constexpr size_t s_cmd_len{2};
220 static constexpr size_t s_reply_len{3};
221 static constexpr const char* s_prototype{"return_getDistanceRange IRangefinder2DMsgs::getDistanceRange_RPC()"};
222 static constexpr const char* s_help{""};
223};
224
225// getScanLimits_RPC 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(IRangefinder2DMsgs* ptr);
271
274
275 static constexpr const char* s_tag{"getScanLimits_RPC"};
276 static constexpr size_t s_tag_len{2};
277 static constexpr size_t s_cmd_len{2};
278 static constexpr size_t s_reply_len{3};
279 static constexpr const char* s_prototype{"return_getScanLimits IRangefinder2DMsgs::getScanLimits_RPC()"};
280 static constexpr const char* s_help{""};
281};
282
283// getHorizontalResolution_RPC helper class declaration
285 public yarp::os::Portable
286{
287public:
289 bool write(yarp::os::ConnectionWriter& connection) const override;
290 bool read(yarp::os::ConnectionReader& connection) override;
291
292 class Command :
294 {
295 public:
296 Command() = default;
297 ~Command() override = default;
298
299 bool write(yarp::os::ConnectionWriter& connection) const override;
300 bool read(yarp::os::ConnectionReader& connection) override;
301
302 bool write(const yarp::os::idl::WireWriter& writer) const override;
303 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
304 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
305
306 bool read(yarp::os::idl::WireReader& reader) override;
309 };
310
311 class Reply :
313 {
314 public:
315 Reply() = default;
316 ~Reply() override = default;
317
318 bool write(yarp::os::ConnectionWriter& connection) const override;
319 bool read(yarp::os::ConnectionReader& connection) override;
320
321 bool write(const yarp::os::idl::WireWriter& writer) const override;
322 bool read(yarp::os::idl::WireReader& reader) override;
323
325 };
326
328 void call(IRangefinder2DMsgs* ptr);
329
332
333 static constexpr const char* s_tag{"getHorizontalResolution_RPC"};
334 static constexpr size_t s_tag_len{2};
335 static constexpr size_t s_cmd_len{2};
336 static constexpr size_t s_reply_len{2};
337 static constexpr const char* s_prototype{"return_getHorizontalResolution IRangefinder2DMsgs::getHorizontalResolution_RPC()"};
338 static constexpr const char* s_help{""};
339};
340
341// getScanRate_RPC helper class declaration
343 public yarp::os::Portable
344{
345public:
347 bool write(yarp::os::ConnectionWriter& connection) const override;
348 bool read(yarp::os::ConnectionReader& connection) override;
349
350 class Command :
352 {
353 public:
354 Command() = default;
355 ~Command() override = default;
356
357 bool write(yarp::os::ConnectionWriter& connection) const override;
358 bool read(yarp::os::ConnectionReader& connection) override;
359
360 bool write(const yarp::os::idl::WireWriter& writer) const override;
361 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
362 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
363
364 bool read(yarp::os::idl::WireReader& reader) override;
367 };
368
369 class Reply :
371 {
372 public:
373 Reply() = default;
374 ~Reply() override = default;
375
376 bool write(yarp::os::ConnectionWriter& connection) const override;
377 bool read(yarp::os::ConnectionReader& connection) override;
378
379 bool write(const yarp::os::idl::WireWriter& writer) const override;
380 bool read(yarp::os::idl::WireReader& reader) override;
381
383 };
384
386 void call(IRangefinder2DMsgs* ptr);
387
390
391 static constexpr const char* s_tag{"getScanRate_RPC"};
392 static constexpr size_t s_tag_len{2};
393 static constexpr size_t s_cmd_len{2};
394 static constexpr size_t s_reply_len{2};
395 static constexpr const char* s_prototype{"return_getScanRate IRangefinder2DMsgs::getScanRate_RPC()"};
396 static constexpr const char* s_help{""};
397};
398
399// getDeviceInfo_RPC helper class declaration
401 public yarp::os::Portable
402{
403public:
405 bool write(yarp::os::ConnectionWriter& connection) const override;
406 bool read(yarp::os::ConnectionReader& connection) override;
407
408 class Command :
410 {
411 public:
412 Command() = default;
413 ~Command() override = default;
414
415 bool write(yarp::os::ConnectionWriter& connection) const override;
416 bool read(yarp::os::ConnectionReader& connection) override;
417
418 bool write(const yarp::os::idl::WireWriter& writer) const override;
419 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
420 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
421
422 bool read(yarp::os::idl::WireReader& reader) override;
425 };
426
427 class Reply :
429 {
430 public:
431 Reply() = default;
432 ~Reply() override = default;
433
434 bool write(yarp::os::ConnectionWriter& connection) const override;
435 bool read(yarp::os::ConnectionReader& connection) override;
436
437 bool write(const yarp::os::idl::WireWriter& writer) const override;
438 bool read(yarp::os::idl::WireReader& reader) override;
439
441 };
442
444 void call(IRangefinder2DMsgs* ptr);
445
448
449 static constexpr const char* s_tag{"getDeviceInfo_RPC"};
450 static constexpr size_t s_tag_len{2};
451 static constexpr size_t s_cmd_len{2};
452 static constexpr size_t s_reply_len{2};
453 static constexpr const char* s_prototype{"return_getDeviceInfo IRangefinder2DMsgs::getDeviceInfo_RPC()"};
454 static constexpr const char* s_help{""};
455};
456
457// setDistanceRange_RPC helper class declaration
459 public yarp::os::Portable
460{
461public:
463 IRangefinder2DMsgs_setDistanceRange_RPC_helper(const double min, const double max);
464 bool write(yarp::os::ConnectionWriter& connection) const override;
465 bool read(yarp::os::ConnectionReader& connection) override;
466
467 class Command :
469 {
470 public:
471 Command() = default;
472 Command(const double min, const double max);
473
474 ~Command() override = default;
475
476 bool write(yarp::os::ConnectionWriter& connection) const override;
477 bool read(yarp::os::ConnectionReader& connection) override;
478
479 bool write(const yarp::os::idl::WireWriter& writer) const override;
480 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
481 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
482
483 bool read(yarp::os::idl::WireReader& reader) override;
486
487 double min{0.0};
488 double max{0.0};
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
507 using funcptr_t = yarp::dev::ReturnValue (*)(const double, const double);
508 void call(IRangefinder2DMsgs* ptr);
509
512
513 static constexpr const char* s_tag{"setDistanceRange_RPC"};
514 static constexpr size_t s_tag_len{2};
515 static constexpr size_t s_cmd_len{4};
516 static constexpr size_t s_reply_len{1};
517 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IRangefinder2DMsgs::setDistanceRange_RPC(const double min, const double max)"};
518 static constexpr const char* s_help{""};
519};
520
521// setScanLimits_RPC helper class declaration
523 public yarp::os::Portable
524{
525public:
527 IRangefinder2DMsgs_setScanLimits_RPC_helper(const double min, const double max);
528 bool write(yarp::os::ConnectionWriter& connection) const override;
529 bool read(yarp::os::ConnectionReader& connection) override;
530
531 class Command :
533 {
534 public:
535 Command() = default;
536 Command(const double min, const double max);
537
538 ~Command() override = default;
539
540 bool write(yarp::os::ConnectionWriter& connection) const override;
541 bool read(yarp::os::ConnectionReader& connection) override;
542
543 bool write(const yarp::os::idl::WireWriter& writer) const override;
544 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
545 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
546
547 bool read(yarp::os::idl::WireReader& reader) override;
550
551 double min{0.0};
552 double max{0.0};
553 };
554
555 class Reply :
557 {
558 public:
559 Reply() = default;
560 ~Reply() override = default;
561
562 bool write(yarp::os::ConnectionWriter& connection) const override;
563 bool read(yarp::os::ConnectionReader& connection) override;
564
565 bool write(const yarp::os::idl::WireWriter& writer) const override;
566 bool read(yarp::os::idl::WireReader& reader) override;
567
569 };
570
571 using funcptr_t = yarp::dev::ReturnValue (*)(const double, const double);
572 void call(IRangefinder2DMsgs* ptr);
573
576
577 static constexpr const char* s_tag{"setScanLimits_RPC"};
578 static constexpr size_t s_tag_len{2};
579 static constexpr size_t s_cmd_len{4};
580 static constexpr size_t s_reply_len{1};
581 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IRangefinder2DMsgs::setScanLimits_RPC(const double min, const double max)"};
582 static constexpr const char* s_help{""};
583};
584
585// setHorizontalResolution_RPC helper class declaration
587 public yarp::os::Portable
588{
589public:
592 bool write(yarp::os::ConnectionWriter& connection) const override;
593 bool read(yarp::os::ConnectionReader& connection) override;
594
595 class Command :
597 {
598 public:
599 Command() = default;
600 explicit Command(const double step);
601
602 ~Command() override = default;
603
604 bool write(yarp::os::ConnectionWriter& connection) const override;
605 bool read(yarp::os::ConnectionReader& connection) override;
606
607 bool write(const yarp::os::idl::WireWriter& writer) const override;
608 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
609 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
610
611 bool read(yarp::os::idl::WireReader& reader) override;
614
615 double step{0.0};
616 };
617
618 class Reply :
620 {
621 public:
622 Reply() = default;
623 ~Reply() override = default;
624
625 bool write(yarp::os::ConnectionWriter& connection) const override;
626 bool read(yarp::os::ConnectionReader& connection) override;
627
628 bool write(const yarp::os::idl::WireWriter& writer) const override;
629 bool read(yarp::os::idl::WireReader& reader) override;
630
632 };
633
634 using funcptr_t = yarp::dev::ReturnValue (*)(const double);
635 void call(IRangefinder2DMsgs* ptr);
636
639
640 static constexpr const char* s_tag{"setHorizontalResolution_RPC"};
641 static constexpr size_t s_tag_len{2};
642 static constexpr size_t s_cmd_len{3};
643 static constexpr size_t s_reply_len{1};
644 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IRangefinder2DMsgs::setHorizontalResolution_RPC(const double step)"};
645 static constexpr const char* s_help{""};
646};
647
648// setScanRate_RPC helper class declaration
650 public yarp::os::Portable
651{
652public:
654 explicit IRangefinder2DMsgs_setScanRate_RPC_helper(const double rate);
655 bool write(yarp::os::ConnectionWriter& connection) const override;
656 bool read(yarp::os::ConnectionReader& connection) override;
657
658 class Command :
660 {
661 public:
662 Command() = default;
663 explicit Command(const double rate);
664
665 ~Command() override = default;
666
667 bool write(yarp::os::ConnectionWriter& connection) const override;
668 bool read(yarp::os::ConnectionReader& connection) override;
669
670 bool write(const yarp::os::idl::WireWriter& writer) const override;
671 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
672 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
673
674 bool read(yarp::os::idl::WireReader& reader) override;
677
678 double rate{0.0};
679 };
680
681 class Reply :
683 {
684 public:
685 Reply() = default;
686 ~Reply() override = default;
687
688 bool write(yarp::os::ConnectionWriter& connection) const override;
689 bool read(yarp::os::ConnectionReader& connection) override;
690
691 bool write(const yarp::os::idl::WireWriter& writer) const override;
692 bool read(yarp::os::idl::WireReader& reader) override;
693
695 };
696
697 using funcptr_t = yarp::dev::ReturnValue (*)(const double);
698 void call(IRangefinder2DMsgs* ptr);
699
702
703 static constexpr const char* s_tag{"setScanRate_RPC"};
704 static constexpr size_t s_tag_len{2};
705 static constexpr size_t s_cmd_len{3};
706 static constexpr size_t s_reply_len{1};
707 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IRangefinder2DMsgs::setScanRate_RPC(const double rate)"};
708 static constexpr const char* s_help{""};
709};
710
711// getDeviceStatus_RPC helper class implementation
713{
714 return cmd.write(connection);
715}
716
721
723{
724 yarp::os::idl::WireWriter writer(connection);
725 if (!writer.writeListHeader(s_cmd_len)) {
726 return false;
727 }
728 return write(writer);
729}
730
732{
733 yarp::os::idl::WireReader reader(connection);
734 if (!reader.readListHeader()) {
735 reader.fail();
736 return false;
737 }
738 return read(reader);
739}
740
742{
743 if (!writeTag(writer)) {
744 return false;
745 }
746 if (!writeArgs(writer)) {
747 return false;
748 }
749 return true;
750}
751
753{
754 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
755 return false;
756 }
757 return true;
758}
759
761{
762 return true;
763}
764
766{
767 if (!readTag(reader)) {
768 return false;
769 }
770 if (!readArgs(reader)) {
771 return false;
772 }
773 return true;
774}
775
777{
778 std::string tag = reader.readTag(s_tag_len);
779 if (reader.isError()) {
780 return false;
781 }
782 if (tag != s_tag) {
783 reader.fail();
784 return false;
785 }
786 return true;
787}
788
790{
791 if (!reader.noMore()) {
792 reader.fail();
793 return false;
794 }
795 return true;
796}
797
799{
800 yarp::os::idl::WireWriter writer(connection);
801 return write(writer);
802}
803
809
811{
812 if (!writer.isNull()) {
813 if (!writer.writeListHeader(s_reply_len)) {
814 return false;
815 }
816 if (!writer.write(return_helper)) {
817 return false;
818 }
819 }
820 return true;
821}
822
824{
825 if (!reader.readListReturn()) {
826 return false;
827 }
828 if (reader.noMore()) {
829 reader.fail();
830 return false;
831 }
832 if (!reader.read(return_helper)) {
833 reader.fail();
834 return false;
835 }
836 return true;
837}
838
843
844// getDistanceRange_RPC helper class implementation
846{
847 return cmd.write(connection);
848}
849
854
856{
857 yarp::os::idl::WireWriter writer(connection);
858 if (!writer.writeListHeader(s_cmd_len)) {
859 return false;
860 }
861 return write(writer);
862}
863
865{
866 yarp::os::idl::WireReader reader(connection);
867 if (!reader.readListHeader()) {
868 reader.fail();
869 return false;
870 }
871 return read(reader);
872}
873
875{
876 if (!writeTag(writer)) {
877 return false;
878 }
879 if (!writeArgs(writer)) {
880 return false;
881 }
882 return true;
883}
884
886{
887 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
888 return false;
889 }
890 return true;
891}
892
894{
895 return true;
896}
897
899{
900 if (!readTag(reader)) {
901 return false;
902 }
903 if (!readArgs(reader)) {
904 return false;
905 }
906 return true;
907}
908
910{
911 std::string tag = reader.readTag(s_tag_len);
912 if (reader.isError()) {
913 return false;
914 }
915 if (tag != s_tag) {
916 reader.fail();
917 return false;
918 }
919 return true;
920}
921
923{
924 if (!reader.noMore()) {
925 reader.fail();
926 return false;
927 }
928 return true;
929}
930
932{
933 yarp::os::idl::WireWriter writer(connection);
934 return write(writer);
935}
936
942
944{
945 if (!writer.isNull()) {
946 if (!writer.writeListHeader(s_reply_len)) {
947 return false;
948 }
949 if (!writer.write(return_helper)) {
950 return false;
951 }
952 }
953 return true;
954}
955
957{
958 if (!reader.readListReturn()) {
959 return false;
960 }
961 if (reader.noMore()) {
962 reader.fail();
963 return false;
964 }
965 if (!reader.read(return_helper)) {
966 reader.fail();
967 return false;
968 }
969 return true;
970}
971
976
977// getScanLimits_RPC helper class implementation
979{
980 return cmd.write(connection);
981}
982
987
989{
990 yarp::os::idl::WireWriter writer(connection);
991 if (!writer.writeListHeader(s_cmd_len)) {
992 return false;
993 }
994 return write(writer);
995}
996
998{
999 yarp::os::idl::WireReader reader(connection);
1000 if (!reader.readListHeader()) {
1001 reader.fail();
1002 return false;
1003 }
1004 return read(reader);
1005}
1006
1008{
1009 if (!writeTag(writer)) {
1010 return false;
1011 }
1012 if (!writeArgs(writer)) {
1013 return false;
1014 }
1015 return true;
1016}
1017
1019{
1020 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1021 return false;
1022 }
1023 return true;
1024}
1025
1027{
1028 return true;
1029}
1030
1032{
1033 if (!readTag(reader)) {
1034 return false;
1035 }
1036 if (!readArgs(reader)) {
1037 return false;
1038 }
1039 return true;
1040}
1041
1043{
1044 std::string tag = reader.readTag(s_tag_len);
1045 if (reader.isError()) {
1046 return false;
1047 }
1048 if (tag != s_tag) {
1049 reader.fail();
1050 return false;
1051 }
1052 return true;
1053}
1054
1056{
1057 if (!reader.noMore()) {
1058 reader.fail();
1059 return false;
1060 }
1061 return true;
1062}
1063
1065{
1066 yarp::os::idl::WireWriter writer(connection);
1067 return write(writer);
1068}
1069
1071{
1072 yarp::os::idl::WireReader reader(connection);
1073 return read(reader);
1074}
1075
1077{
1078 if (!writer.isNull()) {
1079 if (!writer.writeListHeader(s_reply_len)) {
1080 return false;
1081 }
1082 if (!writer.write(return_helper)) {
1083 return false;
1084 }
1085 }
1086 return true;
1087}
1088
1090{
1091 if (!reader.readListReturn()) {
1092 return false;
1093 }
1094 if (reader.noMore()) {
1095 reader.fail();
1096 return false;
1097 }
1098 if (!reader.read(return_helper)) {
1099 reader.fail();
1100 return false;
1101 }
1102 return true;
1103}
1104
1109
1110// getHorizontalResolution_RPC helper class implementation
1115
1120
1122{
1123 yarp::os::idl::WireWriter writer(connection);
1124 if (!writer.writeListHeader(s_cmd_len)) {
1125 return false;
1126 }
1127 return write(writer);
1128}
1129
1131{
1132 yarp::os::idl::WireReader reader(connection);
1133 if (!reader.readListHeader()) {
1134 reader.fail();
1135 return false;
1136 }
1137 return read(reader);
1138}
1139
1141{
1142 if (!writeTag(writer)) {
1143 return false;
1144 }
1145 if (!writeArgs(writer)) {
1146 return false;
1147 }
1148 return true;
1149}
1150
1152{
1153 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1154 return false;
1155 }
1156 return true;
1157}
1158
1160{
1161 return true;
1162}
1163
1165{
1166 if (!readTag(reader)) {
1167 return false;
1168 }
1169 if (!readArgs(reader)) {
1170 return false;
1171 }
1172 return true;
1173}
1174
1176{
1177 std::string tag = reader.readTag(s_tag_len);
1178 if (reader.isError()) {
1179 return false;
1180 }
1181 if (tag != s_tag) {
1182 reader.fail();
1183 return false;
1184 }
1185 return true;
1186}
1187
1189{
1190 if (!reader.noMore()) {
1191 reader.fail();
1192 return false;
1193 }
1194 return true;
1195}
1196
1198{
1199 yarp::os::idl::WireWriter writer(connection);
1200 return write(writer);
1201}
1202
1208
1210{
1211 if (!writer.isNull()) {
1212 if (!writer.writeListHeader(s_reply_len)) {
1213 return false;
1214 }
1215 if (!writer.write(return_helper)) {
1216 return false;
1217 }
1218 }
1219 return true;
1220}
1221
1223{
1224 if (!reader.readListReturn()) {
1225 return false;
1226 }
1227 if (reader.noMore()) {
1228 reader.fail();
1229 return false;
1230 }
1231 if (!reader.read(return_helper)) {
1232 reader.fail();
1233 return false;
1234 }
1235 return true;
1236}
1237
1242
1243// getScanRate_RPC helper class implementation
1245{
1246 return cmd.write(connection);
1247}
1248
1250{
1251 return reply.read(connection);
1252}
1253
1255{
1256 yarp::os::idl::WireWriter writer(connection);
1257 if (!writer.writeListHeader(s_cmd_len)) {
1258 return false;
1259 }
1260 return write(writer);
1261}
1262
1264{
1265 yarp::os::idl::WireReader reader(connection);
1266 if (!reader.readListHeader()) {
1267 reader.fail();
1268 return false;
1269 }
1270 return read(reader);
1271}
1272
1274{
1275 if (!writeTag(writer)) {
1276 return false;
1277 }
1278 if (!writeArgs(writer)) {
1279 return false;
1280 }
1281 return true;
1282}
1283
1285{
1286 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1287 return false;
1288 }
1289 return true;
1290}
1291
1293{
1294 return true;
1295}
1296
1298{
1299 if (!readTag(reader)) {
1300 return false;
1301 }
1302 if (!readArgs(reader)) {
1303 return false;
1304 }
1305 return true;
1306}
1307
1309{
1310 std::string tag = reader.readTag(s_tag_len);
1311 if (reader.isError()) {
1312 return false;
1313 }
1314 if (tag != s_tag) {
1315 reader.fail();
1316 return false;
1317 }
1318 return true;
1319}
1320
1322{
1323 if (!reader.noMore()) {
1324 reader.fail();
1325 return false;
1326 }
1327 return true;
1328}
1329
1331{
1332 yarp::os::idl::WireWriter writer(connection);
1333 return write(writer);
1334}
1335
1337{
1338 yarp::os::idl::WireReader reader(connection);
1339 return read(reader);
1340}
1341
1343{
1344 if (!writer.isNull()) {
1345 if (!writer.writeListHeader(s_reply_len)) {
1346 return false;
1347 }
1348 if (!writer.write(return_helper)) {
1349 return false;
1350 }
1351 }
1352 return true;
1353}
1354
1356{
1357 if (!reader.readListReturn()) {
1358 return false;
1359 }
1360 if (reader.noMore()) {
1361 reader.fail();
1362 return false;
1363 }
1364 if (!reader.read(return_helper)) {
1365 reader.fail();
1366 return false;
1367 }
1368 return true;
1369}
1370
1375
1376// getDeviceInfo_RPC helper class implementation
1378{
1379 return cmd.write(connection);
1380}
1381
1386
1388{
1389 yarp::os::idl::WireWriter writer(connection);
1390 if (!writer.writeListHeader(s_cmd_len)) {
1391 return false;
1392 }
1393 return write(writer);
1394}
1395
1397{
1398 yarp::os::idl::WireReader reader(connection);
1399 if (!reader.readListHeader()) {
1400 reader.fail();
1401 return false;
1402 }
1403 return read(reader);
1404}
1405
1407{
1408 if (!writeTag(writer)) {
1409 return false;
1410 }
1411 if (!writeArgs(writer)) {
1412 return false;
1413 }
1414 return true;
1415}
1416
1418{
1419 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1420 return false;
1421 }
1422 return true;
1423}
1424
1426{
1427 return true;
1428}
1429
1431{
1432 if (!readTag(reader)) {
1433 return false;
1434 }
1435 if (!readArgs(reader)) {
1436 return false;
1437 }
1438 return true;
1439}
1440
1442{
1443 std::string tag = reader.readTag(s_tag_len);
1444 if (reader.isError()) {
1445 return false;
1446 }
1447 if (tag != s_tag) {
1448 reader.fail();
1449 return false;
1450 }
1451 return true;
1452}
1453
1455{
1456 if (!reader.noMore()) {
1457 reader.fail();
1458 return false;
1459 }
1460 return true;
1461}
1462
1464{
1465 yarp::os::idl::WireWriter writer(connection);
1466 return write(writer);
1467}
1468
1470{
1471 yarp::os::idl::WireReader reader(connection);
1472 return read(reader);
1473}
1474
1476{
1477 if (!writer.isNull()) {
1478 if (!writer.writeListHeader(s_reply_len)) {
1479 return false;
1480 }
1481 if (!writer.write(return_helper)) {
1482 return false;
1483 }
1484 }
1485 return true;
1486}
1487
1489{
1490 if (!reader.readListReturn()) {
1491 return false;
1492 }
1493 if (reader.noMore()) {
1494 reader.fail();
1495 return false;
1496 }
1497 if (!reader.read(return_helper)) {
1498 reader.fail();
1499 return false;
1500 }
1501 return true;
1502}
1503
1508
1509// setDistanceRange_RPC helper class implementation
1514
1516{
1517 return cmd.write(connection);
1518}
1519
1524
1526 min{min},
1527 max{max}
1528{
1529}
1530
1532{
1533 yarp::os::idl::WireWriter writer(connection);
1534 if (!writer.writeListHeader(s_cmd_len)) {
1535 return false;
1536 }
1537 return write(writer);
1538}
1539
1541{
1542 yarp::os::idl::WireReader reader(connection);
1543 if (!reader.readListHeader()) {
1544 reader.fail();
1545 return false;
1546 }
1547 return read(reader);
1548}
1549
1551{
1552 if (!writeTag(writer)) {
1553 return false;
1554 }
1555 if (!writeArgs(writer)) {
1556 return false;
1557 }
1558 return true;
1559}
1560
1562{
1563 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1564 return false;
1565 }
1566 return true;
1567}
1568
1570{
1571 if (!writer.writeFloat64(min)) {
1572 return false;
1573 }
1574 if (!writer.writeFloat64(max)) {
1575 return false;
1576 }
1577 return true;
1578}
1579
1581{
1582 if (!readTag(reader)) {
1583 return false;
1584 }
1585 if (!readArgs(reader)) {
1586 return false;
1587 }
1588 return true;
1589}
1590
1592{
1593 std::string tag = reader.readTag(s_tag_len);
1594 if (reader.isError()) {
1595 return false;
1596 }
1597 if (tag != s_tag) {
1598 reader.fail();
1599 return false;
1600 }
1601 return true;
1602}
1603
1605{
1606 if (reader.noMore()) {
1607 reader.fail();
1608 return false;
1609 }
1610 if (!reader.readFloat64(min)) {
1611 reader.fail();
1612 return false;
1613 }
1614 if (reader.noMore()) {
1615 reader.fail();
1616 return false;
1617 }
1618 if (!reader.readFloat64(max)) {
1619 reader.fail();
1620 return false;
1621 }
1622 if (!reader.noMore()) {
1623 reader.fail();
1624 return false;
1625 }
1626 return true;
1627}
1628
1630{
1631 yarp::os::idl::WireWriter writer(connection);
1632 return write(writer);
1633}
1634
1636{
1637 yarp::os::idl::WireReader reader(connection);
1638 return read(reader);
1639}
1640
1642{
1643 if (!writer.isNull()) {
1644 if (!writer.write(return_helper)) {
1645 return false;
1646 }
1647 }
1648 return true;
1649}
1650
1652{
1653 if (reader.noMore()) {
1654 reader.fail();
1655 return false;
1656 }
1657 if (!reader.read(return_helper)) {
1658 reader.fail();
1659 return false;
1660 }
1661 return true;
1662}
1663
1668
1669// setScanLimits_RPC helper class implementation
1671 cmd{min, max}
1672{
1673}
1674
1676{
1677 return cmd.write(connection);
1678}
1679
1684
1686 min{min},
1687 max{max}
1688{
1689}
1690
1692{
1693 yarp::os::idl::WireWriter writer(connection);
1694 if (!writer.writeListHeader(s_cmd_len)) {
1695 return false;
1696 }
1697 return write(writer);
1698}
1699
1701{
1702 yarp::os::idl::WireReader reader(connection);
1703 if (!reader.readListHeader()) {
1704 reader.fail();
1705 return false;
1706 }
1707 return read(reader);
1708}
1709
1711{
1712 if (!writeTag(writer)) {
1713 return false;
1714 }
1715 if (!writeArgs(writer)) {
1716 return false;
1717 }
1718 return true;
1719}
1720
1722{
1723 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1724 return false;
1725 }
1726 return true;
1727}
1728
1730{
1731 if (!writer.writeFloat64(min)) {
1732 return false;
1733 }
1734 if (!writer.writeFloat64(max)) {
1735 return false;
1736 }
1737 return true;
1738}
1739
1741{
1742 if (!readTag(reader)) {
1743 return false;
1744 }
1745 if (!readArgs(reader)) {
1746 return false;
1747 }
1748 return true;
1749}
1750
1752{
1753 std::string tag = reader.readTag(s_tag_len);
1754 if (reader.isError()) {
1755 return false;
1756 }
1757 if (tag != s_tag) {
1758 reader.fail();
1759 return false;
1760 }
1761 return true;
1762}
1763
1765{
1766 if (reader.noMore()) {
1767 reader.fail();
1768 return false;
1769 }
1770 if (!reader.readFloat64(min)) {
1771 reader.fail();
1772 return false;
1773 }
1774 if (reader.noMore()) {
1775 reader.fail();
1776 return false;
1777 }
1778 if (!reader.readFloat64(max)) {
1779 reader.fail();
1780 return false;
1781 }
1782 if (!reader.noMore()) {
1783 reader.fail();
1784 return false;
1785 }
1786 return true;
1787}
1788
1790{
1791 yarp::os::idl::WireWriter writer(connection);
1792 return write(writer);
1793}
1794
1796{
1797 yarp::os::idl::WireReader reader(connection);
1798 return read(reader);
1799}
1800
1802{
1803 if (!writer.isNull()) {
1804 if (!writer.write(return_helper)) {
1805 return false;
1806 }
1807 }
1808 return true;
1809}
1810
1812{
1813 if (reader.noMore()) {
1814 reader.fail();
1815 return false;
1816 }
1817 if (!reader.read(return_helper)) {
1818 reader.fail();
1819 return false;
1820 }
1821 return true;
1822}
1823
1828
1829// setHorizontalResolution_RPC helper class implementation
1834
1839
1844
1849
1851{
1852 yarp::os::idl::WireWriter writer(connection);
1853 if (!writer.writeListHeader(s_cmd_len)) {
1854 return false;
1855 }
1856 return write(writer);
1857}
1858
1860{
1861 yarp::os::idl::WireReader reader(connection);
1862 if (!reader.readListHeader()) {
1863 reader.fail();
1864 return false;
1865 }
1866 return read(reader);
1867}
1868
1870{
1871 if (!writeTag(writer)) {
1872 return false;
1873 }
1874 if (!writeArgs(writer)) {
1875 return false;
1876 }
1877 return true;
1878}
1879
1881{
1882 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1883 return false;
1884 }
1885 return true;
1886}
1887
1889{
1890 if (!writer.writeFloat64(step)) {
1891 return false;
1892 }
1893 return true;
1894}
1895
1897{
1898 if (!readTag(reader)) {
1899 return false;
1900 }
1901 if (!readArgs(reader)) {
1902 return false;
1903 }
1904 return true;
1905}
1906
1908{
1909 std::string tag = reader.readTag(s_tag_len);
1910 if (reader.isError()) {
1911 return false;
1912 }
1913 if (tag != s_tag) {
1914 reader.fail();
1915 return false;
1916 }
1917 return true;
1918}
1919
1921{
1922 if (reader.noMore()) {
1923 reader.fail();
1924 return false;
1925 }
1926 if (!reader.readFloat64(step)) {
1927 reader.fail();
1928 return false;
1929 }
1930 if (!reader.noMore()) {
1931 reader.fail();
1932 return false;
1933 }
1934 return true;
1935}
1936
1938{
1939 yarp::os::idl::WireWriter writer(connection);
1940 return write(writer);
1941}
1942
1948
1950{
1951 if (!writer.isNull()) {
1952 if (!writer.write(return_helper)) {
1953 return false;
1954 }
1955 }
1956 return true;
1957}
1958
1960{
1961 if (reader.noMore()) {
1962 reader.fail();
1963 return false;
1964 }
1965 if (!reader.read(return_helper)) {
1966 reader.fail();
1967 return false;
1968 }
1969 return true;
1970}
1971
1976
1977// setScanRate_RPC helper class implementation
1982
1984{
1985 return cmd.write(connection);
1986}
1987
1989{
1990 return reply.read(connection);
1991}
1992
1994 rate{rate}
1995{
1996}
1997
1999{
2000 yarp::os::idl::WireWriter writer(connection);
2001 if (!writer.writeListHeader(s_cmd_len)) {
2002 return false;
2003 }
2004 return write(writer);
2005}
2006
2008{
2009 yarp::os::idl::WireReader reader(connection);
2010 if (!reader.readListHeader()) {
2011 reader.fail();
2012 return false;
2013 }
2014 return read(reader);
2015}
2016
2018{
2019 if (!writeTag(writer)) {
2020 return false;
2021 }
2022 if (!writeArgs(writer)) {
2023 return false;
2024 }
2025 return true;
2026}
2027
2029{
2030 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2031 return false;
2032 }
2033 return true;
2034}
2035
2037{
2038 if (!writer.writeFloat64(rate)) {
2039 return false;
2040 }
2041 return true;
2042}
2043
2045{
2046 if (!readTag(reader)) {
2047 return false;
2048 }
2049 if (!readArgs(reader)) {
2050 return false;
2051 }
2052 return true;
2053}
2054
2056{
2057 std::string tag = reader.readTag(s_tag_len);
2058 if (reader.isError()) {
2059 return false;
2060 }
2061 if (tag != s_tag) {
2062 reader.fail();
2063 return false;
2064 }
2065 return true;
2066}
2067
2069{
2070 if (reader.noMore()) {
2071 reader.fail();
2072 return false;
2073 }
2074 if (!reader.readFloat64(rate)) {
2075 reader.fail();
2076 return false;
2077 }
2078 if (!reader.noMore()) {
2079 reader.fail();
2080 return false;
2081 }
2082 return true;
2083}
2084
2086{
2087 yarp::os::idl::WireWriter writer(connection);
2088 return write(writer);
2089}
2090
2092{
2093 yarp::os::idl::WireReader reader(connection);
2094 return read(reader);
2095}
2096
2098{
2099 if (!writer.isNull()) {
2100 if (!writer.write(return_helper)) {
2101 return false;
2102 }
2103 }
2104 return true;
2105}
2106
2108{
2109 if (reader.noMore()) {
2110 reader.fail();
2111 return false;
2112 }
2113 if (!reader.read(return_helper)) {
2114 reader.fail();
2115 return false;
2116 }
2117 return true;
2118}
2119
2124
2125// Constructor
2127{
2128 yarp().setOwner(*this);
2129}
2130
2132{
2133 if (!yarp().canWrite()) {
2135 }
2137 bool ok = yarp().write(helper, helper);
2138 if (!ok) {
2139 return_getDeviceStatus failed_reply{};
2141 return failed_reply;
2142 }
2143 return helper.reply.return_helper;
2144}
2145
2147{
2148 if (!yarp().canWrite()) {
2150 }
2152 bool ok = yarp().write(helper, helper);
2153 if (!ok) {
2154 return_getDistanceRange failed_reply{};
2156 return failed_reply;
2157 }
2158 return helper.reply.return_helper;
2159}
2160
2162{
2163 if (!yarp().canWrite()) {
2165 }
2167 bool ok = yarp().write(helper, helper);
2168 if (!ok) {
2169 return_getScanLimits failed_reply{};
2171 return failed_reply;
2172 }
2173 return helper.reply.return_helper;
2174}
2175
2177{
2178 if (!yarp().canWrite()) {
2180 }
2182 bool ok = yarp().write(helper, helper);
2183 if (!ok) {
2184 return_getHorizontalResolution failed_reply{};
2186 return failed_reply;
2187 }
2188 return helper.reply.return_helper;
2189}
2190
2192{
2193 if (!yarp().canWrite()) {
2194 yError("Missing server method '%s'?", IRangefinder2DMsgs_getScanRate_RPC_helper::s_prototype);
2195 }
2197 bool ok = yarp().write(helper, helper);
2198 if (!ok) {
2199 return_getScanRate failed_reply{};
2201 return failed_reply;
2202 }
2203 return helper.reply.return_helper;
2204}
2205
2207{
2208 if (!yarp().canWrite()) {
2210 }
2212 bool ok = yarp().write(helper, helper);
2213 if (!ok) {
2214 return_getDeviceInfo failed_reply{};
2216 return failed_reply;
2217 }
2218 return helper.reply.return_helper;
2219}
2220
2222{
2223 if (!yarp().canWrite()) {
2225 }
2227 bool ok = yarp().write(helper, helper);
2229}
2230
2232{
2233 if (!yarp().canWrite()) {
2235 }
2237 bool ok = yarp().write(helper, helper);
2239}
2240
2242{
2243 if (!yarp().canWrite()) {
2245 }
2247 bool ok = yarp().write(helper, helper);
2249}
2250
2252{
2253 if (!yarp().canWrite()) {
2254 yError("Missing server method '%s'?", IRangefinder2DMsgs_setScanRate_RPC_helper::s_prototype);
2255 }
2257 bool ok = yarp().write(helper, helper);
2259}
2260
2261// help method
2262std::vector<std::string> IRangefinder2DMsgs::help(const std::string& functionName)
2263{
2264 bool showAll = (functionName == "--all");
2265 std::vector<std::string> helpString;
2266 if (showAll) {
2267 helpString.emplace_back("*** Available commands:");
2272 helpString.emplace_back(IRangefinder2DMsgs_getScanRate_RPC_helper::s_tag);
2277 helpString.emplace_back(IRangefinder2DMsgs_setScanRate_RPC_helper::s_tag);
2278 helpString.emplace_back("help");
2279 } else {
2282 }
2285 }
2288 }
2291 }
2294 }
2297 }
2300 }
2303 }
2306 }
2309 }
2310 if (functionName == "help") {
2311 helpString.emplace_back("std::vector<std::string> help(const std::string& functionName = \"--all\")");
2312 helpString.emplace_back("Return list of available commands, or help message for a specific function");
2313 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");
2314 helpString.emplace_back("@return list of strings (one string per line)");
2315 }
2316 }
2317 if (helpString.empty()) {
2318 helpString.emplace_back("Command not found");
2319 }
2320 return helpString;
2321}
2322
2323// read from ConnectionReader
2325{
2326 constexpr size_t max_tag_len = 2;
2327 size_t tag_len = 1;
2328
2329 yarp::os::idl::WireReader reader(connection);
2330 reader.expectAccept();
2331 if (!reader.readListHeader()) {
2332 reader.fail();
2333 return false;
2334 }
2335
2336 std::string tag = reader.readTag(1);
2337 bool direct = (tag == "__direct__");
2338 if (direct) {
2339 tag = reader.readTag(1);
2340 }
2341 while (tag_len <= max_tag_len && !reader.isError()) {
2342 if(tag == "getRemoteProtocolVersion") {
2343 if (!reader.noMore()) {
2344 yError("Reader invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
2345 reader.fail();
2346 return false;
2347 }
2348
2349 auto proto = getLocalProtocolVersion();
2350
2351 yarp::os::idl::WireWriter writer(reader);
2352 if (!writer.writeListHeader(1)) {
2353 yWarning("Writer invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
2354 return false;}
2355 if (!writer.write(proto)) {
2356 yWarning("Writer invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
2357 return false;
2358 }
2359 reader.accept();
2360 return true;
2361 }
2364 if (!helper.cmd.readArgs(reader)) {
2365 return false;
2366 }
2367
2368 helper.call(this);
2369
2370 yarp::os::idl::WireWriter writer(reader);
2371 if (!helper.reply.write(writer)) {
2372 return false;
2373 }
2374 reader.accept();
2375 return true;
2376 }
2379 if (!helper.cmd.readArgs(reader)) {
2380 return false;
2381 }
2382
2383 helper.call(this);
2384
2385 yarp::os::idl::WireWriter writer(reader);
2386 if (!helper.reply.write(writer)) {
2387 return false;
2388 }
2389 reader.accept();
2390 return true;
2391 }
2394 if (!helper.cmd.readArgs(reader)) {
2395 return false;
2396 }
2397
2398 helper.call(this);
2399
2400 yarp::os::idl::WireWriter writer(reader);
2401 if (!helper.reply.write(writer)) {
2402 return false;
2403 }
2404 reader.accept();
2405 return true;
2406 }
2409 if (!helper.cmd.readArgs(reader)) {
2410 return false;
2411 }
2412
2413 helper.call(this);
2414
2415 yarp::os::idl::WireWriter writer(reader);
2416 if (!helper.reply.write(writer)) {
2417 return false;
2418 }
2419 reader.accept();
2420 return true;
2421 }
2424 if (!helper.cmd.readArgs(reader)) {
2425 return false;
2426 }
2427
2428 helper.call(this);
2429
2430 yarp::os::idl::WireWriter writer(reader);
2431 if (!helper.reply.write(writer)) {
2432 return false;
2433 }
2434 reader.accept();
2435 return true;
2436 }
2439 if (!helper.cmd.readArgs(reader)) {
2440 return false;
2441 }
2442
2443 helper.call(this);
2444
2445 yarp::os::idl::WireWriter writer(reader);
2446 if (!helper.reply.write(writer)) {
2447 return false;
2448 }
2449 reader.accept();
2450 return true;
2451 }
2454 if (!helper.cmd.readArgs(reader)) {
2455 return false;
2456 }
2457
2458 helper.call(this);
2459
2460 yarp::os::idl::WireWriter writer(reader);
2461 if (!helper.reply.write(writer)) {
2462 return false;
2463 }
2464 reader.accept();
2465 return true;
2466 }
2469 if (!helper.cmd.readArgs(reader)) {
2470 return false;
2471 }
2472
2473 helper.call(this);
2474
2475 yarp::os::idl::WireWriter writer(reader);
2476 if (!helper.reply.write(writer)) {
2477 return false;
2478 }
2479 reader.accept();
2480 return true;
2481 }
2484 if (!helper.cmd.readArgs(reader)) {
2485 return false;
2486 }
2487
2488 helper.call(this);
2489
2490 yarp::os::idl::WireWriter writer(reader);
2491 if (!helper.reply.write(writer)) {
2492 return false;
2493 }
2494 reader.accept();
2495 return true;
2496 }
2499 if (!helper.cmd.readArgs(reader)) {
2500 return false;
2501 }
2502
2503 helper.call(this);
2504
2505 yarp::os::idl::WireWriter writer(reader);
2506 if (!helper.reply.write(writer)) {
2507 return false;
2508 }
2509 reader.accept();
2510 return true;
2511 }
2512 if (tag == "help") {
2513 std::string functionName;
2514 if (!reader.readString(functionName)) {
2515 functionName = "--all";
2516 }
2517 auto help_strings = help(functionName);
2518 yarp::os::idl::WireWriter writer(reader);
2519 if (!writer.isNull()) {
2520 if (!writer.writeListHeader(2)) {
2521 return false;
2522 }
2523 if (!writer.writeTag("many", 1, 0)) {
2524 return false;
2525 }
2526 if (!writer.writeListBegin(0, help_strings.size())) {
2527 return false;
2528 }
2529 for (const auto& help_string : help_strings) {
2530 if (!writer.writeString(help_string)) {
2531 return false;
2532 }
2533 }
2534 if (!writer.writeListEnd()) {
2535 return false;
2536 }
2537 }
2538 reader.accept();
2539 return true;
2540 }
2541 if (reader.noMore()) {
2542 reader.fail();
2543 return false;
2544 }
2545 std::string next_tag = reader.readTag(1);
2546 if (next_tag.empty()) {
2547 break;
2548 }
2549 tag.append("_").append(next_tag);
2550 tag_len = std::count(tag.begin(), tag.end(), '_') + 1;
2551 }
2552 return false;
2553}
#define yError(...)
Definition Log.h:361
#define __YFUNCTION__
Definition Log.h:24
#define yWarning(...)
Definition Log.h:340
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
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 writeArgs(const yarp::os::idl::WireWriter &writer) const
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
yarp::os::ApplicationNetworkProtocolVersion helper_proto
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 read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool 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 read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool readTag(yarp::os::idl::WireReader &reader)
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool 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 double, const double) funcptr_t
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool 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.
yarp::dev::ReturnValue(*)(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 read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
yarp::dev::ReturnValue(*)(const double, const double) funcptr_t
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 readTag(yarp::os::idl::WireReader &reader)
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
yarp::dev::ReturnValue(*)(const double) 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.
virtual yarp::dev::ReturnValue setHorizontalResolution_RPC(const double step)
virtual std::vector< std::string > help(const std::string &functionName="--all")
virtual return_getScanRate getScanRate_RPC()
virtual yarp::os::ApplicationNetworkProtocolVersion getLocalProtocolVersion()
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
virtual return_getHorizontalResolution getHorizontalResolution_RPC()
virtual bool checkProtocolVersion()
virtual return_getDeviceStatus getDeviceStatus_RPC()
virtual yarp::dev::ReturnValue setScanRate_RPC(const double rate)
virtual return_getScanLimits getScanLimits_RPC()
virtual yarp::os::ApplicationNetworkProtocolVersion getRemoteProtocolVersion()
virtual return_getDeviceInfo getDeviceInfo_RPC()
virtual yarp::dev::ReturnValue setScanLimits_RPC(const double min, const double max)
virtual return_getDistanceRange getDistanceRange_RPC()
virtual yarp::dev::ReturnValue setDistanceRange_RPC(const double min, const double max)
yarp::dev::ReturnValue retval
yarp::dev::ReturnValue retval
yarp::dev::ReturnValue retval
yarp::dev::ReturnValue retval
yarp::dev::ReturnValue retval
@ return_value_error_nws_nwc_communication_error
Method is not (yet) implemented.
An interface for reading from a network connection.
An interface for writing to a network connection.
This is a base class for objects that can be both read from and be written to the YARP network.
Definition Portable.h:25
yarp::os::WireLink & yarp()
Get YARP state associated with this object.
Definition Wire.h:28
A "tamed" Portable, that promises to serialize itself in an IDL-friendly way.
IDL-friendly connection reader.
Definition WireReader.h:27
bool readString(std::string &str, bool *is_vocab=nullptr)
std::string readTag(size_t len=static_cast< size_t >(-1))
bool read(WirePortable &obj)
bool readFloat64(yarp::conf::float64_t &x)
IDL-friendly connection writer.
Definition WireWriter.h:28
bool write(const WirePortable &obj) const
bool writeListHeader(int len) const
bool writeTag(const char *tag, int split, int len) const
bool writeFloat64(yarp::conf::float64_t x, bool skip_tag=false) const
bool writeString(const std::string &str, bool skip_tag=false) const
bool writeListBegin(int tag, size_t len) const
#define yCError(component,...)
#define YARP_LOG_COMPONENT(name,...)
The main, catch-all namespace for YARP.
Definition dirs.h:16
#define YARP_VERSION_PATCH
Definition version.h:12
#define YARP_VERSION_MAJOR
Definition version.h:10
#define YARP_VERSION_MINOR
Definition version.h:11