YARP
Yet Another Robot Platform
 
Loading...
Searching...
No Matches
FrameTransformStorageSetRPC.cpp
Go to the documentation of this file.
1/*
2 * SPDX-FileCopyrightText: 2006-2021 Istituto Italiano di Tecnologia (IIT)
3 * SPDX-License-Identifier: BSD-3-Clause
4 */
5
6// Autogenerated by Thrift Compiler (0.14.1-yarped)
7//
8// This is an automatically generated file.
9// It could get re-generated if the ALLOW_IDL_GENERATION flag is on.
10
11#include <yarp/conf/version.h>
14#include <yarp/os/LogStream.h>
15
17
18#include <algorithm>
19
20namespace
21{
22 YARP_LOG_COMPONENT(SERVICE_LOG_COMPONENT, "FrameTransformStorageSetRPC")
23}
24
25//FrameTransformStorageSetRPC_getRemoteProtocolVersion_helper declaration
36
38{
39 yarp::os::idl::WireWriter writer(connection);
40 if (!writer.writeListHeader(1)) {
41 return false;
42 }
43 if (!writer.writeString("getRemoteProtocolVersion")) {
44 return false;
45 }
46 return true;
47}
48
49bool FrameTransformStorageSetRPC_getRemoteProtocolVersion_helper ::read(yarp::os::ConnectionReader & connection)
50 {
51 yarp::os::idl::WireReader reader(connection);
52 if (!reader.readListHeader()) {
53 reader.fail();
54 return false;
55 }
56
57 if (!helper_proto.read(connection)) {
58 reader.fail();
59 return false;
60 }
61 return true;
62}
63
64//ProtocolVersion, client side
66 {
67 if(!yarp().canWrite()) {
68 yError(" Missing server method FrameTransformStorageSetRPC::getRemoteProtocolVersion");
69 }
71 bool ok = yarp().write(helper, helper);
72 if (ok) {
73 return helper.helper_proto;}
74 else {
76 return failureproto;}
77}
78
79//ProtocolVersion, client side
81 {
82 auto locproto = this->getLocalProtocolVersion();
83 auto remproto = this->getRemoteProtocolVersion();
84 if (remproto.protocol_version != locproto.protocol_version)
85 {
86 yCError(SERVICE_LOG_COMPONENT) << "Invalid communication protocol.";
87 yCError(SERVICE_LOG_COMPONENT) << "Local Protocol Version: " << locproto.toString();
88 yCError(SERVICE_LOG_COMPONENT) << "Remote Protocol Version: " << remproto.toString();
89 return false;
90 }
91 return true;
92}
93
94//ProtocolVersion, server side
96{
98 //myproto.protocol_version using default value = 0
99 //to change this value add the following line to the .thrift file:
100 //const i16 protocol_version = <your_number_here>
101 myproto.protocol_version = 0;
105 return myproto;
106}
107
108// setTransformsRPC helper class declaration
110 public yarp::os::Portable
111{
112public:
114 explicit FrameTransformStorageSetRPC_setTransformsRPC_helper(const std::vector<yarp::math::FrameTransform>& transforms);
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 explicit Command(const std::vector<yarp::math::FrameTransform>& transforms);
124
125 ~Command() override = default;
126
127 bool write(yarp::os::ConnectionWriter& connection) const override;
128 bool read(yarp::os::ConnectionReader& connection) override;
129
130 bool write(const yarp::os::idl::WireWriter& writer) const override;
131 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
132 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
133
134 bool read(yarp::os::idl::WireReader& reader) override;
137
138 std::vector<yarp::math::FrameTransform> transforms{};
139 };
140
141 class Reply :
143 {
144 public:
145 Reply() = default;
146 ~Reply() override = default;
147
148 bool write(yarp::os::ConnectionWriter& connection) const override;
149 bool read(yarp::os::ConnectionReader& connection) override;
150
151 bool write(const yarp::os::idl::WireWriter& writer) const override;
152 bool read(yarp::os::idl::WireReader& reader) override;
153
155 };
156
157 using funcptr_t = yarp::dev::ReturnValue (*)(const std::vector<yarp::math::FrameTransform>&);
159
162
163 static constexpr const char* s_tag{"setTransformsRPC"};
164 static constexpr size_t s_tag_len{1};
165 static constexpr size_t s_cmd_len{2};
166 static constexpr size_t s_reply_len{1};
167 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameTransformStorageSetRPC::setTransformsRPC(const std::vector<yarp::math::FrameTransform>& transforms)"};
168 static constexpr const char* s_help{""};
169};
170
171// setTransformRPC helper class declaration
173 public yarp::os::Portable
174{
175public:
178 bool write(yarp::os::ConnectionWriter& connection) const override;
179 bool read(yarp::os::ConnectionReader& connection) override;
180
181 class Command :
183 {
184 public:
185 Command() = default;
187
188 ~Command() override = default;
189
190 bool write(yarp::os::ConnectionWriter& connection) const override;
191 bool read(yarp::os::ConnectionReader& connection) override;
192
193 bool write(const yarp::os::idl::WireWriter& writer) const override;
194 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
195 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
196
197 bool read(yarp::os::idl::WireReader& reader) override;
200
202 };
203
204 class Reply :
206 {
207 public:
208 Reply() = default;
209 ~Reply() override = default;
210
211 bool write(yarp::os::ConnectionWriter& connection) const override;
212 bool read(yarp::os::ConnectionReader& connection) override;
213
214 bool write(const yarp::os::idl::WireWriter& writer) const override;
215 bool read(yarp::os::idl::WireReader& reader) override;
216
218 };
219
222
225
226 static constexpr const char* s_tag{"setTransformRPC"};
227 static constexpr size_t s_tag_len{1};
228 static constexpr size_t s_cmd_len{2};
229 static constexpr size_t s_reply_len{1};
230 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameTransformStorageSetRPC::setTransformRPC(const yarp::math::FrameTransform& transform)"};
231 static constexpr const char* s_help{""};
232};
233
234// deleteTransformRPC helper class declaration
236 public yarp::os::Portable
237{
238public:
240 FrameTransformStorageSetRPC_deleteTransformRPC_helper(const std::string& src, const std::string& dst);
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(const std::string& src, const std::string& dst);
250
251 ~Command() override = default;
252
253 bool write(yarp::os::ConnectionWriter& connection) const override;
254 bool read(yarp::os::ConnectionReader& connection) override;
255
256 bool write(const yarp::os::idl::WireWriter& writer) const override;
257 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
258 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
259
260 bool read(yarp::os::idl::WireReader& reader) override;
263
264 std::string src{};
265 std::string dst{};
266 };
267
268 class Reply :
270 {
271 public:
272 Reply() = default;
273 ~Reply() override = default;
274
275 bool write(yarp::os::ConnectionWriter& connection) const override;
276 bool read(yarp::os::ConnectionReader& connection) override;
277
278 bool write(const yarp::os::idl::WireWriter& writer) const override;
279 bool read(yarp::os::idl::WireReader& reader) override;
280
282 };
283
284 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&, const std::string&);
286
289
290 static constexpr const char* s_tag{"deleteTransformRPC"};
291 static constexpr size_t s_tag_len{1};
292 static constexpr size_t s_cmd_len{3};
293 static constexpr size_t s_reply_len{1};
294 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameTransformStorageSetRPC::deleteTransformRPC(const std::string& src, const std::string& dst)"};
295 static constexpr const char* s_help{""};
296};
297
298// clearAllRPC helper class declaration
300 public yarp::os::Portable
301{
302public:
304 bool write(yarp::os::ConnectionWriter& connection) const override;
305 bool read(yarp::os::ConnectionReader& connection) override;
306
307 class Command :
309 {
310 public:
311 Command() = default;
312 ~Command() override = default;
313
314 bool write(yarp::os::ConnectionWriter& connection) const override;
315 bool read(yarp::os::ConnectionReader& connection) override;
316
317 bool write(const yarp::os::idl::WireWriter& writer) const override;
318 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
319 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
320
321 bool read(yarp::os::idl::WireReader& reader) override;
324 };
325
326 class Reply :
328 {
329 public:
330 Reply() = default;
331 ~Reply() override = default;
332
333 bool write(yarp::os::ConnectionWriter& connection) const override;
334 bool read(yarp::os::ConnectionReader& connection) override;
335
336 bool write(const yarp::os::idl::WireWriter& writer) const override;
337 bool read(yarp::os::idl::WireReader& reader) override;
338
340 };
341
344
347
348 static constexpr const char* s_tag{"clearAllRPC"};
349 static constexpr size_t s_tag_len{1};
350 static constexpr size_t s_cmd_len{1};
351 static constexpr size_t s_reply_len{1};
352 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameTransformStorageSetRPC::clearAllRPC()"};
353 static constexpr const char* s_help{""};
354};
355
356// setTransformsRPC helper class implementation
358 cmd{transforms}
359{
360}
361
366
371
372FrameTransformStorageSetRPC_setTransformsRPC_helper::Command::Command(const std::vector<yarp::math::FrameTransform>& transforms) :
373 transforms{transforms}
374{
375}
376
378{
379 yarp::os::idl::WireWriter writer(connection);
380 if (!writer.writeListHeader(s_cmd_len)) {
381 return false;
382 }
383 return write(writer);
384}
385
387{
388 yarp::os::idl::WireReader reader(connection);
389 if (!reader.readListHeader()) {
390 reader.fail();
391 return false;
392 }
393 return read(reader);
394}
395
397{
398 if (!writeTag(writer)) {
399 return false;
400 }
401 if (!writeArgs(writer)) {
402 return false;
403 }
404 return true;
405}
406
408{
409 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
410 return false;
411 }
412 return true;
413}
414
416{
417 if (!writer.writeListBegin(BOTTLE_TAG_LIST, transforms.size())) {
418 return false;
419 }
420 for (const auto& _item : transforms) {
421 if (!writer.writeNested(_item)) {
422 return false;
423 }
424 }
425 if (!writer.writeListEnd()) {
426 return false;
427 }
428 return true;
429}
430
432{
433 if (!readTag(reader)) {
434 return false;
435 }
436 if (!readArgs(reader)) {
437 return false;
438 }
439 return true;
440}
441
443{
444 std::string tag = reader.readTag(s_tag_len);
445 if (reader.isError()) {
446 return false;
447 }
448 if (tag != s_tag) {
449 reader.fail();
450 return false;
451 }
452 return true;
453}
454
456{
457 if (reader.noMore()) {
458 reader.fail();
459 return false;
460 }
461 {
462 size_t _csize;
464 reader.readListBegin(_etype, _csize);
465 // WireReader removes BOTTLE_TAG_LIST from the tag
466 constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
467 if constexpr (expected_tag != 0) {
468 if (_csize != 0 && _etype.code != expected_tag) {
469 return false;
470 }
471 }
472 transforms.resize(_csize);
473 for (size_t _i = 0; _i < _csize; ++_i) {
474 if (reader.noMore()) {
475 reader.fail();
476 return false;
477 }
478 if (!reader.readNested(transforms[_i])) {
479 reader.fail();
480 return false;
481 }
482 }
483 reader.readListEnd();
484 }
485 if (!reader.noMore()) {
486 reader.fail();
487 return false;
488 }
489 return true;
490}
491
497
503
505{
506 if (!writer.isNull()) {
507 if (!writer.write(return_helper)) {
508 return false;
509 }
510 }
511 return true;
512}
513
515{
516 if (reader.noMore()) {
517 reader.fail();
518 return false;
519 }
520 if (!reader.read(return_helper)) {
521 reader.fail();
522 return false;
523 }
524 return true;
525}
526
531
532// setTransformRPC helper class implementation
537
542
547
552
554{
555 yarp::os::idl::WireWriter writer(connection);
556 if (!writer.writeListHeader(s_cmd_len)) {
557 return false;
558 }
559 return write(writer);
560}
561
563{
564 yarp::os::idl::WireReader reader(connection);
565 if (!reader.readListHeader()) {
566 reader.fail();
567 return false;
568 }
569 return read(reader);
570}
571
573{
574 if (!writeTag(writer)) {
575 return false;
576 }
577 if (!writeArgs(writer)) {
578 return false;
579 }
580 return true;
581}
582
584{
585 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
586 return false;
587 }
588 return true;
589}
590
592{
593 if (!writer.writeNested(transform)) {
594 return false;
595 }
596 return true;
597}
598
600{
601 if (!readTag(reader)) {
602 return false;
603 }
604 if (!readArgs(reader)) {
605 return false;
606 }
607 return true;
608}
609
611{
612 std::string tag = reader.readTag(s_tag_len);
613 if (reader.isError()) {
614 return false;
615 }
616 if (tag != s_tag) {
617 reader.fail();
618 return false;
619 }
620 return true;
621}
622
624{
625 if (reader.noMore()) {
626 reader.fail();
627 return false;
628 }
629 if (!reader.readNested(transform)) {
630 reader.fail();
631 return false;
632 }
633 if (!reader.noMore()) {
634 reader.fail();
635 return false;
636 }
637 return true;
638}
639
645
651
653{
654 if (!writer.isNull()) {
655 if (!writer.write(return_helper)) {
656 return false;
657 }
658 }
659 return true;
660}
661
663{
664 if (reader.noMore()) {
665 reader.fail();
666 return false;
667 }
668 if (!reader.read(return_helper)) {
669 reader.fail();
670 return false;
671 }
672 return true;
673}
674
679
680// deleteTransformRPC helper class implementation
685
690
695
696FrameTransformStorageSetRPC_deleteTransformRPC_helper::Command::Command(const std::string& src, const std::string& dst) :
697 src{src},
698 dst{dst}
699{
700}
701
703{
704 yarp::os::idl::WireWriter writer(connection);
705 if (!writer.writeListHeader(s_cmd_len)) {
706 return false;
707 }
708 return write(writer);
709}
710
712{
713 yarp::os::idl::WireReader reader(connection);
714 if (!reader.readListHeader()) {
715 reader.fail();
716 return false;
717 }
718 return read(reader);
719}
720
722{
723 if (!writeTag(writer)) {
724 return false;
725 }
726 if (!writeArgs(writer)) {
727 return false;
728 }
729 return true;
730}
731
733{
734 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
735 return false;
736 }
737 return true;
738}
739
741{
742 if (!writer.writeString(src)) {
743 return false;
744 }
745 if (!writer.writeString(dst)) {
746 return false;
747 }
748 return true;
749}
750
752{
753 if (!readTag(reader)) {
754 return false;
755 }
756 if (!readArgs(reader)) {
757 return false;
758 }
759 return true;
760}
761
763{
764 std::string tag = reader.readTag(s_tag_len);
765 if (reader.isError()) {
766 return false;
767 }
768 if (tag != s_tag) {
769 reader.fail();
770 return false;
771 }
772 return true;
773}
774
776{
777 if (reader.noMore()) {
778 reader.fail();
779 return false;
780 }
781 if (!reader.readString(src)) {
782 reader.fail();
783 return false;
784 }
785 if (reader.noMore()) {
786 reader.fail();
787 return false;
788 }
789 if (!reader.readString(dst)) {
790 reader.fail();
791 return false;
792 }
793 if (!reader.noMore()) {
794 reader.fail();
795 return false;
796 }
797 return true;
798}
799
805
811
813{
814 if (!writer.isNull()) {
815 if (!writer.write(return_helper)) {
816 return false;
817 }
818 }
819 return true;
820}
821
823{
824 if (reader.noMore()) {
825 reader.fail();
826 return false;
827 }
828 if (!reader.read(return_helper)) {
829 reader.fail();
830 return false;
831 }
832 return true;
833}
834
839
840// clearAllRPC helper class implementation
842{
843 return cmd.write(connection);
844}
845
850
852{
853 yarp::os::idl::WireWriter writer(connection);
854 if (!writer.writeListHeader(s_cmd_len)) {
855 return false;
856 }
857 return write(writer);
858}
859
861{
862 yarp::os::idl::WireReader reader(connection);
863 if (!reader.readListHeader()) {
864 reader.fail();
865 return false;
866 }
867 return read(reader);
868}
869
871{
872 if (!writeTag(writer)) {
873 return false;
874 }
875 if (!writeArgs(writer)) {
876 return false;
877 }
878 return true;
879}
880
882{
883 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
884 return false;
885 }
886 return true;
887}
888
890{
891 return true;
892}
893
895{
896 if (!readTag(reader)) {
897 return false;
898 }
899 if (!readArgs(reader)) {
900 return false;
901 }
902 return true;
903}
904
906{
907 std::string tag = reader.readTag(s_tag_len);
908 if (reader.isError()) {
909 return false;
910 }
911 if (tag != s_tag) {
912 reader.fail();
913 return false;
914 }
915 return true;
916}
917
919{
920 if (!reader.noMore()) {
921 reader.fail();
922 return false;
923 }
924 return true;
925}
926
928{
929 yarp::os::idl::WireWriter writer(connection);
930 return write(writer);
931}
932
938
940{
941 if (!writer.isNull()) {
942 if (!writer.write(return_helper)) {
943 return false;
944 }
945 }
946 return true;
947}
948
950{
951 if (reader.noMore()) {
952 reader.fail();
953 return false;
954 }
955 if (!reader.read(return_helper)) {
956 reader.fail();
957 return false;
958 }
959 return true;
960}
961
966
967// Constructor
972
973yarp::dev::ReturnValue FrameTransformStorageSetRPC::setTransformsRPC(const std::vector<yarp::math::FrameTransform>& transforms)
974{
975 if (!yarp().canWrite()) {
977 }
979 bool ok = yarp().write(helper, helper);
980 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
981}
982
984{
985 if (!yarp().canWrite()) {
987 }
989 bool ok = yarp().write(helper, helper);
990 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
991}
992
993yarp::dev::ReturnValue FrameTransformStorageSetRPC::deleteTransformRPC(const std::string& src, const std::string& dst)
994{
995 if (!yarp().canWrite()) {
997 }
999 bool ok = yarp().write(helper, helper);
1000 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
1001}
1002
1004{
1005 if (!yarp().canWrite()) {
1007 }
1009 bool ok = yarp().write(helper, helper);
1010 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
1011}
1012
1013// help method
1014std::vector<std::string> FrameTransformStorageSetRPC::help(const std::string& functionName)
1015{
1016 bool showAll = (functionName == "--all");
1017 std::vector<std::string> helpString;
1018 if (showAll) {
1019 helpString.emplace_back("*** Available commands:");
1024 helpString.emplace_back("help");
1025 } else {
1028 }
1031 }
1034 }
1037 }
1038 if (functionName == "help") {
1039 helpString.emplace_back("std::vector<std::string> help(const std::string& functionName = \"--all\")");
1040 helpString.emplace_back("Return list of available commands, or help message for a specific function");
1041 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");
1042 helpString.emplace_back("@return list of strings (one string per line)");
1043 }
1044 }
1045 if (helpString.empty()) {
1046 helpString.emplace_back("Command not found");
1047 }
1048 return helpString;
1049}
1050
1051// read from ConnectionReader
1053{
1054 constexpr size_t max_tag_len = 1;
1055 size_t tag_len = 1;
1056
1057 yarp::os::idl::WireReader reader(connection);
1058 reader.expectAccept();
1059 if (!reader.readListHeader()) {
1060 reader.fail();
1061 return false;
1062 }
1063
1064 std::string tag = reader.readTag(1);
1065 bool direct = (tag == "__direct__");
1066 if (direct) {
1067 tag = reader.readTag(1);
1068 }
1069 while (tag_len <= max_tag_len && !reader.isError()) {
1070 if(tag == "getRemoteProtocolVersion") {
1071 if (!reader.noMore()) {
1072 yError("Reader invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
1073 reader.fail();
1074 return false;
1075 }
1076
1077 auto proto = getLocalProtocolVersion();
1078
1079 yarp::os::idl::WireWriter writer(reader);
1080 if (!writer.writeListHeader(1)) {
1081 yWarning("Writer invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
1082 return false;}
1083 if (!writer.write(proto)) {
1084 yWarning("Writer invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
1085 return false;
1086 }
1087 reader.accept();
1088 return true;
1089 }
1092 if (!helper.cmd.readArgs(reader)) {
1093 return false;
1094 }
1095
1096 helper.call(this);
1097
1098 yarp::os::idl::WireWriter writer(reader);
1099 if (!helper.reply.write(writer)) {
1100 return false;
1101 }
1102 reader.accept();
1103 return true;
1104 }
1107 if (!helper.cmd.readArgs(reader)) {
1108 return false;
1109 }
1110
1111 helper.call(this);
1112
1113 yarp::os::idl::WireWriter writer(reader);
1114 if (!helper.reply.write(writer)) {
1115 return false;
1116 }
1117 reader.accept();
1118 return true;
1119 }
1122 if (!helper.cmd.readArgs(reader)) {
1123 return false;
1124 }
1125
1126 helper.call(this);
1127
1128 yarp::os::idl::WireWriter writer(reader);
1129 if (!helper.reply.write(writer)) {
1130 return false;
1131 }
1132 reader.accept();
1133 return true;
1134 }
1137 if (!helper.cmd.readArgs(reader)) {
1138 return false;
1139 }
1140
1141 helper.call(this);
1142
1143 yarp::os::idl::WireWriter writer(reader);
1144 if (!helper.reply.write(writer)) {
1145 return false;
1146 }
1147 reader.accept();
1148 return true;
1149 }
1150 if (tag == "help") {
1151 std::string functionName;
1152 if (!reader.readString(functionName)) {
1153 functionName = "--all";
1154 }
1155 auto help_strings = help(functionName);
1156 yarp::os::idl::WireWriter writer(reader);
1157 if (!writer.isNull()) {
1158 if (!writer.writeListHeader(2)) {
1159 return false;
1160 }
1161 if (!writer.writeTag("many", 1, 0)) {
1162 return false;
1163 }
1164 if (!writer.writeListBegin(0, help_strings.size())) {
1165 return false;
1166 }
1167 for (const auto& help_string : help_strings) {
1168 if (!writer.writeString(help_string)) {
1169 return false;
1170 }
1171 }
1172 if (!writer.writeListEnd()) {
1173 return false;
1174 }
1175 }
1176 reader.accept();
1177 return true;
1178 }
1179 if (reader.noMore()) {
1180 reader.fail();
1181 return false;
1182 }
1183 std::string next_tag = reader.readTag(1);
1184 if (next_tag.empty()) {
1185 break;
1186 }
1187 tag.append("_").append(next_tag);
1188 tag_len = std::count(tag.begin(), tag.end(), '_') + 1;
1189 }
1190 return false;
1191}
#define BOTTLE_TAG_LIST
Definition Bottle.h:29
#define yError(...)
Definition Log.h:361
#define __YFUNCTION__
Definition Log.h:24
#define yWarning(...)
Definition Log.h:340
bool 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 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 write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
yarp::dev::ReturnValue(*)(const std::string &, const std::string &) 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 writeTag(const yarp::os::idl::WireWriter &writer) const
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
yarp::dev::ReturnValue(*)(const yarp::math::FrameTransform &) funcptr_t
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
yarp::dev::ReturnValue(*)(const std::vector< yarp::math::FrameTransform > &) funcptr_t
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
virtual yarp::dev::ReturnValue deleteTransformRPC(const std::string &src, const std::string &dst)
virtual yarp::dev::ReturnValue clearAllRPC()
virtual yarp::os::ApplicationNetworkProtocolVersion getRemoteProtocolVersion()
virtual std::vector< std::string > help(const std::string &functionName="--all")
virtual yarp::os::ApplicationNetworkProtocolVersion getLocalProtocolVersion()
virtual yarp::dev::ReturnValue setTransformRPC(const yarp::math::FrameTransform &transform)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
virtual yarp::dev::ReturnValue setTransformsRPC(const std::vector< yarp::math::FrameTransform > &transforms)
An interface for reading from a network connection.
An interface for writing to a network connection.
This is a base class for objects that can be both read from and be written to the YARP network.
Definition Portable.h:25
yarp::os::WireLink & yarp()
Get YARP state associated with this object.
Definition Wire.h:28
A "tamed" Portable, that promises to serialize itself in an IDL-friendly way.
IDL-friendly connection reader.
Definition WireReader.h:27
bool readNested(WirePortable &obj)
bool readString(std::string &str, bool *is_vocab=nullptr)
void readListBegin(yarp::os::idl::WireState &nstate, size_t &len)
std::string readTag(size_t len=static_cast< size_t >(-1))
bool read(WirePortable &obj)
IDL-friendly state.
Definition WireState.h:17
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 writeNested(const WirePortable &obj) const
bool writeListBegin(int tag, size_t len) const
#define yCError(component,...)
#define YARP_LOG_COMPONENT(name,...)
The main, catch-all namespace for YARP.
Definition dirs.h:16
#define YARP_VERSION_PATCH
Definition version.h:12
#define YARP_VERSION_MAJOR
Definition version.h:10
#define YARP_VERSION_MINOR
Definition version.h:11