YARP
Yet Another Robot Platform
 
Loading...
Searching...
No Matches
IMap2DMsgs.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 Compiler (0.14.1-yarped)
7//
8// This is an automatically generated file.
9// It could get re-generated if the ALLOW_IDL_GENERATION flag is on.
10
11#include <IMap2DMsgs.h>
12
14
15#include <algorithm>
16
17// clear_all_maps_RPC helper class declaration
20{
21public:
23 bool write(yarp::os::ConnectionWriter& connection) const override;
24 bool read(yarp::os::ConnectionReader& connection) override;
25
26 class Command :
28 {
29 public:
30 Command() = default;
31 ~Command() override = default;
32
33 bool write(yarp::os::ConnectionWriter& connection) const override;
34 bool read(yarp::os::ConnectionReader& connection) override;
35
36 bool write(const yarp::os::idl::WireWriter& writer) const override;
37 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
38 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
39
40 bool read(yarp::os::idl::WireReader& reader) override;
43 };
44
45 class Reply :
47 {
48 public:
49 Reply() = default;
50 ~Reply() override = default;
51
52 bool write(yarp::os::ConnectionWriter& connection) const override;
53 bool read(yarp::os::ConnectionReader& connection) override;
54
55 bool write(const yarp::os::idl::WireWriter& writer) const override;
56 bool read(yarp::os::idl::WireReader& reader) override;
57
59 };
60
62 void call(IMap2DMsgs* ptr);
63
66
67 static constexpr const char* s_tag{"clear_all_maps_RPC"};
68 static constexpr size_t s_tag_len{4};
69 static constexpr size_t s_cmd_len{4};
70 static constexpr size_t s_reply_len{1};
71 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::clear_all_maps_RPC()"};
72 static constexpr const char* s_help{""};
73};
74
75// store_map_RPC helper class declaration
78{
79public:
82 bool write(yarp::os::ConnectionWriter& connection) const override;
83 bool read(yarp::os::ConnectionReader& connection) override;
84
85 class Command :
87 {
88 public:
89 Command() = default;
91
92 ~Command() override = default;
93
94 bool write(yarp::os::ConnectionWriter& connection) const override;
95 bool read(yarp::os::ConnectionReader& connection) override;
96
97 bool write(const yarp::os::idl::WireWriter& writer) const override;
98 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
99 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
100
101 bool read(yarp::os::idl::WireReader& reader) override;
104
106 };
107
108 class Reply :
110 {
111 public:
112 Reply() = default;
113 ~Reply() override = default;
114
115 bool write(yarp::os::ConnectionWriter& connection) const override;
116 bool read(yarp::os::ConnectionReader& connection) override;
117
118 bool write(const yarp::os::idl::WireWriter& writer) const override;
119 bool read(yarp::os::idl::WireReader& reader) override;
120
122 };
123
125 void call(IMap2DMsgs* ptr);
126
129
130 static constexpr const char* s_tag{"store_map_RPC"};
131 static constexpr size_t s_tag_len{3};
132 static constexpr size_t s_cmd_len{4};
133 static constexpr size_t s_reply_len{1};
134 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::store_map_RPC(const yarp::dev::Nav2D::MapGrid2D& themap)"};
135 static constexpr const char* s_help{""};
136};
137
138// get_map_RPC helper class declaration
140 public yarp::os::Portable
141{
142public:
144 explicit IMap2DMsgs_get_map_RPC_helper(const std::string& map_name);
145 bool write(yarp::os::ConnectionWriter& connection) const override;
146 bool read(yarp::os::ConnectionReader& connection) override;
147
148 class Command :
150 {
151 public:
152 Command() = default;
153 explicit Command(const std::string& map_name);
154
155 ~Command() override = default;
156
157 bool write(yarp::os::ConnectionWriter& connection) const override;
158 bool read(yarp::os::ConnectionReader& connection) override;
159
160 bool write(const yarp::os::idl::WireWriter& writer) const override;
161 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
162 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
163
164 bool read(yarp::os::idl::WireReader& reader) override;
167
168 std::string map_name{};
169 };
170
171 class Reply :
173 {
174 public:
175 Reply() = default;
176 ~Reply() override = default;
177
178 bool write(yarp::os::ConnectionWriter& connection) const override;
179 bool read(yarp::os::ConnectionReader& connection) override;
180
181 bool write(const yarp::os::idl::WireWriter& writer) const override;
182 bool read(yarp::os::idl::WireReader& reader) override;
183
185 };
186
187 using funcptr_t = return_get_map (*)(const std::string&);
188 void call(IMap2DMsgs* ptr);
189
192
193 static constexpr const char* s_tag{"get_map_RPC"};
194 static constexpr size_t s_tag_len{3};
195 static constexpr size_t s_cmd_len{4};
196 static constexpr size_t s_reply_len{2};
197 static constexpr const char* s_prototype{"return_get_map IMap2DMsgs::get_map_RPC(const std::string& map_name)"};
198 static constexpr const char* s_help{""};
199};
200
201// get_map_names_RPC helper class declaration
203 public yarp::os::Portable
204{
205public:
207 bool write(yarp::os::ConnectionWriter& connection) const override;
208 bool read(yarp::os::ConnectionReader& connection) override;
209
210 class Command :
212 {
213 public:
214 Command() = default;
215 ~Command() override = default;
216
217 bool write(yarp::os::ConnectionWriter& connection) const override;
218 bool read(yarp::os::ConnectionReader& connection) override;
219
220 bool write(const yarp::os::idl::WireWriter& writer) const override;
221 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
222 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
223
224 bool read(yarp::os::idl::WireReader& reader) override;
227 };
228
229 class Reply :
231 {
232 public:
233 Reply() = default;
234 ~Reply() override = default;
235
236 bool write(yarp::os::ConnectionWriter& connection) const override;
237 bool read(yarp::os::ConnectionReader& connection) override;
238
239 bool write(const yarp::os::idl::WireWriter& writer) const override;
240 bool read(yarp::os::idl::WireReader& reader) override;
241
243 };
244
246 void call(IMap2DMsgs* ptr);
247
250
251 static constexpr const char* s_tag{"get_map_names_RPC"};
252 static constexpr size_t s_tag_len{4};
253 static constexpr size_t s_cmd_len{4};
254 static constexpr size_t s_reply_len{2};
255 static constexpr const char* s_prototype{"return_get_map_names IMap2DMsgs::get_map_names_RPC()"};
256 static constexpr const char* s_help{""};
257};
258
259// remove_map_RPC helper class declaration
261 public yarp::os::Portable
262{
263public:
265 explicit IMap2DMsgs_remove_map_RPC_helper(const std::string& map_name);
266 bool write(yarp::os::ConnectionWriter& connection) const override;
267 bool read(yarp::os::ConnectionReader& connection) override;
268
269 class Command :
271 {
272 public:
273 Command() = default;
274 explicit Command(const std::string& map_name);
275
276 ~Command() override = default;
277
278 bool write(yarp::os::ConnectionWriter& connection) const override;
279 bool read(yarp::os::ConnectionReader& connection) override;
280
281 bool write(const yarp::os::idl::WireWriter& writer) const override;
282 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
283 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
284
285 bool read(yarp::os::idl::WireReader& reader) override;
288
289 std::string map_name{};
290 };
291
292 class Reply :
294 {
295 public:
296 Reply() = default;
297 ~Reply() override = default;
298
299 bool write(yarp::os::ConnectionWriter& connection) const override;
300 bool read(yarp::os::ConnectionReader& connection) override;
301
302 bool write(const yarp::os::idl::WireWriter& writer) const override;
303 bool read(yarp::os::idl::WireReader& reader) override;
304
306 };
307
308 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&);
309 void call(IMap2DMsgs* ptr);
310
313
314 static constexpr const char* s_tag{"remove_map_RPC"};
315 static constexpr size_t s_tag_len{3};
316 static constexpr size_t s_cmd_len{4};
317 static constexpr size_t s_reply_len{1};
318 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::remove_map_RPC(const std::string& map_name)"};
319 static constexpr const char* s_help{""};
320};
321
322// store_location_RPC helper class declaration
324 public yarp::os::Portable
325{
326public:
328 IMap2DMsgs_store_location_RPC_helper(const std::string& location_name, const yarp::dev::Nav2D::Map2DLocation& loc);
329 bool write(yarp::os::ConnectionWriter& connection) const override;
330 bool read(yarp::os::ConnectionReader& connection) override;
331
332 class Command :
334 {
335 public:
336 Command() = default;
337 Command(const std::string& location_name, const yarp::dev::Nav2D::Map2DLocation& loc);
338
339 ~Command() override = default;
340
341 bool write(yarp::os::ConnectionWriter& connection) const override;
342 bool read(yarp::os::ConnectionReader& connection) override;
343
344 bool write(const yarp::os::idl::WireWriter& writer) const override;
345 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
346 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
347
348 bool read(yarp::os::idl::WireReader& reader) override;
351
352 std::string location_name{};
354 };
355
356 class Reply :
358 {
359 public:
360 Reply() = default;
361 ~Reply() override = default;
362
363 bool write(yarp::os::ConnectionWriter& connection) const override;
364 bool read(yarp::os::ConnectionReader& connection) override;
365
366 bool write(const yarp::os::idl::WireWriter& writer) const override;
367 bool read(yarp::os::idl::WireReader& reader) override;
368
370 };
371
372 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&, const yarp::dev::Nav2D::Map2DLocation&);
373 void call(IMap2DMsgs* ptr);
374
377
378 static constexpr const char* s_tag{"store_location_RPC"};
379 static constexpr size_t s_tag_len{3};
380 static constexpr size_t s_cmd_len{5};
381 static constexpr size_t s_reply_len{1};
382 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::store_location_RPC(const std::string& location_name, const yarp::dev::Nav2D::Map2DLocation& loc)"};
383 static constexpr const char* s_help{""};
384};
385
386// store_area_RPC helper class declaration
388 public yarp::os::Portable
389{
390public:
392 IMap2DMsgs_store_area_RPC_helper(const std::string& area_name, const yarp::dev::Nav2D::Map2DArea& area);
393 bool write(yarp::os::ConnectionWriter& connection) const override;
394 bool read(yarp::os::ConnectionReader& connection) override;
395
396 class Command :
398 {
399 public:
400 Command() = default;
401 Command(const std::string& area_name, const yarp::dev::Nav2D::Map2DArea& area);
402
403 ~Command() override = default;
404
405 bool write(yarp::os::ConnectionWriter& connection) const override;
406 bool read(yarp::os::ConnectionReader& connection) override;
407
408 bool write(const yarp::os::idl::WireWriter& writer) const override;
409 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
410 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
411
412 bool read(yarp::os::idl::WireReader& reader) override;
415
416 std::string area_name{};
418 };
419
420 class Reply :
422 {
423 public:
424 Reply() = default;
425 ~Reply() override = default;
426
427 bool write(yarp::os::ConnectionWriter& connection) const override;
428 bool read(yarp::os::ConnectionReader& connection) override;
429
430 bool write(const yarp::os::idl::WireWriter& writer) const override;
431 bool read(yarp::os::idl::WireReader& reader) override;
432
434 };
435
436 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&, const yarp::dev::Nav2D::Map2DArea&);
437 void call(IMap2DMsgs* ptr);
438
441
442 static constexpr const char* s_tag{"store_area_RPC"};
443 static constexpr size_t s_tag_len{3};
444 static constexpr size_t s_cmd_len{5};
445 static constexpr size_t s_reply_len{1};
446 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::store_area_RPC(const std::string& area_name, const yarp::dev::Nav2D::Map2DArea& area)"};
447 static constexpr const char* s_help{""};
448};
449
450// store_path_RPC helper class declaration
452 public yarp::os::Portable
453{
454public:
456 IMap2DMsgs_store_path_RPC_helper(const std::string& path_name, const yarp::dev::Nav2D::Map2DPath& path);
457 bool write(yarp::os::ConnectionWriter& connection) const override;
458 bool read(yarp::os::ConnectionReader& connection) override;
459
460 class Command :
462 {
463 public:
464 Command() = default;
465 Command(const std::string& path_name, const yarp::dev::Nav2D::Map2DPath& path);
466
467 ~Command() override = default;
468
469 bool write(yarp::os::ConnectionWriter& connection) const override;
470 bool read(yarp::os::ConnectionReader& connection) override;
471
472 bool write(const yarp::os::idl::WireWriter& writer) const override;
473 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
474 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
475
476 bool read(yarp::os::idl::WireReader& reader) override;
479
480 std::string path_name{};
482 };
483
484 class Reply :
486 {
487 public:
488 Reply() = default;
489 ~Reply() override = default;
490
491 bool write(yarp::os::ConnectionWriter& connection) const override;
492 bool read(yarp::os::ConnectionReader& connection) override;
493
494 bool write(const yarp::os::idl::WireWriter& writer) const override;
495 bool read(yarp::os::idl::WireReader& reader) override;
496
498 };
499
500 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&, const yarp::dev::Nav2D::Map2DPath&);
501 void call(IMap2DMsgs* ptr);
502
505
506 static constexpr const char* s_tag{"store_path_RPC"};
507 static constexpr size_t s_tag_len{3};
508 static constexpr size_t s_cmd_len{5};
509 static constexpr size_t s_reply_len{1};
510 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::store_path_RPC(const std::string& path_name, const yarp::dev::Nav2D::Map2DPath& path)"};
511 static constexpr const char* s_help{""};
512};
513
514// get_location_RPC helper class declaration
516 public yarp::os::Portable
517{
518public:
520 explicit IMap2DMsgs_get_location_RPC_helper(const std::string& location_name);
521 bool write(yarp::os::ConnectionWriter& connection) const override;
522 bool read(yarp::os::ConnectionReader& connection) override;
523
524 class Command :
526 {
527 public:
528 Command() = default;
529 explicit Command(const std::string& location_name);
530
531 ~Command() override = default;
532
533 bool write(yarp::os::ConnectionWriter& connection) const override;
534 bool read(yarp::os::ConnectionReader& connection) override;
535
536 bool write(const yarp::os::idl::WireWriter& writer) const override;
537 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
538 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
539
540 bool read(yarp::os::idl::WireReader& reader) override;
543
544 std::string location_name{};
545 };
546
547 class Reply :
549 {
550 public:
551 Reply() = default;
552 ~Reply() override = default;
553
554 bool write(yarp::os::ConnectionWriter& connection) const override;
555 bool read(yarp::os::ConnectionReader& connection) override;
556
557 bool write(const yarp::os::idl::WireWriter& writer) const override;
558 bool read(yarp::os::idl::WireReader& reader) override;
559
561 };
562
563 using funcptr_t = return_get_location (*)(const std::string&);
564 void call(IMap2DMsgs* ptr);
565
568
569 static constexpr const char* s_tag{"get_location_RPC"};
570 static constexpr size_t s_tag_len{3};
571 static constexpr size_t s_cmd_len{4};
572 static constexpr size_t s_reply_len{2};
573 static constexpr const char* s_prototype{"return_get_location IMap2DMsgs::get_location_RPC(const std::string& location_name)"};
574 static constexpr const char* s_help{""};
575};
576
577// get_area_RPC helper class declaration
579 public yarp::os::Portable
580{
581public:
583 explicit IMap2DMsgs_get_area_RPC_helper(const std::string& area_name);
584 bool write(yarp::os::ConnectionWriter& connection) const override;
585 bool read(yarp::os::ConnectionReader& connection) override;
586
587 class Command :
589 {
590 public:
591 Command() = default;
592 explicit Command(const std::string& area_name);
593
594 ~Command() override = default;
595
596 bool write(yarp::os::ConnectionWriter& connection) const override;
597 bool read(yarp::os::ConnectionReader& connection) override;
598
599 bool write(const yarp::os::idl::WireWriter& writer) const override;
600 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
601 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
602
603 bool read(yarp::os::idl::WireReader& reader) override;
606
607 std::string area_name{};
608 };
609
610 class Reply :
612 {
613 public:
614 Reply() = default;
615 ~Reply() override = default;
616
617 bool write(yarp::os::ConnectionWriter& connection) const override;
618 bool read(yarp::os::ConnectionReader& connection) override;
619
620 bool write(const yarp::os::idl::WireWriter& writer) const override;
621 bool read(yarp::os::idl::WireReader& reader) override;
622
624 };
625
626 using funcptr_t = return_get_area (*)(const std::string&);
627 void call(IMap2DMsgs* ptr);
628
631
632 static constexpr const char* s_tag{"get_area_RPC"};
633 static constexpr size_t s_tag_len{3};
634 static constexpr size_t s_cmd_len{4};
635 static constexpr size_t s_reply_len{2};
636 static constexpr const char* s_prototype{"return_get_area IMap2DMsgs::get_area_RPC(const std::string& area_name)"};
637 static constexpr const char* s_help{""};
638};
639
640// get_path_RPC helper class declaration
642 public yarp::os::Portable
643{
644public:
646 explicit IMap2DMsgs_get_path_RPC_helper(const std::string& path_name);
647 bool write(yarp::os::ConnectionWriter& connection) const override;
648 bool read(yarp::os::ConnectionReader& connection) override;
649
650 class Command :
652 {
653 public:
654 Command() = default;
655 explicit Command(const std::string& path_name);
656
657 ~Command() override = default;
658
659 bool write(yarp::os::ConnectionWriter& connection) const override;
660 bool read(yarp::os::ConnectionReader& connection) override;
661
662 bool write(const yarp::os::idl::WireWriter& writer) const override;
663 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
664 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
665
666 bool read(yarp::os::idl::WireReader& reader) override;
669
670 std::string path_name{};
671 };
672
673 class Reply :
675 {
676 public:
677 Reply() = default;
678 ~Reply() override = default;
679
680 bool write(yarp::os::ConnectionWriter& connection) const override;
681 bool read(yarp::os::ConnectionReader& connection) override;
682
683 bool write(const yarp::os::idl::WireWriter& writer) const override;
684 bool read(yarp::os::idl::WireReader& reader) override;
685
687 };
688
689 using funcptr_t = return_get_path (*)(const std::string&);
690 void call(IMap2DMsgs* ptr);
691
694
695 static constexpr const char* s_tag{"get_path_RPC"};
696 static constexpr size_t s_tag_len{3};
697 static constexpr size_t s_cmd_len{4};
698 static constexpr size_t s_reply_len{2};
699 static constexpr const char* s_prototype{"return_get_path IMap2DMsgs::get_path_RPC(const std::string& path_name)"};
700 static constexpr const char* s_help{""};
701};
702
703// get_locations_list_RPC helper class declaration
705 public yarp::os::Portable
706{
707public:
709 bool write(yarp::os::ConnectionWriter& connection) const override;
710 bool read(yarp::os::ConnectionReader& connection) override;
711
712 class Command :
714 {
715 public:
716 Command() = default;
717 ~Command() override = default;
718
719 bool write(yarp::os::ConnectionWriter& connection) const override;
720 bool read(yarp::os::ConnectionReader& connection) override;
721
722 bool write(const yarp::os::idl::WireWriter& writer) const override;
723 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
724 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
725
726 bool read(yarp::os::idl::WireReader& reader) override;
729 };
730
731 class Reply :
733 {
734 public:
735 Reply() = default;
736 ~Reply() override = default;
737
738 bool write(yarp::os::ConnectionWriter& connection) const override;
739 bool read(yarp::os::ConnectionReader& connection) override;
740
741 bool write(const yarp::os::idl::WireWriter& writer) const override;
742 bool read(yarp::os::idl::WireReader& reader) override;
743
745 };
746
748 void call(IMap2DMsgs* ptr);
749
752
753 static constexpr const char* s_tag{"get_locations_list_RPC"};
754 static constexpr size_t s_tag_len{4};
755 static constexpr size_t s_cmd_len{4};
756 static constexpr size_t s_reply_len{2};
757 static constexpr const char* s_prototype{"return_get_locations_list IMap2DMsgs::get_locations_list_RPC()"};
758 static constexpr const char* s_help{""};
759};
760
761// get_areas_list_RPC helper class declaration
763 public yarp::os::Portable
764{
765public:
767 bool write(yarp::os::ConnectionWriter& connection) const override;
768 bool read(yarp::os::ConnectionReader& connection) override;
769
770 class Command :
772 {
773 public:
774 Command() = default;
775 ~Command() override = default;
776
777 bool write(yarp::os::ConnectionWriter& connection) const override;
778 bool read(yarp::os::ConnectionReader& connection) override;
779
780 bool write(const yarp::os::idl::WireWriter& writer) const override;
781 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
782 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
783
784 bool read(yarp::os::idl::WireReader& reader) override;
787 };
788
789 class Reply :
791 {
792 public:
793 Reply() = default;
794 ~Reply() override = default;
795
796 bool write(yarp::os::ConnectionWriter& connection) const override;
797 bool read(yarp::os::ConnectionReader& connection) override;
798
799 bool write(const yarp::os::idl::WireWriter& writer) const override;
800 bool read(yarp::os::idl::WireReader& reader) override;
801
803 };
804
806 void call(IMap2DMsgs* ptr);
807
810
811 static constexpr const char* s_tag{"get_areas_list_RPC"};
812 static constexpr size_t s_tag_len{4};
813 static constexpr size_t s_cmd_len{4};
814 static constexpr size_t s_reply_len{2};
815 static constexpr const char* s_prototype{"return_get_areas_list IMap2DMsgs::get_areas_list_RPC()"};
816 static constexpr const char* s_help{""};
817};
818
819// get_paths_list_RPC helper class declaration
821 public yarp::os::Portable
822{
823public:
825 bool write(yarp::os::ConnectionWriter& connection) const override;
826 bool read(yarp::os::ConnectionReader& connection) override;
827
828 class Command :
830 {
831 public:
832 Command() = default;
833 ~Command() override = default;
834
835 bool write(yarp::os::ConnectionWriter& connection) const override;
836 bool read(yarp::os::ConnectionReader& connection) override;
837
838 bool write(const yarp::os::idl::WireWriter& writer) const override;
839 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
840 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
841
842 bool read(yarp::os::idl::WireReader& reader) override;
845 };
846
847 class Reply :
849 {
850 public:
851 Reply() = default;
852 ~Reply() override = default;
853
854 bool write(yarp::os::ConnectionWriter& connection) const override;
855 bool read(yarp::os::ConnectionReader& connection) override;
856
857 bool write(const yarp::os::idl::WireWriter& writer) const override;
858 bool read(yarp::os::idl::WireReader& reader) override;
859
861 };
862
864 void call(IMap2DMsgs* ptr);
865
868
869 static constexpr const char* s_tag{"get_paths_list_RPC"};
870 static constexpr size_t s_tag_len{4};
871 static constexpr size_t s_cmd_len{4};
872 static constexpr size_t s_reply_len{2};
873 static constexpr const char* s_prototype{"return_get_paths_list IMap2DMsgs::get_paths_list_RPC()"};
874 static constexpr const char* s_help{""};
875};
876
877// get_all_locations_RPC helper class declaration
879 public yarp::os::Portable
880{
881public:
883 bool write(yarp::os::ConnectionWriter& connection) const override;
884 bool read(yarp::os::ConnectionReader& connection) override;
885
886 class Command :
888 {
889 public:
890 Command() = default;
891 ~Command() override = default;
892
893 bool write(yarp::os::ConnectionWriter& connection) const override;
894 bool read(yarp::os::ConnectionReader& connection) override;
895
896 bool write(const yarp::os::idl::WireWriter& writer) const override;
897 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
898 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
899
900 bool read(yarp::os::idl::WireReader& reader) override;
903 };
904
905 class Reply :
907 {
908 public:
909 Reply() = default;
910 ~Reply() override = default;
911
912 bool write(yarp::os::ConnectionWriter& connection) const override;
913 bool read(yarp::os::ConnectionReader& connection) override;
914
915 bool write(const yarp::os::idl::WireWriter& writer) const override;
916 bool read(yarp::os::idl::WireReader& reader) override;
917
919 };
920
922 void call(IMap2DMsgs* ptr);
923
926
927 static constexpr const char* s_tag{"get_all_locations_RPC"};
928 static constexpr size_t s_tag_len{4};
929 static constexpr size_t s_cmd_len{4};
930 static constexpr size_t s_reply_len{2};
931 static constexpr const char* s_prototype{"return_get_all_locations IMap2DMsgs::get_all_locations_RPC()"};
932 static constexpr const char* s_help{""};
933};
934
935// get_all_areas_RPC helper class declaration
937 public yarp::os::Portable
938{
939public:
941 bool write(yarp::os::ConnectionWriter& connection) const override;
942 bool read(yarp::os::ConnectionReader& connection) override;
943
944 class Command :
946 {
947 public:
948 Command() = default;
949 ~Command() override = default;
950
951 bool write(yarp::os::ConnectionWriter& connection) const override;
952 bool read(yarp::os::ConnectionReader& connection) override;
953
954 bool write(const yarp::os::idl::WireWriter& writer) const override;
955 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
956 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
957
958 bool read(yarp::os::idl::WireReader& reader) override;
961 };
962
963 class Reply :
965 {
966 public:
967 Reply() = default;
968 ~Reply() override = default;
969
970 bool write(yarp::os::ConnectionWriter& connection) const override;
971 bool read(yarp::os::ConnectionReader& connection) override;
972
973 bool write(const yarp::os::idl::WireWriter& writer) const override;
974 bool read(yarp::os::idl::WireReader& reader) override;
975
977 };
978
980 void call(IMap2DMsgs* ptr);
981
984
985 static constexpr const char* s_tag{"get_all_areas_RPC"};
986 static constexpr size_t s_tag_len{4};
987 static constexpr size_t s_cmd_len{4};
988 static constexpr size_t s_reply_len{2};
989 static constexpr const char* s_prototype{"return_get_all_areas IMap2DMsgs::get_all_areas_RPC()"};
990 static constexpr const char* s_help{""};
991};
992
993// get_all_paths_RPC helper class declaration
995 public yarp::os::Portable
996{
997public:
999 bool write(yarp::os::ConnectionWriter& connection) const override;
1000 bool read(yarp::os::ConnectionReader& connection) override;
1001
1002 class Command :
1004 {
1005 public:
1006 Command() = default;
1007 ~Command() override = default;
1008
1009 bool write(yarp::os::ConnectionWriter& connection) const override;
1010 bool read(yarp::os::ConnectionReader& connection) override;
1011
1012 bool write(const yarp::os::idl::WireWriter& writer) const override;
1013 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1014 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1015
1016 bool read(yarp::os::idl::WireReader& reader) override;
1017 bool readTag(yarp::os::idl::WireReader& reader);
1018 bool readArgs(yarp::os::idl::WireReader& reader);
1019 };
1020
1021 class Reply :
1023 {
1024 public:
1025 Reply() = default;
1026 ~Reply() override = default;
1027
1028 bool write(yarp::os::ConnectionWriter& connection) const override;
1029 bool read(yarp::os::ConnectionReader& connection) override;
1030
1031 bool write(const yarp::os::idl::WireWriter& writer) const override;
1032 bool read(yarp::os::idl::WireReader& reader) override;
1033
1035 };
1036
1038 void call(IMap2DMsgs* ptr);
1039
1042
1043 static constexpr const char* s_tag{"get_all_paths_RPC"};
1044 static constexpr size_t s_tag_len{4};
1045 static constexpr size_t s_cmd_len{4};
1046 static constexpr size_t s_reply_len{2};
1047 static constexpr const char* s_prototype{"return_get_all_paths IMap2DMsgs::get_all_paths_RPC()"};
1048 static constexpr const char* s_help{""};
1049};
1050
1051// rename_location_RPC helper class declaration
1053 public yarp::os::Portable
1054{
1055public:
1057 IMap2DMsgs_rename_location_RPC_helper(const std::string& original_name, const std::string& new_name);
1058 bool write(yarp::os::ConnectionWriter& connection) const override;
1059 bool read(yarp::os::ConnectionReader& connection) override;
1060
1061 class Command :
1063 {
1064 public:
1065 Command() = default;
1066 Command(const std::string& original_name, const std::string& new_name);
1067
1068 ~Command() override = default;
1069
1070 bool write(yarp::os::ConnectionWriter& connection) const override;
1071 bool read(yarp::os::ConnectionReader& connection) override;
1072
1073 bool write(const yarp::os::idl::WireWriter& writer) const override;
1074 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1075 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1076
1077 bool read(yarp::os::idl::WireReader& reader) override;
1078 bool readTag(yarp::os::idl::WireReader& reader);
1079 bool readArgs(yarp::os::idl::WireReader& reader);
1080
1081 std::string original_name{};
1082 std::string new_name{};
1083 };
1084
1085 class Reply :
1087 {
1088 public:
1089 Reply() = default;
1090 ~Reply() override = default;
1091
1092 bool write(yarp::os::ConnectionWriter& connection) const override;
1093 bool read(yarp::os::ConnectionReader& connection) override;
1094
1095 bool write(const yarp::os::idl::WireWriter& writer) const override;
1096 bool read(yarp::os::idl::WireReader& reader) override;
1097
1099 };
1100
1101 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&, const std::string&);
1102 void call(IMap2DMsgs* ptr);
1103
1106
1107 static constexpr const char* s_tag{"rename_location_RPC"};
1108 static constexpr size_t s_tag_len{3};
1109 static constexpr size_t s_cmd_len{5};
1110 static constexpr size_t s_reply_len{1};
1111 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::rename_location_RPC(const std::string& original_name, const std::string& new_name)"};
1112 static constexpr const char* s_help{""};
1113};
1114
1115// delete_location_RPC helper class declaration
1117 public yarp::os::Portable
1118{
1119public:
1121 explicit IMap2DMsgs_delete_location_RPC_helper(const std::string& location_name);
1122 bool write(yarp::os::ConnectionWriter& connection) const override;
1123 bool read(yarp::os::ConnectionReader& connection) override;
1124
1125 class Command :
1127 {
1128 public:
1129 Command() = default;
1130 explicit Command(const std::string& location_name);
1131
1132 ~Command() override = default;
1133
1134 bool write(yarp::os::ConnectionWriter& connection) const override;
1135 bool read(yarp::os::ConnectionReader& connection) override;
1136
1137 bool write(const yarp::os::idl::WireWriter& writer) const override;
1138 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1139 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1140
1141 bool read(yarp::os::idl::WireReader& reader) override;
1142 bool readTag(yarp::os::idl::WireReader& reader);
1143 bool readArgs(yarp::os::idl::WireReader& reader);
1144
1145 std::string location_name{};
1146 };
1147
1148 class Reply :
1150 {
1151 public:
1152 Reply() = default;
1153 ~Reply() override = default;
1154
1155 bool write(yarp::os::ConnectionWriter& connection) const override;
1156 bool read(yarp::os::ConnectionReader& connection) override;
1157
1158 bool write(const yarp::os::idl::WireWriter& writer) const override;
1159 bool read(yarp::os::idl::WireReader& reader) override;
1160
1162 };
1163
1164 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&);
1165 void call(IMap2DMsgs* ptr);
1166
1169
1170 static constexpr const char* s_tag{"delete_location_RPC"};
1171 static constexpr size_t s_tag_len{3};
1172 static constexpr size_t s_cmd_len{4};
1173 static constexpr size_t s_reply_len{1};
1174 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::delete_location_RPC(const std::string& location_name)"};
1175 static constexpr const char* s_help{""};
1176};
1177
1178// delete_path_RPC helper class declaration
1180 public yarp::os::Portable
1181{
1182public:
1184 explicit IMap2DMsgs_delete_path_RPC_helper(const std::string& path_name);
1185 bool write(yarp::os::ConnectionWriter& connection) const override;
1186 bool read(yarp::os::ConnectionReader& connection) override;
1187
1188 class Command :
1190 {
1191 public:
1192 Command() = default;
1193 explicit Command(const std::string& path_name);
1194
1195 ~Command() override = default;
1196
1197 bool write(yarp::os::ConnectionWriter& connection) const override;
1198 bool read(yarp::os::ConnectionReader& connection) override;
1199
1200 bool write(const yarp::os::idl::WireWriter& writer) const override;
1201 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1202 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1203
1204 bool read(yarp::os::idl::WireReader& reader) override;
1205 bool readTag(yarp::os::idl::WireReader& reader);
1206 bool readArgs(yarp::os::idl::WireReader& reader);
1207
1208 std::string path_name{};
1209 };
1210
1211 class Reply :
1213 {
1214 public:
1215 Reply() = default;
1216 ~Reply() override = default;
1217
1218 bool write(yarp::os::ConnectionWriter& connection) const override;
1219 bool read(yarp::os::ConnectionReader& connection) override;
1220
1221 bool write(const yarp::os::idl::WireWriter& writer) const override;
1222 bool read(yarp::os::idl::WireReader& reader) override;
1223
1225 };
1226
1227 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&);
1228 void call(IMap2DMsgs* ptr);
1229
1232
1233 static constexpr const char* s_tag{"delete_path_RPC"};
1234 static constexpr size_t s_tag_len{3};
1235 static constexpr size_t s_cmd_len{4};
1236 static constexpr size_t s_reply_len{1};
1237 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::delete_path_RPC(const std::string& path_name)"};
1238 static constexpr const char* s_help{""};
1239};
1240
1241// rename_area_RPC helper class declaration
1243 public yarp::os::Portable
1244{
1245public:
1247 IMap2DMsgs_rename_area_RPC_helper(const std::string& original_name, const std::string& new_name);
1248 bool write(yarp::os::ConnectionWriter& connection) const override;
1249 bool read(yarp::os::ConnectionReader& connection) override;
1250
1251 class Command :
1253 {
1254 public:
1255 Command() = default;
1256 Command(const std::string& original_name, const std::string& new_name);
1257
1258 ~Command() override = default;
1259
1260 bool write(yarp::os::ConnectionWriter& connection) const override;
1261 bool read(yarp::os::ConnectionReader& connection) override;
1262
1263 bool write(const yarp::os::idl::WireWriter& writer) const override;
1264 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1265 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1266
1267 bool read(yarp::os::idl::WireReader& reader) override;
1268 bool readTag(yarp::os::idl::WireReader& reader);
1269 bool readArgs(yarp::os::idl::WireReader& reader);
1270
1271 std::string original_name{};
1272 std::string new_name{};
1273 };
1274
1275 class Reply :
1277 {
1278 public:
1279 Reply() = default;
1280 ~Reply() override = default;
1281
1282 bool write(yarp::os::ConnectionWriter& connection) const override;
1283 bool read(yarp::os::ConnectionReader& connection) override;
1284
1285 bool write(const yarp::os::idl::WireWriter& writer) const override;
1286 bool read(yarp::os::idl::WireReader& reader) override;
1287
1289 };
1290
1291 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&, const std::string&);
1292 void call(IMap2DMsgs* ptr);
1293
1296
1297 static constexpr const char* s_tag{"rename_area_RPC"};
1298 static constexpr size_t s_tag_len{3};
1299 static constexpr size_t s_cmd_len{5};
1300 static constexpr size_t s_reply_len{1};
1301 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::rename_area_RPC(const std::string& original_name, const std::string& new_name)"};
1302 static constexpr const char* s_help{""};
1303};
1304
1305// rename_path_RPC helper class declaration
1307 public yarp::os::Portable
1308{
1309public:
1311 IMap2DMsgs_rename_path_RPC_helper(const std::string& original_name, const std::string& new_name);
1312 bool write(yarp::os::ConnectionWriter& connection) const override;
1313 bool read(yarp::os::ConnectionReader& connection) override;
1314
1315 class Command :
1317 {
1318 public:
1319 Command() = default;
1320 Command(const std::string& original_name, const std::string& new_name);
1321
1322 ~Command() override = default;
1323
1324 bool write(yarp::os::ConnectionWriter& connection) const override;
1325 bool read(yarp::os::ConnectionReader& connection) override;
1326
1327 bool write(const yarp::os::idl::WireWriter& writer) const override;
1328 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1329 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1330
1331 bool read(yarp::os::idl::WireReader& reader) override;
1332 bool readTag(yarp::os::idl::WireReader& reader);
1333 bool readArgs(yarp::os::idl::WireReader& reader);
1334
1335 std::string original_name{};
1336 std::string new_name{};
1337 };
1338
1339 class Reply :
1341 {
1342 public:
1343 Reply() = default;
1344 ~Reply() override = default;
1345
1346 bool write(yarp::os::ConnectionWriter& connection) const override;
1347 bool read(yarp::os::ConnectionReader& connection) override;
1348
1349 bool write(const yarp::os::idl::WireWriter& writer) const override;
1350 bool read(yarp::os::idl::WireReader& reader) override;
1351
1353 };
1354
1355 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&, const std::string&);
1356 void call(IMap2DMsgs* ptr);
1357
1360
1361 static constexpr const char* s_tag{"rename_path_RPC"};
1362 static constexpr size_t s_tag_len{3};
1363 static constexpr size_t s_cmd_len{5};
1364 static constexpr size_t s_reply_len{1};
1365 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::rename_path_RPC(const std::string& original_name, const std::string& new_name)"};
1366 static constexpr const char* s_help{""};
1367};
1368
1369// delete_area_RPC helper class declaration
1371 public yarp::os::Portable
1372{
1373public:
1375 explicit IMap2DMsgs_delete_area_RPC_helper(const std::string& area_name);
1376 bool write(yarp::os::ConnectionWriter& connection) const override;
1377 bool read(yarp::os::ConnectionReader& connection) override;
1378
1379 class Command :
1381 {
1382 public:
1383 Command() = default;
1384 explicit Command(const std::string& area_name);
1385
1386 ~Command() override = default;
1387
1388 bool write(yarp::os::ConnectionWriter& connection) const override;
1389 bool read(yarp::os::ConnectionReader& connection) override;
1390
1391 bool write(const yarp::os::idl::WireWriter& writer) const override;
1392 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1393 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1394
1395 bool read(yarp::os::idl::WireReader& reader) override;
1396 bool readTag(yarp::os::idl::WireReader& reader);
1397 bool readArgs(yarp::os::idl::WireReader& reader);
1398
1399 std::string area_name{};
1400 };
1401
1402 class Reply :
1404 {
1405 public:
1406 Reply() = default;
1407 ~Reply() override = default;
1408
1409 bool write(yarp::os::ConnectionWriter& connection) const override;
1410 bool read(yarp::os::ConnectionReader& connection) override;
1411
1412 bool write(const yarp::os::idl::WireWriter& writer) const override;
1413 bool read(yarp::os::idl::WireReader& reader) override;
1414
1416 };
1417
1418 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&);
1419 void call(IMap2DMsgs* ptr);
1420
1423
1424 static constexpr const char* s_tag{"delete_area_RPC"};
1425 static constexpr size_t s_tag_len{3};
1426 static constexpr size_t s_cmd_len{4};
1427 static constexpr size_t s_reply_len{1};
1428 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::delete_area_RPC(const std::string& area_name)"};
1429 static constexpr const char* s_help{""};
1430};
1431
1432// clear_all_locations_RPC helper class declaration
1434 public yarp::os::Portable
1435{
1436public:
1438 bool write(yarp::os::ConnectionWriter& connection) const override;
1439 bool read(yarp::os::ConnectionReader& connection) override;
1440
1441 class Command :
1443 {
1444 public:
1445 Command() = default;
1446 ~Command() override = default;
1447
1448 bool write(yarp::os::ConnectionWriter& connection) const override;
1449 bool read(yarp::os::ConnectionReader& connection) override;
1450
1451 bool write(const yarp::os::idl::WireWriter& writer) const override;
1452 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1453 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1454
1455 bool read(yarp::os::idl::WireReader& reader) override;
1456 bool readTag(yarp::os::idl::WireReader& reader);
1457 bool readArgs(yarp::os::idl::WireReader& reader);
1458 };
1459
1460 class Reply :
1462 {
1463 public:
1464 Reply() = default;
1465 ~Reply() override = default;
1466
1467 bool write(yarp::os::ConnectionWriter& connection) const override;
1468 bool read(yarp::os::ConnectionReader& connection) override;
1469
1470 bool write(const yarp::os::idl::WireWriter& writer) const override;
1471 bool read(yarp::os::idl::WireReader& reader) override;
1472
1474 };
1475
1477 void call(IMap2DMsgs* ptr);
1478
1481
1482 static constexpr const char* s_tag{"clear_all_locations_RPC"};
1483 static constexpr size_t s_tag_len{4};
1484 static constexpr size_t s_cmd_len{4};
1485 static constexpr size_t s_reply_len{1};
1486 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::clear_all_locations_RPC()"};
1487 static constexpr const char* s_help{""};
1488};
1489
1490// clear_all_areas_RPC helper class declaration
1492 public yarp::os::Portable
1493{
1494public:
1496 bool write(yarp::os::ConnectionWriter& connection) const override;
1497 bool read(yarp::os::ConnectionReader& connection) override;
1498
1499 class Command :
1501 {
1502 public:
1503 Command() = default;
1504 ~Command() override = default;
1505
1506 bool write(yarp::os::ConnectionWriter& connection) const override;
1507 bool read(yarp::os::ConnectionReader& connection) override;
1508
1509 bool write(const yarp::os::idl::WireWriter& writer) const override;
1510 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1511 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1512
1513 bool read(yarp::os::idl::WireReader& reader) override;
1514 bool readTag(yarp::os::idl::WireReader& reader);
1515 bool readArgs(yarp::os::idl::WireReader& reader);
1516 };
1517
1518 class Reply :
1520 {
1521 public:
1522 Reply() = default;
1523 ~Reply() override = default;
1524
1525 bool write(yarp::os::ConnectionWriter& connection) const override;
1526 bool read(yarp::os::ConnectionReader& connection) override;
1527
1528 bool write(const yarp::os::idl::WireWriter& writer) const override;
1529 bool read(yarp::os::idl::WireReader& reader) override;
1530
1532 };
1533
1535 void call(IMap2DMsgs* ptr);
1536
1539
1540 static constexpr const char* s_tag{"clear_all_areas_RPC"};
1541 static constexpr size_t s_tag_len{4};
1542 static constexpr size_t s_cmd_len{4};
1543 static constexpr size_t s_reply_len{1};
1544 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::clear_all_areas_RPC()"};
1545 static constexpr const char* s_help{""};
1546};
1547
1548// clear_all_paths_RPC helper class declaration
1550 public yarp::os::Portable
1551{
1552public:
1554 bool write(yarp::os::ConnectionWriter& connection) const override;
1555 bool read(yarp::os::ConnectionReader& connection) override;
1556
1557 class Command :
1559 {
1560 public:
1561 Command() = default;
1562 ~Command() override = default;
1563
1564 bool write(yarp::os::ConnectionWriter& connection) const override;
1565 bool read(yarp::os::ConnectionReader& connection) override;
1566
1567 bool write(const yarp::os::idl::WireWriter& writer) const override;
1568 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1569 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1570
1571 bool read(yarp::os::idl::WireReader& reader) override;
1572 bool readTag(yarp::os::idl::WireReader& reader);
1573 bool readArgs(yarp::os::idl::WireReader& reader);
1574 };
1575
1576 class Reply :
1578 {
1579 public:
1580 Reply() = default;
1581 ~Reply() override = default;
1582
1583 bool write(yarp::os::ConnectionWriter& connection) const override;
1584 bool read(yarp::os::ConnectionReader& connection) override;
1585
1586 bool write(const yarp::os::idl::WireWriter& writer) const override;
1587 bool read(yarp::os::idl::WireReader& reader) override;
1588
1590 };
1591
1593 void call(IMap2DMsgs* ptr);
1594
1597
1598 static constexpr const char* s_tag{"clear_all_paths_RPC"};
1599 static constexpr size_t s_tag_len{4};
1600 static constexpr size_t s_cmd_len{4};
1601 static constexpr size_t s_reply_len{1};
1602 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::clear_all_paths_RPC()"};
1603 static constexpr const char* s_help{""};
1604};
1605
1606// clear_all_maps_temporary_flags_RPC helper class declaration
1608 public yarp::os::Portable
1609{
1610public:
1612 bool write(yarp::os::ConnectionWriter& connection) const override;
1613 bool read(yarp::os::ConnectionReader& connection) override;
1614
1615 class Command :
1617 {
1618 public:
1619 Command() = default;
1620 ~Command() override = default;
1621
1622 bool write(yarp::os::ConnectionWriter& connection) const override;
1623 bool read(yarp::os::ConnectionReader& connection) override;
1624
1625 bool write(const yarp::os::idl::WireWriter& writer) const override;
1626 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1627 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1628
1629 bool read(yarp::os::idl::WireReader& reader) override;
1630 bool readTag(yarp::os::idl::WireReader& reader);
1631 bool readArgs(yarp::os::idl::WireReader& reader);
1632 };
1633
1634 class Reply :
1636 {
1637 public:
1638 Reply() = default;
1639 ~Reply() override = default;
1640
1641 bool write(yarp::os::ConnectionWriter& connection) const override;
1642 bool read(yarp::os::ConnectionReader& connection) override;
1643
1644 bool write(const yarp::os::idl::WireWriter& writer) const override;
1645 bool read(yarp::os::idl::WireReader& reader) override;
1646
1648 };
1649
1651 void call(IMap2DMsgs* ptr);
1652
1655
1656 static constexpr const char* s_tag{"clear_all_maps_temporary_flags_RPC"};
1657 static constexpr size_t s_tag_len{6};
1658 static constexpr size_t s_cmd_len{6};
1659 static constexpr size_t s_reply_len{1};
1660 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::clear_all_maps_temporary_flags_RPC()"};
1661 static constexpr const char* s_help{""};
1662};
1663
1664// clear_map_temporary_flags_RPC helper class declaration
1666 public yarp::os::Portable
1667{
1668public:
1670 explicit IMap2DMsgs_clear_map_temporary_flags_RPC_helper(const std::string& map_name);
1671 bool write(yarp::os::ConnectionWriter& connection) const override;
1672 bool read(yarp::os::ConnectionReader& connection) override;
1673
1674 class Command :
1676 {
1677 public:
1678 Command() = default;
1679 explicit Command(const std::string& map_name);
1680
1681 ~Command() override = default;
1682
1683 bool write(yarp::os::ConnectionWriter& connection) const override;
1684 bool read(yarp::os::ConnectionReader& connection) override;
1685
1686 bool write(const yarp::os::idl::WireWriter& writer) const override;
1687 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1688 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1689
1690 bool read(yarp::os::idl::WireReader& reader) override;
1691 bool readTag(yarp::os::idl::WireReader& reader);
1692 bool readArgs(yarp::os::idl::WireReader& reader);
1693
1694 std::string map_name{};
1695 };
1696
1697 class Reply :
1699 {
1700 public:
1701 Reply() = default;
1702 ~Reply() override = default;
1703
1704 bool write(yarp::os::ConnectionWriter& connection) const override;
1705 bool read(yarp::os::ConnectionReader& connection) override;
1706
1707 bool write(const yarp::os::idl::WireWriter& writer) const override;
1708 bool read(yarp::os::idl::WireReader& reader) override;
1709
1711 };
1712
1713 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&);
1714 void call(IMap2DMsgs* ptr);
1715
1718
1719 static constexpr const char* s_tag{"clear_map_temporary_flags_RPC"};
1720 static constexpr size_t s_tag_len{5};
1721 static constexpr size_t s_cmd_len{6};
1722 static constexpr size_t s_reply_len{1};
1723 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::clear_map_temporary_flags_RPC(const std::string& map_name)"};
1724 static constexpr const char* s_help{""};
1725};
1726
1727// save_maps_collection_RPC helper class declaration
1729 public yarp::os::Portable
1730{
1731public:
1733 explicit IMap2DMsgs_save_maps_collection_RPC_helper(const std::string& maps_collection_file);
1734 bool write(yarp::os::ConnectionWriter& connection) const override;
1735 bool read(yarp::os::ConnectionReader& connection) override;
1736
1737 class Command :
1739 {
1740 public:
1741 Command() = default;
1742 explicit Command(const std::string& maps_collection_file);
1743
1744 ~Command() override = default;
1745
1746 bool write(yarp::os::ConnectionWriter& connection) const override;
1747 bool read(yarp::os::ConnectionReader& connection) override;
1748
1749 bool write(const yarp::os::idl::WireWriter& writer) const override;
1750 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1751 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1752
1753 bool read(yarp::os::idl::WireReader& reader) override;
1754 bool readTag(yarp::os::idl::WireReader& reader);
1755 bool readArgs(yarp::os::idl::WireReader& reader);
1756
1758 };
1759
1760 class Reply :
1762 {
1763 public:
1764 Reply() = default;
1765 ~Reply() override = default;
1766
1767 bool write(yarp::os::ConnectionWriter& connection) const override;
1768 bool read(yarp::os::ConnectionReader& connection) override;
1769
1770 bool write(const yarp::os::idl::WireWriter& writer) const override;
1771 bool read(yarp::os::idl::WireReader& reader) override;
1772
1774 };
1775
1776 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&);
1777 void call(IMap2DMsgs* ptr);
1778
1781
1782 static constexpr const char* s_tag{"save_maps_collection_RPC"};
1783 static constexpr size_t s_tag_len{4};
1784 static constexpr size_t s_cmd_len{5};
1785 static constexpr size_t s_reply_len{1};
1786 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::save_maps_collection_RPC(const std::string& maps_collection_file)"};
1787 static constexpr const char* s_help{""};
1788};
1789
1790// load_maps_collection_RPC helper class declaration
1792 public yarp::os::Portable
1793{
1794public:
1796 explicit IMap2DMsgs_load_maps_collection_RPC_helper(const std::string& maps_collection_file);
1797 bool write(yarp::os::ConnectionWriter& connection) const override;
1798 bool read(yarp::os::ConnectionReader& connection) override;
1799
1800 class Command :
1802 {
1803 public:
1804 Command() = default;
1805 explicit Command(const std::string& maps_collection_file);
1806
1807 ~Command() override = default;
1808
1809 bool write(yarp::os::ConnectionWriter& connection) const override;
1810 bool read(yarp::os::ConnectionReader& connection) override;
1811
1812 bool write(const yarp::os::idl::WireWriter& writer) const override;
1813 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1814 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1815
1816 bool read(yarp::os::idl::WireReader& reader) override;
1817 bool readTag(yarp::os::idl::WireReader& reader);
1818 bool readArgs(yarp::os::idl::WireReader& reader);
1819
1821 };
1822
1823 class Reply :
1825 {
1826 public:
1827 Reply() = default;
1828 ~Reply() override = default;
1829
1830 bool write(yarp::os::ConnectionWriter& connection) const override;
1831 bool read(yarp::os::ConnectionReader& connection) override;
1832
1833 bool write(const yarp::os::idl::WireWriter& writer) const override;
1834 bool read(yarp::os::idl::WireReader& reader) override;
1835
1837 };
1838
1839 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&);
1840 void call(IMap2DMsgs* ptr);
1841
1844
1845 static constexpr const char* s_tag{"load_maps_collection_RPC"};
1846 static constexpr size_t s_tag_len{4};
1847 static constexpr size_t s_cmd_len{5};
1848 static constexpr size_t s_reply_len{1};
1849 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::load_maps_collection_RPC(const std::string& maps_collection_file)"};
1850 static constexpr const char* s_help{""};
1851};
1852
1853// save_locations_and_extras_RPC helper class declaration
1855 public yarp::os::Portable
1856{
1857public:
1859 explicit IMap2DMsgs_save_locations_and_extras_RPC_helper(const std::string& locations_collection_file);
1860 bool write(yarp::os::ConnectionWriter& connection) const override;
1861 bool read(yarp::os::ConnectionReader& connection) override;
1862
1863 class Command :
1865 {
1866 public:
1867 Command() = default;
1868 explicit Command(const std::string& locations_collection_file);
1869
1870 ~Command() override = default;
1871
1872 bool write(yarp::os::ConnectionWriter& connection) const override;
1873 bool read(yarp::os::ConnectionReader& connection) override;
1874
1875 bool write(const yarp::os::idl::WireWriter& writer) const override;
1876 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1877 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1878
1879 bool read(yarp::os::idl::WireReader& reader) override;
1880 bool readTag(yarp::os::idl::WireReader& reader);
1881 bool readArgs(yarp::os::idl::WireReader& reader);
1882
1884 };
1885
1886 class Reply :
1888 {
1889 public:
1890 Reply() = default;
1891 ~Reply() override = default;
1892
1893 bool write(yarp::os::ConnectionWriter& connection) const override;
1894 bool read(yarp::os::ConnectionReader& connection) override;
1895
1896 bool write(const yarp::os::idl::WireWriter& writer) const override;
1897 bool read(yarp::os::idl::WireReader& reader) override;
1898
1900 };
1901
1902 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&);
1903 void call(IMap2DMsgs* ptr);
1904
1907
1908 static constexpr const char* s_tag{"save_locations_and_extras_RPC"};
1909 static constexpr size_t s_tag_len{5};
1910 static constexpr size_t s_cmd_len{6};
1911 static constexpr size_t s_reply_len{1};
1912 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::save_locations_and_extras_RPC(const std::string& locations_collection_file)"};
1913 static constexpr const char* s_help{""};
1914};
1915
1916// load_locations_and_extras_RPC helper class declaration
1918 public yarp::os::Portable
1919{
1920public:
1922 explicit IMap2DMsgs_load_locations_and_extras_RPC_helper(const std::string& locations_collection_file);
1923 bool write(yarp::os::ConnectionWriter& connection) const override;
1924 bool read(yarp::os::ConnectionReader& connection) override;
1925
1926 class Command :
1928 {
1929 public:
1930 Command() = default;
1931 explicit Command(const std::string& locations_collection_file);
1932
1933 ~Command() override = default;
1934
1935 bool write(yarp::os::ConnectionWriter& connection) const override;
1936 bool read(yarp::os::ConnectionReader& connection) override;
1937
1938 bool write(const yarp::os::idl::WireWriter& writer) const override;
1939 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1940 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1941
1942 bool read(yarp::os::idl::WireReader& reader) override;
1943 bool readTag(yarp::os::idl::WireReader& reader);
1944 bool readArgs(yarp::os::idl::WireReader& reader);
1945
1947 };
1948
1949 class Reply :
1951 {
1952 public:
1953 Reply() = default;
1954 ~Reply() override = default;
1955
1956 bool write(yarp::os::ConnectionWriter& connection) const override;
1957 bool read(yarp::os::ConnectionReader& connection) override;
1958
1959 bool write(const yarp::os::idl::WireWriter& writer) const override;
1960 bool read(yarp::os::idl::WireReader& reader) override;
1961
1963 };
1964
1965 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&);
1966 void call(IMap2DMsgs* ptr);
1967
1970
1971 static constexpr const char* s_tag{"load_locations_and_extras_RPC"};
1972 static constexpr size_t s_tag_len{5};
1973 static constexpr size_t s_cmd_len{6};
1974 static constexpr size_t s_reply_len{1};
1975 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::load_locations_and_extras_RPC(const std::string& locations_collection_file)"};
1976 static constexpr const char* s_help{""};
1977};
1978
1979// save_map_to_disk_RPC helper class declaration
1981 public yarp::os::Portable
1982{
1983public:
1985 IMap2DMsgs_save_map_to_disk_RPC_helper(const std::string& map_name, const std::string& file_name);
1986 bool write(yarp::os::ConnectionWriter& connection) const override;
1987 bool read(yarp::os::ConnectionReader& connection) override;
1988
1989 class Command :
1991 {
1992 public:
1993 Command() = default;
1994 Command(const std::string& map_name, const std::string& file_name);
1995
1996 ~Command() override = default;
1997
1998 bool write(yarp::os::ConnectionWriter& connection) const override;
1999 bool read(yarp::os::ConnectionReader& connection) override;
2000
2001 bool write(const yarp::os::idl::WireWriter& writer) const override;
2002 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2003 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2004
2005 bool read(yarp::os::idl::WireReader& reader) override;
2006 bool readTag(yarp::os::idl::WireReader& reader);
2007 bool readArgs(yarp::os::idl::WireReader& reader);
2008
2009 std::string map_name{};
2010 std::string file_name{};
2011 };
2012
2013 class Reply :
2015 {
2016 public:
2017 Reply() = default;
2018 ~Reply() override = default;
2019
2020 bool write(yarp::os::ConnectionWriter& connection) const override;
2021 bool read(yarp::os::ConnectionReader& connection) override;
2022
2023 bool write(const yarp::os::idl::WireWriter& writer) const override;
2024 bool read(yarp::os::idl::WireReader& reader) override;
2025
2027 };
2028
2029 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&, const std::string&);
2030 void call(IMap2DMsgs* ptr);
2031
2034
2035 static constexpr const char* s_tag{"save_map_to_disk_RPC"};
2036 static constexpr size_t s_tag_len{5};
2037 static constexpr size_t s_cmd_len{7};
2038 static constexpr size_t s_reply_len{1};
2039 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::save_map_to_disk_RPC(const std::string& map_name, const std::string& file_name)"};
2040 static constexpr const char* s_help{""};
2041};
2042
2043// load_map_from_disk_RPC helper class declaration
2045 public yarp::os::Portable
2046{
2047public:
2049 explicit IMap2DMsgs_load_map_from_disk_RPC_helper(const std::string& file_name);
2050 bool write(yarp::os::ConnectionWriter& connection) const override;
2051 bool read(yarp::os::ConnectionReader& connection) override;
2052
2053 class Command :
2055 {
2056 public:
2057 Command() = default;
2058 explicit Command(const std::string& file_name);
2059
2060 ~Command() override = default;
2061
2062 bool write(yarp::os::ConnectionWriter& connection) const override;
2063 bool read(yarp::os::ConnectionReader& connection) override;
2064
2065 bool write(const yarp::os::idl::WireWriter& writer) const override;
2066 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2067 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2068
2069 bool read(yarp::os::idl::WireReader& reader) override;
2070 bool readTag(yarp::os::idl::WireReader& reader);
2071 bool readArgs(yarp::os::idl::WireReader& reader);
2072
2073 std::string file_name{};
2074 };
2075
2076 class Reply :
2078 {
2079 public:
2080 Reply() = default;
2081 ~Reply() override = default;
2082
2083 bool write(yarp::os::ConnectionWriter& connection) const override;
2084 bool read(yarp::os::ConnectionReader& connection) override;
2085
2086 bool write(const yarp::os::idl::WireWriter& writer) const override;
2087 bool read(yarp::os::idl::WireReader& reader) override;
2088
2090 };
2091
2092 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&);
2093 void call(IMap2DMsgs* ptr);
2094
2097
2098 static constexpr const char* s_tag{"load_map_from_disk_RPC"};
2099 static constexpr size_t s_tag_len{5};
2100 static constexpr size_t s_cmd_len{6};
2101 static constexpr size_t s_reply_len{1};
2102 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::load_map_from_disk_RPC(const std::string& file_name)"};
2103 static constexpr const char* s_help{""};
2104};
2105
2106// enable_maps_compression_RPC helper class declaration
2108 public yarp::os::Portable
2109{
2110public:
2112 explicit IMap2DMsgs_enable_maps_compression_RPC_helper(const bool enable_compression);
2113 bool write(yarp::os::ConnectionWriter& connection) const override;
2114 bool read(yarp::os::ConnectionReader& connection) override;
2115
2116 class Command :
2118 {
2119 public:
2120 Command() = default;
2121 explicit Command(const bool enable_compression);
2122
2123 ~Command() override = default;
2124
2125 bool write(yarp::os::ConnectionWriter& connection) const override;
2126 bool read(yarp::os::ConnectionReader& connection) override;
2127
2128 bool write(const yarp::os::idl::WireWriter& writer) const override;
2129 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2130 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2131
2132 bool read(yarp::os::idl::WireReader& reader) override;
2133 bool readTag(yarp::os::idl::WireReader& reader);
2134 bool readArgs(yarp::os::idl::WireReader& reader);
2135
2137 };
2138
2139 class Reply :
2141 {
2142 public:
2143 Reply() = default;
2144 ~Reply() override = default;
2145
2146 bool write(yarp::os::ConnectionWriter& connection) const override;
2147 bool read(yarp::os::ConnectionReader& connection) override;
2148
2149 bool write(const yarp::os::idl::WireWriter& writer) const override;
2150 bool read(yarp::os::idl::WireReader& reader) override;
2151
2153 };
2154
2155 using funcptr_t = yarp::dev::ReturnValue (*)(const bool);
2156 void call(IMap2DMsgs* ptr);
2157
2160
2161 static constexpr const char* s_tag{"enable_maps_compression_RPC"};
2162 static constexpr size_t s_tag_len{4};
2163 static constexpr size_t s_cmd_len{5};
2164 static constexpr size_t s_reply_len{1};
2165 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::enable_maps_compression_RPC(const bool enable_compression)"};
2166 static constexpr const char* s_help{""};
2167};
2168
2169// clear_all_maps_RPC helper class implementation
2171{
2172 return cmd.write(connection);
2173}
2174
2176{
2177 return reply.read(connection);
2178}
2179
2181{
2182 yarp::os::idl::WireWriter writer(connection);
2183 if (!writer.writeListHeader(s_cmd_len)) {
2184 return false;
2185 }
2186 return write(writer);
2187}
2188
2190{
2191 yarp::os::idl::WireReader reader(connection);
2192 if (!reader.readListHeader()) {
2193 reader.fail();
2194 return false;
2195 }
2196 return read(reader);
2197}
2198
2200{
2201 if (!writeTag(writer)) {
2202 return false;
2203 }
2204 if (!writeArgs(writer)) {
2205 return false;
2206 }
2207 return true;
2208}
2209
2211{
2212 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2213 return false;
2214 }
2215 return true;
2216}
2217
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 return true;
2254}
2255
2257{
2258 yarp::os::idl::WireWriter writer(connection);
2259 return write(writer);
2260}
2261
2263{
2264 yarp::os::idl::WireReader reader(connection);
2265 return read(reader);
2266}
2267
2269{
2270 if (!writer.isNull()) {
2271 if (!writer.write(return_helper)) {
2272 return false;
2273 }
2274 }
2275 return true;
2276}
2277
2279{
2280 if (reader.noMore()) {
2281 reader.fail();
2282 return false;
2283 }
2284 if (!reader.read(return_helper)) {
2285 reader.fail();
2286 return false;
2287 }
2288 return true;
2289}
2290
2295
2296// store_map_RPC helper class implementation
2301
2303{
2304 return cmd.write(connection);
2305}
2306
2308{
2309 return reply.read(connection);
2310}
2311
2316
2318{
2319 yarp::os::idl::WireWriter writer(connection);
2320 if (!writer.writeListHeader(s_cmd_len)) {
2321 return false;
2322 }
2323 return write(writer);
2324}
2325
2327{
2328 yarp::os::idl::WireReader reader(connection);
2329 if (!reader.readListHeader()) {
2330 reader.fail();
2331 return false;
2332 }
2333 return read(reader);
2334}
2335
2337{
2338 if (!writeTag(writer)) {
2339 return false;
2340 }
2341 if (!writeArgs(writer)) {
2342 return false;
2343 }
2344 return true;
2345}
2346
2348{
2349 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2350 return false;
2351 }
2352 return true;
2353}
2354
2356{
2357 if (!writer.writeNested(themap)) {
2358 return false;
2359 }
2360 return true;
2361}
2362
2364{
2365 if (!readTag(reader)) {
2366 return false;
2367 }
2368 if (!readArgs(reader)) {
2369 return false;
2370 }
2371 return true;
2372}
2373
2375{
2376 std::string tag = reader.readTag(s_tag_len);
2377 if (reader.isError()) {
2378 return false;
2379 }
2380 if (tag != s_tag) {
2381 reader.fail();
2382 return false;
2383 }
2384 return true;
2385}
2386
2388{
2389 if (reader.noMore()) {
2390 reader.fail();
2391 return false;
2392 }
2393 if (!reader.readNested(themap)) {
2394 reader.fail();
2395 return false;
2396 }
2397 if (!reader.noMore()) {
2398 reader.fail();
2399 return false;
2400 }
2401 return true;
2402}
2403
2405{
2406 yarp::os::idl::WireWriter writer(connection);
2407 return write(writer);
2408}
2409
2411{
2412 yarp::os::idl::WireReader reader(connection);
2413 return read(reader);
2414}
2415
2417{
2418 if (!writer.isNull()) {
2419 if (!writer.write(return_helper)) {
2420 return false;
2421 }
2422 }
2423 return true;
2424}
2425
2427{
2428 if (reader.noMore()) {
2429 reader.fail();
2430 return false;
2431 }
2432 if (!reader.read(return_helper)) {
2433 reader.fail();
2434 return false;
2435 }
2436 return true;
2437}
2438
2443
2444// get_map_RPC helper class implementation
2446 cmd{map_name}
2447{
2448}
2449
2451{
2452 return cmd.write(connection);
2453}
2454
2456{
2457 return reply.read(connection);
2458}
2459
2461 map_name{map_name}
2462{
2463}
2464
2466{
2467 yarp::os::idl::WireWriter writer(connection);
2468 if (!writer.writeListHeader(s_cmd_len)) {
2469 return false;
2470 }
2471 return write(writer);
2472}
2473
2475{
2476 yarp::os::idl::WireReader reader(connection);
2477 if (!reader.readListHeader()) {
2478 reader.fail();
2479 return false;
2480 }
2481 return read(reader);
2482}
2483
2485{
2486 if (!writeTag(writer)) {
2487 return false;
2488 }
2489 if (!writeArgs(writer)) {
2490 return false;
2491 }
2492 return true;
2493}
2494
2496{
2497 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2498 return false;
2499 }
2500 return true;
2501}
2502
2504{
2505 if (!writer.writeString(map_name)) {
2506 return false;
2507 }
2508 return true;
2509}
2510
2512{
2513 if (!readTag(reader)) {
2514 return false;
2515 }
2516 if (!readArgs(reader)) {
2517 return false;
2518 }
2519 return true;
2520}
2521
2523{
2524 std::string tag = reader.readTag(s_tag_len);
2525 if (reader.isError()) {
2526 return false;
2527 }
2528 if (tag != s_tag) {
2529 reader.fail();
2530 return false;
2531 }
2532 return true;
2533}
2534
2536{
2537 if (reader.noMore()) {
2538 reader.fail();
2539 return false;
2540 }
2541 if (!reader.readString(map_name)) {
2542 reader.fail();
2543 return false;
2544 }
2545 if (!reader.noMore()) {
2546 reader.fail();
2547 return false;
2548 }
2549 return true;
2550}
2551
2553{
2554 yarp::os::idl::WireWriter writer(connection);
2555 return write(writer);
2556}
2557
2559{
2560 yarp::os::idl::WireReader reader(connection);
2561 return read(reader);
2562}
2563
2565{
2566 if (!writer.isNull()) {
2567 if (!writer.writeListHeader(s_reply_len)) {
2568 return false;
2569 }
2570 if (!writer.write(return_helper)) {
2571 return false;
2572 }
2573 }
2574 return true;
2575}
2576
2578{
2579 if (!reader.readListReturn()) {
2580 return false;
2581 }
2582 if (reader.noMore()) {
2583 reader.fail();
2584 return false;
2585 }
2586 if (!reader.read(return_helper)) {
2587 reader.fail();
2588 return false;
2589 }
2590 return true;
2591}
2592
2597
2598// get_map_names_RPC helper class implementation
2600{
2601 return cmd.write(connection);
2602}
2603
2605{
2606 return reply.read(connection);
2607}
2608
2610{
2611 yarp::os::idl::WireWriter writer(connection);
2612 if (!writer.writeListHeader(s_cmd_len)) {
2613 return false;
2614 }
2615 return write(writer);
2616}
2617
2619{
2620 yarp::os::idl::WireReader reader(connection);
2621 if (!reader.readListHeader()) {
2622 reader.fail();
2623 return false;
2624 }
2625 return read(reader);
2626}
2627
2629{
2630 if (!writeTag(writer)) {
2631 return false;
2632 }
2633 if (!writeArgs(writer)) {
2634 return false;
2635 }
2636 return true;
2637}
2638
2640{
2641 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2642 return false;
2643 }
2644 return true;
2645}
2646
2648{
2649 return true;
2650}
2651
2653{
2654 if (!readTag(reader)) {
2655 return false;
2656 }
2657 if (!readArgs(reader)) {
2658 return false;
2659 }
2660 return true;
2661}
2662
2664{
2665 std::string tag = reader.readTag(s_tag_len);
2666 if (reader.isError()) {
2667 return false;
2668 }
2669 if (tag != s_tag) {
2670 reader.fail();
2671 return false;
2672 }
2673 return true;
2674}
2675
2677{
2678 if (!reader.noMore()) {
2679 reader.fail();
2680 return false;
2681 }
2682 return true;
2683}
2684
2686{
2687 yarp::os::idl::WireWriter writer(connection);
2688 return write(writer);
2689}
2690
2692{
2693 yarp::os::idl::WireReader reader(connection);
2694 return read(reader);
2695}
2696
2698{
2699 if (!writer.isNull()) {
2700 if (!writer.writeListHeader(s_reply_len)) {
2701 return false;
2702 }
2703 if (!writer.write(return_helper)) {
2704 return false;
2705 }
2706 }
2707 return true;
2708}
2709
2711{
2712 if (!reader.readListReturn()) {
2713 return false;
2714 }
2715 if (reader.noMore()) {
2716 reader.fail();
2717 return false;
2718 }
2719 if (!reader.read(return_helper)) {
2720 reader.fail();
2721 return false;
2722 }
2723 return true;
2724}
2725
2730
2731// remove_map_RPC helper class implementation
2733 cmd{map_name}
2734{
2735}
2736
2738{
2739 return cmd.write(connection);
2740}
2741
2743{
2744 return reply.read(connection);
2745}
2746
2748 map_name{map_name}
2749{
2750}
2751
2753{
2754 yarp::os::idl::WireWriter writer(connection);
2755 if (!writer.writeListHeader(s_cmd_len)) {
2756 return false;
2757 }
2758 return write(writer);
2759}
2760
2762{
2763 yarp::os::idl::WireReader reader(connection);
2764 if (!reader.readListHeader()) {
2765 reader.fail();
2766 return false;
2767 }
2768 return read(reader);
2769}
2770
2772{
2773 if (!writeTag(writer)) {
2774 return false;
2775 }
2776 if (!writeArgs(writer)) {
2777 return false;
2778 }
2779 return true;
2780}
2781
2783{
2784 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2785 return false;
2786 }
2787 return true;
2788}
2789
2791{
2792 if (!writer.writeString(map_name)) {
2793 return false;
2794 }
2795 return true;
2796}
2797
2799{
2800 if (!readTag(reader)) {
2801 return false;
2802 }
2803 if (!readArgs(reader)) {
2804 return false;
2805 }
2806 return true;
2807}
2808
2810{
2811 std::string tag = reader.readTag(s_tag_len);
2812 if (reader.isError()) {
2813 return false;
2814 }
2815 if (tag != s_tag) {
2816 reader.fail();
2817 return false;
2818 }
2819 return true;
2820}
2821
2823{
2824 if (reader.noMore()) {
2825 reader.fail();
2826 return false;
2827 }
2828 if (!reader.readString(map_name)) {
2829 reader.fail();
2830 return false;
2831 }
2832 if (!reader.noMore()) {
2833 reader.fail();
2834 return false;
2835 }
2836 return true;
2837}
2838
2840{
2841 yarp::os::idl::WireWriter writer(connection);
2842 return write(writer);
2843}
2844
2846{
2847 yarp::os::idl::WireReader reader(connection);
2848 return read(reader);
2849}
2850
2852{
2853 if (!writer.isNull()) {
2854 if (!writer.write(return_helper)) {
2855 return false;
2856 }
2857 }
2858 return true;
2859}
2860
2862{
2863 if (reader.noMore()) {
2864 reader.fail();
2865 return false;
2866 }
2867 if (!reader.read(return_helper)) {
2868 reader.fail();
2869 return false;
2870 }
2871 return true;
2872}
2873
2878
2879// store_location_RPC helper class implementation
2881 cmd{location_name, loc}
2882{
2883}
2884
2886{
2887 return cmd.write(connection);
2888}
2889
2891{
2892 return reply.read(connection);
2893}
2894
2896 location_name{location_name},
2897 loc{loc}
2898{
2899}
2900
2902{
2903 yarp::os::idl::WireWriter writer(connection);
2904 if (!writer.writeListHeader(s_cmd_len)) {
2905 return false;
2906 }
2907 return write(writer);
2908}
2909
2911{
2912 yarp::os::idl::WireReader reader(connection);
2913 if (!reader.readListHeader()) {
2914 reader.fail();
2915 return false;
2916 }
2917 return read(reader);
2918}
2919
2921{
2922 if (!writeTag(writer)) {
2923 return false;
2924 }
2925 if (!writeArgs(writer)) {
2926 return false;
2927 }
2928 return true;
2929}
2930
2932{
2933 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2934 return false;
2935 }
2936 return true;
2937}
2938
2940{
2941 if (!writer.writeString(location_name)) {
2942 return false;
2943 }
2944 if (!writer.writeNested(loc)) {
2945 return false;
2946 }
2947 return true;
2948}
2949
2951{
2952 if (!readTag(reader)) {
2953 return false;
2954 }
2955 if (!readArgs(reader)) {
2956 return false;
2957 }
2958 return true;
2959}
2960
2962{
2963 std::string tag = reader.readTag(s_tag_len);
2964 if (reader.isError()) {
2965 return false;
2966 }
2967 if (tag != s_tag) {
2968 reader.fail();
2969 return false;
2970 }
2971 return true;
2972}
2973
2975{
2976 if (reader.noMore()) {
2977 reader.fail();
2978 return false;
2979 }
2980 if (!reader.readString(location_name)) {
2981 reader.fail();
2982 return false;
2983 }
2984 if (reader.noMore()) {
2985 reader.fail();
2986 return false;
2987 }
2988 if (!reader.readNested(loc)) {
2989 reader.fail();
2990 return false;
2991 }
2992 if (!reader.noMore()) {
2993 reader.fail();
2994 return false;
2995 }
2996 return true;
2997}
2998
3000{
3001 yarp::os::idl::WireWriter writer(connection);
3002 return write(writer);
3003}
3004
3006{
3007 yarp::os::idl::WireReader reader(connection);
3008 return read(reader);
3009}
3010
3012{
3013 if (!writer.isNull()) {
3014 if (!writer.write(return_helper)) {
3015 return false;
3016 }
3017 }
3018 return true;
3019}
3020
3022{
3023 if (reader.noMore()) {
3024 reader.fail();
3025 return false;
3026 }
3027 if (!reader.read(return_helper)) {
3028 reader.fail();
3029 return false;
3030 }
3031 return true;
3032}
3033
3038
3039// store_area_RPC helper class implementation
3041 cmd{area_name, area}
3042{
3043}
3044
3046{
3047 return cmd.write(connection);
3048}
3049
3051{
3052 return reply.read(connection);
3053}
3054
3056 area_name{area_name},
3057 area{area}
3058{
3059}
3060
3062{
3063 yarp::os::idl::WireWriter writer(connection);
3064 if (!writer.writeListHeader(s_cmd_len)) {
3065 return false;
3066 }
3067 return write(writer);
3068}
3069
3071{
3072 yarp::os::idl::WireReader reader(connection);
3073 if (!reader.readListHeader()) {
3074 reader.fail();
3075 return false;
3076 }
3077 return read(reader);
3078}
3079
3081{
3082 if (!writeTag(writer)) {
3083 return false;
3084 }
3085 if (!writeArgs(writer)) {
3086 return false;
3087 }
3088 return true;
3089}
3090
3092{
3093 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3094 return false;
3095 }
3096 return true;
3097}
3098
3100{
3101 if (!writer.writeString(area_name)) {
3102 return false;
3103 }
3104 if (!writer.writeNested(area)) {
3105 return false;
3106 }
3107 return true;
3108}
3109
3111{
3112 if (!readTag(reader)) {
3113 return false;
3114 }
3115 if (!readArgs(reader)) {
3116 return false;
3117 }
3118 return true;
3119}
3120
3122{
3123 std::string tag = reader.readTag(s_tag_len);
3124 if (reader.isError()) {
3125 return false;
3126 }
3127 if (tag != s_tag) {
3128 reader.fail();
3129 return false;
3130 }
3131 return true;
3132}
3133
3135{
3136 if (reader.noMore()) {
3137 reader.fail();
3138 return false;
3139 }
3140 if (!reader.readString(area_name)) {
3141 reader.fail();
3142 return false;
3143 }
3144 if (reader.noMore()) {
3145 reader.fail();
3146 return false;
3147 }
3148 if (!reader.readNested(area)) {
3149 reader.fail();
3150 return false;
3151 }
3152 if (!reader.noMore()) {
3153 reader.fail();
3154 return false;
3155 }
3156 return true;
3157}
3158
3160{
3161 yarp::os::idl::WireWriter writer(connection);
3162 return write(writer);
3163}
3164
3166{
3167 yarp::os::idl::WireReader reader(connection);
3168 return read(reader);
3169}
3170
3172{
3173 if (!writer.isNull()) {
3174 if (!writer.write(return_helper)) {
3175 return false;
3176 }
3177 }
3178 return true;
3179}
3180
3182{
3183 if (reader.noMore()) {
3184 reader.fail();
3185 return false;
3186 }
3187 if (!reader.read(return_helper)) {
3188 reader.fail();
3189 return false;
3190 }
3191 return true;
3192}
3193
3198
3199// store_path_RPC helper class implementation
3201 cmd{path_name, path}
3202{
3203}
3204
3206{
3207 return cmd.write(connection);
3208}
3209
3211{
3212 return reply.read(connection);
3213}
3214
3216 path_name{path_name},
3217 path{path}
3218{
3219}
3220
3222{
3223 yarp::os::idl::WireWriter writer(connection);
3224 if (!writer.writeListHeader(s_cmd_len)) {
3225 return false;
3226 }
3227 return write(writer);
3228}
3229
3231{
3232 yarp::os::idl::WireReader reader(connection);
3233 if (!reader.readListHeader()) {
3234 reader.fail();
3235 return false;
3236 }
3237 return read(reader);
3238}
3239
3241{
3242 if (!writeTag(writer)) {
3243 return false;
3244 }
3245 if (!writeArgs(writer)) {
3246 return false;
3247 }
3248 return true;
3249}
3250
3252{
3253 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3254 return false;
3255 }
3256 return true;
3257}
3258
3260{
3261 if (!writer.writeString(path_name)) {
3262 return false;
3263 }
3264 if (!writer.writeNested(path)) {
3265 return false;
3266 }
3267 return true;
3268}
3269
3271{
3272 if (!readTag(reader)) {
3273 return false;
3274 }
3275 if (!readArgs(reader)) {
3276 return false;
3277 }
3278 return true;
3279}
3280
3282{
3283 std::string tag = reader.readTag(s_tag_len);
3284 if (reader.isError()) {
3285 return false;
3286 }
3287 if (tag != s_tag) {
3288 reader.fail();
3289 return false;
3290 }
3291 return true;
3292}
3293
3295{
3296 if (reader.noMore()) {
3297 reader.fail();
3298 return false;
3299 }
3300 if (!reader.readString(path_name)) {
3301 reader.fail();
3302 return false;
3303 }
3304 if (reader.noMore()) {
3305 reader.fail();
3306 return false;
3307 }
3308 if (!reader.readNested(path)) {
3309 reader.fail();
3310 return false;
3311 }
3312 if (!reader.noMore()) {
3313 reader.fail();
3314 return false;
3315 }
3316 return true;
3317}
3318
3320{
3321 yarp::os::idl::WireWriter writer(connection);
3322 return write(writer);
3323}
3324
3326{
3327 yarp::os::idl::WireReader reader(connection);
3328 return read(reader);
3329}
3330
3332{
3333 if (!writer.isNull()) {
3334 if (!writer.write(return_helper)) {
3335 return false;
3336 }
3337 }
3338 return true;
3339}
3340
3342{
3343 if (reader.noMore()) {
3344 reader.fail();
3345 return false;
3346 }
3347 if (!reader.read(return_helper)) {
3348 reader.fail();
3349 return false;
3350 }
3351 return true;
3352}
3353
3358
3359// get_location_RPC helper class implementation
3361 cmd{location_name}
3362{
3363}
3364
3366{
3367 return cmd.write(connection);
3368}
3369
3371{
3372 return reply.read(connection);
3373}
3374
3376 location_name{location_name}
3377{
3378}
3379
3381{
3382 yarp::os::idl::WireWriter writer(connection);
3383 if (!writer.writeListHeader(s_cmd_len)) {
3384 return false;
3385 }
3386 return write(writer);
3387}
3388
3390{
3391 yarp::os::idl::WireReader reader(connection);
3392 if (!reader.readListHeader()) {
3393 reader.fail();
3394 return false;
3395 }
3396 return read(reader);
3397}
3398
3400{
3401 if (!writeTag(writer)) {
3402 return false;
3403 }
3404 if (!writeArgs(writer)) {
3405 return false;
3406 }
3407 return true;
3408}
3409
3411{
3412 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3413 return false;
3414 }
3415 return true;
3416}
3417
3419{
3420 if (!writer.writeString(location_name)) {
3421 return false;
3422 }
3423 return true;
3424}
3425
3427{
3428 if (!readTag(reader)) {
3429 return false;
3430 }
3431 if (!readArgs(reader)) {
3432 return false;
3433 }
3434 return true;
3435}
3436
3438{
3439 std::string tag = reader.readTag(s_tag_len);
3440 if (reader.isError()) {
3441 return false;
3442 }
3443 if (tag != s_tag) {
3444 reader.fail();
3445 return false;
3446 }
3447 return true;
3448}
3449
3451{
3452 if (reader.noMore()) {
3453 reader.fail();
3454 return false;
3455 }
3456 if (!reader.readString(location_name)) {
3457 reader.fail();
3458 return false;
3459 }
3460 if (!reader.noMore()) {
3461 reader.fail();
3462 return false;
3463 }
3464 return true;
3465}
3466
3468{
3469 yarp::os::idl::WireWriter writer(connection);
3470 return write(writer);
3471}
3472
3474{
3475 yarp::os::idl::WireReader reader(connection);
3476 return read(reader);
3477}
3478
3480{
3481 if (!writer.isNull()) {
3482 if (!writer.writeListHeader(s_reply_len)) {
3483 return false;
3484 }
3485 if (!writer.write(return_helper)) {
3486 return false;
3487 }
3488 }
3489 return true;
3490}
3491
3493{
3494 if (!reader.readListReturn()) {
3495 return false;
3496 }
3497 if (reader.noMore()) {
3498 reader.fail();
3499 return false;
3500 }
3501 if (!reader.read(return_helper)) {
3502 reader.fail();
3503 return false;
3504 }
3505 return true;
3506}
3507
3512
3513// get_area_RPC helper class implementation
3515 cmd{area_name}
3516{
3517}
3518
3520{
3521 return cmd.write(connection);
3522}
3523
3525{
3526 return reply.read(connection);
3527}
3528
3530 area_name{area_name}
3531{
3532}
3533
3535{
3536 yarp::os::idl::WireWriter writer(connection);
3537 if (!writer.writeListHeader(s_cmd_len)) {
3538 return false;
3539 }
3540 return write(writer);
3541}
3542
3544{
3545 yarp::os::idl::WireReader reader(connection);
3546 if (!reader.readListHeader()) {
3547 reader.fail();
3548 return false;
3549 }
3550 return read(reader);
3551}
3552
3554{
3555 if (!writeTag(writer)) {
3556 return false;
3557 }
3558 if (!writeArgs(writer)) {
3559 return false;
3560 }
3561 return true;
3562}
3563
3565{
3566 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3567 return false;
3568 }
3569 return true;
3570}
3571
3573{
3574 if (!writer.writeString(area_name)) {
3575 return false;
3576 }
3577 return true;
3578}
3579
3581{
3582 if (!readTag(reader)) {
3583 return false;
3584 }
3585 if (!readArgs(reader)) {
3586 return false;
3587 }
3588 return true;
3589}
3590
3592{
3593 std::string tag = reader.readTag(s_tag_len);
3594 if (reader.isError()) {
3595 return false;
3596 }
3597 if (tag != s_tag) {
3598 reader.fail();
3599 return false;
3600 }
3601 return true;
3602}
3603
3605{
3606 if (reader.noMore()) {
3607 reader.fail();
3608 return false;
3609 }
3610 if (!reader.readString(area_name)) {
3611 reader.fail();
3612 return false;
3613 }
3614 if (!reader.noMore()) {
3615 reader.fail();
3616 return false;
3617 }
3618 return true;
3619}
3620
3622{
3623 yarp::os::idl::WireWriter writer(connection);
3624 return write(writer);
3625}
3626
3628{
3629 yarp::os::idl::WireReader reader(connection);
3630 return read(reader);
3631}
3632
3634{
3635 if (!writer.isNull()) {
3636 if (!writer.writeListHeader(s_reply_len)) {
3637 return false;
3638 }
3639 if (!writer.write(return_helper)) {
3640 return false;
3641 }
3642 }
3643 return true;
3644}
3645
3647{
3648 if (!reader.readListReturn()) {
3649 return false;
3650 }
3651 if (reader.noMore()) {
3652 reader.fail();
3653 return false;
3654 }
3655 if (!reader.read(return_helper)) {
3656 reader.fail();
3657 return false;
3658 }
3659 return true;
3660}
3661
3666
3667// get_path_RPC helper class implementation
3669 cmd{path_name}
3670{
3671}
3672
3674{
3675 return cmd.write(connection);
3676}
3677
3679{
3680 return reply.read(connection);
3681}
3682
3684 path_name{path_name}
3685{
3686}
3687
3689{
3690 yarp::os::idl::WireWriter writer(connection);
3691 if (!writer.writeListHeader(s_cmd_len)) {
3692 return false;
3693 }
3694 return write(writer);
3695}
3696
3698{
3699 yarp::os::idl::WireReader reader(connection);
3700 if (!reader.readListHeader()) {
3701 reader.fail();
3702 return false;
3703 }
3704 return read(reader);
3705}
3706
3708{
3709 if (!writeTag(writer)) {
3710 return false;
3711 }
3712 if (!writeArgs(writer)) {
3713 return false;
3714 }
3715 return true;
3716}
3717
3719{
3720 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3721 return false;
3722 }
3723 return true;
3724}
3725
3727{
3728 if (!writer.writeString(path_name)) {
3729 return false;
3730 }
3731 return true;
3732}
3733
3735{
3736 if (!readTag(reader)) {
3737 return false;
3738 }
3739 if (!readArgs(reader)) {
3740 return false;
3741 }
3742 return true;
3743}
3744
3746{
3747 std::string tag = reader.readTag(s_tag_len);
3748 if (reader.isError()) {
3749 return false;
3750 }
3751 if (tag != s_tag) {
3752 reader.fail();
3753 return false;
3754 }
3755 return true;
3756}
3757
3759{
3760 if (reader.noMore()) {
3761 reader.fail();
3762 return false;
3763 }
3764 if (!reader.readString(path_name)) {
3765 reader.fail();
3766 return false;
3767 }
3768 if (!reader.noMore()) {
3769 reader.fail();
3770 return false;
3771 }
3772 return true;
3773}
3774
3776{
3777 yarp::os::idl::WireWriter writer(connection);
3778 return write(writer);
3779}
3780
3782{
3783 yarp::os::idl::WireReader reader(connection);
3784 return read(reader);
3785}
3786
3788{
3789 if (!writer.isNull()) {
3790 if (!writer.writeListHeader(s_reply_len)) {
3791 return false;
3792 }
3793 if (!writer.write(return_helper)) {
3794 return false;
3795 }
3796 }
3797 return true;
3798}
3799
3801{
3802 if (!reader.readListReturn()) {
3803 return false;
3804 }
3805 if (reader.noMore()) {
3806 reader.fail();
3807 return false;
3808 }
3809 if (!reader.read(return_helper)) {
3810 reader.fail();
3811 return false;
3812 }
3813 return true;
3814}
3815
3820
3821// get_locations_list_RPC helper class implementation
3823{
3824 return cmd.write(connection);
3825}
3826
3828{
3829 return reply.read(connection);
3830}
3831
3833{
3834 yarp::os::idl::WireWriter writer(connection);
3835 if (!writer.writeListHeader(s_cmd_len)) {
3836 return false;
3837 }
3838 return write(writer);
3839}
3840
3842{
3843 yarp::os::idl::WireReader reader(connection);
3844 if (!reader.readListHeader()) {
3845 reader.fail();
3846 return false;
3847 }
3848 return read(reader);
3849}
3850
3852{
3853 if (!writeTag(writer)) {
3854 return false;
3855 }
3856 if (!writeArgs(writer)) {
3857 return false;
3858 }
3859 return true;
3860}
3861
3863{
3864 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3865 return false;
3866 }
3867 return true;
3868}
3869
3871{
3872 return true;
3873}
3874
3876{
3877 if (!readTag(reader)) {
3878 return false;
3879 }
3880 if (!readArgs(reader)) {
3881 return false;
3882 }
3883 return true;
3884}
3885
3887{
3888 std::string tag = reader.readTag(s_tag_len);
3889 if (reader.isError()) {
3890 return false;
3891 }
3892 if (tag != s_tag) {
3893 reader.fail();
3894 return false;
3895 }
3896 return true;
3897}
3898
3900{
3901 if (!reader.noMore()) {
3902 reader.fail();
3903 return false;
3904 }
3905 return true;
3906}
3907
3909{
3910 yarp::os::idl::WireWriter writer(connection);
3911 return write(writer);
3912}
3913
3915{
3916 yarp::os::idl::WireReader reader(connection);
3917 return read(reader);
3918}
3919
3921{
3922 if (!writer.isNull()) {
3923 if (!writer.writeListHeader(s_reply_len)) {
3924 return false;
3925 }
3926 if (!writer.write(return_helper)) {
3927 return false;
3928 }
3929 }
3930 return true;
3931}
3932
3934{
3935 if (!reader.readListReturn()) {
3936 return false;
3937 }
3938 if (reader.noMore()) {
3939 reader.fail();
3940 return false;
3941 }
3942 if (!reader.read(return_helper)) {
3943 reader.fail();
3944 return false;
3945 }
3946 return true;
3947}
3948
3953
3954// get_areas_list_RPC helper class implementation
3956{
3957 return cmd.write(connection);
3958}
3959
3961{
3962 return reply.read(connection);
3963}
3964
3966{
3967 yarp::os::idl::WireWriter writer(connection);
3968 if (!writer.writeListHeader(s_cmd_len)) {
3969 return false;
3970 }
3971 return write(writer);
3972}
3973
3975{
3976 yarp::os::idl::WireReader reader(connection);
3977 if (!reader.readListHeader()) {
3978 reader.fail();
3979 return false;
3980 }
3981 return read(reader);
3982}
3983
3985{
3986 if (!writeTag(writer)) {
3987 return false;
3988 }
3989 if (!writeArgs(writer)) {
3990 return false;
3991 }
3992 return true;
3993}
3994
3996{
3997 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3998 return false;
3999 }
4000 return true;
4001}
4002
4004{
4005 return true;
4006}
4007
4009{
4010 if (!readTag(reader)) {
4011 return false;
4012 }
4013 if (!readArgs(reader)) {
4014 return false;
4015 }
4016 return true;
4017}
4018
4020{
4021 std::string tag = reader.readTag(s_tag_len);
4022 if (reader.isError()) {
4023 return false;
4024 }
4025 if (tag != s_tag) {
4026 reader.fail();
4027 return false;
4028 }
4029 return true;
4030}
4031
4033{
4034 if (!reader.noMore()) {
4035 reader.fail();
4036 return false;
4037 }
4038 return true;
4039}
4040
4042{
4043 yarp::os::idl::WireWriter writer(connection);
4044 return write(writer);
4045}
4046
4048{
4049 yarp::os::idl::WireReader reader(connection);
4050 return read(reader);
4051}
4052
4054{
4055 if (!writer.isNull()) {
4056 if (!writer.writeListHeader(s_reply_len)) {
4057 return false;
4058 }
4059 if (!writer.write(return_helper)) {
4060 return false;
4061 }
4062 }
4063 return true;
4064}
4065
4067{
4068 if (!reader.readListReturn()) {
4069 return false;
4070 }
4071 if (reader.noMore()) {
4072 reader.fail();
4073 return false;
4074 }
4075 if (!reader.read(return_helper)) {
4076 reader.fail();
4077 return false;
4078 }
4079 return true;
4080}
4081
4086
4087// get_paths_list_RPC helper class implementation
4089{
4090 return cmd.write(connection);
4091}
4092
4094{
4095 return reply.read(connection);
4096}
4097
4099{
4100 yarp::os::idl::WireWriter writer(connection);
4101 if (!writer.writeListHeader(s_cmd_len)) {
4102 return false;
4103 }
4104 return write(writer);
4105}
4106
4108{
4109 yarp::os::idl::WireReader reader(connection);
4110 if (!reader.readListHeader()) {
4111 reader.fail();
4112 return false;
4113 }
4114 return read(reader);
4115}
4116
4118{
4119 if (!writeTag(writer)) {
4120 return false;
4121 }
4122 if (!writeArgs(writer)) {
4123 return false;
4124 }
4125 return true;
4126}
4127
4129{
4130 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4131 return false;
4132 }
4133 return true;
4134}
4135
4137{
4138 return true;
4139}
4140
4142{
4143 if (!readTag(reader)) {
4144 return false;
4145 }
4146 if (!readArgs(reader)) {
4147 return false;
4148 }
4149 return true;
4150}
4151
4153{
4154 std::string tag = reader.readTag(s_tag_len);
4155 if (reader.isError()) {
4156 return false;
4157 }
4158 if (tag != s_tag) {
4159 reader.fail();
4160 return false;
4161 }
4162 return true;
4163}
4164
4166{
4167 if (!reader.noMore()) {
4168 reader.fail();
4169 return false;
4170 }
4171 return true;
4172}
4173
4175{
4176 yarp::os::idl::WireWriter writer(connection);
4177 return write(writer);
4178}
4179
4181{
4182 yarp::os::idl::WireReader reader(connection);
4183 return read(reader);
4184}
4185
4187{
4188 if (!writer.isNull()) {
4189 if (!writer.writeListHeader(s_reply_len)) {
4190 return false;
4191 }
4192 if (!writer.write(return_helper)) {
4193 return false;
4194 }
4195 }
4196 return true;
4197}
4198
4200{
4201 if (!reader.readListReturn()) {
4202 return false;
4203 }
4204 if (reader.noMore()) {
4205 reader.fail();
4206 return false;
4207 }
4208 if (!reader.read(return_helper)) {
4209 reader.fail();
4210 return false;
4211 }
4212 return true;
4213}
4214
4219
4220// get_all_locations_RPC helper class implementation
4222{
4223 return cmd.write(connection);
4224}
4225
4227{
4228 return reply.read(connection);
4229}
4230
4232{
4233 yarp::os::idl::WireWriter writer(connection);
4234 if (!writer.writeListHeader(s_cmd_len)) {
4235 return false;
4236 }
4237 return write(writer);
4238}
4239
4241{
4242 yarp::os::idl::WireReader reader(connection);
4243 if (!reader.readListHeader()) {
4244 reader.fail();
4245 return false;
4246 }
4247 return read(reader);
4248}
4249
4251{
4252 if (!writeTag(writer)) {
4253 return false;
4254 }
4255 if (!writeArgs(writer)) {
4256 return false;
4257 }
4258 return true;
4259}
4260
4262{
4263 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4264 return false;
4265 }
4266 return true;
4267}
4268
4270{
4271 return true;
4272}
4273
4275{
4276 if (!readTag(reader)) {
4277 return false;
4278 }
4279 if (!readArgs(reader)) {
4280 return false;
4281 }
4282 return true;
4283}
4284
4286{
4287 std::string tag = reader.readTag(s_tag_len);
4288 if (reader.isError()) {
4289 return false;
4290 }
4291 if (tag != s_tag) {
4292 reader.fail();
4293 return false;
4294 }
4295 return true;
4296}
4297
4299{
4300 if (!reader.noMore()) {
4301 reader.fail();
4302 return false;
4303 }
4304 return true;
4305}
4306
4308{
4309 yarp::os::idl::WireWriter writer(connection);
4310 return write(writer);
4311}
4312
4314{
4315 yarp::os::idl::WireReader reader(connection);
4316 return read(reader);
4317}
4318
4320{
4321 if (!writer.isNull()) {
4322 if (!writer.writeListHeader(s_reply_len)) {
4323 return false;
4324 }
4325 if (!writer.write(return_helper)) {
4326 return false;
4327 }
4328 }
4329 return true;
4330}
4331
4333{
4334 if (!reader.readListReturn()) {
4335 return false;
4336 }
4337 if (reader.noMore()) {
4338 reader.fail();
4339 return false;
4340 }
4341 if (!reader.read(return_helper)) {
4342 reader.fail();
4343 return false;
4344 }
4345 return true;
4346}
4347
4352
4353// get_all_areas_RPC helper class implementation
4355{
4356 return cmd.write(connection);
4357}
4358
4360{
4361 return reply.read(connection);
4362}
4363
4365{
4366 yarp::os::idl::WireWriter writer(connection);
4367 if (!writer.writeListHeader(s_cmd_len)) {
4368 return false;
4369 }
4370 return write(writer);
4371}
4372
4374{
4375 yarp::os::idl::WireReader reader(connection);
4376 if (!reader.readListHeader()) {
4377 reader.fail();
4378 return false;
4379 }
4380 return read(reader);
4381}
4382
4384{
4385 if (!writeTag(writer)) {
4386 return false;
4387 }
4388 if (!writeArgs(writer)) {
4389 return false;
4390 }
4391 return true;
4392}
4393
4395{
4396 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4397 return false;
4398 }
4399 return true;
4400}
4401
4403{
4404 return true;
4405}
4406
4408{
4409 if (!readTag(reader)) {
4410 return false;
4411 }
4412 if (!readArgs(reader)) {
4413 return false;
4414 }
4415 return true;
4416}
4417
4419{
4420 std::string tag = reader.readTag(s_tag_len);
4421 if (reader.isError()) {
4422 return false;
4423 }
4424 if (tag != s_tag) {
4425 reader.fail();
4426 return false;
4427 }
4428 return true;
4429}
4430
4432{
4433 if (!reader.noMore()) {
4434 reader.fail();
4435 return false;
4436 }
4437 return true;
4438}
4439
4441{
4442 yarp::os::idl::WireWriter writer(connection);
4443 return write(writer);
4444}
4445
4447{
4448 yarp::os::idl::WireReader reader(connection);
4449 return read(reader);
4450}
4451
4453{
4454 if (!writer.isNull()) {
4455 if (!writer.writeListHeader(s_reply_len)) {
4456 return false;
4457 }
4458 if (!writer.write(return_helper)) {
4459 return false;
4460 }
4461 }
4462 return true;
4463}
4464
4466{
4467 if (!reader.readListReturn()) {
4468 return false;
4469 }
4470 if (reader.noMore()) {
4471 reader.fail();
4472 return false;
4473 }
4474 if (!reader.read(return_helper)) {
4475 reader.fail();
4476 return false;
4477 }
4478 return true;
4479}
4480
4485
4486// get_all_paths_RPC helper class implementation
4488{
4489 return cmd.write(connection);
4490}
4491
4493{
4494 return reply.read(connection);
4495}
4496
4498{
4499 yarp::os::idl::WireWriter writer(connection);
4500 if (!writer.writeListHeader(s_cmd_len)) {
4501 return false;
4502 }
4503 return write(writer);
4504}
4505
4507{
4508 yarp::os::idl::WireReader reader(connection);
4509 if (!reader.readListHeader()) {
4510 reader.fail();
4511 return false;
4512 }
4513 return read(reader);
4514}
4515
4517{
4518 if (!writeTag(writer)) {
4519 return false;
4520 }
4521 if (!writeArgs(writer)) {
4522 return false;
4523 }
4524 return true;
4525}
4526
4528{
4529 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4530 return false;
4531 }
4532 return true;
4533}
4534
4536{
4537 return true;
4538}
4539
4541{
4542 if (!readTag(reader)) {
4543 return false;
4544 }
4545 if (!readArgs(reader)) {
4546 return false;
4547 }
4548 return true;
4549}
4550
4552{
4553 std::string tag = reader.readTag(s_tag_len);
4554 if (reader.isError()) {
4555 return false;
4556 }
4557 if (tag != s_tag) {
4558 reader.fail();
4559 return false;
4560 }
4561 return true;
4562}
4563
4565{
4566 if (!reader.noMore()) {
4567 reader.fail();
4568 return false;
4569 }
4570 return true;
4571}
4572
4574{
4575 yarp::os::idl::WireWriter writer(connection);
4576 return write(writer);
4577}
4578
4580{
4581 yarp::os::idl::WireReader reader(connection);
4582 return read(reader);
4583}
4584
4586{
4587 if (!writer.isNull()) {
4588 if (!writer.writeListHeader(s_reply_len)) {
4589 return false;
4590 }
4591 if (!writer.write(return_helper)) {
4592 return false;
4593 }
4594 }
4595 return true;
4596}
4597
4599{
4600 if (!reader.readListReturn()) {
4601 return false;
4602 }
4603 if (reader.noMore()) {
4604 reader.fail();
4605 return false;
4606 }
4607 if (!reader.read(return_helper)) {
4608 reader.fail();
4609 return false;
4610 }
4611 return true;
4612}
4613
4618
4619// rename_location_RPC helper class implementation
4620IMap2DMsgs_rename_location_RPC_helper::IMap2DMsgs_rename_location_RPC_helper(const std::string& original_name, const std::string& new_name) :
4621 cmd{original_name, new_name}
4622{
4623}
4624
4626{
4627 return cmd.write(connection);
4628}
4629
4631{
4632 return reply.read(connection);
4633}
4634
4635IMap2DMsgs_rename_location_RPC_helper::Command::Command(const std::string& original_name, const std::string& new_name) :
4636 original_name{original_name},
4637 new_name{new_name}
4638{
4639}
4640
4642{
4643 yarp::os::idl::WireWriter writer(connection);
4644 if (!writer.writeListHeader(s_cmd_len)) {
4645 return false;
4646 }
4647 return write(writer);
4648}
4649
4651{
4652 yarp::os::idl::WireReader reader(connection);
4653 if (!reader.readListHeader()) {
4654 reader.fail();
4655 return false;
4656 }
4657 return read(reader);
4658}
4659
4661{
4662 if (!writeTag(writer)) {
4663 return false;
4664 }
4665 if (!writeArgs(writer)) {
4666 return false;
4667 }
4668 return true;
4669}
4670
4672{
4673 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4674 return false;
4675 }
4676 return true;
4677}
4678
4680{
4681 if (!writer.writeString(original_name)) {
4682 return false;
4683 }
4684 if (!writer.writeString(new_name)) {
4685 return false;
4686 }
4687 return true;
4688}
4689
4691{
4692 if (!readTag(reader)) {
4693 return false;
4694 }
4695 if (!readArgs(reader)) {
4696 return false;
4697 }
4698 return true;
4699}
4700
4702{
4703 std::string tag = reader.readTag(s_tag_len);
4704 if (reader.isError()) {
4705 return false;
4706 }
4707 if (tag != s_tag) {
4708 reader.fail();
4709 return false;
4710 }
4711 return true;
4712}
4713
4715{
4716 if (reader.noMore()) {
4717 reader.fail();
4718 return false;
4719 }
4720 if (!reader.readString(original_name)) {
4721 reader.fail();
4722 return false;
4723 }
4724 if (reader.noMore()) {
4725 reader.fail();
4726 return false;
4727 }
4728 if (!reader.readString(new_name)) {
4729 reader.fail();
4730 return false;
4731 }
4732 if (!reader.noMore()) {
4733 reader.fail();
4734 return false;
4735 }
4736 return true;
4737}
4738
4740{
4741 yarp::os::idl::WireWriter writer(connection);
4742 return write(writer);
4743}
4744
4746{
4747 yarp::os::idl::WireReader reader(connection);
4748 return read(reader);
4749}
4750
4752{
4753 if (!writer.isNull()) {
4754 if (!writer.write(return_helper)) {
4755 return false;
4756 }
4757 }
4758 return true;
4759}
4760
4762{
4763 if (reader.noMore()) {
4764 reader.fail();
4765 return false;
4766 }
4767 if (!reader.read(return_helper)) {
4768 reader.fail();
4769 return false;
4770 }
4771 return true;
4772}
4773
4778
4779// delete_location_RPC helper class implementation
4781 cmd{location_name}
4782{
4783}
4784
4786{
4787 return cmd.write(connection);
4788}
4789
4791{
4792 return reply.read(connection);
4793}
4794
4796 location_name{location_name}
4797{
4798}
4799
4801{
4802 yarp::os::idl::WireWriter writer(connection);
4803 if (!writer.writeListHeader(s_cmd_len)) {
4804 return false;
4805 }
4806 return write(writer);
4807}
4808
4810{
4811 yarp::os::idl::WireReader reader(connection);
4812 if (!reader.readListHeader()) {
4813 reader.fail();
4814 return false;
4815 }
4816 return read(reader);
4817}
4818
4820{
4821 if (!writeTag(writer)) {
4822 return false;
4823 }
4824 if (!writeArgs(writer)) {
4825 return false;
4826 }
4827 return true;
4828}
4829
4831{
4832 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4833 return false;
4834 }
4835 return true;
4836}
4837
4839{
4840 if (!writer.writeString(location_name)) {
4841 return false;
4842 }
4843 return true;
4844}
4845
4847{
4848 if (!readTag(reader)) {
4849 return false;
4850 }
4851 if (!readArgs(reader)) {
4852 return false;
4853 }
4854 return true;
4855}
4856
4858{
4859 std::string tag = reader.readTag(s_tag_len);
4860 if (reader.isError()) {
4861 return false;
4862 }
4863 if (tag != s_tag) {
4864 reader.fail();
4865 return false;
4866 }
4867 return true;
4868}
4869
4871{
4872 if (reader.noMore()) {
4873 reader.fail();
4874 return false;
4875 }
4876 if (!reader.readString(location_name)) {
4877 reader.fail();
4878 return false;
4879 }
4880 if (!reader.noMore()) {
4881 reader.fail();
4882 return false;
4883 }
4884 return true;
4885}
4886
4888{
4889 yarp::os::idl::WireWriter writer(connection);
4890 return write(writer);
4891}
4892
4894{
4895 yarp::os::idl::WireReader reader(connection);
4896 return read(reader);
4897}
4898
4900{
4901 if (!writer.isNull()) {
4902 if (!writer.write(return_helper)) {
4903 return false;
4904 }
4905 }
4906 return true;
4907}
4908
4910{
4911 if (reader.noMore()) {
4912 reader.fail();
4913 return false;
4914 }
4915 if (!reader.read(return_helper)) {
4916 reader.fail();
4917 return false;
4918 }
4919 return true;
4920}
4921
4926
4927// delete_path_RPC helper class implementation
4929 cmd{path_name}
4930{
4931}
4932
4934{
4935 return cmd.write(connection);
4936}
4937
4939{
4940 return reply.read(connection);
4941}
4942
4944 path_name{path_name}
4945{
4946}
4947
4949{
4950 yarp::os::idl::WireWriter writer(connection);
4951 if (!writer.writeListHeader(s_cmd_len)) {
4952 return false;
4953 }
4954 return write(writer);
4955}
4956
4958{
4959 yarp::os::idl::WireReader reader(connection);
4960 if (!reader.readListHeader()) {
4961 reader.fail();
4962 return false;
4963 }
4964 return read(reader);
4965}
4966
4968{
4969 if (!writeTag(writer)) {
4970 return false;
4971 }
4972 if (!writeArgs(writer)) {
4973 return false;
4974 }
4975 return true;
4976}
4977
4979{
4980 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4981 return false;
4982 }
4983 return true;
4984}
4985
4987{
4988 if (!writer.writeString(path_name)) {
4989 return false;
4990 }
4991 return true;
4992}
4993
4995{
4996 if (!readTag(reader)) {
4997 return false;
4998 }
4999 if (!readArgs(reader)) {
5000 return false;
5001 }
5002 return true;
5003}
5004
5006{
5007 std::string tag = reader.readTag(s_tag_len);
5008 if (reader.isError()) {
5009 return false;
5010 }
5011 if (tag != s_tag) {
5012 reader.fail();
5013 return false;
5014 }
5015 return true;
5016}
5017
5019{
5020 if (reader.noMore()) {
5021 reader.fail();
5022 return false;
5023 }
5024 if (!reader.readString(path_name)) {
5025 reader.fail();
5026 return false;
5027 }
5028 if (!reader.noMore()) {
5029 reader.fail();
5030 return false;
5031 }
5032 return true;
5033}
5034
5036{
5037 yarp::os::idl::WireWriter writer(connection);
5038 return write(writer);
5039}
5040
5042{
5043 yarp::os::idl::WireReader reader(connection);
5044 return read(reader);
5045}
5046
5048{
5049 if (!writer.isNull()) {
5050 if (!writer.write(return_helper)) {
5051 return false;
5052 }
5053 }
5054 return true;
5055}
5056
5058{
5059 if (reader.noMore()) {
5060 reader.fail();
5061 return false;
5062 }
5063 if (!reader.read(return_helper)) {
5064 reader.fail();
5065 return false;
5066 }
5067 return true;
5068}
5069
5074
5075// rename_area_RPC helper class implementation
5076IMap2DMsgs_rename_area_RPC_helper::IMap2DMsgs_rename_area_RPC_helper(const std::string& original_name, const std::string& new_name) :
5077 cmd{original_name, new_name}
5078{
5079}
5080
5082{
5083 return cmd.write(connection);
5084}
5085
5087{
5088 return reply.read(connection);
5089}
5090
5091IMap2DMsgs_rename_area_RPC_helper::Command::Command(const std::string& original_name, const std::string& new_name) :
5092 original_name{original_name},
5093 new_name{new_name}
5094{
5095}
5096
5098{
5099 yarp::os::idl::WireWriter writer(connection);
5100 if (!writer.writeListHeader(s_cmd_len)) {
5101 return false;
5102 }
5103 return write(writer);
5104}
5105
5107{
5108 yarp::os::idl::WireReader reader(connection);
5109 if (!reader.readListHeader()) {
5110 reader.fail();
5111 return false;
5112 }
5113 return read(reader);
5114}
5115
5117{
5118 if (!writeTag(writer)) {
5119 return false;
5120 }
5121 if (!writeArgs(writer)) {
5122 return false;
5123 }
5124 return true;
5125}
5126
5128{
5129 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5130 return false;
5131 }
5132 return true;
5133}
5134
5136{
5137 if (!writer.writeString(original_name)) {
5138 return false;
5139 }
5140 if (!writer.writeString(new_name)) {
5141 return false;
5142 }
5143 return true;
5144}
5145
5147{
5148 if (!readTag(reader)) {
5149 return false;
5150 }
5151 if (!readArgs(reader)) {
5152 return false;
5153 }
5154 return true;
5155}
5156
5158{
5159 std::string tag = reader.readTag(s_tag_len);
5160 if (reader.isError()) {
5161 return false;
5162 }
5163 if (tag != s_tag) {
5164 reader.fail();
5165 return false;
5166 }
5167 return true;
5168}
5169
5171{
5172 if (reader.noMore()) {
5173 reader.fail();
5174 return false;
5175 }
5176 if (!reader.readString(original_name)) {
5177 reader.fail();
5178 return false;
5179 }
5180 if (reader.noMore()) {
5181 reader.fail();
5182 return false;
5183 }
5184 if (!reader.readString(new_name)) {
5185 reader.fail();
5186 return false;
5187 }
5188 if (!reader.noMore()) {
5189 reader.fail();
5190 return false;
5191 }
5192 return true;
5193}
5194
5196{
5197 yarp::os::idl::WireWriter writer(connection);
5198 return write(writer);
5199}
5200
5202{
5203 yarp::os::idl::WireReader reader(connection);
5204 return read(reader);
5205}
5206
5208{
5209 if (!writer.isNull()) {
5210 if (!writer.write(return_helper)) {
5211 return false;
5212 }
5213 }
5214 return true;
5215}
5216
5218{
5219 if (reader.noMore()) {
5220 reader.fail();
5221 return false;
5222 }
5223 if (!reader.read(return_helper)) {
5224 reader.fail();
5225 return false;
5226 }
5227 return true;
5228}
5229
5234
5235// rename_path_RPC helper class implementation
5236IMap2DMsgs_rename_path_RPC_helper::IMap2DMsgs_rename_path_RPC_helper(const std::string& original_name, const std::string& new_name) :
5237 cmd{original_name, new_name}
5238{
5239}
5240
5242{
5243 return cmd.write(connection);
5244}
5245
5247{
5248 return reply.read(connection);
5249}
5250
5251IMap2DMsgs_rename_path_RPC_helper::Command::Command(const std::string& original_name, const std::string& new_name) :
5252 original_name{original_name},
5253 new_name{new_name}
5254{
5255}
5256
5258{
5259 yarp::os::idl::WireWriter writer(connection);
5260 if (!writer.writeListHeader(s_cmd_len)) {
5261 return false;
5262 }
5263 return write(writer);
5264}
5265
5267{
5268 yarp::os::idl::WireReader reader(connection);
5269 if (!reader.readListHeader()) {
5270 reader.fail();
5271 return false;
5272 }
5273 return read(reader);
5274}
5275
5277{
5278 if (!writeTag(writer)) {
5279 return false;
5280 }
5281 if (!writeArgs(writer)) {
5282 return false;
5283 }
5284 return true;
5285}
5286
5288{
5289 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5290 return false;
5291 }
5292 return true;
5293}
5294
5296{
5297 if (!writer.writeString(original_name)) {
5298 return false;
5299 }
5300 if (!writer.writeString(new_name)) {
5301 return false;
5302 }
5303 return true;
5304}
5305
5307{
5308 if (!readTag(reader)) {
5309 return false;
5310 }
5311 if (!readArgs(reader)) {
5312 return false;
5313 }
5314 return true;
5315}
5316
5318{
5319 std::string tag = reader.readTag(s_tag_len);
5320 if (reader.isError()) {
5321 return false;
5322 }
5323 if (tag != s_tag) {
5324 reader.fail();
5325 return false;
5326 }
5327 return true;
5328}
5329
5331{
5332 if (reader.noMore()) {
5333 reader.fail();
5334 return false;
5335 }
5336 if (!reader.readString(original_name)) {
5337 reader.fail();
5338 return false;
5339 }
5340 if (reader.noMore()) {
5341 reader.fail();
5342 return false;
5343 }
5344 if (!reader.readString(new_name)) {
5345 reader.fail();
5346 return false;
5347 }
5348 if (!reader.noMore()) {
5349 reader.fail();
5350 return false;
5351 }
5352 return true;
5353}
5354
5356{
5357 yarp::os::idl::WireWriter writer(connection);
5358 return write(writer);
5359}
5360
5362{
5363 yarp::os::idl::WireReader reader(connection);
5364 return read(reader);
5365}
5366
5368{
5369 if (!writer.isNull()) {
5370 if (!writer.write(return_helper)) {
5371 return false;
5372 }
5373 }
5374 return true;
5375}
5376
5378{
5379 if (reader.noMore()) {
5380 reader.fail();
5381 return false;
5382 }
5383 if (!reader.read(return_helper)) {
5384 reader.fail();
5385 return false;
5386 }
5387 return true;
5388}
5389
5394
5395// delete_area_RPC helper class implementation
5397 cmd{area_name}
5398{
5399}
5400
5402{
5403 return cmd.write(connection);
5404}
5405
5407{
5408 return reply.read(connection);
5409}
5410
5412 area_name{area_name}
5413{
5414}
5415
5417{
5418 yarp::os::idl::WireWriter writer(connection);
5419 if (!writer.writeListHeader(s_cmd_len)) {
5420 return false;
5421 }
5422 return write(writer);
5423}
5424
5426{
5427 yarp::os::idl::WireReader reader(connection);
5428 if (!reader.readListHeader()) {
5429 reader.fail();
5430 return false;
5431 }
5432 return read(reader);
5433}
5434
5436{
5437 if (!writeTag(writer)) {
5438 return false;
5439 }
5440 if (!writeArgs(writer)) {
5441 return false;
5442 }
5443 return true;
5444}
5445
5447{
5448 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5449 return false;
5450 }
5451 return true;
5452}
5453
5455{
5456 if (!writer.writeString(area_name)) {
5457 return false;
5458 }
5459 return true;
5460}
5461
5463{
5464 if (!readTag(reader)) {
5465 return false;
5466 }
5467 if (!readArgs(reader)) {
5468 return false;
5469 }
5470 return true;
5471}
5472
5474{
5475 std::string tag = reader.readTag(s_tag_len);
5476 if (reader.isError()) {
5477 return false;
5478 }
5479 if (tag != s_tag) {
5480 reader.fail();
5481 return false;
5482 }
5483 return true;
5484}
5485
5487{
5488 if (reader.noMore()) {
5489 reader.fail();
5490 return false;
5491 }
5492 if (!reader.readString(area_name)) {
5493 reader.fail();
5494 return false;
5495 }
5496 if (!reader.noMore()) {
5497 reader.fail();
5498 return false;
5499 }
5500 return true;
5501}
5502
5504{
5505 yarp::os::idl::WireWriter writer(connection);
5506 return write(writer);
5507}
5508
5510{
5511 yarp::os::idl::WireReader reader(connection);
5512 return read(reader);
5513}
5514
5516{
5517 if (!writer.isNull()) {
5518 if (!writer.write(return_helper)) {
5519 return false;
5520 }
5521 }
5522 return true;
5523}
5524
5526{
5527 if (reader.noMore()) {
5528 reader.fail();
5529 return false;
5530 }
5531 if (!reader.read(return_helper)) {
5532 reader.fail();
5533 return false;
5534 }
5535 return true;
5536}
5537
5542
5543// clear_all_locations_RPC helper class implementation
5545{
5546 return cmd.write(connection);
5547}
5548
5550{
5551 return reply.read(connection);
5552}
5553
5555{
5556 yarp::os::idl::WireWriter writer(connection);
5557 if (!writer.writeListHeader(s_cmd_len)) {
5558 return false;
5559 }
5560 return write(writer);
5561}
5562
5564{
5565 yarp::os::idl::WireReader reader(connection);
5566 if (!reader.readListHeader()) {
5567 reader.fail();
5568 return false;
5569 }
5570 return read(reader);
5571}
5572
5574{
5575 if (!writeTag(writer)) {
5576 return false;
5577 }
5578 if (!writeArgs(writer)) {
5579 return false;
5580 }
5581 return true;
5582}
5583
5585{
5586 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5587 return false;
5588 }
5589 return true;
5590}
5591
5593{
5594 return true;
5595}
5596
5598{
5599 if (!readTag(reader)) {
5600 return false;
5601 }
5602 if (!readArgs(reader)) {
5603 return false;
5604 }
5605 return true;
5606}
5607
5609{
5610 std::string tag = reader.readTag(s_tag_len);
5611 if (reader.isError()) {
5612 return false;
5613 }
5614 if (tag != s_tag) {
5615 reader.fail();
5616 return false;
5617 }
5618 return true;
5619}
5620
5622{
5623 if (!reader.noMore()) {
5624 reader.fail();
5625 return false;
5626 }
5627 return true;
5628}
5629
5631{
5632 yarp::os::idl::WireWriter writer(connection);
5633 return write(writer);
5634}
5635
5637{
5638 yarp::os::idl::WireReader reader(connection);
5639 return read(reader);
5640}
5641
5643{
5644 if (!writer.isNull()) {
5645 if (!writer.write(return_helper)) {
5646 return false;
5647 }
5648 }
5649 return true;
5650}
5651
5653{
5654 if (reader.noMore()) {
5655 reader.fail();
5656 return false;
5657 }
5658 if (!reader.read(return_helper)) {
5659 reader.fail();
5660 return false;
5661 }
5662 return true;
5663}
5664
5669
5670// clear_all_areas_RPC helper class implementation
5672{
5673 return cmd.write(connection);
5674}
5675
5677{
5678 return reply.read(connection);
5679}
5680
5682{
5683 yarp::os::idl::WireWriter writer(connection);
5684 if (!writer.writeListHeader(s_cmd_len)) {
5685 return false;
5686 }
5687 return write(writer);
5688}
5689
5691{
5692 yarp::os::idl::WireReader reader(connection);
5693 if (!reader.readListHeader()) {
5694 reader.fail();
5695 return false;
5696 }
5697 return read(reader);
5698}
5699
5701{
5702 if (!writeTag(writer)) {
5703 return false;
5704 }
5705 if (!writeArgs(writer)) {
5706 return false;
5707 }
5708 return true;
5709}
5710
5712{
5713 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5714 return false;
5715 }
5716 return true;
5717}
5718
5720{
5721 return true;
5722}
5723
5725{
5726 if (!readTag(reader)) {
5727 return false;
5728 }
5729 if (!readArgs(reader)) {
5730 return false;
5731 }
5732 return true;
5733}
5734
5736{
5737 std::string tag = reader.readTag(s_tag_len);
5738 if (reader.isError()) {
5739 return false;
5740 }
5741 if (tag != s_tag) {
5742 reader.fail();
5743 return false;
5744 }
5745 return true;
5746}
5747
5749{
5750 if (!reader.noMore()) {
5751 reader.fail();
5752 return false;
5753 }
5754 return true;
5755}
5756
5758{
5759 yarp::os::idl::WireWriter writer(connection);
5760 return write(writer);
5761}
5762
5764{
5765 yarp::os::idl::WireReader reader(connection);
5766 return read(reader);
5767}
5768
5770{
5771 if (!writer.isNull()) {
5772 if (!writer.write(return_helper)) {
5773 return false;
5774 }
5775 }
5776 return true;
5777}
5778
5780{
5781 if (reader.noMore()) {
5782 reader.fail();
5783 return false;
5784 }
5785 if (!reader.read(return_helper)) {
5786 reader.fail();
5787 return false;
5788 }
5789 return true;
5790}
5791
5796
5797// clear_all_paths_RPC helper class implementation
5799{
5800 return cmd.write(connection);
5801}
5802
5804{
5805 return reply.read(connection);
5806}
5807
5809{
5810 yarp::os::idl::WireWriter writer(connection);
5811 if (!writer.writeListHeader(s_cmd_len)) {
5812 return false;
5813 }
5814 return write(writer);
5815}
5816
5818{
5819 yarp::os::idl::WireReader reader(connection);
5820 if (!reader.readListHeader()) {
5821 reader.fail();
5822 return false;
5823 }
5824 return read(reader);
5825}
5826
5828{
5829 if (!writeTag(writer)) {
5830 return false;
5831 }
5832 if (!writeArgs(writer)) {
5833 return false;
5834 }
5835 return true;
5836}
5837
5839{
5840 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5841 return false;
5842 }
5843 return true;
5844}
5845
5847{
5848 return true;
5849}
5850
5852{
5853 if (!readTag(reader)) {
5854 return false;
5855 }
5856 if (!readArgs(reader)) {
5857 return false;
5858 }
5859 return true;
5860}
5861
5863{
5864 std::string tag = reader.readTag(s_tag_len);
5865 if (reader.isError()) {
5866 return false;
5867 }
5868 if (tag != s_tag) {
5869 reader.fail();
5870 return false;
5871 }
5872 return true;
5873}
5874
5876{
5877 if (!reader.noMore()) {
5878 reader.fail();
5879 return false;
5880 }
5881 return true;
5882}
5883
5885{
5886 yarp::os::idl::WireWriter writer(connection);
5887 return write(writer);
5888}
5889
5891{
5892 yarp::os::idl::WireReader reader(connection);
5893 return read(reader);
5894}
5895
5897{
5898 if (!writer.isNull()) {
5899 if (!writer.write(return_helper)) {
5900 return false;
5901 }
5902 }
5903 return true;
5904}
5905
5907{
5908 if (reader.noMore()) {
5909 reader.fail();
5910 return false;
5911 }
5912 if (!reader.read(return_helper)) {
5913 reader.fail();
5914 return false;
5915 }
5916 return true;
5917}
5918
5923
5924// clear_all_maps_temporary_flags_RPC helper class implementation
5929
5934
5936{
5937 yarp::os::idl::WireWriter writer(connection);
5938 if (!writer.writeListHeader(s_cmd_len)) {
5939 return false;
5940 }
5941 return write(writer);
5942}
5943
5945{
5946 yarp::os::idl::WireReader reader(connection);
5947 if (!reader.readListHeader()) {
5948 reader.fail();
5949 return false;
5950 }
5951 return read(reader);
5952}
5953
5955{
5956 if (!writeTag(writer)) {
5957 return false;
5958 }
5959 if (!writeArgs(writer)) {
5960 return false;
5961 }
5962 return true;
5963}
5964
5966{
5967 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5968 return false;
5969 }
5970 return true;
5971}
5972
5974{
5975 return true;
5976}
5977
5979{
5980 if (!readTag(reader)) {
5981 return false;
5982 }
5983 if (!readArgs(reader)) {
5984 return false;
5985 }
5986 return true;
5987}
5988
5990{
5991 std::string tag = reader.readTag(s_tag_len);
5992 if (reader.isError()) {
5993 return false;
5994 }
5995 if (tag != s_tag) {
5996 reader.fail();
5997 return false;
5998 }
5999 return true;
6000}
6001
6003{
6004 if (!reader.noMore()) {
6005 reader.fail();
6006 return false;
6007 }
6008 return true;
6009}
6010
6012{
6013 yarp::os::idl::WireWriter writer(connection);
6014 return write(writer);
6015}
6016
6022
6024{
6025 if (!writer.isNull()) {
6026 if (!writer.write(return_helper)) {
6027 return false;
6028 }
6029 }
6030 return true;
6031}
6032
6034{
6035 if (reader.noMore()) {
6036 reader.fail();
6037 return false;
6038 }
6039 if (!reader.read(return_helper)) {
6040 reader.fail();
6041 return false;
6042 }
6043 return true;
6044}
6045
6050
6051// clear_map_temporary_flags_RPC helper class implementation
6056
6058{
6059 return cmd.write(connection);
6060}
6061
6066
6068 map_name{map_name}
6069{
6070}
6071
6073{
6074 yarp::os::idl::WireWriter writer(connection);
6075 if (!writer.writeListHeader(s_cmd_len)) {
6076 return false;
6077 }
6078 return write(writer);
6079}
6080
6082{
6083 yarp::os::idl::WireReader reader(connection);
6084 if (!reader.readListHeader()) {
6085 reader.fail();
6086 return false;
6087 }
6088 return read(reader);
6089}
6090
6092{
6093 if (!writeTag(writer)) {
6094 return false;
6095 }
6096 if (!writeArgs(writer)) {
6097 return false;
6098 }
6099 return true;
6100}
6101
6103{
6104 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6105 return false;
6106 }
6107 return true;
6108}
6109
6111{
6112 if (!writer.writeString(map_name)) {
6113 return false;
6114 }
6115 return true;
6116}
6117
6119{
6120 if (!readTag(reader)) {
6121 return false;
6122 }
6123 if (!readArgs(reader)) {
6124 return false;
6125 }
6126 return true;
6127}
6128
6130{
6131 std::string tag = reader.readTag(s_tag_len);
6132 if (reader.isError()) {
6133 return false;
6134 }
6135 if (tag != s_tag) {
6136 reader.fail();
6137 return false;
6138 }
6139 return true;
6140}
6141
6143{
6144 if (reader.noMore()) {
6145 reader.fail();
6146 return false;
6147 }
6148 if (!reader.readString(map_name)) {
6149 reader.fail();
6150 return false;
6151 }
6152 if (!reader.noMore()) {
6153 reader.fail();
6154 return false;
6155 }
6156 return true;
6157}
6158
6160{
6161 yarp::os::idl::WireWriter writer(connection);
6162 return write(writer);
6163}
6164
6166{
6167 yarp::os::idl::WireReader reader(connection);
6168 return read(reader);
6169}
6170
6172{
6173 if (!writer.isNull()) {
6174 if (!writer.write(return_helper)) {
6175 return false;
6176 }
6177 }
6178 return true;
6179}
6180
6182{
6183 if (reader.noMore()) {
6184 reader.fail();
6185 return false;
6186 }
6187 if (!reader.read(return_helper)) {
6188 reader.fail();
6189 return false;
6190 }
6191 return true;
6192}
6193
6198
6199// save_maps_collection_RPC helper class implementation
6201 cmd{maps_collection_file}
6202{
6203}
6204
6206{
6207 return cmd.write(connection);
6208}
6209
6211{
6212 return reply.read(connection);
6213}
6214
6216 maps_collection_file{maps_collection_file}
6217{
6218}
6219
6221{
6222 yarp::os::idl::WireWriter writer(connection);
6223 if (!writer.writeListHeader(s_cmd_len)) {
6224 return false;
6225 }
6226 return write(writer);
6227}
6228
6230{
6231 yarp::os::idl::WireReader reader(connection);
6232 if (!reader.readListHeader()) {
6233 reader.fail();
6234 return false;
6235 }
6236 return read(reader);
6237}
6238
6240{
6241 if (!writeTag(writer)) {
6242 return false;
6243 }
6244 if (!writeArgs(writer)) {
6245 return false;
6246 }
6247 return true;
6248}
6249
6251{
6252 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6253 return false;
6254 }
6255 return true;
6256}
6257
6259{
6260 if (!writer.writeString(maps_collection_file)) {
6261 return false;
6262 }
6263 return true;
6264}
6265
6267{
6268 if (!readTag(reader)) {
6269 return false;
6270 }
6271 if (!readArgs(reader)) {
6272 return false;
6273 }
6274 return true;
6275}
6276
6278{
6279 std::string tag = reader.readTag(s_tag_len);
6280 if (reader.isError()) {
6281 return false;
6282 }
6283 if (tag != s_tag) {
6284 reader.fail();
6285 return false;
6286 }
6287 return true;
6288}
6289
6291{
6292 if (reader.noMore()) {
6293 reader.fail();
6294 return false;
6295 }
6296 if (!reader.readString(maps_collection_file)) {
6297 reader.fail();
6298 return false;
6299 }
6300 if (!reader.noMore()) {
6301 reader.fail();
6302 return false;
6303 }
6304 return true;
6305}
6306
6308{
6309 yarp::os::idl::WireWriter writer(connection);
6310 return write(writer);
6311}
6312
6314{
6315 yarp::os::idl::WireReader reader(connection);
6316 return read(reader);
6317}
6318
6320{
6321 if (!writer.isNull()) {
6322 if (!writer.write(return_helper)) {
6323 return false;
6324 }
6325 }
6326 return true;
6327}
6328
6330{
6331 if (reader.noMore()) {
6332 reader.fail();
6333 return false;
6334 }
6335 if (!reader.read(return_helper)) {
6336 reader.fail();
6337 return false;
6338 }
6339 return true;
6340}
6341
6346
6347// load_maps_collection_RPC helper class implementation
6349 cmd{maps_collection_file}
6350{
6351}
6352
6354{
6355 return cmd.write(connection);
6356}
6357
6359{
6360 return reply.read(connection);
6361}
6362
6364 maps_collection_file{maps_collection_file}
6365{
6366}
6367
6369{
6370 yarp::os::idl::WireWriter writer(connection);
6371 if (!writer.writeListHeader(s_cmd_len)) {
6372 return false;
6373 }
6374 return write(writer);
6375}
6376
6378{
6379 yarp::os::idl::WireReader reader(connection);
6380 if (!reader.readListHeader()) {
6381 reader.fail();
6382 return false;
6383 }
6384 return read(reader);
6385}
6386
6388{
6389 if (!writeTag(writer)) {
6390 return false;
6391 }
6392 if (!writeArgs(writer)) {
6393 return false;
6394 }
6395 return true;
6396}
6397
6399{
6400 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6401 return false;
6402 }
6403 return true;
6404}
6405
6407{
6408 if (!writer.writeString(maps_collection_file)) {
6409 return false;
6410 }
6411 return true;
6412}
6413
6415{
6416 if (!readTag(reader)) {
6417 return false;
6418 }
6419 if (!readArgs(reader)) {
6420 return false;
6421 }
6422 return true;
6423}
6424
6426{
6427 std::string tag = reader.readTag(s_tag_len);
6428 if (reader.isError()) {
6429 return false;
6430 }
6431 if (tag != s_tag) {
6432 reader.fail();
6433 return false;
6434 }
6435 return true;
6436}
6437
6439{
6440 if (reader.noMore()) {
6441 reader.fail();
6442 return false;
6443 }
6444 if (!reader.readString(maps_collection_file)) {
6445 reader.fail();
6446 return false;
6447 }
6448 if (!reader.noMore()) {
6449 reader.fail();
6450 return false;
6451 }
6452 return true;
6453}
6454
6456{
6457 yarp::os::idl::WireWriter writer(connection);
6458 return write(writer);
6459}
6460
6462{
6463 yarp::os::idl::WireReader reader(connection);
6464 return read(reader);
6465}
6466
6468{
6469 if (!writer.isNull()) {
6470 if (!writer.write(return_helper)) {
6471 return false;
6472 }
6473 }
6474 return true;
6475}
6476
6478{
6479 if (reader.noMore()) {
6480 reader.fail();
6481 return false;
6482 }
6483 if (!reader.read(return_helper)) {
6484 reader.fail();
6485 return false;
6486 }
6487 return true;
6488}
6489
6494
6495// save_locations_and_extras_RPC helper class implementation
6497 cmd{locations_collection_file}
6498{
6499}
6500
6502{
6503 return cmd.write(connection);
6504}
6505
6510
6511IMap2DMsgs_save_locations_and_extras_RPC_helper::Command::Command(const std::string& locations_collection_file) :
6512 locations_collection_file{locations_collection_file}
6513{
6514}
6515
6517{
6518 yarp::os::idl::WireWriter writer(connection);
6519 if (!writer.writeListHeader(s_cmd_len)) {
6520 return false;
6521 }
6522 return write(writer);
6523}
6524
6526{
6527 yarp::os::idl::WireReader reader(connection);
6528 if (!reader.readListHeader()) {
6529 reader.fail();
6530 return false;
6531 }
6532 return read(reader);
6533}
6534
6536{
6537 if (!writeTag(writer)) {
6538 return false;
6539 }
6540 if (!writeArgs(writer)) {
6541 return false;
6542 }
6543 return true;
6544}
6545
6547{
6548 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6549 return false;
6550 }
6551 return true;
6552}
6553
6555{
6556 if (!writer.writeString(locations_collection_file)) {
6557 return false;
6558 }
6559 return true;
6560}
6561
6563{
6564 if (!readTag(reader)) {
6565 return false;
6566 }
6567 if (!readArgs(reader)) {
6568 return false;
6569 }
6570 return true;
6571}
6572
6574{
6575 std::string tag = reader.readTag(s_tag_len);
6576 if (reader.isError()) {
6577 return false;
6578 }
6579 if (tag != s_tag) {
6580 reader.fail();
6581 return false;
6582 }
6583 return true;
6584}
6585
6587{
6588 if (reader.noMore()) {
6589 reader.fail();
6590 return false;
6591 }
6592 if (!reader.readString(locations_collection_file)) {
6593 reader.fail();
6594 return false;
6595 }
6596 if (!reader.noMore()) {
6597 reader.fail();
6598 return false;
6599 }
6600 return true;
6601}
6602
6604{
6605 yarp::os::idl::WireWriter writer(connection);
6606 return write(writer);
6607}
6608
6610{
6611 yarp::os::idl::WireReader reader(connection);
6612 return read(reader);
6613}
6614
6616{
6617 if (!writer.isNull()) {
6618 if (!writer.write(return_helper)) {
6619 return false;
6620 }
6621 }
6622 return true;
6623}
6624
6626{
6627 if (reader.noMore()) {
6628 reader.fail();
6629 return false;
6630 }
6631 if (!reader.read(return_helper)) {
6632 reader.fail();
6633 return false;
6634 }
6635 return true;
6636}
6637
6642
6643// load_locations_and_extras_RPC helper class implementation
6645 cmd{locations_collection_file}
6646{
6647}
6648
6650{
6651 return cmd.write(connection);
6652}
6653
6658
6659IMap2DMsgs_load_locations_and_extras_RPC_helper::Command::Command(const std::string& locations_collection_file) :
6660 locations_collection_file{locations_collection_file}
6661{
6662}
6663
6665{
6666 yarp::os::idl::WireWriter writer(connection);
6667 if (!writer.writeListHeader(s_cmd_len)) {
6668 return false;
6669 }
6670 return write(writer);
6671}
6672
6674{
6675 yarp::os::idl::WireReader reader(connection);
6676 if (!reader.readListHeader()) {
6677 reader.fail();
6678 return false;
6679 }
6680 return read(reader);
6681}
6682
6684{
6685 if (!writeTag(writer)) {
6686 return false;
6687 }
6688 if (!writeArgs(writer)) {
6689 return false;
6690 }
6691 return true;
6692}
6693
6695{
6696 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6697 return false;
6698 }
6699 return true;
6700}
6701
6703{
6704 if (!writer.writeString(locations_collection_file)) {
6705 return false;
6706 }
6707 return true;
6708}
6709
6711{
6712 if (!readTag(reader)) {
6713 return false;
6714 }
6715 if (!readArgs(reader)) {
6716 return false;
6717 }
6718 return true;
6719}
6720
6722{
6723 std::string tag = reader.readTag(s_tag_len);
6724 if (reader.isError()) {
6725 return false;
6726 }
6727 if (tag != s_tag) {
6728 reader.fail();
6729 return false;
6730 }
6731 return true;
6732}
6733
6735{
6736 if (reader.noMore()) {
6737 reader.fail();
6738 return false;
6739 }
6740 if (!reader.readString(locations_collection_file)) {
6741 reader.fail();
6742 return false;
6743 }
6744 if (!reader.noMore()) {
6745 reader.fail();
6746 return false;
6747 }
6748 return true;
6749}
6750
6752{
6753 yarp::os::idl::WireWriter writer(connection);
6754 return write(writer);
6755}
6756
6758{
6759 yarp::os::idl::WireReader reader(connection);
6760 return read(reader);
6761}
6762
6764{
6765 if (!writer.isNull()) {
6766 if (!writer.write(return_helper)) {
6767 return false;
6768 }
6769 }
6770 return true;
6771}
6772
6774{
6775 if (reader.noMore()) {
6776 reader.fail();
6777 return false;
6778 }
6779 if (!reader.read(return_helper)) {
6780 reader.fail();
6781 return false;
6782 }
6783 return true;
6784}
6785
6790
6791// save_map_to_disk_RPC helper class implementation
6792IMap2DMsgs_save_map_to_disk_RPC_helper::IMap2DMsgs_save_map_to_disk_RPC_helper(const std::string& map_name, const std::string& file_name) :
6793 cmd{map_name, file_name}
6794{
6795}
6796
6798{
6799 return cmd.write(connection);
6800}
6801
6803{
6804 return reply.read(connection);
6805}
6806
6807IMap2DMsgs_save_map_to_disk_RPC_helper::Command::Command(const std::string& map_name, const std::string& file_name) :
6808 map_name{map_name},
6809 file_name{file_name}
6810{
6811}
6812
6814{
6815 yarp::os::idl::WireWriter writer(connection);
6816 if (!writer.writeListHeader(s_cmd_len)) {
6817 return false;
6818 }
6819 return write(writer);
6820}
6821
6823{
6824 yarp::os::idl::WireReader reader(connection);
6825 if (!reader.readListHeader()) {
6826 reader.fail();
6827 return false;
6828 }
6829 return read(reader);
6830}
6831
6833{
6834 if (!writeTag(writer)) {
6835 return false;
6836 }
6837 if (!writeArgs(writer)) {
6838 return false;
6839 }
6840 return true;
6841}
6842
6844{
6845 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6846 return false;
6847 }
6848 return true;
6849}
6850
6852{
6853 if (!writer.writeString(map_name)) {
6854 return false;
6855 }
6856 if (!writer.writeString(file_name)) {
6857 return false;
6858 }
6859 return true;
6860}
6861
6863{
6864 if (!readTag(reader)) {
6865 return false;
6866 }
6867 if (!readArgs(reader)) {
6868 return false;
6869 }
6870 return true;
6871}
6872
6874{
6875 std::string tag = reader.readTag(s_tag_len);
6876 if (reader.isError()) {
6877 return false;
6878 }
6879 if (tag != s_tag) {
6880 reader.fail();
6881 return false;
6882 }
6883 return true;
6884}
6885
6887{
6888 if (reader.noMore()) {
6889 reader.fail();
6890 return false;
6891 }
6892 if (!reader.readString(map_name)) {
6893 reader.fail();
6894 return false;
6895 }
6896 if (reader.noMore()) {
6897 reader.fail();
6898 return false;
6899 }
6900 if (!reader.readString(file_name)) {
6901 reader.fail();
6902 return false;
6903 }
6904 if (!reader.noMore()) {
6905 reader.fail();
6906 return false;
6907 }
6908 return true;
6909}
6910
6912{
6913 yarp::os::idl::WireWriter writer(connection);
6914 return write(writer);
6915}
6916
6918{
6919 yarp::os::idl::WireReader reader(connection);
6920 return read(reader);
6921}
6922
6924{
6925 if (!writer.isNull()) {
6926 if (!writer.write(return_helper)) {
6927 return false;
6928 }
6929 }
6930 return true;
6931}
6932
6934{
6935 if (reader.noMore()) {
6936 reader.fail();
6937 return false;
6938 }
6939 if (!reader.read(return_helper)) {
6940 reader.fail();
6941 return false;
6942 }
6943 return true;
6944}
6945
6950
6951// load_map_from_disk_RPC helper class implementation
6953 cmd{file_name}
6954{
6955}
6956
6958{
6959 return cmd.write(connection);
6960}
6961
6963{
6964 return reply.read(connection);
6965}
6966
6968 file_name{file_name}
6969{
6970}
6971
6973{
6974 yarp::os::idl::WireWriter writer(connection);
6975 if (!writer.writeListHeader(s_cmd_len)) {
6976 return false;
6977 }
6978 return write(writer);
6979}
6980
6982{
6983 yarp::os::idl::WireReader reader(connection);
6984 if (!reader.readListHeader()) {
6985 reader.fail();
6986 return false;
6987 }
6988 return read(reader);
6989}
6990
6992{
6993 if (!writeTag(writer)) {
6994 return false;
6995 }
6996 if (!writeArgs(writer)) {
6997 return false;
6998 }
6999 return true;
7000}
7001
7003{
7004 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7005 return false;
7006 }
7007 return true;
7008}
7009
7011{
7012 if (!writer.writeString(file_name)) {
7013 return false;
7014 }
7015 return true;
7016}
7017
7019{
7020 if (!readTag(reader)) {
7021 return false;
7022 }
7023 if (!readArgs(reader)) {
7024 return false;
7025 }
7026 return true;
7027}
7028
7030{
7031 std::string tag = reader.readTag(s_tag_len);
7032 if (reader.isError()) {
7033 return false;
7034 }
7035 if (tag != s_tag) {
7036 reader.fail();
7037 return false;
7038 }
7039 return true;
7040}
7041
7043{
7044 if (reader.noMore()) {
7045 reader.fail();
7046 return false;
7047 }
7048 if (!reader.readString(file_name)) {
7049 reader.fail();
7050 return false;
7051 }
7052 if (!reader.noMore()) {
7053 reader.fail();
7054 return false;
7055 }
7056 return true;
7057}
7058
7060{
7061 yarp::os::idl::WireWriter writer(connection);
7062 return write(writer);
7063}
7064
7066{
7067 yarp::os::idl::WireReader reader(connection);
7068 return read(reader);
7069}
7070
7072{
7073 if (!writer.isNull()) {
7074 if (!writer.write(return_helper)) {
7075 return false;
7076 }
7077 }
7078 return true;
7079}
7080
7082{
7083 if (reader.noMore()) {
7084 reader.fail();
7085 return false;
7086 }
7087 if (!reader.read(return_helper)) {
7088 reader.fail();
7089 return false;
7090 }
7091 return true;
7092}
7093
7098
7099// enable_maps_compression_RPC helper class implementation
7101 cmd{enable_compression}
7102{
7103}
7104
7106{
7107 return cmd.write(connection);
7108}
7109
7114
7116 enable_compression{enable_compression}
7117{
7118}
7119
7121{
7122 yarp::os::idl::WireWriter writer(connection);
7123 if (!writer.writeListHeader(s_cmd_len)) {
7124 return false;
7125 }
7126 return write(writer);
7127}
7128
7130{
7131 yarp::os::idl::WireReader reader(connection);
7132 if (!reader.readListHeader()) {
7133 reader.fail();
7134 return false;
7135 }
7136 return read(reader);
7137}
7138
7140{
7141 if (!writeTag(writer)) {
7142 return false;
7143 }
7144 if (!writeArgs(writer)) {
7145 return false;
7146 }
7147 return true;
7148}
7149
7151{
7152 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7153 return false;
7154 }
7155 return true;
7156}
7157
7159{
7160 if (!writer.writeBool(enable_compression)) {
7161 return false;
7162 }
7163 return true;
7164}
7165
7167{
7168 if (!readTag(reader)) {
7169 return false;
7170 }
7171 if (!readArgs(reader)) {
7172 return false;
7173 }
7174 return true;
7175}
7176
7178{
7179 std::string tag = reader.readTag(s_tag_len);
7180 if (reader.isError()) {
7181 return false;
7182 }
7183 if (tag != s_tag) {
7184 reader.fail();
7185 return false;
7186 }
7187 return true;
7188}
7189
7191{
7192 if (reader.noMore()) {
7193 reader.fail();
7194 return false;
7195 }
7196 if (!reader.readBool(enable_compression)) {
7197 reader.fail();
7198 return false;
7199 }
7200 if (!reader.noMore()) {
7201 reader.fail();
7202 return false;
7203 }
7204 return true;
7205}
7206
7208{
7209 yarp::os::idl::WireWriter writer(connection);
7210 return write(writer);
7211}
7212
7214{
7215 yarp::os::idl::WireReader reader(connection);
7216 return read(reader);
7217}
7218
7220{
7221 if (!writer.isNull()) {
7222 if (!writer.write(return_helper)) {
7223 return false;
7224 }
7225 }
7226 return true;
7227}
7228
7230{
7231 if (reader.noMore()) {
7232 reader.fail();
7233 return false;
7234 }
7235 if (!reader.read(return_helper)) {
7236 reader.fail();
7237 return false;
7238 }
7239 return true;
7240}
7241
7246
7247// Constructor
7249{
7250 yarp().setOwner(*this);
7251}
7252
7254{
7255 if (!yarp().canWrite()) {
7256 yError("Missing server method '%s'?", IMap2DMsgs_clear_all_maps_RPC_helper::s_prototype);
7257 }
7259 bool ok = yarp().write(helper, helper);
7260 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
7261}
7262
7264{
7265 if (!yarp().canWrite()) {
7266 yError("Missing server method '%s'?", IMap2DMsgs_store_map_RPC_helper::s_prototype);
7267 }
7268 IMap2DMsgs_store_map_RPC_helper helper{themap};
7269 bool ok = yarp().write(helper, helper);
7270 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
7271}
7272
7273return_get_map IMap2DMsgs::get_map_RPC(const std::string& map_name)
7274{
7275 if (!yarp().canWrite()) {
7276 yError("Missing server method '%s'?", IMap2DMsgs_get_map_RPC_helper::s_prototype);
7277 }
7278 IMap2DMsgs_get_map_RPC_helper helper{map_name};
7279 bool ok = yarp().write(helper, helper);
7280 return ok ? helper.reply.return_helper : return_get_map{};
7281}
7282
7284{
7285 if (!yarp().canWrite()) {
7286 yError("Missing server method '%s'?", IMap2DMsgs_get_map_names_RPC_helper::s_prototype);
7287 }
7289 bool ok = yarp().write(helper, helper);
7290 return ok ? helper.reply.return_helper : return_get_map_names{};
7291}
7292
7294{
7295 if (!yarp().canWrite()) {
7296 yError("Missing server method '%s'?", IMap2DMsgs_remove_map_RPC_helper::s_prototype);
7297 }
7298 IMap2DMsgs_remove_map_RPC_helper helper{map_name};
7299 bool ok = yarp().write(helper, helper);
7300 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
7301}
7302
7304{
7305 if (!yarp().canWrite()) {
7306 yError("Missing server method '%s'?", IMap2DMsgs_store_location_RPC_helper::s_prototype);
7307 }
7308 IMap2DMsgs_store_location_RPC_helper helper{location_name, loc};
7309 bool ok = yarp().write(helper, helper);
7310 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
7311}
7312
7314{
7315 if (!yarp().canWrite()) {
7316 yError("Missing server method '%s'?", IMap2DMsgs_store_area_RPC_helper::s_prototype);
7317 }
7318 IMap2DMsgs_store_area_RPC_helper helper{area_name, area};
7319 bool ok = yarp().write(helper, helper);
7320 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
7321}
7322
7324{
7325 if (!yarp().canWrite()) {
7326 yError("Missing server method '%s'?", IMap2DMsgs_store_path_RPC_helper::s_prototype);
7327 }
7328 IMap2DMsgs_store_path_RPC_helper helper{path_name, path};
7329 bool ok = yarp().write(helper, helper);
7330 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
7331}
7332
7333return_get_location IMap2DMsgs::get_location_RPC(const std::string& location_name)
7334{
7335 if (!yarp().canWrite()) {
7336 yError("Missing server method '%s'?", IMap2DMsgs_get_location_RPC_helper::s_prototype);
7337 }
7338 IMap2DMsgs_get_location_RPC_helper helper{location_name};
7339 bool ok = yarp().write(helper, helper);
7340 return ok ? helper.reply.return_helper : return_get_location{};
7341}
7342
7343return_get_area IMap2DMsgs::get_area_RPC(const std::string& area_name)
7344{
7345 if (!yarp().canWrite()) {
7346 yError("Missing server method '%s'?", IMap2DMsgs_get_area_RPC_helper::s_prototype);
7347 }
7348 IMap2DMsgs_get_area_RPC_helper helper{area_name};
7349 bool ok = yarp().write(helper, helper);
7350 return ok ? helper.reply.return_helper : return_get_area{};
7351}
7352
7353return_get_path IMap2DMsgs::get_path_RPC(const std::string& path_name)
7354{
7355 if (!yarp().canWrite()) {
7356 yError("Missing server method '%s'?", IMap2DMsgs_get_path_RPC_helper::s_prototype);
7357 }
7358 IMap2DMsgs_get_path_RPC_helper helper{path_name};
7359 bool ok = yarp().write(helper, helper);
7360 return ok ? helper.reply.return_helper : return_get_path{};
7361}
7362
7364{
7365 if (!yarp().canWrite()) {
7366 yError("Missing server method '%s'?", IMap2DMsgs_get_locations_list_RPC_helper::s_prototype);
7367 }
7369 bool ok = yarp().write(helper, helper);
7370 return ok ? helper.reply.return_helper : return_get_locations_list{};
7371}
7372
7374{
7375 if (!yarp().canWrite()) {
7376 yError("Missing server method '%s'?", IMap2DMsgs_get_areas_list_RPC_helper::s_prototype);
7377 }
7379 bool ok = yarp().write(helper, helper);
7380 return ok ? helper.reply.return_helper : return_get_areas_list{};
7381}
7382
7384{
7385 if (!yarp().canWrite()) {
7386 yError("Missing server method '%s'?", IMap2DMsgs_get_paths_list_RPC_helper::s_prototype);
7387 }
7389 bool ok = yarp().write(helper, helper);
7390 return ok ? helper.reply.return_helper : return_get_paths_list{};
7391}
7392
7394{
7395 if (!yarp().canWrite()) {
7396 yError("Missing server method '%s'?", IMap2DMsgs_get_all_locations_RPC_helper::s_prototype);
7397 }
7399 bool ok = yarp().write(helper, helper);
7400 return ok ? helper.reply.return_helper : return_get_all_locations{};
7401}
7402
7404{
7405 if (!yarp().canWrite()) {
7406 yError("Missing server method '%s'?", IMap2DMsgs_get_all_areas_RPC_helper::s_prototype);
7407 }
7409 bool ok = yarp().write(helper, helper);
7410 return ok ? helper.reply.return_helper : return_get_all_areas{};
7411}
7412
7414{
7415 if (!yarp().canWrite()) {
7416 yError("Missing server method '%s'?", IMap2DMsgs_get_all_paths_RPC_helper::s_prototype);
7417 }
7419 bool ok = yarp().write(helper, helper);
7420 return ok ? helper.reply.return_helper : return_get_all_paths{};
7421}
7422
7423yarp::dev::ReturnValue IMap2DMsgs::rename_location_RPC(const std::string& original_name, const std::string& new_name)
7424{
7425 if (!yarp().canWrite()) {
7426 yError("Missing server method '%s'?", IMap2DMsgs_rename_location_RPC_helper::s_prototype);
7427 }
7428 IMap2DMsgs_rename_location_RPC_helper helper{original_name, new_name};
7429 bool ok = yarp().write(helper, helper);
7430 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
7431}
7432
7434{
7435 if (!yarp().canWrite()) {
7436 yError("Missing server method '%s'?", IMap2DMsgs_delete_location_RPC_helper::s_prototype);
7437 }
7438 IMap2DMsgs_delete_location_RPC_helper helper{location_name};
7439 bool ok = yarp().write(helper, helper);
7440 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
7441}
7442
7444{
7445 if (!yarp().canWrite()) {
7446 yError("Missing server method '%s'?", IMap2DMsgs_delete_path_RPC_helper::s_prototype);
7447 }
7448 IMap2DMsgs_delete_path_RPC_helper helper{path_name};
7449 bool ok = yarp().write(helper, helper);
7450 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
7451}
7452
7453yarp::dev::ReturnValue IMap2DMsgs::rename_area_RPC(const std::string& original_name, const std::string& new_name)
7454{
7455 if (!yarp().canWrite()) {
7456 yError("Missing server method '%s'?", IMap2DMsgs_rename_area_RPC_helper::s_prototype);
7457 }
7458 IMap2DMsgs_rename_area_RPC_helper helper{original_name, new_name};
7459 bool ok = yarp().write(helper, helper);
7460 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
7461}
7462
7463yarp::dev::ReturnValue IMap2DMsgs::rename_path_RPC(const std::string& original_name, const std::string& new_name)
7464{
7465 if (!yarp().canWrite()) {
7466 yError("Missing server method '%s'?", IMap2DMsgs_rename_path_RPC_helper::s_prototype);
7467 }
7468 IMap2DMsgs_rename_path_RPC_helper helper{original_name, new_name};
7469 bool ok = yarp().write(helper, helper);
7470 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
7471}
7472
7474{
7475 if (!yarp().canWrite()) {
7476 yError("Missing server method '%s'?", IMap2DMsgs_delete_area_RPC_helper::s_prototype);
7477 }
7478 IMap2DMsgs_delete_area_RPC_helper helper{area_name};
7479 bool ok = yarp().write(helper, helper);
7480 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
7481}
7482
7484{
7485 if (!yarp().canWrite()) {
7486 yError("Missing server method '%s'?", IMap2DMsgs_clear_all_locations_RPC_helper::s_prototype);
7487 }
7489 bool ok = yarp().write(helper, helper);
7490 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
7491}
7492
7494{
7495 if (!yarp().canWrite()) {
7496 yError("Missing server method '%s'?", IMap2DMsgs_clear_all_areas_RPC_helper::s_prototype);
7497 }
7499 bool ok = yarp().write(helper, helper);
7500 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
7501}
7502
7504{
7505 if (!yarp().canWrite()) {
7506 yError("Missing server method '%s'?", IMap2DMsgs_clear_all_paths_RPC_helper::s_prototype);
7507 }
7509 bool ok = yarp().write(helper, helper);
7510 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
7511}
7512
7514{
7515 if (!yarp().canWrite()) {
7517 }
7519 bool ok = yarp().write(helper, helper);
7520 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
7521}
7522
7524{
7525 if (!yarp().canWrite()) {
7527 }
7529 bool ok = yarp().write(helper, helper);
7530 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
7531}
7532
7533yarp::dev::ReturnValue IMap2DMsgs::save_maps_collection_RPC(const std::string& maps_collection_file)
7534{
7535 if (!yarp().canWrite()) {
7537 }
7538 IMap2DMsgs_save_maps_collection_RPC_helper helper{maps_collection_file};
7539 bool ok = yarp().write(helper, helper);
7540 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
7541}
7542
7543yarp::dev::ReturnValue IMap2DMsgs::load_maps_collection_RPC(const std::string& maps_collection_file)
7544{
7545 if (!yarp().canWrite()) {
7547 }
7548 IMap2DMsgs_load_maps_collection_RPC_helper helper{maps_collection_file};
7549 bool ok = yarp().write(helper, helper);
7550 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
7551}
7552
7553yarp::dev::ReturnValue IMap2DMsgs::save_locations_and_extras_RPC(const std::string& locations_collection_file)
7554{
7555 if (!yarp().canWrite()) {
7557 }
7558 IMap2DMsgs_save_locations_and_extras_RPC_helper helper{locations_collection_file};
7559 bool ok = yarp().write(helper, helper);
7560 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
7561}
7562
7563yarp::dev::ReturnValue IMap2DMsgs::load_locations_and_extras_RPC(const std::string& locations_collection_file)
7564{
7565 if (!yarp().canWrite()) {
7567 }
7568 IMap2DMsgs_load_locations_and_extras_RPC_helper helper{locations_collection_file};
7569 bool ok = yarp().write(helper, helper);
7570 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
7571}
7572
7573yarp::dev::ReturnValue IMap2DMsgs::save_map_to_disk_RPC(const std::string& map_name, const std::string& file_name)
7574{
7575 if (!yarp().canWrite()) {
7576 yError("Missing server method '%s'?", IMap2DMsgs_save_map_to_disk_RPC_helper::s_prototype);
7577 }
7578 IMap2DMsgs_save_map_to_disk_RPC_helper helper{map_name, file_name};
7579 bool ok = yarp().write(helper, helper);
7580 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
7581}
7582
7584{
7585 if (!yarp().canWrite()) {
7586 yError("Missing server method '%s'?", IMap2DMsgs_load_map_from_disk_RPC_helper::s_prototype);
7587 }
7589 bool ok = yarp().write(helper, helper);
7590 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
7591}
7592
7594{
7595 if (!yarp().canWrite()) {
7597 }
7598 IMap2DMsgs_enable_maps_compression_RPC_helper helper{enable_compression};
7599 bool ok = yarp().write(helper, helper);
7600 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
7601}
7602
7603// help method
7604std::vector<std::string> IMap2DMsgs::help(const std::string& functionName)
7605{
7606 bool showAll = (functionName == "--all");
7607 std::vector<std::string> helpString;
7608 if (showAll) {
7609 helpString.emplace_back("*** Available commands:");
7610 helpString.emplace_back(IMap2DMsgs_clear_all_maps_RPC_helper::s_tag);
7611 helpString.emplace_back(IMap2DMsgs_store_map_RPC_helper::s_tag);
7612 helpString.emplace_back(IMap2DMsgs_get_map_RPC_helper::s_tag);
7613 helpString.emplace_back(IMap2DMsgs_get_map_names_RPC_helper::s_tag);
7614 helpString.emplace_back(IMap2DMsgs_remove_map_RPC_helper::s_tag);
7615 helpString.emplace_back(IMap2DMsgs_store_location_RPC_helper::s_tag);
7616 helpString.emplace_back(IMap2DMsgs_store_area_RPC_helper::s_tag);
7617 helpString.emplace_back(IMap2DMsgs_store_path_RPC_helper::s_tag);
7618 helpString.emplace_back(IMap2DMsgs_get_location_RPC_helper::s_tag);
7619 helpString.emplace_back(IMap2DMsgs_get_area_RPC_helper::s_tag);
7620 helpString.emplace_back(IMap2DMsgs_get_path_RPC_helper::s_tag);
7621 helpString.emplace_back(IMap2DMsgs_get_locations_list_RPC_helper::s_tag);
7622 helpString.emplace_back(IMap2DMsgs_get_areas_list_RPC_helper::s_tag);
7623 helpString.emplace_back(IMap2DMsgs_get_paths_list_RPC_helper::s_tag);
7624 helpString.emplace_back(IMap2DMsgs_get_all_locations_RPC_helper::s_tag);
7625 helpString.emplace_back(IMap2DMsgs_get_all_areas_RPC_helper::s_tag);
7626 helpString.emplace_back(IMap2DMsgs_get_all_paths_RPC_helper::s_tag);
7627 helpString.emplace_back(IMap2DMsgs_rename_location_RPC_helper::s_tag);
7628 helpString.emplace_back(IMap2DMsgs_delete_location_RPC_helper::s_tag);
7629 helpString.emplace_back(IMap2DMsgs_delete_path_RPC_helper::s_tag);
7630 helpString.emplace_back(IMap2DMsgs_rename_area_RPC_helper::s_tag);
7631 helpString.emplace_back(IMap2DMsgs_rename_path_RPC_helper::s_tag);
7632 helpString.emplace_back(IMap2DMsgs_delete_area_RPC_helper::s_tag);
7633 helpString.emplace_back(IMap2DMsgs_clear_all_locations_RPC_helper::s_tag);
7634 helpString.emplace_back(IMap2DMsgs_clear_all_areas_RPC_helper::s_tag);
7635 helpString.emplace_back(IMap2DMsgs_clear_all_paths_RPC_helper::s_tag);
7642 helpString.emplace_back(IMap2DMsgs_save_map_to_disk_RPC_helper::s_tag);
7643 helpString.emplace_back(IMap2DMsgs_load_map_from_disk_RPC_helper::s_tag);
7645 helpString.emplace_back("help");
7646 } else {
7647 if (functionName == IMap2DMsgs_clear_all_maps_RPC_helper::s_tag) {
7649 }
7650 if (functionName == IMap2DMsgs_store_map_RPC_helper::s_tag) {
7651 helpString.emplace_back(IMap2DMsgs_store_map_RPC_helper::s_prototype);
7652 }
7653 if (functionName == IMap2DMsgs_get_map_RPC_helper::s_tag) {
7654 helpString.emplace_back(IMap2DMsgs_get_map_RPC_helper::s_prototype);
7655 }
7656 if (functionName == IMap2DMsgs_get_map_names_RPC_helper::s_tag) {
7657 helpString.emplace_back(IMap2DMsgs_get_map_names_RPC_helper::s_prototype);
7658 }
7659 if (functionName == IMap2DMsgs_remove_map_RPC_helper::s_tag) {
7660 helpString.emplace_back(IMap2DMsgs_remove_map_RPC_helper::s_prototype);
7661 }
7662 if (functionName == IMap2DMsgs_store_location_RPC_helper::s_tag) {
7664 }
7665 if (functionName == IMap2DMsgs_store_area_RPC_helper::s_tag) {
7666 helpString.emplace_back(IMap2DMsgs_store_area_RPC_helper::s_prototype);
7667 }
7668 if (functionName == IMap2DMsgs_store_path_RPC_helper::s_tag) {
7669 helpString.emplace_back(IMap2DMsgs_store_path_RPC_helper::s_prototype);
7670 }
7671 if (functionName == IMap2DMsgs_get_location_RPC_helper::s_tag) {
7672 helpString.emplace_back(IMap2DMsgs_get_location_RPC_helper::s_prototype);
7673 }
7674 if (functionName == IMap2DMsgs_get_area_RPC_helper::s_tag) {
7675 helpString.emplace_back(IMap2DMsgs_get_area_RPC_helper::s_prototype);
7676 }
7677 if (functionName == IMap2DMsgs_get_path_RPC_helper::s_tag) {
7678 helpString.emplace_back(IMap2DMsgs_get_path_RPC_helper::s_prototype);
7679 }
7682 }
7683 if (functionName == IMap2DMsgs_get_areas_list_RPC_helper::s_tag) {
7685 }
7686 if (functionName == IMap2DMsgs_get_paths_list_RPC_helper::s_tag) {
7688 }
7691 }
7692 if (functionName == IMap2DMsgs_get_all_areas_RPC_helper::s_tag) {
7693 helpString.emplace_back(IMap2DMsgs_get_all_areas_RPC_helper::s_prototype);
7694 }
7695 if (functionName == IMap2DMsgs_get_all_paths_RPC_helper::s_tag) {
7696 helpString.emplace_back(IMap2DMsgs_get_all_paths_RPC_helper::s_prototype);
7697 }
7700 }
7703 }
7704 if (functionName == IMap2DMsgs_delete_path_RPC_helper::s_tag) {
7705 helpString.emplace_back(IMap2DMsgs_delete_path_RPC_helper::s_prototype);
7706 }
7707 if (functionName == IMap2DMsgs_rename_area_RPC_helper::s_tag) {
7708 helpString.emplace_back(IMap2DMsgs_rename_area_RPC_helper::s_prototype);
7709 }
7710 if (functionName == IMap2DMsgs_rename_path_RPC_helper::s_tag) {
7711 helpString.emplace_back(IMap2DMsgs_rename_path_RPC_helper::s_prototype);
7712 }
7713 if (functionName == IMap2DMsgs_delete_area_RPC_helper::s_tag) {
7714 helpString.emplace_back(IMap2DMsgs_delete_area_RPC_helper::s_prototype);
7715 }
7718 }
7721 }
7724 }
7727 }
7730 }
7733 }
7736 }
7739 }
7742 }
7745 }
7748 }
7751 }
7752 if (functionName == "help") {
7753 helpString.emplace_back("std::vector<std::string> help(const std::string& functionName = \"--all\")");
7754 helpString.emplace_back("Return list of available commands, or help message for a specific function");
7755 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");
7756 helpString.emplace_back("@return list of strings (one string per line)");
7757 }
7758 }
7759 if (helpString.empty()) {
7760 helpString.emplace_back("Command not found");
7761 }
7762 return helpString;
7763}
7764
7765// read from ConnectionReader
7767{
7768 constexpr size_t max_tag_len = 6;
7769 size_t tag_len = 1;
7770
7771 yarp::os::idl::WireReader reader(connection);
7772 reader.expectAccept();
7773 if (!reader.readListHeader()) {
7774 reader.fail();
7775 return false;
7776 }
7777
7778 std::string tag = reader.readTag(1);
7779 bool direct = (tag == "__direct__");
7780 if (direct) {
7781 tag = reader.readTag(1);
7782 }
7783 while (tag_len <= max_tag_len && !reader.isError()) {
7786 if (!helper.cmd.readArgs(reader)) {
7787 return false;
7788 }
7789
7790 helper.call(this);
7791
7792 yarp::os::idl::WireWriter writer(reader);
7793 if (!helper.reply.write(writer)) {
7794 return false;
7795 }
7796 reader.accept();
7797 return true;
7798 }
7801 if (!helper.cmd.readArgs(reader)) {
7802 return false;
7803 }
7804
7805 helper.call(this);
7806
7807 yarp::os::idl::WireWriter writer(reader);
7808 if (!helper.reply.write(writer)) {
7809 return false;
7810 }
7811 reader.accept();
7812 return true;
7813 }
7816 if (!helper.cmd.readArgs(reader)) {
7817 return false;
7818 }
7819
7820 helper.call(this);
7821
7822 yarp::os::idl::WireWriter writer(reader);
7823 if (!helper.reply.write(writer)) {
7824 return false;
7825 }
7826 reader.accept();
7827 return true;
7828 }
7831 if (!helper.cmd.readArgs(reader)) {
7832 return false;
7833 }
7834
7835 helper.call(this);
7836
7837 yarp::os::idl::WireWriter writer(reader);
7838 if (!helper.reply.write(writer)) {
7839 return false;
7840 }
7841 reader.accept();
7842 return true;
7843 }
7846 if (!helper.cmd.readArgs(reader)) {
7847 return false;
7848 }
7849
7850 helper.call(this);
7851
7852 yarp::os::idl::WireWriter writer(reader);
7853 if (!helper.reply.write(writer)) {
7854 return false;
7855 }
7856 reader.accept();
7857 return true;
7858 }
7861 if (!helper.cmd.readArgs(reader)) {
7862 return false;
7863 }
7864
7865 helper.call(this);
7866
7867 yarp::os::idl::WireWriter writer(reader);
7868 if (!helper.reply.write(writer)) {
7869 return false;
7870 }
7871 reader.accept();
7872 return true;
7873 }
7876 if (!helper.cmd.readArgs(reader)) {
7877 return false;
7878 }
7879
7880 helper.call(this);
7881
7882 yarp::os::idl::WireWriter writer(reader);
7883 if (!helper.reply.write(writer)) {
7884 return false;
7885 }
7886 reader.accept();
7887 return true;
7888 }
7891 if (!helper.cmd.readArgs(reader)) {
7892 return false;
7893 }
7894
7895 helper.call(this);
7896
7897 yarp::os::idl::WireWriter writer(reader);
7898 if (!helper.reply.write(writer)) {
7899 return false;
7900 }
7901 reader.accept();
7902 return true;
7903 }
7906 if (!helper.cmd.readArgs(reader)) {
7907 return false;
7908 }
7909
7910 helper.call(this);
7911
7912 yarp::os::idl::WireWriter writer(reader);
7913 if (!helper.reply.write(writer)) {
7914 return false;
7915 }
7916 reader.accept();
7917 return true;
7918 }
7921 if (!helper.cmd.readArgs(reader)) {
7922 return false;
7923 }
7924
7925 helper.call(this);
7926
7927 yarp::os::idl::WireWriter writer(reader);
7928 if (!helper.reply.write(writer)) {
7929 return false;
7930 }
7931 reader.accept();
7932 return true;
7933 }
7936 if (!helper.cmd.readArgs(reader)) {
7937 return false;
7938 }
7939
7940 helper.call(this);
7941
7942 yarp::os::idl::WireWriter writer(reader);
7943 if (!helper.reply.write(writer)) {
7944 return false;
7945 }
7946 reader.accept();
7947 return true;
7948 }
7951 if (!helper.cmd.readArgs(reader)) {
7952 return false;
7953 }
7954
7955 helper.call(this);
7956
7957 yarp::os::idl::WireWriter writer(reader);
7958 if (!helper.reply.write(writer)) {
7959 return false;
7960 }
7961 reader.accept();
7962 return true;
7963 }
7966 if (!helper.cmd.readArgs(reader)) {
7967 return false;
7968 }
7969
7970 helper.call(this);
7971
7972 yarp::os::idl::WireWriter writer(reader);
7973 if (!helper.reply.write(writer)) {
7974 return false;
7975 }
7976 reader.accept();
7977 return true;
7978 }
7981 if (!helper.cmd.readArgs(reader)) {
7982 return false;
7983 }
7984
7985 helper.call(this);
7986
7987 yarp::os::idl::WireWriter writer(reader);
7988 if (!helper.reply.write(writer)) {
7989 return false;
7990 }
7991 reader.accept();
7992 return true;
7993 }
7996 if (!helper.cmd.readArgs(reader)) {
7997 return false;
7998 }
7999
8000 helper.call(this);
8001
8002 yarp::os::idl::WireWriter writer(reader);
8003 if (!helper.reply.write(writer)) {
8004 return false;
8005 }
8006 reader.accept();
8007 return true;
8008 }
8011 if (!helper.cmd.readArgs(reader)) {
8012 return false;
8013 }
8014
8015 helper.call(this);
8016
8017 yarp::os::idl::WireWriter writer(reader);
8018 if (!helper.reply.write(writer)) {
8019 return false;
8020 }
8021 reader.accept();
8022 return true;
8023 }
8026 if (!helper.cmd.readArgs(reader)) {
8027 return false;
8028 }
8029
8030 helper.call(this);
8031
8032 yarp::os::idl::WireWriter writer(reader);
8033 if (!helper.reply.write(writer)) {
8034 return false;
8035 }
8036 reader.accept();
8037 return true;
8038 }
8041 if (!helper.cmd.readArgs(reader)) {
8042 return false;
8043 }
8044
8045 helper.call(this);
8046
8047 yarp::os::idl::WireWriter writer(reader);
8048 if (!helper.reply.write(writer)) {
8049 return false;
8050 }
8051 reader.accept();
8052 return true;
8053 }
8056 if (!helper.cmd.readArgs(reader)) {
8057 return false;
8058 }
8059
8060 helper.call(this);
8061
8062 yarp::os::idl::WireWriter writer(reader);
8063 if (!helper.reply.write(writer)) {
8064 return false;
8065 }
8066 reader.accept();
8067 return true;
8068 }
8071 if (!helper.cmd.readArgs(reader)) {
8072 return false;
8073 }
8074
8075 helper.call(this);
8076
8077 yarp::os::idl::WireWriter writer(reader);
8078 if (!helper.reply.write(writer)) {
8079 return false;
8080 }
8081 reader.accept();
8082 return true;
8083 }
8086 if (!helper.cmd.readArgs(reader)) {
8087 return false;
8088 }
8089
8090 helper.call(this);
8091
8092 yarp::os::idl::WireWriter writer(reader);
8093 if (!helper.reply.write(writer)) {
8094 return false;
8095 }
8096 reader.accept();
8097 return true;
8098 }
8101 if (!helper.cmd.readArgs(reader)) {
8102 return false;
8103 }
8104
8105 helper.call(this);
8106
8107 yarp::os::idl::WireWriter writer(reader);
8108 if (!helper.reply.write(writer)) {
8109 return false;
8110 }
8111 reader.accept();
8112 return true;
8113 }
8116 if (!helper.cmd.readArgs(reader)) {
8117 return false;
8118 }
8119
8120 helper.call(this);
8121
8122 yarp::os::idl::WireWriter writer(reader);
8123 if (!helper.reply.write(writer)) {
8124 return false;
8125 }
8126 reader.accept();
8127 return true;
8128 }
8131 if (!helper.cmd.readArgs(reader)) {
8132 return false;
8133 }
8134
8135 helper.call(this);
8136
8137 yarp::os::idl::WireWriter writer(reader);
8138 if (!helper.reply.write(writer)) {
8139 return false;
8140 }
8141 reader.accept();
8142 return true;
8143 }
8146 if (!helper.cmd.readArgs(reader)) {
8147 return false;
8148 }
8149
8150 helper.call(this);
8151
8152 yarp::os::idl::WireWriter writer(reader);
8153 if (!helper.reply.write(writer)) {
8154 return false;
8155 }
8156 reader.accept();
8157 return true;
8158 }
8161 if (!helper.cmd.readArgs(reader)) {
8162 return false;
8163 }
8164
8165 helper.call(this);
8166
8167 yarp::os::idl::WireWriter writer(reader);
8168 if (!helper.reply.write(writer)) {
8169 return false;
8170 }
8171 reader.accept();
8172 return true;
8173 }
8176 if (!helper.cmd.readArgs(reader)) {
8177 return false;
8178 }
8179
8180 helper.call(this);
8181
8182 yarp::os::idl::WireWriter writer(reader);
8183 if (!helper.reply.write(writer)) {
8184 return false;
8185 }
8186 reader.accept();
8187 return true;
8188 }
8191 if (!helper.cmd.readArgs(reader)) {
8192 return false;
8193 }
8194
8195 helper.call(this);
8196
8197 yarp::os::idl::WireWriter writer(reader);
8198 if (!helper.reply.write(writer)) {
8199 return false;
8200 }
8201 reader.accept();
8202 return true;
8203 }
8206 if (!helper.cmd.readArgs(reader)) {
8207 return false;
8208 }
8209
8210 helper.call(this);
8211
8212 yarp::os::idl::WireWriter writer(reader);
8213 if (!helper.reply.write(writer)) {
8214 return false;
8215 }
8216 reader.accept();
8217 return true;
8218 }
8221 if (!helper.cmd.readArgs(reader)) {
8222 return false;
8223 }
8224
8225 helper.call(this);
8226
8227 yarp::os::idl::WireWriter writer(reader);
8228 if (!helper.reply.write(writer)) {
8229 return false;
8230 }
8231 reader.accept();
8232 return true;
8233 }
8236 if (!helper.cmd.readArgs(reader)) {
8237 return false;
8238 }
8239
8240 helper.call(this);
8241
8242 yarp::os::idl::WireWriter writer(reader);
8243 if (!helper.reply.write(writer)) {
8244 return false;
8245 }
8246 reader.accept();
8247 return true;
8248 }
8251 if (!helper.cmd.readArgs(reader)) {
8252 return false;
8253 }
8254
8255 helper.call(this);
8256
8257 yarp::os::idl::WireWriter writer(reader);
8258 if (!helper.reply.write(writer)) {
8259 return false;
8260 }
8261 reader.accept();
8262 return true;
8263 }
8266 if (!helper.cmd.readArgs(reader)) {
8267 return false;
8268 }
8269
8270 helper.call(this);
8271
8272 yarp::os::idl::WireWriter writer(reader);
8273 if (!helper.reply.write(writer)) {
8274 return false;
8275 }
8276 reader.accept();
8277 return true;
8278 }
8281 if (!helper.cmd.readArgs(reader)) {
8282 return false;
8283 }
8284
8285 helper.call(this);
8286
8287 yarp::os::idl::WireWriter writer(reader);
8288 if (!helper.reply.write(writer)) {
8289 return false;
8290 }
8291 reader.accept();
8292 return true;
8293 }
8296 if (!helper.cmd.readArgs(reader)) {
8297 return false;
8298 }
8299
8300 helper.call(this);
8301
8302 yarp::os::idl::WireWriter writer(reader);
8303 if (!helper.reply.write(writer)) {
8304 return false;
8305 }
8306 reader.accept();
8307 return true;
8308 }
8309 if (tag == "help") {
8310 std::string functionName;
8311 if (!reader.readString(functionName)) {
8312 functionName = "--all";
8313 }
8314 auto help_strings = help(functionName);
8315 yarp::os::idl::WireWriter writer(reader);
8316 if (!writer.isNull()) {
8317 if (!writer.writeListHeader(2)) {
8318 return false;
8319 }
8320 if (!writer.writeTag("many", 1, 0)) {
8321 return false;
8322 }
8323 if (!writer.writeListBegin(0, help_strings.size())) {
8324 return false;
8325 }
8326 for (const auto& help_string : help_strings) {
8327 if (!writer.writeString(help_string)) {
8328 return false;
8329 }
8330 }
8331 if (!writer.writeListEnd()) {
8332 return false;
8333 }
8334 }
8335 reader.accept();
8336 return true;
8337 }
8338 if (reader.noMore()) {
8339 reader.fail();
8340 return false;
8341 }
8342 std::string next_tag = reader.readTag(1);
8343 if (next_tag.empty()) {
8344 break;
8345 }
8346 tag.append("_").append(next_tag);
8347 tag_len = std::count(tag.begin(), tag.end(), '_') + 1;
8348 }
8349 return false;
8350}
#define yError(...)
Definition Log.h:361
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool readTag(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool readArgs(yarp::os::idl::WireReader &reader)
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_tag
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
yarp::dev::ReturnValue(*)() funcptr_t
static constexpr size_t s_reply_len
static constexpr const char * s_prototype
static constexpr const char * s_help
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 readArgs(yarp::os::idl::WireReader &reader)
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool readTag(yarp::os::idl::WireReader &reader)
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
yarp::dev::ReturnValue(*)() funcptr_t
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_help
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_tag
static constexpr const char * s_prototype
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool readTag(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool readArgs(yarp::os::idl::WireReader &reader)
bool 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.
static constexpr const char * s_prototype
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr size_t s_cmd_len
static constexpr size_t s_reply_len
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
yarp::dev::ReturnValue(*)() funcptr_t
static constexpr const char * s_help
static constexpr size_t s_tag_len
static constexpr const char * s_tag
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool readTag(yarp::os::idl::WireReader &reader)
bool readArgs(yarp::os::idl::WireReader &reader)
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_prototype
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_help
yarp::dev::ReturnValue(*)() funcptr_t
static constexpr const char * s_tag
static constexpr size_t s_reply_len
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool readTag(yarp::os::idl::WireReader &reader)
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool readArgs(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool 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 std::string &) 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 write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool readArgs(yarp::os::idl::WireReader &reader)
bool readTag(yarp::os::idl::WireReader &reader)
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.
static constexpr size_t s_cmd_len
yarp::dev::ReturnValue(*)(const std::string &) funcptr_t
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_tag
static constexpr const char * s_prototype
static constexpr size_t s_reply_len
static constexpr const char * s_help
static constexpr size_t s_tag_len
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 readArgs(yarp::os::idl::WireReader &reader)
bool readTag(yarp::os::idl::WireReader &reader)
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool 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.
static constexpr const char * s_help
static constexpr size_t s_reply_len
static constexpr const char * s_prototype
yarp::dev::ReturnValue(*)(const std::string &) funcptr_t
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_tag
bool readTag(yarp::os::idl::WireReader &reader)
bool readArgs(yarp::os::idl::WireReader &reader)
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool 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.
static constexpr size_t s_cmd_len
static constexpr const char * s_prototype
static constexpr const char * s_tag
static constexpr size_t s_reply_len
static constexpr const char * s_help
yarp::dev::ReturnValue(*)(const std::string &) 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.
static constexpr size_t s_tag_len
bool readArgs(yarp::os::idl::WireReader &reader)
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool readTag(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_prototype
yarp::dev::ReturnValue(*)(const bool) 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 readArgs(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool readTag(yarp::os::idl::WireReader &reader)
bool 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.
static constexpr const char * s_tag
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_prototype
static constexpr size_t s_tag_len
static constexpr size_t s_reply_len
static constexpr const char * s_help
return_get_all_areas(*)() funcptr_t
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr size_t s_cmd_len
bool readArgs(yarp::os::idl::WireReader &reader)
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool readTag(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
return_get_all_locations(*)() funcptr_t
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_prototype
static constexpr const char * s_help
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_tag
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool readTag(yarp::os::idl::WireReader &reader)
bool readArgs(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_tag
static constexpr size_t s_tag_len
static constexpr size_t s_cmd_len
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
return_get_all_paths(*)() funcptr_t
static constexpr const char * s_prototype
static constexpr const char * s_help
static constexpr size_t s_reply_len
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 readTag(yarp::os::idl::WireReader &reader)
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool readArgs(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_prototype
static constexpr const char * s_tag
static constexpr size_t s_reply_len
return_get_area(*)(const std::string &) funcptr_t
static constexpr size_t s_tag_len
static constexpr size_t s_cmd_len
void call(IMap2DMsgs *ptr)
static constexpr const char * s_help
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 readArgs(yarp::os::idl::WireReader &reader)
bool readTag(yarp::os::idl::WireReader &reader)
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.
static constexpr const char * s_help
static constexpr size_t s_cmd_len
static constexpr const char * s_prototype
return_get_areas_list(*)() funcptr_t
static constexpr const char * s_tag
static constexpr size_t s_reply_len
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr size_t s_tag_len
bool readTag(yarp::os::idl::WireReader &reader)
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool readArgs(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr size_t s_reply_len
static constexpr const char * s_prototype
static constexpr size_t s_tag_len
static constexpr size_t s_cmd_len
return_get_location(*)(const std::string &) funcptr_t
static constexpr const char * s_help
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_tag
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool readTag(yarp::os::idl::WireReader &reader)
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool readArgs(yarp::os::idl::WireReader &reader)
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_prototype
static constexpr const char * s_tag
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_locations_list(*)() funcptr_t
static constexpr const char * s_help
bool readTag(yarp::os::idl::WireReader &reader)
bool readArgs(yarp::os::idl::WireReader &reader)
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool 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.
static constexpr const char * s_help
static constexpr size_t s_cmd_len
static constexpr const char * s_tag
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_prototype
static constexpr size_t s_tag_len
return_get_map(*)(const std::string &) funcptr_t
void call(IMap2DMsgs *ptr)
static constexpr size_t s_reply_len
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool readArgs(yarp::os::idl::WireReader &reader)
bool readTag(yarp::os::idl::WireReader &reader)
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr size_t s_reply_len
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr size_t s_cmd_len
static constexpr const char * s_help
return_get_map_names(*)() funcptr_t
static constexpr size_t s_tag_len
static constexpr const char * s_prototype
static constexpr const char * s_tag
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
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 readArgs(yarp::os::idl::WireReader &reader)
bool readTag(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
void call(IMap2DMsgs *ptr)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_tag
return_get_path(*)(const std::string &) funcptr_t
static constexpr size_t s_reply_len
static constexpr const char * s_help
static constexpr size_t s_tag_len
static constexpr size_t s_cmd_len
static constexpr const char * s_prototype
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool readTag(yarp::os::idl::WireReader &reader)
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool readArgs(yarp::os::idl::WireReader &reader)
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_help
static constexpr const char * s_prototype
return_get_paths_list(*)() funcptr_t
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr size_t s_cmd_len
static constexpr const char * s_tag
static constexpr size_t s_reply_len
static constexpr size_t s_tag_len
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 readArgs(yarp::os::idl::WireReader &reader)
bool readTag(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
yarp::dev::ReturnValue(*)(const std::string &) funcptr_t
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool readTag(yarp::os::idl::WireReader &reader)
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool readArgs(yarp::os::idl::WireReader &reader)
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
yarp::dev::ReturnValue(*)(const std::string &) funcptr_t
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_help
static constexpr const char * s_prototype
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_tag
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool readArgs(yarp::os::idl::WireReader &reader)
bool readTag(yarp::os::idl::WireReader &reader)
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_help
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_prototype
static constexpr const char * s_tag
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
yarp::dev::ReturnValue(*)(const std::string &) funcptr_t
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool readTag(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool readArgs(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_tag
static constexpr size_t s_cmd_len
static constexpr size_t s_reply_len
static constexpr const char * s_help
static constexpr const char * s_prototype
static constexpr size_t s_tag_len
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
yarp::dev::ReturnValue(*)(const std::string &) funcptr_t
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool readArgs(yarp::os::idl::WireReader &reader)
bool readTag(yarp::os::idl::WireReader &reader)
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.
static constexpr size_t s_tag_len
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_tag
static constexpr const char * s_prototype
yarp::dev::ReturnValue(*)(const std::string &, const std::string &) funcptr_t
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr size_t s_cmd_len
static constexpr size_t s_reply_len
static constexpr const char * s_help
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool readArgs(yarp::os::idl::WireReader &reader)
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool readTag(yarp::os::idl::WireReader &reader)
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_prototype
static constexpr const char * s_tag
static constexpr size_t s_reply_len
static constexpr const char * s_help
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
yarp::dev::ReturnValue(*)(const std::string &, const std::string &) funcptr_t
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool readArgs(yarp::os::idl::WireReader &reader)
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool 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 readTag(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_help
static constexpr size_t s_tag_len
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr size_t s_reply_len
static constexpr size_t s_cmd_len
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_tag
yarp::dev::ReturnValue(*)(const std::string &, const std::string &) funcptr_t
static constexpr const char * s_prototype
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 readTag(yarp::os::idl::WireReader &reader)
bool readArgs(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
yarp::dev::ReturnValue(*)(const std::string &) 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 readTag(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool readArgs(yarp::os::idl::WireReader &reader)
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_help
yarp::dev::ReturnValue(*)(const std::string &, const std::string &) funcptr_t
static constexpr const char * s_prototype
static constexpr const char * s_tag
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool readArgs(yarp::os::idl::WireReader &reader)
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool readTag(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_prototype
static constexpr const char * s_tag
static constexpr const char * s_help
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 std::string &) funcptr_t
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool readTag(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool readArgs(yarp::os::idl::WireReader &reader)
bool 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.
static constexpr const char * s_tag
static constexpr size_t s_reply_len
static constexpr size_t s_tag_len
yarp::dev::ReturnValue(*)(const std::string &, const yarp::dev::Nav2D::Map2DArea &) funcptr_t
static constexpr const char * s_prototype
static constexpr size_t s_cmd_len
static constexpr const char * s_help
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 readArgs(yarp::os::idl::WireReader &reader)
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
yarp::dev::Nav2D::Map2DLocation loc
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool readTag(yarp::os::idl::WireReader &reader)
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr size_t s_reply_len
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_tag
yarp::dev::ReturnValue(*)(const std::string &, const yarp::dev::Nav2D::Map2DLocation &) funcptr_t
static constexpr size_t s_tag_len
static constexpr const char * s_prototype
static constexpr const char * s_help
static constexpr size_t s_cmd_len
bool readArgs(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
yarp::dev::Nav2D::MapGrid2D themap
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool readTag(yarp::os::idl::WireReader &reader)
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool 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.
static constexpr const char * s_prototype
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr const char * s_tag
static constexpr size_t s_tag_len
static constexpr const char * s_help
static constexpr size_t s_cmd_len
static constexpr size_t s_reply_len
yarp::dev::ReturnValue(*)(const yarp::dev::Nav2D::MapGrid2D &) funcptr_t
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 readArgs(yarp::os::idl::WireReader &reader)
bool readTag(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr size_t s_tag_len
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
yarp::dev::ReturnValue(*)(const std::string &, const yarp::dev::Nav2D::Map2DPath &) funcptr_t
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr size_t s_cmd_len
static constexpr size_t s_reply_len
static constexpr const char * s_help
static constexpr const char * s_prototype
static constexpr const char * s_tag
virtual return_get_map_names get_map_names_RPC()
virtual yarp::dev::ReturnValue save_map_to_disk_RPC(const std::string &map_name, const std::string &file_name)
virtual yarp::dev::ReturnValue save_maps_collection_RPC(const std::string &maps_collection_file)
virtual yarp::dev::ReturnValue remove_map_RPC(const std::string &map_name)
virtual yarp::dev::ReturnValue clear_all_areas_RPC()
virtual yarp::dev::ReturnValue enable_maps_compression_RPC(const bool enable_compression)
virtual yarp::dev::ReturnValue store_area_RPC(const std::string &area_name, const yarp::dev::Nav2D::Map2DArea &area)
virtual yarp::dev::ReturnValue rename_path_RPC(const std::string &original_name, const std::string &new_name)
virtual yarp::dev::ReturnValue delete_path_RPC(const std::string &path_name)
virtual return_get_all_areas get_all_areas_RPC()
virtual yarp::dev::ReturnValue store_map_RPC(const yarp::dev::Nav2D::MapGrid2D &themap)
virtual yarp::dev::ReturnValue rename_location_RPC(const std::string &original_name, const std::string &new_name)
virtual return_get_location get_location_RPC(const std::string &location_name)
virtual return_get_areas_list get_areas_list_RPC()
virtual yarp::dev::ReturnValue load_map_from_disk_RPC(const std::string &file_name)
virtual return_get_path get_path_RPC(const std::string &path_name)
virtual yarp::dev::ReturnValue store_path_RPC(const std::string &path_name, const yarp::dev::Nav2D::Map2DPath &path)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
virtual yarp::dev::ReturnValue clear_all_locations_RPC()
virtual yarp::dev::ReturnValue rename_area_RPC(const std::string &original_name, const std::string &new_name)
virtual yarp::dev::ReturnValue clear_all_maps_RPC()
virtual yarp::dev::ReturnValue delete_location_RPC(const std::string &location_name)
virtual yarp::dev::ReturnValue load_locations_and_extras_RPC(const std::string &locations_collection_file)
virtual yarp::dev::ReturnValue load_maps_collection_RPC(const std::string &maps_collection_file)
virtual yarp::dev::ReturnValue delete_area_RPC(const std::string &area_name)
virtual yarp::dev::ReturnValue store_location_RPC(const std::string &location_name, const yarp::dev::Nav2D::Map2DLocation &loc)
virtual return_get_area get_area_RPC(const std::string &area_name)
virtual return_get_all_paths get_all_paths_RPC()
virtual return_get_map get_map_RPC(const std::string &map_name)
virtual yarp::dev::ReturnValue save_locations_and_extras_RPC(const std::string &locations_collection_file)
virtual yarp::dev::ReturnValue clear_all_maps_temporary_flags_RPC()
virtual return_get_paths_list get_paths_list_RPC()
virtual std::vector< std::string > help(const std::string &functionName="--all")
virtual yarp::dev::ReturnValue clear_all_paths_RPC()
virtual return_get_locations_list get_locations_list_RPC()
virtual return_get_all_locations get_all_locations_RPC()
virtual yarp::dev::ReturnValue clear_map_temporary_flags_RPC(const std::string &map_name)
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
A "tamed" Portable, that promises to serialize itself in an IDL-friendly way.
IDL-friendly connection reader.
Definition WireReader.h:27
bool readNested(WirePortable &obj)
bool readString(std::string &str, bool *is_vocab=nullptr)
std::string readTag(size_t len=static_cast< size_t >(-1))
bool read(WirePortable &obj)
IDL-friendly connection writer.
Definition WireWriter.h:28
bool writeBool(bool x, bool skip_tag=false) const
bool write(const WirePortable &obj) const
bool writeListHeader(int len) const
bool writeTag(const char *tag, int split, int len) const
bool writeString(const std::string &str, bool skip_tag=false) const
bool writeNested(const WirePortable &obj) const
bool writeListBegin(int tag, size_t len) const
The main, catch-all namespace for YARP.
Definition dirs.h:16