YARP
Yet Another Robot Platform
 
Loading...
Searching...
No Matches
yarpActionsPlayer_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, "yarpActionsPlayer_IDL")
24}
25
26//yarpActionsPlayer_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 yarpActionsPlayer_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 yarpActionsPlayer_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// start helper class declaration
111 public yarp::os::Portable
112{
113public:
115 bool write(yarp::os::ConnectionWriter& connection) const override;
116 bool read(yarp::os::ConnectionReader& connection) override;
117
118 class Command :
120 {
121 public:
122 Command() = default;
123 ~Command() override = default;
124
125 bool write(yarp::os::ConnectionWriter& connection) const override;
126 bool read(yarp::os::ConnectionReader& connection) override;
127
128 bool write(const yarp::os::idl::WireWriter& writer) const override;
129 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
130 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
131
132 bool read(yarp::os::idl::WireReader& reader) override;
135 };
136
137 class Reply :
139 {
140 public:
141 Reply() = default;
142 ~Reply() override = default;
143
144 bool write(yarp::os::ConnectionWriter& connection) const override;
145 bool read(yarp::os::ConnectionReader& connection) override;
146
147 bool write(const yarp::os::idl::WireWriter& writer) const override;
148 bool read(yarp::os::idl::WireReader& reader) override;
149
150 bool return_helper{false};
151 };
152
153 using funcptr_t = bool (*)();
154 void call(yarpActionsPlayer_IDL* ptr);
155
158
159 static constexpr const char* s_tag{"start"};
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 yarpActionsPlayer_IDL::start()"};
164 static constexpr const char* s_help{
165 "Start (or resumes, if stopped) the currently selected action.\n"
166 "It will stop when the last frame is reached.\n"
167 "@return true/false on success/failure"
168 };
169};
170
171// stop helper class declaration
173 public yarp::os::Portable
174{
175public:
177 bool write(yarp::os::ConnectionWriter& connection) const override;
178 bool read(yarp::os::ConnectionReader& connection) override;
179
180 class Command :
182 {
183 public:
184 Command() = default;
185 ~Command() override = default;
186
187 bool write(yarp::os::ConnectionWriter& connection) const override;
188 bool read(yarp::os::ConnectionReader& connection) override;
189
190 bool write(const yarp::os::idl::WireWriter& writer) const override;
191 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
192 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
193
194 bool read(yarp::os::idl::WireReader& reader) override;
197 };
198
199 class Reply :
201 {
202 public:
203 Reply() = default;
204 ~Reply() override = default;
205
206 bool write(yarp::os::ConnectionWriter& connection) const override;
207 bool read(yarp::os::ConnectionReader& connection) override;
208
209 bool write(const yarp::os::idl::WireWriter& writer) const override;
210 bool read(yarp::os::idl::WireReader& reader) override;
211
212 bool return_helper{false};
213 };
214
215 using funcptr_t = bool (*)();
216 void call(yarpActionsPlayer_IDL* ptr);
217
220
221 static constexpr const char* s_tag{"stop"};
222 static constexpr size_t s_tag_len{1};
223 static constexpr size_t s_cmd_len{1};
224 static constexpr size_t s_reply_len{1};
225 static constexpr const char* s_prototype{"bool yarpActionsPlayer_IDL::stop()"};
226 static constexpr const char* s_help{
227 "Stops the currently selected (running) action. Can be resumed by start.\n"
228 "@return true/false on success/failure"
229 };
230};
231
232// reset helper class declaration
234 public yarp::os::Portable
235{
236public:
238 bool write(yarp::os::ConnectionWriter& connection) const override;
239 bool read(yarp::os::ConnectionReader& connection) override;
240
241 class Command :
243 {
244 public:
245 Command() = default;
246 ~Command() override = default;
247
248 bool write(yarp::os::ConnectionWriter& connection) const override;
249 bool read(yarp::os::ConnectionReader& connection) override;
250
251 bool write(const yarp::os::idl::WireWriter& writer) const override;
252 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
253 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
254
255 bool read(yarp::os::idl::WireReader& reader) override;
258 };
259
260 class Reply :
262 {
263 public:
264 Reply() = default;
265 ~Reply() override = default;
266
267 bool write(yarp::os::ConnectionWriter& connection) const override;
268 bool read(yarp::os::ConnectionReader& connection) override;
269
270 bool write(const yarp::os::idl::WireWriter& writer) const override;
271 bool read(yarp::os::idl::WireReader& reader) override;
272
273 bool return_helper{false};
274 };
275
276 using funcptr_t = bool (*)();
277 void call(yarpActionsPlayer_IDL* ptr);
278
281
282 static constexpr const char* s_tag{"reset"};
283 static constexpr size_t s_tag_len{1};
284 static constexpr size_t s_cmd_len{1};
285 static constexpr size_t s_reply_len{1};
286 static constexpr const char* s_prototype{"bool yarpActionsPlayer_IDL::reset()"};
287 static constexpr const char* s_help{
288 "Rewinds the currently selected action.\n"
289 "@return true/false on success/failure"
290 };
291};
292
293// forever helper class declaration
295 public yarp::os::Portable
296{
297public:
299 bool write(yarp::os::ConnectionWriter& connection) const override;
300 bool read(yarp::os::ConnectionReader& connection) override;
301
302 class Command :
304 {
305 public:
306 Command() = default;
307 ~Command() override = default;
308
309 bool write(yarp::os::ConnectionWriter& connection) const override;
310 bool read(yarp::os::ConnectionReader& connection) override;
311
312 bool write(const yarp::os::idl::WireWriter& writer) const override;
313 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
314 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
315
316 bool read(yarp::os::idl::WireReader& reader) override;
319 };
320
321 class Reply :
323 {
324 public:
325 Reply() = default;
326 ~Reply() override = default;
327
328 bool write(yarp::os::ConnectionWriter& connection) const override;
329 bool read(yarp::os::ConnectionReader& connection) override;
330
331 bool write(const yarp::os::idl::WireWriter& writer) const override;
332 bool read(yarp::os::idl::WireReader& reader) override;
333
334 bool return_helper{false};
335 };
336
337 using funcptr_t = bool (*)();
338 void call(yarpActionsPlayer_IDL* ptr);
339
342
343 static constexpr const char* s_tag{"forever"};
344 static constexpr size_t s_tag_len{1};
345 static constexpr size_t s_cmd_len{1};
346 static constexpr size_t s_reply_len{1};
347 static constexpr const char* s_prototype{"bool yarpActionsPlayer_IDL::forever()"};
348 static constexpr const char* s_help{
349 "Similar to play, but it will automatically restart the playback when the last\n"
350 "frame is reached.\n"
351 "@return true/false on success/failure"
352 };
353};
354
355// print_frames helper class declaration
357 public yarp::os::Portable
358{
359public:
361 bool write(yarp::os::ConnectionWriter& connection) const override;
362 bool read(yarp::os::ConnectionReader& connection) override;
363
364 class Command :
366 {
367 public:
368 Command() = default;
369 ~Command() override = default;
370
371 bool write(yarp::os::ConnectionWriter& connection) const override;
372 bool read(yarp::os::ConnectionReader& connection) override;
373
374 bool write(const yarp::os::idl::WireWriter& writer) const override;
375 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
376 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
377
378 bool read(yarp::os::idl::WireReader& reader) override;
381 };
382
383 class Reply :
385 {
386 public:
387 Reply() = default;
388 ~Reply() override = default;
389
390 bool write(yarp::os::ConnectionWriter& connection) const override;
391 bool read(yarp::os::ConnectionReader& connection) override;
392
393 bool write(const yarp::os::idl::WireWriter& writer) const override;
394 bool read(yarp::os::idl::WireReader& reader) override;
395
396 bool return_helper{false};
397 };
398
399 using funcptr_t = bool (*)();
400 void call(yarpActionsPlayer_IDL* ptr);
401
404
405 static constexpr const char* s_tag{"print_frames"};
406 static constexpr size_t s_tag_len{2};
407 static constexpr size_t s_cmd_len{2};
408 static constexpr size_t s_reply_len{1};
409 static constexpr const char* s_prototype{"bool yarpActionsPlayer_IDL::print_frames()"};
410 static constexpr const char* s_help{
411 "Prints all the frames of the currently selected action.\n"
412 "@return true/false on success/failure"
413 };
414};
415
416// speed_factor helper class declaration
418 public yarp::os::Portable
419{
420public:
422 explicit yarpActionsPlayer_IDL_speed_factor_helper(const double value);
423 bool write(yarp::os::ConnectionWriter& connection) const override;
424 bool read(yarp::os::ConnectionReader& connection) override;
425
426 class Command :
428 {
429 public:
430 Command() = default;
431 explicit Command(const double value);
432
433 ~Command() override = default;
434
435 bool write(yarp::os::ConnectionWriter& connection) const override;
436 bool read(yarp::os::ConnectionReader& connection) override;
437
438 bool write(const yarp::os::idl::WireWriter& writer) const override;
439 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
440 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
441
442 bool read(yarp::os::idl::WireReader& reader) override;
445
446 double value{0.0};
447 };
448
449 class Reply :
451 {
452 public:
453 Reply() = default;
454 ~Reply() override = default;
455
456 bool write(yarp::os::ConnectionWriter& connection) const override;
457 bool read(yarp::os::ConnectionReader& connection) override;
458
459 bool write(const yarp::os::idl::WireWriter& writer) const override;
460 bool read(yarp::os::idl::WireReader& reader) override;
461
462 bool return_helper{false};
463 };
464
465 using funcptr_t = bool (*)(const double);
466 void call(yarpActionsPlayer_IDL* ptr);
467
470
471 static constexpr const char* s_tag{"speed_factor"};
472 static constexpr size_t s_tag_len{2};
473 static constexpr size_t s_cmd_len{3};
474 static constexpr size_t s_reply_len{1};
475 static constexpr const char* s_prototype{"bool yarpActionsPlayer_IDL::speed_factor(const double value)"};
476 static constexpr const char* s_help{
477 "Sets the playback speed factor for the currently selected action (default value: 1.0).\n"
478 "@return true/false on success/failure"
479 };
480};
481
482// resample helper class declaration
484 public yarp::os::Portable
485{
486public:
488 explicit yarpActionsPlayer_IDL_resample_helper(const double value);
489 bool write(yarp::os::ConnectionWriter& connection) const override;
490 bool read(yarp::os::ConnectionReader& connection) override;
491
492 class Command :
494 {
495 public:
496 Command() = default;
497 explicit Command(const double value);
498
499 ~Command() override = default;
500
501 bool write(yarp::os::ConnectionWriter& connection) const override;
502 bool read(yarp::os::ConnectionReader& connection) override;
503
504 bool write(const yarp::os::idl::WireWriter& writer) const override;
505 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
506 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
507
508 bool read(yarp::os::idl::WireReader& reader) override;
511
512 double value{0.0};
513 };
514
515 class Reply :
517 {
518 public:
519 Reply() = default;
520 ~Reply() override = default;
521
522 bool write(yarp::os::ConnectionWriter& connection) const override;
523 bool read(yarp::os::ConnectionReader& connection) override;
524
525 bool write(const yarp::os::idl::WireWriter& writer) const override;
526 bool read(yarp::os::idl::WireReader& reader) override;
527
528 bool return_helper{false};
529 };
530
531 using funcptr_t = bool (*)(const double);
532 void call(yarpActionsPlayer_IDL* ptr);
533
536
537 static constexpr const char* s_tag{"resample"};
538 static constexpr size_t s_tag_len{1};
539 static constexpr size_t s_cmd_len{2};
540 static constexpr size_t s_reply_len{1};
541 static constexpr const char* s_prototype{"bool yarpActionsPlayer_IDL::resample(const double value)"};
542 static constexpr const char* s_help{
543 "Resamples the currently selected action (in seconds, recommended value 0.010s).\n"
544 "@return true/false on success/failure"
545 };
546};
547
548// choose_action helper class declaration
550 public yarp::os::Portable
551{
552public:
554 explicit yarpActionsPlayer_IDL_choose_action_helper(const std::string& action_name);
555 bool write(yarp::os::ConnectionWriter& connection) const override;
556 bool read(yarp::os::ConnectionReader& connection) override;
557
558 class Command :
560 {
561 public:
562 Command() = default;
563 explicit Command(const std::string& action_name);
564
565 ~Command() override = default;
566
567 bool write(yarp::os::ConnectionWriter& connection) const override;
568 bool read(yarp::os::ConnectionReader& connection) override;
569
570 bool write(const yarp::os::idl::WireWriter& writer) const override;
571 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
572 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
573
574 bool read(yarp::os::idl::WireReader& reader) override;
577
578 std::string action_name{};
579 };
580
581 class Reply :
583 {
584 public:
585 Reply() = default;
586 ~Reply() override = default;
587
588 bool write(yarp::os::ConnectionWriter& connection) const override;
589 bool read(yarp::os::ConnectionReader& connection) override;
590
591 bool write(const yarp::os::idl::WireWriter& writer) const override;
592 bool read(yarp::os::idl::WireReader& reader) override;
593
594 bool return_helper{false};
595 };
596
597 using funcptr_t = bool (*)(const std::string&);
598 void call(yarpActionsPlayer_IDL* ptr);
599
602
603 static constexpr const char* s_tag{"choose_action"};
604 static constexpr size_t s_tag_len{2};
605 static constexpr size_t s_cmd_len{3};
606 static constexpr size_t s_reply_len{1};
607 static constexpr const char* s_prototype{"bool yarpActionsPlayer_IDL::choose_action(const std::string& action_name)"};
608 static constexpr const char* s_help{
609 "Choose the current action and wait for further commands.\n"
610 "@return true/false on success/failure"
611 };
612};
613
614// play_action helper class declaration
616 public yarp::os::Portable
617{
618public:
620 explicit yarpActionsPlayer_IDL_play_action_helper(const std::string& action_name);
621 bool write(yarp::os::ConnectionWriter& connection) const override;
622 bool read(yarp::os::ConnectionReader& connection) override;
623
624 class Command :
626 {
627 public:
628 Command() = default;
629 explicit Command(const std::string& action_name);
630
631 ~Command() override = default;
632
633 bool write(yarp::os::ConnectionWriter& connection) const override;
634 bool read(yarp::os::ConnectionReader& connection) override;
635
636 bool write(const yarp::os::idl::WireWriter& writer) const override;
637 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
638 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
639
640 bool read(yarp::os::idl::WireReader& reader) override;
643
644 std::string action_name{};
645 };
646
647 class Reply :
649 {
650 public:
651 Reply() = default;
652 ~Reply() override = default;
653
654 bool write(yarp::os::ConnectionWriter& connection) const override;
655 bool read(yarp::os::ConnectionReader& connection) override;
656
657 bool write(const yarp::os::idl::WireWriter& writer) const override;
658 bool read(yarp::os::idl::WireReader& reader) override;
659
660 bool return_helper{false};
661 };
662
663 using funcptr_t = bool (*)(const std::string&);
664 void call(yarpActionsPlayer_IDL* ptr);
665
668
669 static constexpr const char* s_tag{"play_action"};
670 static constexpr size_t s_tag_len{2};
671 static constexpr size_t s_cmd_len{3};
672 static constexpr size_t s_reply_len{1};
673 static constexpr const char* s_prototype{"bool yarpActionsPlayer_IDL::play_action(const std::string& action_name)"};
674 static constexpr const char* s_help{
675 "Play an action one single time. The call blocks untils the playback is complete.\n"
676 "@return true/false on success/failure"
677 };
678};
679
680// show_actions helper class declaration
682 public yarp::os::Portable
683{
684public:
686 bool write(yarp::os::ConnectionWriter& connection) const override;
687 bool read(yarp::os::ConnectionReader& connection) override;
688
689 class Command :
691 {
692 public:
693 Command() = default;
694 ~Command() override = default;
695
696 bool write(yarp::os::ConnectionWriter& connection) const override;
697 bool read(yarp::os::ConnectionReader& connection) override;
698
699 bool write(const yarp::os::idl::WireWriter& writer) const override;
700 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
701 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
702
703 bool read(yarp::os::idl::WireReader& reader) override;
706 };
707
708 class Reply :
710 {
711 public:
712 Reply() = default;
713 ~Reply() override = default;
714
715 bool write(yarp::os::ConnectionWriter& connection) const override;
716 bool read(yarp::os::ConnectionReader& connection) override;
717
718 bool write(const yarp::os::idl::WireWriter& writer) const override;
719 bool read(yarp::os::idl::WireReader& reader) override;
720
721 bool return_helper{false};
722 };
723
724 using funcptr_t = bool (*)();
725 void call(yarpActionsPlayer_IDL* ptr);
726
729
730 static constexpr const char* s_tag{"show_actions"};
731 static constexpr size_t s_tag_len{2};
732 static constexpr size_t s_cmd_len{2};
733 static constexpr size_t s_reply_len{1};
734 static constexpr const char* s_prototype{"bool yarpActionsPlayer_IDL::show_actions()"};
735 static constexpr const char* s_help{
736 "Prints all the loaded actions.\n"
737 "@return true/false on success/failure"
738 };
739};
740
741// set_thread_period helper class declaration
743 public yarp::os::Portable
744{
745public:
747 explicit yarpActionsPlayer_IDL_set_thread_period_helper(const double value);
748 bool write(yarp::os::ConnectionWriter& connection) const override;
749 bool read(yarp::os::ConnectionReader& connection) override;
750
751 class Command :
753 {
754 public:
755 Command() = default;
756 explicit Command(const double value);
757
758 ~Command() override = default;
759
760 bool write(yarp::os::ConnectionWriter& connection) const override;
761 bool read(yarp::os::ConnectionReader& connection) override;
762
763 bool write(const yarp::os::idl::WireWriter& writer) const override;
764 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
765 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
766
767 bool read(yarp::os::idl::WireReader& reader) override;
770
771 double value{0.0};
772 };
773
774 class Reply :
776 {
777 public:
778 Reply() = default;
779 ~Reply() override = default;
780
781 bool write(yarp::os::ConnectionWriter& connection) const override;
782 bool read(yarp::os::ConnectionReader& connection) override;
783
784 bool write(const yarp::os::idl::WireWriter& writer) const override;
785 bool read(yarp::os::idl::WireReader& reader) override;
786
787 bool return_helper{false};
788 };
789
790 using funcptr_t = bool (*)(const double);
791 void call(yarpActionsPlayer_IDL* ptr);
792
795
796 static constexpr const char* s_tag{"set_thread_period"};
797 static constexpr size_t s_tag_len{3};
798 static constexpr size_t s_cmd_len{4};
799 static constexpr size_t s_reply_len{1};
800 static constexpr const char* s_prototype{"bool yarpActionsPlayer_IDL::set_thread_period(const double value)"};
801 static constexpr const char* s_help{
802 "Sets the period of the sampling thread (for advanced use only, default value: 0.010s).\n"
803 "@return true/false on success/failure"
804 };
805};
806
807// set_initial_move_time helper class declaration
809 public yarp::os::Portable
810{
811public:
813 explicit yarpActionsPlayer_IDL_set_initial_move_time_helper(const double value);
814 bool write(yarp::os::ConnectionWriter& connection) const override;
815 bool read(yarp::os::ConnectionReader& connection) override;
816
817 class Command :
819 {
820 public:
821 Command() = default;
822 explicit Command(const double value);
823
824 ~Command() override = default;
825
826 bool write(yarp::os::ConnectionWriter& connection) const override;
827 bool read(yarp::os::ConnectionReader& connection) override;
828
829 bool write(const yarp::os::idl::WireWriter& writer) const override;
830 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
831 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
832
833 bool read(yarp::os::idl::WireReader& reader) override;
836
837 double value{0.0};
838 };
839
840 class Reply :
842 {
843 public:
844 Reply() = default;
845 ~Reply() override = default;
846
847 bool write(yarp::os::ConnectionWriter& connection) const override;
848 bool read(yarp::os::ConnectionReader& connection) override;
849
850 bool write(const yarp::os::idl::WireWriter& writer) const override;
851 bool read(yarp::os::idl::WireReader& reader) override;
852
853 bool return_helper{false};
854 };
855
856 using funcptr_t = bool (*)(const double);
857 void call(yarpActionsPlayer_IDL* ptr);
858
861
862 static constexpr const char* s_tag{"set_initial_move_time"};
863 static constexpr size_t s_tag_len{4};
864 static constexpr size_t s_cmd_len{5};
865 static constexpr size_t s_reply_len{1};
866 static constexpr const char* s_prototype{"bool yarpActionsPlayer_IDL::set_initial_move_time(const double value)"};
867 static constexpr const char* s_help{
868 "Sets the uration for the initial homing movement (for advanced use only, default value: 2s).\n"
869 "@return true/false on success/failure"
870 };
871};
872
873// start helper class implementation
875{
876 return cmd.write(connection);
877}
878
880{
881 return reply.read(connection);
882}
883
885{
886 yarp::os::idl::WireWriter writer(connection);
887 if (!writer.writeListHeader(s_cmd_len)) {
888 return false;
889 }
890 return write(writer);
891}
892
894{
895 yarp::os::idl::WireReader reader(connection);
896 if (!reader.readListHeader()) {
897 reader.fail();
898 return false;
899 }
900 return read(reader);
901}
902
904{
905 if (!writeTag(writer)) {
906 return false;
907 }
908 if (!writeArgs(writer)) {
909 return false;
910 }
911 return true;
912}
913
915{
916 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
917 return false;
918 }
919 return true;
920}
921
923{
924 return true;
925}
926
928{
929 if (!readTag(reader)) {
930 return false;
931 }
932 if (!readArgs(reader)) {
933 return false;
934 }
935 return true;
936}
937
939{
940 std::string tag = reader.readTag(s_tag_len);
941 if (reader.isError()) {
942 return false;
943 }
944 if (tag != s_tag) {
945 reader.fail();
946 return false;
947 }
948 return true;
949}
950
952{
953 if (!reader.noMore()) {
954 reader.fail();
955 return false;
956 }
957 return true;
958}
959
961{
962 yarp::os::idl::WireWriter writer(connection);
963 return write(writer);
964}
965
967{
968 yarp::os::idl::WireReader reader(connection);
969 return read(reader);
970}
971
973{
974 if (!writer.isNull()) {
975 if (!writer.writeListHeader(s_reply_len)) {
976 return false;
977 }
978 if (!writer.writeBool(return_helper)) {
979 return false;
980 }
981 }
982 return true;
983}
984
986{
987 if (!reader.readListReturn()) {
988 return false;
989 }
990 if (reader.noMore()) {
991 reader.fail();
992 return false;
993 }
994 if (!reader.readBool(return_helper)) {
995 reader.fail();
996 return false;
997 }
998 return true;
999}
1000
1005
1006// stop helper class implementation
1008{
1009 return cmd.write(connection);
1010}
1011
1013{
1014 return reply.read(connection);
1015}
1016
1018{
1019 yarp::os::idl::WireWriter writer(connection);
1020 if (!writer.writeListHeader(s_cmd_len)) {
1021 return false;
1022 }
1023 return write(writer);
1024}
1025
1027{
1028 yarp::os::idl::WireReader reader(connection);
1029 if (!reader.readListHeader()) {
1030 reader.fail();
1031 return false;
1032 }
1033 return read(reader);
1034}
1035
1037{
1038 if (!writeTag(writer)) {
1039 return false;
1040 }
1041 if (!writeArgs(writer)) {
1042 return false;
1043 }
1044 return true;
1045}
1046
1048{
1049 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1050 return false;
1051 }
1052 return true;
1053}
1054
1056{
1057 return true;
1058}
1059
1061{
1062 if (!readTag(reader)) {
1063 return false;
1064 }
1065 if (!readArgs(reader)) {
1066 return false;
1067 }
1068 return true;
1069}
1070
1072{
1073 std::string tag = reader.readTag(s_tag_len);
1074 if (reader.isError()) {
1075 return false;
1076 }
1077 if (tag != s_tag) {
1078 reader.fail();
1079 return false;
1080 }
1081 return true;
1082}
1083
1085{
1086 if (!reader.noMore()) {
1087 reader.fail();
1088 return false;
1089 }
1090 return true;
1091}
1092
1094{
1095 yarp::os::idl::WireWriter writer(connection);
1096 return write(writer);
1097}
1098
1100{
1101 yarp::os::idl::WireReader reader(connection);
1102 return read(reader);
1103}
1104
1106{
1107 if (!writer.isNull()) {
1108 if (!writer.writeListHeader(s_reply_len)) {
1109 return false;
1110 }
1111 if (!writer.writeBool(return_helper)) {
1112 return false;
1113 }
1114 }
1115 return true;
1116}
1117
1119{
1120 if (!reader.readListReturn()) {
1121 return false;
1122 }
1123 if (reader.noMore()) {
1124 reader.fail();
1125 return false;
1126 }
1127 if (!reader.readBool(return_helper)) {
1128 reader.fail();
1129 return false;
1130 }
1131 return true;
1132}
1133
1138
1139// reset helper class implementation
1141{
1142 return cmd.write(connection);
1143}
1144
1146{
1147 return reply.read(connection);
1148}
1149
1151{
1152 yarp::os::idl::WireWriter writer(connection);
1153 if (!writer.writeListHeader(s_cmd_len)) {
1154 return false;
1155 }
1156 return write(writer);
1157}
1158
1160{
1161 yarp::os::idl::WireReader reader(connection);
1162 if (!reader.readListHeader()) {
1163 reader.fail();
1164 return false;
1165 }
1166 return read(reader);
1167}
1168
1170{
1171 if (!writeTag(writer)) {
1172 return false;
1173 }
1174 if (!writeArgs(writer)) {
1175 return false;
1176 }
1177 return true;
1178}
1179
1181{
1182 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1183 return false;
1184 }
1185 return true;
1186}
1187
1189{
1190 return true;
1191}
1192
1194{
1195 if (!readTag(reader)) {
1196 return false;
1197 }
1198 if (!readArgs(reader)) {
1199 return false;
1200 }
1201 return true;
1202}
1203
1205{
1206 std::string tag = reader.readTag(s_tag_len);
1207 if (reader.isError()) {
1208 return false;
1209 }
1210 if (tag != s_tag) {
1211 reader.fail();
1212 return false;
1213 }
1214 return true;
1215}
1216
1218{
1219 if (!reader.noMore()) {
1220 reader.fail();
1221 return false;
1222 }
1223 return true;
1224}
1225
1227{
1228 yarp::os::idl::WireWriter writer(connection);
1229 return write(writer);
1230}
1231
1233{
1234 yarp::os::idl::WireReader reader(connection);
1235 return read(reader);
1236}
1237
1239{
1240 if (!writer.isNull()) {
1241 if (!writer.writeListHeader(s_reply_len)) {
1242 return false;
1243 }
1244 if (!writer.writeBool(return_helper)) {
1245 return false;
1246 }
1247 }
1248 return true;
1249}
1250
1252{
1253 if (!reader.readListReturn()) {
1254 return false;
1255 }
1256 if (reader.noMore()) {
1257 reader.fail();
1258 return false;
1259 }
1260 if (!reader.readBool(return_helper)) {
1261 reader.fail();
1262 return false;
1263 }
1264 return true;
1265}
1266
1271
1272// forever helper class implementation
1274{
1275 return cmd.write(connection);
1276}
1277
1279{
1280 return reply.read(connection);
1281}
1282
1284{
1285 yarp::os::idl::WireWriter writer(connection);
1286 if (!writer.writeListHeader(s_cmd_len)) {
1287 return false;
1288 }
1289 return write(writer);
1290}
1291
1293{
1294 yarp::os::idl::WireReader reader(connection);
1295 if (!reader.readListHeader()) {
1296 reader.fail();
1297 return false;
1298 }
1299 return read(reader);
1300}
1301
1303{
1304 if (!writeTag(writer)) {
1305 return false;
1306 }
1307 if (!writeArgs(writer)) {
1308 return false;
1309 }
1310 return true;
1311}
1312
1314{
1315 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1316 return false;
1317 }
1318 return true;
1319}
1320
1322{
1323 return true;
1324}
1325
1327{
1328 if (!readTag(reader)) {
1329 return false;
1330 }
1331 if (!readArgs(reader)) {
1332 return false;
1333 }
1334 return true;
1335}
1336
1338{
1339 std::string tag = reader.readTag(s_tag_len);
1340 if (reader.isError()) {
1341 return false;
1342 }
1343 if (tag != s_tag) {
1344 reader.fail();
1345 return false;
1346 }
1347 return true;
1348}
1349
1351{
1352 if (!reader.noMore()) {
1353 reader.fail();
1354 return false;
1355 }
1356 return true;
1357}
1358
1360{
1361 yarp::os::idl::WireWriter writer(connection);
1362 return write(writer);
1363}
1364
1366{
1367 yarp::os::idl::WireReader reader(connection);
1368 return read(reader);
1369}
1370
1372{
1373 if (!writer.isNull()) {
1374 if (!writer.writeListHeader(s_reply_len)) {
1375 return false;
1376 }
1377 if (!writer.writeBool(return_helper)) {
1378 return false;
1379 }
1380 }
1381 return true;
1382}
1383
1385{
1386 if (!reader.readListReturn()) {
1387 return false;
1388 }
1389 if (reader.noMore()) {
1390 reader.fail();
1391 return false;
1392 }
1393 if (!reader.readBool(return_helper)) {
1394 reader.fail();
1395 return false;
1396 }
1397 return true;
1398}
1399
1404
1405// print_frames helper class implementation
1407{
1408 return cmd.write(connection);
1409}
1410
1412{
1413 return reply.read(connection);
1414}
1415
1417{
1418 yarp::os::idl::WireWriter writer(connection);
1419 if (!writer.writeListHeader(s_cmd_len)) {
1420 return false;
1421 }
1422 return write(writer);
1423}
1424
1426{
1427 yarp::os::idl::WireReader reader(connection);
1428 if (!reader.readListHeader()) {
1429 reader.fail();
1430 return false;
1431 }
1432 return read(reader);
1433}
1434
1436{
1437 if (!writeTag(writer)) {
1438 return false;
1439 }
1440 if (!writeArgs(writer)) {
1441 return false;
1442 }
1443 return true;
1444}
1445
1447{
1448 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1449 return false;
1450 }
1451 return true;
1452}
1453
1455{
1456 return true;
1457}
1458
1460{
1461 if (!readTag(reader)) {
1462 return false;
1463 }
1464 if (!readArgs(reader)) {
1465 return false;
1466 }
1467 return true;
1468}
1469
1471{
1472 std::string tag = reader.readTag(s_tag_len);
1473 if (reader.isError()) {
1474 return false;
1475 }
1476 if (tag != s_tag) {
1477 reader.fail();
1478 return false;
1479 }
1480 return true;
1481}
1482
1484{
1485 if (!reader.noMore()) {
1486 reader.fail();
1487 return false;
1488 }
1489 return true;
1490}
1491
1493{
1494 yarp::os::idl::WireWriter writer(connection);
1495 return write(writer);
1496}
1497
1499{
1500 yarp::os::idl::WireReader reader(connection);
1501 return read(reader);
1502}
1503
1505{
1506 if (!writer.isNull()) {
1507 if (!writer.writeListHeader(s_reply_len)) {
1508 return false;
1509 }
1510 if (!writer.writeBool(return_helper)) {
1511 return false;
1512 }
1513 }
1514 return true;
1515}
1516
1518{
1519 if (!reader.readListReturn()) {
1520 return false;
1521 }
1522 if (reader.noMore()) {
1523 reader.fail();
1524 return false;
1525 }
1526 if (!reader.readBool(return_helper)) {
1527 reader.fail();
1528 return false;
1529 }
1530 return true;
1531}
1532
1537
1538// speed_factor helper class implementation
1543
1545{
1546 return cmd.write(connection);
1547}
1548
1550{
1551 return reply.read(connection);
1552}
1553
1555 value{value}
1556{
1557}
1558
1560{
1561 yarp::os::idl::WireWriter writer(connection);
1562 if (!writer.writeListHeader(s_cmd_len)) {
1563 return false;
1564 }
1565 return write(writer);
1566}
1567
1569{
1570 yarp::os::idl::WireReader reader(connection);
1571 if (!reader.readListHeader()) {
1572 reader.fail();
1573 return false;
1574 }
1575 return read(reader);
1576}
1577
1579{
1580 if (!writeTag(writer)) {
1581 return false;
1582 }
1583 if (!writeArgs(writer)) {
1584 return false;
1585 }
1586 return true;
1587}
1588
1590{
1591 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1592 return false;
1593 }
1594 return true;
1595}
1596
1598{
1599 if (!writer.writeFloat64(value)) {
1600 return false;
1601 }
1602 return true;
1603}
1604
1606{
1607 if (!readTag(reader)) {
1608 return false;
1609 }
1610 if (!readArgs(reader)) {
1611 return false;
1612 }
1613 return true;
1614}
1615
1617{
1618 std::string tag = reader.readTag(s_tag_len);
1619 if (reader.isError()) {
1620 return false;
1621 }
1622 if (tag != s_tag) {
1623 reader.fail();
1624 return false;
1625 }
1626 return true;
1627}
1628
1630{
1631 if (reader.noMore()) {
1632 reader.fail();
1633 return false;
1634 }
1635 if (!reader.readFloat64(value)) {
1636 reader.fail();
1637 return false;
1638 }
1639 if (!reader.noMore()) {
1640 reader.fail();
1641 return false;
1642 }
1643 return true;
1644}
1645
1647{
1648 yarp::os::idl::WireWriter writer(connection);
1649 return write(writer);
1650}
1651
1653{
1654 yarp::os::idl::WireReader reader(connection);
1655 return read(reader);
1656}
1657
1659{
1660 if (!writer.isNull()) {
1661 if (!writer.writeListHeader(s_reply_len)) {
1662 return false;
1663 }
1664 if (!writer.writeBool(return_helper)) {
1665 return false;
1666 }
1667 }
1668 return true;
1669}
1670
1672{
1673 if (!reader.readListReturn()) {
1674 return false;
1675 }
1676 if (reader.noMore()) {
1677 reader.fail();
1678 return false;
1679 }
1680 if (!reader.readBool(return_helper)) {
1681 reader.fail();
1682 return false;
1683 }
1684 return true;
1685}
1686
1691
1692// resample helper class implementation
1697
1699{
1700 return cmd.write(connection);
1701}
1702
1704{
1705 return reply.read(connection);
1706}
1707
1709 value{value}
1710{
1711}
1712
1714{
1715 yarp::os::idl::WireWriter writer(connection);
1716 if (!writer.writeListHeader(s_cmd_len)) {
1717 return false;
1718 }
1719 return write(writer);
1720}
1721
1723{
1724 yarp::os::idl::WireReader reader(connection);
1725 if (!reader.readListHeader()) {
1726 reader.fail();
1727 return false;
1728 }
1729 return read(reader);
1730}
1731
1733{
1734 if (!writeTag(writer)) {
1735 return false;
1736 }
1737 if (!writeArgs(writer)) {
1738 return false;
1739 }
1740 return true;
1741}
1742
1744{
1745 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1746 return false;
1747 }
1748 return true;
1749}
1750
1752{
1753 if (!writer.writeFloat64(value)) {
1754 return false;
1755 }
1756 return true;
1757}
1758
1760{
1761 if (!readTag(reader)) {
1762 return false;
1763 }
1764 if (!readArgs(reader)) {
1765 return false;
1766 }
1767 return true;
1768}
1769
1771{
1772 std::string tag = reader.readTag(s_tag_len);
1773 if (reader.isError()) {
1774 return false;
1775 }
1776 if (tag != s_tag) {
1777 reader.fail();
1778 return false;
1779 }
1780 return true;
1781}
1782
1784{
1785 if (reader.noMore()) {
1786 reader.fail();
1787 return false;
1788 }
1789 if (!reader.readFloat64(value)) {
1790 reader.fail();
1791 return false;
1792 }
1793 if (!reader.noMore()) {
1794 reader.fail();
1795 return false;
1796 }
1797 return true;
1798}
1799
1801{
1802 yarp::os::idl::WireWriter writer(connection);
1803 return write(writer);
1804}
1805
1807{
1808 yarp::os::idl::WireReader reader(connection);
1809 return read(reader);
1810}
1811
1813{
1814 if (!writer.isNull()) {
1815 if (!writer.writeListHeader(s_reply_len)) {
1816 return false;
1817 }
1818 if (!writer.writeBool(return_helper)) {
1819 return false;
1820 }
1821 }
1822 return true;
1823}
1824
1826{
1827 if (!reader.readListReturn()) {
1828 return false;
1829 }
1830 if (reader.noMore()) {
1831 reader.fail();
1832 return false;
1833 }
1834 if (!reader.readBool(return_helper)) {
1835 reader.fail();
1836 return false;
1837 }
1838 return true;
1839}
1840
1845
1846// choose_action helper class implementation
1848 cmd{action_name}
1849{
1850}
1851
1853{
1854 return cmd.write(connection);
1855}
1856
1858{
1859 return reply.read(connection);
1860}
1861
1863 action_name{action_name}
1864{
1865}
1866
1868{
1869 yarp::os::idl::WireWriter writer(connection);
1870 if (!writer.writeListHeader(s_cmd_len)) {
1871 return false;
1872 }
1873 return write(writer);
1874}
1875
1877{
1878 yarp::os::idl::WireReader reader(connection);
1879 if (!reader.readListHeader()) {
1880 reader.fail();
1881 return false;
1882 }
1883 return read(reader);
1884}
1885
1887{
1888 if (!writeTag(writer)) {
1889 return false;
1890 }
1891 if (!writeArgs(writer)) {
1892 return false;
1893 }
1894 return true;
1895}
1896
1898{
1899 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1900 return false;
1901 }
1902 return true;
1903}
1904
1906{
1907 if (!writer.writeString(action_name)) {
1908 return false;
1909 }
1910 return true;
1911}
1912
1914{
1915 if (!readTag(reader)) {
1916 return false;
1917 }
1918 if (!readArgs(reader)) {
1919 return false;
1920 }
1921 return true;
1922}
1923
1925{
1926 std::string tag = reader.readTag(s_tag_len);
1927 if (reader.isError()) {
1928 return false;
1929 }
1930 if (tag != s_tag) {
1931 reader.fail();
1932 return false;
1933 }
1934 return true;
1935}
1936
1938{
1939 if (reader.noMore()) {
1940 reader.fail();
1941 return false;
1942 }
1943 if (!reader.readString(action_name)) {
1944 reader.fail();
1945 return false;
1946 }
1947 if (!reader.noMore()) {
1948 reader.fail();
1949 return false;
1950 }
1951 return true;
1952}
1953
1955{
1956 yarp::os::idl::WireWriter writer(connection);
1957 return write(writer);
1958}
1959
1961{
1962 yarp::os::idl::WireReader reader(connection);
1963 return read(reader);
1964}
1965
1967{
1968 if (!writer.isNull()) {
1969 if (!writer.writeListHeader(s_reply_len)) {
1970 return false;
1971 }
1972 if (!writer.writeBool(return_helper)) {
1973 return false;
1974 }
1975 }
1976 return true;
1977}
1978
1980{
1981 if (!reader.readListReturn()) {
1982 return false;
1983 }
1984 if (reader.noMore()) {
1985 reader.fail();
1986 return false;
1987 }
1988 if (!reader.readBool(return_helper)) {
1989 reader.fail();
1990 return false;
1991 }
1992 return true;
1993}
1994
1999
2000// play_action helper class implementation
2002 cmd{action_name}
2003{
2004}
2005
2007{
2008 return cmd.write(connection);
2009}
2010
2012{
2013 return reply.read(connection);
2014}
2015
2017 action_name{action_name}
2018{
2019}
2020
2022{
2023 yarp::os::idl::WireWriter writer(connection);
2024 if (!writer.writeListHeader(s_cmd_len)) {
2025 return false;
2026 }
2027 return write(writer);
2028}
2029
2031{
2032 yarp::os::idl::WireReader reader(connection);
2033 if (!reader.readListHeader()) {
2034 reader.fail();
2035 return false;
2036 }
2037 return read(reader);
2038}
2039
2041{
2042 if (!writeTag(writer)) {
2043 return false;
2044 }
2045 if (!writeArgs(writer)) {
2046 return false;
2047 }
2048 return true;
2049}
2050
2052{
2053 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2054 return false;
2055 }
2056 return true;
2057}
2058
2060{
2061 if (!writer.writeString(action_name)) {
2062 return false;
2063 }
2064 return true;
2065}
2066
2068{
2069 if (!readTag(reader)) {
2070 return false;
2071 }
2072 if (!readArgs(reader)) {
2073 return false;
2074 }
2075 return true;
2076}
2077
2079{
2080 std::string tag = reader.readTag(s_tag_len);
2081 if (reader.isError()) {
2082 return false;
2083 }
2084 if (tag != s_tag) {
2085 reader.fail();
2086 return false;
2087 }
2088 return true;
2089}
2090
2092{
2093 if (reader.noMore()) {
2094 reader.fail();
2095 return false;
2096 }
2097 if (!reader.readString(action_name)) {
2098 reader.fail();
2099 return false;
2100 }
2101 if (!reader.noMore()) {
2102 reader.fail();
2103 return false;
2104 }
2105 return true;
2106}
2107
2109{
2110 yarp::os::idl::WireWriter writer(connection);
2111 return write(writer);
2112}
2113
2115{
2116 yarp::os::idl::WireReader reader(connection);
2117 return read(reader);
2118}
2119
2121{
2122 if (!writer.isNull()) {
2123 if (!writer.writeListHeader(s_reply_len)) {
2124 return false;
2125 }
2126 if (!writer.writeBool(return_helper)) {
2127 return false;
2128 }
2129 }
2130 return true;
2131}
2132
2134{
2135 if (!reader.readListReturn()) {
2136 return false;
2137 }
2138 if (reader.noMore()) {
2139 reader.fail();
2140 return false;
2141 }
2142 if (!reader.readBool(return_helper)) {
2143 reader.fail();
2144 return false;
2145 }
2146 return true;
2147}
2148
2153
2154// show_actions helper class implementation
2156{
2157 return cmd.write(connection);
2158}
2159
2161{
2162 return reply.read(connection);
2163}
2164
2166{
2167 yarp::os::idl::WireWriter writer(connection);
2168 if (!writer.writeListHeader(s_cmd_len)) {
2169 return false;
2170 }
2171 return write(writer);
2172}
2173
2175{
2176 yarp::os::idl::WireReader reader(connection);
2177 if (!reader.readListHeader()) {
2178 reader.fail();
2179 return false;
2180 }
2181 return read(reader);
2182}
2183
2185{
2186 if (!writeTag(writer)) {
2187 return false;
2188 }
2189 if (!writeArgs(writer)) {
2190 return false;
2191 }
2192 return true;
2193}
2194
2196{
2197 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2198 return false;
2199 }
2200 return true;
2201}
2202
2204{
2205 return true;
2206}
2207
2209{
2210 if (!readTag(reader)) {
2211 return false;
2212 }
2213 if (!readArgs(reader)) {
2214 return false;
2215 }
2216 return true;
2217}
2218
2220{
2221 std::string tag = reader.readTag(s_tag_len);
2222 if (reader.isError()) {
2223 return false;
2224 }
2225 if (tag != s_tag) {
2226 reader.fail();
2227 return false;
2228 }
2229 return true;
2230}
2231
2233{
2234 if (!reader.noMore()) {
2235 reader.fail();
2236 return false;
2237 }
2238 return true;
2239}
2240
2242{
2243 yarp::os::idl::WireWriter writer(connection);
2244 return write(writer);
2245}
2246
2248{
2249 yarp::os::idl::WireReader reader(connection);
2250 return read(reader);
2251}
2252
2254{
2255 if (!writer.isNull()) {
2256 if (!writer.writeListHeader(s_reply_len)) {
2257 return false;
2258 }
2259 if (!writer.writeBool(return_helper)) {
2260 return false;
2261 }
2262 }
2263 return true;
2264}
2265
2267{
2268 if (!reader.readListReturn()) {
2269 return false;
2270 }
2271 if (reader.noMore()) {
2272 reader.fail();
2273 return false;
2274 }
2275 if (!reader.readBool(return_helper)) {
2276 reader.fail();
2277 return false;
2278 }
2279 return true;
2280}
2281
2286
2287// set_thread_period helper class implementation
2292
2294{
2295 return cmd.write(connection);
2296}
2297
2302
2304 value{value}
2305{
2306}
2307
2309{
2310 yarp::os::idl::WireWriter writer(connection);
2311 if (!writer.writeListHeader(s_cmd_len)) {
2312 return false;
2313 }
2314 return write(writer);
2315}
2316
2318{
2319 yarp::os::idl::WireReader reader(connection);
2320 if (!reader.readListHeader()) {
2321 reader.fail();
2322 return false;
2323 }
2324 return read(reader);
2325}
2326
2328{
2329 if (!writeTag(writer)) {
2330 return false;
2331 }
2332 if (!writeArgs(writer)) {
2333 return false;
2334 }
2335 return true;
2336}
2337
2339{
2340 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2341 return false;
2342 }
2343 return true;
2344}
2345
2347{
2348 if (!writer.writeFloat64(value)) {
2349 return false;
2350 }
2351 return true;
2352}
2353
2355{
2356 if (!readTag(reader)) {
2357 return false;
2358 }
2359 if (!readArgs(reader)) {
2360 return false;
2361 }
2362 return true;
2363}
2364
2366{
2367 std::string tag = reader.readTag(s_tag_len);
2368 if (reader.isError()) {
2369 return false;
2370 }
2371 if (tag != s_tag) {
2372 reader.fail();
2373 return false;
2374 }
2375 return true;
2376}
2377
2379{
2380 if (reader.noMore()) {
2381 reader.fail();
2382 return false;
2383 }
2384 if (!reader.readFloat64(value)) {
2385 reader.fail();
2386 return false;
2387 }
2388 if (!reader.noMore()) {
2389 reader.fail();
2390 return false;
2391 }
2392 return true;
2393}
2394
2396{
2397 yarp::os::idl::WireWriter writer(connection);
2398 return write(writer);
2399}
2400
2402{
2403 yarp::os::idl::WireReader reader(connection);
2404 return read(reader);
2405}
2406
2408{
2409 if (!writer.isNull()) {
2410 if (!writer.writeListHeader(s_reply_len)) {
2411 return false;
2412 }
2413 if (!writer.writeBool(return_helper)) {
2414 return false;
2415 }
2416 }
2417 return true;
2418}
2419
2421{
2422 if (!reader.readListReturn()) {
2423 return false;
2424 }
2425 if (reader.noMore()) {
2426 reader.fail();
2427 return false;
2428 }
2429 if (!reader.readBool(return_helper)) {
2430 reader.fail();
2431 return false;
2432 }
2433 return true;
2434}
2435
2440
2441// set_initial_move_time helper class implementation
2446
2448{
2449 return cmd.write(connection);
2450}
2451
2456
2458 value{value}
2459{
2460}
2461
2463{
2464 yarp::os::idl::WireWriter writer(connection);
2465 if (!writer.writeListHeader(s_cmd_len)) {
2466 return false;
2467 }
2468 return write(writer);
2469}
2470
2472{
2473 yarp::os::idl::WireReader reader(connection);
2474 if (!reader.readListHeader()) {
2475 reader.fail();
2476 return false;
2477 }
2478 return read(reader);
2479}
2480
2482{
2483 if (!writeTag(writer)) {
2484 return false;
2485 }
2486 if (!writeArgs(writer)) {
2487 return false;
2488 }
2489 return true;
2490}
2491
2493{
2494 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2495 return false;
2496 }
2497 return true;
2498}
2499
2501{
2502 if (!writer.writeFloat64(value)) {
2503 return false;
2504 }
2505 return true;
2506}
2507
2509{
2510 if (!readTag(reader)) {
2511 return false;
2512 }
2513 if (!readArgs(reader)) {
2514 return false;
2515 }
2516 return true;
2517}
2518
2520{
2521 std::string tag = reader.readTag(s_tag_len);
2522 if (reader.isError()) {
2523 return false;
2524 }
2525 if (tag != s_tag) {
2526 reader.fail();
2527 return false;
2528 }
2529 return true;
2530}
2531
2533{
2534 if (reader.noMore()) {
2535 reader.fail();
2536 return false;
2537 }
2538 if (!reader.readFloat64(value)) {
2539 reader.fail();
2540 return false;
2541 }
2542 if (!reader.noMore()) {
2543 reader.fail();
2544 return false;
2545 }
2546 return true;
2547}
2548
2550{
2551 yarp::os::idl::WireWriter writer(connection);
2552 return write(writer);
2553}
2554
2560
2562{
2563 if (!writer.isNull()) {
2564 if (!writer.writeListHeader(s_reply_len)) {
2565 return false;
2566 }
2567 if (!writer.writeBool(return_helper)) {
2568 return false;
2569 }
2570 }
2571 return true;
2572}
2573
2575{
2576 if (!reader.readListReturn()) {
2577 return false;
2578 }
2579 if (reader.noMore()) {
2580 reader.fail();
2581 return false;
2582 }
2583 if (!reader.readBool(return_helper)) {
2584 reader.fail();
2585 return false;
2586 }
2587 return true;
2588}
2589
2594
2595// Constructor
2597{
2598 yarp().setOwner(*this);
2599}
2600
2602{
2603 if (!yarp().canWrite()) {
2604 yError("Missing server method '%s'?", yarpActionsPlayer_IDL_start_helper::s_prototype);
2605 }
2607 bool ok = yarp().write(helper, helper);
2608 return ok ? helper.reply.return_helper : bool{};
2609}
2610
2612{
2613 if (!yarp().canWrite()) {
2614 yError("Missing server method '%s'?", yarpActionsPlayer_IDL_stop_helper::s_prototype);
2615 }
2617 bool ok = yarp().write(helper, helper);
2618 return ok ? helper.reply.return_helper : bool{};
2619}
2620
2622{
2623 if (!yarp().canWrite()) {
2624 yError("Missing server method '%s'?", yarpActionsPlayer_IDL_reset_helper::s_prototype);
2625 }
2627 bool ok = yarp().write(helper, helper);
2628 return ok ? helper.reply.return_helper : bool{};
2629}
2630
2632{
2633 if (!yarp().canWrite()) {
2634 yError("Missing server method '%s'?", yarpActionsPlayer_IDL_forever_helper::s_prototype);
2635 }
2637 bool ok = yarp().write(helper, helper);
2638 return ok ? helper.reply.return_helper : bool{};
2639}
2640
2642{
2643 if (!yarp().canWrite()) {
2644 yError("Missing server method '%s'?", yarpActionsPlayer_IDL_print_frames_helper::s_prototype);
2645 }
2647 bool ok = yarp().write(helper, helper);
2648 return ok ? helper.reply.return_helper : bool{};
2649}
2650
2652{
2653 if (!yarp().canWrite()) {
2654 yError("Missing server method '%s'?", yarpActionsPlayer_IDL_speed_factor_helper::s_prototype);
2655 }
2657 bool ok = yarp().write(helper, helper);
2658 return ok ? helper.reply.return_helper : bool{};
2659}
2660
2661bool yarpActionsPlayer_IDL::resample(const double value)
2662{
2663 if (!yarp().canWrite()) {
2664 yError("Missing server method '%s'?", yarpActionsPlayer_IDL_resample_helper::s_prototype);
2665 }
2667 bool ok = yarp().write(helper, helper);
2668 return ok ? helper.reply.return_helper : bool{};
2669}
2670
2671bool yarpActionsPlayer_IDL::choose_action(const std::string& action_name)
2672{
2673 if (!yarp().canWrite()) {
2675 }
2677 bool ok = yarp().write(helper, helper);
2678 return ok ? helper.reply.return_helper : bool{};
2679}
2680
2681bool yarpActionsPlayer_IDL::play_action(const std::string& action_name)
2682{
2683 if (!yarp().canWrite()) {
2684 yError("Missing server method '%s'?", yarpActionsPlayer_IDL_play_action_helper::s_prototype);
2685 }
2686 yarpActionsPlayer_IDL_play_action_helper helper{action_name};
2687 bool ok = yarp().write(helper, helper);
2688 return ok ? helper.reply.return_helper : bool{};
2689}
2690
2692{
2693 if (!yarp().canWrite()) {
2694 yError("Missing server method '%s'?", yarpActionsPlayer_IDL_show_actions_helper::s_prototype);
2695 }
2697 bool ok = yarp().write(helper, helper);
2698 return ok ? helper.reply.return_helper : bool{};
2699}
2700
2702{
2703 if (!yarp().canWrite()) {
2705 }
2707 bool ok = yarp().write(helper, helper);
2708 return ok ? helper.reply.return_helper : bool{};
2709}
2710
2712{
2713 if (!yarp().canWrite()) {
2715 }
2717 bool ok = yarp().write(helper, helper);
2718 return ok ? helper.reply.return_helper : bool{};
2719}
2720
2721// help method
2722std::vector<std::string> yarpActionsPlayer_IDL::help(const std::string& functionName)
2723{
2724 bool showAll = (functionName == "--all");
2725 std::vector<std::string> helpString;
2726 if (showAll) {
2727 helpString.emplace_back("*** Available commands:");
2728 helpString.emplace_back(yarpActionsPlayer_IDL_start_helper::s_tag);
2729 helpString.emplace_back(yarpActionsPlayer_IDL_stop_helper::s_tag);
2730 helpString.emplace_back(yarpActionsPlayer_IDL_reset_helper::s_tag);
2731 helpString.emplace_back(yarpActionsPlayer_IDL_forever_helper::s_tag);
2732 helpString.emplace_back(yarpActionsPlayer_IDL_print_frames_helper::s_tag);
2733 helpString.emplace_back(yarpActionsPlayer_IDL_speed_factor_helper::s_tag);
2734 helpString.emplace_back(yarpActionsPlayer_IDL_resample_helper::s_tag);
2736 helpString.emplace_back(yarpActionsPlayer_IDL_play_action_helper::s_tag);
2737 helpString.emplace_back(yarpActionsPlayer_IDL_show_actions_helper::s_tag);
2740 helpString.emplace_back("help");
2741 } else {
2742 if (functionName == yarpActionsPlayer_IDL_start_helper::s_tag) {
2743 helpString.emplace_back(yarpActionsPlayer_IDL_start_helper::s_prototype);
2744 helpString.emplace_back(yarpActionsPlayer_IDL_start_helper::s_help);
2745 }
2746 if (functionName == yarpActionsPlayer_IDL_stop_helper::s_tag) {
2747 helpString.emplace_back(yarpActionsPlayer_IDL_stop_helper::s_prototype);
2748 helpString.emplace_back(yarpActionsPlayer_IDL_stop_helper::s_help);
2749 }
2750 if (functionName == yarpActionsPlayer_IDL_reset_helper::s_tag) {
2751 helpString.emplace_back(yarpActionsPlayer_IDL_reset_helper::s_prototype);
2752 helpString.emplace_back(yarpActionsPlayer_IDL_reset_helper::s_help);
2753 }
2754 if (functionName == yarpActionsPlayer_IDL_forever_helper::s_tag) {
2756 helpString.emplace_back(yarpActionsPlayer_IDL_forever_helper::s_help);
2757 }
2761 }
2765 }
2768 helpString.emplace_back(yarpActionsPlayer_IDL_resample_helper::s_help);
2769 }
2773 }
2776 helpString.emplace_back(yarpActionsPlayer_IDL_play_action_helper::s_help);
2777 }
2781 }
2785 }
2789 }
2790 if (functionName == "help") {
2791 helpString.emplace_back("std::vector<std::string> help(const std::string& functionName = \"--all\")");
2792 helpString.emplace_back("Return list of available commands, or help message for a specific function");
2793 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");
2794 helpString.emplace_back("@return list of strings (one string per line)");
2795 }
2796 }
2797 if (helpString.empty()) {
2798 helpString.emplace_back("Command not found");
2799 }
2800 return helpString;
2801}
2802
2803// read from ConnectionReader
2805{
2806 constexpr size_t max_tag_len = 4;
2807 size_t tag_len = 1;
2808
2809 yarp::os::idl::WireReader reader(connection);
2810 reader.expectAccept();
2811 if (!reader.readListHeader()) {
2812 reader.fail();
2813 return false;
2814 }
2815
2816 std::string tag = reader.readTag(1);
2817 bool direct = (tag == "__direct__");
2818 if (direct) {
2819 tag = reader.readTag(1);
2820 }
2821 while (tag_len <= max_tag_len && !reader.isError()) {
2822 if(tag == "getRemoteProtocolVersion") {
2823 if (!reader.noMore()) {
2824 yError("Reader invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
2825 reader.fail();
2826 return false;
2827 }
2828
2829 auto proto = getLocalProtocolVersion();
2830
2831 yarp::os::idl::WireWriter writer(reader);
2832 if (!writer.writeListHeader(1)) {
2833 yWarning("Writer invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
2834 return false;}
2835 if (!writer.write(proto)) {
2836 yWarning("Writer invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
2837 return false;
2838 }
2839 reader.accept();
2840 return true;
2841 }
2844 if (!helper.cmd.readArgs(reader)) {
2845 return false;
2846 }
2847
2848 helper.call(this);
2849
2850 yarp::os::idl::WireWriter writer(reader);
2851 if (!helper.reply.write(writer)) {
2852 return false;
2853 }
2854 reader.accept();
2855 return true;
2856 }
2859 if (!helper.cmd.readArgs(reader)) {
2860 return false;
2861 }
2862
2863 helper.call(this);
2864
2865 yarp::os::idl::WireWriter writer(reader);
2866 if (!helper.reply.write(writer)) {
2867 return false;
2868 }
2869 reader.accept();
2870 return true;
2871 }
2874 if (!helper.cmd.readArgs(reader)) {
2875 return false;
2876 }
2877
2878 helper.call(this);
2879
2880 yarp::os::idl::WireWriter writer(reader);
2881 if (!helper.reply.write(writer)) {
2882 return false;
2883 }
2884 reader.accept();
2885 return true;
2886 }
2889 if (!helper.cmd.readArgs(reader)) {
2890 return false;
2891 }
2892
2893 helper.call(this);
2894
2895 yarp::os::idl::WireWriter writer(reader);
2896 if (!helper.reply.write(writer)) {
2897 return false;
2898 }
2899 reader.accept();
2900 return true;
2901 }
2904 if (!helper.cmd.readArgs(reader)) {
2905 return false;
2906 }
2907
2908 helper.call(this);
2909
2910 yarp::os::idl::WireWriter writer(reader);
2911 if (!helper.reply.write(writer)) {
2912 return false;
2913 }
2914 reader.accept();
2915 return true;
2916 }
2919 if (!helper.cmd.readArgs(reader)) {
2920 return false;
2921 }
2922
2923 helper.call(this);
2924
2925 yarp::os::idl::WireWriter writer(reader);
2926 if (!helper.reply.write(writer)) {
2927 return false;
2928 }
2929 reader.accept();
2930 return true;
2931 }
2934 if (!helper.cmd.readArgs(reader)) {
2935 return false;
2936 }
2937
2938 helper.call(this);
2939
2940 yarp::os::idl::WireWriter writer(reader);
2941 if (!helper.reply.write(writer)) {
2942 return false;
2943 }
2944 reader.accept();
2945 return true;
2946 }
2949 if (!helper.cmd.readArgs(reader)) {
2950 return false;
2951 }
2952
2953 helper.call(this);
2954
2955 yarp::os::idl::WireWriter writer(reader);
2956 if (!helper.reply.write(writer)) {
2957 return false;
2958 }
2959 reader.accept();
2960 return true;
2961 }
2964 if (!helper.cmd.readArgs(reader)) {
2965 return false;
2966 }
2967
2968 helper.call(this);
2969
2970 yarp::os::idl::WireWriter writer(reader);
2971 if (!helper.reply.write(writer)) {
2972 return false;
2973 }
2974 reader.accept();
2975 return true;
2976 }
2979 if (!helper.cmd.readArgs(reader)) {
2980 return false;
2981 }
2982
2983 helper.call(this);
2984
2985 yarp::os::idl::WireWriter writer(reader);
2986 if (!helper.reply.write(writer)) {
2987 return false;
2988 }
2989 reader.accept();
2990 return true;
2991 }
2994 if (!helper.cmd.readArgs(reader)) {
2995 return false;
2996 }
2997
2998 helper.call(this);
2999
3000 yarp::os::idl::WireWriter writer(reader);
3001 if (!helper.reply.write(writer)) {
3002 return false;
3003 }
3004 reader.accept();
3005 return true;
3006 }
3009 if (!helper.cmd.readArgs(reader)) {
3010 return false;
3011 }
3012
3013 helper.call(this);
3014
3015 yarp::os::idl::WireWriter writer(reader);
3016 if (!helper.reply.write(writer)) {
3017 return false;
3018 }
3019 reader.accept();
3020 return true;
3021 }
3022 if (tag == "help") {
3023 std::string functionName;
3024 if (!reader.readString(functionName)) {
3025 functionName = "--all";
3026 }
3027 auto help_strings = help(functionName);
3028 yarp::os::idl::WireWriter writer(reader);
3029 if (!writer.isNull()) {
3030 if (!writer.writeListHeader(2)) {
3031 return false;
3032 }
3033 if (!writer.writeTag("many", 1, 0)) {
3034 return false;
3035 }
3036 if (!writer.writeListBegin(0, help_strings.size())) {
3037 return false;
3038 }
3039 for (const auto& help_string : help_strings) {
3040 if (!writer.writeString(help_string)) {
3041 return false;
3042 }
3043 }
3044 if (!writer.writeListEnd()) {
3045 return false;
3046 }
3047 }
3048 reader.accept();
3049 return true;
3050 }
3051 if (reader.noMore()) {
3052 reader.fail();
3053 return false;
3054 }
3055 std::string next_tag = reader.readTag(1);
3056 if (next_tag.empty()) {
3057 break;
3058 }
3059 tag.append("_").append(next_tag);
3060 tag_len = std::count(tag.begin(), tag.end(), '_') + 1;
3061 }
3062 return false;
3063}
#define yError(...)
Definition Log.h:361
#define __YFUNCTION__
Definition Log.h:24
#define yWarning(...)
Definition Log.h:340
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool readArgs(yarp::os::idl::WireReader &reader)
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool readTag(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_prototype
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
void call(yarpActionsPlayer_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.
yarp::os::ApplicationNetworkProtocolVersion helper_proto
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 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 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 write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool readTag(yarp::os::idl::WireReader &reader)
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool readArgs(yarp::os::idl::WireReader &reader)
bool 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 writeTag(const yarp::os::idl::WireWriter &writer) const
bool readTag(yarp::os::idl::WireReader &reader)
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool readArgs(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_prototype
void call(yarpActionsPlayer_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 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 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 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 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 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 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 readTag(yarp::os::idl::WireReader &reader)
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool readArgs(yarp::os::idl::WireReader &reader)
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_prototype
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
void call(yarpActionsPlayer_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 readTag(yarp::os::idl::WireReader &reader)
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool readArgs(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_tag
static constexpr const char * s_prototype
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_help
void call(yarpActionsPlayer_IDL *ptr)
yarpActionsPlayer_IDL Interface.
virtual bool show_actions()
Prints all the loaded actions.
virtual bool choose_action(const std::string &action_name)
Choose the current action and wait for further commands.
virtual std::vector< std::string > help(const std::string &functionName="--all")
virtual bool play_action(const std::string &action_name)
Play an action one single time.
virtual bool set_initial_move_time(const double value)
Sets the uration for the initial homing movement (for advanced use only, default value: 2s).
virtual bool start()
Start (or resumes, if stopped) the currently selected action.
virtual bool forever()
Similar to play, but it will automatically restart the playback when the last frame is reached.
virtual bool print_frames()
Prints all the frames of the currently selected action.
virtual bool resample(const double value)
Resamples the currently selected action (in seconds, recommended value 0.010s).
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
virtual bool speed_factor(const double value)
Sets the playback speed factor for the currently selected action (default value: 1....
virtual bool stop()
Stops the currently selected (running) action.
virtual yarp::os::ApplicationNetworkProtocolVersion getRemoteProtocolVersion()
virtual bool reset()
Rewinds the currently selected action.
virtual yarp::os::ApplicationNetworkProtocolVersion getLocalProtocolVersion()
virtual bool set_thread_period(const double value)
Sets the period of the sampling thread (for advanced use only, default value: 0.010s).
An interface for reading from a network connection.
An interface for writing to a network connection.
This is a base class for objects that can be both read from and be written to the YARP network.
Definition Portable.h:25
yarp::os::WireLink & yarp()
Get YARP state associated with this object.
Definition Wire.h:28
A "tamed" Portable, that promises to serialize itself in an IDL-friendly way.
IDL-friendly connection reader.
Definition WireReader.h:27
bool readString(std::string &str, bool *is_vocab=nullptr)
std::string readTag(size_t len=static_cast< size_t >(-1))
bool readFloat64(yarp::conf::float64_t &x)
IDL-friendly connection writer.
Definition WireWriter.h:28
bool writeBool(bool x, bool skip_tag=false) const
bool write(const WirePortable &obj) 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
#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