YARP
Yet Another Robot Platform
 
Loading...
Searching...
No Matches
yarpdataplayer_IDL.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 <yarpdataplayer_IDL.h>
15#include <yarp/os/LogStream.h>
16
18
19#include <algorithm>
20
21namespace
22{
23 YARP_LOG_COMPONENT(SERVICE_LOG_COMPONENT, "yarpdataplayer_IDL")
24}
25
26//yarpdataplayer_IDL_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 yarpdataplayer_IDL_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 yarpdataplayer_IDL::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// step 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 bool return_helper{false};
151 };
152
153 using funcptr_t = bool (*)();
154 void call(yarpdataplayer_IDL* ptr);
155
158
159 static constexpr const char* s_tag{"step"};
160 static constexpr size_t s_tag_len{1};
161 static constexpr size_t s_cmd_len{1};
162 static constexpr size_t s_reply_len{1};
163 static constexpr const char* s_prototype{"bool yarpdataplayer_IDL::step()"};
164 static constexpr const char* s_help{
165 "Steps the player once. The player will be stepped\n"
166 "until all parts have sent data\n"
167 "@return true/false on success/failure"
168 };
169};
170
171// setFrame helper class declaration
173 public yarp::os::Portable
174{
175public:
177 explicit yarpdataplayer_IDL_setFrame_helper(const std::int32_t frameNum);
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;
186 explicit Command(const std::int32_t frameNum);
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
201 std::int32_t frameNum{0};
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
217 bool return_helper{false};
218 };
219
220 using funcptr_t = bool (*)(const std::int32_t);
221 void call(yarpdataplayer_IDL* ptr);
222
225
226 static constexpr const char* s_tag{"setFrame"};
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{"bool yarpdataplayer_IDL::setFrame(const std::int32_t frameNum)"};
231 static constexpr const char* s_help{
232 "Sets the frame number to the user desired frame.\n"
233 "@param frameNum specifies the frame number the user\n"
234 " would like to skip to\n"
235 "@return true/false on success/failure"
236 };
237};
238
239// getFrame helper class declaration
241 public yarp::os::Portable
242{
243public:
245 explicit yarpdataplayer_IDL_getFrame_helper(const std::string& name);
246 bool write(yarp::os::ConnectionWriter& connection) const override;
247 bool read(yarp::os::ConnectionReader& connection) override;
248
249 class Command :
251 {
252 public:
253 Command() = default;
254 explicit Command(const std::string& name);
255
256 ~Command() override = default;
257
258 bool write(yarp::os::ConnectionWriter& connection) const override;
259 bool read(yarp::os::ConnectionReader& connection) override;
260
261 bool write(const yarp::os::idl::WireWriter& writer) const override;
262 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
263 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
264
265 bool read(yarp::os::idl::WireReader& reader) override;
268
269 std::string name{};
270 };
271
272 class Reply :
274 {
275 public:
276 Reply() = default;
277 ~Reply() override = default;
278
279 bool write(yarp::os::ConnectionWriter& connection) const override;
280 bool read(yarp::os::ConnectionReader& connection) override;
281
282 bool write(const yarp::os::idl::WireWriter& writer) const override;
283 bool read(yarp::os::idl::WireReader& reader) override;
284
285 std::int32_t return_helper{0};
286 };
287
288 using funcptr_t = std::int32_t (*)(const std::string&);
289 void call(yarpdataplayer_IDL* ptr);
290
293
294 static constexpr const char* s_tag{"getFrame"};
295 static constexpr size_t s_tag_len{1};
296 static constexpr size_t s_cmd_len{2};
297 static constexpr size_t s_reply_len{1};
298 static constexpr const char* s_prototype{"std::int32_t yarpdataplayer_IDL::getFrame(const std::string& name)"};
299 static constexpr const char* s_help{
300 "Gets the frame number the user is requesting\n"
301 "@param name specifies the name of the data to modify\n"
302 " would like to skip to\n"
303 "@return i32 returns the current frame index"
304 };
305};
306
307// load helper class declaration
309 public yarp::os::Portable
310{
311public:
313 explicit yarpdataplayer_IDL_load_helper(const std::string& path);
314 bool write(yarp::os::ConnectionWriter& connection) const override;
315 bool read(yarp::os::ConnectionReader& connection) override;
316
317 class Command :
319 {
320 public:
321 Command() = default;
322 explicit Command(const std::string& path);
323
324 ~Command() override = default;
325
326 bool write(yarp::os::ConnectionWriter& connection) const override;
327 bool read(yarp::os::ConnectionReader& connection) override;
328
329 bool write(const yarp::os::idl::WireWriter& writer) const override;
330 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
331 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
332
333 bool read(yarp::os::idl::WireReader& reader) override;
336
337 std::string path{};
338 };
339
340 class Reply :
342 {
343 public:
344 Reply() = default;
345 ~Reply() override = default;
346
347 bool write(yarp::os::ConnectionWriter& connection) const override;
348 bool read(yarp::os::ConnectionReader& connection) override;
349
350 bool write(const yarp::os::idl::WireWriter& writer) const override;
351 bool read(yarp::os::idl::WireReader& reader) override;
352
353 bool return_helper{false};
354 };
355
356 using funcptr_t = bool (*)(const std::string&);
357 void call(yarpdataplayer_IDL* ptr);
358
361
362 static constexpr const char* s_tag{"load"};
363 static constexpr size_t s_tag_len{1};
364 static constexpr size_t s_cmd_len{2};
365 static constexpr size_t s_reply_len{1};
366 static constexpr const char* s_prototype{"bool yarpdataplayer_IDL::load(const std::string& path)"};
367 static constexpr const char* s_help{
368 "Loads a dataset from a path\n"
369 "@return true/false on success/failure"
370 };
371};
372
373// getSliderPercentage helper class declaration
375 public yarp::os::Portable
376{
377public:
379 bool write(yarp::os::ConnectionWriter& connection) const override;
380 bool read(yarp::os::ConnectionReader& connection) override;
381
382 class Command :
384 {
385 public:
386 Command() = default;
387 ~Command() override = default;
388
389 bool write(yarp::os::ConnectionWriter& connection) const override;
390 bool read(yarp::os::ConnectionReader& connection) override;
391
392 bool write(const yarp::os::idl::WireWriter& writer) const override;
393 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
394 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
395
396 bool read(yarp::os::idl::WireReader& reader) override;
399 };
400
401 class Reply :
403 {
404 public:
405 Reply() = default;
406 ~Reply() override = default;
407
408 bool write(yarp::os::ConnectionWriter& connection) const override;
409 bool read(yarp::os::ConnectionReader& connection) override;
410
411 bool write(const yarp::os::idl::WireWriter& writer) const override;
412 bool read(yarp::os::idl::WireReader& reader) override;
413
414 std::int32_t return_helper{0};
415 };
416
417 using funcptr_t = std::int32_t (*)();
418 void call(yarpdataplayer_IDL* ptr);
419
422
423 static constexpr const char* s_tag{"getSliderPercentage"};
424 static constexpr size_t s_tag_len{1};
425 static constexpr size_t s_cmd_len{1};
426 static constexpr size_t s_reply_len{1};
427 static constexpr const char* s_prototype{"std::int32_t yarpdataplayer_IDL::getSliderPercentage()"};
428 static constexpr const char* s_help{
429 "Get slider percentage\n"
430 "@return i32 percentage"
431 };
432};
433
434// getStatus helper class declaration
436 public yarp::os::Portable
437{
438public:
440 bool write(yarp::os::ConnectionWriter& connection) const override;
441 bool read(yarp::os::ConnectionReader& connection) override;
442
443 class Command :
445 {
446 public:
447 Command() = default;
448 ~Command() override = default;
449
450 bool write(yarp::os::ConnectionWriter& connection) const override;
451 bool read(yarp::os::ConnectionReader& connection) override;
452
453 bool write(const yarp::os::idl::WireWriter& writer) const override;
454 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
455 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
456
457 bool read(yarp::os::idl::WireReader& reader) override;
460 };
461
462 class Reply :
464 {
465 public:
466 Reply() = default;
467 ~Reply() override = default;
468
469 bool write(yarp::os::ConnectionWriter& connection) const override;
470 bool read(yarp::os::ConnectionReader& connection) override;
471
472 bool write(const yarp::os::idl::WireWriter& writer) const override;
473 bool read(yarp::os::idl::WireReader& reader) override;
474
475 std::string return_helper{};
476 };
477
478 using funcptr_t = std::string (*)();
479 void call(yarpdataplayer_IDL* ptr);
480
483
484 static constexpr const char* s_tag{"getStatus"};
485 static constexpr size_t s_tag_len{1};
486 static constexpr size_t s_cmd_len{1};
487 static constexpr size_t s_reply_len{1};
488 static constexpr const char* s_prototype{"std::string yarpdataplayer_IDL::getStatus()"};
489 static constexpr const char* s_help{
490 "Get the status of playing\n"
491 "@return the status (playing, paused, stopped)"
492 };
493};
494
495// play helper class declaration
497 public yarp::os::Portable
498{
499public:
501 bool write(yarp::os::ConnectionWriter& connection) const override;
502 bool read(yarp::os::ConnectionReader& connection) override;
503
504 class Command :
506 {
507 public:
508 Command() = default;
509 ~Command() override = default;
510
511 bool write(yarp::os::ConnectionWriter& connection) const override;
512 bool read(yarp::os::ConnectionReader& connection) override;
513
514 bool write(const yarp::os::idl::WireWriter& writer) const override;
515 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
516 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
517
518 bool read(yarp::os::idl::WireReader& reader) override;
521 };
522
523 class Reply :
525 {
526 public:
527 Reply() = default;
528 ~Reply() override = default;
529
530 bool write(yarp::os::ConnectionWriter& connection) const override;
531 bool read(yarp::os::ConnectionReader& connection) override;
532
533 bool write(const yarp::os::idl::WireWriter& writer) const override;
534 bool read(yarp::os::idl::WireReader& reader) override;
535
536 bool return_helper{false};
537 };
538
539 using funcptr_t = bool (*)();
540 void call(yarpdataplayer_IDL* ptr);
541
544
545 static constexpr const char* s_tag{"play"};
546 static constexpr size_t s_tag_len{1};
547 static constexpr size_t s_cmd_len{1};
548 static constexpr size_t s_reply_len{1};
549 static constexpr const char* s_prototype{"bool yarpdataplayer_IDL::play()"};
550 static constexpr const char* s_help{
551 "Plays the dataSets\n"
552 "@return true/false on success/failure"
553 };
554};
555
556// pause helper class declaration
558 public yarp::os::Portable
559{
560public:
562 bool write(yarp::os::ConnectionWriter& connection) const override;
563 bool read(yarp::os::ConnectionReader& connection) override;
564
565 class Command :
567 {
568 public:
569 Command() = default;
570 ~Command() override = default;
571
572 bool write(yarp::os::ConnectionWriter& connection) const override;
573 bool read(yarp::os::ConnectionReader& connection) override;
574
575 bool write(const yarp::os::idl::WireWriter& writer) const override;
576 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
577 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
578
579 bool read(yarp::os::idl::WireReader& reader) override;
582 };
583
584 class Reply :
586 {
587 public:
588 Reply() = default;
589 ~Reply() override = default;
590
591 bool write(yarp::os::ConnectionWriter& connection) const override;
592 bool read(yarp::os::ConnectionReader& connection) override;
593
594 bool write(const yarp::os::idl::WireWriter& writer) const override;
595 bool read(yarp::os::idl::WireReader& reader) override;
596
597 bool return_helper{false};
598 };
599
600 using funcptr_t = bool (*)();
601 void call(yarpdataplayer_IDL* ptr);
602
605
606 static constexpr const char* s_tag{"pause"};
607 static constexpr size_t s_tag_len{1};
608 static constexpr size_t s_cmd_len{1};
609 static constexpr size_t s_reply_len{1};
610 static constexpr const char* s_prototype{"bool yarpdataplayer_IDL::pause()"};
611 static constexpr const char* s_help{
612 "Pauses the dataSets\n"
613 "@return true/false on success/failure"
614 };
615};
616
617// stop helper class declaration
619 public yarp::os::Portable
620{
621public:
623 bool write(yarp::os::ConnectionWriter& connection) const override;
624 bool read(yarp::os::ConnectionReader& connection) override;
625
626 class Command :
628 {
629 public:
630 Command() = default;
631 ~Command() override = default;
632
633 bool write(yarp::os::ConnectionWriter& connection) const override;
634 bool read(yarp::os::ConnectionReader& connection) override;
635
636 bool write(const yarp::os::idl::WireWriter& writer) const override;
637 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
638 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
639
640 bool read(yarp::os::idl::WireReader& reader) override;
643 };
644
645 class Reply :
647 {
648 public:
649 Reply() = default;
650 ~Reply() override = default;
651
652 bool write(yarp::os::ConnectionWriter& connection) const override;
653 bool read(yarp::os::ConnectionReader& connection) override;
654
655 bool write(const yarp::os::idl::WireWriter& writer) const override;
656 bool read(yarp::os::idl::WireReader& reader) override;
657
658 bool return_helper{false};
659 };
660
661 using funcptr_t = bool (*)();
662 void call(yarpdataplayer_IDL* ptr);
663
666
667 static constexpr const char* s_tag{"stop"};
668 static constexpr size_t s_tag_len{1};
669 static constexpr size_t s_cmd_len{1};
670 static constexpr size_t s_reply_len{1};
671 static constexpr const char* s_prototype{"bool yarpdataplayer_IDL::stop()"};
672 static constexpr const char* s_help{
673 "Stops the dataSets\n"
674 "@return true/false on success/failure"
675 };
676};
677
678// quit helper class declaration
680 public yarp::os::Portable
681{
682public:
684 bool write(yarp::os::ConnectionWriter& connection) const override;
685 bool read(yarp::os::ConnectionReader& connection) override;
686
687 class Command :
689 {
690 public:
691 Command() = default;
692 ~Command() override = default;
693
694 bool write(yarp::os::ConnectionWriter& connection) const override;
695 bool read(yarp::os::ConnectionReader& connection) override;
696
697 bool write(const yarp::os::idl::WireWriter& writer) const override;
698 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
699 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
700
701 bool read(yarp::os::idl::WireReader& reader) override;
704 };
705
706 class Reply :
708 {
709 public:
710 Reply() = default;
711 ~Reply() override = default;
712
713 bool write(yarp::os::ConnectionWriter& connection) const override;
714 bool read(yarp::os::ConnectionReader& connection) override;
715
716 bool write(const yarp::os::idl::WireWriter& writer) const override;
717 bool read(yarp::os::idl::WireReader& reader) override;
718
719 bool return_helper{false};
720 };
721
722 using funcptr_t = bool (*)();
723 void call(yarpdataplayer_IDL* ptr);
724
727
728 static constexpr const char* s_tag{"quit"};
729 static constexpr size_t s_tag_len{1};
730 static constexpr size_t s_cmd_len{1};
731 static constexpr size_t s_reply_len{1};
732 static constexpr const char* s_prototype{"bool yarpdataplayer_IDL::quit()"};
733 static constexpr const char* s_help{
734 "Quit the module.\n"
735 "@return true/false on success/failure"
736 };
737};
738
739// step helper class implementation
741{
742 return cmd.write(connection);
743}
744
746{
747 return reply.read(connection);
748}
749
751{
752 yarp::os::idl::WireWriter writer(connection);
753 if (!writer.writeListHeader(s_cmd_len)) {
754 return false;
755 }
756 return write(writer);
757}
758
760{
761 yarp::os::idl::WireReader reader(connection);
762 if (!reader.readListHeader()) {
763 reader.fail();
764 return false;
765 }
766 return read(reader);
767}
768
770{
771 if (!writeTag(writer)) {
772 return false;
773 }
774 if (!writeArgs(writer)) {
775 return false;
776 }
777 return true;
778}
779
781{
782 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
783 return false;
784 }
785 return true;
786}
787
789{
790 return true;
791}
792
794{
795 if (!readTag(reader)) {
796 return false;
797 }
798 if (!readArgs(reader)) {
799 return false;
800 }
801 return true;
802}
803
805{
806 std::string tag = reader.readTag(s_tag_len);
807 if (reader.isError()) {
808 return false;
809 }
810 if (tag != s_tag) {
811 reader.fail();
812 return false;
813 }
814 return true;
815}
816
818{
819 if (!reader.noMore()) {
820 reader.fail();
821 return false;
822 }
823 return true;
824}
825
827{
828 yarp::os::idl::WireWriter writer(connection);
829 return write(writer);
830}
831
833{
834 yarp::os::idl::WireReader reader(connection);
835 return read(reader);
836}
837
839{
840 if (!writer.isNull()) {
841 if (!writer.writeListHeader(s_reply_len)) {
842 return false;
843 }
844 if (!writer.writeBool(return_helper)) {
845 return false;
846 }
847 }
848 return true;
849}
850
852{
853 if (!reader.readListReturn()) {
854 return false;
855 }
856 if (reader.noMore()) {
857 reader.fail();
858 return false;
859 }
860 if (!reader.readBool(return_helper)) {
861 reader.fail();
862 return false;
863 }
864 return true;
865}
866
871
872// setFrame helper class implementation
874 cmd{frameNum}
875{
876}
877
879{
880 return cmd.write(connection);
881}
882
884{
885 return reply.read(connection);
886}
887
889 frameNum{frameNum}
890{
891}
892
894{
895 yarp::os::idl::WireWriter writer(connection);
896 if (!writer.writeListHeader(s_cmd_len)) {
897 return false;
898 }
899 return write(writer);
900}
901
903{
904 yarp::os::idl::WireReader reader(connection);
905 if (!reader.readListHeader()) {
906 reader.fail();
907 return false;
908 }
909 return read(reader);
910}
911
913{
914 if (!writeTag(writer)) {
915 return false;
916 }
917 if (!writeArgs(writer)) {
918 return false;
919 }
920 return true;
921}
922
924{
925 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
926 return false;
927 }
928 return true;
929}
930
932{
933 if (!writer.writeI32(frameNum)) {
934 return false;
935 }
936 return true;
937}
938
940{
941 if (!readTag(reader)) {
942 return false;
943 }
944 if (!readArgs(reader)) {
945 return false;
946 }
947 return true;
948}
949
951{
952 std::string tag = reader.readTag(s_tag_len);
953 if (reader.isError()) {
954 return false;
955 }
956 if (tag != s_tag) {
957 reader.fail();
958 return false;
959 }
960 return true;
961}
962
964{
965 if (reader.noMore()) {
966 reader.fail();
967 return false;
968 }
969 if (!reader.readI32(frameNum)) {
970 reader.fail();
971 return false;
972 }
973 if (!reader.noMore()) {
974 reader.fail();
975 return false;
976 }
977 return true;
978}
979
981{
982 yarp::os::idl::WireWriter writer(connection);
983 return write(writer);
984}
985
987{
988 yarp::os::idl::WireReader reader(connection);
989 return read(reader);
990}
991
993{
994 if (!writer.isNull()) {
995 if (!writer.writeListHeader(s_reply_len)) {
996 return false;
997 }
998 if (!writer.writeBool(return_helper)) {
999 return false;
1000 }
1001 }
1002 return true;
1003}
1004
1006{
1007 if (!reader.readListReturn()) {
1008 return false;
1009 }
1010 if (reader.noMore()) {
1011 reader.fail();
1012 return false;
1013 }
1014 if (!reader.readBool(return_helper)) {
1015 reader.fail();
1016 return false;
1017 }
1018 return true;
1019}
1020
1025
1026// getFrame helper class implementation
1028 cmd{name}
1029{
1030}
1031
1033{
1034 return cmd.write(connection);
1035}
1036
1038{
1039 return reply.read(connection);
1040}
1041
1043 name{name}
1044{
1045}
1046
1048{
1049 yarp::os::idl::WireWriter writer(connection);
1050 if (!writer.writeListHeader(s_cmd_len)) {
1051 return false;
1052 }
1053 return write(writer);
1054}
1055
1057{
1058 yarp::os::idl::WireReader reader(connection);
1059 if (!reader.readListHeader()) {
1060 reader.fail();
1061 return false;
1062 }
1063 return read(reader);
1064}
1065
1067{
1068 if (!writeTag(writer)) {
1069 return false;
1070 }
1071 if (!writeArgs(writer)) {
1072 return false;
1073 }
1074 return true;
1075}
1076
1078{
1079 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1080 return false;
1081 }
1082 return true;
1083}
1084
1086{
1087 if (!writer.writeString(name)) {
1088 return false;
1089 }
1090 return true;
1091}
1092
1094{
1095 if (!readTag(reader)) {
1096 return false;
1097 }
1098 if (!readArgs(reader)) {
1099 return false;
1100 }
1101 return true;
1102}
1103
1105{
1106 std::string tag = reader.readTag(s_tag_len);
1107 if (reader.isError()) {
1108 return false;
1109 }
1110 if (tag != s_tag) {
1111 reader.fail();
1112 return false;
1113 }
1114 return true;
1115}
1116
1118{
1119 if (reader.noMore()) {
1120 reader.fail();
1121 return false;
1122 }
1123 if (!reader.readString(name)) {
1124 reader.fail();
1125 return false;
1126 }
1127 if (!reader.noMore()) {
1128 reader.fail();
1129 return false;
1130 }
1131 return true;
1132}
1133
1135{
1136 yarp::os::idl::WireWriter writer(connection);
1137 return write(writer);
1138}
1139
1141{
1142 yarp::os::idl::WireReader reader(connection);
1143 return read(reader);
1144}
1145
1147{
1148 if (!writer.isNull()) {
1149 if (!writer.writeListHeader(s_reply_len)) {
1150 return false;
1151 }
1152 if (!writer.writeI32(return_helper)) {
1153 return false;
1154 }
1155 }
1156 return true;
1157}
1158
1160{
1161 if (!reader.readListReturn()) {
1162 return false;
1163 }
1164 if (reader.noMore()) {
1165 reader.fail();
1166 return false;
1167 }
1168 if (!reader.readI32(return_helper)) {
1169 reader.fail();
1170 return false;
1171 }
1172 return true;
1173}
1174
1179
1180// load helper class implementation
1182 cmd{path}
1183{
1184}
1185
1187{
1188 return cmd.write(connection);
1189}
1190
1192{
1193 return reply.read(connection);
1194}
1195
1197 path{path}
1198{
1199}
1200
1202{
1203 yarp::os::idl::WireWriter writer(connection);
1204 if (!writer.writeListHeader(s_cmd_len)) {
1205 return false;
1206 }
1207 return write(writer);
1208}
1209
1211{
1212 yarp::os::idl::WireReader reader(connection);
1213 if (!reader.readListHeader()) {
1214 reader.fail();
1215 return false;
1216 }
1217 return read(reader);
1218}
1219
1221{
1222 if (!writeTag(writer)) {
1223 return false;
1224 }
1225 if (!writeArgs(writer)) {
1226 return false;
1227 }
1228 return true;
1229}
1230
1232{
1233 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1234 return false;
1235 }
1236 return true;
1237}
1238
1240{
1241 if (!writer.writeString(path)) {
1242 return false;
1243 }
1244 return true;
1245}
1246
1248{
1249 if (!readTag(reader)) {
1250 return false;
1251 }
1252 if (!readArgs(reader)) {
1253 return false;
1254 }
1255 return true;
1256}
1257
1259{
1260 std::string tag = reader.readTag(s_tag_len);
1261 if (reader.isError()) {
1262 return false;
1263 }
1264 if (tag != s_tag) {
1265 reader.fail();
1266 return false;
1267 }
1268 return true;
1269}
1270
1272{
1273 if (reader.noMore()) {
1274 reader.fail();
1275 return false;
1276 }
1277 if (!reader.readString(path)) {
1278 reader.fail();
1279 return false;
1280 }
1281 if (!reader.noMore()) {
1282 reader.fail();
1283 return false;
1284 }
1285 return true;
1286}
1287
1289{
1290 yarp::os::idl::WireWriter writer(connection);
1291 return write(writer);
1292}
1293
1295{
1296 yarp::os::idl::WireReader reader(connection);
1297 return read(reader);
1298}
1299
1301{
1302 if (!writer.isNull()) {
1303 if (!writer.writeListHeader(s_reply_len)) {
1304 return false;
1305 }
1306 if (!writer.writeBool(return_helper)) {
1307 return false;
1308 }
1309 }
1310 return true;
1311}
1312
1314{
1315 if (!reader.readListReturn()) {
1316 return false;
1317 }
1318 if (reader.noMore()) {
1319 reader.fail();
1320 return false;
1321 }
1322 if (!reader.readBool(return_helper)) {
1323 reader.fail();
1324 return false;
1325 }
1326 return true;
1327}
1328
1333
1334// getSliderPercentage helper class implementation
1336{
1337 return cmd.write(connection);
1338}
1339
1344
1346{
1347 yarp::os::idl::WireWriter writer(connection);
1348 if (!writer.writeListHeader(s_cmd_len)) {
1349 return false;
1350 }
1351 return write(writer);
1352}
1353
1355{
1356 yarp::os::idl::WireReader reader(connection);
1357 if (!reader.readListHeader()) {
1358 reader.fail();
1359 return false;
1360 }
1361 return read(reader);
1362}
1363
1365{
1366 if (!writeTag(writer)) {
1367 return false;
1368 }
1369 if (!writeArgs(writer)) {
1370 return false;
1371 }
1372 return true;
1373}
1374
1376{
1377 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1378 return false;
1379 }
1380 return true;
1381}
1382
1384{
1385 return true;
1386}
1387
1389{
1390 if (!readTag(reader)) {
1391 return false;
1392 }
1393 if (!readArgs(reader)) {
1394 return false;
1395 }
1396 return true;
1397}
1398
1400{
1401 std::string tag = reader.readTag(s_tag_len);
1402 if (reader.isError()) {
1403 return false;
1404 }
1405 if (tag != s_tag) {
1406 reader.fail();
1407 return false;
1408 }
1409 return true;
1410}
1411
1413{
1414 if (!reader.noMore()) {
1415 reader.fail();
1416 return false;
1417 }
1418 return true;
1419}
1420
1422{
1423 yarp::os::idl::WireWriter writer(connection);
1424 return write(writer);
1425}
1426
1428{
1429 yarp::os::idl::WireReader reader(connection);
1430 return read(reader);
1431}
1432
1434{
1435 if (!writer.isNull()) {
1436 if (!writer.writeListHeader(s_reply_len)) {
1437 return false;
1438 }
1439 if (!writer.writeI32(return_helper)) {
1440 return false;
1441 }
1442 }
1443 return true;
1444}
1445
1447{
1448 if (!reader.readListReturn()) {
1449 return false;
1450 }
1451 if (reader.noMore()) {
1452 reader.fail();
1453 return false;
1454 }
1455 if (!reader.readI32(return_helper)) {
1456 reader.fail();
1457 return false;
1458 }
1459 return true;
1460}
1461
1466
1467// getStatus helper class implementation
1469{
1470 return cmd.write(connection);
1471}
1472
1474{
1475 return reply.read(connection);
1476}
1477
1479{
1480 yarp::os::idl::WireWriter writer(connection);
1481 if (!writer.writeListHeader(s_cmd_len)) {
1482 return false;
1483 }
1484 return write(writer);
1485}
1486
1488{
1489 yarp::os::idl::WireReader reader(connection);
1490 if (!reader.readListHeader()) {
1491 reader.fail();
1492 return false;
1493 }
1494 return read(reader);
1495}
1496
1498{
1499 if (!writeTag(writer)) {
1500 return false;
1501 }
1502 if (!writeArgs(writer)) {
1503 return false;
1504 }
1505 return true;
1506}
1507
1509{
1510 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1511 return false;
1512 }
1513 return true;
1514}
1515
1517{
1518 return true;
1519}
1520
1522{
1523 if (!readTag(reader)) {
1524 return false;
1525 }
1526 if (!readArgs(reader)) {
1527 return false;
1528 }
1529 return true;
1530}
1531
1533{
1534 std::string tag = reader.readTag(s_tag_len);
1535 if (reader.isError()) {
1536 return false;
1537 }
1538 if (tag != s_tag) {
1539 reader.fail();
1540 return false;
1541 }
1542 return true;
1543}
1544
1546{
1547 if (!reader.noMore()) {
1548 reader.fail();
1549 return false;
1550 }
1551 return true;
1552}
1553
1555{
1556 yarp::os::idl::WireWriter writer(connection);
1557 return write(writer);
1558}
1559
1561{
1562 yarp::os::idl::WireReader reader(connection);
1563 return read(reader);
1564}
1565
1567{
1568 if (!writer.isNull()) {
1569 if (!writer.writeListHeader(s_reply_len)) {
1570 return false;
1571 }
1572 if (!writer.writeString(return_helper)) {
1573 return false;
1574 }
1575 }
1576 return true;
1577}
1578
1580{
1581 if (!reader.readListReturn()) {
1582 return false;
1583 }
1584 if (reader.noMore()) {
1585 reader.fail();
1586 return false;
1587 }
1588 if (!reader.readString(return_helper)) {
1589 reader.fail();
1590 return false;
1591 }
1592 return true;
1593}
1594
1599
1600// play helper class implementation
1602{
1603 return cmd.write(connection);
1604}
1605
1607{
1608 return reply.read(connection);
1609}
1610
1612{
1613 yarp::os::idl::WireWriter writer(connection);
1614 if (!writer.writeListHeader(s_cmd_len)) {
1615 return false;
1616 }
1617 return write(writer);
1618}
1619
1621{
1622 yarp::os::idl::WireReader reader(connection);
1623 if (!reader.readListHeader()) {
1624 reader.fail();
1625 return false;
1626 }
1627 return read(reader);
1628}
1629
1631{
1632 if (!writeTag(writer)) {
1633 return false;
1634 }
1635 if (!writeArgs(writer)) {
1636 return false;
1637 }
1638 return true;
1639}
1640
1642{
1643 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1644 return false;
1645 }
1646 return true;
1647}
1648
1650{
1651 return true;
1652}
1653
1655{
1656 if (!readTag(reader)) {
1657 return false;
1658 }
1659 if (!readArgs(reader)) {
1660 return false;
1661 }
1662 return true;
1663}
1664
1666{
1667 std::string tag = reader.readTag(s_tag_len);
1668 if (reader.isError()) {
1669 return false;
1670 }
1671 if (tag != s_tag) {
1672 reader.fail();
1673 return false;
1674 }
1675 return true;
1676}
1677
1679{
1680 if (!reader.noMore()) {
1681 reader.fail();
1682 return false;
1683 }
1684 return true;
1685}
1686
1688{
1689 yarp::os::idl::WireWriter writer(connection);
1690 return write(writer);
1691}
1692
1694{
1695 yarp::os::idl::WireReader reader(connection);
1696 return read(reader);
1697}
1698
1700{
1701 if (!writer.isNull()) {
1702 if (!writer.writeListHeader(s_reply_len)) {
1703 return false;
1704 }
1705 if (!writer.writeBool(return_helper)) {
1706 return false;
1707 }
1708 }
1709 return true;
1710}
1711
1713{
1714 if (!reader.readListReturn()) {
1715 return false;
1716 }
1717 if (reader.noMore()) {
1718 reader.fail();
1719 return false;
1720 }
1721 if (!reader.readBool(return_helper)) {
1722 reader.fail();
1723 return false;
1724 }
1725 return true;
1726}
1727
1732
1733// pause helper class implementation
1735{
1736 return cmd.write(connection);
1737}
1738
1740{
1741 return reply.read(connection);
1742}
1743
1745{
1746 yarp::os::idl::WireWriter writer(connection);
1747 if (!writer.writeListHeader(s_cmd_len)) {
1748 return false;
1749 }
1750 return write(writer);
1751}
1752
1754{
1755 yarp::os::idl::WireReader reader(connection);
1756 if (!reader.readListHeader()) {
1757 reader.fail();
1758 return false;
1759 }
1760 return read(reader);
1761}
1762
1764{
1765 if (!writeTag(writer)) {
1766 return false;
1767 }
1768 if (!writeArgs(writer)) {
1769 return false;
1770 }
1771 return true;
1772}
1773
1775{
1776 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1777 return false;
1778 }
1779 return true;
1780}
1781
1783{
1784 return true;
1785}
1786
1788{
1789 if (!readTag(reader)) {
1790 return false;
1791 }
1792 if (!readArgs(reader)) {
1793 return false;
1794 }
1795 return true;
1796}
1797
1799{
1800 std::string tag = reader.readTag(s_tag_len);
1801 if (reader.isError()) {
1802 return false;
1803 }
1804 if (tag != s_tag) {
1805 reader.fail();
1806 return false;
1807 }
1808 return true;
1809}
1810
1812{
1813 if (!reader.noMore()) {
1814 reader.fail();
1815 return false;
1816 }
1817 return true;
1818}
1819
1821{
1822 yarp::os::idl::WireWriter writer(connection);
1823 return write(writer);
1824}
1825
1827{
1828 yarp::os::idl::WireReader reader(connection);
1829 return read(reader);
1830}
1831
1833{
1834 if (!writer.isNull()) {
1835 if (!writer.writeListHeader(s_reply_len)) {
1836 return false;
1837 }
1838 if (!writer.writeBool(return_helper)) {
1839 return false;
1840 }
1841 }
1842 return true;
1843}
1844
1846{
1847 if (!reader.readListReturn()) {
1848 return false;
1849 }
1850 if (reader.noMore()) {
1851 reader.fail();
1852 return false;
1853 }
1854 if (!reader.readBool(return_helper)) {
1855 reader.fail();
1856 return false;
1857 }
1858 return true;
1859}
1860
1865
1866// stop helper class implementation
1868{
1869 return cmd.write(connection);
1870}
1871
1873{
1874 return reply.read(connection);
1875}
1876
1878{
1879 yarp::os::idl::WireWriter writer(connection);
1880 if (!writer.writeListHeader(s_cmd_len)) {
1881 return false;
1882 }
1883 return write(writer);
1884}
1885
1887{
1888 yarp::os::idl::WireReader reader(connection);
1889 if (!reader.readListHeader()) {
1890 reader.fail();
1891 return false;
1892 }
1893 return read(reader);
1894}
1895
1897{
1898 if (!writeTag(writer)) {
1899 return false;
1900 }
1901 if (!writeArgs(writer)) {
1902 return false;
1903 }
1904 return true;
1905}
1906
1908{
1909 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1910 return false;
1911 }
1912 return true;
1913}
1914
1916{
1917 return true;
1918}
1919
1921{
1922 if (!readTag(reader)) {
1923 return false;
1924 }
1925 if (!readArgs(reader)) {
1926 return false;
1927 }
1928 return true;
1929}
1930
1932{
1933 std::string tag = reader.readTag(s_tag_len);
1934 if (reader.isError()) {
1935 return false;
1936 }
1937 if (tag != s_tag) {
1938 reader.fail();
1939 return false;
1940 }
1941 return true;
1942}
1943
1945{
1946 if (!reader.noMore()) {
1947 reader.fail();
1948 return false;
1949 }
1950 return true;
1951}
1952
1954{
1955 yarp::os::idl::WireWriter writer(connection);
1956 return write(writer);
1957}
1958
1960{
1961 yarp::os::idl::WireReader reader(connection);
1962 return read(reader);
1963}
1964
1966{
1967 if (!writer.isNull()) {
1968 if (!writer.writeListHeader(s_reply_len)) {
1969 return false;
1970 }
1971 if (!writer.writeBool(return_helper)) {
1972 return false;
1973 }
1974 }
1975 return true;
1976}
1977
1979{
1980 if (!reader.readListReturn()) {
1981 return false;
1982 }
1983 if (reader.noMore()) {
1984 reader.fail();
1985 return false;
1986 }
1987 if (!reader.readBool(return_helper)) {
1988 reader.fail();
1989 return false;
1990 }
1991 return true;
1992}
1993
1998
1999// quit helper class implementation
2001{
2002 return cmd.write(connection);
2003}
2004
2006{
2007 return reply.read(connection);
2008}
2009
2011{
2012 yarp::os::idl::WireWriter writer(connection);
2013 if (!writer.writeListHeader(s_cmd_len)) {
2014 return false;
2015 }
2016 return write(writer);
2017}
2018
2020{
2021 yarp::os::idl::WireReader reader(connection);
2022 if (!reader.readListHeader()) {
2023 reader.fail();
2024 return false;
2025 }
2026 return read(reader);
2027}
2028
2030{
2031 if (!writeTag(writer)) {
2032 return false;
2033 }
2034 if (!writeArgs(writer)) {
2035 return false;
2036 }
2037 return true;
2038}
2039
2041{
2042 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2043 return false;
2044 }
2045 return true;
2046}
2047
2049{
2050 return true;
2051}
2052
2054{
2055 if (!readTag(reader)) {
2056 return false;
2057 }
2058 if (!readArgs(reader)) {
2059 return false;
2060 }
2061 return true;
2062}
2063
2065{
2066 std::string tag = reader.readTag(s_tag_len);
2067 if (reader.isError()) {
2068 return false;
2069 }
2070 if (tag != s_tag) {
2071 reader.fail();
2072 return false;
2073 }
2074 return true;
2075}
2076
2078{
2079 if (!reader.noMore()) {
2080 reader.fail();
2081 return false;
2082 }
2083 return true;
2084}
2085
2087{
2088 yarp::os::idl::WireWriter writer(connection);
2089 return write(writer);
2090}
2091
2093{
2094 yarp::os::idl::WireReader reader(connection);
2095 return read(reader);
2096}
2097
2099{
2100 if (!writer.isNull()) {
2101 if (!writer.writeListHeader(s_reply_len)) {
2102 return false;
2103 }
2104 if (!writer.writeBool(return_helper)) {
2105 return false;
2106 }
2107 }
2108 return true;
2109}
2110
2112{
2113 if (!reader.readListReturn()) {
2114 return false;
2115 }
2116 if (reader.noMore()) {
2117 reader.fail();
2118 return false;
2119 }
2120 if (!reader.readBool(return_helper)) {
2121 reader.fail();
2122 return false;
2123 }
2124 return true;
2125}
2126
2131
2132// Constructor
2134{
2135 yarp().setOwner(*this);
2136}
2137
2139{
2140 if (!yarp().canWrite()) {
2141 yError("Missing server method '%s'?", yarpdataplayer_IDL_step_helper::s_prototype);
2142 }
2144 bool ok = yarp().write(helper, helper);
2145 return ok ? helper.reply.return_helper : bool{};
2146}
2147
2148bool yarpdataplayer_IDL::setFrame(const std::int32_t frameNum)
2149{
2150 if (!yarp().canWrite()) {
2151 yError("Missing server method '%s'?", yarpdataplayer_IDL_setFrame_helper::s_prototype);
2152 }
2153 yarpdataplayer_IDL_setFrame_helper helper{frameNum};
2154 bool ok = yarp().write(helper, helper);
2155 return ok ? helper.reply.return_helper : bool{};
2156}
2157
2158std::int32_t yarpdataplayer_IDL::getFrame(const std::string& name)
2159{
2160 if (!yarp().canWrite()) {
2161 yError("Missing server method '%s'?", yarpdataplayer_IDL_getFrame_helper::s_prototype);
2162 }
2164 bool ok = yarp().write(helper, helper);
2165 return ok ? helper.reply.return_helper : std::int32_t{};
2166}
2167
2168bool yarpdataplayer_IDL::load(const std::string& path)
2169{
2170 if (!yarp().canWrite()) {
2171 yError("Missing server method '%s'?", yarpdataplayer_IDL_load_helper::s_prototype);
2172 }
2173 yarpdataplayer_IDL_load_helper helper{path};
2174 bool ok = yarp().write(helper, helper);
2175 return ok ? helper.reply.return_helper : bool{};
2176}
2177
2179{
2180 if (!yarp().canWrite()) {
2182 }
2184 bool ok = yarp().write(helper, helper);
2185 return ok ? helper.reply.return_helper : std::int32_t{};
2186}
2187
2189{
2190 if (!yarp().canWrite()) {
2191 yError("Missing server method '%s'?", yarpdataplayer_IDL_getStatus_helper::s_prototype);
2192 }
2194 bool ok = yarp().write(helper, helper);
2195 return ok ? helper.reply.return_helper : std::string{};
2196}
2197
2199{
2200 if (!yarp().canWrite()) {
2201 yError("Missing server method '%s'?", yarpdataplayer_IDL_play_helper::s_prototype);
2202 }
2204 bool ok = yarp().write(helper, helper);
2205 return ok ? helper.reply.return_helper : bool{};
2206}
2207
2209{
2210 if (!yarp().canWrite()) {
2211 yError("Missing server method '%s'?", yarpdataplayer_IDL_pause_helper::s_prototype);
2212 }
2214 bool ok = yarp().write(helper, helper);
2215 return ok ? helper.reply.return_helper : bool{};
2216}
2217
2219{
2220 if (!yarp().canWrite()) {
2221 yError("Missing server method '%s'?", yarpdataplayer_IDL_stop_helper::s_prototype);
2222 }
2224 bool ok = yarp().write(helper, helper);
2225 return ok ? helper.reply.return_helper : bool{};
2226}
2227
2229{
2230 if (!yarp().canWrite()) {
2231 yError("Missing server method '%s'?", yarpdataplayer_IDL_quit_helper::s_prototype);
2232 }
2234 bool ok = yarp().write(helper, helper);
2235 return ok ? helper.reply.return_helper : bool{};
2236}
2237
2238// help method
2239std::vector<std::string> yarpdataplayer_IDL::help(const std::string& functionName)
2240{
2241 bool showAll = (functionName == "--all");
2242 std::vector<std::string> helpString;
2243 if (showAll) {
2244 helpString.emplace_back("*** Available commands:");
2245 helpString.emplace_back(yarpdataplayer_IDL_step_helper::s_tag);
2246 helpString.emplace_back(yarpdataplayer_IDL_setFrame_helper::s_tag);
2247 helpString.emplace_back(yarpdataplayer_IDL_getFrame_helper::s_tag);
2248 helpString.emplace_back(yarpdataplayer_IDL_load_helper::s_tag);
2250 helpString.emplace_back(yarpdataplayer_IDL_getStatus_helper::s_tag);
2251 helpString.emplace_back(yarpdataplayer_IDL_play_helper::s_tag);
2252 helpString.emplace_back(yarpdataplayer_IDL_pause_helper::s_tag);
2253 helpString.emplace_back(yarpdataplayer_IDL_stop_helper::s_tag);
2254 helpString.emplace_back(yarpdataplayer_IDL_quit_helper::s_tag);
2255 helpString.emplace_back("help");
2256 } else {
2257 if (functionName == yarpdataplayer_IDL_step_helper::s_tag) {
2258 helpString.emplace_back(yarpdataplayer_IDL_step_helper::s_prototype);
2259 helpString.emplace_back(yarpdataplayer_IDL_step_helper::s_help);
2260 }
2261 if (functionName == yarpdataplayer_IDL_setFrame_helper::s_tag) {
2262 helpString.emplace_back(yarpdataplayer_IDL_setFrame_helper::s_prototype);
2263 helpString.emplace_back(yarpdataplayer_IDL_setFrame_helper::s_help);
2264 }
2265 if (functionName == yarpdataplayer_IDL_getFrame_helper::s_tag) {
2266 helpString.emplace_back(yarpdataplayer_IDL_getFrame_helper::s_prototype);
2267 helpString.emplace_back(yarpdataplayer_IDL_getFrame_helper::s_help);
2268 }
2269 if (functionName == yarpdataplayer_IDL_load_helper::s_tag) {
2270 helpString.emplace_back(yarpdataplayer_IDL_load_helper::s_prototype);
2271 helpString.emplace_back(yarpdataplayer_IDL_load_helper::s_help);
2272 }
2276 }
2277 if (functionName == yarpdataplayer_IDL_getStatus_helper::s_tag) {
2278 helpString.emplace_back(yarpdataplayer_IDL_getStatus_helper::s_prototype);
2279 helpString.emplace_back(yarpdataplayer_IDL_getStatus_helper::s_help);
2280 }
2281 if (functionName == yarpdataplayer_IDL_play_helper::s_tag) {
2282 helpString.emplace_back(yarpdataplayer_IDL_play_helper::s_prototype);
2283 helpString.emplace_back(yarpdataplayer_IDL_play_helper::s_help);
2284 }
2285 if (functionName == yarpdataplayer_IDL_pause_helper::s_tag) {
2286 helpString.emplace_back(yarpdataplayer_IDL_pause_helper::s_prototype);
2287 helpString.emplace_back(yarpdataplayer_IDL_pause_helper::s_help);
2288 }
2289 if (functionName == yarpdataplayer_IDL_stop_helper::s_tag) {
2290 helpString.emplace_back(yarpdataplayer_IDL_stop_helper::s_prototype);
2291 helpString.emplace_back(yarpdataplayer_IDL_stop_helper::s_help);
2292 }
2293 if (functionName == yarpdataplayer_IDL_quit_helper::s_tag) {
2294 helpString.emplace_back(yarpdataplayer_IDL_quit_helper::s_prototype);
2295 helpString.emplace_back(yarpdataplayer_IDL_quit_helper::s_help);
2296 }
2297 if (functionName == "help") {
2298 helpString.emplace_back("std::vector<std::string> help(const std::string& functionName = \"--all\")");
2299 helpString.emplace_back("Return list of available commands, or help message for a specific function");
2300 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");
2301 helpString.emplace_back("@return list of strings (one string per line)");
2302 }
2303 }
2304 if (helpString.empty()) {
2305 helpString.emplace_back("Command not found");
2306 }
2307 return helpString;
2308}
2309
2310// read from ConnectionReader
2312{
2313 constexpr size_t max_tag_len = 1;
2314 size_t tag_len = 1;
2315
2316 yarp::os::idl::WireReader reader(connection);
2317 reader.expectAccept();
2318 if (!reader.readListHeader()) {
2319 reader.fail();
2320 return false;
2321 }
2322
2323 std::string tag = reader.readTag(1);
2324 bool direct = (tag == "__direct__");
2325 if (direct) {
2326 tag = reader.readTag(1);
2327 }
2328 while (tag_len <= max_tag_len && !reader.isError()) {
2329 if(tag == "getRemoteProtocolVersion") {
2330 if (!reader.noMore()) {
2331 yError("Reader invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
2332 reader.fail();
2333 return false;
2334 }
2335
2336 auto proto = getLocalProtocolVersion();
2337
2338 yarp::os::idl::WireWriter writer(reader);
2339 if (!writer.writeListHeader(1)) {
2340 yWarning("Writer invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
2341 return false;}
2342 if (!writer.write(proto)) {
2343 yWarning("Writer invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
2344 return false;
2345 }
2346 reader.accept();
2347 return true;
2348 }
2351 if (!helper.cmd.readArgs(reader)) {
2352 return false;
2353 }
2354
2355 helper.call(this);
2356
2357 yarp::os::idl::WireWriter writer(reader);
2358 if (!helper.reply.write(writer)) {
2359 return false;
2360 }
2361 reader.accept();
2362 return true;
2363 }
2366 if (!helper.cmd.readArgs(reader)) {
2367 return false;
2368 }
2369
2370 helper.call(this);
2371
2372 yarp::os::idl::WireWriter writer(reader);
2373 if (!helper.reply.write(writer)) {
2374 return false;
2375 }
2376 reader.accept();
2377 return true;
2378 }
2381 if (!helper.cmd.readArgs(reader)) {
2382 return false;
2383 }
2384
2385 helper.call(this);
2386
2387 yarp::os::idl::WireWriter writer(reader);
2388 if (!helper.reply.write(writer)) {
2389 return false;
2390 }
2391 reader.accept();
2392 return true;
2393 }
2396 if (!helper.cmd.readArgs(reader)) {
2397 return false;
2398 }
2399
2400 helper.call(this);
2401
2402 yarp::os::idl::WireWriter writer(reader);
2403 if (!helper.reply.write(writer)) {
2404 return false;
2405 }
2406 reader.accept();
2407 return true;
2408 }
2411 if (!helper.cmd.readArgs(reader)) {
2412 return false;
2413 }
2414
2415 helper.call(this);
2416
2417 yarp::os::idl::WireWriter writer(reader);
2418 if (!helper.reply.write(writer)) {
2419 return false;
2420 }
2421 reader.accept();
2422 return true;
2423 }
2426 if (!helper.cmd.readArgs(reader)) {
2427 return false;
2428 }
2429
2430 helper.call(this);
2431
2432 yarp::os::idl::WireWriter writer(reader);
2433 if (!helper.reply.write(writer)) {
2434 return false;
2435 }
2436 reader.accept();
2437 return true;
2438 }
2441 if (!helper.cmd.readArgs(reader)) {
2442 return false;
2443 }
2444
2445 helper.call(this);
2446
2447 yarp::os::idl::WireWriter writer(reader);
2448 if (!helper.reply.write(writer)) {
2449 return false;
2450 }
2451 reader.accept();
2452 return true;
2453 }
2456 if (!helper.cmd.readArgs(reader)) {
2457 return false;
2458 }
2459
2460 helper.call(this);
2461
2462 yarp::os::idl::WireWriter writer(reader);
2463 if (!helper.reply.write(writer)) {
2464 return false;
2465 }
2466 reader.accept();
2467 return true;
2468 }
2471 if (!helper.cmd.readArgs(reader)) {
2472 return false;
2473 }
2474
2475 helper.call(this);
2476
2477 yarp::os::idl::WireWriter writer(reader);
2478 if (!helper.reply.write(writer)) {
2479 return false;
2480 }
2481 reader.accept();
2482 return true;
2483 }
2486 if (!helper.cmd.readArgs(reader)) {
2487 return false;
2488 }
2489
2490 helper.call(this);
2491
2492 yarp::os::idl::WireWriter writer(reader);
2493 if (!helper.reply.write(writer)) {
2494 return false;
2495 }
2496 reader.accept();
2497 return true;
2498 }
2499 if (tag == "help") {
2500 std::string functionName;
2501 if (!reader.readString(functionName)) {
2502 functionName = "--all";
2503 }
2504 auto help_strings = help(functionName);
2505 yarp::os::idl::WireWriter writer(reader);
2506 if (!writer.isNull()) {
2507 if (!writer.writeListHeader(2)) {
2508 return false;
2509 }
2510 if (!writer.writeTag("many", 1, 0)) {
2511 return false;
2512 }
2513 if (!writer.writeListBegin(0, help_strings.size())) {
2514 return false;
2515 }
2516 for (const auto& help_string : help_strings) {
2517 if (!writer.writeString(help_string)) {
2518 return false;
2519 }
2520 }
2521 if (!writer.writeListEnd()) {
2522 return false;
2523 }
2524 }
2525 reader.accept();
2526 return true;
2527 }
2528 if (reader.noMore()) {
2529 reader.fail();
2530 return false;
2531 }
2532 std::string next_tag = reader.readTag(1);
2533 if (next_tag.empty()) {
2534 break;
2535 }
2536 tag.append("_").append(next_tag);
2537 tag_len = std::count(tag.begin(), tag.end(), '_') + 1;
2538 }
2539 return false;
2540}
#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 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 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.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_help
std::int32_t(*)(const std::string &) funcptr_t
void call(yarpdataplayer_IDL *ptr)
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
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 read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool 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 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 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.
static constexpr const char * s_prototype
static constexpr const char * s_tag
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_help
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 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 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_help
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr size_t s_reply_len
bool(*)(const std::string &) funcptr_t
static constexpr const char * s_prototype
void call(yarpdataplayer_IDL *ptr)
static constexpr const char * s_tag
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 read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool readArgs(yarp::os::idl::WireReader &reader)
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_tag
static constexpr const char * s_help
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_prototype
void call(yarpdataplayer_IDL *ptr)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool readTag(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 read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
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.
static constexpr const char * s_prototype
void call(yarpdataplayer_IDL *ptr)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_help
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_reply_len
bool writeTag(const yarp::os::idl::WireWriter &writer) const
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 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.
static constexpr size_t s_reply_len
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_help
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
void call(yarpdataplayer_IDL *ptr)
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to 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 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(*)(const std::int32_t) funcptr_t
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_help
static constexpr const char * s_prototype
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
void call(yarpdataplayer_IDL *ptr)
static constexpr const char * s_tag
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
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 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.
static constexpr const char * s_tag
void call(yarpdataplayer_IDL *ptr)
static constexpr const char * s_help
static constexpr const char * s_prototype
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
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool readTag(yarp::os::idl::WireReader &reader)
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 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
static constexpr const char * s_prototype
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
void call(yarpdataplayer_IDL *ptr)
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_help
yarpdataplayer_IDL Interface.
virtual bool play()
Plays the dataSets.
virtual bool quit()
Quit the module.
virtual bool setFrame(const std::int32_t frameNum)
Sets the frame number to the user desired frame.
virtual yarp::os::ApplicationNetworkProtocolVersion getRemoteProtocolVersion()
virtual bool step()
Steps the player once.
virtual yarp::os::ApplicationNetworkProtocolVersion getLocalProtocolVersion()
virtual std::vector< std::string > help(const std::string &functionName="--all")
virtual bool load(const std::string &path)
Loads a dataset from a path.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
virtual std::int32_t getFrame(const std::string &name)
Gets the frame number the user is requesting.
virtual bool checkProtocolVersion()
virtual bool pause()
Pauses the dataSets.
virtual bool stop()
Stops the dataSets.
virtual std::string getStatus()
Get the status of playing.
virtual std::int32_t getSliderPercentage()
Get slider percentage.
#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