YARP
Yet Another Robot Platform
 
Loading...
Searching...
No Matches
IChatBotMsgs.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 <IChatBotMsgs.h>
15#include <yarp/os/LogStream.h>
16
18
19#include <algorithm>
20
21namespace
22{
23 YARP_LOG_COMPONENT(SERVICE_LOG_COMPONENT, "IChatBotMsgs")
24}
25
26//IChatBotMsgs_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 IChatBotMsgs_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 IChatBotMsgs::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// interactRPC helper class declaration
111 public yarp::os::Portable
112{
113public:
115 explicit IChatBotMsgs_interactRPC_helper(const std::string& messageIn);
116 bool write(yarp::os::ConnectionWriter& connection) const override;
117 bool read(yarp::os::ConnectionReader& connection) override;
118
119 class Command :
121 {
122 public:
123 Command() = default;
124 explicit Command(const std::string& messageIn);
125
126 ~Command() override = default;
127
128 bool write(yarp::os::ConnectionWriter& connection) const override;
129 bool read(yarp::os::ConnectionReader& connection) override;
130
131 bool write(const yarp::os::idl::WireWriter& writer) const override;
132 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
133 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
134
135 bool read(yarp::os::idl::WireReader& reader) override;
138
139 std::string messageIn{};
140 };
141
142 class Reply :
144 {
145 public:
146 Reply() = default;
147 ~Reply() override = default;
148
149 bool write(yarp::os::ConnectionWriter& connection) const override;
150 bool read(yarp::os::ConnectionReader& connection) override;
151
152 bool write(const yarp::os::idl::WireWriter& writer) const override;
153 bool read(yarp::os::idl::WireReader& reader) override;
154
156 };
157
158 using funcptr_t = return_interact (*)(const std::string&);
159 void call(IChatBotMsgs* ptr);
160
163
164 static constexpr const char* s_tag{"interactRPC"};
165 static constexpr size_t s_tag_len{1};
166 static constexpr size_t s_cmd_len{2};
167 static constexpr size_t s_reply_len{2};
168 static constexpr const char* s_prototype{"return_interact IChatBotMsgs::interactRPC(const std::string& messageIn)"};
169 static constexpr const char* s_help{""};
170};
171
172// setLanguageRPC helper class declaration
174 public yarp::os::Portable
175{
176public:
178 explicit IChatBotMsgs_setLanguageRPC_helper(const std::string& language);
179 bool write(yarp::os::ConnectionWriter& connection) const override;
180 bool read(yarp::os::ConnectionReader& connection) override;
181
182 class Command :
184 {
185 public:
186 Command() = default;
187 explicit Command(const std::string& language);
188
189 ~Command() override = default;
190
191 bool write(yarp::os::ConnectionWriter& connection) const override;
192 bool read(yarp::os::ConnectionReader& connection) override;
193
194 bool write(const yarp::os::idl::WireWriter& writer) const override;
195 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
196 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
197
198 bool read(yarp::os::idl::WireReader& reader) override;
201
202 std::string language{};
203 };
204
205 class Reply :
207 {
208 public:
209 Reply() = default;
210 ~Reply() override = default;
211
212 bool write(yarp::os::ConnectionWriter& connection) const override;
213 bool read(yarp::os::ConnectionReader& connection) override;
214
215 bool write(const yarp::os::idl::WireWriter& writer) const override;
216 bool read(yarp::os::idl::WireReader& reader) override;
217
219 };
220
221 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&);
222 void call(IChatBotMsgs* ptr);
223
226
227 static constexpr const char* s_tag{"setLanguageRPC"};
228 static constexpr size_t s_tag_len{1};
229 static constexpr size_t s_cmd_len{2};
230 static constexpr size_t s_reply_len{1};
231 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IChatBotMsgs::setLanguageRPC(const std::string& language)"};
232 static constexpr const char* s_help{""};
233};
234
235// getLanguageRPC helper class declaration
237 public yarp::os::Portable
238{
239public:
241 bool write(yarp::os::ConnectionWriter& connection) const override;
242 bool read(yarp::os::ConnectionReader& connection) override;
243
244 class Command :
246 {
247 public:
248 Command() = default;
249 ~Command() override = default;
250
251 bool write(yarp::os::ConnectionWriter& connection) const override;
252 bool read(yarp::os::ConnectionReader& connection) override;
253
254 bool write(const yarp::os::idl::WireWriter& writer) const override;
255 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
256 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
257
258 bool read(yarp::os::idl::WireReader& reader) override;
261 };
262
263 class Reply :
265 {
266 public:
267 Reply() = default;
268 ~Reply() override = default;
269
270 bool write(yarp::os::ConnectionWriter& connection) const override;
271 bool read(yarp::os::ConnectionReader& connection) override;
272
273 bool write(const yarp::os::idl::WireWriter& writer) const override;
274 bool read(yarp::os::idl::WireReader& reader) override;
275
277 };
278
280 void call(IChatBotMsgs* ptr);
281
284
285 static constexpr const char* s_tag{"getLanguageRPC"};
286 static constexpr size_t s_tag_len{1};
287 static constexpr size_t s_cmd_len{1};
288 static constexpr size_t s_reply_len{2};
289 static constexpr const char* s_prototype{"return_getLanguage IChatBotMsgs::getLanguageRPC()"};
290 static constexpr const char* s_help{""};
291};
292
293// getStatusRPC helper class declaration
295 public yarp::os::Portable
296{
297public:
299 bool write(yarp::os::ConnectionWriter& connection) const override;
300 bool read(yarp::os::ConnectionReader& connection) override;
301
302 class Command :
304 {
305 public:
306 Command() = default;
307 ~Command() override = default;
308
309 bool write(yarp::os::ConnectionWriter& connection) const override;
310 bool read(yarp::os::ConnectionReader& connection) override;
311
312 bool write(const yarp::os::idl::WireWriter& writer) const override;
313 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
314 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
315
316 bool read(yarp::os::idl::WireReader& reader) override;
319 };
320
321 class Reply :
323 {
324 public:
325 Reply() = default;
326 ~Reply() override = default;
327
328 bool write(yarp::os::ConnectionWriter& connection) const override;
329 bool read(yarp::os::ConnectionReader& connection) override;
330
331 bool write(const yarp::os::idl::WireWriter& writer) const override;
332 bool read(yarp::os::idl::WireReader& reader) override;
333
335 };
336
338 void call(IChatBotMsgs* ptr);
339
342
343 static constexpr const char* s_tag{"getStatusRPC"};
344 static constexpr size_t s_tag_len{1};
345 static constexpr size_t s_cmd_len{1};
346 static constexpr size_t s_reply_len{2};
347 static constexpr const char* s_prototype{"return_getStatus IChatBotMsgs::getStatusRPC()"};
348 static constexpr const char* s_help{""};
349};
350
351// resetBotRPC helper class declaration
353 public yarp::os::Portable
354{
355public:
357 bool write(yarp::os::ConnectionWriter& connection) const override;
358 bool read(yarp::os::ConnectionReader& connection) override;
359
360 class Command :
362 {
363 public:
364 Command() = default;
365 ~Command() override = default;
366
367 bool write(yarp::os::ConnectionWriter& connection) const override;
368 bool read(yarp::os::ConnectionReader& connection) override;
369
370 bool write(const yarp::os::idl::WireWriter& writer) const override;
371 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
372 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
373
374 bool read(yarp::os::idl::WireReader& reader) override;
377 };
378
379 class Reply :
381 {
382 public:
383 Reply() = default;
384 ~Reply() override = default;
385
386 bool write(yarp::os::ConnectionWriter& connection) const override;
387 bool read(yarp::os::ConnectionReader& connection) override;
388
389 bool write(const yarp::os::idl::WireWriter& writer) const override;
390 bool read(yarp::os::idl::WireReader& reader) override;
391
393 };
394
396 void call(IChatBotMsgs* ptr);
397
400
401 static constexpr const char* s_tag{"resetBotRPC"};
402 static constexpr size_t s_tag_len{1};
403 static constexpr size_t s_cmd_len{1};
404 static constexpr size_t s_reply_len{1};
405 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IChatBotMsgs::resetBotRPC()"};
406 static constexpr const char* s_help{""};
407};
408
409// interactRPC helper class implementation
411 cmd{messageIn}
412{
413}
414
416{
417 return cmd.write(connection);
418}
419
421{
422 return reply.read(connection);
423}
424
426 messageIn{messageIn}
427{
428}
429
431{
432 yarp::os::idl::WireWriter writer(connection);
433 if (!writer.writeListHeader(s_cmd_len)) {
434 return false;
435 }
436 return write(writer);
437}
438
440{
441 yarp::os::idl::WireReader reader(connection);
442 if (!reader.readListHeader()) {
443 reader.fail();
444 return false;
445 }
446 return read(reader);
447}
448
450{
451 if (!writeTag(writer)) {
452 return false;
453 }
454 if (!writeArgs(writer)) {
455 return false;
456 }
457 return true;
458}
459
461{
462 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
463 return false;
464 }
465 return true;
466}
467
469{
470 if (!writer.writeString(messageIn)) {
471 return false;
472 }
473 return true;
474}
475
477{
478 if (!readTag(reader)) {
479 return false;
480 }
481 if (!readArgs(reader)) {
482 return false;
483 }
484 return true;
485}
486
488{
489 std::string tag = reader.readTag(s_tag_len);
490 if (reader.isError()) {
491 return false;
492 }
493 if (tag != s_tag) {
494 reader.fail();
495 return false;
496 }
497 return true;
498}
499
501{
502 if (reader.noMore()) {
503 reader.fail();
504 return false;
505 }
506 if (!reader.readString(messageIn)) {
507 reader.fail();
508 return false;
509 }
510 if (!reader.noMore()) {
511 reader.fail();
512 return false;
513 }
514 return true;
515}
516
518{
519 yarp::os::idl::WireWriter writer(connection);
520 return write(writer);
521}
522
524{
525 yarp::os::idl::WireReader reader(connection);
526 return read(reader);
527}
528
530{
531 if (!writer.isNull()) {
532 if (!writer.writeListHeader(s_reply_len)) {
533 return false;
534 }
535 if (!writer.write(return_helper)) {
536 return false;
537 }
538 }
539 return true;
540}
541
543{
544 if (!reader.readListReturn()) {
545 return false;
546 }
547 if (reader.noMore()) {
548 reader.fail();
549 return false;
550 }
551 if (!reader.read(return_helper)) {
552 reader.fail();
553 return false;
554 }
555 return true;
556}
557
562
563// setLanguageRPC helper class implementation
565 cmd{language}
566{
567}
568
570{
571 return cmd.write(connection);
572}
573
575{
576 return reply.read(connection);
577}
578
580 language{language}
581{
582}
583
585{
586 yarp::os::idl::WireWriter writer(connection);
587 if (!writer.writeListHeader(s_cmd_len)) {
588 return false;
589 }
590 return write(writer);
591}
592
594{
595 yarp::os::idl::WireReader reader(connection);
596 if (!reader.readListHeader()) {
597 reader.fail();
598 return false;
599 }
600 return read(reader);
601}
602
604{
605 if (!writeTag(writer)) {
606 return false;
607 }
608 if (!writeArgs(writer)) {
609 return false;
610 }
611 return true;
612}
613
615{
616 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
617 return false;
618 }
619 return true;
620}
621
623{
624 if (!writer.writeString(language)) {
625 return false;
626 }
627 return true;
628}
629
631{
632 if (!readTag(reader)) {
633 return false;
634 }
635 if (!readArgs(reader)) {
636 return false;
637 }
638 return true;
639}
640
642{
643 std::string tag = reader.readTag(s_tag_len);
644 if (reader.isError()) {
645 return false;
646 }
647 if (tag != s_tag) {
648 reader.fail();
649 return false;
650 }
651 return true;
652}
653
655{
656 if (reader.noMore()) {
657 reader.fail();
658 return false;
659 }
660 if (!reader.readString(language)) {
661 reader.fail();
662 return false;
663 }
664 if (!reader.noMore()) {
665 reader.fail();
666 return false;
667 }
668 return true;
669}
670
672{
673 yarp::os::idl::WireWriter writer(connection);
674 return write(writer);
675}
676
678{
679 yarp::os::idl::WireReader reader(connection);
680 return read(reader);
681}
682
684{
685 if (!writer.isNull()) {
686 if (!writer.write(return_helper)) {
687 return false;
688 }
689 }
690 return true;
691}
692
694{
695 if (reader.noMore()) {
696 reader.fail();
697 return false;
698 }
699 if (!reader.read(return_helper)) {
700 reader.fail();
701 return false;
702 }
703 return true;
704}
705
710
711// getLanguageRPC helper class implementation
713{
714 return cmd.write(connection);
715}
716
718{
719 return reply.read(connection);
720}
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
805{
806 yarp::os::idl::WireReader reader(connection);
807 return read(reader);
808}
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// getStatusRPC helper class implementation
846{
847 return cmd.write(connection);
848}
849
851{
852 return reply.read(connection);
853}
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
938{
939 yarp::os::idl::WireReader reader(connection);
940 return read(reader);
941}
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// resetBotRPC helper class implementation
979{
980 return cmd.write(connection);
981}
982
984{
985 return reply.read(connection);
986}
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.write(return_helper)) {
1080 return false;
1081 }
1082 }
1083 return true;
1084}
1085
1087{
1088 if (reader.noMore()) {
1089 reader.fail();
1090 return false;
1091 }
1092 if (!reader.read(return_helper)) {
1093 reader.fail();
1094 return false;
1095 }
1096 return true;
1097}
1098
1103
1104// Constructor
1106{
1107 yarp().setOwner(*this);
1108}
1109
1110return_interact IChatBotMsgs::interactRPC(const std::string& messageIn)
1111{
1112 if (!yarp().canWrite()) {
1113 yError("Missing server method '%s'?", IChatBotMsgs_interactRPC_helper::s_prototype);
1114 }
1115 IChatBotMsgs_interactRPC_helper helper{messageIn};
1116 bool ok = yarp().write(helper, helper);
1117 if (!ok) {
1118 return_interact failed_reply{};
1120 return failed_reply;
1121 }
1122 return helper.reply.return_helper;
1123}
1124
1126{
1127 if (!yarp().canWrite()) {
1128 yError("Missing server method '%s'?", IChatBotMsgs_setLanguageRPC_helper::s_prototype);
1129 }
1130 IChatBotMsgs_setLanguageRPC_helper helper{language};
1131 bool ok = yarp().write(helper, helper);
1133}
1134
1136{
1137 if (!yarp().canWrite()) {
1138 yError("Missing server method '%s'?", IChatBotMsgs_getLanguageRPC_helper::s_prototype);
1139 }
1141 bool ok = yarp().write(helper, helper);
1142 if (!ok) {
1143 return_getLanguage failed_reply{};
1145 return failed_reply;
1146 }
1147 return helper.reply.return_helper;
1148}
1149
1151{
1152 if (!yarp().canWrite()) {
1153 yError("Missing server method '%s'?", IChatBotMsgs_getStatusRPC_helper::s_prototype);
1154 }
1156 bool ok = yarp().write(helper, helper);
1157 if (!ok) {
1158 return_getStatus failed_reply{};
1160 return failed_reply;
1161 }
1162 return helper.reply.return_helper;
1163}
1164
1166{
1167 if (!yarp().canWrite()) {
1168 yError("Missing server method '%s'?", IChatBotMsgs_resetBotRPC_helper::s_prototype);
1169 }
1171 bool ok = yarp().write(helper, helper);
1173}
1174
1175// help method
1176std::vector<std::string> IChatBotMsgs::help(const std::string& functionName)
1177{
1178 bool showAll = (functionName == "--all");
1179 std::vector<std::string> helpString;
1180 if (showAll) {
1181 helpString.emplace_back("*** Available commands:");
1182 helpString.emplace_back(IChatBotMsgs_interactRPC_helper::s_tag);
1183 helpString.emplace_back(IChatBotMsgs_setLanguageRPC_helper::s_tag);
1184 helpString.emplace_back(IChatBotMsgs_getLanguageRPC_helper::s_tag);
1185 helpString.emplace_back(IChatBotMsgs_getStatusRPC_helper::s_tag);
1186 helpString.emplace_back(IChatBotMsgs_resetBotRPC_helper::s_tag);
1187 helpString.emplace_back("help");
1188 } else {
1189 if (functionName == IChatBotMsgs_interactRPC_helper::s_tag) {
1190 helpString.emplace_back(IChatBotMsgs_interactRPC_helper::s_prototype);
1191 }
1192 if (functionName == IChatBotMsgs_setLanguageRPC_helper::s_tag) {
1193 helpString.emplace_back(IChatBotMsgs_setLanguageRPC_helper::s_prototype);
1194 }
1195 if (functionName == IChatBotMsgs_getLanguageRPC_helper::s_tag) {
1196 helpString.emplace_back(IChatBotMsgs_getLanguageRPC_helper::s_prototype);
1197 }
1198 if (functionName == IChatBotMsgs_getStatusRPC_helper::s_tag) {
1199 helpString.emplace_back(IChatBotMsgs_getStatusRPC_helper::s_prototype);
1200 }
1201 if (functionName == IChatBotMsgs_resetBotRPC_helper::s_tag) {
1202 helpString.emplace_back(IChatBotMsgs_resetBotRPC_helper::s_prototype);
1203 }
1204 if (functionName == "help") {
1205 helpString.emplace_back("std::vector<std::string> help(const std::string& functionName = \"--all\")");
1206 helpString.emplace_back("Return list of available commands, or help message for a specific function");
1207 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");
1208 helpString.emplace_back("@return list of strings (one string per line)");
1209 }
1210 }
1211 if (helpString.empty()) {
1212 helpString.emplace_back("Command not found");
1213 }
1214 return helpString;
1215}
1216
1217// read from ConnectionReader
1219{
1220 constexpr size_t max_tag_len = 1;
1221 size_t tag_len = 1;
1222
1223 yarp::os::idl::WireReader reader(connection);
1224 reader.expectAccept();
1225 if (!reader.readListHeader()) {
1226 reader.fail();
1227 return false;
1228 }
1229
1230 std::string tag = reader.readTag(1);
1231 bool direct = (tag == "__direct__");
1232 if (direct) {
1233 tag = reader.readTag(1);
1234 }
1235 while (tag_len <= max_tag_len && !reader.isError()) {
1236 if(tag == "getRemoteProtocolVersion") {
1237 if (!reader.noMore()) {
1238 yError("Reader invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
1239 reader.fail();
1240 return false;
1241 }
1242
1243 auto proto = getLocalProtocolVersion();
1244
1245 yarp::os::idl::WireWriter writer(reader);
1246 if (!writer.writeListHeader(1)) {
1247 yWarning("Writer invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
1248 return false;}
1249 if (!writer.write(proto)) {
1250 yWarning("Writer invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
1251 return false;
1252 }
1253 reader.accept();
1254 return true;
1255 }
1258 if (!helper.cmd.readArgs(reader)) {
1259 return false;
1260 }
1261
1262 helper.call(this);
1263
1264 yarp::os::idl::WireWriter writer(reader);
1265 if (!helper.reply.write(writer)) {
1266 return false;
1267 }
1268 reader.accept();
1269 return true;
1270 }
1273 if (!helper.cmd.readArgs(reader)) {
1274 return false;
1275 }
1276
1277 helper.call(this);
1278
1279 yarp::os::idl::WireWriter writer(reader);
1280 if (!helper.reply.write(writer)) {
1281 return false;
1282 }
1283 reader.accept();
1284 return true;
1285 }
1288 if (!helper.cmd.readArgs(reader)) {
1289 return false;
1290 }
1291
1292 helper.call(this);
1293
1294 yarp::os::idl::WireWriter writer(reader);
1295 if (!helper.reply.write(writer)) {
1296 return false;
1297 }
1298 reader.accept();
1299 return true;
1300 }
1303 if (!helper.cmd.readArgs(reader)) {
1304 return false;
1305 }
1306
1307 helper.call(this);
1308
1309 yarp::os::idl::WireWriter writer(reader);
1310 if (!helper.reply.write(writer)) {
1311 return false;
1312 }
1313 reader.accept();
1314 return true;
1315 }
1318 if (!helper.cmd.readArgs(reader)) {
1319 return false;
1320 }
1321
1322 helper.call(this);
1323
1324 yarp::os::idl::WireWriter writer(reader);
1325 if (!helper.reply.write(writer)) {
1326 return false;
1327 }
1328 reader.accept();
1329 return true;
1330 }
1331 if (tag == "help") {
1332 std::string functionName;
1333 if (!reader.readString(functionName)) {
1334 functionName = "--all";
1335 }
1336 auto help_strings = help(functionName);
1337 yarp::os::idl::WireWriter writer(reader);
1338 if (!writer.isNull()) {
1339 if (!writer.writeListHeader(2)) {
1340 return false;
1341 }
1342 if (!writer.writeTag("many", 1, 0)) {
1343 return false;
1344 }
1345 if (!writer.writeListBegin(0, help_strings.size())) {
1346 return false;
1347 }
1348 for (const auto& help_string : help_strings) {
1349 if (!writer.writeString(help_string)) {
1350 return false;
1351 }
1352 }
1353 if (!writer.writeListEnd()) {
1354 return false;
1355 }
1356 }
1357 reader.accept();
1358 return true;
1359 }
1360 if (reader.noMore()) {
1361 reader.fail();
1362 return false;
1363 }
1364 std::string next_tag = reader.readTag(1);
1365 if (next_tag.empty()) {
1366 break;
1367 }
1368 tag.append("_").append(next_tag);
1369 tag_len = std::count(tag.begin(), tag.end(), '_') + 1;
1370 }
1371 return false;
1372}
#define yError(...)
Definition Log.h:361
#define __YFUNCTION__
Definition Log.h:24
#define yWarning(...)
Definition Log.h:340
bool readArgs(yarp::os::idl::WireReader &reader)
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool readTag(yarp::os::idl::WireReader &reader)
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool 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_help
static constexpr const char * s_tag
static constexpr const char * s_prototype
static constexpr size_t s_reply_len
static constexpr size_t s_cmd_len
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.
return_getLanguage(*)() funcptr_t
static constexpr size_t s_tag_len
yarp::os::ApplicationNetworkProtocolVersion helper_proto
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 write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool readArgs(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_help
return_getStatus(*)() funcptr_t
static constexpr const char * s_tag
static constexpr size_t s_reply_len
static constexpr size_t s_cmd_len
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
void call(IChatBotMsgs *ptr)
static constexpr const char * s_prototype
static constexpr size_t s_tag_len
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool readArgs(yarp::os::idl::WireReader &reader)
bool readTag(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr size_t s_reply_len
static constexpr const char * s_prototype
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_tag
static constexpr const char * s_help
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr size_t s_cmd_len
static constexpr size_t s_tag_len
return_interact(*)(const std::string &) funcptr_t
void call(IChatBotMsgs *ptr)
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 readArgs(yarp::os::idl::WireReader &reader)
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_tag
static constexpr const char * s_help
static constexpr const char * s_prototype
void call(IChatBotMsgs *ptr)
static constexpr size_t s_tag_len
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 size_t s_reply_len
static constexpr size_t s_cmd_len
yarp::dev::ReturnValue(*)() funcptr_t
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 readTag(yarp::os::idl::WireReader &reader)
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_prototype
static constexpr size_t s_reply_len
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_tag
static constexpr size_t s_cmd_len
static constexpr const char * s_help
yarp::dev::ReturnValue(*)(const std::string &) funcptr_t
static constexpr size_t s_tag_len
virtual yarp::os::ApplicationNetworkProtocolVersion getLocalProtocolVersion()
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
virtual bool checkProtocolVersion()
virtual yarp::dev::ReturnValue resetBotRPC()
virtual yarp::dev::ReturnValue setLanguageRPC(const std::string &language)
virtual yarp::os::ApplicationNetworkProtocolVersion getRemoteProtocolVersion()
virtual std::vector< std::string > help(const std::string &functionName="--all")
virtual return_getStatus getStatusRPC()
virtual return_interact interactRPC(const std::string &messageIn)
virtual return_getLanguage getLanguageRPC()
yarp::dev::ReturnValue result
yarp::dev::ReturnValue result
yarp::dev::ReturnValue result
@ 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)
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 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