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 (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, "FrameTransformStorageSetRPC")
24}
25
26//FrameTransformStorageSetRPC_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 FrameTransformStorageSetRPC_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 FrameTransformStorageSetRPC::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// setTransformsRPC helper class declaration
111 public yarp::os::Portable
112{
113public:
115 explicit FrameTransformStorageSetRPC_setTransformsRPC_helper(const std::vector<yarp::math::FrameTransform>& transforms);
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::vector<yarp::math::FrameTransform>& transforms);
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::vector<yarp::math::FrameTransform> transforms{};
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 = yarp::dev::ReturnValue (*)(const std::vector<yarp::math::FrameTransform>&);
160
163
164 static constexpr const char* s_tag{"setTransformsRPC"};
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{1};
168 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameTransformStorageSetRPC::setTransformsRPC(const std::vector<yarp::math::FrameTransform>& transforms)"};
169 static constexpr const char* s_help{""};
170};
171
172// setTransformRPC helper class declaration
174 public yarp::os::Portable
175{
176public:
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;
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
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
223
226
227 static constexpr const char* s_tag{"setTransformRPC"};
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 FrameTransformStorageSetRPC::setTransformRPC(const yarp::math::FrameTransform& transform)"};
232 static constexpr const char* s_help{""};
233};
234
235// deleteTransformRPC helper class declaration
237 public yarp::os::Portable
238{
239public:
241 FrameTransformStorageSetRPC_deleteTransformRPC_helper(const std::string& src, const std::string& dst);
242 bool write(yarp::os::ConnectionWriter& connection) const override;
243 bool read(yarp::os::ConnectionReader& connection) override;
244
245 class Command :
247 {
248 public:
249 Command() = default;
250 Command(const std::string& src, const std::string& dst);
251
252 ~Command() override = default;
253
254 bool write(yarp::os::ConnectionWriter& connection) const override;
255 bool read(yarp::os::ConnectionReader& connection) override;
256
257 bool write(const yarp::os::idl::WireWriter& writer) const override;
258 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
259 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
260
261 bool read(yarp::os::idl::WireReader& reader) override;
264
265 std::string src{};
266 std::string dst{};
267 };
268
269 class Reply :
271 {
272 public:
273 Reply() = default;
274 ~Reply() override = default;
275
276 bool write(yarp::os::ConnectionWriter& connection) const override;
277 bool read(yarp::os::ConnectionReader& connection) override;
278
279 bool write(const yarp::os::idl::WireWriter& writer) const override;
280 bool read(yarp::os::idl::WireReader& reader) override;
281
283 };
284
285 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&, const std::string&);
287
290
291 static constexpr const char* s_tag{"deleteTransformRPC"};
292 static constexpr size_t s_tag_len{1};
293 static constexpr size_t s_cmd_len{3};
294 static constexpr size_t s_reply_len{1};
295 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameTransformStorageSetRPC::deleteTransformRPC(const std::string& src, const std::string& dst)"};
296 static constexpr const char* s_help{""};
297};
298
299// clearAllRPC helper class declaration
301 public yarp::os::Portable
302{
303public:
305 bool write(yarp::os::ConnectionWriter& connection) const override;
306 bool read(yarp::os::ConnectionReader& connection) override;
307
308 class Command :
310 {
311 public:
312 Command() = default;
313 ~Command() override = default;
314
315 bool write(yarp::os::ConnectionWriter& connection) const override;
316 bool read(yarp::os::ConnectionReader& connection) override;
317
318 bool write(const yarp::os::idl::WireWriter& writer) const override;
319 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
320 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
321
322 bool read(yarp::os::idl::WireReader& reader) override;
325 };
326
327 class Reply :
329 {
330 public:
331 Reply() = default;
332 ~Reply() override = default;
333
334 bool write(yarp::os::ConnectionWriter& connection) const override;
335 bool read(yarp::os::ConnectionReader& connection) override;
336
337 bool write(const yarp::os::idl::WireWriter& writer) const override;
338 bool read(yarp::os::idl::WireReader& reader) override;
339
341 };
342
345
348
349 static constexpr const char* s_tag{"clearAllRPC"};
350 static constexpr size_t s_tag_len{1};
351 static constexpr size_t s_cmd_len{1};
352 static constexpr size_t s_reply_len{1};
353 static constexpr const char* s_prototype{"yarp::dev::ReturnValue FrameTransformStorageSetRPC::clearAllRPC()"};
354 static constexpr const char* s_help{""};
355};
356
357// setTransformsRPC helper class implementation
359 cmd{transforms}
360{
361}
362
367
372
373FrameTransformStorageSetRPC_setTransformsRPC_helper::Command::Command(const std::vector<yarp::math::FrameTransform>& transforms) :
374 transforms{transforms}
375{
376}
377
379{
380 yarp::os::idl::WireWriter writer(connection);
381 if (!writer.writeListHeader(s_cmd_len)) {
382 return false;
383 }
384 return write(writer);
385}
386
388{
389 yarp::os::idl::WireReader reader(connection);
390 if (!reader.readListHeader()) {
391 reader.fail();
392 return false;
393 }
394 return read(reader);
395}
396
398{
399 if (!writeTag(writer)) {
400 return false;
401 }
402 if (!writeArgs(writer)) {
403 return false;
404 }
405 return true;
406}
407
409{
410 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
411 return false;
412 }
413 return true;
414}
415
417{
418 if (!writer.writeListBegin(BOTTLE_TAG_LIST, transforms.size())) {
419 return false;
420 }
421 for (const auto& _item : transforms) {
422 if (!writer.writeNested(_item)) {
423 return false;
424 }
425 }
426 if (!writer.writeListEnd()) {
427 return false;
428 }
429 return true;
430}
431
433{
434 if (!readTag(reader)) {
435 return false;
436 }
437 if (!readArgs(reader)) {
438 return false;
439 }
440 return true;
441}
442
444{
445 std::string tag = reader.readTag(s_tag_len);
446 if (reader.isError()) {
447 return false;
448 }
449 if (tag != s_tag) {
450 reader.fail();
451 return false;
452 }
453 return true;
454}
455
457{
458 if (reader.noMore()) {
459 reader.fail();
460 return false;
461 }
462 {
463 size_t _csize;
465 reader.readListBegin(_etype, _csize);
466 // WireReader removes BOTTLE_TAG_LIST from the tag
467 constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
468 if constexpr (expected_tag != 0) {
469 if (_csize != 0 && _etype.code != expected_tag) {
470 return false;
471 }
472 }
473 transforms.resize(_csize);
474 for (size_t _i0 = 0; _i0 < _csize; ++_i0) {
475 if (reader.noMore()) {
476 reader.fail();
477 return false;
478 }
479 if (!reader.readNested(transforms[_i0])) {
480 reader.fail();
481 return false;
482 }
483 }
484 reader.readListEnd();
485 }
486 if (!reader.noMore()) {
487 reader.fail();
488 return false;
489 }
490 return true;
491}
492
498
504
506{
507 if (!writer.isNull()) {
508 if (!writer.write(return_helper)) {
509 return false;
510 }
511 }
512 return true;
513}
514
516{
517 if (reader.noMore()) {
518 reader.fail();
519 return false;
520 }
521 if (!reader.read(return_helper)) {
522 reader.fail();
523 return false;
524 }
525 return true;
526}
527
532
533// setTransformRPC helper class implementation
538
543
548
553
555{
556 yarp::os::idl::WireWriter writer(connection);
557 if (!writer.writeListHeader(s_cmd_len)) {
558 return false;
559 }
560 return write(writer);
561}
562
564{
565 yarp::os::idl::WireReader reader(connection);
566 if (!reader.readListHeader()) {
567 reader.fail();
568 return false;
569 }
570 return read(reader);
571}
572
574{
575 if (!writeTag(writer)) {
576 return false;
577 }
578 if (!writeArgs(writer)) {
579 return false;
580 }
581 return true;
582}
583
585{
586 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
587 return false;
588 }
589 return true;
590}
591
593{
594 if (!writer.writeNested(transform)) {
595 return false;
596 }
597 return true;
598}
599
601{
602 if (!readTag(reader)) {
603 return false;
604 }
605 if (!readArgs(reader)) {
606 return false;
607 }
608 return true;
609}
610
612{
613 std::string tag = reader.readTag(s_tag_len);
614 if (reader.isError()) {
615 return false;
616 }
617 if (tag != s_tag) {
618 reader.fail();
619 return false;
620 }
621 return true;
622}
623
625{
626 if (reader.noMore()) {
627 reader.fail();
628 return false;
629 }
630 if (!reader.readNested(transform)) {
631 reader.fail();
632 return false;
633 }
634 if (!reader.noMore()) {
635 reader.fail();
636 return false;
637 }
638 return true;
639}
640
646
652
654{
655 if (!writer.isNull()) {
656 if (!writer.write(return_helper)) {
657 return false;
658 }
659 }
660 return true;
661}
662
664{
665 if (reader.noMore()) {
666 reader.fail();
667 return false;
668 }
669 if (!reader.read(return_helper)) {
670 reader.fail();
671 return false;
672 }
673 return true;
674}
675
680
681// deleteTransformRPC helper class implementation
686
691
696
697FrameTransformStorageSetRPC_deleteTransformRPC_helper::Command::Command(const std::string& src, const std::string& dst) :
698 src{src},
699 dst{dst}
700{
701}
702
704{
705 yarp::os::idl::WireWriter writer(connection);
706 if (!writer.writeListHeader(s_cmd_len)) {
707 return false;
708 }
709 return write(writer);
710}
711
713{
714 yarp::os::idl::WireReader reader(connection);
715 if (!reader.readListHeader()) {
716 reader.fail();
717 return false;
718 }
719 return read(reader);
720}
721
723{
724 if (!writeTag(writer)) {
725 return false;
726 }
727 if (!writeArgs(writer)) {
728 return false;
729 }
730 return true;
731}
732
734{
735 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
736 return false;
737 }
738 return true;
739}
740
742{
743 if (!writer.writeString(src)) {
744 return false;
745 }
746 if (!writer.writeString(dst)) {
747 return false;
748 }
749 return true;
750}
751
753{
754 if (!readTag(reader)) {
755 return false;
756 }
757 if (!readArgs(reader)) {
758 return false;
759 }
760 return true;
761}
762
764{
765 std::string tag = reader.readTag(s_tag_len);
766 if (reader.isError()) {
767 return false;
768 }
769 if (tag != s_tag) {
770 reader.fail();
771 return false;
772 }
773 return true;
774}
775
777{
778 if (reader.noMore()) {
779 reader.fail();
780 return false;
781 }
782 if (!reader.readString(src)) {
783 reader.fail();
784 return false;
785 }
786 if (reader.noMore()) {
787 reader.fail();
788 return false;
789 }
790 if (!reader.readString(dst)) {
791 reader.fail();
792 return false;
793 }
794 if (!reader.noMore()) {
795 reader.fail();
796 return false;
797 }
798 return true;
799}
800
806
812
814{
815 if (!writer.isNull()) {
816 if (!writer.write(return_helper)) {
817 return false;
818 }
819 }
820 return true;
821}
822
824{
825 if (reader.noMore()) {
826 reader.fail();
827 return false;
828 }
829 if (!reader.read(return_helper)) {
830 reader.fail();
831 return false;
832 }
833 return true;
834}
835
840
841// clearAllRPC helper class implementation
843{
844 return cmd.write(connection);
845}
846
851
853{
854 yarp::os::idl::WireWriter writer(connection);
855 if (!writer.writeListHeader(s_cmd_len)) {
856 return false;
857 }
858 return write(writer);
859}
860
862{
863 yarp::os::idl::WireReader reader(connection);
864 if (!reader.readListHeader()) {
865 reader.fail();
866 return false;
867 }
868 return read(reader);
869}
870
872{
873 if (!writeTag(writer)) {
874 return false;
875 }
876 if (!writeArgs(writer)) {
877 return false;
878 }
879 return true;
880}
881
883{
884 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
885 return false;
886 }
887 return true;
888}
889
891{
892 return true;
893}
894
896{
897 if (!readTag(reader)) {
898 return false;
899 }
900 if (!readArgs(reader)) {
901 return false;
902 }
903 return true;
904}
905
907{
908 std::string tag = reader.readTag(s_tag_len);
909 if (reader.isError()) {
910 return false;
911 }
912 if (tag != s_tag) {
913 reader.fail();
914 return false;
915 }
916 return true;
917}
918
920{
921 if (!reader.noMore()) {
922 reader.fail();
923 return false;
924 }
925 return true;
926}
927
929{
930 yarp::os::idl::WireWriter writer(connection);
931 return write(writer);
932}
933
939
941{
942 if (!writer.isNull()) {
943 if (!writer.write(return_helper)) {
944 return false;
945 }
946 }
947 return true;
948}
949
951{
952 if (reader.noMore()) {
953 reader.fail();
954 return false;
955 }
956 if (!reader.read(return_helper)) {
957 reader.fail();
958 return false;
959 }
960 return true;
961}
962
967
968// Constructor
973
974yarp::dev::ReturnValue FrameTransformStorageSetRPC::setTransformsRPC(const std::vector<yarp::math::FrameTransform>& transforms)
975{
976 if (!yarp().canWrite()) {
978 }
980 bool ok = yarp().write(helper, helper);
982}
983
993
994yarp::dev::ReturnValue FrameTransformStorageSetRPC::deleteTransformRPC(const std::string& src, const std::string& dst)
995{
996 if (!yarp().canWrite()) {
998 }
1000 bool ok = yarp().write(helper, helper);
1002}
1003
1005{
1006 if (!yarp().canWrite()) {
1008 }
1010 bool ok = yarp().write(helper, helper);
1012}
1013
1014// help method
1015std::vector<std::string> FrameTransformStorageSetRPC::help(const std::string& functionName)
1016{
1017 bool showAll = (functionName == "--all");
1018 std::vector<std::string> helpString;
1019 if (showAll) {
1020 helpString.emplace_back("*** Available commands:");
1025 helpString.emplace_back("help");
1026 } else {
1029 }
1032 }
1035 }
1038 }
1039 if (functionName == "help") {
1040 helpString.emplace_back("std::vector<std::string> help(const std::string& functionName = \"--all\")");
1041 helpString.emplace_back("Return list of available commands, or help message for a specific function");
1042 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");
1043 helpString.emplace_back("@return list of strings (one string per line)");
1044 }
1045 }
1046 if (helpString.empty()) {
1047 helpString.emplace_back("Command not found");
1048 }
1049 return helpString;
1050}
1051
1052// read from ConnectionReader
1054{
1055 constexpr size_t max_tag_len = 1;
1056 size_t tag_len = 1;
1057
1058 yarp::os::idl::WireReader reader(connection);
1059 reader.expectAccept();
1060 if (!reader.readListHeader()) {
1061 reader.fail();
1062 return false;
1063 }
1064
1065 std::string tag = reader.readTag(1);
1066 bool direct = (tag == "__direct__");
1067 if (direct) {
1068 tag = reader.readTag(1);
1069 }
1070 while (tag_len <= max_tag_len && !reader.isError()) {
1071 if(tag == "getRemoteProtocolVersion") {
1072 if (!reader.noMore()) {
1073 yError("Reader invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
1074 reader.fail();
1075 return false;
1076 }
1077
1078 auto proto = getLocalProtocolVersion();
1079
1080 yarp::os::idl::WireWriter writer(reader);
1081 if (!writer.writeListHeader(1)) {
1082 yWarning("Writer invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
1083 return false;}
1084 if (!writer.write(proto)) {
1085 yWarning("Writer invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
1086 return false;
1087 }
1088 reader.accept();
1089 return true;
1090 }
1093 if (!helper.cmd.readArgs(reader)) {
1094 return false;
1095 }
1096
1097 helper.call(this);
1098
1099 yarp::os::idl::WireWriter writer(reader);
1100 if (!helper.reply.write(writer)) {
1101 return false;
1102 }
1103 reader.accept();
1104 return true;
1105 }
1108 if (!helper.cmd.readArgs(reader)) {
1109 return false;
1110 }
1111
1112 helper.call(this);
1113
1114 yarp::os::idl::WireWriter writer(reader);
1115 if (!helper.reply.write(writer)) {
1116 return false;
1117 }
1118 reader.accept();
1119 return true;
1120 }
1123 if (!helper.cmd.readArgs(reader)) {
1124 return false;
1125 }
1126
1127 helper.call(this);
1128
1129 yarp::os::idl::WireWriter writer(reader);
1130 if (!helper.reply.write(writer)) {
1131 return false;
1132 }
1133 reader.accept();
1134 return true;
1135 }
1138 if (!helper.cmd.readArgs(reader)) {
1139 return false;
1140 }
1141
1142 helper.call(this);
1143
1144 yarp::os::idl::WireWriter writer(reader);
1145 if (!helper.reply.write(writer)) {
1146 return false;
1147 }
1148 reader.accept();
1149 return true;
1150 }
1151 if (tag == "help") {
1152 std::string functionName;
1153 if (!reader.readString(functionName)) {
1154 functionName = "--all";
1155 }
1156 auto help_strings = help(functionName);
1157 yarp::os::idl::WireWriter writer(reader);
1158 if (!writer.isNull()) {
1159 if (!writer.writeListHeader(2)) {
1160 return false;
1161 }
1162 if (!writer.writeTag("many", 1, 0)) {
1163 return false;
1164 }
1165 if (!writer.writeListBegin(0, help_strings.size())) {
1166 return false;
1167 }
1168 for (const auto& help_string : help_strings) {
1169 if (!writer.writeString(help_string)) {
1170 return false;
1171 }
1172 }
1173 if (!writer.writeListEnd()) {
1174 return false;
1175 }
1176 }
1177 reader.accept();
1178 return true;
1179 }
1180 if (reader.noMore()) {
1181 reader.fail();
1182 return false;
1183 }
1184 std::string next_tag = reader.readTag(1);
1185 if (next_tag.empty()) {
1186 break;
1187 }
1188 tag.append("_").append(next_tag);
1189 tag_len = std::count(tag.begin(), tag.end(), '_') + 1;
1190 }
1191 return false;
1192}
#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)
@ return_value_error_nws_nwc_communication_error
Method is not (yet) implemented.
An interface for reading from a network connection.
An interface for writing to a network connection.
This is a base class for objects that can be both read from and be written to the YARP network.
Definition Portable.h:25
yarp::os::WireLink & yarp()
Get YARP state associated with this object.
Definition Wire.h:28
A "tamed" Portable, that promises to serialize itself in an IDL-friendly way.
IDL-friendly connection reader.
Definition WireReader.h:27
bool readNested(WirePortable &obj)
bool readString(std::string &str, bool *is_vocab=nullptr)
void readListBegin(yarp::os::idl::WireState &nstate, size_t &len)
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