YARP
Yet Another Robot Platform
 
Loading...
Searching...
No Matches
INavigation2DMsgs.cpp
Go to the documentation of this file.
1/*
2 * SPDX-FileCopyrightText: 2006-2021 Istituto Italiano di Tecnologia (IIT)
3 * SPDX-License-Identifier: BSD-3-Clause
4 */
5
6// Autogenerated by Thrift (based on compiler 0.14.1-yarped)
7// yarpidl_thrift version 2.0 - 11/11/2026
8// Protocol version: protocol_version=0, yarp_major=4, yarp_minor=0, yarp_patch=2
9// This is an automatically generated file.
10// It could get re-generated if the ALLOW_IDL_GENERATION flag is on.
11
12#include <yarp/conf/version.h>
13#include <INavigation2DMsgs.h>
15#include <yarp/os/LogStream.h>
16
18
19#include <algorithm>
20
21namespace
22{
23 YARP_LOG_COMPONENT(SERVICE_LOG_COMPONENT, "INavigation2DMsgs")
24}
25
26//INavigation2DMsgs_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 INavigation2DMsgs_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 INavigation2DMsgs::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// stop_navigation_RPC 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
151 };
152
154 void call(INavigation2DMsgs* ptr);
155
158
159 static constexpr const char* s_tag{"stop_navigation_RPC"};
160 static constexpr size_t s_tag_len{3};
161 static constexpr size_t s_cmd_len{3};
162 static constexpr size_t s_reply_len{1};
163 static constexpr const char* s_prototype{"yarp::dev::ReturnValue INavigation2DMsgs::stop_navigation_RPC()"};
164 static constexpr const char* s_help{""};
165};
166
167// resume_navigation_RPC helper class declaration
169 public yarp::os::Portable
170{
171public:
173 bool write(yarp::os::ConnectionWriter& connection) const override;
174 bool read(yarp::os::ConnectionReader& connection) override;
175
176 class Command :
178 {
179 public:
180 Command() = default;
181 ~Command() override = default;
182
183 bool write(yarp::os::ConnectionWriter& connection) const override;
184 bool read(yarp::os::ConnectionReader& connection) override;
185
186 bool write(const yarp::os::idl::WireWriter& writer) const override;
187 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
188 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
189
190 bool read(yarp::os::idl::WireReader& reader) override;
193 };
194
195 class Reply :
197 {
198 public:
199 Reply() = default;
200 ~Reply() override = default;
201
202 bool write(yarp::os::ConnectionWriter& connection) const override;
203 bool read(yarp::os::ConnectionReader& connection) override;
204
205 bool write(const yarp::os::idl::WireWriter& writer) const override;
206 bool read(yarp::os::idl::WireReader& reader) override;
207
209 };
210
212 void call(INavigation2DMsgs* ptr);
213
216
217 static constexpr const char* s_tag{"resume_navigation_RPC"};
218 static constexpr size_t s_tag_len{3};
219 static constexpr size_t s_cmd_len{3};
220 static constexpr size_t s_reply_len{1};
221 static constexpr const char* s_prototype{"yarp::dev::ReturnValue INavigation2DMsgs::resume_navigation_RPC()"};
222 static constexpr const char* s_help{""};
223};
224
225// suspend_navigation_RPC helper class declaration
227 public yarp::os::Portable
228{
229public:
231 explicit INavigation2DMsgs_suspend_navigation_RPC_helper(const double time_s);
232 bool write(yarp::os::ConnectionWriter& connection) const override;
233 bool read(yarp::os::ConnectionReader& connection) override;
234
235 class Command :
237 {
238 public:
239 Command() = default;
240 explicit Command(const double time_s);
241
242 ~Command() override = default;
243
244 bool write(yarp::os::ConnectionWriter& connection) const override;
245 bool read(yarp::os::ConnectionReader& connection) override;
246
247 bool write(const yarp::os::idl::WireWriter& writer) const override;
248 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
249 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
250
251 bool read(yarp::os::idl::WireReader& reader) override;
254
255 double time_s{0.0};
256 };
257
258 class Reply :
260 {
261 public:
262 Reply() = default;
263 ~Reply() override = default;
264
265 bool write(yarp::os::ConnectionWriter& connection) const override;
266 bool read(yarp::os::ConnectionReader& connection) override;
267
268 bool write(const yarp::os::idl::WireWriter& writer) const override;
269 bool read(yarp::os::idl::WireReader& reader) override;
270
272 };
273
274 using funcptr_t = yarp::dev::ReturnValue (*)(const double);
275 void call(INavigation2DMsgs* ptr);
276
279
280 static constexpr const char* s_tag{"suspend_navigation_RPC"};
281 static constexpr size_t s_tag_len{3};
282 static constexpr size_t s_cmd_len{4};
283 static constexpr size_t s_reply_len{1};
284 static constexpr const char* s_prototype{"yarp::dev::ReturnValue INavigation2DMsgs::suspend_navigation_RPC(const double time_s)"};
285 static constexpr const char* s_help{""};
286};
287
288// recompute_current_navigation_path_RPC helper class declaration
290 public yarp::os::Portable
291{
292public:
294 bool write(yarp::os::ConnectionWriter& connection) const override;
295 bool read(yarp::os::ConnectionReader& connection) override;
296
297 class Command :
299 {
300 public:
301 Command() = default;
302 ~Command() override = default;
303
304 bool write(yarp::os::ConnectionWriter& connection) const override;
305 bool read(yarp::os::ConnectionReader& connection) override;
306
307 bool write(const yarp::os::idl::WireWriter& writer) const override;
308 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
309 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
310
311 bool read(yarp::os::idl::WireReader& reader) override;
314 };
315
316 class Reply :
318 {
319 public:
320 Reply() = default;
321 ~Reply() override = default;
322
323 bool write(yarp::os::ConnectionWriter& connection) const override;
324 bool read(yarp::os::ConnectionReader& connection) override;
325
326 bool write(const yarp::os::idl::WireWriter& writer) const override;
327 bool read(yarp::os::idl::WireReader& reader) override;
328
330 };
331
333 void call(INavigation2DMsgs* ptr);
334
337
338 static constexpr const char* s_tag{"recompute_current_navigation_path_RPC"};
339 static constexpr size_t s_tag_len{5};
340 static constexpr size_t s_cmd_len{5};
341 static constexpr size_t s_reply_len{1};
342 static constexpr const char* s_prototype{"yarp::dev::ReturnValue INavigation2DMsgs::recompute_current_navigation_path_RPC()"};
343 static constexpr const char* s_help{""};
344};
345
346// get_navigation_status_RPC helper class declaration
348 public yarp::os::Portable
349{
350public:
352 bool write(yarp::os::ConnectionWriter& connection) const override;
353 bool read(yarp::os::ConnectionReader& connection) override;
354
355 class Command :
357 {
358 public:
359 Command() = default;
360 ~Command() override = default;
361
362 bool write(yarp::os::ConnectionWriter& connection) const override;
363 bool read(yarp::os::ConnectionReader& connection) override;
364
365 bool write(const yarp::os::idl::WireWriter& writer) const override;
366 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
367 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
368
369 bool read(yarp::os::idl::WireReader& reader) override;
372 };
373
374 class Reply :
376 {
377 public:
378 Reply() = default;
379 ~Reply() override = default;
380
381 bool write(yarp::os::ConnectionWriter& connection) const override;
382 bool read(yarp::os::ConnectionReader& connection) override;
383
384 bool write(const yarp::os::idl::WireWriter& writer) const override;
385 bool read(yarp::os::idl::WireReader& reader) override;
386
388 };
389
391 void call(INavigation2DMsgs* ptr);
392
395
396 static constexpr const char* s_tag{"get_navigation_status_RPC"};
397 static constexpr size_t s_tag_len{4};
398 static constexpr size_t s_cmd_len{4};
399 static constexpr size_t s_reply_len{2};
400 static constexpr const char* s_prototype{"return_get_navigation_status INavigation2DMsgs::get_navigation_status_RPC()"};
401 static constexpr const char* s_help{""};
402};
403
404// get_current_nav_waypoint_RPC helper class declaration
406 public yarp::os::Portable
407{
408public:
410 bool write(yarp::os::ConnectionWriter& connection) const override;
411 bool read(yarp::os::ConnectionReader& connection) override;
412
413 class Command :
415 {
416 public:
417 Command() = default;
418 ~Command() override = default;
419
420 bool write(yarp::os::ConnectionWriter& connection) const override;
421 bool read(yarp::os::ConnectionReader& connection) override;
422
423 bool write(const yarp::os::idl::WireWriter& writer) const override;
424 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
425 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
426
427 bool read(yarp::os::idl::WireReader& reader) override;
430 };
431
432 class Reply :
434 {
435 public:
436 Reply() = default;
437 ~Reply() override = default;
438
439 bool write(yarp::os::ConnectionWriter& connection) const override;
440 bool read(yarp::os::ConnectionReader& connection) override;
441
442 bool write(const yarp::os::idl::WireWriter& writer) const override;
443 bool read(yarp::os::idl::WireReader& reader) override;
444
446 };
447
449 void call(INavigation2DMsgs* ptr);
450
453
454 static constexpr const char* s_tag{"get_current_nav_waypoint_RPC"};
455 static constexpr size_t s_tag_len{5};
456 static constexpr size_t s_cmd_len{5};
457 static constexpr size_t s_reply_len{2};
458 static constexpr const char* s_prototype{"return_get_current_nav_waypoint INavigation2DMsgs::get_current_nav_waypoint_RPC()"};
459 static constexpr const char* s_help{""};
460};
461
462// get_all_navigation_waypoints_RPC helper class declaration
464 public yarp::os::Portable
465{
466public:
469 bool write(yarp::os::ConnectionWriter& connection) const override;
470 bool read(yarp::os::ConnectionReader& connection) override;
471
472 class Command :
474 {
475 public:
476 Command() = default;
478
479 ~Command() override = default;
480
481 bool write(yarp::os::ConnectionWriter& connection) const override;
482 bool read(yarp::os::ConnectionReader& connection) override;
483
484 bool write(const yarp::os::idl::WireWriter& writer) const override;
485 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
486 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
487
488 bool read(yarp::os::idl::WireReader& reader) override;
491
493 };
494
495 class Reply :
497 {
498 public:
499 Reply() = default;
500 ~Reply() override = default;
501
502 bool write(yarp::os::ConnectionWriter& connection) const override;
503 bool read(yarp::os::ConnectionReader& connection) override;
504
505 bool write(const yarp::os::idl::WireWriter& writer) const override;
506 bool read(yarp::os::idl::WireReader& reader) override;
507
509 };
510
512 void call(INavigation2DMsgs* ptr);
513
516
517 static constexpr const char* s_tag{"get_all_navigation_waypoints_RPC"};
518 static constexpr size_t s_tag_len{5};
519 static constexpr size_t s_cmd_len{6};
520 static constexpr size_t s_reply_len{2};
521 static constexpr const char* s_prototype{"return_get_all_nav_waypoints INavigation2DMsgs::get_all_navigation_waypoints_RPC(const yarp::dev::Nav2D::TrajectoryTypeEnum trajectory_type)"};
522 static constexpr const char* s_help{""};
523};
524
525// get_current_navigation_map_RPC helper class declaration
527 public yarp::os::Portable
528{
529public:
532 bool write(yarp::os::ConnectionWriter& connection) const override;
533 bool read(yarp::os::ConnectionReader& connection) override;
534
535 class Command :
537 {
538 public:
539 Command() = default;
541
542 ~Command() override = default;
543
544 bool write(yarp::os::ConnectionWriter& connection) const override;
545 bool read(yarp::os::ConnectionReader& connection) override;
546
547 bool write(const yarp::os::idl::WireWriter& writer) const override;
548 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
549 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
550
551 bool read(yarp::os::idl::WireReader& reader) override;
554
556 };
557
558 class Reply :
560 {
561 public:
562 Reply() = default;
563 ~Reply() override = default;
564
565 bool write(yarp::os::ConnectionWriter& connection) const override;
566 bool read(yarp::os::ConnectionReader& connection) override;
567
568 bool write(const yarp::os::idl::WireWriter& writer) const override;
569 bool read(yarp::os::idl::WireReader& reader) override;
570
572 };
573
575 void call(INavigation2DMsgs* ptr);
576
579
580 static constexpr const char* s_tag{"get_current_navigation_map_RPC"};
581 static constexpr size_t s_tag_len{5};
582 static constexpr size_t s_cmd_len{6};
583 static constexpr size_t s_reply_len{2};
584 static constexpr const char* s_prototype{"return_get_current_nav_map INavigation2DMsgs::get_current_navigation_map_RPC(const yarp::dev::Nav2D::NavigationMapTypeEnum map_type)"};
585 static constexpr const char* s_help{""};
586};
587
588// goto_target_by_absolute_location_RPC helper class declaration
590 public yarp::os::Portable
591{
592public:
595 bool write(yarp::os::ConnectionWriter& connection) const override;
596 bool read(yarp::os::ConnectionReader& connection) override;
597
598 class Command :
600 {
601 public:
602 Command() = default;
604
605 ~Command() override = default;
606
607 bool write(yarp::os::ConnectionWriter& connection) const override;
608 bool read(yarp::os::ConnectionReader& connection) override;
609
610 bool write(const yarp::os::idl::WireWriter& writer) const override;
611 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
612 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
613
614 bool read(yarp::os::idl::WireReader& reader) override;
617
619 };
620
621 class Reply :
623 {
624 public:
625 Reply() = default;
626 ~Reply() override = default;
627
628 bool write(yarp::os::ConnectionWriter& connection) const override;
629 bool read(yarp::os::ConnectionReader& connection) override;
630
631 bool write(const yarp::os::idl::WireWriter& writer) const override;
632 bool read(yarp::os::idl::WireReader& reader) override;
633
635 };
636
638 void call(INavigation2DMsgs* ptr);
639
642
643 static constexpr const char* s_tag{"goto_target_by_absolute_location_RPC"};
644 static constexpr size_t s_tag_len{6};
645 static constexpr size_t s_cmd_len{7};
646 static constexpr size_t s_reply_len{1};
647 static constexpr const char* s_prototype{"yarp::dev::ReturnValue INavigation2DMsgs::goto_target_by_absolute_location_RPC(const yarp::dev::Nav2D::Map2DLocation& loc)"};
648 static constexpr const char* s_help{""};
649};
650
651// follow_path_RPC helper class declaration
653 public yarp::os::Portable
654{
655public:
658 bool write(yarp::os::ConnectionWriter& connection) const override;
659 bool read(yarp::os::ConnectionReader& connection) override;
660
661 class Command :
663 {
664 public:
665 Command() = default;
667
668 ~Command() override = default;
669
670 bool write(yarp::os::ConnectionWriter& connection) const override;
671 bool read(yarp::os::ConnectionReader& connection) override;
672
673 bool write(const yarp::os::idl::WireWriter& writer) const override;
674 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
675 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
676
677 bool read(yarp::os::idl::WireReader& reader) override;
680
682 };
683
684 class Reply :
686 {
687 public:
688 Reply() = default;
689 ~Reply() override = default;
690
691 bool write(yarp::os::ConnectionWriter& connection) const override;
692 bool read(yarp::os::ConnectionReader& connection) override;
693
694 bool write(const yarp::os::idl::WireWriter& writer) const override;
695 bool read(yarp::os::idl::WireReader& reader) override;
696
698 };
699
701 void call(INavigation2DMsgs* ptr);
702
705
706 static constexpr const char* s_tag{"follow_path_RPC"};
707 static constexpr size_t s_tag_len{3};
708 static constexpr size_t s_cmd_len{4};
709 static constexpr size_t s_reply_len{1};
710 static constexpr const char* s_prototype{"yarp::dev::ReturnValue INavigation2DMsgs::follow_path_RPC(const yarp::dev::Nav2D::Map2DPath& path)"};
711 static constexpr const char* s_help{""};
712};
713
714// goto_target_by_relative_location1_RPC helper class declaration
716 public yarp::os::Portable
717{
718public:
721 bool write(yarp::os::ConnectionWriter& connection) const override;
722 bool read(yarp::os::ConnectionReader& connection) override;
723
724 class Command :
726 {
727 public:
728 Command() = default;
729 Command(const double x, const double y);
730
731 ~Command() override = default;
732
733 bool write(yarp::os::ConnectionWriter& connection) const override;
734 bool read(yarp::os::ConnectionReader& connection) override;
735
736 bool write(const yarp::os::idl::WireWriter& writer) const override;
737 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
738 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
739
740 bool read(yarp::os::idl::WireReader& reader) override;
743
744 double x{0.0};
745 double y{0.0};
746 };
747
748 class Reply :
750 {
751 public:
752 Reply() = default;
753 ~Reply() override = default;
754
755 bool write(yarp::os::ConnectionWriter& connection) const override;
756 bool read(yarp::os::ConnectionReader& connection) override;
757
758 bool write(const yarp::os::idl::WireWriter& writer) const override;
759 bool read(yarp::os::idl::WireReader& reader) override;
760
762 };
763
764 using funcptr_t = yarp::dev::ReturnValue (*)(const double, const double);
765 void call(INavigation2DMsgs* ptr);
766
769
770 static constexpr const char* s_tag{"goto_target_by_relative_location1_RPC"};
771 static constexpr size_t s_tag_len{6};
772 static constexpr size_t s_cmd_len{8};
773 static constexpr size_t s_reply_len{1};
774 static constexpr const char* s_prototype{"yarp::dev::ReturnValue INavigation2DMsgs::goto_target_by_relative_location1_RPC(const double x, const double y)"};
775 static constexpr const char* s_help{""};
776};
777
778// goto_target_by_relative_location2_RPC helper class declaration
780 public yarp::os::Portable
781{
782public:
784 INavigation2DMsgs_goto_target_by_relative_location2_RPC_helper(const double x, const double y, const double theta);
785 bool write(yarp::os::ConnectionWriter& connection) const override;
786 bool read(yarp::os::ConnectionReader& connection) override;
787
788 class Command :
790 {
791 public:
792 Command() = default;
793 Command(const double x, const double y, const double theta);
794
795 ~Command() override = default;
796
797 bool write(yarp::os::ConnectionWriter& connection) const override;
798 bool read(yarp::os::ConnectionReader& connection) override;
799
800 bool write(const yarp::os::idl::WireWriter& writer) const override;
801 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
802 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
803
804 bool read(yarp::os::idl::WireReader& reader) override;
807
808 double x{0.0};
809 double y{0.0};
810 double theta{0.0};
811 };
812
813 class Reply :
815 {
816 public:
817 Reply() = default;
818 ~Reply() override = default;
819
820 bool write(yarp::os::ConnectionWriter& connection) const override;
821 bool read(yarp::os::ConnectionReader& connection) override;
822
823 bool write(const yarp::os::idl::WireWriter& writer) const override;
824 bool read(yarp::os::idl::WireReader& reader) override;
825
827 };
828
829 using funcptr_t = yarp::dev::ReturnValue (*)(const double, const double, const double);
830 void call(INavigation2DMsgs* ptr);
831
834
835 static constexpr const char* s_tag{"goto_target_by_relative_location2_RPC"};
836 static constexpr size_t s_tag_len{6};
837 static constexpr size_t s_cmd_len{9};
838 static constexpr size_t s_reply_len{1};
839 static constexpr const char* s_prototype{"yarp::dev::ReturnValue INavigation2DMsgs::goto_target_by_relative_location2_RPC(const double x, const double y, const double theta)"};
840 static constexpr const char* s_help{""};
841};
842
843// get_absolute_location_of_current_target_RPC helper class declaration
845 public yarp::os::Portable
846{
847public:
849 bool write(yarp::os::ConnectionWriter& connection) const override;
850 bool read(yarp::os::ConnectionReader& connection) override;
851
852 class Command :
854 {
855 public:
856 Command() = default;
857 ~Command() 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 writeTag(const yarp::os::idl::WireWriter& writer) const;
864 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
865
866 bool read(yarp::os::idl::WireReader& reader) override;
869 };
870
871 class Reply :
873 {
874 public:
875 Reply() = default;
876 ~Reply() override = default;
877
878 bool write(yarp::os::ConnectionWriter& connection) const override;
879 bool read(yarp::os::ConnectionReader& connection) override;
880
881 bool write(const yarp::os::idl::WireWriter& writer) const override;
882 bool read(yarp::os::idl::WireReader& reader) override;
883
885 };
886
888 void call(INavigation2DMsgs* ptr);
889
892
893 static constexpr const char* s_tag{"get_absolute_location_of_current_target_RPC"};
894 static constexpr size_t s_tag_len{7};
895 static constexpr size_t s_cmd_len{7};
896 static constexpr size_t s_reply_len{2};
897 static constexpr const char* s_prototype{"return_get_abs_loc_of_curr_target INavigation2DMsgs::get_absolute_location_of_current_target_RPC()"};
898 static constexpr const char* s_help{""};
899};
900
901// get_relative_location_of_current_target_RPC helper class declaration
903 public yarp::os::Portable
904{
905public:
907 bool write(yarp::os::ConnectionWriter& connection) const override;
908 bool read(yarp::os::ConnectionReader& connection) override;
909
910 class Command :
912 {
913 public:
914 Command() = default;
915 ~Command() override = default;
916
917 bool write(yarp::os::ConnectionWriter& connection) const override;
918 bool read(yarp::os::ConnectionReader& connection) override;
919
920 bool write(const yarp::os::idl::WireWriter& writer) const override;
921 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
922 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
923
924 bool read(yarp::os::idl::WireReader& reader) override;
927 };
928
929 class Reply :
931 {
932 public:
933 Reply() = default;
934 ~Reply() override = default;
935
936 bool write(yarp::os::ConnectionWriter& connection) const override;
937 bool read(yarp::os::ConnectionReader& connection) override;
938
939 bool write(const yarp::os::idl::WireWriter& writer) const override;
940 bool read(yarp::os::idl::WireReader& reader) override;
941
943 };
944
946 void call(INavigation2DMsgs* ptr);
947
950
951 static constexpr const char* s_tag{"get_relative_location_of_current_target_RPC"};
952 static constexpr size_t s_tag_len{7};
953 static constexpr size_t s_cmd_len{7};
954 static constexpr size_t s_reply_len{4};
955 static constexpr const char* s_prototype{"return_get_rel_loc_of_curr_target INavigation2DMsgs::get_relative_location_of_current_target_RPC()"};
956 static constexpr const char* s_help{""};
957};
958
959// goto_target_by_absolute_location_and_set_name_RPC helper class declaration
961 public yarp::os::Portable
962{
963public:
966 bool write(yarp::os::ConnectionWriter& connection) const override;
967 bool read(yarp::os::ConnectionReader& connection) override;
968
969 class Command :
971 {
972 public:
973 Command() = default;
974 Command(const yarp::dev::Nav2D::Map2DLocation& loc, const std::string& name);
975
976 ~Command() override = default;
977
978 bool write(yarp::os::ConnectionWriter& connection) const override;
979 bool read(yarp::os::ConnectionReader& connection) override;
980
981 bool write(const yarp::os::idl::WireWriter& writer) const override;
982 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
983 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
984
985 bool read(yarp::os::idl::WireReader& reader) override;
988
990 std::string name{};
991 };
992
993 class Reply :
995 {
996 public:
997 Reply() = default;
998 ~Reply() override = default;
999
1000 bool write(yarp::os::ConnectionWriter& connection) const override;
1001 bool read(yarp::os::ConnectionReader& connection) override;
1002
1003 bool write(const yarp::os::idl::WireWriter& writer) const override;
1004 bool read(yarp::os::idl::WireReader& reader) override;
1005
1007 };
1008
1010 void call(INavigation2DMsgs* ptr);
1011
1014
1015 static constexpr const char* s_tag{"goto_target_by_absolute_location_and_set_name_RPC"};
1016 static constexpr size_t s_tag_len{9};
1017 static constexpr size_t s_cmd_len{11};
1018 static constexpr size_t s_reply_len{1};
1019 static constexpr const char* s_prototype{"yarp::dev::ReturnValue INavigation2DMsgs::goto_target_by_absolute_location_and_set_name_RPC(const yarp::dev::Nav2D::Map2DLocation& loc, const std::string& name)"};
1020 static constexpr const char* s_help{""};
1021};
1022
1023// apply_velocity_command_RPC helper class declaration
1025 public yarp::os::Portable
1026{
1027public:
1029 INavigation2DMsgs_apply_velocity_command_RPC_helper(const double x_vel, const double y_vel, const double theta_vel, const double timeout);
1030 bool write(yarp::os::ConnectionWriter& connection) const override;
1031 bool read(yarp::os::ConnectionReader& connection) override;
1032
1033 class Command :
1035 {
1036 public:
1037 Command() = default;
1038 Command(const double x_vel, const double y_vel, const double theta_vel, const double timeout);
1039
1040 ~Command() override = default;
1041
1042 bool write(yarp::os::ConnectionWriter& connection) const override;
1043 bool read(yarp::os::ConnectionReader& connection) override;
1044
1045 bool write(const yarp::os::idl::WireWriter& writer) const override;
1046 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1047 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1048
1049 bool read(yarp::os::idl::WireReader& reader) override;
1050 bool readTag(yarp::os::idl::WireReader& reader);
1051 bool readArgs(yarp::os::idl::WireReader& reader);
1052
1053 double x_vel{0.0};
1054 double y_vel{0.0};
1055 double theta_vel{0.0};
1056 double timeout{0.0};
1057 };
1058
1059 class Reply :
1061 {
1062 public:
1063 Reply() = default;
1064 ~Reply() override = default;
1065
1066 bool write(yarp::os::ConnectionWriter& connection) const override;
1067 bool read(yarp::os::ConnectionReader& connection) override;
1068
1069 bool write(const yarp::os::idl::WireWriter& writer) const override;
1070 bool read(yarp::os::idl::WireReader& reader) override;
1071
1073 };
1074
1075 using funcptr_t = yarp::dev::ReturnValue (*)(const double, const double, const double, const double);
1076 void call(INavigation2DMsgs* ptr);
1077
1080
1081 static constexpr const char* s_tag{"apply_velocity_command_RPC"};
1082 static constexpr size_t s_tag_len{4};
1083 static constexpr size_t s_cmd_len{8};
1084 static constexpr size_t s_reply_len{1};
1085 static constexpr const char* s_prototype{"yarp::dev::ReturnValue INavigation2DMsgs::apply_velocity_command_RPC(const double x_vel, const double y_vel, const double theta_vel, const double timeout)"};
1086 static constexpr const char* s_help{""};
1087};
1088
1089// get_last_velocity_command_RPC helper class declaration
1091 public yarp::os::Portable
1092{
1093public:
1095 bool write(yarp::os::ConnectionWriter& connection) const override;
1096 bool read(yarp::os::ConnectionReader& connection) override;
1097
1098 class Command :
1100 {
1101 public:
1102 Command() = default;
1103 ~Command() override = default;
1104
1105 bool write(yarp::os::ConnectionWriter& connection) const override;
1106 bool read(yarp::os::ConnectionReader& connection) override;
1107
1108 bool write(const yarp::os::idl::WireWriter& writer) const override;
1109 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1110 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1111
1112 bool read(yarp::os::idl::WireReader& reader) override;
1113 bool readTag(yarp::os::idl::WireReader& reader);
1114 bool readArgs(yarp::os::idl::WireReader& reader);
1115 };
1116
1117 class Reply :
1119 {
1120 public:
1121 Reply() = default;
1122 ~Reply() override = default;
1123
1124 bool write(yarp::os::ConnectionWriter& connection) const override;
1125 bool read(yarp::os::ConnectionReader& connection) override;
1126
1127 bool write(const yarp::os::idl::WireWriter& writer) const override;
1128 bool read(yarp::os::idl::WireReader& reader) override;
1129
1131 };
1132
1134 void call(INavigation2DMsgs* ptr);
1135
1138
1139 static constexpr const char* s_tag{"get_last_velocity_command_RPC"};
1140 static constexpr size_t s_tag_len{5};
1141 static constexpr size_t s_cmd_len{5};
1142 static constexpr size_t s_reply_len{4};
1143 static constexpr const char* s_prototype{"return_get_last_velocity_command INavigation2DMsgs::get_last_velocity_command_RPC()"};
1144 static constexpr const char* s_help{""};
1145};
1146
1147// get_name_of_current_target_RPC helper class declaration
1149 public yarp::os::Portable
1150{
1151public:
1153 bool write(yarp::os::ConnectionWriter& connection) const override;
1154 bool read(yarp::os::ConnectionReader& connection) override;
1155
1156 class Command :
1158 {
1159 public:
1160 Command() = default;
1161 ~Command() override = default;
1162
1163 bool write(yarp::os::ConnectionWriter& connection) const override;
1164 bool read(yarp::os::ConnectionReader& connection) override;
1165
1166 bool write(const yarp::os::idl::WireWriter& writer) const override;
1167 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1168 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1169
1170 bool read(yarp::os::idl::WireReader& reader) override;
1171 bool readTag(yarp::os::idl::WireReader& reader);
1172 bool readArgs(yarp::os::idl::WireReader& reader);
1173 };
1174
1175 class Reply :
1177 {
1178 public:
1179 Reply() = default;
1180 ~Reply() override = default;
1181
1182 bool write(yarp::os::ConnectionWriter& connection) const override;
1183 bool read(yarp::os::ConnectionReader& connection) override;
1184
1185 bool write(const yarp::os::idl::WireWriter& writer) const override;
1186 bool read(yarp::os::idl::WireReader& reader) override;
1187
1189 };
1190
1192 void call(INavigation2DMsgs* ptr);
1193
1196
1197 static constexpr const char* s_tag{"get_name_of_current_target_RPC"};
1198 static constexpr size_t s_tag_len{6};
1199 static constexpr size_t s_cmd_len{6};
1200 static constexpr size_t s_reply_len{2};
1201 static constexpr const char* s_prototype{"return_get_name_of_current_target INavigation2DMsgs::get_name_of_current_target_RPC()"};
1202 static constexpr const char* s_help{""};
1203};
1204
1205// stop_navigation_RPC helper class implementation
1207{
1208 return cmd.write(connection);
1209}
1210
1215
1217{
1218 yarp::os::idl::WireWriter writer(connection);
1219 if (!writer.writeListHeader(s_cmd_len)) {
1220 return false;
1221 }
1222 return write(writer);
1223}
1224
1226{
1227 yarp::os::idl::WireReader reader(connection);
1228 if (!reader.readListHeader()) {
1229 reader.fail();
1230 return false;
1231 }
1232 return read(reader);
1233}
1234
1236{
1237 if (!writeTag(writer)) {
1238 return false;
1239 }
1240 if (!writeArgs(writer)) {
1241 return false;
1242 }
1243 return true;
1244}
1245
1247{
1248 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1249 return false;
1250 }
1251 return true;
1252}
1253
1255{
1256 return true;
1257}
1258
1260{
1261 if (!readTag(reader)) {
1262 return false;
1263 }
1264 if (!readArgs(reader)) {
1265 return false;
1266 }
1267 return true;
1268}
1269
1271{
1272 std::string tag = reader.readTag(s_tag_len);
1273 if (reader.isError()) {
1274 return false;
1275 }
1276 if (tag != s_tag) {
1277 reader.fail();
1278 return false;
1279 }
1280 return true;
1281}
1282
1284{
1285 if (!reader.noMore()) {
1286 reader.fail();
1287 return false;
1288 }
1289 return true;
1290}
1291
1293{
1294 yarp::os::idl::WireWriter writer(connection);
1295 return write(writer);
1296}
1297
1299{
1300 yarp::os::idl::WireReader reader(connection);
1301 return read(reader);
1302}
1303
1305{
1306 if (!writer.isNull()) {
1307 if (!writer.write(return_helper)) {
1308 return false;
1309 }
1310 }
1311 return true;
1312}
1313
1315{
1316 if (reader.noMore()) {
1317 reader.fail();
1318 return false;
1319 }
1320 if (!reader.read(return_helper)) {
1321 reader.fail();
1322 return false;
1323 }
1324 return true;
1325}
1326
1331
1332// resume_navigation_RPC helper class implementation
1334{
1335 return cmd.write(connection);
1336}
1337
1342
1344{
1345 yarp::os::idl::WireWriter writer(connection);
1346 if (!writer.writeListHeader(s_cmd_len)) {
1347 return false;
1348 }
1349 return write(writer);
1350}
1351
1353{
1354 yarp::os::idl::WireReader reader(connection);
1355 if (!reader.readListHeader()) {
1356 reader.fail();
1357 return false;
1358 }
1359 return read(reader);
1360}
1361
1363{
1364 if (!writeTag(writer)) {
1365 return false;
1366 }
1367 if (!writeArgs(writer)) {
1368 return false;
1369 }
1370 return true;
1371}
1372
1374{
1375 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1376 return false;
1377 }
1378 return true;
1379}
1380
1382{
1383 return true;
1384}
1385
1387{
1388 if (!readTag(reader)) {
1389 return false;
1390 }
1391 if (!readArgs(reader)) {
1392 return false;
1393 }
1394 return true;
1395}
1396
1398{
1399 std::string tag = reader.readTag(s_tag_len);
1400 if (reader.isError()) {
1401 return false;
1402 }
1403 if (tag != s_tag) {
1404 reader.fail();
1405 return false;
1406 }
1407 return true;
1408}
1409
1411{
1412 if (!reader.noMore()) {
1413 reader.fail();
1414 return false;
1415 }
1416 return true;
1417}
1418
1420{
1421 yarp::os::idl::WireWriter writer(connection);
1422 return write(writer);
1423}
1424
1426{
1427 yarp::os::idl::WireReader reader(connection);
1428 return read(reader);
1429}
1430
1432{
1433 if (!writer.isNull()) {
1434 if (!writer.write(return_helper)) {
1435 return false;
1436 }
1437 }
1438 return true;
1439}
1440
1442{
1443 if (reader.noMore()) {
1444 reader.fail();
1445 return false;
1446 }
1447 if (!reader.read(return_helper)) {
1448 reader.fail();
1449 return false;
1450 }
1451 return true;
1452}
1453
1458
1459// suspend_navigation_RPC helper class implementation
1464
1466{
1467 return cmd.write(connection);
1468}
1469
1474
1476 time_s{time_s}
1477{
1478}
1479
1481{
1482 yarp::os::idl::WireWriter writer(connection);
1483 if (!writer.writeListHeader(s_cmd_len)) {
1484 return false;
1485 }
1486 return write(writer);
1487}
1488
1490{
1491 yarp::os::idl::WireReader reader(connection);
1492 if (!reader.readListHeader()) {
1493 reader.fail();
1494 return false;
1495 }
1496 return read(reader);
1497}
1498
1500{
1501 if (!writeTag(writer)) {
1502 return false;
1503 }
1504 if (!writeArgs(writer)) {
1505 return false;
1506 }
1507 return true;
1508}
1509
1511{
1512 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1513 return false;
1514 }
1515 return true;
1516}
1517
1519{
1520 if (!writer.writeFloat64(time_s)) {
1521 return false;
1522 }
1523 return true;
1524}
1525
1527{
1528 if (!readTag(reader)) {
1529 return false;
1530 }
1531 if (!readArgs(reader)) {
1532 return false;
1533 }
1534 return true;
1535}
1536
1538{
1539 std::string tag = reader.readTag(s_tag_len);
1540 if (reader.isError()) {
1541 return false;
1542 }
1543 if (tag != s_tag) {
1544 reader.fail();
1545 return false;
1546 }
1547 return true;
1548}
1549
1551{
1552 if (reader.noMore()) {
1553 reader.fail();
1554 return false;
1555 }
1556 if (!reader.readFloat64(time_s)) {
1557 reader.fail();
1558 return false;
1559 }
1560 if (!reader.noMore()) {
1561 reader.fail();
1562 return false;
1563 }
1564 return true;
1565}
1566
1568{
1569 yarp::os::idl::WireWriter writer(connection);
1570 return write(writer);
1571}
1572
1574{
1575 yarp::os::idl::WireReader reader(connection);
1576 return read(reader);
1577}
1578
1580{
1581 if (!writer.isNull()) {
1582 if (!writer.write(return_helper)) {
1583 return false;
1584 }
1585 }
1586 return true;
1587}
1588
1590{
1591 if (reader.noMore()) {
1592 reader.fail();
1593 return false;
1594 }
1595 if (!reader.read(return_helper)) {
1596 reader.fail();
1597 return false;
1598 }
1599 return true;
1600}
1601
1606
1607// recompute_current_navigation_path_RPC helper class implementation
1612
1617
1619{
1620 yarp::os::idl::WireWriter writer(connection);
1621 if (!writer.writeListHeader(s_cmd_len)) {
1622 return false;
1623 }
1624 return write(writer);
1625}
1626
1628{
1629 yarp::os::idl::WireReader reader(connection);
1630 if (!reader.readListHeader()) {
1631 reader.fail();
1632 return false;
1633 }
1634 return read(reader);
1635}
1636
1638{
1639 if (!writeTag(writer)) {
1640 return false;
1641 }
1642 if (!writeArgs(writer)) {
1643 return false;
1644 }
1645 return true;
1646}
1647
1649{
1650 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1651 return false;
1652 }
1653 return true;
1654}
1655
1657{
1658 return true;
1659}
1660
1662{
1663 if (!readTag(reader)) {
1664 return false;
1665 }
1666 if (!readArgs(reader)) {
1667 return false;
1668 }
1669 return true;
1670}
1671
1673{
1674 std::string tag = reader.readTag(s_tag_len);
1675 if (reader.isError()) {
1676 return false;
1677 }
1678 if (tag != s_tag) {
1679 reader.fail();
1680 return false;
1681 }
1682 return true;
1683}
1684
1686{
1687 if (!reader.noMore()) {
1688 reader.fail();
1689 return false;
1690 }
1691 return true;
1692}
1693
1699
1705
1707{
1708 if (!writer.isNull()) {
1709 if (!writer.write(return_helper)) {
1710 return false;
1711 }
1712 }
1713 return true;
1714}
1715
1717{
1718 if (reader.noMore()) {
1719 reader.fail();
1720 return false;
1721 }
1722 if (!reader.read(return_helper)) {
1723 reader.fail();
1724 return false;
1725 }
1726 return true;
1727}
1728
1733
1734// get_navigation_status_RPC helper class implementation
1736{
1737 return cmd.write(connection);
1738}
1739
1744
1746{
1747 yarp::os::idl::WireWriter writer(connection);
1748 if (!writer.writeListHeader(s_cmd_len)) {
1749 return false;
1750 }
1751 return write(writer);
1752}
1753
1755{
1756 yarp::os::idl::WireReader reader(connection);
1757 if (!reader.readListHeader()) {
1758 reader.fail();
1759 return false;
1760 }
1761 return read(reader);
1762}
1763
1765{
1766 if (!writeTag(writer)) {
1767 return false;
1768 }
1769 if (!writeArgs(writer)) {
1770 return false;
1771 }
1772 return true;
1773}
1774
1776{
1777 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1778 return false;
1779 }
1780 return true;
1781}
1782
1784{
1785 return true;
1786}
1787
1789{
1790 if (!readTag(reader)) {
1791 return false;
1792 }
1793 if (!readArgs(reader)) {
1794 return false;
1795 }
1796 return true;
1797}
1798
1800{
1801 std::string tag = reader.readTag(s_tag_len);
1802 if (reader.isError()) {
1803 return false;
1804 }
1805 if (tag != s_tag) {
1806 reader.fail();
1807 return false;
1808 }
1809 return true;
1810}
1811
1813{
1814 if (!reader.noMore()) {
1815 reader.fail();
1816 return false;
1817 }
1818 return true;
1819}
1820
1822{
1823 yarp::os::idl::WireWriter writer(connection);
1824 return write(writer);
1825}
1826
1832
1834{
1835 if (!writer.isNull()) {
1836 if (!writer.writeListHeader(s_reply_len)) {
1837 return false;
1838 }
1839 if (!writer.write(return_helper)) {
1840 return false;
1841 }
1842 }
1843 return true;
1844}
1845
1847{
1848 if (!reader.readListReturn()) {
1849 return false;
1850 }
1851 if (reader.noMore()) {
1852 reader.fail();
1853 return false;
1854 }
1855 if (!reader.read(return_helper)) {
1856 reader.fail();
1857 return false;
1858 }
1859 return true;
1860}
1861
1866
1867// get_current_nav_waypoint_RPC helper class implementation
1872
1877
1879{
1880 yarp::os::idl::WireWriter writer(connection);
1881 if (!writer.writeListHeader(s_cmd_len)) {
1882 return false;
1883 }
1884 return write(writer);
1885}
1886
1888{
1889 yarp::os::idl::WireReader reader(connection);
1890 if (!reader.readListHeader()) {
1891 reader.fail();
1892 return false;
1893 }
1894 return read(reader);
1895}
1896
1898{
1899 if (!writeTag(writer)) {
1900 return false;
1901 }
1902 if (!writeArgs(writer)) {
1903 return false;
1904 }
1905 return true;
1906}
1907
1909{
1910 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1911 return false;
1912 }
1913 return true;
1914}
1915
1917{
1918 return true;
1919}
1920
1922{
1923 if (!readTag(reader)) {
1924 return false;
1925 }
1926 if (!readArgs(reader)) {
1927 return false;
1928 }
1929 return true;
1930}
1931
1933{
1934 std::string tag = reader.readTag(s_tag_len);
1935 if (reader.isError()) {
1936 return false;
1937 }
1938 if (tag != s_tag) {
1939 reader.fail();
1940 return false;
1941 }
1942 return true;
1943}
1944
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
1965
1967{
1968 if (!writer.isNull()) {
1969 if (!writer.writeListHeader(s_reply_len)) {
1970 return false;
1971 }
1972 if (!writer.write(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.read(return_helper)) {
1989 reader.fail();
1990 return false;
1991 }
1992 return true;
1993}
1994
1999
2000// get_all_navigation_waypoints_RPC helper class implementation
2005
2010
2015
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.writeVocab32(static_cast<yarp::conf::vocab32_t>(trajectory_type))) {
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 yarp::conf::vocab32_t _ecast;
2098 if (!reader.readVocab32(_ecast)) {
2099 reader.fail();
2100 return false;
2101 }
2102 trajectory_type = static_cast<yarp::dev::Nav2D::TrajectoryTypeEnum>(_ecast);
2103 if (!reader.noMore()) {
2104 reader.fail();
2105 return false;
2106 }
2107 return true;
2108}
2109
2115
2121
2123{
2124 if (!writer.isNull()) {
2125 if (!writer.writeListHeader(s_reply_len)) {
2126 return false;
2127 }
2128 if (!writer.write(return_helper)) {
2129 return false;
2130 }
2131 }
2132 return true;
2133}
2134
2136{
2137 if (!reader.readListReturn()) {
2138 return false;
2139 }
2140 if (reader.noMore()) {
2141 reader.fail();
2142 return false;
2143 }
2144 if (!reader.read(return_helper)) {
2145 reader.fail();
2146 return false;
2147 }
2148 return true;
2149}
2150
2155
2156// get_current_navigation_map_RPC helper class implementation
2161
2166
2171
2176
2178{
2179 yarp::os::idl::WireWriter writer(connection);
2180 if (!writer.writeListHeader(s_cmd_len)) {
2181 return false;
2182 }
2183 return write(writer);
2184}
2185
2187{
2188 yarp::os::idl::WireReader reader(connection);
2189 if (!reader.readListHeader()) {
2190 reader.fail();
2191 return false;
2192 }
2193 return read(reader);
2194}
2195
2197{
2198 if (!writeTag(writer)) {
2199 return false;
2200 }
2201 if (!writeArgs(writer)) {
2202 return false;
2203 }
2204 return true;
2205}
2206
2208{
2209 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2210 return false;
2211 }
2212 return true;
2213}
2214
2216{
2217 if (!writer.writeVocab32(static_cast<yarp::conf::vocab32_t>(map_type))) {
2218 return false;
2219 }
2220 return true;
2221}
2222
2224{
2225 if (!readTag(reader)) {
2226 return false;
2227 }
2228 if (!readArgs(reader)) {
2229 return false;
2230 }
2231 return true;
2232}
2233
2235{
2236 std::string tag = reader.readTag(s_tag_len);
2237 if (reader.isError()) {
2238 return false;
2239 }
2240 if (tag != s_tag) {
2241 reader.fail();
2242 return false;
2243 }
2244 return true;
2245}
2246
2248{
2249 if (reader.noMore()) {
2250 reader.fail();
2251 return false;
2252 }
2253 yarp::conf::vocab32_t _ecast;
2254 if (!reader.readVocab32(_ecast)) {
2255 reader.fail();
2256 return false;
2257 }
2258 map_type = static_cast<yarp::dev::Nav2D::NavigationMapTypeEnum>(_ecast);
2259 if (!reader.noMore()) {
2260 reader.fail();
2261 return false;
2262 }
2263 return true;
2264}
2265
2271
2277
2279{
2280 if (!writer.isNull()) {
2281 if (!writer.writeListHeader(s_reply_len)) {
2282 return false;
2283 }
2284 if (!writer.write(return_helper)) {
2285 return false;
2286 }
2287 }
2288 return true;
2289}
2290
2292{
2293 if (!reader.readListReturn()) {
2294 return false;
2295 }
2296 if (reader.noMore()) {
2297 reader.fail();
2298 return false;
2299 }
2300 if (!reader.read(return_helper)) {
2301 reader.fail();
2302 return false;
2303 }
2304 return true;
2305}
2306
2311
2312// goto_target_by_absolute_location_RPC helper class implementation
2317
2322
2327
2332
2334{
2335 yarp::os::idl::WireWriter writer(connection);
2336 if (!writer.writeListHeader(s_cmd_len)) {
2337 return false;
2338 }
2339 return write(writer);
2340}
2341
2343{
2344 yarp::os::idl::WireReader reader(connection);
2345 if (!reader.readListHeader()) {
2346 reader.fail();
2347 return false;
2348 }
2349 return read(reader);
2350}
2351
2353{
2354 if (!writeTag(writer)) {
2355 return false;
2356 }
2357 if (!writeArgs(writer)) {
2358 return false;
2359 }
2360 return true;
2361}
2362
2364{
2365 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2366 return false;
2367 }
2368 return true;
2369}
2370
2372{
2373 if (!writer.writeNested(loc)) {
2374 return false;
2375 }
2376 return true;
2377}
2378
2380{
2381 if (!readTag(reader)) {
2382 return false;
2383 }
2384 if (!readArgs(reader)) {
2385 return false;
2386 }
2387 return true;
2388}
2389
2391{
2392 std::string tag = reader.readTag(s_tag_len);
2393 if (reader.isError()) {
2394 return false;
2395 }
2396 if (tag != s_tag) {
2397 reader.fail();
2398 return false;
2399 }
2400 return true;
2401}
2402
2404{
2405 if (reader.noMore()) {
2406 reader.fail();
2407 return false;
2408 }
2409 if (!reader.readNested(loc)) {
2410 reader.fail();
2411 return false;
2412 }
2413 if (!reader.noMore()) {
2414 reader.fail();
2415 return false;
2416 }
2417 return true;
2418}
2419
2425
2431
2433{
2434 if (!writer.isNull()) {
2435 if (!writer.write(return_helper)) {
2436 return false;
2437 }
2438 }
2439 return true;
2440}
2441
2443{
2444 if (reader.noMore()) {
2445 reader.fail();
2446 return false;
2447 }
2448 if (!reader.read(return_helper)) {
2449 reader.fail();
2450 return false;
2451 }
2452 return true;
2453}
2454
2459
2460// follow_path_RPC helper class implementation
2465
2467{
2468 return cmd.write(connection);
2469}
2470
2472{
2473 return reply.read(connection);
2474}
2475
2480
2482{
2483 yarp::os::idl::WireWriter writer(connection);
2484 if (!writer.writeListHeader(s_cmd_len)) {
2485 return false;
2486 }
2487 return write(writer);
2488}
2489
2491{
2492 yarp::os::idl::WireReader reader(connection);
2493 if (!reader.readListHeader()) {
2494 reader.fail();
2495 return false;
2496 }
2497 return read(reader);
2498}
2499
2501{
2502 if (!writeTag(writer)) {
2503 return false;
2504 }
2505 if (!writeArgs(writer)) {
2506 return false;
2507 }
2508 return true;
2509}
2510
2512{
2513 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2514 return false;
2515 }
2516 return true;
2517}
2518
2520{
2521 if (!writer.writeNested(path)) {
2522 return false;
2523 }
2524 return true;
2525}
2526
2528{
2529 if (!readTag(reader)) {
2530 return false;
2531 }
2532 if (!readArgs(reader)) {
2533 return false;
2534 }
2535 return true;
2536}
2537
2539{
2540 std::string tag = reader.readTag(s_tag_len);
2541 if (reader.isError()) {
2542 return false;
2543 }
2544 if (tag != s_tag) {
2545 reader.fail();
2546 return false;
2547 }
2548 return true;
2549}
2550
2552{
2553 if (reader.noMore()) {
2554 reader.fail();
2555 return false;
2556 }
2557 if (!reader.readNested(path)) {
2558 reader.fail();
2559 return false;
2560 }
2561 if (!reader.noMore()) {
2562 reader.fail();
2563 return false;
2564 }
2565 return true;
2566}
2567
2569{
2570 yarp::os::idl::WireWriter writer(connection);
2571 return write(writer);
2572}
2573
2575{
2576 yarp::os::idl::WireReader reader(connection);
2577 return read(reader);
2578}
2579
2581{
2582 if (!writer.isNull()) {
2583 if (!writer.write(return_helper)) {
2584 return false;
2585 }
2586 }
2587 return true;
2588}
2589
2591{
2592 if (reader.noMore()) {
2593 reader.fail();
2594 return false;
2595 }
2596 if (!reader.read(return_helper)) {
2597 reader.fail();
2598 return false;
2599 }
2600 return true;
2601}
2602
2607
2608// goto_target_by_relative_location1_RPC helper class implementation
2613
2618
2623
2625 x{x},
2626 y{y}
2627{
2628}
2629
2631{
2632 yarp::os::idl::WireWriter writer(connection);
2633 if (!writer.writeListHeader(s_cmd_len)) {
2634 return false;
2635 }
2636 return write(writer);
2637}
2638
2640{
2641 yarp::os::idl::WireReader reader(connection);
2642 if (!reader.readListHeader()) {
2643 reader.fail();
2644 return false;
2645 }
2646 return read(reader);
2647}
2648
2650{
2651 if (!writeTag(writer)) {
2652 return false;
2653 }
2654 if (!writeArgs(writer)) {
2655 return false;
2656 }
2657 return true;
2658}
2659
2661{
2662 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2663 return false;
2664 }
2665 return true;
2666}
2667
2669{
2670 if (!writer.writeFloat64(x)) {
2671 return false;
2672 }
2673 if (!writer.writeFloat64(y)) {
2674 return false;
2675 }
2676 return true;
2677}
2678
2680{
2681 if (!readTag(reader)) {
2682 return false;
2683 }
2684 if (!readArgs(reader)) {
2685 return false;
2686 }
2687 return true;
2688}
2689
2691{
2692 std::string tag = reader.readTag(s_tag_len);
2693 if (reader.isError()) {
2694 return false;
2695 }
2696 if (tag != s_tag) {
2697 reader.fail();
2698 return false;
2699 }
2700 return true;
2701}
2702
2704{
2705 if (reader.noMore()) {
2706 reader.fail();
2707 return false;
2708 }
2709 if (!reader.readFloat64(x)) {
2710 reader.fail();
2711 return false;
2712 }
2713 if (reader.noMore()) {
2714 reader.fail();
2715 return false;
2716 }
2717 if (!reader.readFloat64(y)) {
2718 reader.fail();
2719 return false;
2720 }
2721 if (!reader.noMore()) {
2722 reader.fail();
2723 return false;
2724 }
2725 return true;
2726}
2727
2733
2739
2741{
2742 if (!writer.isNull()) {
2743 if (!writer.write(return_helper)) {
2744 return false;
2745 }
2746 }
2747 return true;
2748}
2749
2751{
2752 if (reader.noMore()) {
2753 reader.fail();
2754 return false;
2755 }
2756 if (!reader.read(return_helper)) {
2757 reader.fail();
2758 return false;
2759 }
2760 return true;
2761}
2762
2767
2768// goto_target_by_relative_location2_RPC helper class implementation
2773
2778
2783
2785 x{x},
2786 y{y},
2787 theta{theta}
2788{
2789}
2790
2792{
2793 yarp::os::idl::WireWriter writer(connection);
2794 if (!writer.writeListHeader(s_cmd_len)) {
2795 return false;
2796 }
2797 return write(writer);
2798}
2799
2801{
2802 yarp::os::idl::WireReader reader(connection);
2803 if (!reader.readListHeader()) {
2804 reader.fail();
2805 return false;
2806 }
2807 return read(reader);
2808}
2809
2811{
2812 if (!writeTag(writer)) {
2813 return false;
2814 }
2815 if (!writeArgs(writer)) {
2816 return false;
2817 }
2818 return true;
2819}
2820
2822{
2823 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2824 return false;
2825 }
2826 return true;
2827}
2828
2830{
2831 if (!writer.writeFloat64(x)) {
2832 return false;
2833 }
2834 if (!writer.writeFloat64(y)) {
2835 return false;
2836 }
2837 if (!writer.writeFloat64(theta)) {
2838 return false;
2839 }
2840 return true;
2841}
2842
2844{
2845 if (!readTag(reader)) {
2846 return false;
2847 }
2848 if (!readArgs(reader)) {
2849 return false;
2850 }
2851 return true;
2852}
2853
2855{
2856 std::string tag = reader.readTag(s_tag_len);
2857 if (reader.isError()) {
2858 return false;
2859 }
2860 if (tag != s_tag) {
2861 reader.fail();
2862 return false;
2863 }
2864 return true;
2865}
2866
2868{
2869 if (reader.noMore()) {
2870 reader.fail();
2871 return false;
2872 }
2873 if (!reader.readFloat64(x)) {
2874 reader.fail();
2875 return false;
2876 }
2877 if (reader.noMore()) {
2878 reader.fail();
2879 return false;
2880 }
2881 if (!reader.readFloat64(y)) {
2882 reader.fail();
2883 return false;
2884 }
2885 if (reader.noMore()) {
2886 reader.fail();
2887 return false;
2888 }
2889 if (!reader.readFloat64(theta)) {
2890 reader.fail();
2891 return false;
2892 }
2893 if (!reader.noMore()) {
2894 reader.fail();
2895 return false;
2896 }
2897 return true;
2898}
2899
2905
2911
2913{
2914 if (!writer.isNull()) {
2915 if (!writer.write(return_helper)) {
2916 return false;
2917 }
2918 }
2919 return true;
2920}
2921
2923{
2924 if (reader.noMore()) {
2925 reader.fail();
2926 return false;
2927 }
2928 if (!reader.read(return_helper)) {
2929 reader.fail();
2930 return false;
2931 }
2932 return true;
2933}
2934
2939
2940// get_absolute_location_of_current_target_RPC helper class implementation
2945
2950
2952{
2953 yarp::os::idl::WireWriter writer(connection);
2954 if (!writer.writeListHeader(s_cmd_len)) {
2955 return false;
2956 }
2957 return write(writer);
2958}
2959
2961{
2962 yarp::os::idl::WireReader reader(connection);
2963 if (!reader.readListHeader()) {
2964 reader.fail();
2965 return false;
2966 }
2967 return read(reader);
2968}
2969
2971{
2972 if (!writeTag(writer)) {
2973 return false;
2974 }
2975 if (!writeArgs(writer)) {
2976 return false;
2977 }
2978 return true;
2979}
2980
2982{
2983 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2984 return false;
2985 }
2986 return true;
2987}
2988
2993
2995{
2996 if (!readTag(reader)) {
2997 return false;
2998 }
2999 if (!readArgs(reader)) {
3000 return false;
3001 }
3002 return true;
3003}
3004
3006{
3007 std::string tag = reader.readTag(s_tag_len);
3008 if (reader.isError()) {
3009 return false;
3010 }
3011 if (tag != s_tag) {
3012 reader.fail();
3013 return false;
3014 }
3015 return true;
3016}
3017
3019{
3020 if (!reader.noMore()) {
3021 reader.fail();
3022 return false;
3023 }
3024 return true;
3025}
3026
3032
3038
3040{
3041 if (!writer.isNull()) {
3042 if (!writer.writeListHeader(s_reply_len)) {
3043 return false;
3044 }
3045 if (!writer.write(return_helper)) {
3046 return false;
3047 }
3048 }
3049 return true;
3050}
3051
3053{
3054 if (!reader.readListReturn()) {
3055 return false;
3056 }
3057 if (reader.noMore()) {
3058 reader.fail();
3059 return false;
3060 }
3061 if (!reader.read(return_helper)) {
3062 reader.fail();
3063 return false;
3064 }
3065 return true;
3066}
3067
3072
3073// get_relative_location_of_current_target_RPC helper class implementation
3078
3083
3085{
3086 yarp::os::idl::WireWriter writer(connection);
3087 if (!writer.writeListHeader(s_cmd_len)) {
3088 return false;
3089 }
3090 return write(writer);
3091}
3092
3094{
3095 yarp::os::idl::WireReader reader(connection);
3096 if (!reader.readListHeader()) {
3097 reader.fail();
3098 return false;
3099 }
3100 return read(reader);
3101}
3102
3104{
3105 if (!writeTag(writer)) {
3106 return false;
3107 }
3108 if (!writeArgs(writer)) {
3109 return false;
3110 }
3111 return true;
3112}
3113
3115{
3116 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3117 return false;
3118 }
3119 return true;
3120}
3121
3126
3128{
3129 if (!readTag(reader)) {
3130 return false;
3131 }
3132 if (!readArgs(reader)) {
3133 return false;
3134 }
3135 return true;
3136}
3137
3139{
3140 std::string tag = reader.readTag(s_tag_len);
3141 if (reader.isError()) {
3142 return false;
3143 }
3144 if (tag != s_tag) {
3145 reader.fail();
3146 return false;
3147 }
3148 return true;
3149}
3150
3152{
3153 if (!reader.noMore()) {
3154 reader.fail();
3155 return false;
3156 }
3157 return true;
3158}
3159
3165
3171
3173{
3174 if (!writer.isNull()) {
3175 if (!writer.writeListHeader(s_reply_len)) {
3176 return false;
3177 }
3178 if (!writer.write(return_helper)) {
3179 return false;
3180 }
3181 }
3182 return true;
3183}
3184
3186{
3187 if (!reader.readListReturn()) {
3188 return false;
3189 }
3190 if (reader.noMore()) {
3191 reader.fail();
3192 return false;
3193 }
3194 if (!reader.read(return_helper)) {
3195 reader.fail();
3196 return false;
3197 }
3198 return true;
3199}
3200
3205
3206// goto_target_by_absolute_location_and_set_name_RPC helper class implementation
3211
3216
3221
3227
3229{
3230 yarp::os::idl::WireWriter writer(connection);
3231 if (!writer.writeListHeader(s_cmd_len)) {
3232 return false;
3233 }
3234 return write(writer);
3235}
3236
3238{
3239 yarp::os::idl::WireReader reader(connection);
3240 if (!reader.readListHeader()) {
3241 reader.fail();
3242 return false;
3243 }
3244 return read(reader);
3245}
3246
3248{
3249 if (!writeTag(writer)) {
3250 return false;
3251 }
3252 if (!writeArgs(writer)) {
3253 return false;
3254 }
3255 return true;
3256}
3257
3259{
3260 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3261 return false;
3262 }
3263 return true;
3264}
3265
3267{
3268 if (!writer.writeNested(loc)) {
3269 return false;
3270 }
3271 if (!writer.writeString(name)) {
3272 return false;
3273 }
3274 return true;
3275}
3276
3278{
3279 if (!readTag(reader)) {
3280 return false;
3281 }
3282 if (!readArgs(reader)) {
3283 return false;
3284 }
3285 return true;
3286}
3287
3289{
3290 std::string tag = reader.readTag(s_tag_len);
3291 if (reader.isError()) {
3292 return false;
3293 }
3294 if (tag != s_tag) {
3295 reader.fail();
3296 return false;
3297 }
3298 return true;
3299}
3300
3302{
3303 if (reader.noMore()) {
3304 reader.fail();
3305 return false;
3306 }
3307 if (!reader.readNested(loc)) {
3308 reader.fail();
3309 return false;
3310 }
3311 if (reader.noMore()) {
3312 reader.fail();
3313 return false;
3314 }
3315 if (!reader.readString(name)) {
3316 reader.fail();
3317 return false;
3318 }
3319 if (!reader.noMore()) {
3320 reader.fail();
3321 return false;
3322 }
3323 return true;
3324}
3325
3331
3337
3339{
3340 if (!writer.isNull()) {
3341 if (!writer.write(return_helper)) {
3342 return false;
3343 }
3344 }
3345 return true;
3346}
3347
3349{
3350 if (reader.noMore()) {
3351 reader.fail();
3352 return false;
3353 }
3354 if (!reader.read(return_helper)) {
3355 reader.fail();
3356 return false;
3357 }
3358 return true;
3359}
3360
3365
3366// apply_velocity_command_RPC helper class implementation
3367INavigation2DMsgs_apply_velocity_command_RPC_helper::INavigation2DMsgs_apply_velocity_command_RPC_helper(const double x_vel, const double y_vel, const double theta_vel, const double timeout) :
3368 cmd{x_vel, y_vel, theta_vel, timeout}
3369{
3370}
3371
3373{
3374 return cmd.write(connection);
3375}
3376
3381
3382INavigation2DMsgs_apply_velocity_command_RPC_helper::Command::Command(const double x_vel, const double y_vel, const double theta_vel, const double timeout) :
3383 x_vel{x_vel},
3384 y_vel{y_vel},
3385 theta_vel{theta_vel},
3386 timeout{timeout}
3387{
3388}
3389
3391{
3392 yarp::os::idl::WireWriter writer(connection);
3393 if (!writer.writeListHeader(s_cmd_len)) {
3394 return false;
3395 }
3396 return write(writer);
3397}
3398
3400{
3401 yarp::os::idl::WireReader reader(connection);
3402 if (!reader.readListHeader()) {
3403 reader.fail();
3404 return false;
3405 }
3406 return read(reader);
3407}
3408
3410{
3411 if (!writeTag(writer)) {
3412 return false;
3413 }
3414 if (!writeArgs(writer)) {
3415 return false;
3416 }
3417 return true;
3418}
3419
3421{
3422 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3423 return false;
3424 }
3425 return true;
3426}
3427
3429{
3430 if (!writer.writeFloat64(x_vel)) {
3431 return false;
3432 }
3433 if (!writer.writeFloat64(y_vel)) {
3434 return false;
3435 }
3436 if (!writer.writeFloat64(theta_vel)) {
3437 return false;
3438 }
3439 if (!writer.writeFloat64(timeout)) {
3440 return false;
3441 }
3442 return true;
3443}
3444
3446{
3447 if (!readTag(reader)) {
3448 return false;
3449 }
3450 if (!readArgs(reader)) {
3451 return false;
3452 }
3453 return true;
3454}
3455
3457{
3458 std::string tag = reader.readTag(s_tag_len);
3459 if (reader.isError()) {
3460 return false;
3461 }
3462 if (tag != s_tag) {
3463 reader.fail();
3464 return false;
3465 }
3466 return true;
3467}
3468
3470{
3471 if (reader.noMore()) {
3472 reader.fail();
3473 return false;
3474 }
3475 if (!reader.readFloat64(x_vel)) {
3476 reader.fail();
3477 return false;
3478 }
3479 if (reader.noMore()) {
3480 reader.fail();
3481 return false;
3482 }
3483 if (!reader.readFloat64(y_vel)) {
3484 reader.fail();
3485 return false;
3486 }
3487 if (reader.noMore()) {
3488 reader.fail();
3489 return false;
3490 }
3491 if (!reader.readFloat64(theta_vel)) {
3492 reader.fail();
3493 return false;
3494 }
3495 if (reader.noMore()) {
3496 reader.fail();
3497 return false;
3498 }
3499 if (!reader.readFloat64(timeout)) {
3500 reader.fail();
3501 return false;
3502 }
3503 if (!reader.noMore()) {
3504 reader.fail();
3505 return false;
3506 }
3507 return true;
3508}
3509
3511{
3512 yarp::os::idl::WireWriter writer(connection);
3513 return write(writer);
3514}
3515
3521
3523{
3524 if (!writer.isNull()) {
3525 if (!writer.write(return_helper)) {
3526 return false;
3527 }
3528 }
3529 return true;
3530}
3531
3533{
3534 if (reader.noMore()) {
3535 reader.fail();
3536 return false;
3537 }
3538 if (!reader.read(return_helper)) {
3539 reader.fail();
3540 return false;
3541 }
3542 return true;
3543}
3544
3549
3550// get_last_velocity_command_RPC helper class implementation
3555
3560
3562{
3563 yarp::os::idl::WireWriter writer(connection);
3564 if (!writer.writeListHeader(s_cmd_len)) {
3565 return false;
3566 }
3567 return write(writer);
3568}
3569
3571{
3572 yarp::os::idl::WireReader reader(connection);
3573 if (!reader.readListHeader()) {
3574 reader.fail();
3575 return false;
3576 }
3577 return read(reader);
3578}
3579
3581{
3582 if (!writeTag(writer)) {
3583 return false;
3584 }
3585 if (!writeArgs(writer)) {
3586 return false;
3587 }
3588 return true;
3589}
3590
3592{
3593 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3594 return false;
3595 }
3596 return true;
3597}
3598
3600{
3601 return true;
3602}
3603
3605{
3606 if (!readTag(reader)) {
3607 return false;
3608 }
3609 if (!readArgs(reader)) {
3610 return false;
3611 }
3612 return true;
3613}
3614
3616{
3617 std::string tag = reader.readTag(s_tag_len);
3618 if (reader.isError()) {
3619 return false;
3620 }
3621 if (tag != s_tag) {
3622 reader.fail();
3623 return false;
3624 }
3625 return true;
3626}
3627
3629{
3630 if (!reader.noMore()) {
3631 reader.fail();
3632 return false;
3633 }
3634 return true;
3635}
3636
3638{
3639 yarp::os::idl::WireWriter writer(connection);
3640 return write(writer);
3641}
3642
3648
3650{
3651 if (!writer.isNull()) {
3652 if (!writer.writeListHeader(s_reply_len)) {
3653 return false;
3654 }
3655 if (!writer.write(return_helper)) {
3656 return false;
3657 }
3658 }
3659 return true;
3660}
3661
3663{
3664 if (!reader.readListReturn()) {
3665 return false;
3666 }
3667 if (reader.noMore()) {
3668 reader.fail();
3669 return false;
3670 }
3671 if (!reader.read(return_helper)) {
3672 reader.fail();
3673 return false;
3674 }
3675 return true;
3676}
3677
3682
3683// get_name_of_current_target_RPC helper class implementation
3688
3693
3695{
3696 yarp::os::idl::WireWriter writer(connection);
3697 if (!writer.writeListHeader(s_cmd_len)) {
3698 return false;
3699 }
3700 return write(writer);
3701}
3702
3704{
3705 yarp::os::idl::WireReader reader(connection);
3706 if (!reader.readListHeader()) {
3707 reader.fail();
3708 return false;
3709 }
3710 return read(reader);
3711}
3712
3714{
3715 if (!writeTag(writer)) {
3716 return false;
3717 }
3718 if (!writeArgs(writer)) {
3719 return false;
3720 }
3721 return true;
3722}
3723
3725{
3726 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3727 return false;
3728 }
3729 return true;
3730}
3731
3733{
3734 return true;
3735}
3736
3738{
3739 if (!readTag(reader)) {
3740 return false;
3741 }
3742 if (!readArgs(reader)) {
3743 return false;
3744 }
3745 return true;
3746}
3747
3749{
3750 std::string tag = reader.readTag(s_tag_len);
3751 if (reader.isError()) {
3752 return false;
3753 }
3754 if (tag != s_tag) {
3755 reader.fail();
3756 return false;
3757 }
3758 return true;
3759}
3760
3762{
3763 if (!reader.noMore()) {
3764 reader.fail();
3765 return false;
3766 }
3767 return true;
3768}
3769
3775
3781
3783{
3784 if (!writer.isNull()) {
3785 if (!writer.writeListHeader(s_reply_len)) {
3786 return false;
3787 }
3788 if (!writer.write(return_helper)) {
3789 return false;
3790 }
3791 }
3792 return true;
3793}
3794
3796{
3797 if (!reader.readListReturn()) {
3798 return false;
3799 }
3800 if (reader.noMore()) {
3801 reader.fail();
3802 return false;
3803 }
3804 if (!reader.read(return_helper)) {
3805 reader.fail();
3806 return false;
3807 }
3808 return true;
3809}
3810
3815
3816// Constructor
3818{
3819 yarp().setOwner(*this);
3820}
3821
3823{
3824 if (!yarp().canWrite()) {
3826 }
3828 bool ok = yarp().write(helper, helper);
3830}
3831
3833{
3834 if (!yarp().canWrite()) {
3836 }
3838 bool ok = yarp().write(helper, helper);
3840}
3841
3843{
3844 if (!yarp().canWrite()) {
3846 }
3848 bool ok = yarp().write(helper, helper);
3850}
3851
3861
3863{
3864 if (!yarp().canWrite()) {
3866 }
3868 bool ok = yarp().write(helper, helper);
3869 if (!ok) {
3870 return_get_navigation_status failed_reply{};
3872 return failed_reply;
3873 }
3874 return helper.reply.return_helper;
3875}
3876
3878{
3879 if (!yarp().canWrite()) {
3881 }
3883 bool ok = yarp().write(helper, helper);
3884 if (!ok) {
3885 return_get_current_nav_waypoint failed_reply{};
3887 return failed_reply;
3888 }
3889 return helper.reply.return_helper;
3890}
3891
3893{
3894 if (!yarp().canWrite()) {
3896 }
3898 bool ok = yarp().write(helper, helper);
3899 if (!ok) {
3900 return_get_all_nav_waypoints failed_reply{};
3902 return failed_reply;
3903 }
3904 return helper.reply.return_helper;
3905}
3906
3908{
3909 if (!yarp().canWrite()) {
3911 }
3913 bool ok = yarp().write(helper, helper);
3914 if (!ok) {
3915 return_get_current_nav_map failed_reply{};
3917 return failed_reply;
3918 }
3919 return helper.reply.return_helper;
3920}
3921
3931
3933{
3934 if (!yarp().canWrite()) {
3935 yError("Missing server method '%s'?", INavigation2DMsgs_follow_path_RPC_helper::s_prototype);
3936 }
3938 bool ok = yarp().write(helper, helper);
3940}
3941
3943{
3944 if (!yarp().canWrite()) {
3946 }
3948 bool ok = yarp().write(helper, helper);
3950}
3951
3953{
3954 if (!yarp().canWrite()) {
3956 }
3958 bool ok = yarp().write(helper, helper);
3960}
3961
3963{
3964 if (!yarp().canWrite()) {
3966 }
3968 bool ok = yarp().write(helper, helper);
3969 if (!ok) {
3970 return_get_abs_loc_of_curr_target failed_reply{};
3972 return failed_reply;
3973 }
3974 return helper.reply.return_helper;
3975}
3976
3978{
3979 if (!yarp().canWrite()) {
3981 }
3983 bool ok = yarp().write(helper, helper);
3984 if (!ok) {
3985 return_get_rel_loc_of_curr_target failed_reply{};
3987 return failed_reply;
3988 }
3989 return helper.reply.return_helper;
3990}
3991
4001
4002yarp::dev::ReturnValue INavigation2DMsgs::apply_velocity_command_RPC(const double x_vel, const double y_vel, const double theta_vel, const double timeout)
4003{
4004 if (!yarp().canWrite()) {
4006 }
4007 INavigation2DMsgs_apply_velocity_command_RPC_helper helper{x_vel, y_vel, theta_vel, timeout};
4008 bool ok = yarp().write(helper, helper);
4010}
4011
4013{
4014 if (!yarp().canWrite()) {
4016 }
4018 bool ok = yarp().write(helper, helper);
4019 if (!ok) {
4020 return_get_last_velocity_command failed_reply{};
4022 return failed_reply;
4023 }
4024 return helper.reply.return_helper;
4025}
4026
4028{
4029 if (!yarp().canWrite()) {
4031 }
4033 bool ok = yarp().write(helper, helper);
4034 if (!ok) {
4035 return_get_name_of_current_target failed_reply{};
4037 return failed_reply;
4038 }
4039 return helper.reply.return_helper;
4040}
4041
4042// help method
4043std::vector<std::string> INavigation2DMsgs::help(const std::string& functionName)
4044{
4045 bool showAll = (functionName == "--all");
4046 std::vector<std::string> helpString;
4047 if (showAll) {
4048 helpString.emplace_back("*** Available commands:");
4058 helpString.emplace_back(INavigation2DMsgs_follow_path_RPC_helper::s_tag);
4067 helpString.emplace_back("help");
4068 } else {
4071 }
4074 }
4077 }
4080 }
4083 }
4086 }
4089 }
4092 }
4095 }
4098 }
4101 }
4104 }
4107 }
4110 }
4113 }
4116 }
4119 }
4122 }
4123 if (functionName == "help") {
4124 helpString.emplace_back("std::vector<std::string> help(const std::string& functionName = \"--all\")");
4125 helpString.emplace_back("Return list of available commands, or help message for a specific function");
4126 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");
4127 helpString.emplace_back("@return list of strings (one string per line)");
4128 }
4129 }
4130 if (helpString.empty()) {
4131 helpString.emplace_back("Command not found");
4132 }
4133 return helpString;
4134}
4135
4136// read from ConnectionReader
4138{
4139 constexpr size_t max_tag_len = 9;
4140 size_t tag_len = 1;
4141
4142 yarp::os::idl::WireReader reader(connection);
4143 reader.expectAccept();
4144 if (!reader.readListHeader()) {
4145 reader.fail();
4146 return false;
4147 }
4148
4149 std::string tag = reader.readTag(1);
4150 bool direct = (tag == "__direct__");
4151 if (direct) {
4152 tag = reader.readTag(1);
4153 }
4154 while (tag_len <= max_tag_len && !reader.isError()) {
4155 if(tag == "getRemoteProtocolVersion") {
4156 if (!reader.noMore()) {
4157 yError("Reader invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
4158 reader.fail();
4159 return false;
4160 }
4161
4162 auto proto = getLocalProtocolVersion();
4163
4164 yarp::os::idl::WireWriter writer(reader);
4165 if (!writer.writeListHeader(1)) {
4166 yWarning("Writer invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
4167 return false;}
4168 if (!writer.write(proto)) {
4169 yWarning("Writer invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
4170 return false;
4171 }
4172 reader.accept();
4173 return true;
4174 }
4177 if (!helper.cmd.readArgs(reader)) {
4178 return false;
4179 }
4180
4181 helper.call(this);
4182
4183 yarp::os::idl::WireWriter writer(reader);
4184 if (!helper.reply.write(writer)) {
4185 return false;
4186 }
4187 reader.accept();
4188 return true;
4189 }
4192 if (!helper.cmd.readArgs(reader)) {
4193 return false;
4194 }
4195
4196 helper.call(this);
4197
4198 yarp::os::idl::WireWriter writer(reader);
4199 if (!helper.reply.write(writer)) {
4200 return false;
4201 }
4202 reader.accept();
4203 return true;
4204 }
4207 if (!helper.cmd.readArgs(reader)) {
4208 return false;
4209 }
4210
4211 helper.call(this);
4212
4213 yarp::os::idl::WireWriter writer(reader);
4214 if (!helper.reply.write(writer)) {
4215 return false;
4216 }
4217 reader.accept();
4218 return true;
4219 }
4222 if (!helper.cmd.readArgs(reader)) {
4223 return false;
4224 }
4225
4226 helper.call(this);
4227
4228 yarp::os::idl::WireWriter writer(reader);
4229 if (!helper.reply.write(writer)) {
4230 return false;
4231 }
4232 reader.accept();
4233 return true;
4234 }
4237 if (!helper.cmd.readArgs(reader)) {
4238 return false;
4239 }
4240
4241 helper.call(this);
4242
4243 yarp::os::idl::WireWriter writer(reader);
4244 if (!helper.reply.write(writer)) {
4245 return false;
4246 }
4247 reader.accept();
4248 return true;
4249 }
4252 if (!helper.cmd.readArgs(reader)) {
4253 return false;
4254 }
4255
4256 helper.call(this);
4257
4258 yarp::os::idl::WireWriter writer(reader);
4259 if (!helper.reply.write(writer)) {
4260 return false;
4261 }
4262 reader.accept();
4263 return true;
4264 }
4267 if (!helper.cmd.readArgs(reader)) {
4268 return false;
4269 }
4270
4271 helper.call(this);
4272
4273 yarp::os::idl::WireWriter writer(reader);
4274 if (!helper.reply.write(writer)) {
4275 return false;
4276 }
4277 reader.accept();
4278 return true;
4279 }
4282 if (!helper.cmd.readArgs(reader)) {
4283 return false;
4284 }
4285
4286 helper.call(this);
4287
4288 yarp::os::idl::WireWriter writer(reader);
4289 if (!helper.reply.write(writer)) {
4290 return false;
4291 }
4292 reader.accept();
4293 return true;
4294 }
4297 if (!helper.cmd.readArgs(reader)) {
4298 return false;
4299 }
4300
4301 helper.call(this);
4302
4303 yarp::os::idl::WireWriter writer(reader);
4304 if (!helper.reply.write(writer)) {
4305 return false;
4306 }
4307 reader.accept();
4308 return true;
4309 }
4312 if (!helper.cmd.readArgs(reader)) {
4313 return false;
4314 }
4315
4316 helper.call(this);
4317
4318 yarp::os::idl::WireWriter writer(reader);
4319 if (!helper.reply.write(writer)) {
4320 return false;
4321 }
4322 reader.accept();
4323 return true;
4324 }
4327 if (!helper.cmd.readArgs(reader)) {
4328 return false;
4329 }
4330
4331 helper.call(this);
4332
4333 yarp::os::idl::WireWriter writer(reader);
4334 if (!helper.reply.write(writer)) {
4335 return false;
4336 }
4337 reader.accept();
4338 return true;
4339 }
4342 if (!helper.cmd.readArgs(reader)) {
4343 return false;
4344 }
4345
4346 helper.call(this);
4347
4348 yarp::os::idl::WireWriter writer(reader);
4349 if (!helper.reply.write(writer)) {
4350 return false;
4351 }
4352 reader.accept();
4353 return true;
4354 }
4357 if (!helper.cmd.readArgs(reader)) {
4358 return false;
4359 }
4360
4361 helper.call(this);
4362
4363 yarp::os::idl::WireWriter writer(reader);
4364 if (!helper.reply.write(writer)) {
4365 return false;
4366 }
4367 reader.accept();
4368 return true;
4369 }
4372 if (!helper.cmd.readArgs(reader)) {
4373 return false;
4374 }
4375
4376 helper.call(this);
4377
4378 yarp::os::idl::WireWriter writer(reader);
4379 if (!helper.reply.write(writer)) {
4380 return false;
4381 }
4382 reader.accept();
4383 return true;
4384 }
4387 if (!helper.cmd.readArgs(reader)) {
4388 return false;
4389 }
4390
4391 helper.call(this);
4392
4393 yarp::os::idl::WireWriter writer(reader);
4394 if (!helper.reply.write(writer)) {
4395 return false;
4396 }
4397 reader.accept();
4398 return true;
4399 }
4402 if (!helper.cmd.readArgs(reader)) {
4403 return false;
4404 }
4405
4406 helper.call(this);
4407
4408 yarp::os::idl::WireWriter writer(reader);
4409 if (!helper.reply.write(writer)) {
4410 return false;
4411 }
4412 reader.accept();
4413 return true;
4414 }
4417 if (!helper.cmd.readArgs(reader)) {
4418 return false;
4419 }
4420
4421 helper.call(this);
4422
4423 yarp::os::idl::WireWriter writer(reader);
4424 if (!helper.reply.write(writer)) {
4425 return false;
4426 }
4427 reader.accept();
4428 return true;
4429 }
4432 if (!helper.cmd.readArgs(reader)) {
4433 return false;
4434 }
4435
4436 helper.call(this);
4437
4438 yarp::os::idl::WireWriter writer(reader);
4439 if (!helper.reply.write(writer)) {
4440 return false;
4441 }
4442 reader.accept();
4443 return true;
4444 }
4445 if (tag == "help") {
4446 std::string functionName;
4447 if (!reader.readString(functionName)) {
4448 functionName = "--all";
4449 }
4450 auto help_strings = help(functionName);
4451 yarp::os::idl::WireWriter writer(reader);
4452 if (!writer.isNull()) {
4453 if (!writer.writeListHeader(2)) {
4454 return false;
4455 }
4456 if (!writer.writeTag("many", 1, 0)) {
4457 return false;
4458 }
4459 if (!writer.writeListBegin(0, help_strings.size())) {
4460 return false;
4461 }
4462 for (const auto& help_string : help_strings) {
4463 if (!writer.writeString(help_string)) {
4464 return false;
4465 }
4466 }
4467 if (!writer.writeListEnd()) {
4468 return false;
4469 }
4470 }
4471 reader.accept();
4472 return true;
4473 }
4474 if (reader.noMore()) {
4475 reader.fail();
4476 return false;
4477 }
4478 std::string next_tag = reader.readTag(1);
4479 if (next_tag.empty()) {
4480 break;
4481 }
4482 tag.append("_").append(next_tag);
4483 tag_len = std::count(tag.begin(), tag.end(), '_') + 1;
4484 }
4485 return false;
4486}
#define yError(...)
Definition Log.h:361
#define __YFUNCTION__
Definition Log.h:24
#define yWarning(...)
Definition Log.h:340
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
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.
yarp::dev::ReturnValue(*)(const double, const double, const double, const double) funcptr_t
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool 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 readArgs(yarp::os::idl::WireReader &reader)
bool readTag(yarp::os::idl::WireReader &reader)
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool 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::dev::ReturnValue(*)(const yarp::dev::Nav2D::Map2DPath &) funcptr_t
static constexpr const char * s_prototype
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
yarp::os::ApplicationNetworkProtocolVersion helper_proto
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 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 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.
return_get_all_nav_waypoints(*)(const yarp::dev::Nav2D::TrajectoryTypeEnum) funcptr_t
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 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.
return_get_current_nav_map(*)(const yarp::dev::Nav2D::NavigationMapTypeEnum) funcptr_t
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 read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool 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 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 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 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 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 read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
yarp::dev::ReturnValue(*)(const yarp::dev::Nav2D::Map2DLocation &) funcptr_t
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
yarp::dev::ReturnValue(*)(const yarp::dev::Nav2D::Map2DLocation &, 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 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.
yarp::dev::ReturnValue(*)(const double, const double) funcptr_t
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 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.
yarp::dev::ReturnValue(*)(const double, const double, const double) funcptr_t
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
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 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 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.
yarp::dev::ReturnValue(*)(const double) funcptr_t
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
virtual yarp::dev::ReturnValue goto_target_by_absolute_location_RPC(const yarp::dev::Nav2D::Map2DLocation &loc)
virtual yarp::dev::ReturnValue goto_target_by_relative_location1_RPC(const double x, const double y)
virtual yarp::dev::ReturnValue goto_target_by_absolute_location_and_set_name_RPC(const yarp::dev::Nav2D::Map2DLocation &loc, const std::string &name)
virtual yarp::os::ApplicationNetworkProtocolVersion getRemoteProtocolVersion()
virtual return_get_abs_loc_of_curr_target get_absolute_location_of_current_target_RPC()
virtual yarp::os::ApplicationNetworkProtocolVersion getLocalProtocolVersion()
virtual return_get_last_velocity_command get_last_velocity_command_RPC()
virtual yarp::dev::ReturnValue resume_navigation_RPC()
virtual return_get_current_nav_map get_current_navigation_map_RPC(const yarp::dev::Nav2D::NavigationMapTypeEnum map_type)
virtual bool checkProtocolVersion()
virtual yarp::dev::ReturnValue follow_path_RPC(const yarp::dev::Nav2D::Map2DPath &path)
virtual yarp::dev::ReturnValue apply_velocity_command_RPC(const double x_vel, const double y_vel, const double theta_vel, const double timeout)
virtual return_get_navigation_status get_navigation_status_RPC()
virtual yarp::dev::ReturnValue suspend_navigation_RPC(const double time_s)
virtual std::vector< std::string > help(const std::string &functionName="--all")
virtual return_get_current_nav_waypoint get_current_nav_waypoint_RPC()
virtual yarp::dev::ReturnValue stop_navigation_RPC()
virtual yarp::dev::ReturnValue recompute_current_navigation_path_RPC()
virtual return_get_name_of_current_target get_name_of_current_target_RPC()
virtual return_get_rel_loc_of_curr_target get_relative_location_of_current_target_RPC()
virtual return_get_all_nav_waypoints get_all_navigation_waypoints_RPC(const yarp::dev::Nav2D::TrajectoryTypeEnum trajectory_type)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
virtual yarp::dev::ReturnValue goto_target_by_relative_location2_RPC(const double x, const double y, const double theta)
@ return_value_error_nws_nwc_communication_error
Method is not (yet) implemented.
An interface for reading from a network connection.
An interface for writing to a network connection.
This is a base class for objects that can be both read from and be written to the YARP network.
Definition Portable.h:25
yarp::os::WireLink & yarp()
Get YARP state associated with this object.
Definition Wire.h:28
A "tamed" Portable, that promises to serialize itself in an IDL-friendly way.
IDL-friendly connection reader.
Definition WireReader.h:27
bool readVocab32(yarp::conf::vocab32_t &x)
bool readNested(WirePortable &obj)
bool readString(std::string &str, bool *is_vocab=nullptr)
std::string readTag(size_t len=static_cast< size_t >(-1))
bool read(WirePortable &obj)
bool readFloat64(yarp::conf::float64_t &x)
IDL-friendly connection writer.
Definition WireWriter.h:28
bool writeVocab32(yarp::conf::vocab32_t 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 writeNested(const WirePortable &obj) const
bool writeListBegin(int tag, size_t len) const
#define yCError(component,...)
#define YARP_LOG_COMPONENT(name,...)
std::int32_t vocab32_t
Definition numeric.h:78
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