YARP
Yet Another Robot Platform
 
Loading...
Searching...
No Matches
yarprobotinterfaceRpc.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>
15#include <yarp/os/LogStream.h>
16
18
19#include <algorithm>
20
21namespace
22{
23 YARP_LOG_COMPONENT(SERVICE_LOG_COMPONENT, "yarprobotinterfaceRpc")
24}
25
26//yarprobotinterfaceRpc_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 yarprobotinterfaceRpc_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 yarprobotinterfaceRpc::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// get_phase 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
150 std::string return_helper{};
151 };
152
153 using funcptr_t = std::string (*)();
154 void call(yarprobotinterfaceRpc* ptr);
155
158
159 static constexpr const char* s_tag{"get_phase"};
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{1};
163 static constexpr const char* s_prototype{"std::string yarprobotinterfaceRpc::get_phase()"};
164 static constexpr const char* s_help{
165 "Returns current phase."
166 };
167};
168
169// get_level helper class declaration
171 public yarp::os::Portable
172{
173public:
175 bool write(yarp::os::ConnectionWriter& connection) const override;
176 bool read(yarp::os::ConnectionReader& connection) override;
177
178 class Command :
180 {
181 public:
182 Command() = default;
183 ~Command() override = default;
184
185 bool write(yarp::os::ConnectionWriter& connection) const override;
186 bool read(yarp::os::ConnectionReader& connection) override;
187
188 bool write(const yarp::os::idl::WireWriter& writer) const override;
189 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
190 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
191
192 bool read(yarp::os::idl::WireReader& reader) override;
195 };
196
197 class Reply :
199 {
200 public:
201 Reply() = default;
202 ~Reply() override = default;
203
204 bool write(yarp::os::ConnectionWriter& connection) const override;
205 bool read(yarp::os::ConnectionReader& connection) override;
206
207 bool write(const yarp::os::idl::WireWriter& writer) const override;
208 bool read(yarp::os::idl::WireReader& reader) override;
209
210 std::int32_t return_helper{0};
211 };
212
213 using funcptr_t = std::int32_t (*)();
214 void call(yarprobotinterfaceRpc* ptr);
215
218
219 static constexpr const char* s_tag{"get_level"};
220 static constexpr size_t s_tag_len{2};
221 static constexpr size_t s_cmd_len{2};
222 static constexpr size_t s_reply_len{1};
223 static constexpr const char* s_prototype{"std::int32_t yarprobotinterfaceRpc::get_level()"};
224 static constexpr const char* s_help{
225 "Returns current level."
226 };
227};
228
229// get_robot helper class declaration
231 public yarp::os::Portable
232{
233public:
235 bool write(yarp::os::ConnectionWriter& connection) const override;
236 bool read(yarp::os::ConnectionReader& connection) override;
237
238 class Command :
240 {
241 public:
242 Command() = default;
243 ~Command() override = default;
244
245 bool write(yarp::os::ConnectionWriter& connection) const override;
246 bool read(yarp::os::ConnectionReader& connection) override;
247
248 bool write(const yarp::os::idl::WireWriter& writer) const override;
249 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
250 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
251
252 bool read(yarp::os::idl::WireReader& reader) override;
255 };
256
257 class Reply :
259 {
260 public:
261 Reply() = default;
262 ~Reply() override = default;
263
264 bool write(yarp::os::ConnectionWriter& connection) const override;
265 bool read(yarp::os::ConnectionReader& connection) override;
266
267 bool write(const yarp::os::idl::WireWriter& writer) const override;
268 bool read(yarp::os::idl::WireReader& reader) override;
269
270 std::string return_helper{};
271 };
272
273 using funcptr_t = std::string (*)();
274 void call(yarprobotinterfaceRpc* ptr);
275
278
279 static constexpr const char* s_tag{"get_robot"};
280 static constexpr size_t s_tag_len{2};
281 static constexpr size_t s_cmd_len{2};
282 static constexpr size_t s_reply_len{1};
283 static constexpr const char* s_prototype{"std::string yarprobotinterfaceRpc::get_robot()"};
284 static constexpr const char* s_help{
285 "Returns robot name."
286 };
287};
288
289// is_ready helper class declaration
291 public yarp::os::Portable
292{
293public:
295 bool write(yarp::os::ConnectionWriter& connection) const override;
296 bool read(yarp::os::ConnectionReader& connection) override;
297
298 class Command :
300 {
301 public:
302 Command() = default;
303 ~Command() override = default;
304
305 bool write(yarp::os::ConnectionWriter& connection) const override;
306 bool read(yarp::os::ConnectionReader& connection) override;
307
308 bool write(const yarp::os::idl::WireWriter& writer) const override;
309 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
310 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
311
312 bool read(yarp::os::idl::WireReader& reader) override;
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
330 bool return_helper{false};
331 };
332
333 using funcptr_t = bool (*)();
334 void call(yarprobotinterfaceRpc* ptr);
335
338
339 static constexpr const char* s_tag{"is_ready"};
340 static constexpr size_t s_tag_len{2};
341 static constexpr size_t s_cmd_len{2};
342 static constexpr size_t s_reply_len{1};
343 static constexpr const char* s_prototype{"bool yarprobotinterfaceRpc::is_ready()"};
344 static constexpr const char* s_help{
345 "Returns true if yarprobotinterface is ready (all startup actions\n"
346 "performed and no interrupt called)."
347 };
348};
349
350// quit helper class declaration
352 public yarp::os::Portable
353{
354public:
356 bool write(yarp::os::ConnectionWriter& connection) const override;
357 bool read(yarp::os::ConnectionReader& connection) override;
358
359 class Command :
361 {
362 public:
363 Command() = default;
364 ~Command() override = default;
365
366 bool write(yarp::os::ConnectionWriter& connection) const override;
367 bool read(yarp::os::ConnectionReader& connection) override;
368
369 bool write(const yarp::os::idl::WireWriter& writer) const override;
370 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
371 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
372
373 bool read(yarp::os::idl::WireReader& reader) override;
376 };
377
378 class Reply :
380 {
381 public:
382 Reply() = default;
383 ~Reply() override = default;
384
385 bool write(yarp::os::ConnectionWriter& connection) const override;
386 bool read(yarp::os::ConnectionReader& connection) override;
387
388 bool write(const yarp::os::idl::WireWriter& writer) const override;
389 bool read(yarp::os::idl::WireReader& reader) override;
390
391 std::string return_helper{};
392 };
393
394 using funcptr_t = std::string (*)();
395 void call(yarprobotinterfaceRpc* ptr);
396
399
400 static constexpr const char* s_tag{"quit"};
401 static constexpr size_t s_tag_len{1};
402 static constexpr size_t s_cmd_len{1};
403 static constexpr size_t s_reply_len{1};
404 static constexpr const char* s_prototype{"std::string yarprobotinterfaceRpc::quit()"};
405 static constexpr const char* s_help{
406 "Closes yarprobotinterface."
407 };
408};
409
410// bye helper class declaration
412 public yarp::os::Portable
413{
414public:
416 bool write(yarp::os::ConnectionWriter& connection) const override;
417 bool read(yarp::os::ConnectionReader& connection) override;
418
419 class Command :
421 {
422 public:
423 Command() = default;
424 ~Command() override = default;
425
426 bool write(yarp::os::ConnectionWriter& connection) const override;
427 bool read(yarp::os::ConnectionReader& connection) override;
428
429 bool write(const yarp::os::idl::WireWriter& writer) const override;
430 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
431 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
432
433 bool read(yarp::os::idl::WireReader& reader) override;
436 };
437
438 class Reply :
440 {
441 public:
442 Reply() = default;
443 ~Reply() override = default;
444
445 bool write(yarp::os::ConnectionWriter& connection) const override;
446 bool read(yarp::os::ConnectionReader& connection) override;
447
448 bool write(const yarp::os::idl::WireWriter& writer) const override;
449 bool read(yarp::os::idl::WireReader& reader) override;
450
451 std::string return_helper{};
452 };
453
454 using funcptr_t = std::string (*)();
455 void call(yarprobotinterfaceRpc* ptr);
456
459
460 static constexpr const char* s_tag{"bye"};
461 static constexpr size_t s_tag_len{1};
462 static constexpr size_t s_cmd_len{1};
463 static constexpr size_t s_reply_len{1};
464 static constexpr const char* s_prototype{"std::string yarprobotinterfaceRpc::bye()"};
465 static constexpr const char* s_help{
466 "Closes yarprobotinterface."
467 };
468};
469
470// exit helper class declaration
472 public yarp::os::Portable
473{
474public:
476 bool write(yarp::os::ConnectionWriter& connection) const override;
477 bool read(yarp::os::ConnectionReader& connection) override;
478
479 class Command :
481 {
482 public:
483 Command() = default;
484 ~Command() override = default;
485
486 bool write(yarp::os::ConnectionWriter& connection) const override;
487 bool read(yarp::os::ConnectionReader& connection) override;
488
489 bool write(const yarp::os::idl::WireWriter& writer) const override;
490 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
491 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
492
493 bool read(yarp::os::idl::WireReader& reader) override;
496 };
497
498 class Reply :
500 {
501 public:
502 Reply() = default;
503 ~Reply() override = default;
504
505 bool write(yarp::os::ConnectionWriter& connection) const override;
506 bool read(yarp::os::ConnectionReader& connection) override;
507
508 bool write(const yarp::os::idl::WireWriter& writer) const override;
509 bool read(yarp::os::idl::WireReader& reader) override;
510
511 std::string return_helper{};
512 };
513
514 using funcptr_t = std::string (*)();
515 void call(yarprobotinterfaceRpc* ptr);
516
519
520 static constexpr const char* s_tag{"exit"};
521 static constexpr size_t s_tag_len{1};
522 static constexpr size_t s_cmd_len{1};
523 static constexpr size_t s_reply_len{1};
524 static constexpr const char* s_prototype{"std::string yarprobotinterfaceRpc::exit()"};
525 static constexpr const char* s_help{
526 "Closes yarprobotinterface."
527 };
528};
529
530// get_phase helper class implementation
532{
533 return cmd.write(connection);
534}
535
537{
538 return reply.read(connection);
539}
540
542{
543 yarp::os::idl::WireWriter writer(connection);
544 if (!writer.writeListHeader(s_cmd_len)) {
545 return false;
546 }
547 return write(writer);
548}
549
551{
552 yarp::os::idl::WireReader reader(connection);
553 if (!reader.readListHeader()) {
554 reader.fail();
555 return false;
556 }
557 return read(reader);
558}
559
561{
562 if (!writeTag(writer)) {
563 return false;
564 }
565 if (!writeArgs(writer)) {
566 return false;
567 }
568 return true;
569}
570
572{
573 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
574 return false;
575 }
576 return true;
577}
578
580{
581 return true;
582}
583
585{
586 if (!readTag(reader)) {
587 return false;
588 }
589 if (!readArgs(reader)) {
590 return false;
591 }
592 return true;
593}
594
596{
597 std::string tag = reader.readTag(s_tag_len);
598 if (reader.isError()) {
599 return false;
600 }
601 if (tag != s_tag) {
602 reader.fail();
603 return false;
604 }
605 return true;
606}
607
609{
610 if (!reader.noMore()) {
611 reader.fail();
612 return false;
613 }
614 return true;
615}
616
618{
619 yarp::os::idl::WireWriter writer(connection);
620 return write(writer);
621}
622
624{
625 yarp::os::idl::WireReader reader(connection);
626 return read(reader);
627}
628
630{
631 if (!writer.isNull()) {
632 if (!writer.writeListHeader(s_reply_len)) {
633 return false;
634 }
635 if (!writer.writeString(return_helper)) {
636 return false;
637 }
638 }
639 return true;
640}
641
643{
644 if (!reader.readListReturn()) {
645 return false;
646 }
647 if (reader.noMore()) {
648 reader.fail();
649 return false;
650 }
651 if (!reader.readString(return_helper)) {
652 reader.fail();
653 return false;
654 }
655 return true;
656}
657
662
663// get_level helper class implementation
665{
666 return cmd.write(connection);
667}
668
670{
671 return reply.read(connection);
672}
673
675{
676 yarp::os::idl::WireWriter writer(connection);
677 if (!writer.writeListHeader(s_cmd_len)) {
678 return false;
679 }
680 return write(writer);
681}
682
684{
685 yarp::os::idl::WireReader reader(connection);
686 if (!reader.readListHeader()) {
687 reader.fail();
688 return false;
689 }
690 return read(reader);
691}
692
694{
695 if (!writeTag(writer)) {
696 return false;
697 }
698 if (!writeArgs(writer)) {
699 return false;
700 }
701 return true;
702}
703
705{
706 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
707 return false;
708 }
709 return true;
710}
711
713{
714 return true;
715}
716
718{
719 if (!readTag(reader)) {
720 return false;
721 }
722 if (!readArgs(reader)) {
723 return false;
724 }
725 return true;
726}
727
729{
730 std::string tag = reader.readTag(s_tag_len);
731 if (reader.isError()) {
732 return false;
733 }
734 if (tag != s_tag) {
735 reader.fail();
736 return false;
737 }
738 return true;
739}
740
742{
743 if (!reader.noMore()) {
744 reader.fail();
745 return false;
746 }
747 return true;
748}
749
751{
752 yarp::os::idl::WireWriter writer(connection);
753 return write(writer);
754}
755
757{
758 yarp::os::idl::WireReader reader(connection);
759 return read(reader);
760}
761
763{
764 if (!writer.isNull()) {
765 if (!writer.writeListHeader(s_reply_len)) {
766 return false;
767 }
768 if (!writer.writeI32(return_helper)) {
769 return false;
770 }
771 }
772 return true;
773}
774
776{
777 if (!reader.readListReturn()) {
778 return false;
779 }
780 if (reader.noMore()) {
781 reader.fail();
782 return false;
783 }
784 if (!reader.readI32(return_helper)) {
785 reader.fail();
786 return false;
787 }
788 return true;
789}
790
795
796// get_robot helper class implementation
798{
799 return cmd.write(connection);
800}
801
803{
804 return reply.read(connection);
805}
806
808{
809 yarp::os::idl::WireWriter writer(connection);
810 if (!writer.writeListHeader(s_cmd_len)) {
811 return false;
812 }
813 return write(writer);
814}
815
817{
818 yarp::os::idl::WireReader reader(connection);
819 if (!reader.readListHeader()) {
820 reader.fail();
821 return false;
822 }
823 return read(reader);
824}
825
827{
828 if (!writeTag(writer)) {
829 return false;
830 }
831 if (!writeArgs(writer)) {
832 return false;
833 }
834 return true;
835}
836
838{
839 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
840 return false;
841 }
842 return true;
843}
844
846{
847 return true;
848}
849
851{
852 if (!readTag(reader)) {
853 return false;
854 }
855 if (!readArgs(reader)) {
856 return false;
857 }
858 return true;
859}
860
862{
863 std::string tag = reader.readTag(s_tag_len);
864 if (reader.isError()) {
865 return false;
866 }
867 if (tag != s_tag) {
868 reader.fail();
869 return false;
870 }
871 return true;
872}
873
875{
876 if (!reader.noMore()) {
877 reader.fail();
878 return false;
879 }
880 return true;
881}
882
884{
885 yarp::os::idl::WireWriter writer(connection);
886 return write(writer);
887}
888
890{
891 yarp::os::idl::WireReader reader(connection);
892 return read(reader);
893}
894
896{
897 if (!writer.isNull()) {
898 if (!writer.writeListHeader(s_reply_len)) {
899 return false;
900 }
901 if (!writer.writeString(return_helper)) {
902 return false;
903 }
904 }
905 return true;
906}
907
909{
910 if (!reader.readListReturn()) {
911 return false;
912 }
913 if (reader.noMore()) {
914 reader.fail();
915 return false;
916 }
917 if (!reader.readString(return_helper)) {
918 reader.fail();
919 return false;
920 }
921 return true;
922}
923
928
929// is_ready helper class implementation
931{
932 return cmd.write(connection);
933}
934
936{
937 return reply.read(connection);
938}
939
941{
942 yarp::os::idl::WireWriter writer(connection);
943 if (!writer.writeListHeader(s_cmd_len)) {
944 return false;
945 }
946 return write(writer);
947}
948
950{
951 yarp::os::idl::WireReader reader(connection);
952 if (!reader.readListHeader()) {
953 reader.fail();
954 return false;
955 }
956 return read(reader);
957}
958
960{
961 if (!writeTag(writer)) {
962 return false;
963 }
964 if (!writeArgs(writer)) {
965 return false;
966 }
967 return true;
968}
969
971{
972 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
973 return false;
974 }
975 return true;
976}
977
979{
980 return true;
981}
982
984{
985 if (!readTag(reader)) {
986 return false;
987 }
988 if (!readArgs(reader)) {
989 return false;
990 }
991 return true;
992}
993
995{
996 std::string tag = reader.readTag(s_tag_len);
997 if (reader.isError()) {
998 return false;
999 }
1000 if (tag != s_tag) {
1001 reader.fail();
1002 return false;
1003 }
1004 return true;
1005}
1006
1008{
1009 if (!reader.noMore()) {
1010 reader.fail();
1011 return false;
1012 }
1013 return true;
1014}
1015
1017{
1018 yarp::os::idl::WireWriter writer(connection);
1019 return write(writer);
1020}
1021
1023{
1024 yarp::os::idl::WireReader reader(connection);
1025 return read(reader);
1026}
1027
1029{
1030 if (!writer.isNull()) {
1031 if (!writer.writeListHeader(s_reply_len)) {
1032 return false;
1033 }
1034 if (!writer.writeBool(return_helper)) {
1035 return false;
1036 }
1037 }
1038 return true;
1039}
1040
1042{
1043 if (!reader.readListReturn()) {
1044 return false;
1045 }
1046 if (reader.noMore()) {
1047 reader.fail();
1048 return false;
1049 }
1050 if (!reader.readBool(return_helper)) {
1051 reader.fail();
1052 return false;
1053 }
1054 return true;
1055}
1056
1061
1062// quit helper class implementation
1064{
1065 return cmd.write(connection);
1066}
1067
1069{
1070 return reply.read(connection);
1071}
1072
1074{
1075 yarp::os::idl::WireWriter writer(connection);
1076 if (!writer.writeListHeader(s_cmd_len)) {
1077 return false;
1078 }
1079 return write(writer);
1080}
1081
1083{
1084 yarp::os::idl::WireReader reader(connection);
1085 if (!reader.readListHeader()) {
1086 reader.fail();
1087 return false;
1088 }
1089 return read(reader);
1090}
1091
1093{
1094 if (!writeTag(writer)) {
1095 return false;
1096 }
1097 if (!writeArgs(writer)) {
1098 return false;
1099 }
1100 return true;
1101}
1102
1104{
1105 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1106 return false;
1107 }
1108 return true;
1109}
1110
1112{
1113 return true;
1114}
1115
1117{
1118 if (!readTag(reader)) {
1119 return false;
1120 }
1121 if (!readArgs(reader)) {
1122 return false;
1123 }
1124 return true;
1125}
1126
1128{
1129 std::string tag = reader.readTag(s_tag_len);
1130 if (reader.isError()) {
1131 return false;
1132 }
1133 if (tag != s_tag) {
1134 reader.fail();
1135 return false;
1136 }
1137 return true;
1138}
1139
1141{
1142 if (!reader.noMore()) {
1143 reader.fail();
1144 return false;
1145 }
1146 return true;
1147}
1148
1150{
1151 yarp::os::idl::WireWriter writer(connection);
1152 return write(writer);
1153}
1154
1156{
1157 yarp::os::idl::WireReader reader(connection);
1158 return read(reader);
1159}
1160
1162{
1163 if (!writer.isNull()) {
1164 if (!writer.writeListHeader(s_reply_len)) {
1165 return false;
1166 }
1167 if (!writer.writeString(return_helper)) {
1168 return false;
1169 }
1170 }
1171 return true;
1172}
1173
1175{
1176 if (!reader.readListReturn()) {
1177 return false;
1178 }
1179 if (reader.noMore()) {
1180 reader.fail();
1181 return false;
1182 }
1183 if (!reader.readString(return_helper)) {
1184 reader.fail();
1185 return false;
1186 }
1187 return true;
1188}
1189
1194
1195// bye helper class implementation
1197{
1198 return cmd.write(connection);
1199}
1200
1202{
1203 return reply.read(connection);
1204}
1205
1207{
1208 yarp::os::idl::WireWriter writer(connection);
1209 if (!writer.writeListHeader(s_cmd_len)) {
1210 return false;
1211 }
1212 return write(writer);
1213}
1214
1216{
1217 yarp::os::idl::WireReader reader(connection);
1218 if (!reader.readListHeader()) {
1219 reader.fail();
1220 return false;
1221 }
1222 return read(reader);
1223}
1224
1226{
1227 if (!writeTag(writer)) {
1228 return false;
1229 }
1230 if (!writeArgs(writer)) {
1231 return false;
1232 }
1233 return true;
1234}
1235
1237{
1238 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1239 return false;
1240 }
1241 return true;
1242}
1243
1245{
1246 return true;
1247}
1248
1250{
1251 if (!readTag(reader)) {
1252 return false;
1253 }
1254 if (!readArgs(reader)) {
1255 return false;
1256 }
1257 return true;
1258}
1259
1261{
1262 std::string tag = reader.readTag(s_tag_len);
1263 if (reader.isError()) {
1264 return false;
1265 }
1266 if (tag != s_tag) {
1267 reader.fail();
1268 return false;
1269 }
1270 return true;
1271}
1272
1274{
1275 if (!reader.noMore()) {
1276 reader.fail();
1277 return false;
1278 }
1279 return true;
1280}
1281
1283{
1284 yarp::os::idl::WireWriter writer(connection);
1285 return write(writer);
1286}
1287
1289{
1290 yarp::os::idl::WireReader reader(connection);
1291 return read(reader);
1292}
1293
1295{
1296 if (!writer.isNull()) {
1297 if (!writer.writeListHeader(s_reply_len)) {
1298 return false;
1299 }
1300 if (!writer.writeString(return_helper)) {
1301 return false;
1302 }
1303 }
1304 return true;
1305}
1306
1308{
1309 if (!reader.readListReturn()) {
1310 return false;
1311 }
1312 if (reader.noMore()) {
1313 reader.fail();
1314 return false;
1315 }
1316 if (!reader.readString(return_helper)) {
1317 reader.fail();
1318 return false;
1319 }
1320 return true;
1321}
1322
1327
1328// exit helper class implementation
1330{
1331 return cmd.write(connection);
1332}
1333
1335{
1336 return reply.read(connection);
1337}
1338
1340{
1341 yarp::os::idl::WireWriter writer(connection);
1342 if (!writer.writeListHeader(s_cmd_len)) {
1343 return false;
1344 }
1345 return write(writer);
1346}
1347
1349{
1350 yarp::os::idl::WireReader reader(connection);
1351 if (!reader.readListHeader()) {
1352 reader.fail();
1353 return false;
1354 }
1355 return read(reader);
1356}
1357
1359{
1360 if (!writeTag(writer)) {
1361 return false;
1362 }
1363 if (!writeArgs(writer)) {
1364 return false;
1365 }
1366 return true;
1367}
1368
1370{
1371 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1372 return false;
1373 }
1374 return true;
1375}
1376
1378{
1379 return true;
1380}
1381
1383{
1384 if (!readTag(reader)) {
1385 return false;
1386 }
1387 if (!readArgs(reader)) {
1388 return false;
1389 }
1390 return true;
1391}
1392
1394{
1395 std::string tag = reader.readTag(s_tag_len);
1396 if (reader.isError()) {
1397 return false;
1398 }
1399 if (tag != s_tag) {
1400 reader.fail();
1401 return false;
1402 }
1403 return true;
1404}
1405
1407{
1408 if (!reader.noMore()) {
1409 reader.fail();
1410 return false;
1411 }
1412 return true;
1413}
1414
1416{
1417 yarp::os::idl::WireWriter writer(connection);
1418 return write(writer);
1419}
1420
1422{
1423 yarp::os::idl::WireReader reader(connection);
1424 return read(reader);
1425}
1426
1428{
1429 if (!writer.isNull()) {
1430 if (!writer.writeListHeader(s_reply_len)) {
1431 return false;
1432 }
1433 if (!writer.writeString(return_helper)) {
1434 return false;
1435 }
1436 }
1437 return true;
1438}
1439
1441{
1442 if (!reader.readListReturn()) {
1443 return false;
1444 }
1445 if (reader.noMore()) {
1446 reader.fail();
1447 return false;
1448 }
1449 if (!reader.readString(return_helper)) {
1450 reader.fail();
1451 return false;
1452 }
1453 return true;
1454}
1455
1460
1461// Constructor
1463{
1464 yarp().setOwner(*this);
1465}
1466
1468{
1469 if (!yarp().canWrite()) {
1470 yError("Missing server method '%s'?", yarprobotinterfaceRpc_get_phase_helper::s_prototype);
1471 }
1473 bool ok = yarp().write(helper, helper);
1474 return ok ? helper.reply.return_helper : std::string{};
1475}
1476
1478{
1479 if (!yarp().canWrite()) {
1480 yError("Missing server method '%s'?", yarprobotinterfaceRpc_get_level_helper::s_prototype);
1481 }
1483 bool ok = yarp().write(helper, helper);
1484 return ok ? helper.reply.return_helper : std::int32_t{};
1485}
1486
1488{
1489 if (!yarp().canWrite()) {
1490 yError("Missing server method '%s'?", yarprobotinterfaceRpc_get_robot_helper::s_prototype);
1491 }
1493 bool ok = yarp().write(helper, helper);
1494 return ok ? helper.reply.return_helper : std::string{};
1495}
1496
1498{
1499 if (!yarp().canWrite()) {
1500 yError("Missing server method '%s'?", yarprobotinterfaceRpc_is_ready_helper::s_prototype);
1501 }
1503 bool ok = yarp().write(helper, helper);
1504 return ok ? helper.reply.return_helper : bool{};
1505}
1506
1508{
1509 if (!yarp().canWrite()) {
1510 yError("Missing server method '%s'?", yarprobotinterfaceRpc_quit_helper::s_prototype);
1511 }
1513 bool ok = yarp().write(helper, helper);
1514 return ok ? helper.reply.return_helper : std::string{};
1515}
1516
1518{
1519 if (!yarp().canWrite()) {
1520 yError("Missing server method '%s'?", yarprobotinterfaceRpc_bye_helper::s_prototype);
1521 }
1523 bool ok = yarp().write(helper, helper);
1524 return ok ? helper.reply.return_helper : std::string{};
1525}
1526
1528{
1529 if (!yarp().canWrite()) {
1530 yError("Missing server method '%s'?", yarprobotinterfaceRpc_exit_helper::s_prototype);
1531 }
1533 bool ok = yarp().write(helper, helper);
1534 return ok ? helper.reply.return_helper : std::string{};
1535}
1536
1537// help method
1538std::vector<std::string> yarprobotinterfaceRpc::help(const std::string& functionName)
1539{
1540 bool showAll = (functionName == "--all");
1541 std::vector<std::string> helpString;
1542 if (showAll) {
1543 helpString.emplace_back("*** Available commands:");
1544 helpString.emplace_back(yarprobotinterfaceRpc_get_phase_helper::s_tag);
1545 helpString.emplace_back(yarprobotinterfaceRpc_get_level_helper::s_tag);
1546 helpString.emplace_back(yarprobotinterfaceRpc_get_robot_helper::s_tag);
1547 helpString.emplace_back(yarprobotinterfaceRpc_is_ready_helper::s_tag);
1548 helpString.emplace_back(yarprobotinterfaceRpc_quit_helper::s_tag);
1549 helpString.emplace_back(yarprobotinterfaceRpc_bye_helper::s_tag);
1550 helpString.emplace_back(yarprobotinterfaceRpc_exit_helper::s_tag);
1551 helpString.emplace_back("help");
1552 } else {
1555 helpString.emplace_back(yarprobotinterfaceRpc_get_phase_helper::s_help);
1556 }
1559 helpString.emplace_back(yarprobotinterfaceRpc_get_level_helper::s_help);
1560 }
1563 helpString.emplace_back(yarprobotinterfaceRpc_get_robot_helper::s_help);
1564 }
1567 helpString.emplace_back(yarprobotinterfaceRpc_is_ready_helper::s_help);
1568 }
1569 if (functionName == yarprobotinterfaceRpc_quit_helper::s_tag) {
1570 helpString.emplace_back(yarprobotinterfaceRpc_quit_helper::s_prototype);
1571 helpString.emplace_back(yarprobotinterfaceRpc_quit_helper::s_help);
1572 }
1573 if (functionName == yarprobotinterfaceRpc_bye_helper::s_tag) {
1574 helpString.emplace_back(yarprobotinterfaceRpc_bye_helper::s_prototype);
1575 helpString.emplace_back(yarprobotinterfaceRpc_bye_helper::s_help);
1576 }
1577 if (functionName == yarprobotinterfaceRpc_exit_helper::s_tag) {
1578 helpString.emplace_back(yarprobotinterfaceRpc_exit_helper::s_prototype);
1579 helpString.emplace_back(yarprobotinterfaceRpc_exit_helper::s_help);
1580 }
1581 if (functionName == "help") {
1582 helpString.emplace_back("std::vector<std::string> help(const std::string& functionName = \"--all\")");
1583 helpString.emplace_back("Return list of available commands, or help message for a specific function");
1584 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");
1585 helpString.emplace_back("@return list of strings (one string per line)");
1586 }
1587 }
1588 if (helpString.empty()) {
1589 helpString.emplace_back("Command not found");
1590 }
1591 return helpString;
1592}
1593
1594// read from ConnectionReader
1596{
1597 constexpr size_t max_tag_len = 2;
1598 size_t tag_len = 1;
1599
1600 yarp::os::idl::WireReader reader(connection);
1601 reader.expectAccept();
1602 if (!reader.readListHeader()) {
1603 reader.fail();
1604 return false;
1605 }
1606
1607 std::string tag = reader.readTag(1);
1608 bool direct = (tag == "__direct__");
1609 if (direct) {
1610 tag = reader.readTag(1);
1611 }
1612 while (tag_len <= max_tag_len && !reader.isError()) {
1613 if(tag == "getRemoteProtocolVersion") {
1614 if (!reader.noMore()) {
1615 yError("Reader invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
1616 reader.fail();
1617 return false;
1618 }
1619
1620 auto proto = getLocalProtocolVersion();
1621
1622 yarp::os::idl::WireWriter writer(reader);
1623 if (!writer.writeListHeader(1)) {
1624 yWarning("Writer invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
1625 return false;}
1626 if (!writer.write(proto)) {
1627 yWarning("Writer invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
1628 return false;
1629 }
1630 reader.accept();
1631 return true;
1632 }
1635 if (!helper.cmd.readArgs(reader)) {
1636 return false;
1637 }
1638
1639 helper.call(this);
1640
1641 yarp::os::idl::WireWriter writer(reader);
1642 if (!helper.reply.write(writer)) {
1643 return false;
1644 }
1645 reader.accept();
1646 return true;
1647 }
1650 if (!helper.cmd.readArgs(reader)) {
1651 return false;
1652 }
1653
1654 helper.call(this);
1655
1656 yarp::os::idl::WireWriter writer(reader);
1657 if (!helper.reply.write(writer)) {
1658 return false;
1659 }
1660 reader.accept();
1661 return true;
1662 }
1665 if (!helper.cmd.readArgs(reader)) {
1666 return false;
1667 }
1668
1669 helper.call(this);
1670
1671 yarp::os::idl::WireWriter writer(reader);
1672 if (!helper.reply.write(writer)) {
1673 return false;
1674 }
1675 reader.accept();
1676 return true;
1677 }
1680 if (!helper.cmd.readArgs(reader)) {
1681 return false;
1682 }
1683
1684 helper.call(this);
1685
1686 yarp::os::idl::WireWriter writer(reader);
1687 if (!helper.reply.write(writer)) {
1688 return false;
1689 }
1690 reader.accept();
1691 return true;
1692 }
1695 if (!helper.cmd.readArgs(reader)) {
1696 return false;
1697 }
1698
1699 helper.call(this);
1700
1701 yarp::os::idl::WireWriter writer(reader);
1702 if (!helper.reply.write(writer)) {
1703 return false;
1704 }
1705 reader.accept();
1706 return true;
1707 }
1710 if (!helper.cmd.readArgs(reader)) {
1711 return false;
1712 }
1713
1714 helper.call(this);
1715
1716 yarp::os::idl::WireWriter writer(reader);
1717 if (!helper.reply.write(writer)) {
1718 return false;
1719 }
1720 reader.accept();
1721 return true;
1722 }
1725 if (!helper.cmd.readArgs(reader)) {
1726 return false;
1727 }
1728
1729 helper.call(this);
1730
1731 yarp::os::idl::WireWriter writer(reader);
1732 if (!helper.reply.write(writer)) {
1733 return false;
1734 }
1735 reader.accept();
1736 return true;
1737 }
1738 if (tag == "help") {
1739 std::string functionName;
1740 if (!reader.readString(functionName)) {
1741 functionName = "--all";
1742 }
1743 auto help_strings = help(functionName);
1744 yarp::os::idl::WireWriter writer(reader);
1745 if (!writer.isNull()) {
1746 if (!writer.writeListHeader(2)) {
1747 return false;
1748 }
1749 if (!writer.writeTag("many", 1, 0)) {
1750 return false;
1751 }
1752 if (!writer.writeListBegin(0, help_strings.size())) {
1753 return false;
1754 }
1755 for (const auto& help_string : help_strings) {
1756 if (!writer.writeString(help_string)) {
1757 return false;
1758 }
1759 }
1760 if (!writer.writeListEnd()) {
1761 return false;
1762 }
1763 }
1764 reader.accept();
1765 return true;
1766 }
1767 if (reader.noMore()) {
1768 reader.fail();
1769 return false;
1770 }
1771 std::string next_tag = reader.readTag(1);
1772 if (next_tag.empty()) {
1773 break;
1774 }
1775 tag.append("_").append(next_tag);
1776 tag_len = std::count(tag.begin(), tag.end(), '_') + 1;
1777 }
1778 return false;
1779}
#define yError(...)
Definition Log.h:361
#define __YFUNCTION__
Definition Log.h:24
#define yWarning(...)
Definition Log.h:340
An interface for reading from a network connection.
An interface for writing to a network connection.
This is a base class for objects that can be both read from and be written to the YARP network.
Definition Portable.h:25
yarp::os::WireLink & yarp()
Get YARP state associated with this object.
Definition Wire.h:28
A "tamed" Portable, that promises to serialize itself in an IDL-friendly way.
IDL-friendly connection reader.
Definition WireReader.h:27
bool readString(std::string &str, bool *is_vocab=nullptr)
bool readI32(std::int32_t &x)
std::string readTag(size_t len=static_cast< size_t >(-1))
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 writeString(const std::string &str, bool skip_tag=false) const
bool writeListBegin(int tag, size_t len) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool readArgs(yarp::os::idl::WireReader &reader)
bool 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 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
static constexpr const char * s_help
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
void call(yarprobotinterfaceRpc *ptr)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool readTag(yarp::os::idl::WireReader &reader)
bool readArgs(yarp::os::idl::WireReader &reader)
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool 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
void call(yarprobotinterfaceRpc *ptr)
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.
yarp::os::ApplicationNetworkProtocolVersion helper_proto
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 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 readTag(yarp::os::idl::WireReader &reader)
bool readArgs(yarp::os::idl::WireReader &reader)
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
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 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 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 writeArgs(const yarp::os::idl::WireWriter &writer) const
bool readArgs(yarp::os::idl::WireReader &reader)
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool readTag(yarp::os::idl::WireReader &reader)
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
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 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.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool readTag(yarp::os::idl::WireReader &reader)
bool 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 read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_prototype
static constexpr const char * s_tag
static constexpr const char * s_help
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
void call(yarprobotinterfaceRpc *ptr)
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
virtual std::string quit()
Closes yarprobotinterface.
virtual std::string get_phase()
Returns current phase.
virtual std::string get_robot()
Returns robot name.
virtual std::string bye()
Closes yarprobotinterface.
virtual std::string exit()
Closes yarprobotinterface.
virtual std::int32_t get_level()
Returns current level.
virtual yarp::os::ApplicationNetworkProtocolVersion getLocalProtocolVersion()
virtual std::vector< std::string > help(const std::string &functionName="--all")
virtual yarp::os::ApplicationNetworkProtocolVersion getRemoteProtocolVersion()
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
virtual bool is_ready()
Returns true if yarprobotinterface is ready (all startup actions performed and no interrupt called).
#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