YARP
Yet Another Robot Platform
 
Loading...
Searching...
No Matches
yarpdataplayer_console_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>
15#include <yarp/os/LogStream.h>
16
18
19#include <algorithm>
20
21namespace
22{
23 YARP_LOG_COMPONENT(SERVICE_LOG_COMPONENT, "yarpdataplayer_console_IDL")
24}
25
26//yarpdataplayer_console_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_console_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_console_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 (*)();
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_console_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_console_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);
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_console_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_console_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&);
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_console_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_console_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&);
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_console_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// play 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 bool return_helper{false};
415 };
416
417 using funcptr_t = bool (*)();
419
422
423 static constexpr const char* s_tag{"play"};
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{"bool yarpdataplayer_console_IDL::play()"};
428 static constexpr const char* s_help{
429 "Plays the dataSets\n"
430 "@return true/false on success/failure"
431 };
432};
433
434// pause 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 bool return_helper{false};
476 };
477
478 using funcptr_t = bool (*)();
480
483
484 static constexpr const char* s_tag{"pause"};
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{"bool yarpdataplayer_console_IDL::pause()"};
489 static constexpr const char* s_help{
490 "Pauses the dataSets\n"
491 "@return true/false on success/failure"
492 };
493};
494
495// stop 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 (*)();
541
544
545 static constexpr const char* s_tag{"stop"};
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_console_IDL::stop()"};
550 static constexpr const char* s_help{
551 "Stops the dataSets\n"
552 "@return true/false on success/failure"
553 };
554};
555
556// enable helper class declaration
558 public yarp::os::Portable
559{
560public:
562 explicit yarpdataplayer_console_IDL_enable_helper(const std::string& part);
563 bool write(yarp::os::ConnectionWriter& connection) const override;
564 bool read(yarp::os::ConnectionReader& connection) override;
565
566 class Command :
568 {
569 public:
570 Command() = default;
571 explicit Command(const std::string& part);
572
573 ~Command() override = default;
574
575 bool write(yarp::os::ConnectionWriter& connection) const override;
576 bool read(yarp::os::ConnectionReader& connection) override;
577
578 bool write(const yarp::os::idl::WireWriter& writer) const override;
579 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
580 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
581
582 bool read(yarp::os::idl::WireReader& reader) override;
585
586 std::string part{};
587 };
588
589 class Reply :
591 {
592 public:
593 Reply() = default;
594 ~Reply() override = default;
595
596 bool write(yarp::os::ConnectionWriter& connection) const override;
597 bool read(yarp::os::ConnectionReader& connection) override;
598
599 bool write(const yarp::os::idl::WireWriter& writer) const override;
600 bool read(yarp::os::idl::WireReader& reader) override;
601
602 bool return_helper{false};
603 };
604
605 using funcptr_t = bool (*)(const std::string&);
607
610
611 static constexpr const char* s_tag{"enable"};
612 static constexpr size_t s_tag_len{1};
613 static constexpr size_t s_cmd_len{2};
614 static constexpr size_t s_reply_len{1};
615 static constexpr const char* s_prototype{"bool yarpdataplayer_console_IDL::enable(const std::string& part)"};
616 static constexpr const char* s_help{
617 "Enables the specified part.\n"
618 "@param name specifies the name of the loaded data\n"
619 "@return true/false on success/failure"
620 };
621};
622
623// disable helper class declaration
625 public yarp::os::Portable
626{
627public:
629 explicit yarpdataplayer_console_IDL_disable_helper(const std::string& part);
630 bool write(yarp::os::ConnectionWriter& connection) const override;
631 bool read(yarp::os::ConnectionReader& connection) override;
632
633 class Command :
635 {
636 public:
637 Command() = default;
638 explicit Command(const std::string& part);
639
640 ~Command() override = default;
641
642 bool write(yarp::os::ConnectionWriter& connection) const override;
643 bool read(yarp::os::ConnectionReader& connection) override;
644
645 bool write(const yarp::os::idl::WireWriter& writer) const override;
646 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
647 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
648
649 bool read(yarp::os::idl::WireReader& reader) override;
652
653 std::string part{};
654 };
655
656 class Reply :
658 {
659 public:
660 Reply() = default;
661 ~Reply() override = default;
662
663 bool write(yarp::os::ConnectionWriter& connection) const override;
664 bool read(yarp::os::ConnectionReader& connection) override;
665
666 bool write(const yarp::os::idl::WireWriter& writer) const override;
667 bool read(yarp::os::idl::WireReader& reader) override;
668
669 bool return_helper{false};
670 };
671
672 using funcptr_t = bool (*)(const std::string&);
674
677
678 static constexpr const char* s_tag{"disable"};
679 static constexpr size_t s_tag_len{1};
680 static constexpr size_t s_cmd_len{2};
681 static constexpr size_t s_reply_len{1};
682 static constexpr const char* s_prototype{"bool yarpdataplayer_console_IDL::disable(const std::string& part)"};
683 static constexpr const char* s_help{
684 "Disable the specified part.\n"
685 "@param name specifies the name of the loaded data\n"
686 "@return true/false on success/failure"
687 };
688};
689
690// getAllParts helper class declaration
692 public yarp::os::Portable
693{
694public:
696 bool write(yarp::os::ConnectionWriter& connection) const override;
697 bool read(yarp::os::ConnectionReader& connection) override;
698
699 class Command :
701 {
702 public:
703 Command() = default;
704 ~Command() override = default;
705
706 bool write(yarp::os::ConnectionWriter& connection) const override;
707 bool read(yarp::os::ConnectionReader& connection) override;
708
709 bool write(const yarp::os::idl::WireWriter& writer) const override;
710 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
711 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
712
713 bool read(yarp::os::idl::WireReader& reader) override;
716 };
717
718 class Reply :
720 {
721 public:
722 Reply() = default;
723 ~Reply() override = default;
724
725 bool write(yarp::os::ConnectionWriter& connection) const override;
726 bool read(yarp::os::ConnectionReader& connection) override;
727
728 bool write(const yarp::os::idl::WireWriter& writer) const override;
729 bool read(yarp::os::idl::WireReader& reader) override;
730
731 std::vector<std::string> return_helper{};
732 };
733
734 using funcptr_t = std::vector<std::string> (*)();
736
739
740 static constexpr const char* s_tag{"getAllParts"};
741 static constexpr size_t s_tag_len{1};
742 static constexpr size_t s_cmd_len{1};
743 static constexpr size_t s_reply_len{1};
744 static constexpr const char* s_prototype{"std::vector<std::string> yarpdataplayer_console_IDL::getAllParts()"};
745 static constexpr const char* s_help{
746 "Gets the names of all parts loaded.\n"
747 "@return list of names of the loaded parts."
748 };
749};
750
751// getPortName helper class declaration
753 public yarp::os::Portable
754{
755public:
757 explicit yarpdataplayer_console_IDL_getPortName_helper(const std::string& part);
758 bool write(yarp::os::ConnectionWriter& connection) const override;
759 bool read(yarp::os::ConnectionReader& connection) override;
760
761 class Command :
763 {
764 public:
765 Command() = default;
766 explicit Command(const std::string& part);
767
768 ~Command() override = default;
769
770 bool write(yarp::os::ConnectionWriter& connection) const override;
771 bool read(yarp::os::ConnectionReader& connection) override;
772
773 bool write(const yarp::os::idl::WireWriter& writer) const override;
774 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
775 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
776
777 bool read(yarp::os::idl::WireReader& reader) override;
780
781 std::string part{};
782 };
783
784 class Reply :
786 {
787 public:
788 Reply() = default;
789 ~Reply() override = default;
790
791 bool write(yarp::os::ConnectionWriter& connection) const override;
792 bool read(yarp::os::ConnectionReader& connection) override;
793
794 bool write(const yarp::os::idl::WireWriter& writer) const override;
795 bool read(yarp::os::idl::WireReader& reader) override;
796
797 std::string return_helper{};
798 };
799
800 using funcptr_t = std::string (*)(const std::string&);
802
805
806 static constexpr const char* s_tag{"getPortName"};
807 static constexpr size_t s_tag_len{1};
808 static constexpr size_t s_cmd_len{2};
809 static constexpr size_t s_reply_len{1};
810 static constexpr const char* s_prototype{"std::string yarpdataplayer_console_IDL::getPortName(const std::string& part)"};
811 static constexpr const char* s_help{
812 "Gets the name of the port associated to the specified part\n"
813 "@param name specifies the name of the data to modify\n"
814 "@return port name"
815 };
816};
817
818// setPortName helper class declaration
820 public yarp::os::Portable
821{
822public:
824 yarpdataplayer_console_IDL_setPortName_helper(const std::string& part, const std::string& new_name);
825 bool write(yarp::os::ConnectionWriter& connection) const override;
826 bool read(yarp::os::ConnectionReader& connection) override;
827
828 class Command :
830 {
831 public:
832 Command() = default;
833 Command(const std::string& part, const std::string& new_name);
834
835 ~Command() override = default;
836
837 bool write(yarp::os::ConnectionWriter& connection) const override;
838 bool read(yarp::os::ConnectionReader& connection) override;
839
840 bool write(const yarp::os::idl::WireWriter& writer) const override;
841 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
842 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
843
844 bool read(yarp::os::idl::WireReader& reader) override;
847
848 std::string part{};
849 std::string new_name{};
850 };
851
852 class Reply :
854 {
855 public:
856 Reply() = default;
857 ~Reply() override = default;
858
859 bool write(yarp::os::ConnectionWriter& connection) const override;
860 bool read(yarp::os::ConnectionReader& connection) override;
861
862 bool write(const yarp::os::idl::WireWriter& writer) const override;
863 bool read(yarp::os::idl::WireReader& reader) override;
864
865 bool return_helper{false};
866 };
867
868 using funcptr_t = bool (*)(const std::string&, const std::string&);
870
873
874 static constexpr const char* s_tag{"setPortName"};
875 static constexpr size_t s_tag_len{1};
876 static constexpr size_t s_cmd_len{3};
877 static constexpr size_t s_reply_len{1};
878 static constexpr const char* s_prototype{"bool yarpdataplayer_console_IDL::setPortName(const std::string& part, const std::string& new_name)"};
879 static constexpr const char* s_help{
880 "Sets the name of the port associated to the specified part\n"
881 "@param part specifies the name of the data to modify\n"
882 "@param new_name specifies the new name to assign to the port\n"
883 "@return true/false on success/failure"
884 };
885};
886
887// setSpeed helper class declaration
889 public yarp::os::Portable
890{
891public:
893 explicit yarpdataplayer_console_IDL_setSpeed_helper(const double speed);
894 bool write(yarp::os::ConnectionWriter& connection) const override;
895 bool read(yarp::os::ConnectionReader& connection) override;
896
897 class Command :
899 {
900 public:
901 Command() = default;
902 explicit Command(const double speed);
903
904 ~Command() override = default;
905
906 bool write(yarp::os::ConnectionWriter& connection) const override;
907 bool read(yarp::os::ConnectionReader& connection) override;
908
909 bool write(const yarp::os::idl::WireWriter& writer) const override;
910 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
911 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
912
913 bool read(yarp::os::idl::WireReader& reader) override;
916
917 double speed{0.0};
918 };
919
920 class Reply :
922 {
923 public:
924 Reply() = default;
925 ~Reply() override = default;
926
927 bool write(yarp::os::ConnectionWriter& connection) const override;
928 bool read(yarp::os::ConnectionReader& connection) override;
929
930 bool write(const yarp::os::idl::WireWriter& writer) const override;
931 bool read(yarp::os::idl::WireReader& reader) override;
932
933 bool return_helper{false};
934 };
935
936 using funcptr_t = bool (*)(const double);
938
941
942 static constexpr const char* s_tag{"setSpeed"};
943 static constexpr size_t s_tag_len{1};
944 static constexpr size_t s_cmd_len{2};
945 static constexpr size_t s_reply_len{1};
946 static constexpr const char* s_prototype{"bool yarpdataplayer_console_IDL::setSpeed(const double speed)"};
947 static constexpr const char* s_help{
948 "Sets the player speed\n"
949 "@param speed specifies\n"
950 "@return true/false on success/failure"
951 };
952};
953
954// getSpeed helper class declaration
956 public yarp::os::Portable
957{
958public:
960 bool write(yarp::os::ConnectionWriter& connection) const override;
961 bool read(yarp::os::ConnectionReader& connection) override;
962
963 class Command :
965 {
966 public:
967 Command() = default;
968 ~Command() override = default;
969
970 bool write(yarp::os::ConnectionWriter& connection) const override;
971 bool read(yarp::os::ConnectionReader& connection) override;
972
973 bool write(const yarp::os::idl::WireWriter& writer) const override;
974 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
975 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
976
977 bool read(yarp::os::idl::WireReader& reader) override;
980 };
981
982 class Reply :
984 {
985 public:
986 Reply() = default;
987 ~Reply() override = default;
988
989 bool write(yarp::os::ConnectionWriter& connection) const override;
990 bool read(yarp::os::ConnectionReader& connection) override;
991
992 bool write(const yarp::os::idl::WireWriter& writer) const override;
993 bool read(yarp::os::idl::WireReader& reader) override;
994
995 double return_helper{0.0};
996 };
997
998 using funcptr_t = double (*)();
1000
1003
1004 static constexpr const char* s_tag{"getSpeed"};
1005 static constexpr size_t s_tag_len{1};
1006 static constexpr size_t s_cmd_len{1};
1007 static constexpr size_t s_reply_len{1};
1008 static constexpr const char* s_prototype{"double yarpdataplayer_console_IDL::getSpeed()"};
1009 static constexpr const char* s_help{
1010 "Gets the player speed\n"
1011 "@return value of the player speed"
1012 };
1013};
1014
1015// repeat helper class declaration
1017 public yarp::os::Portable
1018{
1019public:
1021 explicit yarpdataplayer_console_IDL_repeat_helper(const bool val);
1022 bool write(yarp::os::ConnectionWriter& connection) const override;
1023 bool read(yarp::os::ConnectionReader& connection) override;
1024
1025 class Command :
1027 {
1028 public:
1029 Command() = default;
1030 explicit Command(const bool val);
1031
1032 ~Command() override = default;
1033
1034 bool write(yarp::os::ConnectionWriter& connection) const override;
1035 bool read(yarp::os::ConnectionReader& connection) override;
1036
1037 bool write(const yarp::os::idl::WireWriter& writer) const override;
1038 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1039 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1040
1041 bool read(yarp::os::idl::WireReader& reader) override;
1042 bool readTag(yarp::os::idl::WireReader& reader);
1043 bool readArgs(yarp::os::idl::WireReader& reader);
1044
1045 bool val{false};
1046 };
1047
1048 class Reply :
1050 {
1051 public:
1052 Reply() = default;
1053 ~Reply() override = default;
1054
1055 bool write(yarp::os::ConnectionWriter& connection) const override;
1056 bool read(yarp::os::ConnectionReader& connection) override;
1057
1058 bool write(const yarp::os::idl::WireWriter& writer) const override;
1059 bool read(yarp::os::idl::WireReader& reader) override;
1060
1061 bool return_helper{false};
1062 };
1063
1064 using funcptr_t = bool (*)(const bool);
1066
1069
1070 static constexpr const char* s_tag{"repeat"};
1071 static constexpr size_t s_tag_len{1};
1072 static constexpr size_t s_cmd_len{2};
1073 static constexpr size_t s_reply_len{1};
1074 static constexpr const char* s_prototype{"bool yarpdataplayer_console_IDL::repeat(const bool val)"};
1075 static constexpr const char* s_help{
1076 "Sets repeat mode\n"
1077 "@param val if true repeat mode is active.\n"
1078 "@return true/false on success/failure"
1079 };
1080};
1081
1082// setStrict helper class declaration
1084 public yarp::os::Portable
1085{
1086public:
1088 explicit yarpdataplayer_console_IDL_setStrict_helper(const bool val);
1089 bool write(yarp::os::ConnectionWriter& connection) const override;
1090 bool read(yarp::os::ConnectionReader& connection) override;
1091
1092 class Command :
1094 {
1095 public:
1096 Command() = default;
1097 explicit Command(const bool val);
1098
1099 ~Command() override = default;
1100
1101 bool write(yarp::os::ConnectionWriter& connection) const override;
1102 bool read(yarp::os::ConnectionReader& connection) override;
1103
1104 bool write(const yarp::os::idl::WireWriter& writer) const override;
1105 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1106 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1107
1108 bool read(yarp::os::idl::WireReader& reader) override;
1109 bool readTag(yarp::os::idl::WireReader& reader);
1110 bool readArgs(yarp::os::idl::WireReader& reader);
1111
1112 bool val{false};
1113 };
1114
1115 class Reply :
1117 {
1118 public:
1119 Reply() = default;
1120 ~Reply() override = default;
1121
1122 bool write(yarp::os::ConnectionWriter& connection) const override;
1123 bool read(yarp::os::ConnectionReader& connection) override;
1124
1125 bool write(const yarp::os::idl::WireWriter& writer) const override;
1126 bool read(yarp::os::idl::WireReader& reader) override;
1127
1128 bool return_helper{false};
1129 };
1130
1131 using funcptr_t = bool (*)(const bool);
1133
1136
1137 static constexpr const char* s_tag{"setStrict"};
1138 static constexpr size_t s_tag_len{1};
1139 static constexpr size_t s_cmd_len{2};
1140 static constexpr size_t s_reply_len{1};
1141 static constexpr const char* s_prototype{"bool yarpdataplayer_console_IDL::setStrict(const bool val)"};
1142 static constexpr const char* s_help{
1143 "Sets strict mode\n"
1144 "@param val if true strict mode is active.\n"
1145 "@return true/false on success/failure"
1146 };
1147};
1148
1149// forward helper class declaration
1151 public yarp::os::Portable
1152{
1153public:
1155 explicit yarpdataplayer_console_IDL_forward_helper(const std::int32_t steps);
1156 bool write(yarp::os::ConnectionWriter& connection) const override;
1157 bool read(yarp::os::ConnectionReader& connection) override;
1158
1159 class Command :
1161 {
1162 public:
1163 Command() = default;
1164 explicit Command(const std::int32_t steps);
1165
1166 ~Command() override = default;
1167
1168 bool write(yarp::os::ConnectionWriter& connection) const override;
1169 bool read(yarp::os::ConnectionReader& connection) override;
1170
1171 bool write(const yarp::os::idl::WireWriter& writer) const override;
1172 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1173 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1174
1175 bool read(yarp::os::idl::WireReader& reader) override;
1176 bool readTag(yarp::os::idl::WireReader& reader);
1177 bool readArgs(yarp::os::idl::WireReader& reader);
1178
1179 std::int32_t steps{5};
1180 };
1181
1182 class Reply :
1184 {
1185 public:
1186 Reply() = default;
1187 ~Reply() override = default;
1188
1189 bool write(yarp::os::ConnectionWriter& connection) const override;
1190 bool read(yarp::os::ConnectionReader& connection) override;
1191
1192 bool write(const yarp::os::idl::WireWriter& writer) const override;
1193 bool read(yarp::os::idl::WireReader& reader) override;
1194
1195 bool return_helper{false};
1196 };
1197
1198 using funcptr_t = bool (*)(const std::int32_t);
1200
1203
1204 static constexpr const char* s_tag{"forward"};
1205 static constexpr size_t s_tag_len{1};
1206 static constexpr size_t s_cmd_len{2};
1207 static constexpr size_t s_reply_len{1};
1208 static constexpr const char* s_prototype{"bool yarpdataplayer_console_IDL::forward(const std::int32_t steps)"};
1209 static constexpr const char* s_help{
1210 "Steps forward\n"
1211 "@param steps number of steps to go forward (default=5).\n"
1212 "@return true/false on success/failure"
1213 };
1214};
1215
1216// backward helper class declaration
1218 public yarp::os::Portable
1219{
1220public:
1222 explicit yarpdataplayer_console_IDL_backward_helper(const std::int32_t steps);
1223 bool write(yarp::os::ConnectionWriter& connection) const override;
1224 bool read(yarp::os::ConnectionReader& connection) override;
1225
1226 class Command :
1228 {
1229 public:
1230 Command() = default;
1231 explicit Command(const std::int32_t steps);
1232
1233 ~Command() override = default;
1234
1235 bool write(yarp::os::ConnectionWriter& connection) const override;
1236 bool read(yarp::os::ConnectionReader& connection) override;
1237
1238 bool write(const yarp::os::idl::WireWriter& writer) const override;
1239 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1240 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1241
1242 bool read(yarp::os::idl::WireReader& reader) override;
1243 bool readTag(yarp::os::idl::WireReader& reader);
1244 bool readArgs(yarp::os::idl::WireReader& reader);
1245
1246 std::int32_t steps{5};
1247 };
1248
1249 class Reply :
1251 {
1252 public:
1253 Reply() = default;
1254 ~Reply() override = default;
1255
1256 bool write(yarp::os::ConnectionWriter& connection) const override;
1257 bool read(yarp::os::ConnectionReader& connection) override;
1258
1259 bool write(const yarp::os::idl::WireWriter& writer) const override;
1260 bool read(yarp::os::idl::WireReader& reader) override;
1261
1262 bool return_helper{false};
1263 };
1264
1265 using funcptr_t = bool (*)(const std::int32_t);
1267
1270
1271 static constexpr const char* s_tag{"backward"};
1272 static constexpr size_t s_tag_len{1};
1273 static constexpr size_t s_cmd_len{2};
1274 static constexpr size_t s_reply_len{1};
1275 static constexpr const char* s_prototype{"bool yarpdataplayer_console_IDL::backward(const std::int32_t steps)"};
1276 static constexpr const char* s_help{
1277 "Steps backward\n"
1278 "@param steps number of steps to go backward (default=5).\n"
1279 "@return true/false on success/failure"
1280 };
1281};
1282
1283// getProgress helper class declaration
1285 public yarp::os::Portable
1286{
1287public:
1289 bool write(yarp::os::ConnectionWriter& connection) const override;
1290 bool read(yarp::os::ConnectionReader& connection) override;
1291
1292 class Command :
1294 {
1295 public:
1296 Command() = default;
1297 ~Command() override = default;
1298
1299 bool write(yarp::os::ConnectionWriter& connection) const override;
1300 bool read(yarp::os::ConnectionReader& connection) override;
1301
1302 bool write(const yarp::os::idl::WireWriter& writer) const override;
1303 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1304 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1305
1306 bool read(yarp::os::idl::WireReader& reader) override;
1307 bool readTag(yarp::os::idl::WireReader& reader);
1308 bool readArgs(yarp::os::idl::WireReader& reader);
1309 };
1310
1311 class Reply :
1313 {
1314 public:
1315 Reply() = default;
1316 ~Reply() override = default;
1317
1318 bool write(yarp::os::ConnectionWriter& connection) const override;
1319 bool read(yarp::os::ConnectionReader& connection) override;
1320
1321 bool write(const yarp::os::idl::WireWriter& writer) const override;
1322 bool read(yarp::os::idl::WireReader& reader) override;
1323
1324 double return_helper{0.0};
1325 };
1326
1327 using funcptr_t = double (*)();
1329
1332
1333 static constexpr const char* s_tag{"getProgress"};
1334 static constexpr size_t s_tag_len{1};
1335 static constexpr size_t s_cmd_len{1};
1336 static constexpr size_t s_reply_len{1};
1337 static constexpr const char* s_prototype{"double yarpdataplayer_console_IDL::getProgress()"};
1338 static constexpr const char* s_help{
1339 "Get the progress of the parts\n"
1340 "@return the progress of the parts"
1341 };
1342};
1343
1344// getStatus helper class declaration
1346 public yarp::os::Portable
1347{
1348public:
1350 bool write(yarp::os::ConnectionWriter& connection) const override;
1351 bool read(yarp::os::ConnectionReader& connection) override;
1352
1353 class Command :
1355 {
1356 public:
1357 Command() = default;
1358 ~Command() override = default;
1359
1360 bool write(yarp::os::ConnectionWriter& connection) const override;
1361 bool read(yarp::os::ConnectionReader& connection) override;
1362
1363 bool write(const yarp::os::idl::WireWriter& writer) const override;
1364 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1365 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1366
1367 bool read(yarp::os::idl::WireReader& reader) override;
1368 bool readTag(yarp::os::idl::WireReader& reader);
1369 bool readArgs(yarp::os::idl::WireReader& reader);
1370 };
1371
1372 class Reply :
1374 {
1375 public:
1376 Reply() = default;
1377 ~Reply() override = default;
1378
1379 bool write(yarp::os::ConnectionWriter& connection) const override;
1380 bool read(yarp::os::ConnectionReader& connection) override;
1381
1382 bool write(const yarp::os::idl::WireWriter& writer) const override;
1383 bool read(yarp::os::idl::WireReader& reader) override;
1384
1385 std::string return_helper{};
1386 };
1387
1388 using funcptr_t = std::string (*)();
1390
1393
1394 static constexpr const char* s_tag{"getStatus"};
1395 static constexpr size_t s_tag_len{1};
1396 static constexpr size_t s_cmd_len{1};
1397 static constexpr size_t s_reply_len{1};
1398 static constexpr const char* s_prototype{"std::string yarpdataplayer_console_IDL::getStatus()"};
1399 static constexpr const char* s_help{
1400 "Get the status of playing\n"
1401 "@return the status (playing, paused, stopped)"
1402 };
1403};
1404
1405// resume helper class declaration
1407 public yarp::os::Portable
1408{
1409public:
1411 bool write(yarp::os::ConnectionWriter& connection) const override;
1412 bool read(yarp::os::ConnectionReader& connection) override;
1413
1414 class Command :
1416 {
1417 public:
1418 Command() = default;
1419 ~Command() override = default;
1420
1421 bool write(yarp::os::ConnectionWriter& connection) const override;
1422 bool read(yarp::os::ConnectionReader& connection) override;
1423
1424 bool write(const yarp::os::idl::WireWriter& writer) const override;
1425 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1426 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1427
1428 bool read(yarp::os::idl::WireReader& reader) override;
1429 bool readTag(yarp::os::idl::WireReader& reader);
1430 bool readArgs(yarp::os::idl::WireReader& reader);
1431 };
1432
1433 class Reply :
1435 {
1436 public:
1437 Reply() = default;
1438 ~Reply() override = default;
1439
1440 bool write(yarp::os::ConnectionWriter& connection) const override;
1441 bool read(yarp::os::ConnectionReader& connection) override;
1442
1443 bool write(const yarp::os::idl::WireWriter& writer) const override;
1444 bool read(yarp::os::idl::WireReader& reader) override;
1445
1446 bool return_helper{false};
1447 };
1448
1449 using funcptr_t = bool (*)();
1451
1454
1455 static constexpr const char* s_tag{"resume"};
1456 static constexpr size_t s_tag_len{1};
1457 static constexpr size_t s_cmd_len{1};
1458 static constexpr size_t s_reply_len{1};
1459 static constexpr const char* s_prototype{"bool yarpdataplayer_console_IDL::resume()"};
1460 static constexpr const char* s_help{
1461 "Resume dataset from where it was paused\n"
1462 "@return true/false on success/failure"
1463 };
1464};
1465
1466// quit helper class declaration
1468 public yarp::os::Portable
1469{
1470public:
1472 bool write(yarp::os::ConnectionWriter& connection) const override;
1473 bool read(yarp::os::ConnectionReader& connection) override;
1474
1475 class Command :
1477 {
1478 public:
1479 Command() = default;
1480 ~Command() override = default;
1481
1482 bool write(yarp::os::ConnectionWriter& connection) const override;
1483 bool read(yarp::os::ConnectionReader& connection) override;
1484
1485 bool write(const yarp::os::idl::WireWriter& writer) const override;
1486 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1487 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1488
1489 bool read(yarp::os::idl::WireReader& reader) override;
1490 bool readTag(yarp::os::idl::WireReader& reader);
1491 bool readArgs(yarp::os::idl::WireReader& reader);
1492 };
1493
1494 class Reply :
1496 {
1497 public:
1498 Reply() = default;
1499 ~Reply() override = default;
1500
1501 bool write(yarp::os::ConnectionWriter& connection) const override;
1502 bool read(yarp::os::ConnectionReader& connection) override;
1503
1504 bool write(const yarp::os::idl::WireWriter& writer) const override;
1505 bool read(yarp::os::idl::WireReader& reader) override;
1506
1507 bool return_helper{false};
1508 };
1509
1510 using funcptr_t = bool (*)();
1512
1515
1516 static constexpr const char* s_tag{"quit"};
1517 static constexpr size_t s_tag_len{1};
1518 static constexpr size_t s_cmd_len{1};
1519 static constexpr size_t s_reply_len{1};
1520 static constexpr const char* s_prototype{"bool yarpdataplayer_console_IDL::quit()"};
1521 static constexpr const char* s_help{
1522 "Quit the module.\n"
1523 "@return true/false on success/failure"
1524 };
1525};
1526
1527// step helper class implementation
1529{
1530 return cmd.write(connection);
1531}
1532
1534{
1535 return reply.read(connection);
1536}
1537
1539{
1540 yarp::os::idl::WireWriter writer(connection);
1541 if (!writer.writeListHeader(s_cmd_len)) {
1542 return false;
1543 }
1544 return write(writer);
1545}
1546
1548{
1549 yarp::os::idl::WireReader reader(connection);
1550 if (!reader.readListHeader()) {
1551 reader.fail();
1552 return false;
1553 }
1554 return read(reader);
1555}
1556
1558{
1559 if (!writeTag(writer)) {
1560 return false;
1561 }
1562 if (!writeArgs(writer)) {
1563 return false;
1564 }
1565 return true;
1566}
1567
1569{
1570 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1571 return false;
1572 }
1573 return true;
1574}
1575
1577{
1578 return true;
1579}
1580
1582{
1583 if (!readTag(reader)) {
1584 return false;
1585 }
1586 if (!readArgs(reader)) {
1587 return false;
1588 }
1589 return true;
1590}
1591
1593{
1594 std::string tag = reader.readTag(s_tag_len);
1595 if (reader.isError()) {
1596 return false;
1597 }
1598 if (tag != s_tag) {
1599 reader.fail();
1600 return false;
1601 }
1602 return true;
1603}
1604
1606{
1607 if (!reader.noMore()) {
1608 reader.fail();
1609 return false;
1610 }
1611 return true;
1612}
1613
1615{
1616 yarp::os::idl::WireWriter writer(connection);
1617 return write(writer);
1618}
1619
1621{
1622 yarp::os::idl::WireReader reader(connection);
1623 return read(reader);
1624}
1625
1627{
1628 if (!writer.isNull()) {
1629 if (!writer.writeListHeader(s_reply_len)) {
1630 return false;
1631 }
1632 if (!writer.writeBool(return_helper)) {
1633 return false;
1634 }
1635 }
1636 return true;
1637}
1638
1640{
1641 if (!reader.readListReturn()) {
1642 return false;
1643 }
1644 if (reader.noMore()) {
1645 reader.fail();
1646 return false;
1647 }
1648 if (!reader.readBool(return_helper)) {
1649 reader.fail();
1650 return false;
1651 }
1652 return true;
1653}
1654
1659
1660// setFrame helper class implementation
1665
1667{
1668 return cmd.write(connection);
1669}
1670
1672{
1673 return reply.read(connection);
1674}
1675
1677 frameNum{frameNum}
1678{
1679}
1680
1682{
1683 yarp::os::idl::WireWriter writer(connection);
1684 if (!writer.writeListHeader(s_cmd_len)) {
1685 return false;
1686 }
1687 return write(writer);
1688}
1689
1691{
1692 yarp::os::idl::WireReader reader(connection);
1693 if (!reader.readListHeader()) {
1694 reader.fail();
1695 return false;
1696 }
1697 return read(reader);
1698}
1699
1701{
1702 if (!writeTag(writer)) {
1703 return false;
1704 }
1705 if (!writeArgs(writer)) {
1706 return false;
1707 }
1708 return true;
1709}
1710
1712{
1713 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1714 return false;
1715 }
1716 return true;
1717}
1718
1720{
1721 if (!writer.writeI32(frameNum)) {
1722 return false;
1723 }
1724 return true;
1725}
1726
1728{
1729 if (!readTag(reader)) {
1730 return false;
1731 }
1732 if (!readArgs(reader)) {
1733 return false;
1734 }
1735 return true;
1736}
1737
1739{
1740 std::string tag = reader.readTag(s_tag_len);
1741 if (reader.isError()) {
1742 return false;
1743 }
1744 if (tag != s_tag) {
1745 reader.fail();
1746 return false;
1747 }
1748 return true;
1749}
1750
1752{
1753 if (reader.noMore()) {
1754 reader.fail();
1755 return false;
1756 }
1757 if (!reader.readI32(frameNum)) {
1758 reader.fail();
1759 return false;
1760 }
1761 if (!reader.noMore()) {
1762 reader.fail();
1763 return false;
1764 }
1765 return true;
1766}
1767
1769{
1770 yarp::os::idl::WireWriter writer(connection);
1771 return write(writer);
1772}
1773
1775{
1776 yarp::os::idl::WireReader reader(connection);
1777 return read(reader);
1778}
1779
1781{
1782 if (!writer.isNull()) {
1783 if (!writer.writeListHeader(s_reply_len)) {
1784 return false;
1785 }
1786 if (!writer.writeBool(return_helper)) {
1787 return false;
1788 }
1789 }
1790 return true;
1791}
1792
1794{
1795 if (!reader.readListReturn()) {
1796 return false;
1797 }
1798 if (reader.noMore()) {
1799 reader.fail();
1800 return false;
1801 }
1802 if (!reader.readBool(return_helper)) {
1803 reader.fail();
1804 return false;
1805 }
1806 return true;
1807}
1808
1813
1814// getFrame helper class implementation
1819
1821{
1822 return cmd.write(connection);
1823}
1824
1826{
1827 return reply.read(connection);
1828}
1829
1831 name{name}
1832{
1833}
1834
1836{
1837 yarp::os::idl::WireWriter writer(connection);
1838 if (!writer.writeListHeader(s_cmd_len)) {
1839 return false;
1840 }
1841 return write(writer);
1842}
1843
1845{
1846 yarp::os::idl::WireReader reader(connection);
1847 if (!reader.readListHeader()) {
1848 reader.fail();
1849 return false;
1850 }
1851 return read(reader);
1852}
1853
1855{
1856 if (!writeTag(writer)) {
1857 return false;
1858 }
1859 if (!writeArgs(writer)) {
1860 return false;
1861 }
1862 return true;
1863}
1864
1866{
1867 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1868 return false;
1869 }
1870 return true;
1871}
1872
1874{
1875 if (!writer.writeString(name)) {
1876 return false;
1877 }
1878 return true;
1879}
1880
1882{
1883 if (!readTag(reader)) {
1884 return false;
1885 }
1886 if (!readArgs(reader)) {
1887 return false;
1888 }
1889 return true;
1890}
1891
1893{
1894 std::string tag = reader.readTag(s_tag_len);
1895 if (reader.isError()) {
1896 return false;
1897 }
1898 if (tag != s_tag) {
1899 reader.fail();
1900 return false;
1901 }
1902 return true;
1903}
1904
1906{
1907 if (reader.noMore()) {
1908 reader.fail();
1909 return false;
1910 }
1911 if (!reader.readString(name)) {
1912 reader.fail();
1913 return false;
1914 }
1915 if (!reader.noMore()) {
1916 reader.fail();
1917 return false;
1918 }
1919 return true;
1920}
1921
1923{
1924 yarp::os::idl::WireWriter writer(connection);
1925 return write(writer);
1926}
1927
1929{
1930 yarp::os::idl::WireReader reader(connection);
1931 return read(reader);
1932}
1933
1935{
1936 if (!writer.isNull()) {
1937 if (!writer.writeListHeader(s_reply_len)) {
1938 return false;
1939 }
1940 if (!writer.writeI32(return_helper)) {
1941 return false;
1942 }
1943 }
1944 return true;
1945}
1946
1948{
1949 if (!reader.readListReturn()) {
1950 return false;
1951 }
1952 if (reader.noMore()) {
1953 reader.fail();
1954 return false;
1955 }
1956 if (!reader.readI32(return_helper)) {
1957 reader.fail();
1958 return false;
1959 }
1960 return true;
1961}
1962
1967
1968// load helper class implementation
1973
1975{
1976 return cmd.write(connection);
1977}
1978
1980{
1981 return reply.read(connection);
1982}
1983
1985 path{path}
1986{
1987}
1988
1990{
1991 yarp::os::idl::WireWriter writer(connection);
1992 if (!writer.writeListHeader(s_cmd_len)) {
1993 return false;
1994 }
1995 return write(writer);
1996}
1997
1999{
2000 yarp::os::idl::WireReader reader(connection);
2001 if (!reader.readListHeader()) {
2002 reader.fail();
2003 return false;
2004 }
2005 return read(reader);
2006}
2007
2009{
2010 if (!writeTag(writer)) {
2011 return false;
2012 }
2013 if (!writeArgs(writer)) {
2014 return false;
2015 }
2016 return true;
2017}
2018
2020{
2021 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2022 return false;
2023 }
2024 return true;
2025}
2026
2028{
2029 if (!writer.writeString(path)) {
2030 return false;
2031 }
2032 return true;
2033}
2034
2036{
2037 if (!readTag(reader)) {
2038 return false;
2039 }
2040 if (!readArgs(reader)) {
2041 return false;
2042 }
2043 return true;
2044}
2045
2047{
2048 std::string tag = reader.readTag(s_tag_len);
2049 if (reader.isError()) {
2050 return false;
2051 }
2052 if (tag != s_tag) {
2053 reader.fail();
2054 return false;
2055 }
2056 return true;
2057}
2058
2060{
2061 if (reader.noMore()) {
2062 reader.fail();
2063 return false;
2064 }
2065 if (!reader.readString(path)) {
2066 reader.fail();
2067 return false;
2068 }
2069 if (!reader.noMore()) {
2070 reader.fail();
2071 return false;
2072 }
2073 return true;
2074}
2075
2077{
2078 yarp::os::idl::WireWriter writer(connection);
2079 return write(writer);
2080}
2081
2083{
2084 yarp::os::idl::WireReader reader(connection);
2085 return read(reader);
2086}
2087
2089{
2090 if (!writer.isNull()) {
2091 if (!writer.writeListHeader(s_reply_len)) {
2092 return false;
2093 }
2094 if (!writer.writeBool(return_helper)) {
2095 return false;
2096 }
2097 }
2098 return true;
2099}
2100
2102{
2103 if (!reader.readListReturn()) {
2104 return false;
2105 }
2106 if (reader.noMore()) {
2107 reader.fail();
2108 return false;
2109 }
2110 if (!reader.readBool(return_helper)) {
2111 reader.fail();
2112 return false;
2113 }
2114 return true;
2115}
2116
2121
2122// play helper class implementation
2124{
2125 return cmd.write(connection);
2126}
2127
2129{
2130 return reply.read(connection);
2131}
2132
2134{
2135 yarp::os::idl::WireWriter writer(connection);
2136 if (!writer.writeListHeader(s_cmd_len)) {
2137 return false;
2138 }
2139 return write(writer);
2140}
2141
2143{
2144 yarp::os::idl::WireReader reader(connection);
2145 if (!reader.readListHeader()) {
2146 reader.fail();
2147 return false;
2148 }
2149 return read(reader);
2150}
2151
2153{
2154 if (!writeTag(writer)) {
2155 return false;
2156 }
2157 if (!writeArgs(writer)) {
2158 return false;
2159 }
2160 return true;
2161}
2162
2164{
2165 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2166 return false;
2167 }
2168 return true;
2169}
2170
2172{
2173 return true;
2174}
2175
2177{
2178 if (!readTag(reader)) {
2179 return false;
2180 }
2181 if (!readArgs(reader)) {
2182 return false;
2183 }
2184 return true;
2185}
2186
2188{
2189 std::string tag = reader.readTag(s_tag_len);
2190 if (reader.isError()) {
2191 return false;
2192 }
2193 if (tag != s_tag) {
2194 reader.fail();
2195 return false;
2196 }
2197 return true;
2198}
2199
2201{
2202 if (!reader.noMore()) {
2203 reader.fail();
2204 return false;
2205 }
2206 return true;
2207}
2208
2210{
2211 yarp::os::idl::WireWriter writer(connection);
2212 return write(writer);
2213}
2214
2216{
2217 yarp::os::idl::WireReader reader(connection);
2218 return read(reader);
2219}
2220
2222{
2223 if (!writer.isNull()) {
2224 if (!writer.writeListHeader(s_reply_len)) {
2225 return false;
2226 }
2227 if (!writer.writeBool(return_helper)) {
2228 return false;
2229 }
2230 }
2231 return true;
2232}
2233
2235{
2236 if (!reader.readListReturn()) {
2237 return false;
2238 }
2239 if (reader.noMore()) {
2240 reader.fail();
2241 return false;
2242 }
2243 if (!reader.readBool(return_helper)) {
2244 reader.fail();
2245 return false;
2246 }
2247 return true;
2248}
2249
2254
2255// pause helper class implementation
2257{
2258 return cmd.write(connection);
2259}
2260
2262{
2263 return reply.read(connection);
2264}
2265
2267{
2268 yarp::os::idl::WireWriter writer(connection);
2269 if (!writer.writeListHeader(s_cmd_len)) {
2270 return false;
2271 }
2272 return write(writer);
2273}
2274
2276{
2277 yarp::os::idl::WireReader reader(connection);
2278 if (!reader.readListHeader()) {
2279 reader.fail();
2280 return false;
2281 }
2282 return read(reader);
2283}
2284
2286{
2287 if (!writeTag(writer)) {
2288 return false;
2289 }
2290 if (!writeArgs(writer)) {
2291 return false;
2292 }
2293 return true;
2294}
2295
2297{
2298 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2299 return false;
2300 }
2301 return true;
2302}
2303
2305{
2306 return true;
2307}
2308
2310{
2311 if (!readTag(reader)) {
2312 return false;
2313 }
2314 if (!readArgs(reader)) {
2315 return false;
2316 }
2317 return true;
2318}
2319
2321{
2322 std::string tag = reader.readTag(s_tag_len);
2323 if (reader.isError()) {
2324 return false;
2325 }
2326 if (tag != s_tag) {
2327 reader.fail();
2328 return false;
2329 }
2330 return true;
2331}
2332
2334{
2335 if (!reader.noMore()) {
2336 reader.fail();
2337 return false;
2338 }
2339 return true;
2340}
2341
2343{
2344 yarp::os::idl::WireWriter writer(connection);
2345 return write(writer);
2346}
2347
2349{
2350 yarp::os::idl::WireReader reader(connection);
2351 return read(reader);
2352}
2353
2355{
2356 if (!writer.isNull()) {
2357 if (!writer.writeListHeader(s_reply_len)) {
2358 return false;
2359 }
2360 if (!writer.writeBool(return_helper)) {
2361 return false;
2362 }
2363 }
2364 return true;
2365}
2366
2368{
2369 if (!reader.readListReturn()) {
2370 return false;
2371 }
2372 if (reader.noMore()) {
2373 reader.fail();
2374 return false;
2375 }
2376 if (!reader.readBool(return_helper)) {
2377 reader.fail();
2378 return false;
2379 }
2380 return true;
2381}
2382
2387
2388// stop helper class implementation
2390{
2391 return cmd.write(connection);
2392}
2393
2395{
2396 return reply.read(connection);
2397}
2398
2400{
2401 yarp::os::idl::WireWriter writer(connection);
2402 if (!writer.writeListHeader(s_cmd_len)) {
2403 return false;
2404 }
2405 return write(writer);
2406}
2407
2409{
2410 yarp::os::idl::WireReader reader(connection);
2411 if (!reader.readListHeader()) {
2412 reader.fail();
2413 return false;
2414 }
2415 return read(reader);
2416}
2417
2419{
2420 if (!writeTag(writer)) {
2421 return false;
2422 }
2423 if (!writeArgs(writer)) {
2424 return false;
2425 }
2426 return true;
2427}
2428
2430{
2431 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2432 return false;
2433 }
2434 return true;
2435}
2436
2438{
2439 return true;
2440}
2441
2443{
2444 if (!readTag(reader)) {
2445 return false;
2446 }
2447 if (!readArgs(reader)) {
2448 return false;
2449 }
2450 return true;
2451}
2452
2454{
2455 std::string tag = reader.readTag(s_tag_len);
2456 if (reader.isError()) {
2457 return false;
2458 }
2459 if (tag != s_tag) {
2460 reader.fail();
2461 return false;
2462 }
2463 return true;
2464}
2465
2467{
2468 if (!reader.noMore()) {
2469 reader.fail();
2470 return false;
2471 }
2472 return true;
2473}
2474
2476{
2477 yarp::os::idl::WireWriter writer(connection);
2478 return write(writer);
2479}
2480
2482{
2483 yarp::os::idl::WireReader reader(connection);
2484 return read(reader);
2485}
2486
2488{
2489 if (!writer.isNull()) {
2490 if (!writer.writeListHeader(s_reply_len)) {
2491 return false;
2492 }
2493 if (!writer.writeBool(return_helper)) {
2494 return false;
2495 }
2496 }
2497 return true;
2498}
2499
2501{
2502 if (!reader.readListReturn()) {
2503 return false;
2504 }
2505 if (reader.noMore()) {
2506 reader.fail();
2507 return false;
2508 }
2509 if (!reader.readBool(return_helper)) {
2510 reader.fail();
2511 return false;
2512 }
2513 return true;
2514}
2515
2520
2521// enable helper class implementation
2526
2528{
2529 return cmd.write(connection);
2530}
2531
2533{
2534 return reply.read(connection);
2535}
2536
2538 part{part}
2539{
2540}
2541
2543{
2544 yarp::os::idl::WireWriter writer(connection);
2545 if (!writer.writeListHeader(s_cmd_len)) {
2546 return false;
2547 }
2548 return write(writer);
2549}
2550
2552{
2553 yarp::os::idl::WireReader reader(connection);
2554 if (!reader.readListHeader()) {
2555 reader.fail();
2556 return false;
2557 }
2558 return read(reader);
2559}
2560
2562{
2563 if (!writeTag(writer)) {
2564 return false;
2565 }
2566 if (!writeArgs(writer)) {
2567 return false;
2568 }
2569 return true;
2570}
2571
2573{
2574 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2575 return false;
2576 }
2577 return true;
2578}
2579
2581{
2582 if (!writer.writeString(part)) {
2583 return false;
2584 }
2585 return true;
2586}
2587
2589{
2590 if (!readTag(reader)) {
2591 return false;
2592 }
2593 if (!readArgs(reader)) {
2594 return false;
2595 }
2596 return true;
2597}
2598
2600{
2601 std::string tag = reader.readTag(s_tag_len);
2602 if (reader.isError()) {
2603 return false;
2604 }
2605 if (tag != s_tag) {
2606 reader.fail();
2607 return false;
2608 }
2609 return true;
2610}
2611
2613{
2614 if (reader.noMore()) {
2615 reader.fail();
2616 return false;
2617 }
2618 if (!reader.readString(part)) {
2619 reader.fail();
2620 return false;
2621 }
2622 if (!reader.noMore()) {
2623 reader.fail();
2624 return false;
2625 }
2626 return true;
2627}
2628
2630{
2631 yarp::os::idl::WireWriter writer(connection);
2632 return write(writer);
2633}
2634
2636{
2637 yarp::os::idl::WireReader reader(connection);
2638 return read(reader);
2639}
2640
2642{
2643 if (!writer.isNull()) {
2644 if (!writer.writeListHeader(s_reply_len)) {
2645 return false;
2646 }
2647 if (!writer.writeBool(return_helper)) {
2648 return false;
2649 }
2650 }
2651 return true;
2652}
2653
2655{
2656 if (!reader.readListReturn()) {
2657 return false;
2658 }
2659 if (reader.noMore()) {
2660 reader.fail();
2661 return false;
2662 }
2663 if (!reader.readBool(return_helper)) {
2664 reader.fail();
2665 return false;
2666 }
2667 return true;
2668}
2669
2674
2675// disable helper class implementation
2680
2682{
2683 return cmd.write(connection);
2684}
2685
2687{
2688 return reply.read(connection);
2689}
2690
2692 part{part}
2693{
2694}
2695
2697{
2698 yarp::os::idl::WireWriter writer(connection);
2699 if (!writer.writeListHeader(s_cmd_len)) {
2700 return false;
2701 }
2702 return write(writer);
2703}
2704
2706{
2707 yarp::os::idl::WireReader reader(connection);
2708 if (!reader.readListHeader()) {
2709 reader.fail();
2710 return false;
2711 }
2712 return read(reader);
2713}
2714
2716{
2717 if (!writeTag(writer)) {
2718 return false;
2719 }
2720 if (!writeArgs(writer)) {
2721 return false;
2722 }
2723 return true;
2724}
2725
2727{
2728 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2729 return false;
2730 }
2731 return true;
2732}
2733
2735{
2736 if (!writer.writeString(part)) {
2737 return false;
2738 }
2739 return true;
2740}
2741
2743{
2744 if (!readTag(reader)) {
2745 return false;
2746 }
2747 if (!readArgs(reader)) {
2748 return false;
2749 }
2750 return true;
2751}
2752
2754{
2755 std::string tag = reader.readTag(s_tag_len);
2756 if (reader.isError()) {
2757 return false;
2758 }
2759 if (tag != s_tag) {
2760 reader.fail();
2761 return false;
2762 }
2763 return true;
2764}
2765
2767{
2768 if (reader.noMore()) {
2769 reader.fail();
2770 return false;
2771 }
2772 if (!reader.readString(part)) {
2773 reader.fail();
2774 return false;
2775 }
2776 if (!reader.noMore()) {
2777 reader.fail();
2778 return false;
2779 }
2780 return true;
2781}
2782
2784{
2785 yarp::os::idl::WireWriter writer(connection);
2786 return write(writer);
2787}
2788
2790{
2791 yarp::os::idl::WireReader reader(connection);
2792 return read(reader);
2793}
2794
2796{
2797 if (!writer.isNull()) {
2798 if (!writer.writeListHeader(s_reply_len)) {
2799 return false;
2800 }
2801 if (!writer.writeBool(return_helper)) {
2802 return false;
2803 }
2804 }
2805 return true;
2806}
2807
2809{
2810 if (!reader.readListReturn()) {
2811 return false;
2812 }
2813 if (reader.noMore()) {
2814 reader.fail();
2815 return false;
2816 }
2817 if (!reader.readBool(return_helper)) {
2818 reader.fail();
2819 return false;
2820 }
2821 return true;
2822}
2823
2828
2829// getAllParts helper class implementation
2831{
2832 return cmd.write(connection);
2833}
2834
2839
2841{
2842 yarp::os::idl::WireWriter writer(connection);
2843 if (!writer.writeListHeader(s_cmd_len)) {
2844 return false;
2845 }
2846 return write(writer);
2847}
2848
2850{
2851 yarp::os::idl::WireReader reader(connection);
2852 if (!reader.readListHeader()) {
2853 reader.fail();
2854 return false;
2855 }
2856 return read(reader);
2857}
2858
2860{
2861 if (!writeTag(writer)) {
2862 return false;
2863 }
2864 if (!writeArgs(writer)) {
2865 return false;
2866 }
2867 return true;
2868}
2869
2871{
2872 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2873 return false;
2874 }
2875 return true;
2876}
2877
2879{
2880 return true;
2881}
2882
2884{
2885 if (!readTag(reader)) {
2886 return false;
2887 }
2888 if (!readArgs(reader)) {
2889 return false;
2890 }
2891 return true;
2892}
2893
2895{
2896 std::string tag = reader.readTag(s_tag_len);
2897 if (reader.isError()) {
2898 return false;
2899 }
2900 if (tag != s_tag) {
2901 reader.fail();
2902 return false;
2903 }
2904 return true;
2905}
2906
2908{
2909 if (!reader.noMore()) {
2910 reader.fail();
2911 return false;
2912 }
2913 return true;
2914}
2915
2917{
2918 yarp::os::idl::WireWriter writer(connection);
2919 return write(writer);
2920}
2921
2923{
2924 yarp::os::idl::WireReader reader(connection);
2925 return read(reader);
2926}
2927
2929{
2930 if (!writer.isNull()) {
2931 if (!writer.writeListHeader(s_reply_len)) {
2932 return false;
2933 }
2934 if (!writer.writeListBegin(BOTTLE_TAG_STRING, return_helper.size())) {
2935 return false;
2936 }
2937 for (const auto& _item : return_helper) {
2938 if (!writer.writeString(_item, true)) {
2939 return false;
2940 }
2941 }
2942 if (!writer.writeListEnd()) {
2943 return false;
2944 }
2945 }
2946 return true;
2947}
2948
2950{
2951 if (!reader.readListReturn()) {
2952 return false;
2953 }
2954 if (reader.noMore()) {
2955 reader.fail();
2956 return false;
2957 }
2958 {
2959 size_t _csize;
2961 reader.readListBegin(_etype, _csize);
2962 // WireReader removes BOTTLE_TAG_LIST from the tag
2963 constexpr int expected_tag = ((BOTTLE_TAG_STRING) & (~BOTTLE_TAG_LIST));
2964 if constexpr (expected_tag != 0) {
2965 if (_csize != 0 && _etype.code != expected_tag) {
2966 return false;
2967 }
2968 }
2969 return_helper.resize(_csize);
2970 for (size_t _i0 = 0; _i0 < _csize; ++_i0) {
2971 if (reader.noMore()) {
2972 reader.fail();
2973 return false;
2974 }
2975 if (!reader.readString(return_helper[_i0])) {
2976 reader.fail();
2977 return false;
2978 }
2979 }
2980 reader.readListEnd();
2981 }
2982 return true;
2983}
2984
2989
2990// getPortName helper class implementation
2995
2997{
2998 return cmd.write(connection);
2999}
3000
3005
3007 part{part}
3008{
3009}
3010
3012{
3013 yarp::os::idl::WireWriter writer(connection);
3014 if (!writer.writeListHeader(s_cmd_len)) {
3015 return false;
3016 }
3017 return write(writer);
3018}
3019
3021{
3022 yarp::os::idl::WireReader reader(connection);
3023 if (!reader.readListHeader()) {
3024 reader.fail();
3025 return false;
3026 }
3027 return read(reader);
3028}
3029
3031{
3032 if (!writeTag(writer)) {
3033 return false;
3034 }
3035 if (!writeArgs(writer)) {
3036 return false;
3037 }
3038 return true;
3039}
3040
3042{
3043 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3044 return false;
3045 }
3046 return true;
3047}
3048
3050{
3051 if (!writer.writeString(part)) {
3052 return false;
3053 }
3054 return true;
3055}
3056
3058{
3059 if (!readTag(reader)) {
3060 return false;
3061 }
3062 if (!readArgs(reader)) {
3063 return false;
3064 }
3065 return true;
3066}
3067
3069{
3070 std::string tag = reader.readTag(s_tag_len);
3071 if (reader.isError()) {
3072 return false;
3073 }
3074 if (tag != s_tag) {
3075 reader.fail();
3076 return false;
3077 }
3078 return true;
3079}
3080
3082{
3083 if (reader.noMore()) {
3084 reader.fail();
3085 return false;
3086 }
3087 if (!reader.readString(part)) {
3088 reader.fail();
3089 return false;
3090 }
3091 if (!reader.noMore()) {
3092 reader.fail();
3093 return false;
3094 }
3095 return true;
3096}
3097
3099{
3100 yarp::os::idl::WireWriter writer(connection);
3101 return write(writer);
3102}
3103
3105{
3106 yarp::os::idl::WireReader reader(connection);
3107 return read(reader);
3108}
3109
3111{
3112 if (!writer.isNull()) {
3113 if (!writer.writeListHeader(s_reply_len)) {
3114 return false;
3115 }
3116 if (!writer.writeString(return_helper)) {
3117 return false;
3118 }
3119 }
3120 return true;
3121}
3122
3124{
3125 if (!reader.readListReturn()) {
3126 return false;
3127 }
3128 if (reader.noMore()) {
3129 reader.fail();
3130 return false;
3131 }
3132 if (!reader.readString(return_helper)) {
3133 reader.fail();
3134 return false;
3135 }
3136 return true;
3137}
3138
3143
3144// setPortName helper class implementation
3146 cmd{part, new_name}
3147{
3148}
3149
3151{
3152 return cmd.write(connection);
3153}
3154
3159
3160yarpdataplayer_console_IDL_setPortName_helper::Command::Command(const std::string& part, const std::string& new_name) :
3161 part{part},
3162 new_name{new_name}
3163{
3164}
3165
3167{
3168 yarp::os::idl::WireWriter writer(connection);
3169 if (!writer.writeListHeader(s_cmd_len)) {
3170 return false;
3171 }
3172 return write(writer);
3173}
3174
3176{
3177 yarp::os::idl::WireReader reader(connection);
3178 if (!reader.readListHeader()) {
3179 reader.fail();
3180 return false;
3181 }
3182 return read(reader);
3183}
3184
3186{
3187 if (!writeTag(writer)) {
3188 return false;
3189 }
3190 if (!writeArgs(writer)) {
3191 return false;
3192 }
3193 return true;
3194}
3195
3197{
3198 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3199 return false;
3200 }
3201 return true;
3202}
3203
3205{
3206 if (!writer.writeString(part)) {
3207 return false;
3208 }
3209 if (!writer.writeString(new_name)) {
3210 return false;
3211 }
3212 return true;
3213}
3214
3216{
3217 if (!readTag(reader)) {
3218 return false;
3219 }
3220 if (!readArgs(reader)) {
3221 return false;
3222 }
3223 return true;
3224}
3225
3227{
3228 std::string tag = reader.readTag(s_tag_len);
3229 if (reader.isError()) {
3230 return false;
3231 }
3232 if (tag != s_tag) {
3233 reader.fail();
3234 return false;
3235 }
3236 return true;
3237}
3238
3240{
3241 if (reader.noMore()) {
3242 reader.fail();
3243 return false;
3244 }
3245 if (!reader.readString(part)) {
3246 reader.fail();
3247 return false;
3248 }
3249 if (reader.noMore()) {
3250 reader.fail();
3251 return false;
3252 }
3253 if (!reader.readString(new_name)) {
3254 reader.fail();
3255 return false;
3256 }
3257 if (!reader.noMore()) {
3258 reader.fail();
3259 return false;
3260 }
3261 return true;
3262}
3263
3265{
3266 yarp::os::idl::WireWriter writer(connection);
3267 return write(writer);
3268}
3269
3271{
3272 yarp::os::idl::WireReader reader(connection);
3273 return read(reader);
3274}
3275
3277{
3278 if (!writer.isNull()) {
3279 if (!writer.writeListHeader(s_reply_len)) {
3280 return false;
3281 }
3282 if (!writer.writeBool(return_helper)) {
3283 return false;
3284 }
3285 }
3286 return true;
3287}
3288
3290{
3291 if (!reader.readListReturn()) {
3292 return false;
3293 }
3294 if (reader.noMore()) {
3295 reader.fail();
3296 return false;
3297 }
3298 if (!reader.readBool(return_helper)) {
3299 reader.fail();
3300 return false;
3301 }
3302 return true;
3303}
3304
3309
3310// setSpeed helper class implementation
3315
3317{
3318 return cmd.write(connection);
3319}
3320
3322{
3323 return reply.read(connection);
3324}
3325
3327 speed{speed}
3328{
3329}
3330
3332{
3333 yarp::os::idl::WireWriter writer(connection);
3334 if (!writer.writeListHeader(s_cmd_len)) {
3335 return false;
3336 }
3337 return write(writer);
3338}
3339
3341{
3342 yarp::os::idl::WireReader reader(connection);
3343 if (!reader.readListHeader()) {
3344 reader.fail();
3345 return false;
3346 }
3347 return read(reader);
3348}
3349
3351{
3352 if (!writeTag(writer)) {
3353 return false;
3354 }
3355 if (!writeArgs(writer)) {
3356 return false;
3357 }
3358 return true;
3359}
3360
3362{
3363 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3364 return false;
3365 }
3366 return true;
3367}
3368
3370{
3371 if (!writer.writeFloat64(speed)) {
3372 return false;
3373 }
3374 return true;
3375}
3376
3378{
3379 if (!readTag(reader)) {
3380 return false;
3381 }
3382 if (!readArgs(reader)) {
3383 return false;
3384 }
3385 return true;
3386}
3387
3389{
3390 std::string tag = reader.readTag(s_tag_len);
3391 if (reader.isError()) {
3392 return false;
3393 }
3394 if (tag != s_tag) {
3395 reader.fail();
3396 return false;
3397 }
3398 return true;
3399}
3400
3402{
3403 if (reader.noMore()) {
3404 reader.fail();
3405 return false;
3406 }
3407 if (!reader.readFloat64(speed)) {
3408 reader.fail();
3409 return false;
3410 }
3411 if (!reader.noMore()) {
3412 reader.fail();
3413 return false;
3414 }
3415 return true;
3416}
3417
3419{
3420 yarp::os::idl::WireWriter writer(connection);
3421 return write(writer);
3422}
3423
3425{
3426 yarp::os::idl::WireReader reader(connection);
3427 return read(reader);
3428}
3429
3431{
3432 if (!writer.isNull()) {
3433 if (!writer.writeListHeader(s_reply_len)) {
3434 return false;
3435 }
3436 if (!writer.writeBool(return_helper)) {
3437 return false;
3438 }
3439 }
3440 return true;
3441}
3442
3444{
3445 if (!reader.readListReturn()) {
3446 return false;
3447 }
3448 if (reader.noMore()) {
3449 reader.fail();
3450 return false;
3451 }
3452 if (!reader.readBool(return_helper)) {
3453 reader.fail();
3454 return false;
3455 }
3456 return true;
3457}
3458
3463
3464// getSpeed helper class implementation
3466{
3467 return cmd.write(connection);
3468}
3469
3471{
3472 return reply.read(connection);
3473}
3474
3476{
3477 yarp::os::idl::WireWriter writer(connection);
3478 if (!writer.writeListHeader(s_cmd_len)) {
3479 return false;
3480 }
3481 return write(writer);
3482}
3483
3485{
3486 yarp::os::idl::WireReader reader(connection);
3487 if (!reader.readListHeader()) {
3488 reader.fail();
3489 return false;
3490 }
3491 return read(reader);
3492}
3493
3495{
3496 if (!writeTag(writer)) {
3497 return false;
3498 }
3499 if (!writeArgs(writer)) {
3500 return false;
3501 }
3502 return true;
3503}
3504
3506{
3507 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3508 return false;
3509 }
3510 return true;
3511}
3512
3514{
3515 return true;
3516}
3517
3519{
3520 if (!readTag(reader)) {
3521 return false;
3522 }
3523 if (!readArgs(reader)) {
3524 return false;
3525 }
3526 return true;
3527}
3528
3530{
3531 std::string tag = reader.readTag(s_tag_len);
3532 if (reader.isError()) {
3533 return false;
3534 }
3535 if (tag != s_tag) {
3536 reader.fail();
3537 return false;
3538 }
3539 return true;
3540}
3541
3543{
3544 if (!reader.noMore()) {
3545 reader.fail();
3546 return false;
3547 }
3548 return true;
3549}
3550
3552{
3553 yarp::os::idl::WireWriter writer(connection);
3554 return write(writer);
3555}
3556
3558{
3559 yarp::os::idl::WireReader reader(connection);
3560 return read(reader);
3561}
3562
3564{
3565 if (!writer.isNull()) {
3566 if (!writer.writeListHeader(s_reply_len)) {
3567 return false;
3568 }
3569 if (!writer.writeFloat64(return_helper)) {
3570 return false;
3571 }
3572 }
3573 return true;
3574}
3575
3577{
3578 if (!reader.readListReturn()) {
3579 return false;
3580 }
3581 if (reader.noMore()) {
3582 reader.fail();
3583 return false;
3584 }
3585 if (!reader.readFloat64(return_helper)) {
3586 reader.fail();
3587 return false;
3588 }
3589 return true;
3590}
3591
3596
3597// repeat helper class implementation
3602
3604{
3605 return cmd.write(connection);
3606}
3607
3609{
3610 return reply.read(connection);
3611}
3612
3614 val{val}
3615{
3616}
3617
3619{
3620 yarp::os::idl::WireWriter writer(connection);
3621 if (!writer.writeListHeader(s_cmd_len)) {
3622 return false;
3623 }
3624 return write(writer);
3625}
3626
3628{
3629 yarp::os::idl::WireReader reader(connection);
3630 if (!reader.readListHeader()) {
3631 reader.fail();
3632 return false;
3633 }
3634 return read(reader);
3635}
3636
3638{
3639 if (!writeTag(writer)) {
3640 return false;
3641 }
3642 if (!writeArgs(writer)) {
3643 return false;
3644 }
3645 return true;
3646}
3647
3649{
3650 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3651 return false;
3652 }
3653 return true;
3654}
3655
3657{
3658 if (!writer.writeBool(val)) {
3659 return false;
3660 }
3661 return true;
3662}
3663
3665{
3666 if (!readTag(reader)) {
3667 return false;
3668 }
3669 if (!readArgs(reader)) {
3670 return false;
3671 }
3672 return true;
3673}
3674
3676{
3677 std::string tag = reader.readTag(s_tag_len);
3678 if (reader.isError()) {
3679 return false;
3680 }
3681 if (tag != s_tag) {
3682 reader.fail();
3683 return false;
3684 }
3685 return true;
3686}
3687
3689{
3690 if (!reader.readBool(val)) {
3691 val = false;
3692 }
3693 if (!reader.noMore()) {
3694 reader.fail();
3695 return false;
3696 }
3697 return true;
3698}
3699
3701{
3702 yarp::os::idl::WireWriter writer(connection);
3703 return write(writer);
3704}
3705
3707{
3708 yarp::os::idl::WireReader reader(connection);
3709 return read(reader);
3710}
3711
3713{
3714 if (!writer.isNull()) {
3715 if (!writer.writeListHeader(s_reply_len)) {
3716 return false;
3717 }
3718 if (!writer.writeBool(return_helper)) {
3719 return false;
3720 }
3721 }
3722 return true;
3723}
3724
3726{
3727 if (!reader.readListReturn()) {
3728 return false;
3729 }
3730 if (reader.noMore()) {
3731 reader.fail();
3732 return false;
3733 }
3734 if (!reader.readBool(return_helper)) {
3735 reader.fail();
3736 return false;
3737 }
3738 return true;
3739}
3740
3745
3746// setStrict helper class implementation
3751
3753{
3754 return cmd.write(connection);
3755}
3756
3761
3763 val{val}
3764{
3765}
3766
3768{
3769 yarp::os::idl::WireWriter writer(connection);
3770 if (!writer.writeListHeader(s_cmd_len)) {
3771 return false;
3772 }
3773 return write(writer);
3774}
3775
3777{
3778 yarp::os::idl::WireReader reader(connection);
3779 if (!reader.readListHeader()) {
3780 reader.fail();
3781 return false;
3782 }
3783 return read(reader);
3784}
3785
3787{
3788 if (!writeTag(writer)) {
3789 return false;
3790 }
3791 if (!writeArgs(writer)) {
3792 return false;
3793 }
3794 return true;
3795}
3796
3798{
3799 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3800 return false;
3801 }
3802 return true;
3803}
3804
3806{
3807 if (!writer.writeBool(val)) {
3808 return false;
3809 }
3810 return true;
3811}
3812
3814{
3815 if (!readTag(reader)) {
3816 return false;
3817 }
3818 if (!readArgs(reader)) {
3819 return false;
3820 }
3821 return true;
3822}
3823
3825{
3826 std::string tag = reader.readTag(s_tag_len);
3827 if (reader.isError()) {
3828 return false;
3829 }
3830 if (tag != s_tag) {
3831 reader.fail();
3832 return false;
3833 }
3834 return true;
3835}
3836
3838{
3839 if (!reader.readBool(val)) {
3840 val = false;
3841 }
3842 if (!reader.noMore()) {
3843 reader.fail();
3844 return false;
3845 }
3846 return true;
3847}
3848
3850{
3851 yarp::os::idl::WireWriter writer(connection);
3852 return write(writer);
3853}
3854
3856{
3857 yarp::os::idl::WireReader reader(connection);
3858 return read(reader);
3859}
3860
3862{
3863 if (!writer.isNull()) {
3864 if (!writer.writeListHeader(s_reply_len)) {
3865 return false;
3866 }
3867 if (!writer.writeBool(return_helper)) {
3868 return false;
3869 }
3870 }
3871 return true;
3872}
3873
3875{
3876 if (!reader.readListReturn()) {
3877 return false;
3878 }
3879 if (reader.noMore()) {
3880 reader.fail();
3881 return false;
3882 }
3883 if (!reader.readBool(return_helper)) {
3884 reader.fail();
3885 return false;
3886 }
3887 return true;
3888}
3889
3894
3895// forward helper class implementation
3900
3902{
3903 return cmd.write(connection);
3904}
3905
3907{
3908 return reply.read(connection);
3909}
3910
3912 steps{steps}
3913{
3914}
3915
3917{
3918 yarp::os::idl::WireWriter writer(connection);
3919 if (!writer.writeListHeader(s_cmd_len)) {
3920 return false;
3921 }
3922 return write(writer);
3923}
3924
3926{
3927 yarp::os::idl::WireReader reader(connection);
3928 if (!reader.readListHeader()) {
3929 reader.fail();
3930 return false;
3931 }
3932 return read(reader);
3933}
3934
3936{
3937 if (!writeTag(writer)) {
3938 return false;
3939 }
3940 if (!writeArgs(writer)) {
3941 return false;
3942 }
3943 return true;
3944}
3945
3947{
3948 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3949 return false;
3950 }
3951 return true;
3952}
3953
3955{
3956 if (!writer.writeI32(steps)) {
3957 return false;
3958 }
3959 return true;
3960}
3961
3963{
3964 if (!readTag(reader)) {
3965 return false;
3966 }
3967 if (!readArgs(reader)) {
3968 return false;
3969 }
3970 return true;
3971}
3972
3974{
3975 std::string tag = reader.readTag(s_tag_len);
3976 if (reader.isError()) {
3977 return false;
3978 }
3979 if (tag != s_tag) {
3980 reader.fail();
3981 return false;
3982 }
3983 return true;
3984}
3985
3987{
3988 if (!reader.readI32(steps)) {
3989 steps = 5;
3990 }
3991 if (!reader.noMore()) {
3992 reader.fail();
3993 return false;
3994 }
3995 return true;
3996}
3997
3999{
4000 yarp::os::idl::WireWriter writer(connection);
4001 return write(writer);
4002}
4003
4005{
4006 yarp::os::idl::WireReader reader(connection);
4007 return read(reader);
4008}
4009
4011{
4012 if (!writer.isNull()) {
4013 if (!writer.writeListHeader(s_reply_len)) {
4014 return false;
4015 }
4016 if (!writer.writeBool(return_helper)) {
4017 return false;
4018 }
4019 }
4020 return true;
4021}
4022
4024{
4025 if (!reader.readListReturn()) {
4026 return false;
4027 }
4028 if (reader.noMore()) {
4029 reader.fail();
4030 return false;
4031 }
4032 if (!reader.readBool(return_helper)) {
4033 reader.fail();
4034 return false;
4035 }
4036 return true;
4037}
4038
4043
4044// backward helper class implementation
4049
4051{
4052 return cmd.write(connection);
4053}
4054
4056{
4057 return reply.read(connection);
4058}
4059
4061 steps{steps}
4062{
4063}
4064
4066{
4067 yarp::os::idl::WireWriter writer(connection);
4068 if (!writer.writeListHeader(s_cmd_len)) {
4069 return false;
4070 }
4071 return write(writer);
4072}
4073
4075{
4076 yarp::os::idl::WireReader reader(connection);
4077 if (!reader.readListHeader()) {
4078 reader.fail();
4079 return false;
4080 }
4081 return read(reader);
4082}
4083
4085{
4086 if (!writeTag(writer)) {
4087 return false;
4088 }
4089 if (!writeArgs(writer)) {
4090 return false;
4091 }
4092 return true;
4093}
4094
4096{
4097 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4098 return false;
4099 }
4100 return true;
4101}
4102
4104{
4105 if (!writer.writeI32(steps)) {
4106 return false;
4107 }
4108 return true;
4109}
4110
4112{
4113 if (!readTag(reader)) {
4114 return false;
4115 }
4116 if (!readArgs(reader)) {
4117 return false;
4118 }
4119 return true;
4120}
4121
4123{
4124 std::string tag = reader.readTag(s_tag_len);
4125 if (reader.isError()) {
4126 return false;
4127 }
4128 if (tag != s_tag) {
4129 reader.fail();
4130 return false;
4131 }
4132 return true;
4133}
4134
4136{
4137 if (!reader.readI32(steps)) {
4138 steps = 5;
4139 }
4140 if (!reader.noMore()) {
4141 reader.fail();
4142 return false;
4143 }
4144 return true;
4145}
4146
4148{
4149 yarp::os::idl::WireWriter writer(connection);
4150 return write(writer);
4151}
4152
4154{
4155 yarp::os::idl::WireReader reader(connection);
4156 return read(reader);
4157}
4158
4160{
4161 if (!writer.isNull()) {
4162 if (!writer.writeListHeader(s_reply_len)) {
4163 return false;
4164 }
4165 if (!writer.writeBool(return_helper)) {
4166 return false;
4167 }
4168 }
4169 return true;
4170}
4171
4173{
4174 if (!reader.readListReturn()) {
4175 return false;
4176 }
4177 if (reader.noMore()) {
4178 reader.fail();
4179 return false;
4180 }
4181 if (!reader.readBool(return_helper)) {
4182 reader.fail();
4183 return false;
4184 }
4185 return true;
4186}
4187
4192
4193// getProgress helper class implementation
4195{
4196 return cmd.write(connection);
4197}
4198
4203
4205{
4206 yarp::os::idl::WireWriter writer(connection);
4207 if (!writer.writeListHeader(s_cmd_len)) {
4208 return false;
4209 }
4210 return write(writer);
4211}
4212
4214{
4215 yarp::os::idl::WireReader reader(connection);
4216 if (!reader.readListHeader()) {
4217 reader.fail();
4218 return false;
4219 }
4220 return read(reader);
4221}
4222
4224{
4225 if (!writeTag(writer)) {
4226 return false;
4227 }
4228 if (!writeArgs(writer)) {
4229 return false;
4230 }
4231 return true;
4232}
4233
4235{
4236 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4237 return false;
4238 }
4239 return true;
4240}
4241
4243{
4244 return true;
4245}
4246
4248{
4249 if (!readTag(reader)) {
4250 return false;
4251 }
4252 if (!readArgs(reader)) {
4253 return false;
4254 }
4255 return true;
4256}
4257
4259{
4260 std::string tag = reader.readTag(s_tag_len);
4261 if (reader.isError()) {
4262 return false;
4263 }
4264 if (tag != s_tag) {
4265 reader.fail();
4266 return false;
4267 }
4268 return true;
4269}
4270
4272{
4273 if (!reader.noMore()) {
4274 reader.fail();
4275 return false;
4276 }
4277 return true;
4278}
4279
4281{
4282 yarp::os::idl::WireWriter writer(connection);
4283 return write(writer);
4284}
4285
4287{
4288 yarp::os::idl::WireReader reader(connection);
4289 return read(reader);
4290}
4291
4293{
4294 if (!writer.isNull()) {
4295 if (!writer.writeListHeader(s_reply_len)) {
4296 return false;
4297 }
4298 if (!writer.writeFloat64(return_helper)) {
4299 return false;
4300 }
4301 }
4302 return true;
4303}
4304
4306{
4307 if (!reader.readListReturn()) {
4308 return false;
4309 }
4310 if (reader.noMore()) {
4311 reader.fail();
4312 return false;
4313 }
4314 if (!reader.readFloat64(return_helper)) {
4315 reader.fail();
4316 return false;
4317 }
4318 return true;
4319}
4320
4325
4326// getStatus helper class implementation
4328{
4329 return cmd.write(connection);
4330}
4331
4336
4338{
4339 yarp::os::idl::WireWriter writer(connection);
4340 if (!writer.writeListHeader(s_cmd_len)) {
4341 return false;
4342 }
4343 return write(writer);
4344}
4345
4347{
4348 yarp::os::idl::WireReader reader(connection);
4349 if (!reader.readListHeader()) {
4350 reader.fail();
4351 return false;
4352 }
4353 return read(reader);
4354}
4355
4357{
4358 if (!writeTag(writer)) {
4359 return false;
4360 }
4361 if (!writeArgs(writer)) {
4362 return false;
4363 }
4364 return true;
4365}
4366
4368{
4369 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4370 return false;
4371 }
4372 return true;
4373}
4374
4376{
4377 return true;
4378}
4379
4381{
4382 if (!readTag(reader)) {
4383 return false;
4384 }
4385 if (!readArgs(reader)) {
4386 return false;
4387 }
4388 return true;
4389}
4390
4392{
4393 std::string tag = reader.readTag(s_tag_len);
4394 if (reader.isError()) {
4395 return false;
4396 }
4397 if (tag != s_tag) {
4398 reader.fail();
4399 return false;
4400 }
4401 return true;
4402}
4403
4405{
4406 if (!reader.noMore()) {
4407 reader.fail();
4408 return false;
4409 }
4410 return true;
4411}
4412
4414{
4415 yarp::os::idl::WireWriter writer(connection);
4416 return write(writer);
4417}
4418
4420{
4421 yarp::os::idl::WireReader reader(connection);
4422 return read(reader);
4423}
4424
4426{
4427 if (!writer.isNull()) {
4428 if (!writer.writeListHeader(s_reply_len)) {
4429 return false;
4430 }
4431 if (!writer.writeString(return_helper)) {
4432 return false;
4433 }
4434 }
4435 return true;
4436}
4437
4439{
4440 if (!reader.readListReturn()) {
4441 return false;
4442 }
4443 if (reader.noMore()) {
4444 reader.fail();
4445 return false;
4446 }
4447 if (!reader.readString(return_helper)) {
4448 reader.fail();
4449 return false;
4450 }
4451 return true;
4452}
4453
4458
4459// resume helper class implementation
4461{
4462 return cmd.write(connection);
4463}
4464
4466{
4467 return reply.read(connection);
4468}
4469
4471{
4472 yarp::os::idl::WireWriter writer(connection);
4473 if (!writer.writeListHeader(s_cmd_len)) {
4474 return false;
4475 }
4476 return write(writer);
4477}
4478
4480{
4481 yarp::os::idl::WireReader reader(connection);
4482 if (!reader.readListHeader()) {
4483 reader.fail();
4484 return false;
4485 }
4486 return read(reader);
4487}
4488
4490{
4491 if (!writeTag(writer)) {
4492 return false;
4493 }
4494 if (!writeArgs(writer)) {
4495 return false;
4496 }
4497 return true;
4498}
4499
4501{
4502 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4503 return false;
4504 }
4505 return true;
4506}
4507
4509{
4510 return true;
4511}
4512
4514{
4515 if (!readTag(reader)) {
4516 return false;
4517 }
4518 if (!readArgs(reader)) {
4519 return false;
4520 }
4521 return true;
4522}
4523
4525{
4526 std::string tag = reader.readTag(s_tag_len);
4527 if (reader.isError()) {
4528 return false;
4529 }
4530 if (tag != s_tag) {
4531 reader.fail();
4532 return false;
4533 }
4534 return true;
4535}
4536
4538{
4539 if (!reader.noMore()) {
4540 reader.fail();
4541 return false;
4542 }
4543 return true;
4544}
4545
4547{
4548 yarp::os::idl::WireWriter writer(connection);
4549 return write(writer);
4550}
4551
4553{
4554 yarp::os::idl::WireReader reader(connection);
4555 return read(reader);
4556}
4557
4559{
4560 if (!writer.isNull()) {
4561 if (!writer.writeListHeader(s_reply_len)) {
4562 return false;
4563 }
4564 if (!writer.writeBool(return_helper)) {
4565 return false;
4566 }
4567 }
4568 return true;
4569}
4570
4572{
4573 if (!reader.readListReturn()) {
4574 return false;
4575 }
4576 if (reader.noMore()) {
4577 reader.fail();
4578 return false;
4579 }
4580 if (!reader.readBool(return_helper)) {
4581 reader.fail();
4582 return false;
4583 }
4584 return true;
4585}
4586
4591
4592// quit helper class implementation
4594{
4595 return cmd.write(connection);
4596}
4597
4599{
4600 return reply.read(connection);
4601}
4602
4604{
4605 yarp::os::idl::WireWriter writer(connection);
4606 if (!writer.writeListHeader(s_cmd_len)) {
4607 return false;
4608 }
4609 return write(writer);
4610}
4611
4613{
4614 yarp::os::idl::WireReader reader(connection);
4615 if (!reader.readListHeader()) {
4616 reader.fail();
4617 return false;
4618 }
4619 return read(reader);
4620}
4621
4623{
4624 if (!writeTag(writer)) {
4625 return false;
4626 }
4627 if (!writeArgs(writer)) {
4628 return false;
4629 }
4630 return true;
4631}
4632
4634{
4635 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4636 return false;
4637 }
4638 return true;
4639}
4640
4642{
4643 return true;
4644}
4645
4647{
4648 if (!readTag(reader)) {
4649 return false;
4650 }
4651 if (!readArgs(reader)) {
4652 return false;
4653 }
4654 return true;
4655}
4656
4658{
4659 std::string tag = reader.readTag(s_tag_len);
4660 if (reader.isError()) {
4661 return false;
4662 }
4663 if (tag != s_tag) {
4664 reader.fail();
4665 return false;
4666 }
4667 return true;
4668}
4669
4671{
4672 if (!reader.noMore()) {
4673 reader.fail();
4674 return false;
4675 }
4676 return true;
4677}
4678
4680{
4681 yarp::os::idl::WireWriter writer(connection);
4682 return write(writer);
4683}
4684
4686{
4687 yarp::os::idl::WireReader reader(connection);
4688 return read(reader);
4689}
4690
4692{
4693 if (!writer.isNull()) {
4694 if (!writer.writeListHeader(s_reply_len)) {
4695 return false;
4696 }
4697 if (!writer.writeBool(return_helper)) {
4698 return false;
4699 }
4700 }
4701 return true;
4702}
4703
4705{
4706 if (!reader.readListReturn()) {
4707 return false;
4708 }
4709 if (reader.noMore()) {
4710 reader.fail();
4711 return false;
4712 }
4713 if (!reader.readBool(return_helper)) {
4714 reader.fail();
4715 return false;
4716 }
4717 return true;
4718}
4719
4724
4725// Constructor
4730
4732{
4733 if (!yarp().canWrite()) {
4734 yError("Missing server method '%s'?", yarpdataplayer_console_IDL_step_helper::s_prototype);
4735 }
4737 bool ok = yarp().write(helper, helper);
4738 return ok ? helper.reply.return_helper : bool{};
4739}
4740
4741bool yarpdataplayer_console_IDL::setFrame(const std::int32_t frameNum)
4742{
4743 if (!yarp().canWrite()) {
4745 }
4747 bool ok = yarp().write(helper, helper);
4748 return ok ? helper.reply.return_helper : bool{};
4749}
4750
4751std::int32_t yarpdataplayer_console_IDL::getFrame(const std::string& name)
4752{
4753 if (!yarp().canWrite()) {
4755 }
4757 bool ok = yarp().write(helper, helper);
4758 return ok ? helper.reply.return_helper : std::int32_t{};
4759}
4760
4761bool yarpdataplayer_console_IDL::load(const std::string& path)
4762{
4763 if (!yarp().canWrite()) {
4764 yError("Missing server method '%s'?", yarpdataplayer_console_IDL_load_helper::s_prototype);
4765 }
4767 bool ok = yarp().write(helper, helper);
4768 return ok ? helper.reply.return_helper : bool{};
4769}
4770
4772{
4773 if (!yarp().canWrite()) {
4774 yError("Missing server method '%s'?", yarpdataplayer_console_IDL_play_helper::s_prototype);
4775 }
4777 bool ok = yarp().write(helper, helper);
4778 return ok ? helper.reply.return_helper : bool{};
4779}
4780
4782{
4783 if (!yarp().canWrite()) {
4784 yError("Missing server method '%s'?", yarpdataplayer_console_IDL_pause_helper::s_prototype);
4785 }
4787 bool ok = yarp().write(helper, helper);
4788 return ok ? helper.reply.return_helper : bool{};
4789}
4790
4792{
4793 if (!yarp().canWrite()) {
4794 yError("Missing server method '%s'?", yarpdataplayer_console_IDL_stop_helper::s_prototype);
4795 }
4797 bool ok = yarp().write(helper, helper);
4798 return ok ? helper.reply.return_helper : bool{};
4799}
4800
4801bool yarpdataplayer_console_IDL::enable(const std::string& part)
4802{
4803 if (!yarp().canWrite()) {
4804 yError("Missing server method '%s'?", yarpdataplayer_console_IDL_enable_helper::s_prototype);
4805 }
4807 bool ok = yarp().write(helper, helper);
4808 return ok ? helper.reply.return_helper : bool{};
4809}
4810
4811bool yarpdataplayer_console_IDL::disable(const std::string& part)
4812{
4813 if (!yarp().canWrite()) {
4814 yError("Missing server method '%s'?", yarpdataplayer_console_IDL_disable_helper::s_prototype);
4815 }
4817 bool ok = yarp().write(helper, helper);
4818 return ok ? helper.reply.return_helper : bool{};
4819}
4820
4822{
4823 if (!yarp().canWrite()) {
4825 }
4827 bool ok = yarp().write(helper, helper);
4828 return ok ? helper.reply.return_helper : std::vector<std::string>{};
4829}
4830
4831std::string yarpdataplayer_console_IDL::getPortName(const std::string& part)
4832{
4833 if (!yarp().canWrite()) {
4835 }
4837 bool ok = yarp().write(helper, helper);
4838 return ok ? helper.reply.return_helper : std::string{};
4839}
4840
4841bool yarpdataplayer_console_IDL::setPortName(const std::string& part, const std::string& new_name)
4842{
4843 if (!yarp().canWrite()) {
4845 }
4846 yarpdataplayer_console_IDL_setPortName_helper helper{part, new_name};
4847 bool ok = yarp().write(helper, helper);
4848 return ok ? helper.reply.return_helper : bool{};
4849}
4850
4852{
4853 if (!yarp().canWrite()) {
4855 }
4857 bool ok = yarp().write(helper, helper);
4858 return ok ? helper.reply.return_helper : bool{};
4859}
4860
4862{
4863 if (!yarp().canWrite()) {
4865 }
4867 bool ok = yarp().write(helper, helper);
4868 return ok ? helper.reply.return_helper : double{};
4869}
4870
4872{
4873 if (!yarp().canWrite()) {
4874 yError("Missing server method '%s'?", yarpdataplayer_console_IDL_repeat_helper::s_prototype);
4875 }
4877 bool ok = yarp().write(helper, helper);
4878 return ok ? helper.reply.return_helper : bool{};
4879}
4880
4882{
4883 if (!yarp().canWrite()) {
4885 }
4887 bool ok = yarp().write(helper, helper);
4888 return ok ? helper.reply.return_helper : bool{};
4889}
4890
4891bool yarpdataplayer_console_IDL::forward(const std::int32_t steps)
4892{
4893 if (!yarp().canWrite()) {
4894 yError("Missing server method '%s'?", yarpdataplayer_console_IDL_forward_helper::s_prototype);
4895 }
4897 bool ok = yarp().write(helper, helper);
4898 return ok ? helper.reply.return_helper : bool{};
4899}
4900
4901bool yarpdataplayer_console_IDL::backward(const std::int32_t steps)
4902{
4903 if (!yarp().canWrite()) {
4905 }
4907 bool ok = yarp().write(helper, helper);
4908 return ok ? helper.reply.return_helper : bool{};
4909}
4910
4912{
4913 if (!yarp().canWrite()) {
4915 }
4917 bool ok = yarp().write(helper, helper);
4918 return ok ? helper.reply.return_helper : double{};
4919}
4920
4922{
4923 if (!yarp().canWrite()) {
4925 }
4927 bool ok = yarp().write(helper, helper);
4928 return ok ? helper.reply.return_helper : std::string{};
4929}
4930
4932{
4933 if (!yarp().canWrite()) {
4934 yError("Missing server method '%s'?", yarpdataplayer_console_IDL_resume_helper::s_prototype);
4935 }
4937 bool ok = yarp().write(helper, helper);
4938 return ok ? helper.reply.return_helper : bool{};
4939}
4940
4942{
4943 if (!yarp().canWrite()) {
4944 yError("Missing server method '%s'?", yarpdataplayer_console_IDL_quit_helper::s_prototype);
4945 }
4947 bool ok = yarp().write(helper, helper);
4948 return ok ? helper.reply.return_helper : bool{};
4949}
4950
4951// help method
4952std::vector<std::string> yarpdataplayer_console_IDL::help(const std::string& functionName)
4953{
4954 bool showAll = (functionName == "--all");
4955 std::vector<std::string> helpString;
4956 if (showAll) {
4957 helpString.emplace_back("*** Available commands:");
4958 helpString.emplace_back(yarpdataplayer_console_IDL_step_helper::s_tag);
4961 helpString.emplace_back(yarpdataplayer_console_IDL_load_helper::s_tag);
4962 helpString.emplace_back(yarpdataplayer_console_IDL_play_helper::s_tag);
4963 helpString.emplace_back(yarpdataplayer_console_IDL_pause_helper::s_tag);
4964 helpString.emplace_back(yarpdataplayer_console_IDL_stop_helper::s_tag);
4965 helpString.emplace_back(yarpdataplayer_console_IDL_enable_helper::s_tag);
4966 helpString.emplace_back(yarpdataplayer_console_IDL_disable_helper::s_tag);
4972 helpString.emplace_back(yarpdataplayer_console_IDL_repeat_helper::s_tag);
4974 helpString.emplace_back(yarpdataplayer_console_IDL_forward_helper::s_tag);
4978 helpString.emplace_back(yarpdataplayer_console_IDL_resume_helper::s_tag);
4979 helpString.emplace_back(yarpdataplayer_console_IDL_quit_helper::s_tag);
4980 helpString.emplace_back("help");
4981 } else {
4984 helpString.emplace_back(yarpdataplayer_console_IDL_step_helper::s_help);
4985 }
4989 }
4993 }
4996 helpString.emplace_back(yarpdataplayer_console_IDL_load_helper::s_help);
4997 }
5000 helpString.emplace_back(yarpdataplayer_console_IDL_play_helper::s_help);
5001 }
5004 helpString.emplace_back(yarpdataplayer_console_IDL_pause_helper::s_help);
5005 }
5008 helpString.emplace_back(yarpdataplayer_console_IDL_stop_helper::s_help);
5009 }
5012 helpString.emplace_back(yarpdataplayer_console_IDL_enable_helper::s_help);
5013 }
5017 }
5021 }
5025 }
5029 }
5033 }
5037 }
5040 helpString.emplace_back(yarpdataplayer_console_IDL_repeat_helper::s_help);
5041 }
5045 }
5049 }
5053 }
5057 }
5061 }
5064 helpString.emplace_back(yarpdataplayer_console_IDL_resume_helper::s_help);
5065 }
5068 helpString.emplace_back(yarpdataplayer_console_IDL_quit_helper::s_help);
5069 }
5070 if (functionName == "help") {
5071 helpString.emplace_back("std::vector<std::string> help(const std::string& functionName = \"--all\")");
5072 helpString.emplace_back("Return list of available commands, or help message for a specific function");
5073 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");
5074 helpString.emplace_back("@return list of strings (one string per line)");
5075 }
5076 }
5077 if (helpString.empty()) {
5078 helpString.emplace_back("Command not found");
5079 }
5080 return helpString;
5081}
5082
5083// read from ConnectionReader
5085{
5086 constexpr size_t max_tag_len = 1;
5087 size_t tag_len = 1;
5088
5089 yarp::os::idl::WireReader reader(connection);
5090 reader.expectAccept();
5091 if (!reader.readListHeader()) {
5092 reader.fail();
5093 return false;
5094 }
5095
5096 std::string tag = reader.readTag(1);
5097 bool direct = (tag == "__direct__");
5098 if (direct) {
5099 tag = reader.readTag(1);
5100 }
5101 while (tag_len <= max_tag_len && !reader.isError()) {
5102 if(tag == "getRemoteProtocolVersion") {
5103 if (!reader.noMore()) {
5104 yError("Reader invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
5105 reader.fail();
5106 return false;
5107 }
5108
5109 auto proto = getLocalProtocolVersion();
5110
5111 yarp::os::idl::WireWriter writer(reader);
5112 if (!writer.writeListHeader(1)) {
5113 yWarning("Writer invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
5114 return false;}
5115 if (!writer.write(proto)) {
5116 yWarning("Writer invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
5117 return false;
5118 }
5119 reader.accept();
5120 return true;
5121 }
5124 if (!helper.cmd.readArgs(reader)) {
5125 return false;
5126 }
5127
5128 helper.call(this);
5129
5130 yarp::os::idl::WireWriter writer(reader);
5131 if (!helper.reply.write(writer)) {
5132 return false;
5133 }
5134 reader.accept();
5135 return true;
5136 }
5139 if (!helper.cmd.readArgs(reader)) {
5140 return false;
5141 }
5142
5143 helper.call(this);
5144
5145 yarp::os::idl::WireWriter writer(reader);
5146 if (!helper.reply.write(writer)) {
5147 return false;
5148 }
5149 reader.accept();
5150 return true;
5151 }
5154 if (!helper.cmd.readArgs(reader)) {
5155 return false;
5156 }
5157
5158 helper.call(this);
5159
5160 yarp::os::idl::WireWriter writer(reader);
5161 if (!helper.reply.write(writer)) {
5162 return false;
5163 }
5164 reader.accept();
5165 return true;
5166 }
5169 if (!helper.cmd.readArgs(reader)) {
5170 return false;
5171 }
5172
5173 helper.call(this);
5174
5175 yarp::os::idl::WireWriter writer(reader);
5176 if (!helper.reply.write(writer)) {
5177 return false;
5178 }
5179 reader.accept();
5180 return true;
5181 }
5184 if (!helper.cmd.readArgs(reader)) {
5185 return false;
5186 }
5187
5188 helper.call(this);
5189
5190 yarp::os::idl::WireWriter writer(reader);
5191 if (!helper.reply.write(writer)) {
5192 return false;
5193 }
5194 reader.accept();
5195 return true;
5196 }
5199 if (!helper.cmd.readArgs(reader)) {
5200 return false;
5201 }
5202
5203 helper.call(this);
5204
5205 yarp::os::idl::WireWriter writer(reader);
5206 if (!helper.reply.write(writer)) {
5207 return false;
5208 }
5209 reader.accept();
5210 return true;
5211 }
5214 if (!helper.cmd.readArgs(reader)) {
5215 return false;
5216 }
5217
5218 helper.call(this);
5219
5220 yarp::os::idl::WireWriter writer(reader);
5221 if (!helper.reply.write(writer)) {
5222 return false;
5223 }
5224 reader.accept();
5225 return true;
5226 }
5229 if (!helper.cmd.readArgs(reader)) {
5230 return false;
5231 }
5232
5233 helper.call(this);
5234
5235 yarp::os::idl::WireWriter writer(reader);
5236 if (!helper.reply.write(writer)) {
5237 return false;
5238 }
5239 reader.accept();
5240 return true;
5241 }
5244 if (!helper.cmd.readArgs(reader)) {
5245 return false;
5246 }
5247
5248 helper.call(this);
5249
5250 yarp::os::idl::WireWriter writer(reader);
5251 if (!helper.reply.write(writer)) {
5252 return false;
5253 }
5254 reader.accept();
5255 return true;
5256 }
5259 if (!helper.cmd.readArgs(reader)) {
5260 return false;
5261 }
5262
5263 helper.call(this);
5264
5265 yarp::os::idl::WireWriter writer(reader);
5266 if (!helper.reply.write(writer)) {
5267 return false;
5268 }
5269 reader.accept();
5270 return true;
5271 }
5274 if (!helper.cmd.readArgs(reader)) {
5275 return false;
5276 }
5277
5278 helper.call(this);
5279
5280 yarp::os::idl::WireWriter writer(reader);
5281 if (!helper.reply.write(writer)) {
5282 return false;
5283 }
5284 reader.accept();
5285 return true;
5286 }
5289 if (!helper.cmd.readArgs(reader)) {
5290 return false;
5291 }
5292
5293 helper.call(this);
5294
5295 yarp::os::idl::WireWriter writer(reader);
5296 if (!helper.reply.write(writer)) {
5297 return false;
5298 }
5299 reader.accept();
5300 return true;
5301 }
5304 if (!helper.cmd.readArgs(reader)) {
5305 return false;
5306 }
5307
5308 helper.call(this);
5309
5310 yarp::os::idl::WireWriter writer(reader);
5311 if (!helper.reply.write(writer)) {
5312 return false;
5313 }
5314 reader.accept();
5315 return true;
5316 }
5319 if (!helper.cmd.readArgs(reader)) {
5320 return false;
5321 }
5322
5323 helper.call(this);
5324
5325 yarp::os::idl::WireWriter writer(reader);
5326 if (!helper.reply.write(writer)) {
5327 return false;
5328 }
5329 reader.accept();
5330 return true;
5331 }
5334 if (!helper.cmd.readArgs(reader)) {
5335 return false;
5336 }
5337
5338 helper.call(this);
5339
5340 yarp::os::idl::WireWriter writer(reader);
5341 if (!helper.reply.write(writer)) {
5342 return false;
5343 }
5344 reader.accept();
5345 return true;
5346 }
5349 if (!helper.cmd.readArgs(reader)) {
5350 return false;
5351 }
5352
5353 helper.call(this);
5354
5355 yarp::os::idl::WireWriter writer(reader);
5356 if (!helper.reply.write(writer)) {
5357 return false;
5358 }
5359 reader.accept();
5360 return true;
5361 }
5364 if (!helper.cmd.readArgs(reader)) {
5365 return false;
5366 }
5367
5368 helper.call(this);
5369
5370 yarp::os::idl::WireWriter writer(reader);
5371 if (!helper.reply.write(writer)) {
5372 return false;
5373 }
5374 reader.accept();
5375 return true;
5376 }
5379 if (!helper.cmd.readArgs(reader)) {
5380 return false;
5381 }
5382
5383 helper.call(this);
5384
5385 yarp::os::idl::WireWriter writer(reader);
5386 if (!helper.reply.write(writer)) {
5387 return false;
5388 }
5389 reader.accept();
5390 return true;
5391 }
5394 if (!helper.cmd.readArgs(reader)) {
5395 return false;
5396 }
5397
5398 helper.call(this);
5399
5400 yarp::os::idl::WireWriter writer(reader);
5401 if (!helper.reply.write(writer)) {
5402 return false;
5403 }
5404 reader.accept();
5405 return true;
5406 }
5409 if (!helper.cmd.readArgs(reader)) {
5410 return false;
5411 }
5412
5413 helper.call(this);
5414
5415 yarp::os::idl::WireWriter writer(reader);
5416 if (!helper.reply.write(writer)) {
5417 return false;
5418 }
5419 reader.accept();
5420 return true;
5421 }
5424 if (!helper.cmd.readArgs(reader)) {
5425 return false;
5426 }
5427
5428 helper.call(this);
5429
5430 yarp::os::idl::WireWriter writer(reader);
5431 if (!helper.reply.write(writer)) {
5432 return false;
5433 }
5434 reader.accept();
5435 return true;
5436 }
5439 if (!helper.cmd.readArgs(reader)) {
5440 return false;
5441 }
5442
5443 helper.call(this);
5444
5445 yarp::os::idl::WireWriter writer(reader);
5446 if (!helper.reply.write(writer)) {
5447 return false;
5448 }
5449 reader.accept();
5450 return true;
5451 }
5452 if (tag == "help") {
5453 std::string functionName;
5454 if (!reader.readString(functionName)) {
5455 functionName = "--all";
5456 }
5457 auto help_strings = help(functionName);
5458 yarp::os::idl::WireWriter writer(reader);
5459 if (!writer.isNull()) {
5460 if (!writer.writeListHeader(2)) {
5461 return false;
5462 }
5463 if (!writer.writeTag("many", 1, 0)) {
5464 return false;
5465 }
5466 if (!writer.writeListBegin(0, help_strings.size())) {
5467 return false;
5468 }
5469 for (const auto& help_string : help_strings) {
5470 if (!writer.writeString(help_string)) {
5471 return false;
5472 }
5473 }
5474 if (!writer.writeListEnd()) {
5475 return false;
5476 }
5477 }
5478 reader.accept();
5479 return true;
5480 }
5481 if (reader.noMore()) {
5482 reader.fail();
5483 return false;
5484 }
5485 std::string next_tag = reader.readTag(1);
5486 if (next_tag.empty()) {
5487 break;
5488 }
5489 tag.append("_").append(next_tag);
5490 tag_len = std::count(tag.begin(), tag.end(), '_') + 1;
5491 }
5492 return false;
5493}
#define BOTTLE_TAG_STRING
Definition Bottle.h:27
#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
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)
void readListBegin(yarp::os::idl::WireState &nstate, size_t &len)
bool readI32(std::int32_t &x)
std::string readTag(size_t len=static_cast< size_t >(-1))
bool readFloat64(yarp::conf::float64_t &x)
IDL-friendly state.
Definition WireState.h:17
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 writeFloat64(yarp::conf::float64_t x, bool skip_tag=false) 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 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 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 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 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 writeArgs(const yarp::os::idl::WireWriter &writer) const
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 read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
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.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
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 read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
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.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool 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 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 writeArgs(const yarp::os::idl::WireWriter &writer) const
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 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 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 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 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 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 read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool 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 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.
void call(yarpdataplayer_console_IDL *ptr)
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
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.
void call(yarpdataplayer_console_IDL *ptr)
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 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 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.
void call(yarpdataplayer_console_IDL *ptr)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool 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.
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 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 read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
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.
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.
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 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 write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool(*)(const std::string &, const std::string &) funcptr_t
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 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.
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 read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool 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 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 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.
void call(yarpdataplayer_console_IDL *ptr)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool 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.
void call(yarpdataplayer_console_IDL *ptr)
yarpdataplayer_console_IDL Interface.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
virtual yarp::os::ApplicationNetworkProtocolVersion getRemoteProtocolVersion()
virtual bool pause()
Pauses the dataSets.
virtual bool quit()
Quit the module.
virtual bool load(const std::string &path)
Loads a dataset from a path.
virtual std::string getPortName(const std::string &part)
Gets the name of the port associated to the specified part.
virtual bool stop()
Stops the dataSets.
virtual double getSpeed()
Gets the player speed.
virtual std::string getStatus()
Get the status of playing.
virtual std::vector< std::string > help(const std::string &functionName="--all")
virtual bool step()
Steps the player once.
virtual bool repeat(const bool val=false)
Sets repeat mode.
virtual bool setPortName(const std::string &part, const std::string &new_name)
Sets the name of the port associated to the specified part.
virtual std::vector< std::string > getAllParts()
Gets the names of all parts loaded.
virtual bool setStrict(const bool val=false)
Sets strict mode.
virtual bool play()
Plays the dataSets.
virtual bool disable(const std::string &part)
Disable the specified part.
virtual bool enable(const std::string &part)
Enables the specified part.
virtual double getProgress()
Get the progress of the parts.
virtual bool resume()
Resume dataset from where it was paused.
virtual std::int32_t getFrame(const std::string &name)
Gets the frame number the user is requesting.
virtual bool setSpeed(const double speed)
Sets the player speed.
virtual yarp::os::ApplicationNetworkProtocolVersion getLocalProtocolVersion()
virtual bool forward(const std::int32_t steps=5)
Steps forward.
virtual bool setFrame(const std::int32_t frameNum)
Sets the frame number to the user desired frame.
virtual bool backward(const std::int32_t steps=5)
Steps backward.
#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