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 (based on compiler 0.14.1-yarped)
7// yarpidl_thrift version 2.0 - 11/11/2026
8// Protocol version: protocol_version=0, yarp_major=4, yarp_minor=0, yarp_patch=2
9// This is an automatically generated file.
10// It could get re-generated if the ALLOW_IDL_GENERATION flag is on.
11
12#include <yarp/conf/version.h>
13#include <IMap2DMsgs.h>
15#include <yarp/os/LogStream.h>
16
18
19#include <algorithm>
20
21namespace
22{
23 YARP_LOG_COMPONENT(SERVICE_LOG_COMPONENT, "IMap2DMsgs")
24}
25
26//IMap2DMsgs_getRemoteProtocolVersion_helper declaration
37
39{
40 yarp::os::idl::WireWriter writer(connection);
41 if (!writer.writeListHeader(1)) {
42 return false;
43 }
44 if (!writer.writeString("getRemoteProtocolVersion")) {
45 return false;
46 }
47 return true;
48}
49
50bool IMap2DMsgs_getRemoteProtocolVersion_helper ::read(yarp::os::ConnectionReader & connection)
51 {
52 yarp::os::idl::WireReader reader(connection);
53 if (!reader.readListHeader()) {
54 reader.fail();
55 return false;
56 }
57
58 if (!helper_proto.read(connection)) {
59 reader.fail();
60 return false;
61 }
62 return true;
63}
64
65//ProtocolVersion, client side
67 {
68 if(!yarp().canWrite()) {
69 yError(" Missing server method IMap2DMsgs::getRemoteProtocolVersion");
70 }
72 bool ok = yarp().write(helper, helper);
73 if (ok) {
74 return helper.helper_proto;}
75 else {
77 return failureproto;}
78}
79
80//ProtocolVersion, client side
82 {
83 auto locproto = this->getLocalProtocolVersion();
84 auto remproto = this->getRemoteProtocolVersion();
85 if (remproto.protocol_version != locproto.protocol_version)
86 {
87 yCError(SERVICE_LOG_COMPONENT) << "Invalid communication protocol.";
88 yCError(SERVICE_LOG_COMPONENT) << "Local Protocol Version: " << locproto.toString();
89 yCError(SERVICE_LOG_COMPONENT) << "Remote Protocol Version: " << remproto.toString();
90 return false;
91 }
92 return true;
93}
94
95//ProtocolVersion, server side
97{
99 //myproto.protocol_version using default value = 0
100 //to change this value add the following line to the .thrift file:
101 //const i16 protocol_version = <your_number_here>
102 myproto.protocol_version = 0;
106 return myproto;
107}
108
109// clear_all_maps_RPC helper class declaration
111 public yarp::os::Portable
112{
113public:
115 bool write(yarp::os::ConnectionWriter& connection) const override;
116 bool read(yarp::os::ConnectionReader& connection) override;
117
118 class Command :
120 {
121 public:
122 Command() = default;
123 ~Command() override = default;
124
125 bool write(yarp::os::ConnectionWriter& connection) const override;
126 bool read(yarp::os::ConnectionReader& connection) override;
127
128 bool write(const yarp::os::idl::WireWriter& writer) const override;
129 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
130 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
131
132 bool read(yarp::os::idl::WireReader& reader) override;
135 };
136
137 class Reply :
139 {
140 public:
141 Reply() = default;
142 ~Reply() override = default;
143
144 bool write(yarp::os::ConnectionWriter& connection) const override;
145 bool read(yarp::os::ConnectionReader& connection) override;
146
147 bool write(const yarp::os::idl::WireWriter& writer) const override;
148 bool read(yarp::os::idl::WireReader& reader) override;
149
151 };
152
154 void call(IMap2DMsgs* ptr);
155
158
159 static constexpr const char* s_tag{"clear_all_maps_RPC"};
160 static constexpr size_t s_tag_len{4};
161 static constexpr size_t s_cmd_len{4};
162 static constexpr size_t s_reply_len{1};
163 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::clear_all_maps_RPC()"};
164 static constexpr const char* s_help{""};
165};
166
167// store_map_RPC helper class declaration
169 public yarp::os::Portable
170{
171public:
174 bool write(yarp::os::ConnectionWriter& connection) const override;
175 bool read(yarp::os::ConnectionReader& connection) override;
176
177 class Command :
179 {
180 public:
181 Command() = default;
183
184 ~Command() override = default;
185
186 bool write(yarp::os::ConnectionWriter& connection) const override;
187 bool read(yarp::os::ConnectionReader& connection) override;
188
189 bool write(const yarp::os::idl::WireWriter& writer) const override;
190 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
191 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
192
193 bool read(yarp::os::idl::WireReader& reader) override;
196
198 };
199
200 class Reply :
202 {
203 public:
204 Reply() = default;
205 ~Reply() override = default;
206
207 bool write(yarp::os::ConnectionWriter& connection) const override;
208 bool read(yarp::os::ConnectionReader& connection) override;
209
210 bool write(const yarp::os::idl::WireWriter& writer) const override;
211 bool read(yarp::os::idl::WireReader& reader) override;
212
214 };
215
217 void call(IMap2DMsgs* ptr);
218
221
222 static constexpr const char* s_tag{"store_map_RPC"};
223 static constexpr size_t s_tag_len{3};
224 static constexpr size_t s_cmd_len{4};
225 static constexpr size_t s_reply_len{1};
226 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::store_map_RPC(const yarp::dev::Nav2D::MapGrid2D& themap)"};
227 static constexpr const char* s_help{""};
228};
229
230// get_map_RPC helper class declaration
232 public yarp::os::Portable
233{
234public:
236 explicit IMap2DMsgs_get_map_RPC_helper(const std::string& map_name);
237 bool write(yarp::os::ConnectionWriter& connection) const override;
238 bool read(yarp::os::ConnectionReader& connection) override;
239
240 class Command :
242 {
243 public:
244 Command() = default;
245 explicit Command(const std::string& map_name);
246
247 ~Command() override = default;
248
249 bool write(yarp::os::ConnectionWriter& connection) const override;
250 bool read(yarp::os::ConnectionReader& connection) override;
251
252 bool write(const yarp::os::idl::WireWriter& writer) const override;
253 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
254 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
255
256 bool read(yarp::os::idl::WireReader& reader) override;
259
260 std::string map_name{};
261 };
262
263 class Reply :
265 {
266 public:
267 Reply() = default;
268 ~Reply() override = default;
269
270 bool write(yarp::os::ConnectionWriter& connection) const override;
271 bool read(yarp::os::ConnectionReader& connection) override;
272
273 bool write(const yarp::os::idl::WireWriter& writer) const override;
274 bool read(yarp::os::idl::WireReader& reader) override;
275
277 };
278
279 using funcptr_t = return_get_map (*)(const std::string&);
280 void call(IMap2DMsgs* ptr);
281
284
285 static constexpr const char* s_tag{"get_map_RPC"};
286 static constexpr size_t s_tag_len{3};
287 static constexpr size_t s_cmd_len{4};
288 static constexpr size_t s_reply_len{2};
289 static constexpr const char* s_prototype{"return_get_map IMap2DMsgs::get_map_RPC(const std::string& map_name)"};
290 static constexpr const char* s_help{""};
291};
292
293// get_map_names_RPC helper class declaration
295 public yarp::os::Portable
296{
297public:
299 bool write(yarp::os::ConnectionWriter& connection) const override;
300 bool read(yarp::os::ConnectionReader& connection) override;
301
302 class Command :
304 {
305 public:
306 Command() = default;
307 ~Command() override = default;
308
309 bool write(yarp::os::ConnectionWriter& connection) const override;
310 bool read(yarp::os::ConnectionReader& connection) override;
311
312 bool write(const yarp::os::idl::WireWriter& writer) const override;
313 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
314 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
315
316 bool read(yarp::os::idl::WireReader& reader) override;
319 };
320
321 class Reply :
323 {
324 public:
325 Reply() = default;
326 ~Reply() override = default;
327
328 bool write(yarp::os::ConnectionWriter& connection) const override;
329 bool read(yarp::os::ConnectionReader& connection) override;
330
331 bool write(const yarp::os::idl::WireWriter& writer) const override;
332 bool read(yarp::os::idl::WireReader& reader) override;
333
335 };
336
338 void call(IMap2DMsgs* ptr);
339
342
343 static constexpr const char* s_tag{"get_map_names_RPC"};
344 static constexpr size_t s_tag_len{4};
345 static constexpr size_t s_cmd_len{4};
346 static constexpr size_t s_reply_len{2};
347 static constexpr const char* s_prototype{"return_get_map_names IMap2DMsgs::get_map_names_RPC()"};
348 static constexpr const char* s_help{""};
349};
350
351// remove_map_RPC helper class declaration
353 public yarp::os::Portable
354{
355public:
357 explicit IMap2DMsgs_remove_map_RPC_helper(const std::string& map_name);
358 bool write(yarp::os::ConnectionWriter& connection) const override;
359 bool read(yarp::os::ConnectionReader& connection) override;
360
361 class Command :
363 {
364 public:
365 Command() = default;
366 explicit Command(const std::string& map_name);
367
368 ~Command() override = default;
369
370 bool write(yarp::os::ConnectionWriter& connection) const override;
371 bool read(yarp::os::ConnectionReader& connection) override;
372
373 bool write(const yarp::os::idl::WireWriter& writer) const override;
374 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
375 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
376
377 bool read(yarp::os::idl::WireReader& reader) override;
380
381 std::string map_name{};
382 };
383
384 class Reply :
386 {
387 public:
388 Reply() = default;
389 ~Reply() override = default;
390
391 bool write(yarp::os::ConnectionWriter& connection) const override;
392 bool read(yarp::os::ConnectionReader& connection) override;
393
394 bool write(const yarp::os::idl::WireWriter& writer) const override;
395 bool read(yarp::os::idl::WireReader& reader) override;
396
398 };
399
400 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&);
401 void call(IMap2DMsgs* ptr);
402
405
406 static constexpr const char* s_tag{"remove_map_RPC"};
407 static constexpr size_t s_tag_len{3};
408 static constexpr size_t s_cmd_len{4};
409 static constexpr size_t s_reply_len{1};
410 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::remove_map_RPC(const std::string& map_name)"};
411 static constexpr const char* s_help{""};
412};
413
414// store_object_RPC helper class declaration
416 public yarp::os::Portable
417{
418public:
420 IMap2DMsgs_store_object_RPC_helper(const std::string& object_name, const yarp::dev::Nav2D::Map2DObject& loc);
421 bool write(yarp::os::ConnectionWriter& connection) const override;
422 bool read(yarp::os::ConnectionReader& connection) override;
423
424 class Command :
426 {
427 public:
428 Command() = default;
429 Command(const std::string& object_name, const yarp::dev::Nav2D::Map2DObject& loc);
430
431 ~Command() override = default;
432
433 bool write(yarp::os::ConnectionWriter& connection) const override;
434 bool read(yarp::os::ConnectionReader& connection) override;
435
436 bool write(const yarp::os::idl::WireWriter& writer) const override;
437 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
438 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
439
440 bool read(yarp::os::idl::WireReader& reader) override;
443
444 std::string object_name{};
446 };
447
448 class Reply :
450 {
451 public:
452 Reply() = default;
453 ~Reply() override = default;
454
455 bool write(yarp::os::ConnectionWriter& connection) const override;
456 bool read(yarp::os::ConnectionReader& connection) override;
457
458 bool write(const yarp::os::idl::WireWriter& writer) const override;
459 bool read(yarp::os::idl::WireReader& reader) override;
460
462 };
463
464 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&, const yarp::dev::Nav2D::Map2DObject&);
465 void call(IMap2DMsgs* ptr);
466
469
470 static constexpr const char* s_tag{"store_object_RPC"};
471 static constexpr size_t s_tag_len{3};
472 static constexpr size_t s_cmd_len{5};
473 static constexpr size_t s_reply_len{1};
474 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::store_object_RPC(const std::string& object_name, const yarp::dev::Nav2D::Map2DObject& loc)"};
475 static constexpr const char* s_help{""};
476};
477
478// store_location_RPC helper class declaration
480 public yarp::os::Portable
481{
482public:
484 IMap2DMsgs_store_location_RPC_helper(const std::string& location_name, const yarp::dev::Nav2D::Map2DLocation& loc);
485 bool write(yarp::os::ConnectionWriter& connection) const override;
486 bool read(yarp::os::ConnectionReader& connection) override;
487
488 class Command :
490 {
491 public:
492 Command() = default;
493 Command(const std::string& location_name, const yarp::dev::Nav2D::Map2DLocation& loc);
494
495 ~Command() override = default;
496
497 bool write(yarp::os::ConnectionWriter& connection) const override;
498 bool read(yarp::os::ConnectionReader& connection) override;
499
500 bool write(const yarp::os::idl::WireWriter& writer) const override;
501 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
502 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
503
504 bool read(yarp::os::idl::WireReader& reader) override;
507
508 std::string location_name{};
510 };
511
512 class Reply :
514 {
515 public:
516 Reply() = default;
517 ~Reply() override = default;
518
519 bool write(yarp::os::ConnectionWriter& connection) const override;
520 bool read(yarp::os::ConnectionReader& connection) override;
521
522 bool write(const yarp::os::idl::WireWriter& writer) const override;
523 bool read(yarp::os::idl::WireReader& reader) override;
524
526 };
527
528 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&, const yarp::dev::Nav2D::Map2DLocation&);
529 void call(IMap2DMsgs* ptr);
530
533
534 static constexpr const char* s_tag{"store_location_RPC"};
535 static constexpr size_t s_tag_len{3};
536 static constexpr size_t s_cmd_len{5};
537 static constexpr size_t s_reply_len{1};
538 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::store_location_RPC(const std::string& location_name, const yarp::dev::Nav2D::Map2DLocation& loc)"};
539 static constexpr const char* s_help{""};
540};
541
542// store_area_RPC helper class declaration
544 public yarp::os::Portable
545{
546public:
548 IMap2DMsgs_store_area_RPC_helper(const std::string& area_name, const yarp::dev::Nav2D::Map2DArea& area);
549 bool write(yarp::os::ConnectionWriter& connection) const override;
550 bool read(yarp::os::ConnectionReader& connection) override;
551
552 class Command :
554 {
555 public:
556 Command() = default;
557 Command(const std::string& area_name, const yarp::dev::Nav2D::Map2DArea& area);
558
559 ~Command() override = default;
560
561 bool write(yarp::os::ConnectionWriter& connection) const override;
562 bool read(yarp::os::ConnectionReader& connection) override;
563
564 bool write(const yarp::os::idl::WireWriter& writer) const override;
565 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
566 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
567
568 bool read(yarp::os::idl::WireReader& reader) override;
571
572 std::string area_name{};
574 };
575
576 class Reply :
578 {
579 public:
580 Reply() = default;
581 ~Reply() override = default;
582
583 bool write(yarp::os::ConnectionWriter& connection) const override;
584 bool read(yarp::os::ConnectionReader& connection) override;
585
586 bool write(const yarp::os::idl::WireWriter& writer) const override;
587 bool read(yarp::os::idl::WireReader& reader) override;
588
590 };
591
592 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&, const yarp::dev::Nav2D::Map2DArea&);
593 void call(IMap2DMsgs* ptr);
594
597
598 static constexpr const char* s_tag{"store_area_RPC"};
599 static constexpr size_t s_tag_len{3};
600 static constexpr size_t s_cmd_len{5};
601 static constexpr size_t s_reply_len{1};
602 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::store_area_RPC(const std::string& area_name, const yarp::dev::Nav2D::Map2DArea& area)"};
603 static constexpr const char* s_help{""};
604};
605
606// store_path_RPC helper class declaration
608 public yarp::os::Portable
609{
610public:
612 IMap2DMsgs_store_path_RPC_helper(const std::string& path_name, const yarp::dev::Nav2D::Map2DPath& path);
613 bool write(yarp::os::ConnectionWriter& connection) const override;
614 bool read(yarp::os::ConnectionReader& connection) override;
615
616 class Command :
618 {
619 public:
620 Command() = default;
621 Command(const std::string& path_name, const yarp::dev::Nav2D::Map2DPath& path);
622
623 ~Command() override = default;
624
625 bool write(yarp::os::ConnectionWriter& connection) const override;
626 bool read(yarp::os::ConnectionReader& connection) override;
627
628 bool write(const yarp::os::idl::WireWriter& writer) const override;
629 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
630 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
631
632 bool read(yarp::os::idl::WireReader& reader) override;
635
636 std::string path_name{};
638 };
639
640 class Reply :
642 {
643 public:
644 Reply() = default;
645 ~Reply() override = default;
646
647 bool write(yarp::os::ConnectionWriter& connection) const override;
648 bool read(yarp::os::ConnectionReader& connection) override;
649
650 bool write(const yarp::os::idl::WireWriter& writer) const override;
651 bool read(yarp::os::idl::WireReader& reader) override;
652
654 };
655
656 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&, const yarp::dev::Nav2D::Map2DPath&);
657 void call(IMap2DMsgs* ptr);
658
661
662 static constexpr const char* s_tag{"store_path_RPC"};
663 static constexpr size_t s_tag_len{3};
664 static constexpr size_t s_cmd_len{5};
665 static constexpr size_t s_reply_len{1};
666 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::store_path_RPC(const std::string& path_name, const yarp::dev::Nav2D::Map2DPath& path)"};
667 static constexpr const char* s_help{""};
668};
669
670// get_object_RPC helper class declaration
672 public yarp::os::Portable
673{
674public:
676 explicit IMap2DMsgs_get_object_RPC_helper(const std::string& object_name);
677 bool write(yarp::os::ConnectionWriter& connection) const override;
678 bool read(yarp::os::ConnectionReader& connection) override;
679
680 class Command :
682 {
683 public:
684 Command() = default;
685 explicit Command(const std::string& object_name);
686
687 ~Command() override = default;
688
689 bool write(yarp::os::ConnectionWriter& connection) const override;
690 bool read(yarp::os::ConnectionReader& connection) override;
691
692 bool write(const yarp::os::idl::WireWriter& writer) const override;
693 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
694 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
695
696 bool read(yarp::os::idl::WireReader& reader) override;
699
700 std::string object_name{};
701 };
702
703 class Reply :
705 {
706 public:
707 Reply() = default;
708 ~Reply() override = default;
709
710 bool write(yarp::os::ConnectionWriter& connection) const override;
711 bool read(yarp::os::ConnectionReader& connection) override;
712
713 bool write(const yarp::os::idl::WireWriter& writer) const override;
714 bool read(yarp::os::idl::WireReader& reader) override;
715
717 };
718
719 using funcptr_t = return_get_object (*)(const std::string&);
720 void call(IMap2DMsgs* ptr);
721
724
725 static constexpr const char* s_tag{"get_object_RPC"};
726 static constexpr size_t s_tag_len{3};
727 static constexpr size_t s_cmd_len{4};
728 static constexpr size_t s_reply_len{2};
729 static constexpr const char* s_prototype{"return_get_object IMap2DMsgs::get_object_RPC(const std::string& object_name)"};
730 static constexpr const char* s_help{""};
731};
732
733// get_location_RPC helper class declaration
735 public yarp::os::Portable
736{
737public:
739 explicit IMap2DMsgs_get_location_RPC_helper(const std::string& location_name);
740 bool write(yarp::os::ConnectionWriter& connection) const override;
741 bool read(yarp::os::ConnectionReader& connection) override;
742
743 class Command :
745 {
746 public:
747 Command() = default;
748 explicit Command(const std::string& location_name);
749
750 ~Command() override = default;
751
752 bool write(yarp::os::ConnectionWriter& connection) const override;
753 bool read(yarp::os::ConnectionReader& connection) override;
754
755 bool write(const yarp::os::idl::WireWriter& writer) const override;
756 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
757 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
758
759 bool read(yarp::os::idl::WireReader& reader) override;
762
763 std::string location_name{};
764 };
765
766 class Reply :
768 {
769 public:
770 Reply() = default;
771 ~Reply() override = default;
772
773 bool write(yarp::os::ConnectionWriter& connection) const override;
774 bool read(yarp::os::ConnectionReader& connection) override;
775
776 bool write(const yarp::os::idl::WireWriter& writer) const override;
777 bool read(yarp::os::idl::WireReader& reader) override;
778
780 };
781
782 using funcptr_t = return_get_location (*)(const std::string&);
783 void call(IMap2DMsgs* ptr);
784
787
788 static constexpr const char* s_tag{"get_location_RPC"};
789 static constexpr size_t s_tag_len{3};
790 static constexpr size_t s_cmd_len{4};
791 static constexpr size_t s_reply_len{2};
792 static constexpr const char* s_prototype{"return_get_location IMap2DMsgs::get_location_RPC(const std::string& location_name)"};
793 static constexpr const char* s_help{""};
794};
795
796// get_area_RPC helper class declaration
798 public yarp::os::Portable
799{
800public:
802 explicit IMap2DMsgs_get_area_RPC_helper(const std::string& area_name);
803 bool write(yarp::os::ConnectionWriter& connection) const override;
804 bool read(yarp::os::ConnectionReader& connection) override;
805
806 class Command :
808 {
809 public:
810 Command() = default;
811 explicit Command(const std::string& area_name);
812
813 ~Command() override = default;
814
815 bool write(yarp::os::ConnectionWriter& connection) const override;
816 bool read(yarp::os::ConnectionReader& connection) override;
817
818 bool write(const yarp::os::idl::WireWriter& writer) const override;
819 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
820 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
821
822 bool read(yarp::os::idl::WireReader& reader) override;
825
826 std::string area_name{};
827 };
828
829 class Reply :
831 {
832 public:
833 Reply() = default;
834 ~Reply() override = default;
835
836 bool write(yarp::os::ConnectionWriter& connection) const override;
837 bool read(yarp::os::ConnectionReader& connection) override;
838
839 bool write(const yarp::os::idl::WireWriter& writer) const override;
840 bool read(yarp::os::idl::WireReader& reader) override;
841
843 };
844
845 using funcptr_t = return_get_area (*)(const std::string&);
846 void call(IMap2DMsgs* ptr);
847
850
851 static constexpr const char* s_tag{"get_area_RPC"};
852 static constexpr size_t s_tag_len{3};
853 static constexpr size_t s_cmd_len{4};
854 static constexpr size_t s_reply_len{2};
855 static constexpr const char* s_prototype{"return_get_area IMap2DMsgs::get_area_RPC(const std::string& area_name)"};
856 static constexpr const char* s_help{""};
857};
858
859// get_path_RPC helper class declaration
861 public yarp::os::Portable
862{
863public:
865 explicit IMap2DMsgs_get_path_RPC_helper(const std::string& path_name);
866 bool write(yarp::os::ConnectionWriter& connection) const override;
867 bool read(yarp::os::ConnectionReader& connection) override;
868
869 class Command :
871 {
872 public:
873 Command() = default;
874 explicit Command(const std::string& path_name);
875
876 ~Command() override = default;
877
878 bool write(yarp::os::ConnectionWriter& connection) const override;
879 bool read(yarp::os::ConnectionReader& connection) override;
880
881 bool write(const yarp::os::idl::WireWriter& writer) const override;
882 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
883 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
884
885 bool read(yarp::os::idl::WireReader& reader) override;
888
889 std::string path_name{};
890 };
891
892 class Reply :
894 {
895 public:
896 Reply() = default;
897 ~Reply() override = default;
898
899 bool write(yarp::os::ConnectionWriter& connection) const override;
900 bool read(yarp::os::ConnectionReader& connection) override;
901
902 bool write(const yarp::os::idl::WireWriter& writer) const override;
903 bool read(yarp::os::idl::WireReader& reader) override;
904
906 };
907
908 using funcptr_t = return_get_path (*)(const std::string&);
909 void call(IMap2DMsgs* ptr);
910
913
914 static constexpr const char* s_tag{"get_path_RPC"};
915 static constexpr size_t s_tag_len{3};
916 static constexpr size_t s_cmd_len{4};
917 static constexpr size_t s_reply_len{2};
918 static constexpr const char* s_prototype{"return_get_path IMap2DMsgs::get_path_RPC(const std::string& path_name)"};
919 static constexpr const char* s_help{""};
920};
921
922// get_objects_list_RPC helper class declaration
924 public yarp::os::Portable
925{
926public:
928 bool write(yarp::os::ConnectionWriter& connection) const override;
929 bool read(yarp::os::ConnectionReader& connection) override;
930
931 class Command :
933 {
934 public:
935 Command() = default;
936 ~Command() override = default;
937
938 bool write(yarp::os::ConnectionWriter& connection) const override;
939 bool read(yarp::os::ConnectionReader& connection) override;
940
941 bool write(const yarp::os::idl::WireWriter& writer) const override;
942 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
943 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
944
945 bool read(yarp::os::idl::WireReader& reader) override;
948 };
949
950 class Reply :
952 {
953 public:
954 Reply() = default;
955 ~Reply() override = default;
956
957 bool write(yarp::os::ConnectionWriter& connection) const override;
958 bool read(yarp::os::ConnectionReader& connection) override;
959
960 bool write(const yarp::os::idl::WireWriter& writer) const override;
961 bool read(yarp::os::idl::WireReader& reader) override;
962
964 };
965
967 void call(IMap2DMsgs* ptr);
968
971
972 static constexpr const char* s_tag{"get_objects_list_RPC"};
973 static constexpr size_t s_tag_len{4};
974 static constexpr size_t s_cmd_len{4};
975 static constexpr size_t s_reply_len{2};
976 static constexpr const char* s_prototype{"return_get_objects_list IMap2DMsgs::get_objects_list_RPC()"};
977 static constexpr const char* s_help{""};
978};
979
980// get_locations_list_RPC helper class declaration
982 public yarp::os::Portable
983{
984public:
986 bool write(yarp::os::ConnectionWriter& connection) const override;
987 bool read(yarp::os::ConnectionReader& connection) override;
988
989 class Command :
991 {
992 public:
993 Command() = default;
994 ~Command() override = default;
995
996 bool write(yarp::os::ConnectionWriter& connection) const override;
997 bool read(yarp::os::ConnectionReader& connection) override;
998
999 bool write(const yarp::os::idl::WireWriter& writer) const override;
1000 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1001 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1002
1003 bool read(yarp::os::idl::WireReader& reader) override;
1004 bool readTag(yarp::os::idl::WireReader& reader);
1005 bool readArgs(yarp::os::idl::WireReader& reader);
1006 };
1007
1008 class Reply :
1010 {
1011 public:
1012 Reply() = default;
1013 ~Reply() override = default;
1014
1015 bool write(yarp::os::ConnectionWriter& connection) const override;
1016 bool read(yarp::os::ConnectionReader& connection) override;
1017
1018 bool write(const yarp::os::idl::WireWriter& writer) const override;
1019 bool read(yarp::os::idl::WireReader& reader) override;
1020
1022 };
1023
1025 void call(IMap2DMsgs* ptr);
1026
1029
1030 static constexpr const char* s_tag{"get_locations_list_RPC"};
1031 static constexpr size_t s_tag_len{4};
1032 static constexpr size_t s_cmd_len{4};
1033 static constexpr size_t s_reply_len{2};
1034 static constexpr const char* s_prototype{"return_get_locations_list IMap2DMsgs::get_locations_list_RPC()"};
1035 static constexpr const char* s_help{""};
1036};
1037
1038// get_areas_list_RPC helper class declaration
1040 public yarp::os::Portable
1041{
1042public:
1044 bool write(yarp::os::ConnectionWriter& connection) const override;
1045 bool read(yarp::os::ConnectionReader& connection) override;
1046
1047 class Command :
1049 {
1050 public:
1051 Command() = default;
1052 ~Command() override = default;
1053
1054 bool write(yarp::os::ConnectionWriter& connection) const override;
1055 bool read(yarp::os::ConnectionReader& connection) override;
1056
1057 bool write(const yarp::os::idl::WireWriter& writer) const override;
1058 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1059 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1060
1061 bool read(yarp::os::idl::WireReader& reader) override;
1062 bool readTag(yarp::os::idl::WireReader& reader);
1063 bool readArgs(yarp::os::idl::WireReader& reader);
1064 };
1065
1066 class Reply :
1068 {
1069 public:
1070 Reply() = default;
1071 ~Reply() override = default;
1072
1073 bool write(yarp::os::ConnectionWriter& connection) const override;
1074 bool read(yarp::os::ConnectionReader& connection) override;
1075
1076 bool write(const yarp::os::idl::WireWriter& writer) const override;
1077 bool read(yarp::os::idl::WireReader& reader) override;
1078
1080 };
1081
1083 void call(IMap2DMsgs* ptr);
1084
1087
1088 static constexpr const char* s_tag{"get_areas_list_RPC"};
1089 static constexpr size_t s_tag_len{4};
1090 static constexpr size_t s_cmd_len{4};
1091 static constexpr size_t s_reply_len{2};
1092 static constexpr const char* s_prototype{"return_get_areas_list IMap2DMsgs::get_areas_list_RPC()"};
1093 static constexpr const char* s_help{""};
1094};
1095
1096// get_paths_list_RPC helper class declaration
1098 public yarp::os::Portable
1099{
1100public:
1102 bool write(yarp::os::ConnectionWriter& connection) const override;
1103 bool read(yarp::os::ConnectionReader& connection) override;
1104
1105 class Command :
1107 {
1108 public:
1109 Command() = default;
1110 ~Command() override = default;
1111
1112 bool write(yarp::os::ConnectionWriter& connection) const override;
1113 bool read(yarp::os::ConnectionReader& connection) override;
1114
1115 bool write(const yarp::os::idl::WireWriter& writer) const override;
1116 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1117 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1118
1119 bool read(yarp::os::idl::WireReader& reader) override;
1120 bool readTag(yarp::os::idl::WireReader& reader);
1121 bool readArgs(yarp::os::idl::WireReader& reader);
1122 };
1123
1124 class Reply :
1126 {
1127 public:
1128 Reply() = default;
1129 ~Reply() override = default;
1130
1131 bool write(yarp::os::ConnectionWriter& connection) const override;
1132 bool read(yarp::os::ConnectionReader& connection) override;
1133
1134 bool write(const yarp::os::idl::WireWriter& writer) const override;
1135 bool read(yarp::os::idl::WireReader& reader) override;
1136
1138 };
1139
1141 void call(IMap2DMsgs* ptr);
1142
1145
1146 static constexpr const char* s_tag{"get_paths_list_RPC"};
1147 static constexpr size_t s_tag_len{4};
1148 static constexpr size_t s_cmd_len{4};
1149 static constexpr size_t s_reply_len{2};
1150 static constexpr const char* s_prototype{"return_get_paths_list IMap2DMsgs::get_paths_list_RPC()"};
1151 static constexpr const char* s_help{""};
1152};
1153
1154// get_all_objects_RPC helper class declaration
1156 public yarp::os::Portable
1157{
1158public:
1160 bool write(yarp::os::ConnectionWriter& connection) const override;
1161 bool read(yarp::os::ConnectionReader& connection) override;
1162
1163 class Command :
1165 {
1166 public:
1167 Command() = default;
1168 ~Command() override = default;
1169
1170 bool write(yarp::os::ConnectionWriter& connection) const override;
1171 bool read(yarp::os::ConnectionReader& connection) override;
1172
1173 bool write(const yarp::os::idl::WireWriter& writer) const override;
1174 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1175 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1176
1177 bool read(yarp::os::idl::WireReader& reader) override;
1178 bool readTag(yarp::os::idl::WireReader& reader);
1179 bool readArgs(yarp::os::idl::WireReader& reader);
1180 };
1181
1182 class Reply :
1184 {
1185 public:
1186 Reply() = default;
1187 ~Reply() override = default;
1188
1189 bool write(yarp::os::ConnectionWriter& connection) const override;
1190 bool read(yarp::os::ConnectionReader& connection) override;
1191
1192 bool write(const yarp::os::idl::WireWriter& writer) const override;
1193 bool read(yarp::os::idl::WireReader& reader) override;
1194
1196 };
1197
1199 void call(IMap2DMsgs* ptr);
1200
1203
1204 static constexpr const char* s_tag{"get_all_objects_RPC"};
1205 static constexpr size_t s_tag_len{4};
1206 static constexpr size_t s_cmd_len{4};
1207 static constexpr size_t s_reply_len{2};
1208 static constexpr const char* s_prototype{"return_get_all_objects IMap2DMsgs::get_all_objects_RPC()"};
1209 static constexpr const char* s_help{""};
1210};
1211
1212// get_all_locations_RPC helper class declaration
1214 public yarp::os::Portable
1215{
1216public:
1218 bool write(yarp::os::ConnectionWriter& connection) const override;
1219 bool read(yarp::os::ConnectionReader& connection) override;
1220
1221 class Command :
1223 {
1224 public:
1225 Command() = default;
1226 ~Command() override = default;
1227
1228 bool write(yarp::os::ConnectionWriter& connection) const override;
1229 bool read(yarp::os::ConnectionReader& connection) override;
1230
1231 bool write(const yarp::os::idl::WireWriter& writer) const override;
1232 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1233 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1234
1235 bool read(yarp::os::idl::WireReader& reader) override;
1236 bool readTag(yarp::os::idl::WireReader& reader);
1237 bool readArgs(yarp::os::idl::WireReader& reader);
1238 };
1239
1240 class Reply :
1242 {
1243 public:
1244 Reply() = default;
1245 ~Reply() override = default;
1246
1247 bool write(yarp::os::ConnectionWriter& connection) const override;
1248 bool read(yarp::os::ConnectionReader& connection) override;
1249
1250 bool write(const yarp::os::idl::WireWriter& writer) const override;
1251 bool read(yarp::os::idl::WireReader& reader) override;
1252
1254 };
1255
1257 void call(IMap2DMsgs* ptr);
1258
1261
1262 static constexpr const char* s_tag{"get_all_locations_RPC"};
1263 static constexpr size_t s_tag_len{4};
1264 static constexpr size_t s_cmd_len{4};
1265 static constexpr size_t s_reply_len{2};
1266 static constexpr const char* s_prototype{"return_get_all_locations IMap2DMsgs::get_all_locations_RPC()"};
1267 static constexpr const char* s_help{""};
1268};
1269
1270// get_all_areas_RPC helper class declaration
1272 public yarp::os::Portable
1273{
1274public:
1276 bool write(yarp::os::ConnectionWriter& connection) const override;
1277 bool read(yarp::os::ConnectionReader& connection) override;
1278
1279 class Command :
1281 {
1282 public:
1283 Command() = default;
1284 ~Command() override = default;
1285
1286 bool write(yarp::os::ConnectionWriter& connection) const override;
1287 bool read(yarp::os::ConnectionReader& connection) override;
1288
1289 bool write(const yarp::os::idl::WireWriter& writer) const override;
1290 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1291 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1292
1293 bool read(yarp::os::idl::WireReader& reader) override;
1294 bool readTag(yarp::os::idl::WireReader& reader);
1295 bool readArgs(yarp::os::idl::WireReader& reader);
1296 };
1297
1298 class Reply :
1300 {
1301 public:
1302 Reply() = default;
1303 ~Reply() override = default;
1304
1305 bool write(yarp::os::ConnectionWriter& connection) const override;
1306 bool read(yarp::os::ConnectionReader& connection) override;
1307
1308 bool write(const yarp::os::idl::WireWriter& writer) const override;
1309 bool read(yarp::os::idl::WireReader& reader) override;
1310
1312 };
1313
1315 void call(IMap2DMsgs* ptr);
1316
1319
1320 static constexpr const char* s_tag{"get_all_areas_RPC"};
1321 static constexpr size_t s_tag_len{4};
1322 static constexpr size_t s_cmd_len{4};
1323 static constexpr size_t s_reply_len{2};
1324 static constexpr const char* s_prototype{"return_get_all_areas IMap2DMsgs::get_all_areas_RPC()"};
1325 static constexpr const char* s_help{""};
1326};
1327
1328// get_all_paths_RPC helper class declaration
1330 public yarp::os::Portable
1331{
1332public:
1334 bool write(yarp::os::ConnectionWriter& connection) const override;
1335 bool read(yarp::os::ConnectionReader& connection) override;
1336
1337 class Command :
1339 {
1340 public:
1341 Command() = default;
1342 ~Command() override = default;
1343
1344 bool write(yarp::os::ConnectionWriter& connection) const override;
1345 bool read(yarp::os::ConnectionReader& connection) override;
1346
1347 bool write(const yarp::os::idl::WireWriter& writer) const override;
1348 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1349 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1350
1351 bool read(yarp::os::idl::WireReader& reader) override;
1352 bool readTag(yarp::os::idl::WireReader& reader);
1353 bool readArgs(yarp::os::idl::WireReader& reader);
1354 };
1355
1356 class Reply :
1358 {
1359 public:
1360 Reply() = default;
1361 ~Reply() override = default;
1362
1363 bool write(yarp::os::ConnectionWriter& connection) const override;
1364 bool read(yarp::os::ConnectionReader& connection) override;
1365
1366 bool write(const yarp::os::idl::WireWriter& writer) const override;
1367 bool read(yarp::os::idl::WireReader& reader) override;
1368
1370 };
1371
1373 void call(IMap2DMsgs* ptr);
1374
1377
1378 static constexpr const char* s_tag{"get_all_paths_RPC"};
1379 static constexpr size_t s_tag_len{4};
1380 static constexpr size_t s_cmd_len{4};
1381 static constexpr size_t s_reply_len{2};
1382 static constexpr const char* s_prototype{"return_get_all_paths IMap2DMsgs::get_all_paths_RPC()"};
1383 static constexpr const char* s_help{""};
1384};
1385
1386// rename_location_RPC helper class declaration
1388 public yarp::os::Portable
1389{
1390public:
1392 IMap2DMsgs_rename_location_RPC_helper(const std::string& original_name, const std::string& new_name);
1393 bool write(yarp::os::ConnectionWriter& connection) const override;
1394 bool read(yarp::os::ConnectionReader& connection) override;
1395
1396 class Command :
1398 {
1399 public:
1400 Command() = default;
1401 Command(const std::string& original_name, const std::string& new_name);
1402
1403 ~Command() override = default;
1404
1405 bool write(yarp::os::ConnectionWriter& connection) const override;
1406 bool read(yarp::os::ConnectionReader& connection) override;
1407
1408 bool write(const yarp::os::idl::WireWriter& writer) const override;
1409 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1410 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1411
1412 bool read(yarp::os::idl::WireReader& reader) override;
1413 bool readTag(yarp::os::idl::WireReader& reader);
1414 bool readArgs(yarp::os::idl::WireReader& reader);
1415
1416 std::string original_name{};
1417 std::string new_name{};
1418 };
1419
1420 class Reply :
1422 {
1423 public:
1424 Reply() = default;
1425 ~Reply() override = default;
1426
1427 bool write(yarp::os::ConnectionWriter& connection) const override;
1428 bool read(yarp::os::ConnectionReader& connection) override;
1429
1430 bool write(const yarp::os::idl::WireWriter& writer) const override;
1431 bool read(yarp::os::idl::WireReader& reader) override;
1432
1434 };
1435
1436 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&, const std::string&);
1437 void call(IMap2DMsgs* ptr);
1438
1441
1442 static constexpr const char* s_tag{"rename_location_RPC"};
1443 static constexpr size_t s_tag_len{3};
1444 static constexpr size_t s_cmd_len{5};
1445 static constexpr size_t s_reply_len{1};
1446 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::rename_location_RPC(const std::string& original_name, const std::string& new_name)"};
1447 static constexpr const char* s_help{""};
1448};
1449
1450// delete_object_RPC helper class declaration
1452 public yarp::os::Portable
1453{
1454public:
1456 explicit IMap2DMsgs_delete_object_RPC_helper(const std::string& object_name);
1457 bool write(yarp::os::ConnectionWriter& connection) const override;
1458 bool read(yarp::os::ConnectionReader& connection) override;
1459
1460 class Command :
1462 {
1463 public:
1464 Command() = default;
1465 explicit Command(const std::string& object_name);
1466
1467 ~Command() override = default;
1468
1469 bool write(yarp::os::ConnectionWriter& connection) const override;
1470 bool read(yarp::os::ConnectionReader& connection) override;
1471
1472 bool write(const yarp::os::idl::WireWriter& writer) const override;
1473 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1474 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1475
1476 bool read(yarp::os::idl::WireReader& reader) override;
1477 bool readTag(yarp::os::idl::WireReader& reader);
1478 bool readArgs(yarp::os::idl::WireReader& reader);
1479
1480 std::string object_name{};
1481 };
1482
1483 class Reply :
1485 {
1486 public:
1487 Reply() = default;
1488 ~Reply() override = default;
1489
1490 bool write(yarp::os::ConnectionWriter& connection) const override;
1491 bool read(yarp::os::ConnectionReader& connection) override;
1492
1493 bool write(const yarp::os::idl::WireWriter& writer) const override;
1494 bool read(yarp::os::idl::WireReader& reader) override;
1495
1497 };
1498
1499 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&);
1500 void call(IMap2DMsgs* ptr);
1501
1504
1505 static constexpr const char* s_tag{"delete_object_RPC"};
1506 static constexpr size_t s_tag_len{3};
1507 static constexpr size_t s_cmd_len{4};
1508 static constexpr size_t s_reply_len{1};
1509 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::delete_object_RPC(const std::string& object_name)"};
1510 static constexpr const char* s_help{""};
1511};
1512
1513// delete_location_RPC helper class declaration
1515 public yarp::os::Portable
1516{
1517public:
1519 explicit IMap2DMsgs_delete_location_RPC_helper(const std::string& location_name);
1520 bool write(yarp::os::ConnectionWriter& connection) const override;
1521 bool read(yarp::os::ConnectionReader& connection) override;
1522
1523 class Command :
1525 {
1526 public:
1527 Command() = default;
1528 explicit Command(const std::string& location_name);
1529
1530 ~Command() override = default;
1531
1532 bool write(yarp::os::ConnectionWriter& connection) const override;
1533 bool read(yarp::os::ConnectionReader& connection) override;
1534
1535 bool write(const yarp::os::idl::WireWriter& writer) const override;
1536 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1537 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1538
1539 bool read(yarp::os::idl::WireReader& reader) override;
1540 bool readTag(yarp::os::idl::WireReader& reader);
1541 bool readArgs(yarp::os::idl::WireReader& reader);
1542
1543 std::string location_name{};
1544 };
1545
1546 class Reply :
1548 {
1549 public:
1550 Reply() = default;
1551 ~Reply() override = default;
1552
1553 bool write(yarp::os::ConnectionWriter& connection) const override;
1554 bool read(yarp::os::ConnectionReader& connection) override;
1555
1556 bool write(const yarp::os::idl::WireWriter& writer) const override;
1557 bool read(yarp::os::idl::WireReader& reader) override;
1558
1560 };
1561
1562 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&);
1563 void call(IMap2DMsgs* ptr);
1564
1567
1568 static constexpr const char* s_tag{"delete_location_RPC"};
1569 static constexpr size_t s_tag_len{3};
1570 static constexpr size_t s_cmd_len{4};
1571 static constexpr size_t s_reply_len{1};
1572 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::delete_location_RPC(const std::string& location_name)"};
1573 static constexpr const char* s_help{""};
1574};
1575
1576// delete_path_RPC helper class declaration
1578 public yarp::os::Portable
1579{
1580public:
1582 explicit IMap2DMsgs_delete_path_RPC_helper(const std::string& path_name);
1583 bool write(yarp::os::ConnectionWriter& connection) const override;
1584 bool read(yarp::os::ConnectionReader& connection) override;
1585
1586 class Command :
1588 {
1589 public:
1590 Command() = default;
1591 explicit Command(const std::string& path_name);
1592
1593 ~Command() override = default;
1594
1595 bool write(yarp::os::ConnectionWriter& connection) const override;
1596 bool read(yarp::os::ConnectionReader& connection) override;
1597
1598 bool write(const yarp::os::idl::WireWriter& writer) const override;
1599 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1600 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1601
1602 bool read(yarp::os::idl::WireReader& reader) override;
1603 bool readTag(yarp::os::idl::WireReader& reader);
1604 bool readArgs(yarp::os::idl::WireReader& reader);
1605
1606 std::string path_name{};
1607 };
1608
1609 class Reply :
1611 {
1612 public:
1613 Reply() = default;
1614 ~Reply() override = default;
1615
1616 bool write(yarp::os::ConnectionWriter& connection) const override;
1617 bool read(yarp::os::ConnectionReader& connection) override;
1618
1619 bool write(const yarp::os::idl::WireWriter& writer) const override;
1620 bool read(yarp::os::idl::WireReader& reader) override;
1621
1623 };
1624
1625 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&);
1626 void call(IMap2DMsgs* ptr);
1627
1630
1631 static constexpr const char* s_tag{"delete_path_RPC"};
1632 static constexpr size_t s_tag_len{3};
1633 static constexpr size_t s_cmd_len{4};
1634 static constexpr size_t s_reply_len{1};
1635 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::delete_path_RPC(const std::string& path_name)"};
1636 static constexpr const char* s_help{""};
1637};
1638
1639// rename_object_RPC helper class declaration
1641 public yarp::os::Portable
1642{
1643public:
1645 IMap2DMsgs_rename_object_RPC_helper(const std::string& original_name, const std::string& new_name);
1646 bool write(yarp::os::ConnectionWriter& connection) const override;
1647 bool read(yarp::os::ConnectionReader& connection) override;
1648
1649 class Command :
1651 {
1652 public:
1653 Command() = default;
1654 Command(const std::string& original_name, const std::string& new_name);
1655
1656 ~Command() override = default;
1657
1658 bool write(yarp::os::ConnectionWriter& connection) const override;
1659 bool read(yarp::os::ConnectionReader& connection) override;
1660
1661 bool write(const yarp::os::idl::WireWriter& writer) const override;
1662 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1663 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1664
1665 bool read(yarp::os::idl::WireReader& reader) override;
1666 bool readTag(yarp::os::idl::WireReader& reader);
1667 bool readArgs(yarp::os::idl::WireReader& reader);
1668
1669 std::string original_name{};
1670 std::string new_name{};
1671 };
1672
1673 class Reply :
1675 {
1676 public:
1677 Reply() = default;
1678 ~Reply() override = default;
1679
1680 bool write(yarp::os::ConnectionWriter& connection) const override;
1681 bool read(yarp::os::ConnectionReader& connection) override;
1682
1683 bool write(const yarp::os::idl::WireWriter& writer) const override;
1684 bool read(yarp::os::idl::WireReader& reader) override;
1685
1687 };
1688
1689 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&, const std::string&);
1690 void call(IMap2DMsgs* ptr);
1691
1694
1695 static constexpr const char* s_tag{"rename_object_RPC"};
1696 static constexpr size_t s_tag_len{3};
1697 static constexpr size_t s_cmd_len{5};
1698 static constexpr size_t s_reply_len{1};
1699 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::rename_object_RPC(const std::string& original_name, const std::string& new_name)"};
1700 static constexpr const char* s_help{""};
1701};
1702
1703// rename_area_RPC helper class declaration
1705 public yarp::os::Portable
1706{
1707public:
1709 IMap2DMsgs_rename_area_RPC_helper(const std::string& original_name, const std::string& new_name);
1710 bool write(yarp::os::ConnectionWriter& connection) const override;
1711 bool read(yarp::os::ConnectionReader& connection) override;
1712
1713 class Command :
1715 {
1716 public:
1717 Command() = default;
1718 Command(const std::string& original_name, const std::string& new_name);
1719
1720 ~Command() override = default;
1721
1722 bool write(yarp::os::ConnectionWriter& connection) const override;
1723 bool read(yarp::os::ConnectionReader& connection) override;
1724
1725 bool write(const yarp::os::idl::WireWriter& writer) const override;
1726 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1727 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1728
1729 bool read(yarp::os::idl::WireReader& reader) override;
1730 bool readTag(yarp::os::idl::WireReader& reader);
1731 bool readArgs(yarp::os::idl::WireReader& reader);
1732
1733 std::string original_name{};
1734 std::string new_name{};
1735 };
1736
1737 class Reply :
1739 {
1740 public:
1741 Reply() = default;
1742 ~Reply() override = default;
1743
1744 bool write(yarp::os::ConnectionWriter& connection) const override;
1745 bool read(yarp::os::ConnectionReader& connection) override;
1746
1747 bool write(const yarp::os::idl::WireWriter& writer) const override;
1748 bool read(yarp::os::idl::WireReader& reader) override;
1749
1751 };
1752
1753 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&, const std::string&);
1754 void call(IMap2DMsgs* ptr);
1755
1758
1759 static constexpr const char* s_tag{"rename_area_RPC"};
1760 static constexpr size_t s_tag_len{3};
1761 static constexpr size_t s_cmd_len{5};
1762 static constexpr size_t s_reply_len{1};
1763 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::rename_area_RPC(const std::string& original_name, const std::string& new_name)"};
1764 static constexpr const char* s_help{""};
1765};
1766
1767// rename_path_RPC helper class declaration
1769 public yarp::os::Portable
1770{
1771public:
1773 IMap2DMsgs_rename_path_RPC_helper(const std::string& original_name, const std::string& new_name);
1774 bool write(yarp::os::ConnectionWriter& connection) const override;
1775 bool read(yarp::os::ConnectionReader& connection) override;
1776
1777 class Command :
1779 {
1780 public:
1781 Command() = default;
1782 Command(const std::string& original_name, const std::string& new_name);
1783
1784 ~Command() override = default;
1785
1786 bool write(yarp::os::ConnectionWriter& connection) const override;
1787 bool read(yarp::os::ConnectionReader& connection) override;
1788
1789 bool write(const yarp::os::idl::WireWriter& writer) const override;
1790 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1791 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1792
1793 bool read(yarp::os::idl::WireReader& reader) override;
1794 bool readTag(yarp::os::idl::WireReader& reader);
1795 bool readArgs(yarp::os::idl::WireReader& reader);
1796
1797 std::string original_name{};
1798 std::string new_name{};
1799 };
1800
1801 class Reply :
1803 {
1804 public:
1805 Reply() = default;
1806 ~Reply() override = default;
1807
1808 bool write(yarp::os::ConnectionWriter& connection) const override;
1809 bool read(yarp::os::ConnectionReader& connection) override;
1810
1811 bool write(const yarp::os::idl::WireWriter& writer) const override;
1812 bool read(yarp::os::idl::WireReader& reader) override;
1813
1815 };
1816
1817 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&, const std::string&);
1818 void call(IMap2DMsgs* ptr);
1819
1822
1823 static constexpr const char* s_tag{"rename_path_RPC"};
1824 static constexpr size_t s_tag_len{3};
1825 static constexpr size_t s_cmd_len{5};
1826 static constexpr size_t s_reply_len{1};
1827 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::rename_path_RPC(const std::string& original_name, const std::string& new_name)"};
1828 static constexpr const char* s_help{""};
1829};
1830
1831// delete_area_RPC helper class declaration
1833 public yarp::os::Portable
1834{
1835public:
1837 explicit IMap2DMsgs_delete_area_RPC_helper(const std::string& area_name);
1838 bool write(yarp::os::ConnectionWriter& connection) const override;
1839 bool read(yarp::os::ConnectionReader& connection) override;
1840
1841 class Command :
1843 {
1844 public:
1845 Command() = default;
1846 explicit Command(const std::string& area_name);
1847
1848 ~Command() override = default;
1849
1850 bool write(yarp::os::ConnectionWriter& connection) const override;
1851 bool read(yarp::os::ConnectionReader& connection) override;
1852
1853 bool write(const yarp::os::idl::WireWriter& writer) const override;
1854 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1855 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1856
1857 bool read(yarp::os::idl::WireReader& reader) override;
1858 bool readTag(yarp::os::idl::WireReader& reader);
1859 bool readArgs(yarp::os::idl::WireReader& reader);
1860
1861 std::string area_name{};
1862 };
1863
1864 class Reply :
1866 {
1867 public:
1868 Reply() = default;
1869 ~Reply() override = default;
1870
1871 bool write(yarp::os::ConnectionWriter& connection) const override;
1872 bool read(yarp::os::ConnectionReader& connection) override;
1873
1874 bool write(const yarp::os::idl::WireWriter& writer) const override;
1875 bool read(yarp::os::idl::WireReader& reader) override;
1876
1878 };
1879
1880 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&);
1881 void call(IMap2DMsgs* ptr);
1882
1885
1886 static constexpr const char* s_tag{"delete_area_RPC"};
1887 static constexpr size_t s_tag_len{3};
1888 static constexpr size_t s_cmd_len{4};
1889 static constexpr size_t s_reply_len{1};
1890 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::delete_area_RPC(const std::string& area_name)"};
1891 static constexpr const char* s_help{""};
1892};
1893
1894// clear_all_objects_RPC helper class declaration
1896 public yarp::os::Portable
1897{
1898public:
1900 bool write(yarp::os::ConnectionWriter& connection) const override;
1901 bool read(yarp::os::ConnectionReader& connection) override;
1902
1903 class Command :
1905 {
1906 public:
1907 Command() = default;
1908 ~Command() override = default;
1909
1910 bool write(yarp::os::ConnectionWriter& connection) const override;
1911 bool read(yarp::os::ConnectionReader& connection) override;
1912
1913 bool write(const yarp::os::idl::WireWriter& writer) const override;
1914 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1915 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1916
1917 bool read(yarp::os::idl::WireReader& reader) override;
1918 bool readTag(yarp::os::idl::WireReader& reader);
1919 bool readArgs(yarp::os::idl::WireReader& reader);
1920 };
1921
1922 class Reply :
1924 {
1925 public:
1926 Reply() = default;
1927 ~Reply() override = default;
1928
1929 bool write(yarp::os::ConnectionWriter& connection) const override;
1930 bool read(yarp::os::ConnectionReader& connection) override;
1931
1932 bool write(const yarp::os::idl::WireWriter& writer) const override;
1933 bool read(yarp::os::idl::WireReader& reader) override;
1934
1936 };
1937
1939 void call(IMap2DMsgs* ptr);
1940
1943
1944 static constexpr const char* s_tag{"clear_all_objects_RPC"};
1945 static constexpr size_t s_tag_len{4};
1946 static constexpr size_t s_cmd_len{4};
1947 static constexpr size_t s_reply_len{1};
1948 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::clear_all_objects_RPC()"};
1949 static constexpr const char* s_help{""};
1950};
1951
1952// clear_all_locations_RPC helper class declaration
1954 public yarp::os::Portable
1955{
1956public:
1958 bool write(yarp::os::ConnectionWriter& connection) const override;
1959 bool read(yarp::os::ConnectionReader& connection) override;
1960
1961 class Command :
1963 {
1964 public:
1965 Command() = default;
1966 ~Command() override = default;
1967
1968 bool write(yarp::os::ConnectionWriter& connection) const override;
1969 bool read(yarp::os::ConnectionReader& connection) override;
1970
1971 bool write(const yarp::os::idl::WireWriter& writer) const override;
1972 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1973 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1974
1975 bool read(yarp::os::idl::WireReader& reader) override;
1976 bool readTag(yarp::os::idl::WireReader& reader);
1977 bool readArgs(yarp::os::idl::WireReader& reader);
1978 };
1979
1980 class Reply :
1982 {
1983 public:
1984 Reply() = default;
1985 ~Reply() override = default;
1986
1987 bool write(yarp::os::ConnectionWriter& connection) const override;
1988 bool read(yarp::os::ConnectionReader& connection) override;
1989
1990 bool write(const yarp::os::idl::WireWriter& writer) const override;
1991 bool read(yarp::os::idl::WireReader& reader) override;
1992
1994 };
1995
1997 void call(IMap2DMsgs* ptr);
1998
2001
2002 static constexpr const char* s_tag{"clear_all_locations_RPC"};
2003 static constexpr size_t s_tag_len{4};
2004 static constexpr size_t s_cmd_len{4};
2005 static constexpr size_t s_reply_len{1};
2006 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::clear_all_locations_RPC()"};
2007 static constexpr const char* s_help{""};
2008};
2009
2010// clear_all_areas_RPC helper class declaration
2012 public yarp::os::Portable
2013{
2014public:
2016 bool write(yarp::os::ConnectionWriter& connection) const override;
2017 bool read(yarp::os::ConnectionReader& connection) override;
2018
2019 class Command :
2021 {
2022 public:
2023 Command() = default;
2024 ~Command() override = default;
2025
2026 bool write(yarp::os::ConnectionWriter& connection) const override;
2027 bool read(yarp::os::ConnectionReader& connection) override;
2028
2029 bool write(const yarp::os::idl::WireWriter& writer) const override;
2030 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2031 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2032
2033 bool read(yarp::os::idl::WireReader& reader) override;
2034 bool readTag(yarp::os::idl::WireReader& reader);
2035 bool readArgs(yarp::os::idl::WireReader& reader);
2036 };
2037
2038 class Reply :
2040 {
2041 public:
2042 Reply() = default;
2043 ~Reply() override = default;
2044
2045 bool write(yarp::os::ConnectionWriter& connection) const override;
2046 bool read(yarp::os::ConnectionReader& connection) override;
2047
2048 bool write(const yarp::os::idl::WireWriter& writer) const override;
2049 bool read(yarp::os::idl::WireReader& reader) override;
2050
2052 };
2053
2055 void call(IMap2DMsgs* ptr);
2056
2059
2060 static constexpr const char* s_tag{"clear_all_areas_RPC"};
2061 static constexpr size_t s_tag_len{4};
2062 static constexpr size_t s_cmd_len{4};
2063 static constexpr size_t s_reply_len{1};
2064 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::clear_all_areas_RPC()"};
2065 static constexpr const char* s_help{""};
2066};
2067
2068// clear_all_paths_RPC helper class declaration
2070 public yarp::os::Portable
2071{
2072public:
2074 bool write(yarp::os::ConnectionWriter& connection) const override;
2075 bool read(yarp::os::ConnectionReader& connection) override;
2076
2077 class Command :
2079 {
2080 public:
2081 Command() = default;
2082 ~Command() override = default;
2083
2084 bool write(yarp::os::ConnectionWriter& connection) const override;
2085 bool read(yarp::os::ConnectionReader& connection) override;
2086
2087 bool write(const yarp::os::idl::WireWriter& writer) const override;
2088 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2089 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2090
2091 bool read(yarp::os::idl::WireReader& reader) override;
2092 bool readTag(yarp::os::idl::WireReader& reader);
2093 bool readArgs(yarp::os::idl::WireReader& reader);
2094 };
2095
2096 class Reply :
2098 {
2099 public:
2100 Reply() = default;
2101 ~Reply() override = default;
2102
2103 bool write(yarp::os::ConnectionWriter& connection) const override;
2104 bool read(yarp::os::ConnectionReader& connection) override;
2105
2106 bool write(const yarp::os::idl::WireWriter& writer) const override;
2107 bool read(yarp::os::idl::WireReader& reader) override;
2108
2110 };
2111
2113 void call(IMap2DMsgs* ptr);
2114
2117
2118 static constexpr const char* s_tag{"clear_all_paths_RPC"};
2119 static constexpr size_t s_tag_len{4};
2120 static constexpr size_t s_cmd_len{4};
2121 static constexpr size_t s_reply_len{1};
2122 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::clear_all_paths_RPC()"};
2123 static constexpr const char* s_help{""};
2124};
2125
2126// clear_all_maps_temporary_flags_RPC helper class declaration
2128 public yarp::os::Portable
2129{
2130public:
2132 bool write(yarp::os::ConnectionWriter& connection) const override;
2133 bool read(yarp::os::ConnectionReader& connection) override;
2134
2135 class Command :
2137 {
2138 public:
2139 Command() = default;
2140 ~Command() override = default;
2141
2142 bool write(yarp::os::ConnectionWriter& connection) const override;
2143 bool read(yarp::os::ConnectionReader& connection) override;
2144
2145 bool write(const yarp::os::idl::WireWriter& writer) const override;
2146 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2147 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2148
2149 bool read(yarp::os::idl::WireReader& reader) override;
2150 bool readTag(yarp::os::idl::WireReader& reader);
2151 bool readArgs(yarp::os::idl::WireReader& reader);
2152 };
2153
2154 class Reply :
2156 {
2157 public:
2158 Reply() = default;
2159 ~Reply() override = default;
2160
2161 bool write(yarp::os::ConnectionWriter& connection) const override;
2162 bool read(yarp::os::ConnectionReader& connection) override;
2163
2164 bool write(const yarp::os::idl::WireWriter& writer) const override;
2165 bool read(yarp::os::idl::WireReader& reader) override;
2166
2168 };
2169
2171 void call(IMap2DMsgs* ptr);
2172
2175
2176 static constexpr const char* s_tag{"clear_all_maps_temporary_flags_RPC"};
2177 static constexpr size_t s_tag_len{6};
2178 static constexpr size_t s_cmd_len{6};
2179 static constexpr size_t s_reply_len{1};
2180 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::clear_all_maps_temporary_flags_RPC()"};
2181 static constexpr const char* s_help{""};
2182};
2183
2184// clear_map_temporary_flags_RPC helper class declaration
2186 public yarp::os::Portable
2187{
2188public:
2190 explicit IMap2DMsgs_clear_map_temporary_flags_RPC_helper(const std::string& map_name);
2191 bool write(yarp::os::ConnectionWriter& connection) const override;
2192 bool read(yarp::os::ConnectionReader& connection) override;
2193
2194 class Command :
2196 {
2197 public:
2198 Command() = default;
2199 explicit Command(const std::string& map_name);
2200
2201 ~Command() override = default;
2202
2203 bool write(yarp::os::ConnectionWriter& connection) const override;
2204 bool read(yarp::os::ConnectionReader& connection) override;
2205
2206 bool write(const yarp::os::idl::WireWriter& writer) const override;
2207 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2208 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2209
2210 bool read(yarp::os::idl::WireReader& reader) override;
2211 bool readTag(yarp::os::idl::WireReader& reader);
2212 bool readArgs(yarp::os::idl::WireReader& reader);
2213
2214 std::string map_name{};
2215 };
2216
2217 class Reply :
2219 {
2220 public:
2221 Reply() = default;
2222 ~Reply() override = default;
2223
2224 bool write(yarp::os::ConnectionWriter& connection) const override;
2225 bool read(yarp::os::ConnectionReader& connection) override;
2226
2227 bool write(const yarp::os::idl::WireWriter& writer) const override;
2228 bool read(yarp::os::idl::WireReader& reader) override;
2229
2231 };
2232
2233 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&);
2234 void call(IMap2DMsgs* ptr);
2235
2238
2239 static constexpr const char* s_tag{"clear_map_temporary_flags_RPC"};
2240 static constexpr size_t s_tag_len{5};
2241 static constexpr size_t s_cmd_len{6};
2242 static constexpr size_t s_reply_len{1};
2243 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::clear_map_temporary_flags_RPC(const std::string& map_name)"};
2244 static constexpr const char* s_help{""};
2245};
2246
2247// save_maps_collection_RPC helper class declaration
2249 public yarp::os::Portable
2250{
2251public:
2253 explicit IMap2DMsgs_save_maps_collection_RPC_helper(const std::string& maps_collection_file);
2254 bool write(yarp::os::ConnectionWriter& connection) const override;
2255 bool read(yarp::os::ConnectionReader& connection) override;
2256
2257 class Command :
2259 {
2260 public:
2261 Command() = default;
2262 explicit Command(const std::string& maps_collection_file);
2263
2264 ~Command() override = default;
2265
2266 bool write(yarp::os::ConnectionWriter& connection) const override;
2267 bool read(yarp::os::ConnectionReader& connection) override;
2268
2269 bool write(const yarp::os::idl::WireWriter& writer) const override;
2270 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2271 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2272
2273 bool read(yarp::os::idl::WireReader& reader) override;
2274 bool readTag(yarp::os::idl::WireReader& reader);
2275 bool readArgs(yarp::os::idl::WireReader& reader);
2276
2278 };
2279
2280 class Reply :
2282 {
2283 public:
2284 Reply() = default;
2285 ~Reply() override = default;
2286
2287 bool write(yarp::os::ConnectionWriter& connection) const override;
2288 bool read(yarp::os::ConnectionReader& connection) override;
2289
2290 bool write(const yarp::os::idl::WireWriter& writer) const override;
2291 bool read(yarp::os::idl::WireReader& reader) override;
2292
2294 };
2295
2296 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&);
2297 void call(IMap2DMsgs* ptr);
2298
2301
2302 static constexpr const char* s_tag{"save_maps_collection_RPC"};
2303 static constexpr size_t s_tag_len{4};
2304 static constexpr size_t s_cmd_len{5};
2305 static constexpr size_t s_reply_len{1};
2306 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::save_maps_collection_RPC(const std::string& maps_collection_file)"};
2307 static constexpr const char* s_help{""};
2308};
2309
2310// load_maps_collection_RPC helper class declaration
2312 public yarp::os::Portable
2313{
2314public:
2316 explicit IMap2DMsgs_load_maps_collection_RPC_helper(const std::string& maps_collection_file);
2317 bool write(yarp::os::ConnectionWriter& connection) const override;
2318 bool read(yarp::os::ConnectionReader& connection) override;
2319
2320 class Command :
2322 {
2323 public:
2324 Command() = default;
2325 explicit Command(const std::string& maps_collection_file);
2326
2327 ~Command() override = default;
2328
2329 bool write(yarp::os::ConnectionWriter& connection) const override;
2330 bool read(yarp::os::ConnectionReader& connection) override;
2331
2332 bool write(const yarp::os::idl::WireWriter& writer) const override;
2333 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2334 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2335
2336 bool read(yarp::os::idl::WireReader& reader) override;
2337 bool readTag(yarp::os::idl::WireReader& reader);
2338 bool readArgs(yarp::os::idl::WireReader& reader);
2339
2341 };
2342
2343 class Reply :
2345 {
2346 public:
2347 Reply() = default;
2348 ~Reply() override = default;
2349
2350 bool write(yarp::os::ConnectionWriter& connection) const override;
2351 bool read(yarp::os::ConnectionReader& connection) override;
2352
2353 bool write(const yarp::os::idl::WireWriter& writer) const override;
2354 bool read(yarp::os::idl::WireReader& reader) override;
2355
2357 };
2358
2359 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&);
2360 void call(IMap2DMsgs* ptr);
2361
2364
2365 static constexpr const char* s_tag{"load_maps_collection_RPC"};
2366 static constexpr size_t s_tag_len{4};
2367 static constexpr size_t s_cmd_len{5};
2368 static constexpr size_t s_reply_len{1};
2369 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::load_maps_collection_RPC(const std::string& maps_collection_file)"};
2370 static constexpr const char* s_help{""};
2371};
2372
2373// save_locations_and_extras_RPC helper class declaration
2375 public yarp::os::Portable
2376{
2377public:
2379 explicit IMap2DMsgs_save_locations_and_extras_RPC_helper(const std::string& locations_collection_file);
2380 bool write(yarp::os::ConnectionWriter& connection) const override;
2381 bool read(yarp::os::ConnectionReader& connection) override;
2382
2383 class Command :
2385 {
2386 public:
2387 Command() = default;
2388 explicit Command(const std::string& locations_collection_file);
2389
2390 ~Command() override = default;
2391
2392 bool write(yarp::os::ConnectionWriter& connection) const override;
2393 bool read(yarp::os::ConnectionReader& connection) override;
2394
2395 bool write(const yarp::os::idl::WireWriter& writer) const override;
2396 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2397 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2398
2399 bool read(yarp::os::idl::WireReader& reader) override;
2400 bool readTag(yarp::os::idl::WireReader& reader);
2401 bool readArgs(yarp::os::idl::WireReader& reader);
2402
2404 };
2405
2406 class Reply :
2408 {
2409 public:
2410 Reply() = default;
2411 ~Reply() override = default;
2412
2413 bool write(yarp::os::ConnectionWriter& connection) const override;
2414 bool read(yarp::os::ConnectionReader& connection) override;
2415
2416 bool write(const yarp::os::idl::WireWriter& writer) const override;
2417 bool read(yarp::os::idl::WireReader& reader) override;
2418
2420 };
2421
2422 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&);
2423 void call(IMap2DMsgs* ptr);
2424
2427
2428 static constexpr const char* s_tag{"save_locations_and_extras_RPC"};
2429 static constexpr size_t s_tag_len{5};
2430 static constexpr size_t s_cmd_len{6};
2431 static constexpr size_t s_reply_len{1};
2432 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::save_locations_and_extras_RPC(const std::string& locations_collection_file)"};
2433 static constexpr const char* s_help{""};
2434};
2435
2436// load_locations_and_extras_RPC helper class declaration
2438 public yarp::os::Portable
2439{
2440public:
2442 explicit IMap2DMsgs_load_locations_and_extras_RPC_helper(const std::string& locations_collection_file);
2443 bool write(yarp::os::ConnectionWriter& connection) const override;
2444 bool read(yarp::os::ConnectionReader& connection) override;
2445
2446 class Command :
2448 {
2449 public:
2450 Command() = default;
2451 explicit Command(const std::string& locations_collection_file);
2452
2453 ~Command() override = default;
2454
2455 bool write(yarp::os::ConnectionWriter& connection) const override;
2456 bool read(yarp::os::ConnectionReader& connection) override;
2457
2458 bool write(const yarp::os::idl::WireWriter& writer) const override;
2459 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2460 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2461
2462 bool read(yarp::os::idl::WireReader& reader) override;
2463 bool readTag(yarp::os::idl::WireReader& reader);
2464 bool readArgs(yarp::os::idl::WireReader& reader);
2465
2467 };
2468
2469 class Reply :
2471 {
2472 public:
2473 Reply() = default;
2474 ~Reply() override = default;
2475
2476 bool write(yarp::os::ConnectionWriter& connection) const override;
2477 bool read(yarp::os::ConnectionReader& connection) override;
2478
2479 bool write(const yarp::os::idl::WireWriter& writer) const override;
2480 bool read(yarp::os::idl::WireReader& reader) override;
2481
2483 };
2484
2485 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&);
2486 void call(IMap2DMsgs* ptr);
2487
2490
2491 static constexpr const char* s_tag{"load_locations_and_extras_RPC"};
2492 static constexpr size_t s_tag_len{5};
2493 static constexpr size_t s_cmd_len{6};
2494 static constexpr size_t s_reply_len{1};
2495 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::load_locations_and_extras_RPC(const std::string& locations_collection_file)"};
2496 static constexpr const char* s_help{""};
2497};
2498
2499// save_map_to_disk_RPC helper class declaration
2501 public yarp::os::Portable
2502{
2503public:
2505 IMap2DMsgs_save_map_to_disk_RPC_helper(const std::string& map_name, const std::string& file_name);
2506 bool write(yarp::os::ConnectionWriter& connection) const override;
2507 bool read(yarp::os::ConnectionReader& connection) override;
2508
2509 class Command :
2511 {
2512 public:
2513 Command() = default;
2514 Command(const std::string& map_name, const std::string& file_name);
2515
2516 ~Command() override = default;
2517
2518 bool write(yarp::os::ConnectionWriter& connection) const override;
2519 bool read(yarp::os::ConnectionReader& connection) override;
2520
2521 bool write(const yarp::os::idl::WireWriter& writer) const override;
2522 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2523 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2524
2525 bool read(yarp::os::idl::WireReader& reader) override;
2526 bool readTag(yarp::os::idl::WireReader& reader);
2527 bool readArgs(yarp::os::idl::WireReader& reader);
2528
2529 std::string map_name{};
2530 std::string file_name{};
2531 };
2532
2533 class Reply :
2535 {
2536 public:
2537 Reply() = default;
2538 ~Reply() override = default;
2539
2540 bool write(yarp::os::ConnectionWriter& connection) const override;
2541 bool read(yarp::os::ConnectionReader& connection) override;
2542
2543 bool write(const yarp::os::idl::WireWriter& writer) const override;
2544 bool read(yarp::os::idl::WireReader& reader) override;
2545
2547 };
2548
2549 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&, const std::string&);
2550 void call(IMap2DMsgs* ptr);
2551
2554
2555 static constexpr const char* s_tag{"save_map_to_disk_RPC"};
2556 static constexpr size_t s_tag_len{5};
2557 static constexpr size_t s_cmd_len{7};
2558 static constexpr size_t s_reply_len{1};
2559 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)"};
2560 static constexpr const char* s_help{""};
2561};
2562
2563// load_map_from_disk_RPC helper class declaration
2565 public yarp::os::Portable
2566{
2567public:
2569 explicit IMap2DMsgs_load_map_from_disk_RPC_helper(const std::string& file_name);
2570 bool write(yarp::os::ConnectionWriter& connection) const override;
2571 bool read(yarp::os::ConnectionReader& connection) override;
2572
2573 class Command :
2575 {
2576 public:
2577 Command() = default;
2578 explicit Command(const std::string& file_name);
2579
2580 ~Command() override = default;
2581
2582 bool write(yarp::os::ConnectionWriter& connection) const override;
2583 bool read(yarp::os::ConnectionReader& connection) override;
2584
2585 bool write(const yarp::os::idl::WireWriter& writer) const override;
2586 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2587 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2588
2589 bool read(yarp::os::idl::WireReader& reader) override;
2590 bool readTag(yarp::os::idl::WireReader& reader);
2591 bool readArgs(yarp::os::idl::WireReader& reader);
2592
2593 std::string file_name{};
2594 };
2595
2596 class Reply :
2598 {
2599 public:
2600 Reply() = default;
2601 ~Reply() override = default;
2602
2603 bool write(yarp::os::ConnectionWriter& connection) const override;
2604 bool read(yarp::os::ConnectionReader& connection) override;
2605
2606 bool write(const yarp::os::idl::WireWriter& writer) const override;
2607 bool read(yarp::os::idl::WireReader& reader) override;
2608
2610 };
2611
2612 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&);
2613 void call(IMap2DMsgs* ptr);
2614
2617
2618 static constexpr const char* s_tag{"load_map_from_disk_RPC"};
2619 static constexpr size_t s_tag_len{5};
2620 static constexpr size_t s_cmd_len{6};
2621 static constexpr size_t s_reply_len{1};
2622 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::load_map_from_disk_RPC(const std::string& file_name)"};
2623 static constexpr const char* s_help{""};
2624};
2625
2626// enable_maps_compression_RPC helper class declaration
2628 public yarp::os::Portable
2629{
2630public:
2632 explicit IMap2DMsgs_enable_maps_compression_RPC_helper(const bool enable_compression);
2633 bool write(yarp::os::ConnectionWriter& connection) const override;
2634 bool read(yarp::os::ConnectionReader& connection) override;
2635
2636 class Command :
2638 {
2639 public:
2640 Command() = default;
2641 explicit Command(const bool enable_compression);
2642
2643 ~Command() override = default;
2644
2645 bool write(yarp::os::ConnectionWriter& connection) const override;
2646 bool read(yarp::os::ConnectionReader& connection) override;
2647
2648 bool write(const yarp::os::idl::WireWriter& writer) const override;
2649 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2650 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2651
2652 bool read(yarp::os::idl::WireReader& reader) override;
2653 bool readTag(yarp::os::idl::WireReader& reader);
2654 bool readArgs(yarp::os::idl::WireReader& reader);
2655
2657 };
2658
2659 class Reply :
2661 {
2662 public:
2663 Reply() = default;
2664 ~Reply() override = default;
2665
2666 bool write(yarp::os::ConnectionWriter& connection) const override;
2667 bool read(yarp::os::ConnectionReader& connection) override;
2668
2669 bool write(const yarp::os::idl::WireWriter& writer) const override;
2670 bool read(yarp::os::idl::WireReader& reader) override;
2671
2673 };
2674
2675 using funcptr_t = yarp::dev::ReturnValue (*)(const bool);
2676 void call(IMap2DMsgs* ptr);
2677
2680
2681 static constexpr const char* s_tag{"enable_maps_compression_RPC"};
2682 static constexpr size_t s_tag_len{4};
2683 static constexpr size_t s_cmd_len{5};
2684 static constexpr size_t s_reply_len{1};
2685 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::enable_maps_compression_RPC(const bool enable_compression)"};
2686 static constexpr const char* s_help{""};
2687};
2688
2689// reload_maps_collection_RPC helper class declaration
2691 public yarp::os::Portable
2692{
2693public:
2695 bool write(yarp::os::ConnectionWriter& connection) const override;
2696 bool read(yarp::os::ConnectionReader& connection) override;
2697
2698 class Command :
2700 {
2701 public:
2702 Command() = default;
2703 ~Command() override = default;
2704
2705 bool write(yarp::os::ConnectionWriter& connection) const override;
2706 bool read(yarp::os::ConnectionReader& connection) override;
2707
2708 bool write(const yarp::os::idl::WireWriter& writer) const override;
2709 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2710 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2711
2712 bool read(yarp::os::idl::WireReader& reader) override;
2713 bool readTag(yarp::os::idl::WireReader& reader);
2714 bool readArgs(yarp::os::idl::WireReader& reader);
2715 };
2716
2717 class Reply :
2719 {
2720 public:
2721 Reply() = default;
2722 ~Reply() override = default;
2723
2724 bool write(yarp::os::ConnectionWriter& connection) const override;
2725 bool read(yarp::os::ConnectionReader& connection) override;
2726
2727 bool write(const yarp::os::idl::WireWriter& writer) const override;
2728 bool read(yarp::os::idl::WireReader& reader) override;
2729
2731 };
2732
2734 void call(IMap2DMsgs* ptr);
2735
2738
2739 static constexpr const char* s_tag{"reload_maps_collection_RPC"};
2740 static constexpr size_t s_tag_len{4};
2741 static constexpr size_t s_cmd_len{4};
2742 static constexpr size_t s_reply_len{1};
2743 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::reload_maps_collection_RPC()"};
2744 static constexpr const char* s_help{""};
2745};
2746
2747// reload_locations_and_extras_RPC helper class declaration
2749 public yarp::os::Portable
2750{
2751public:
2753 bool write(yarp::os::ConnectionWriter& connection) const override;
2754 bool read(yarp::os::ConnectionReader& connection) override;
2755
2756 class Command :
2758 {
2759 public:
2760 Command() = default;
2761 ~Command() override = default;
2762
2763 bool write(yarp::os::ConnectionWriter& connection) const override;
2764 bool read(yarp::os::ConnectionReader& connection) override;
2765
2766 bool write(const yarp::os::idl::WireWriter& writer) const override;
2767 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2768 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2769
2770 bool read(yarp::os::idl::WireReader& reader) override;
2771 bool readTag(yarp::os::idl::WireReader& reader);
2772 bool readArgs(yarp::os::idl::WireReader& reader);
2773 };
2774
2775 class Reply :
2777 {
2778 public:
2779 Reply() = default;
2780 ~Reply() override = default;
2781
2782 bool write(yarp::os::ConnectionWriter& connection) const override;
2783 bool read(yarp::os::ConnectionReader& connection) override;
2784
2785 bool write(const yarp::os::idl::WireWriter& writer) const override;
2786 bool read(yarp::os::idl::WireReader& reader) override;
2787
2789 };
2790
2792 void call(IMap2DMsgs* ptr);
2793
2796
2797 static constexpr const char* s_tag{"reload_locations_and_extras_RPC"};
2798 static constexpr size_t s_tag_len{5};
2799 static constexpr size_t s_cmd_len{5};
2800 static constexpr size_t s_reply_len{1};
2801 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::reload_locations_and_extras_RPC()"};
2802 static constexpr const char* s_help{""};
2803};
2804
2805// clear_all_maps_RPC helper class implementation
2807{
2808 return cmd.write(connection);
2809}
2810
2812{
2813 return reply.read(connection);
2814}
2815
2817{
2818 yarp::os::idl::WireWriter writer(connection);
2819 if (!writer.writeListHeader(s_cmd_len)) {
2820 return false;
2821 }
2822 return write(writer);
2823}
2824
2826{
2827 yarp::os::idl::WireReader reader(connection);
2828 if (!reader.readListHeader()) {
2829 reader.fail();
2830 return false;
2831 }
2832 return read(reader);
2833}
2834
2836{
2837 if (!writeTag(writer)) {
2838 return false;
2839 }
2840 if (!writeArgs(writer)) {
2841 return false;
2842 }
2843 return true;
2844}
2845
2847{
2848 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2849 return false;
2850 }
2851 return true;
2852}
2853
2855{
2856 return true;
2857}
2858
2860{
2861 if (!readTag(reader)) {
2862 return false;
2863 }
2864 if (!readArgs(reader)) {
2865 return false;
2866 }
2867 return true;
2868}
2869
2871{
2872 std::string tag = reader.readTag(s_tag_len);
2873 if (reader.isError()) {
2874 return false;
2875 }
2876 if (tag != s_tag) {
2877 reader.fail();
2878 return false;
2879 }
2880 return true;
2881}
2882
2884{
2885 if (!reader.noMore()) {
2886 reader.fail();
2887 return false;
2888 }
2889 return true;
2890}
2891
2893{
2894 yarp::os::idl::WireWriter writer(connection);
2895 return write(writer);
2896}
2897
2899{
2900 yarp::os::idl::WireReader reader(connection);
2901 return read(reader);
2902}
2903
2905{
2906 if (!writer.isNull()) {
2907 if (!writer.write(return_helper)) {
2908 return false;
2909 }
2910 }
2911 return true;
2912}
2913
2915{
2916 if (reader.noMore()) {
2917 reader.fail();
2918 return false;
2919 }
2920 if (!reader.read(return_helper)) {
2921 reader.fail();
2922 return false;
2923 }
2924 return true;
2925}
2926
2931
2932// store_map_RPC helper class implementation
2937
2939{
2940 return cmd.write(connection);
2941}
2942
2944{
2945 return reply.read(connection);
2946}
2947
2952
2954{
2955 yarp::os::idl::WireWriter writer(connection);
2956 if (!writer.writeListHeader(s_cmd_len)) {
2957 return false;
2958 }
2959 return write(writer);
2960}
2961
2963{
2964 yarp::os::idl::WireReader reader(connection);
2965 if (!reader.readListHeader()) {
2966 reader.fail();
2967 return false;
2968 }
2969 return read(reader);
2970}
2971
2973{
2974 if (!writeTag(writer)) {
2975 return false;
2976 }
2977 if (!writeArgs(writer)) {
2978 return false;
2979 }
2980 return true;
2981}
2982
2984{
2985 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2986 return false;
2987 }
2988 return true;
2989}
2990
2992{
2993 if (!writer.writeNested(themap)) {
2994 return false;
2995 }
2996 return true;
2997}
2998
3000{
3001 if (!readTag(reader)) {
3002 return false;
3003 }
3004 if (!readArgs(reader)) {
3005 return false;
3006 }
3007 return true;
3008}
3009
3011{
3012 std::string tag = reader.readTag(s_tag_len);
3013 if (reader.isError()) {
3014 return false;
3015 }
3016 if (tag != s_tag) {
3017 reader.fail();
3018 return false;
3019 }
3020 return true;
3021}
3022
3024{
3025 if (reader.noMore()) {
3026 reader.fail();
3027 return false;
3028 }
3029 if (!reader.readNested(themap)) {
3030 reader.fail();
3031 return false;
3032 }
3033 if (!reader.noMore()) {
3034 reader.fail();
3035 return false;
3036 }
3037 return true;
3038}
3039
3041{
3042 yarp::os::idl::WireWriter writer(connection);
3043 return write(writer);
3044}
3045
3047{
3048 yarp::os::idl::WireReader reader(connection);
3049 return read(reader);
3050}
3051
3053{
3054 if (!writer.isNull()) {
3055 if (!writer.write(return_helper)) {
3056 return false;
3057 }
3058 }
3059 return true;
3060}
3061
3063{
3064 if (reader.noMore()) {
3065 reader.fail();
3066 return false;
3067 }
3068 if (!reader.read(return_helper)) {
3069 reader.fail();
3070 return false;
3071 }
3072 return true;
3073}
3074
3079
3080// get_map_RPC helper class implementation
3082 cmd{map_name}
3083{
3084}
3085
3087{
3088 return cmd.write(connection);
3089}
3090
3092{
3093 return reply.read(connection);
3094}
3095
3097 map_name{map_name}
3098{
3099}
3100
3102{
3103 yarp::os::idl::WireWriter writer(connection);
3104 if (!writer.writeListHeader(s_cmd_len)) {
3105 return false;
3106 }
3107 return write(writer);
3108}
3109
3111{
3112 yarp::os::idl::WireReader reader(connection);
3113 if (!reader.readListHeader()) {
3114 reader.fail();
3115 return false;
3116 }
3117 return read(reader);
3118}
3119
3121{
3122 if (!writeTag(writer)) {
3123 return false;
3124 }
3125 if (!writeArgs(writer)) {
3126 return false;
3127 }
3128 return true;
3129}
3130
3132{
3133 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3134 return false;
3135 }
3136 return true;
3137}
3138
3140{
3141 if (!writer.writeString(map_name)) {
3142 return false;
3143 }
3144 return true;
3145}
3146
3148{
3149 if (!readTag(reader)) {
3150 return false;
3151 }
3152 if (!readArgs(reader)) {
3153 return false;
3154 }
3155 return true;
3156}
3157
3159{
3160 std::string tag = reader.readTag(s_tag_len);
3161 if (reader.isError()) {
3162 return false;
3163 }
3164 if (tag != s_tag) {
3165 reader.fail();
3166 return false;
3167 }
3168 return true;
3169}
3170
3172{
3173 if (reader.noMore()) {
3174 reader.fail();
3175 return false;
3176 }
3177 if (!reader.readString(map_name)) {
3178 reader.fail();
3179 return false;
3180 }
3181 if (!reader.noMore()) {
3182 reader.fail();
3183 return false;
3184 }
3185 return true;
3186}
3187
3189{
3190 yarp::os::idl::WireWriter writer(connection);
3191 return write(writer);
3192}
3193
3195{
3196 yarp::os::idl::WireReader reader(connection);
3197 return read(reader);
3198}
3199
3201{
3202 if (!writer.isNull()) {
3203 if (!writer.writeListHeader(s_reply_len)) {
3204 return false;
3205 }
3206 if (!writer.write(return_helper)) {
3207 return false;
3208 }
3209 }
3210 return true;
3211}
3212
3214{
3215 if (!reader.readListReturn()) {
3216 return false;
3217 }
3218 if (reader.noMore()) {
3219 reader.fail();
3220 return false;
3221 }
3222 if (!reader.read(return_helper)) {
3223 reader.fail();
3224 return false;
3225 }
3226 return true;
3227}
3228
3233
3234// get_map_names_RPC helper class implementation
3236{
3237 return cmd.write(connection);
3238}
3239
3241{
3242 return reply.read(connection);
3243}
3244
3246{
3247 yarp::os::idl::WireWriter writer(connection);
3248 if (!writer.writeListHeader(s_cmd_len)) {
3249 return false;
3250 }
3251 return write(writer);
3252}
3253
3255{
3256 yarp::os::idl::WireReader reader(connection);
3257 if (!reader.readListHeader()) {
3258 reader.fail();
3259 return false;
3260 }
3261 return read(reader);
3262}
3263
3265{
3266 if (!writeTag(writer)) {
3267 return false;
3268 }
3269 if (!writeArgs(writer)) {
3270 return false;
3271 }
3272 return true;
3273}
3274
3276{
3277 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3278 return false;
3279 }
3280 return true;
3281}
3282
3284{
3285 return true;
3286}
3287
3289{
3290 if (!readTag(reader)) {
3291 return false;
3292 }
3293 if (!readArgs(reader)) {
3294 return false;
3295 }
3296 return true;
3297}
3298
3300{
3301 std::string tag = reader.readTag(s_tag_len);
3302 if (reader.isError()) {
3303 return false;
3304 }
3305 if (tag != s_tag) {
3306 reader.fail();
3307 return false;
3308 }
3309 return true;
3310}
3311
3313{
3314 if (!reader.noMore()) {
3315 reader.fail();
3316 return false;
3317 }
3318 return true;
3319}
3320
3322{
3323 yarp::os::idl::WireWriter writer(connection);
3324 return write(writer);
3325}
3326
3328{
3329 yarp::os::idl::WireReader reader(connection);
3330 return read(reader);
3331}
3332
3334{
3335 if (!writer.isNull()) {
3336 if (!writer.writeListHeader(s_reply_len)) {
3337 return false;
3338 }
3339 if (!writer.write(return_helper)) {
3340 return false;
3341 }
3342 }
3343 return true;
3344}
3345
3347{
3348 if (!reader.readListReturn()) {
3349 return false;
3350 }
3351 if (reader.noMore()) {
3352 reader.fail();
3353 return false;
3354 }
3355 if (!reader.read(return_helper)) {
3356 reader.fail();
3357 return false;
3358 }
3359 return true;
3360}
3361
3366
3367// remove_map_RPC helper class implementation
3369 cmd{map_name}
3370{
3371}
3372
3374{
3375 return cmd.write(connection);
3376}
3377
3379{
3380 return reply.read(connection);
3381}
3382
3384 map_name{map_name}
3385{
3386}
3387
3389{
3390 yarp::os::idl::WireWriter writer(connection);
3391 if (!writer.writeListHeader(s_cmd_len)) {
3392 return false;
3393 }
3394 return write(writer);
3395}
3396
3398{
3399 yarp::os::idl::WireReader reader(connection);
3400 if (!reader.readListHeader()) {
3401 reader.fail();
3402 return false;
3403 }
3404 return read(reader);
3405}
3406
3408{
3409 if (!writeTag(writer)) {
3410 return false;
3411 }
3412 if (!writeArgs(writer)) {
3413 return false;
3414 }
3415 return true;
3416}
3417
3419{
3420 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3421 return false;
3422 }
3423 return true;
3424}
3425
3427{
3428 if (!writer.writeString(map_name)) {
3429 return false;
3430 }
3431 return true;
3432}
3433
3435{
3436 if (!readTag(reader)) {
3437 return false;
3438 }
3439 if (!readArgs(reader)) {
3440 return false;
3441 }
3442 return true;
3443}
3444
3446{
3447 std::string tag = reader.readTag(s_tag_len);
3448 if (reader.isError()) {
3449 return false;
3450 }
3451 if (tag != s_tag) {
3452 reader.fail();
3453 return false;
3454 }
3455 return true;
3456}
3457
3459{
3460 if (reader.noMore()) {
3461 reader.fail();
3462 return false;
3463 }
3464 if (!reader.readString(map_name)) {
3465 reader.fail();
3466 return false;
3467 }
3468 if (!reader.noMore()) {
3469 reader.fail();
3470 return false;
3471 }
3472 return true;
3473}
3474
3476{
3477 yarp::os::idl::WireWriter writer(connection);
3478 return write(writer);
3479}
3480
3482{
3483 yarp::os::idl::WireReader reader(connection);
3484 return read(reader);
3485}
3486
3488{
3489 if (!writer.isNull()) {
3490 if (!writer.write(return_helper)) {
3491 return false;
3492 }
3493 }
3494 return true;
3495}
3496
3498{
3499 if (reader.noMore()) {
3500 reader.fail();
3501 return false;
3502 }
3503 if (!reader.read(return_helper)) {
3504 reader.fail();
3505 return false;
3506 }
3507 return true;
3508}
3509
3514
3515// store_object_RPC helper class implementation
3517 cmd{object_name, loc}
3518{
3519}
3520
3522{
3523 return cmd.write(connection);
3524}
3525
3527{
3528 return reply.read(connection);
3529}
3530
3532 object_name{object_name},
3533 loc{loc}
3534{
3535}
3536
3538{
3539 yarp::os::idl::WireWriter writer(connection);
3540 if (!writer.writeListHeader(s_cmd_len)) {
3541 return false;
3542 }
3543 return write(writer);
3544}
3545
3547{
3548 yarp::os::idl::WireReader reader(connection);
3549 if (!reader.readListHeader()) {
3550 reader.fail();
3551 return false;
3552 }
3553 return read(reader);
3554}
3555
3557{
3558 if (!writeTag(writer)) {
3559 return false;
3560 }
3561 if (!writeArgs(writer)) {
3562 return false;
3563 }
3564 return true;
3565}
3566
3568{
3569 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3570 return false;
3571 }
3572 return true;
3573}
3574
3576{
3577 if (!writer.writeString(object_name)) {
3578 return false;
3579 }
3580 if (!writer.writeNested(loc)) {
3581 return false;
3582 }
3583 return true;
3584}
3585
3587{
3588 if (!readTag(reader)) {
3589 return false;
3590 }
3591 if (!readArgs(reader)) {
3592 return false;
3593 }
3594 return true;
3595}
3596
3598{
3599 std::string tag = reader.readTag(s_tag_len);
3600 if (reader.isError()) {
3601 return false;
3602 }
3603 if (tag != s_tag) {
3604 reader.fail();
3605 return false;
3606 }
3607 return true;
3608}
3609
3611{
3612 if (reader.noMore()) {
3613 reader.fail();
3614 return false;
3615 }
3616 if (!reader.readString(object_name)) {
3617 reader.fail();
3618 return false;
3619 }
3620 if (reader.noMore()) {
3621 reader.fail();
3622 return false;
3623 }
3624 if (!reader.readNested(loc)) {
3625 reader.fail();
3626 return false;
3627 }
3628 if (!reader.noMore()) {
3629 reader.fail();
3630 return false;
3631 }
3632 return true;
3633}
3634
3636{
3637 yarp::os::idl::WireWriter writer(connection);
3638 return write(writer);
3639}
3640
3642{
3643 yarp::os::idl::WireReader reader(connection);
3644 return read(reader);
3645}
3646
3648{
3649 if (!writer.isNull()) {
3650 if (!writer.write(return_helper)) {
3651 return false;
3652 }
3653 }
3654 return true;
3655}
3656
3658{
3659 if (reader.noMore()) {
3660 reader.fail();
3661 return false;
3662 }
3663 if (!reader.read(return_helper)) {
3664 reader.fail();
3665 return false;
3666 }
3667 return true;
3668}
3669
3674
3675// store_location_RPC helper class implementation
3677 cmd{location_name, loc}
3678{
3679}
3680
3682{
3683 return cmd.write(connection);
3684}
3685
3687{
3688 return reply.read(connection);
3689}
3690
3692 location_name{location_name},
3693 loc{loc}
3694{
3695}
3696
3698{
3699 yarp::os::idl::WireWriter writer(connection);
3700 if (!writer.writeListHeader(s_cmd_len)) {
3701 return false;
3702 }
3703 return write(writer);
3704}
3705
3707{
3708 yarp::os::idl::WireReader reader(connection);
3709 if (!reader.readListHeader()) {
3710 reader.fail();
3711 return false;
3712 }
3713 return read(reader);
3714}
3715
3717{
3718 if (!writeTag(writer)) {
3719 return false;
3720 }
3721 if (!writeArgs(writer)) {
3722 return false;
3723 }
3724 return true;
3725}
3726
3728{
3729 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3730 return false;
3731 }
3732 return true;
3733}
3734
3736{
3737 if (!writer.writeString(location_name)) {
3738 return false;
3739 }
3740 if (!writer.writeNested(loc)) {
3741 return false;
3742 }
3743 return true;
3744}
3745
3747{
3748 if (!readTag(reader)) {
3749 return false;
3750 }
3751 if (!readArgs(reader)) {
3752 return false;
3753 }
3754 return true;
3755}
3756
3758{
3759 std::string tag = reader.readTag(s_tag_len);
3760 if (reader.isError()) {
3761 return false;
3762 }
3763 if (tag != s_tag) {
3764 reader.fail();
3765 return false;
3766 }
3767 return true;
3768}
3769
3771{
3772 if (reader.noMore()) {
3773 reader.fail();
3774 return false;
3775 }
3776 if (!reader.readString(location_name)) {
3777 reader.fail();
3778 return false;
3779 }
3780 if (reader.noMore()) {
3781 reader.fail();
3782 return false;
3783 }
3784 if (!reader.readNested(loc)) {
3785 reader.fail();
3786 return false;
3787 }
3788 if (!reader.noMore()) {
3789 reader.fail();
3790 return false;
3791 }
3792 return true;
3793}
3794
3796{
3797 yarp::os::idl::WireWriter writer(connection);
3798 return write(writer);
3799}
3800
3802{
3803 yarp::os::idl::WireReader reader(connection);
3804 return read(reader);
3805}
3806
3808{
3809 if (!writer.isNull()) {
3810 if (!writer.write(return_helper)) {
3811 return false;
3812 }
3813 }
3814 return true;
3815}
3816
3818{
3819 if (reader.noMore()) {
3820 reader.fail();
3821 return false;
3822 }
3823 if (!reader.read(return_helper)) {
3824 reader.fail();
3825 return false;
3826 }
3827 return true;
3828}
3829
3834
3835// store_area_RPC helper class implementation
3837 cmd{area_name, area}
3838{
3839}
3840
3842{
3843 return cmd.write(connection);
3844}
3845
3847{
3848 return reply.read(connection);
3849}
3850
3852 area_name{area_name},
3853 area{area}
3854{
3855}
3856
3858{
3859 yarp::os::idl::WireWriter writer(connection);
3860 if (!writer.writeListHeader(s_cmd_len)) {
3861 return false;
3862 }
3863 return write(writer);
3864}
3865
3867{
3868 yarp::os::idl::WireReader reader(connection);
3869 if (!reader.readListHeader()) {
3870 reader.fail();
3871 return false;
3872 }
3873 return read(reader);
3874}
3875
3877{
3878 if (!writeTag(writer)) {
3879 return false;
3880 }
3881 if (!writeArgs(writer)) {
3882 return false;
3883 }
3884 return true;
3885}
3886
3888{
3889 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3890 return false;
3891 }
3892 return true;
3893}
3894
3896{
3897 if (!writer.writeString(area_name)) {
3898 return false;
3899 }
3900 if (!writer.writeNested(area)) {
3901 return false;
3902 }
3903 return true;
3904}
3905
3907{
3908 if (!readTag(reader)) {
3909 return false;
3910 }
3911 if (!readArgs(reader)) {
3912 return false;
3913 }
3914 return true;
3915}
3916
3918{
3919 std::string tag = reader.readTag(s_tag_len);
3920 if (reader.isError()) {
3921 return false;
3922 }
3923 if (tag != s_tag) {
3924 reader.fail();
3925 return false;
3926 }
3927 return true;
3928}
3929
3931{
3932 if (reader.noMore()) {
3933 reader.fail();
3934 return false;
3935 }
3936 if (!reader.readString(area_name)) {
3937 reader.fail();
3938 return false;
3939 }
3940 if (reader.noMore()) {
3941 reader.fail();
3942 return false;
3943 }
3944 if (!reader.readNested(area)) {
3945 reader.fail();
3946 return false;
3947 }
3948 if (!reader.noMore()) {
3949 reader.fail();
3950 return false;
3951 }
3952 return true;
3953}
3954
3956{
3957 yarp::os::idl::WireWriter writer(connection);
3958 return write(writer);
3959}
3960
3962{
3963 yarp::os::idl::WireReader reader(connection);
3964 return read(reader);
3965}
3966
3968{
3969 if (!writer.isNull()) {
3970 if (!writer.write(return_helper)) {
3971 return false;
3972 }
3973 }
3974 return true;
3975}
3976
3978{
3979 if (reader.noMore()) {
3980 reader.fail();
3981 return false;
3982 }
3983 if (!reader.read(return_helper)) {
3984 reader.fail();
3985 return false;
3986 }
3987 return true;
3988}
3989
3994
3995// store_path_RPC helper class implementation
3997 cmd{path_name, path}
3998{
3999}
4000
4002{
4003 return cmd.write(connection);
4004}
4005
4007{
4008 return reply.read(connection);
4009}
4010
4012 path_name{path_name},
4013 path{path}
4014{
4015}
4016
4018{
4019 yarp::os::idl::WireWriter writer(connection);
4020 if (!writer.writeListHeader(s_cmd_len)) {
4021 return false;
4022 }
4023 return write(writer);
4024}
4025
4027{
4028 yarp::os::idl::WireReader reader(connection);
4029 if (!reader.readListHeader()) {
4030 reader.fail();
4031 return false;
4032 }
4033 return read(reader);
4034}
4035
4037{
4038 if (!writeTag(writer)) {
4039 return false;
4040 }
4041 if (!writeArgs(writer)) {
4042 return false;
4043 }
4044 return true;
4045}
4046
4048{
4049 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4050 return false;
4051 }
4052 return true;
4053}
4054
4056{
4057 if (!writer.writeString(path_name)) {
4058 return false;
4059 }
4060 if (!writer.writeNested(path)) {
4061 return false;
4062 }
4063 return true;
4064}
4065
4067{
4068 if (!readTag(reader)) {
4069 return false;
4070 }
4071 if (!readArgs(reader)) {
4072 return false;
4073 }
4074 return true;
4075}
4076
4078{
4079 std::string tag = reader.readTag(s_tag_len);
4080 if (reader.isError()) {
4081 return false;
4082 }
4083 if (tag != s_tag) {
4084 reader.fail();
4085 return false;
4086 }
4087 return true;
4088}
4089
4091{
4092 if (reader.noMore()) {
4093 reader.fail();
4094 return false;
4095 }
4096 if (!reader.readString(path_name)) {
4097 reader.fail();
4098 return false;
4099 }
4100 if (reader.noMore()) {
4101 reader.fail();
4102 return false;
4103 }
4104 if (!reader.readNested(path)) {
4105 reader.fail();
4106 return false;
4107 }
4108 if (!reader.noMore()) {
4109 reader.fail();
4110 return false;
4111 }
4112 return true;
4113}
4114
4116{
4117 yarp::os::idl::WireWriter writer(connection);
4118 return write(writer);
4119}
4120
4122{
4123 yarp::os::idl::WireReader reader(connection);
4124 return read(reader);
4125}
4126
4128{
4129 if (!writer.isNull()) {
4130 if (!writer.write(return_helper)) {
4131 return false;
4132 }
4133 }
4134 return true;
4135}
4136
4138{
4139 if (reader.noMore()) {
4140 reader.fail();
4141 return false;
4142 }
4143 if (!reader.read(return_helper)) {
4144 reader.fail();
4145 return false;
4146 }
4147 return true;
4148}
4149
4154
4155// get_object_RPC helper class implementation
4157 cmd{object_name}
4158{
4159}
4160
4162{
4163 return cmd.write(connection);
4164}
4165
4167{
4168 return reply.read(connection);
4169}
4170
4172 object_name{object_name}
4173{
4174}
4175
4177{
4178 yarp::os::idl::WireWriter writer(connection);
4179 if (!writer.writeListHeader(s_cmd_len)) {
4180 return false;
4181 }
4182 return write(writer);
4183}
4184
4186{
4187 yarp::os::idl::WireReader reader(connection);
4188 if (!reader.readListHeader()) {
4189 reader.fail();
4190 return false;
4191 }
4192 return read(reader);
4193}
4194
4196{
4197 if (!writeTag(writer)) {
4198 return false;
4199 }
4200 if (!writeArgs(writer)) {
4201 return false;
4202 }
4203 return true;
4204}
4205
4207{
4208 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4209 return false;
4210 }
4211 return true;
4212}
4213
4215{
4216 if (!writer.writeString(object_name)) {
4217 return false;
4218 }
4219 return true;
4220}
4221
4223{
4224 if (!readTag(reader)) {
4225 return false;
4226 }
4227 if (!readArgs(reader)) {
4228 return false;
4229 }
4230 return true;
4231}
4232
4234{
4235 std::string tag = reader.readTag(s_tag_len);
4236 if (reader.isError()) {
4237 return false;
4238 }
4239 if (tag != s_tag) {
4240 reader.fail();
4241 return false;
4242 }
4243 return true;
4244}
4245
4247{
4248 if (reader.noMore()) {
4249 reader.fail();
4250 return false;
4251 }
4252 if (!reader.readString(object_name)) {
4253 reader.fail();
4254 return false;
4255 }
4256 if (!reader.noMore()) {
4257 reader.fail();
4258 return false;
4259 }
4260 return true;
4261}
4262
4264{
4265 yarp::os::idl::WireWriter writer(connection);
4266 return write(writer);
4267}
4268
4270{
4271 yarp::os::idl::WireReader reader(connection);
4272 return read(reader);
4273}
4274
4276{
4277 if (!writer.isNull()) {
4278 if (!writer.writeListHeader(s_reply_len)) {
4279 return false;
4280 }
4281 if (!writer.write(return_helper)) {
4282 return false;
4283 }
4284 }
4285 return true;
4286}
4287
4289{
4290 if (!reader.readListReturn()) {
4291 return false;
4292 }
4293 if (reader.noMore()) {
4294 reader.fail();
4295 return false;
4296 }
4297 if (!reader.read(return_helper)) {
4298 reader.fail();
4299 return false;
4300 }
4301 return true;
4302}
4303
4308
4309// get_location_RPC helper class implementation
4311 cmd{location_name}
4312{
4313}
4314
4316{
4317 return cmd.write(connection);
4318}
4319
4321{
4322 return reply.read(connection);
4323}
4324
4326 location_name{location_name}
4327{
4328}
4329
4331{
4332 yarp::os::idl::WireWriter writer(connection);
4333 if (!writer.writeListHeader(s_cmd_len)) {
4334 return false;
4335 }
4336 return write(writer);
4337}
4338
4340{
4341 yarp::os::idl::WireReader reader(connection);
4342 if (!reader.readListHeader()) {
4343 reader.fail();
4344 return false;
4345 }
4346 return read(reader);
4347}
4348
4350{
4351 if (!writeTag(writer)) {
4352 return false;
4353 }
4354 if (!writeArgs(writer)) {
4355 return false;
4356 }
4357 return true;
4358}
4359
4361{
4362 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4363 return false;
4364 }
4365 return true;
4366}
4367
4369{
4370 if (!writer.writeString(location_name)) {
4371 return false;
4372 }
4373 return true;
4374}
4375
4377{
4378 if (!readTag(reader)) {
4379 return false;
4380 }
4381 if (!readArgs(reader)) {
4382 return false;
4383 }
4384 return true;
4385}
4386
4388{
4389 std::string tag = reader.readTag(s_tag_len);
4390 if (reader.isError()) {
4391 return false;
4392 }
4393 if (tag != s_tag) {
4394 reader.fail();
4395 return false;
4396 }
4397 return true;
4398}
4399
4401{
4402 if (reader.noMore()) {
4403 reader.fail();
4404 return false;
4405 }
4406 if (!reader.readString(location_name)) {
4407 reader.fail();
4408 return false;
4409 }
4410 if (!reader.noMore()) {
4411 reader.fail();
4412 return false;
4413 }
4414 return true;
4415}
4416
4418{
4419 yarp::os::idl::WireWriter writer(connection);
4420 return write(writer);
4421}
4422
4424{
4425 yarp::os::idl::WireReader reader(connection);
4426 return read(reader);
4427}
4428
4430{
4431 if (!writer.isNull()) {
4432 if (!writer.writeListHeader(s_reply_len)) {
4433 return false;
4434 }
4435 if (!writer.write(return_helper)) {
4436 return false;
4437 }
4438 }
4439 return true;
4440}
4441
4443{
4444 if (!reader.readListReturn()) {
4445 return false;
4446 }
4447 if (reader.noMore()) {
4448 reader.fail();
4449 return false;
4450 }
4451 if (!reader.read(return_helper)) {
4452 reader.fail();
4453 return false;
4454 }
4455 return true;
4456}
4457
4462
4463// get_area_RPC helper class implementation
4465 cmd{area_name}
4466{
4467}
4468
4470{
4471 return cmd.write(connection);
4472}
4473
4475{
4476 return reply.read(connection);
4477}
4478
4480 area_name{area_name}
4481{
4482}
4483
4485{
4486 yarp::os::idl::WireWriter writer(connection);
4487 if (!writer.writeListHeader(s_cmd_len)) {
4488 return false;
4489 }
4490 return write(writer);
4491}
4492
4494{
4495 yarp::os::idl::WireReader reader(connection);
4496 if (!reader.readListHeader()) {
4497 reader.fail();
4498 return false;
4499 }
4500 return read(reader);
4501}
4502
4504{
4505 if (!writeTag(writer)) {
4506 return false;
4507 }
4508 if (!writeArgs(writer)) {
4509 return false;
4510 }
4511 return true;
4512}
4513
4515{
4516 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4517 return false;
4518 }
4519 return true;
4520}
4521
4523{
4524 if (!writer.writeString(area_name)) {
4525 return false;
4526 }
4527 return true;
4528}
4529
4531{
4532 if (!readTag(reader)) {
4533 return false;
4534 }
4535 if (!readArgs(reader)) {
4536 return false;
4537 }
4538 return true;
4539}
4540
4542{
4543 std::string tag = reader.readTag(s_tag_len);
4544 if (reader.isError()) {
4545 return false;
4546 }
4547 if (tag != s_tag) {
4548 reader.fail();
4549 return false;
4550 }
4551 return true;
4552}
4553
4555{
4556 if (reader.noMore()) {
4557 reader.fail();
4558 return false;
4559 }
4560 if (!reader.readString(area_name)) {
4561 reader.fail();
4562 return false;
4563 }
4564 if (!reader.noMore()) {
4565 reader.fail();
4566 return false;
4567 }
4568 return true;
4569}
4570
4572{
4573 yarp::os::idl::WireWriter writer(connection);
4574 return write(writer);
4575}
4576
4578{
4579 yarp::os::idl::WireReader reader(connection);
4580 return read(reader);
4581}
4582
4584{
4585 if (!writer.isNull()) {
4586 if (!writer.writeListHeader(s_reply_len)) {
4587 return false;
4588 }
4589 if (!writer.write(return_helper)) {
4590 return false;
4591 }
4592 }
4593 return true;
4594}
4595
4597{
4598 if (!reader.readListReturn()) {
4599 return false;
4600 }
4601 if (reader.noMore()) {
4602 reader.fail();
4603 return false;
4604 }
4605 if (!reader.read(return_helper)) {
4606 reader.fail();
4607 return false;
4608 }
4609 return true;
4610}
4611
4616
4617// get_path_RPC helper class implementation
4619 cmd{path_name}
4620{
4621}
4622
4624{
4625 return cmd.write(connection);
4626}
4627
4629{
4630 return reply.read(connection);
4631}
4632
4634 path_name{path_name}
4635{
4636}
4637
4639{
4640 yarp::os::idl::WireWriter writer(connection);
4641 if (!writer.writeListHeader(s_cmd_len)) {
4642 return false;
4643 }
4644 return write(writer);
4645}
4646
4648{
4649 yarp::os::idl::WireReader reader(connection);
4650 if (!reader.readListHeader()) {
4651 reader.fail();
4652 return false;
4653 }
4654 return read(reader);
4655}
4656
4658{
4659 if (!writeTag(writer)) {
4660 return false;
4661 }
4662 if (!writeArgs(writer)) {
4663 return false;
4664 }
4665 return true;
4666}
4667
4669{
4670 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4671 return false;
4672 }
4673 return true;
4674}
4675
4677{
4678 if (!writer.writeString(path_name)) {
4679 return false;
4680 }
4681 return true;
4682}
4683
4685{
4686 if (!readTag(reader)) {
4687 return false;
4688 }
4689 if (!readArgs(reader)) {
4690 return false;
4691 }
4692 return true;
4693}
4694
4696{
4697 std::string tag = reader.readTag(s_tag_len);
4698 if (reader.isError()) {
4699 return false;
4700 }
4701 if (tag != s_tag) {
4702 reader.fail();
4703 return false;
4704 }
4705 return true;
4706}
4707
4709{
4710 if (reader.noMore()) {
4711 reader.fail();
4712 return false;
4713 }
4714 if (!reader.readString(path_name)) {
4715 reader.fail();
4716 return false;
4717 }
4718 if (!reader.noMore()) {
4719 reader.fail();
4720 return false;
4721 }
4722 return true;
4723}
4724
4726{
4727 yarp::os::idl::WireWriter writer(connection);
4728 return write(writer);
4729}
4730
4732{
4733 yarp::os::idl::WireReader reader(connection);
4734 return read(reader);
4735}
4736
4738{
4739 if (!writer.isNull()) {
4740 if (!writer.writeListHeader(s_reply_len)) {
4741 return false;
4742 }
4743 if (!writer.write(return_helper)) {
4744 return false;
4745 }
4746 }
4747 return true;
4748}
4749
4751{
4752 if (!reader.readListReturn()) {
4753 return false;
4754 }
4755 if (reader.noMore()) {
4756 reader.fail();
4757 return false;
4758 }
4759 if (!reader.read(return_helper)) {
4760 reader.fail();
4761 return false;
4762 }
4763 return true;
4764}
4765
4770
4771// get_objects_list_RPC helper class implementation
4773{
4774 return cmd.write(connection);
4775}
4776
4778{
4779 return reply.read(connection);
4780}
4781
4783{
4784 yarp::os::idl::WireWriter writer(connection);
4785 if (!writer.writeListHeader(s_cmd_len)) {
4786 return false;
4787 }
4788 return write(writer);
4789}
4790
4792{
4793 yarp::os::idl::WireReader reader(connection);
4794 if (!reader.readListHeader()) {
4795 reader.fail();
4796 return false;
4797 }
4798 return read(reader);
4799}
4800
4802{
4803 if (!writeTag(writer)) {
4804 return false;
4805 }
4806 if (!writeArgs(writer)) {
4807 return false;
4808 }
4809 return true;
4810}
4811
4813{
4814 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4815 return false;
4816 }
4817 return true;
4818}
4819
4821{
4822 return true;
4823}
4824
4826{
4827 if (!readTag(reader)) {
4828 return false;
4829 }
4830 if (!readArgs(reader)) {
4831 return false;
4832 }
4833 return true;
4834}
4835
4837{
4838 std::string tag = reader.readTag(s_tag_len);
4839 if (reader.isError()) {
4840 return false;
4841 }
4842 if (tag != s_tag) {
4843 reader.fail();
4844 return false;
4845 }
4846 return true;
4847}
4848
4850{
4851 if (!reader.noMore()) {
4852 reader.fail();
4853 return false;
4854 }
4855 return true;
4856}
4857
4859{
4860 yarp::os::idl::WireWriter writer(connection);
4861 return write(writer);
4862}
4863
4865{
4866 yarp::os::idl::WireReader reader(connection);
4867 return read(reader);
4868}
4869
4871{
4872 if (!writer.isNull()) {
4873 if (!writer.writeListHeader(s_reply_len)) {
4874 return false;
4875 }
4876 if (!writer.write(return_helper)) {
4877 return false;
4878 }
4879 }
4880 return true;
4881}
4882
4884{
4885 if (!reader.readListReturn()) {
4886 return false;
4887 }
4888 if (reader.noMore()) {
4889 reader.fail();
4890 return false;
4891 }
4892 if (!reader.read(return_helper)) {
4893 reader.fail();
4894 return false;
4895 }
4896 return true;
4897}
4898
4903
4904// get_locations_list_RPC helper class implementation
4906{
4907 return cmd.write(connection);
4908}
4909
4911{
4912 return reply.read(connection);
4913}
4914
4916{
4917 yarp::os::idl::WireWriter writer(connection);
4918 if (!writer.writeListHeader(s_cmd_len)) {
4919 return false;
4920 }
4921 return write(writer);
4922}
4923
4925{
4926 yarp::os::idl::WireReader reader(connection);
4927 if (!reader.readListHeader()) {
4928 reader.fail();
4929 return false;
4930 }
4931 return read(reader);
4932}
4933
4935{
4936 if (!writeTag(writer)) {
4937 return false;
4938 }
4939 if (!writeArgs(writer)) {
4940 return false;
4941 }
4942 return true;
4943}
4944
4946{
4947 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4948 return false;
4949 }
4950 return true;
4951}
4952
4954{
4955 return true;
4956}
4957
4959{
4960 if (!readTag(reader)) {
4961 return false;
4962 }
4963 if (!readArgs(reader)) {
4964 return false;
4965 }
4966 return true;
4967}
4968
4970{
4971 std::string tag = reader.readTag(s_tag_len);
4972 if (reader.isError()) {
4973 return false;
4974 }
4975 if (tag != s_tag) {
4976 reader.fail();
4977 return false;
4978 }
4979 return true;
4980}
4981
4983{
4984 if (!reader.noMore()) {
4985 reader.fail();
4986 return false;
4987 }
4988 return true;
4989}
4990
4992{
4993 yarp::os::idl::WireWriter writer(connection);
4994 return write(writer);
4995}
4996
4998{
4999 yarp::os::idl::WireReader reader(connection);
5000 return read(reader);
5001}
5002
5004{
5005 if (!writer.isNull()) {
5006 if (!writer.writeListHeader(s_reply_len)) {
5007 return false;
5008 }
5009 if (!writer.write(return_helper)) {
5010 return false;
5011 }
5012 }
5013 return true;
5014}
5015
5017{
5018 if (!reader.readListReturn()) {
5019 return false;
5020 }
5021 if (reader.noMore()) {
5022 reader.fail();
5023 return false;
5024 }
5025 if (!reader.read(return_helper)) {
5026 reader.fail();
5027 return false;
5028 }
5029 return true;
5030}
5031
5036
5037// get_areas_list_RPC helper class implementation
5039{
5040 return cmd.write(connection);
5041}
5042
5044{
5045 return reply.read(connection);
5046}
5047
5049{
5050 yarp::os::idl::WireWriter writer(connection);
5051 if (!writer.writeListHeader(s_cmd_len)) {
5052 return false;
5053 }
5054 return write(writer);
5055}
5056
5058{
5059 yarp::os::idl::WireReader reader(connection);
5060 if (!reader.readListHeader()) {
5061 reader.fail();
5062 return false;
5063 }
5064 return read(reader);
5065}
5066
5068{
5069 if (!writeTag(writer)) {
5070 return false;
5071 }
5072 if (!writeArgs(writer)) {
5073 return false;
5074 }
5075 return true;
5076}
5077
5079{
5080 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5081 return false;
5082 }
5083 return true;
5084}
5085
5087{
5088 return true;
5089}
5090
5092{
5093 if (!readTag(reader)) {
5094 return false;
5095 }
5096 if (!readArgs(reader)) {
5097 return false;
5098 }
5099 return true;
5100}
5101
5103{
5104 std::string tag = reader.readTag(s_tag_len);
5105 if (reader.isError()) {
5106 return false;
5107 }
5108 if (tag != s_tag) {
5109 reader.fail();
5110 return false;
5111 }
5112 return true;
5113}
5114
5116{
5117 if (!reader.noMore()) {
5118 reader.fail();
5119 return false;
5120 }
5121 return true;
5122}
5123
5125{
5126 yarp::os::idl::WireWriter writer(connection);
5127 return write(writer);
5128}
5129
5131{
5132 yarp::os::idl::WireReader reader(connection);
5133 return read(reader);
5134}
5135
5137{
5138 if (!writer.isNull()) {
5139 if (!writer.writeListHeader(s_reply_len)) {
5140 return false;
5141 }
5142 if (!writer.write(return_helper)) {
5143 return false;
5144 }
5145 }
5146 return true;
5147}
5148
5150{
5151 if (!reader.readListReturn()) {
5152 return false;
5153 }
5154 if (reader.noMore()) {
5155 reader.fail();
5156 return false;
5157 }
5158 if (!reader.read(return_helper)) {
5159 reader.fail();
5160 return false;
5161 }
5162 return true;
5163}
5164
5169
5170// get_paths_list_RPC helper class implementation
5172{
5173 return cmd.write(connection);
5174}
5175
5177{
5178 return reply.read(connection);
5179}
5180
5182{
5183 yarp::os::idl::WireWriter writer(connection);
5184 if (!writer.writeListHeader(s_cmd_len)) {
5185 return false;
5186 }
5187 return write(writer);
5188}
5189
5191{
5192 yarp::os::idl::WireReader reader(connection);
5193 if (!reader.readListHeader()) {
5194 reader.fail();
5195 return false;
5196 }
5197 return read(reader);
5198}
5199
5201{
5202 if (!writeTag(writer)) {
5203 return false;
5204 }
5205 if (!writeArgs(writer)) {
5206 return false;
5207 }
5208 return true;
5209}
5210
5212{
5213 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5214 return false;
5215 }
5216 return true;
5217}
5218
5220{
5221 return true;
5222}
5223
5225{
5226 if (!readTag(reader)) {
5227 return false;
5228 }
5229 if (!readArgs(reader)) {
5230 return false;
5231 }
5232 return true;
5233}
5234
5236{
5237 std::string tag = reader.readTag(s_tag_len);
5238 if (reader.isError()) {
5239 return false;
5240 }
5241 if (tag != s_tag) {
5242 reader.fail();
5243 return false;
5244 }
5245 return true;
5246}
5247
5249{
5250 if (!reader.noMore()) {
5251 reader.fail();
5252 return false;
5253 }
5254 return true;
5255}
5256
5258{
5259 yarp::os::idl::WireWriter writer(connection);
5260 return write(writer);
5261}
5262
5264{
5265 yarp::os::idl::WireReader reader(connection);
5266 return read(reader);
5267}
5268
5270{
5271 if (!writer.isNull()) {
5272 if (!writer.writeListHeader(s_reply_len)) {
5273 return false;
5274 }
5275 if (!writer.write(return_helper)) {
5276 return false;
5277 }
5278 }
5279 return true;
5280}
5281
5283{
5284 if (!reader.readListReturn()) {
5285 return false;
5286 }
5287 if (reader.noMore()) {
5288 reader.fail();
5289 return false;
5290 }
5291 if (!reader.read(return_helper)) {
5292 reader.fail();
5293 return false;
5294 }
5295 return true;
5296}
5297
5302
5303// get_all_objects_RPC helper class implementation
5305{
5306 return cmd.write(connection);
5307}
5308
5310{
5311 return reply.read(connection);
5312}
5313
5315{
5316 yarp::os::idl::WireWriter writer(connection);
5317 if (!writer.writeListHeader(s_cmd_len)) {
5318 return false;
5319 }
5320 return write(writer);
5321}
5322
5324{
5325 yarp::os::idl::WireReader reader(connection);
5326 if (!reader.readListHeader()) {
5327 reader.fail();
5328 return false;
5329 }
5330 return read(reader);
5331}
5332
5334{
5335 if (!writeTag(writer)) {
5336 return false;
5337 }
5338 if (!writeArgs(writer)) {
5339 return false;
5340 }
5341 return true;
5342}
5343
5345{
5346 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5347 return false;
5348 }
5349 return true;
5350}
5351
5353{
5354 return true;
5355}
5356
5358{
5359 if (!readTag(reader)) {
5360 return false;
5361 }
5362 if (!readArgs(reader)) {
5363 return false;
5364 }
5365 return true;
5366}
5367
5369{
5370 std::string tag = reader.readTag(s_tag_len);
5371 if (reader.isError()) {
5372 return false;
5373 }
5374 if (tag != s_tag) {
5375 reader.fail();
5376 return false;
5377 }
5378 return true;
5379}
5380
5382{
5383 if (!reader.noMore()) {
5384 reader.fail();
5385 return false;
5386 }
5387 return true;
5388}
5389
5391{
5392 yarp::os::idl::WireWriter writer(connection);
5393 return write(writer);
5394}
5395
5397{
5398 yarp::os::idl::WireReader reader(connection);
5399 return read(reader);
5400}
5401
5403{
5404 if (!writer.isNull()) {
5405 if (!writer.writeListHeader(s_reply_len)) {
5406 return false;
5407 }
5408 if (!writer.write(return_helper)) {
5409 return false;
5410 }
5411 }
5412 return true;
5413}
5414
5416{
5417 if (!reader.readListReturn()) {
5418 return false;
5419 }
5420 if (reader.noMore()) {
5421 reader.fail();
5422 return false;
5423 }
5424 if (!reader.read(return_helper)) {
5425 reader.fail();
5426 return false;
5427 }
5428 return true;
5429}
5430
5435
5436// get_all_locations_RPC helper class implementation
5438{
5439 return cmd.write(connection);
5440}
5441
5443{
5444 return reply.read(connection);
5445}
5446
5448{
5449 yarp::os::idl::WireWriter writer(connection);
5450 if (!writer.writeListHeader(s_cmd_len)) {
5451 return false;
5452 }
5453 return write(writer);
5454}
5455
5457{
5458 yarp::os::idl::WireReader reader(connection);
5459 if (!reader.readListHeader()) {
5460 reader.fail();
5461 return false;
5462 }
5463 return read(reader);
5464}
5465
5467{
5468 if (!writeTag(writer)) {
5469 return false;
5470 }
5471 if (!writeArgs(writer)) {
5472 return false;
5473 }
5474 return true;
5475}
5476
5478{
5479 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5480 return false;
5481 }
5482 return true;
5483}
5484
5486{
5487 return true;
5488}
5489
5491{
5492 if (!readTag(reader)) {
5493 return false;
5494 }
5495 if (!readArgs(reader)) {
5496 return false;
5497 }
5498 return true;
5499}
5500
5502{
5503 std::string tag = reader.readTag(s_tag_len);
5504 if (reader.isError()) {
5505 return false;
5506 }
5507 if (tag != s_tag) {
5508 reader.fail();
5509 return false;
5510 }
5511 return true;
5512}
5513
5515{
5516 if (!reader.noMore()) {
5517 reader.fail();
5518 return false;
5519 }
5520 return true;
5521}
5522
5524{
5525 yarp::os::idl::WireWriter writer(connection);
5526 return write(writer);
5527}
5528
5530{
5531 yarp::os::idl::WireReader reader(connection);
5532 return read(reader);
5533}
5534
5536{
5537 if (!writer.isNull()) {
5538 if (!writer.writeListHeader(s_reply_len)) {
5539 return false;
5540 }
5541 if (!writer.write(return_helper)) {
5542 return false;
5543 }
5544 }
5545 return true;
5546}
5547
5549{
5550 if (!reader.readListReturn()) {
5551 return false;
5552 }
5553 if (reader.noMore()) {
5554 reader.fail();
5555 return false;
5556 }
5557 if (!reader.read(return_helper)) {
5558 reader.fail();
5559 return false;
5560 }
5561 return true;
5562}
5563
5568
5569// get_all_areas_RPC helper class implementation
5571{
5572 return cmd.write(connection);
5573}
5574
5576{
5577 return reply.read(connection);
5578}
5579
5581{
5582 yarp::os::idl::WireWriter writer(connection);
5583 if (!writer.writeListHeader(s_cmd_len)) {
5584 return false;
5585 }
5586 return write(writer);
5587}
5588
5590{
5591 yarp::os::idl::WireReader reader(connection);
5592 if (!reader.readListHeader()) {
5593 reader.fail();
5594 return false;
5595 }
5596 return read(reader);
5597}
5598
5600{
5601 if (!writeTag(writer)) {
5602 return false;
5603 }
5604 if (!writeArgs(writer)) {
5605 return false;
5606 }
5607 return true;
5608}
5609
5611{
5612 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5613 return false;
5614 }
5615 return true;
5616}
5617
5619{
5620 return true;
5621}
5622
5624{
5625 if (!readTag(reader)) {
5626 return false;
5627 }
5628 if (!readArgs(reader)) {
5629 return false;
5630 }
5631 return true;
5632}
5633
5635{
5636 std::string tag = reader.readTag(s_tag_len);
5637 if (reader.isError()) {
5638 return false;
5639 }
5640 if (tag != s_tag) {
5641 reader.fail();
5642 return false;
5643 }
5644 return true;
5645}
5646
5648{
5649 if (!reader.noMore()) {
5650 reader.fail();
5651 return false;
5652 }
5653 return true;
5654}
5655
5657{
5658 yarp::os::idl::WireWriter writer(connection);
5659 return write(writer);
5660}
5661
5663{
5664 yarp::os::idl::WireReader reader(connection);
5665 return read(reader);
5666}
5667
5669{
5670 if (!writer.isNull()) {
5671 if (!writer.writeListHeader(s_reply_len)) {
5672 return false;
5673 }
5674 if (!writer.write(return_helper)) {
5675 return false;
5676 }
5677 }
5678 return true;
5679}
5680
5682{
5683 if (!reader.readListReturn()) {
5684 return false;
5685 }
5686 if (reader.noMore()) {
5687 reader.fail();
5688 return false;
5689 }
5690 if (!reader.read(return_helper)) {
5691 reader.fail();
5692 return false;
5693 }
5694 return true;
5695}
5696
5701
5702// get_all_paths_RPC helper class implementation
5704{
5705 return cmd.write(connection);
5706}
5707
5709{
5710 return reply.read(connection);
5711}
5712
5714{
5715 yarp::os::idl::WireWriter writer(connection);
5716 if (!writer.writeListHeader(s_cmd_len)) {
5717 return false;
5718 }
5719 return write(writer);
5720}
5721
5723{
5724 yarp::os::idl::WireReader reader(connection);
5725 if (!reader.readListHeader()) {
5726 reader.fail();
5727 return false;
5728 }
5729 return read(reader);
5730}
5731
5733{
5734 if (!writeTag(writer)) {
5735 return false;
5736 }
5737 if (!writeArgs(writer)) {
5738 return false;
5739 }
5740 return true;
5741}
5742
5744{
5745 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5746 return false;
5747 }
5748 return true;
5749}
5750
5752{
5753 return true;
5754}
5755
5757{
5758 if (!readTag(reader)) {
5759 return false;
5760 }
5761 if (!readArgs(reader)) {
5762 return false;
5763 }
5764 return true;
5765}
5766
5768{
5769 std::string tag = reader.readTag(s_tag_len);
5770 if (reader.isError()) {
5771 return false;
5772 }
5773 if (tag != s_tag) {
5774 reader.fail();
5775 return false;
5776 }
5777 return true;
5778}
5779
5781{
5782 if (!reader.noMore()) {
5783 reader.fail();
5784 return false;
5785 }
5786 return true;
5787}
5788
5790{
5791 yarp::os::idl::WireWriter writer(connection);
5792 return write(writer);
5793}
5794
5796{
5797 yarp::os::idl::WireReader reader(connection);
5798 return read(reader);
5799}
5800
5802{
5803 if (!writer.isNull()) {
5804 if (!writer.writeListHeader(s_reply_len)) {
5805 return false;
5806 }
5807 if (!writer.write(return_helper)) {
5808 return false;
5809 }
5810 }
5811 return true;
5812}
5813
5815{
5816 if (!reader.readListReturn()) {
5817 return false;
5818 }
5819 if (reader.noMore()) {
5820 reader.fail();
5821 return false;
5822 }
5823 if (!reader.read(return_helper)) {
5824 reader.fail();
5825 return false;
5826 }
5827 return true;
5828}
5829
5834
5835// rename_location_RPC helper class implementation
5836IMap2DMsgs_rename_location_RPC_helper::IMap2DMsgs_rename_location_RPC_helper(const std::string& original_name, const std::string& new_name) :
5837 cmd{original_name, new_name}
5838{
5839}
5840
5842{
5843 return cmd.write(connection);
5844}
5845
5847{
5848 return reply.read(connection);
5849}
5850
5851IMap2DMsgs_rename_location_RPC_helper::Command::Command(const std::string& original_name, const std::string& new_name) :
5852 original_name{original_name},
5853 new_name{new_name}
5854{
5855}
5856
5858{
5859 yarp::os::idl::WireWriter writer(connection);
5860 if (!writer.writeListHeader(s_cmd_len)) {
5861 return false;
5862 }
5863 return write(writer);
5864}
5865
5867{
5868 yarp::os::idl::WireReader reader(connection);
5869 if (!reader.readListHeader()) {
5870 reader.fail();
5871 return false;
5872 }
5873 return read(reader);
5874}
5875
5877{
5878 if (!writeTag(writer)) {
5879 return false;
5880 }
5881 if (!writeArgs(writer)) {
5882 return false;
5883 }
5884 return true;
5885}
5886
5888{
5889 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5890 return false;
5891 }
5892 return true;
5893}
5894
5896{
5897 if (!writer.writeString(original_name)) {
5898 return false;
5899 }
5900 if (!writer.writeString(new_name)) {
5901 return false;
5902 }
5903 return true;
5904}
5905
5907{
5908 if (!readTag(reader)) {
5909 return false;
5910 }
5911 if (!readArgs(reader)) {
5912 return false;
5913 }
5914 return true;
5915}
5916
5918{
5919 std::string tag = reader.readTag(s_tag_len);
5920 if (reader.isError()) {
5921 return false;
5922 }
5923 if (tag != s_tag) {
5924 reader.fail();
5925 return false;
5926 }
5927 return true;
5928}
5929
5931{
5932 if (reader.noMore()) {
5933 reader.fail();
5934 return false;
5935 }
5936 if (!reader.readString(original_name)) {
5937 reader.fail();
5938 return false;
5939 }
5940 if (reader.noMore()) {
5941 reader.fail();
5942 return false;
5943 }
5944 if (!reader.readString(new_name)) {
5945 reader.fail();
5946 return false;
5947 }
5948 if (!reader.noMore()) {
5949 reader.fail();
5950 return false;
5951 }
5952 return true;
5953}
5954
5956{
5957 yarp::os::idl::WireWriter writer(connection);
5958 return write(writer);
5959}
5960
5962{
5963 yarp::os::idl::WireReader reader(connection);
5964 return read(reader);
5965}
5966
5968{
5969 if (!writer.isNull()) {
5970 if (!writer.write(return_helper)) {
5971 return false;
5972 }
5973 }
5974 return true;
5975}
5976
5978{
5979 if (reader.noMore()) {
5980 reader.fail();
5981 return false;
5982 }
5983 if (!reader.read(return_helper)) {
5984 reader.fail();
5985 return false;
5986 }
5987 return true;
5988}
5989
5994
5995// delete_object_RPC helper class implementation
5997 cmd{object_name}
5998{
5999}
6000
6002{
6003 return cmd.write(connection);
6004}
6005
6007{
6008 return reply.read(connection);
6009}
6010
6012 object_name{object_name}
6013{
6014}
6015
6017{
6018 yarp::os::idl::WireWriter writer(connection);
6019 if (!writer.writeListHeader(s_cmd_len)) {
6020 return false;
6021 }
6022 return write(writer);
6023}
6024
6026{
6027 yarp::os::idl::WireReader reader(connection);
6028 if (!reader.readListHeader()) {
6029 reader.fail();
6030 return false;
6031 }
6032 return read(reader);
6033}
6034
6036{
6037 if (!writeTag(writer)) {
6038 return false;
6039 }
6040 if (!writeArgs(writer)) {
6041 return false;
6042 }
6043 return true;
6044}
6045
6047{
6048 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6049 return false;
6050 }
6051 return true;
6052}
6053
6055{
6056 if (!writer.writeString(object_name)) {
6057 return false;
6058 }
6059 return true;
6060}
6061
6063{
6064 if (!readTag(reader)) {
6065 return false;
6066 }
6067 if (!readArgs(reader)) {
6068 return false;
6069 }
6070 return true;
6071}
6072
6074{
6075 std::string tag = reader.readTag(s_tag_len);
6076 if (reader.isError()) {
6077 return false;
6078 }
6079 if (tag != s_tag) {
6080 reader.fail();
6081 return false;
6082 }
6083 return true;
6084}
6085
6087{
6088 if (reader.noMore()) {
6089 reader.fail();
6090 return false;
6091 }
6092 if (!reader.readString(object_name)) {
6093 reader.fail();
6094 return false;
6095 }
6096 if (!reader.noMore()) {
6097 reader.fail();
6098 return false;
6099 }
6100 return true;
6101}
6102
6104{
6105 yarp::os::idl::WireWriter writer(connection);
6106 return write(writer);
6107}
6108
6110{
6111 yarp::os::idl::WireReader reader(connection);
6112 return read(reader);
6113}
6114
6116{
6117 if (!writer.isNull()) {
6118 if (!writer.write(return_helper)) {
6119 return false;
6120 }
6121 }
6122 return true;
6123}
6124
6126{
6127 if (reader.noMore()) {
6128 reader.fail();
6129 return false;
6130 }
6131 if (!reader.read(return_helper)) {
6132 reader.fail();
6133 return false;
6134 }
6135 return true;
6136}
6137
6142
6143// delete_location_RPC helper class implementation
6145 cmd{location_name}
6146{
6147}
6148
6150{
6151 return cmd.write(connection);
6152}
6153
6155{
6156 return reply.read(connection);
6157}
6158
6160 location_name{location_name}
6161{
6162}
6163
6165{
6166 yarp::os::idl::WireWriter writer(connection);
6167 if (!writer.writeListHeader(s_cmd_len)) {
6168 return false;
6169 }
6170 return write(writer);
6171}
6172
6174{
6175 yarp::os::idl::WireReader reader(connection);
6176 if (!reader.readListHeader()) {
6177 reader.fail();
6178 return false;
6179 }
6180 return read(reader);
6181}
6182
6184{
6185 if (!writeTag(writer)) {
6186 return false;
6187 }
6188 if (!writeArgs(writer)) {
6189 return false;
6190 }
6191 return true;
6192}
6193
6195{
6196 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6197 return false;
6198 }
6199 return true;
6200}
6201
6203{
6204 if (!writer.writeString(location_name)) {
6205 return false;
6206 }
6207 return true;
6208}
6209
6211{
6212 if (!readTag(reader)) {
6213 return false;
6214 }
6215 if (!readArgs(reader)) {
6216 return false;
6217 }
6218 return true;
6219}
6220
6222{
6223 std::string tag = reader.readTag(s_tag_len);
6224 if (reader.isError()) {
6225 return false;
6226 }
6227 if (tag != s_tag) {
6228 reader.fail();
6229 return false;
6230 }
6231 return true;
6232}
6233
6235{
6236 if (reader.noMore()) {
6237 reader.fail();
6238 return false;
6239 }
6240 if (!reader.readString(location_name)) {
6241 reader.fail();
6242 return false;
6243 }
6244 if (!reader.noMore()) {
6245 reader.fail();
6246 return false;
6247 }
6248 return true;
6249}
6250
6252{
6253 yarp::os::idl::WireWriter writer(connection);
6254 return write(writer);
6255}
6256
6258{
6259 yarp::os::idl::WireReader reader(connection);
6260 return read(reader);
6261}
6262
6264{
6265 if (!writer.isNull()) {
6266 if (!writer.write(return_helper)) {
6267 return false;
6268 }
6269 }
6270 return true;
6271}
6272
6274{
6275 if (reader.noMore()) {
6276 reader.fail();
6277 return false;
6278 }
6279 if (!reader.read(return_helper)) {
6280 reader.fail();
6281 return false;
6282 }
6283 return true;
6284}
6285
6290
6291// delete_path_RPC helper class implementation
6293 cmd{path_name}
6294{
6295}
6296
6298{
6299 return cmd.write(connection);
6300}
6301
6303{
6304 return reply.read(connection);
6305}
6306
6308 path_name{path_name}
6309{
6310}
6311
6313{
6314 yarp::os::idl::WireWriter writer(connection);
6315 if (!writer.writeListHeader(s_cmd_len)) {
6316 return false;
6317 }
6318 return write(writer);
6319}
6320
6322{
6323 yarp::os::idl::WireReader reader(connection);
6324 if (!reader.readListHeader()) {
6325 reader.fail();
6326 return false;
6327 }
6328 return read(reader);
6329}
6330
6332{
6333 if (!writeTag(writer)) {
6334 return false;
6335 }
6336 if (!writeArgs(writer)) {
6337 return false;
6338 }
6339 return true;
6340}
6341
6343{
6344 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6345 return false;
6346 }
6347 return true;
6348}
6349
6351{
6352 if (!writer.writeString(path_name)) {
6353 return false;
6354 }
6355 return true;
6356}
6357
6359{
6360 if (!readTag(reader)) {
6361 return false;
6362 }
6363 if (!readArgs(reader)) {
6364 return false;
6365 }
6366 return true;
6367}
6368
6370{
6371 std::string tag = reader.readTag(s_tag_len);
6372 if (reader.isError()) {
6373 return false;
6374 }
6375 if (tag != s_tag) {
6376 reader.fail();
6377 return false;
6378 }
6379 return true;
6380}
6381
6383{
6384 if (reader.noMore()) {
6385 reader.fail();
6386 return false;
6387 }
6388 if (!reader.readString(path_name)) {
6389 reader.fail();
6390 return false;
6391 }
6392 if (!reader.noMore()) {
6393 reader.fail();
6394 return false;
6395 }
6396 return true;
6397}
6398
6400{
6401 yarp::os::idl::WireWriter writer(connection);
6402 return write(writer);
6403}
6404
6406{
6407 yarp::os::idl::WireReader reader(connection);
6408 return read(reader);
6409}
6410
6412{
6413 if (!writer.isNull()) {
6414 if (!writer.write(return_helper)) {
6415 return false;
6416 }
6417 }
6418 return true;
6419}
6420
6422{
6423 if (reader.noMore()) {
6424 reader.fail();
6425 return false;
6426 }
6427 if (!reader.read(return_helper)) {
6428 reader.fail();
6429 return false;
6430 }
6431 return true;
6432}
6433
6438
6439// rename_object_RPC helper class implementation
6440IMap2DMsgs_rename_object_RPC_helper::IMap2DMsgs_rename_object_RPC_helper(const std::string& original_name, const std::string& new_name) :
6441 cmd{original_name, new_name}
6442{
6443}
6444
6446{
6447 return cmd.write(connection);
6448}
6449
6451{
6452 return reply.read(connection);
6453}
6454
6455IMap2DMsgs_rename_object_RPC_helper::Command::Command(const std::string& original_name, const std::string& new_name) :
6456 original_name{original_name},
6457 new_name{new_name}
6458{
6459}
6460
6462{
6463 yarp::os::idl::WireWriter writer(connection);
6464 if (!writer.writeListHeader(s_cmd_len)) {
6465 return false;
6466 }
6467 return write(writer);
6468}
6469
6471{
6472 yarp::os::idl::WireReader reader(connection);
6473 if (!reader.readListHeader()) {
6474 reader.fail();
6475 return false;
6476 }
6477 return read(reader);
6478}
6479
6481{
6482 if (!writeTag(writer)) {
6483 return false;
6484 }
6485 if (!writeArgs(writer)) {
6486 return false;
6487 }
6488 return true;
6489}
6490
6492{
6493 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6494 return false;
6495 }
6496 return true;
6497}
6498
6500{
6501 if (!writer.writeString(original_name)) {
6502 return false;
6503 }
6504 if (!writer.writeString(new_name)) {
6505 return false;
6506 }
6507 return true;
6508}
6509
6511{
6512 if (!readTag(reader)) {
6513 return false;
6514 }
6515 if (!readArgs(reader)) {
6516 return false;
6517 }
6518 return true;
6519}
6520
6522{
6523 std::string tag = reader.readTag(s_tag_len);
6524 if (reader.isError()) {
6525 return false;
6526 }
6527 if (tag != s_tag) {
6528 reader.fail();
6529 return false;
6530 }
6531 return true;
6532}
6533
6535{
6536 if (reader.noMore()) {
6537 reader.fail();
6538 return false;
6539 }
6540 if (!reader.readString(original_name)) {
6541 reader.fail();
6542 return false;
6543 }
6544 if (reader.noMore()) {
6545 reader.fail();
6546 return false;
6547 }
6548 if (!reader.readString(new_name)) {
6549 reader.fail();
6550 return false;
6551 }
6552 if (!reader.noMore()) {
6553 reader.fail();
6554 return false;
6555 }
6556 return true;
6557}
6558
6560{
6561 yarp::os::idl::WireWriter writer(connection);
6562 return write(writer);
6563}
6564
6566{
6567 yarp::os::idl::WireReader reader(connection);
6568 return read(reader);
6569}
6570
6572{
6573 if (!writer.isNull()) {
6574 if (!writer.write(return_helper)) {
6575 return false;
6576 }
6577 }
6578 return true;
6579}
6580
6582{
6583 if (reader.noMore()) {
6584 reader.fail();
6585 return false;
6586 }
6587 if (!reader.read(return_helper)) {
6588 reader.fail();
6589 return false;
6590 }
6591 return true;
6592}
6593
6598
6599// rename_area_RPC helper class implementation
6600IMap2DMsgs_rename_area_RPC_helper::IMap2DMsgs_rename_area_RPC_helper(const std::string& original_name, const std::string& new_name) :
6601 cmd{original_name, new_name}
6602{
6603}
6604
6606{
6607 return cmd.write(connection);
6608}
6609
6611{
6612 return reply.read(connection);
6613}
6614
6615IMap2DMsgs_rename_area_RPC_helper::Command::Command(const std::string& original_name, const std::string& new_name) :
6616 original_name{original_name},
6617 new_name{new_name}
6618{
6619}
6620
6622{
6623 yarp::os::idl::WireWriter writer(connection);
6624 if (!writer.writeListHeader(s_cmd_len)) {
6625 return false;
6626 }
6627 return write(writer);
6628}
6629
6631{
6632 yarp::os::idl::WireReader reader(connection);
6633 if (!reader.readListHeader()) {
6634 reader.fail();
6635 return false;
6636 }
6637 return read(reader);
6638}
6639
6641{
6642 if (!writeTag(writer)) {
6643 return false;
6644 }
6645 if (!writeArgs(writer)) {
6646 return false;
6647 }
6648 return true;
6649}
6650
6652{
6653 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6654 return false;
6655 }
6656 return true;
6657}
6658
6660{
6661 if (!writer.writeString(original_name)) {
6662 return false;
6663 }
6664 if (!writer.writeString(new_name)) {
6665 return false;
6666 }
6667 return true;
6668}
6669
6671{
6672 if (!readTag(reader)) {
6673 return false;
6674 }
6675 if (!readArgs(reader)) {
6676 return false;
6677 }
6678 return true;
6679}
6680
6682{
6683 std::string tag = reader.readTag(s_tag_len);
6684 if (reader.isError()) {
6685 return false;
6686 }
6687 if (tag != s_tag) {
6688 reader.fail();
6689 return false;
6690 }
6691 return true;
6692}
6693
6695{
6696 if (reader.noMore()) {
6697 reader.fail();
6698 return false;
6699 }
6700 if (!reader.readString(original_name)) {
6701 reader.fail();
6702 return false;
6703 }
6704 if (reader.noMore()) {
6705 reader.fail();
6706 return false;
6707 }
6708 if (!reader.readString(new_name)) {
6709 reader.fail();
6710 return false;
6711 }
6712 if (!reader.noMore()) {
6713 reader.fail();
6714 return false;
6715 }
6716 return true;
6717}
6718
6720{
6721 yarp::os::idl::WireWriter writer(connection);
6722 return write(writer);
6723}
6724
6726{
6727 yarp::os::idl::WireReader reader(connection);
6728 return read(reader);
6729}
6730
6732{
6733 if (!writer.isNull()) {
6734 if (!writer.write(return_helper)) {
6735 return false;
6736 }
6737 }
6738 return true;
6739}
6740
6742{
6743 if (reader.noMore()) {
6744 reader.fail();
6745 return false;
6746 }
6747 if (!reader.read(return_helper)) {
6748 reader.fail();
6749 return false;
6750 }
6751 return true;
6752}
6753
6758
6759// rename_path_RPC helper class implementation
6760IMap2DMsgs_rename_path_RPC_helper::IMap2DMsgs_rename_path_RPC_helper(const std::string& original_name, const std::string& new_name) :
6761 cmd{original_name, new_name}
6762{
6763}
6764
6766{
6767 return cmd.write(connection);
6768}
6769
6771{
6772 return reply.read(connection);
6773}
6774
6775IMap2DMsgs_rename_path_RPC_helper::Command::Command(const std::string& original_name, const std::string& new_name) :
6776 original_name{original_name},
6777 new_name{new_name}
6778{
6779}
6780
6782{
6783 yarp::os::idl::WireWriter writer(connection);
6784 if (!writer.writeListHeader(s_cmd_len)) {
6785 return false;
6786 }
6787 return write(writer);
6788}
6789
6791{
6792 yarp::os::idl::WireReader reader(connection);
6793 if (!reader.readListHeader()) {
6794 reader.fail();
6795 return false;
6796 }
6797 return read(reader);
6798}
6799
6801{
6802 if (!writeTag(writer)) {
6803 return false;
6804 }
6805 if (!writeArgs(writer)) {
6806 return false;
6807 }
6808 return true;
6809}
6810
6812{
6813 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6814 return false;
6815 }
6816 return true;
6817}
6818
6820{
6821 if (!writer.writeString(original_name)) {
6822 return false;
6823 }
6824 if (!writer.writeString(new_name)) {
6825 return false;
6826 }
6827 return true;
6828}
6829
6831{
6832 if (!readTag(reader)) {
6833 return false;
6834 }
6835 if (!readArgs(reader)) {
6836 return false;
6837 }
6838 return true;
6839}
6840
6842{
6843 std::string tag = reader.readTag(s_tag_len);
6844 if (reader.isError()) {
6845 return false;
6846 }
6847 if (tag != s_tag) {
6848 reader.fail();
6849 return false;
6850 }
6851 return true;
6852}
6853
6855{
6856 if (reader.noMore()) {
6857 reader.fail();
6858 return false;
6859 }
6860 if (!reader.readString(original_name)) {
6861 reader.fail();
6862 return false;
6863 }
6864 if (reader.noMore()) {
6865 reader.fail();
6866 return false;
6867 }
6868 if (!reader.readString(new_name)) {
6869 reader.fail();
6870 return false;
6871 }
6872 if (!reader.noMore()) {
6873 reader.fail();
6874 return false;
6875 }
6876 return true;
6877}
6878
6880{
6881 yarp::os::idl::WireWriter writer(connection);
6882 return write(writer);
6883}
6884
6886{
6887 yarp::os::idl::WireReader reader(connection);
6888 return read(reader);
6889}
6890
6892{
6893 if (!writer.isNull()) {
6894 if (!writer.write(return_helper)) {
6895 return false;
6896 }
6897 }
6898 return true;
6899}
6900
6902{
6903 if (reader.noMore()) {
6904 reader.fail();
6905 return false;
6906 }
6907 if (!reader.read(return_helper)) {
6908 reader.fail();
6909 return false;
6910 }
6911 return true;
6912}
6913
6918
6919// delete_area_RPC helper class implementation
6921 cmd{area_name}
6922{
6923}
6924
6926{
6927 return cmd.write(connection);
6928}
6929
6931{
6932 return reply.read(connection);
6933}
6934
6936 area_name{area_name}
6937{
6938}
6939
6941{
6942 yarp::os::idl::WireWriter writer(connection);
6943 if (!writer.writeListHeader(s_cmd_len)) {
6944 return false;
6945 }
6946 return write(writer);
6947}
6948
6950{
6951 yarp::os::idl::WireReader reader(connection);
6952 if (!reader.readListHeader()) {
6953 reader.fail();
6954 return false;
6955 }
6956 return read(reader);
6957}
6958
6960{
6961 if (!writeTag(writer)) {
6962 return false;
6963 }
6964 if (!writeArgs(writer)) {
6965 return false;
6966 }
6967 return true;
6968}
6969
6971{
6972 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6973 return false;
6974 }
6975 return true;
6976}
6977
6979{
6980 if (!writer.writeString(area_name)) {
6981 return false;
6982 }
6983 return true;
6984}
6985
6987{
6988 if (!readTag(reader)) {
6989 return false;
6990 }
6991 if (!readArgs(reader)) {
6992 return false;
6993 }
6994 return true;
6995}
6996
6998{
6999 std::string tag = reader.readTag(s_tag_len);
7000 if (reader.isError()) {
7001 return false;
7002 }
7003 if (tag != s_tag) {
7004 reader.fail();
7005 return false;
7006 }
7007 return true;
7008}
7009
7011{
7012 if (reader.noMore()) {
7013 reader.fail();
7014 return false;
7015 }
7016 if (!reader.readString(area_name)) {
7017 reader.fail();
7018 return false;
7019 }
7020 if (!reader.noMore()) {
7021 reader.fail();
7022 return false;
7023 }
7024 return true;
7025}
7026
7028{
7029 yarp::os::idl::WireWriter writer(connection);
7030 return write(writer);
7031}
7032
7034{
7035 yarp::os::idl::WireReader reader(connection);
7036 return read(reader);
7037}
7038
7040{
7041 if (!writer.isNull()) {
7042 if (!writer.write(return_helper)) {
7043 return false;
7044 }
7045 }
7046 return true;
7047}
7048
7050{
7051 if (reader.noMore()) {
7052 reader.fail();
7053 return false;
7054 }
7055 if (!reader.read(return_helper)) {
7056 reader.fail();
7057 return false;
7058 }
7059 return true;
7060}
7061
7066
7067// clear_all_objects_RPC helper class implementation
7069{
7070 return cmd.write(connection);
7071}
7072
7074{
7075 return reply.read(connection);
7076}
7077
7079{
7080 yarp::os::idl::WireWriter writer(connection);
7081 if (!writer.writeListHeader(s_cmd_len)) {
7082 return false;
7083 }
7084 return write(writer);
7085}
7086
7088{
7089 yarp::os::idl::WireReader reader(connection);
7090 if (!reader.readListHeader()) {
7091 reader.fail();
7092 return false;
7093 }
7094 return read(reader);
7095}
7096
7098{
7099 if (!writeTag(writer)) {
7100 return false;
7101 }
7102 if (!writeArgs(writer)) {
7103 return false;
7104 }
7105 return true;
7106}
7107
7109{
7110 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7111 return false;
7112 }
7113 return true;
7114}
7115
7117{
7118 return true;
7119}
7120
7122{
7123 if (!readTag(reader)) {
7124 return false;
7125 }
7126 if (!readArgs(reader)) {
7127 return false;
7128 }
7129 return true;
7130}
7131
7133{
7134 std::string tag = reader.readTag(s_tag_len);
7135 if (reader.isError()) {
7136 return false;
7137 }
7138 if (tag != s_tag) {
7139 reader.fail();
7140 return false;
7141 }
7142 return true;
7143}
7144
7146{
7147 if (!reader.noMore()) {
7148 reader.fail();
7149 return false;
7150 }
7151 return true;
7152}
7153
7155{
7156 yarp::os::idl::WireWriter writer(connection);
7157 return write(writer);
7158}
7159
7161{
7162 yarp::os::idl::WireReader reader(connection);
7163 return read(reader);
7164}
7165
7167{
7168 if (!writer.isNull()) {
7169 if (!writer.write(return_helper)) {
7170 return false;
7171 }
7172 }
7173 return true;
7174}
7175
7177{
7178 if (reader.noMore()) {
7179 reader.fail();
7180 return false;
7181 }
7182 if (!reader.read(return_helper)) {
7183 reader.fail();
7184 return false;
7185 }
7186 return true;
7187}
7188
7193
7194// clear_all_locations_RPC helper class implementation
7196{
7197 return cmd.write(connection);
7198}
7199
7201{
7202 return reply.read(connection);
7203}
7204
7206{
7207 yarp::os::idl::WireWriter writer(connection);
7208 if (!writer.writeListHeader(s_cmd_len)) {
7209 return false;
7210 }
7211 return write(writer);
7212}
7213
7215{
7216 yarp::os::idl::WireReader reader(connection);
7217 if (!reader.readListHeader()) {
7218 reader.fail();
7219 return false;
7220 }
7221 return read(reader);
7222}
7223
7225{
7226 if (!writeTag(writer)) {
7227 return false;
7228 }
7229 if (!writeArgs(writer)) {
7230 return false;
7231 }
7232 return true;
7233}
7234
7236{
7237 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7238 return false;
7239 }
7240 return true;
7241}
7242
7244{
7245 return true;
7246}
7247
7249{
7250 if (!readTag(reader)) {
7251 return false;
7252 }
7253 if (!readArgs(reader)) {
7254 return false;
7255 }
7256 return true;
7257}
7258
7260{
7261 std::string tag = reader.readTag(s_tag_len);
7262 if (reader.isError()) {
7263 return false;
7264 }
7265 if (tag != s_tag) {
7266 reader.fail();
7267 return false;
7268 }
7269 return true;
7270}
7271
7273{
7274 if (!reader.noMore()) {
7275 reader.fail();
7276 return false;
7277 }
7278 return true;
7279}
7280
7282{
7283 yarp::os::idl::WireWriter writer(connection);
7284 return write(writer);
7285}
7286
7288{
7289 yarp::os::idl::WireReader reader(connection);
7290 return read(reader);
7291}
7292
7294{
7295 if (!writer.isNull()) {
7296 if (!writer.write(return_helper)) {
7297 return false;
7298 }
7299 }
7300 return true;
7301}
7302
7304{
7305 if (reader.noMore()) {
7306 reader.fail();
7307 return false;
7308 }
7309 if (!reader.read(return_helper)) {
7310 reader.fail();
7311 return false;
7312 }
7313 return true;
7314}
7315
7320
7321// clear_all_areas_RPC helper class implementation
7323{
7324 return cmd.write(connection);
7325}
7326
7328{
7329 return reply.read(connection);
7330}
7331
7333{
7334 yarp::os::idl::WireWriter writer(connection);
7335 if (!writer.writeListHeader(s_cmd_len)) {
7336 return false;
7337 }
7338 return write(writer);
7339}
7340
7342{
7343 yarp::os::idl::WireReader reader(connection);
7344 if (!reader.readListHeader()) {
7345 reader.fail();
7346 return false;
7347 }
7348 return read(reader);
7349}
7350
7352{
7353 if (!writeTag(writer)) {
7354 return false;
7355 }
7356 if (!writeArgs(writer)) {
7357 return false;
7358 }
7359 return true;
7360}
7361
7363{
7364 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7365 return false;
7366 }
7367 return true;
7368}
7369
7371{
7372 return true;
7373}
7374
7376{
7377 if (!readTag(reader)) {
7378 return false;
7379 }
7380 if (!readArgs(reader)) {
7381 return false;
7382 }
7383 return true;
7384}
7385
7387{
7388 std::string tag = reader.readTag(s_tag_len);
7389 if (reader.isError()) {
7390 return false;
7391 }
7392 if (tag != s_tag) {
7393 reader.fail();
7394 return false;
7395 }
7396 return true;
7397}
7398
7400{
7401 if (!reader.noMore()) {
7402 reader.fail();
7403 return false;
7404 }
7405 return true;
7406}
7407
7409{
7410 yarp::os::idl::WireWriter writer(connection);
7411 return write(writer);
7412}
7413
7415{
7416 yarp::os::idl::WireReader reader(connection);
7417 return read(reader);
7418}
7419
7421{
7422 if (!writer.isNull()) {
7423 if (!writer.write(return_helper)) {
7424 return false;
7425 }
7426 }
7427 return true;
7428}
7429
7431{
7432 if (reader.noMore()) {
7433 reader.fail();
7434 return false;
7435 }
7436 if (!reader.read(return_helper)) {
7437 reader.fail();
7438 return false;
7439 }
7440 return true;
7441}
7442
7447
7448// clear_all_paths_RPC helper class implementation
7450{
7451 return cmd.write(connection);
7452}
7453
7455{
7456 return reply.read(connection);
7457}
7458
7460{
7461 yarp::os::idl::WireWriter writer(connection);
7462 if (!writer.writeListHeader(s_cmd_len)) {
7463 return false;
7464 }
7465 return write(writer);
7466}
7467
7469{
7470 yarp::os::idl::WireReader reader(connection);
7471 if (!reader.readListHeader()) {
7472 reader.fail();
7473 return false;
7474 }
7475 return read(reader);
7476}
7477
7479{
7480 if (!writeTag(writer)) {
7481 return false;
7482 }
7483 if (!writeArgs(writer)) {
7484 return false;
7485 }
7486 return true;
7487}
7488
7490{
7491 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7492 return false;
7493 }
7494 return true;
7495}
7496
7498{
7499 return true;
7500}
7501
7503{
7504 if (!readTag(reader)) {
7505 return false;
7506 }
7507 if (!readArgs(reader)) {
7508 return false;
7509 }
7510 return true;
7511}
7512
7514{
7515 std::string tag = reader.readTag(s_tag_len);
7516 if (reader.isError()) {
7517 return false;
7518 }
7519 if (tag != s_tag) {
7520 reader.fail();
7521 return false;
7522 }
7523 return true;
7524}
7525
7527{
7528 if (!reader.noMore()) {
7529 reader.fail();
7530 return false;
7531 }
7532 return true;
7533}
7534
7536{
7537 yarp::os::idl::WireWriter writer(connection);
7538 return write(writer);
7539}
7540
7542{
7543 yarp::os::idl::WireReader reader(connection);
7544 return read(reader);
7545}
7546
7548{
7549 if (!writer.isNull()) {
7550 if (!writer.write(return_helper)) {
7551 return false;
7552 }
7553 }
7554 return true;
7555}
7556
7558{
7559 if (reader.noMore()) {
7560 reader.fail();
7561 return false;
7562 }
7563 if (!reader.read(return_helper)) {
7564 reader.fail();
7565 return false;
7566 }
7567 return true;
7568}
7569
7574
7575// clear_all_maps_temporary_flags_RPC helper class implementation
7580
7585
7587{
7588 yarp::os::idl::WireWriter writer(connection);
7589 if (!writer.writeListHeader(s_cmd_len)) {
7590 return false;
7591 }
7592 return write(writer);
7593}
7594
7596{
7597 yarp::os::idl::WireReader reader(connection);
7598 if (!reader.readListHeader()) {
7599 reader.fail();
7600 return false;
7601 }
7602 return read(reader);
7603}
7604
7606{
7607 if (!writeTag(writer)) {
7608 return false;
7609 }
7610 if (!writeArgs(writer)) {
7611 return false;
7612 }
7613 return true;
7614}
7615
7617{
7618 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7619 return false;
7620 }
7621 return true;
7622}
7623
7625{
7626 return true;
7627}
7628
7630{
7631 if (!readTag(reader)) {
7632 return false;
7633 }
7634 if (!readArgs(reader)) {
7635 return false;
7636 }
7637 return true;
7638}
7639
7641{
7642 std::string tag = reader.readTag(s_tag_len);
7643 if (reader.isError()) {
7644 return false;
7645 }
7646 if (tag != s_tag) {
7647 reader.fail();
7648 return false;
7649 }
7650 return true;
7651}
7652
7654{
7655 if (!reader.noMore()) {
7656 reader.fail();
7657 return false;
7658 }
7659 return true;
7660}
7661
7663{
7664 yarp::os::idl::WireWriter writer(connection);
7665 return write(writer);
7666}
7667
7673
7675{
7676 if (!writer.isNull()) {
7677 if (!writer.write(return_helper)) {
7678 return false;
7679 }
7680 }
7681 return true;
7682}
7683
7685{
7686 if (reader.noMore()) {
7687 reader.fail();
7688 return false;
7689 }
7690 if (!reader.read(return_helper)) {
7691 reader.fail();
7692 return false;
7693 }
7694 return true;
7695}
7696
7701
7702// clear_map_temporary_flags_RPC helper class implementation
7707
7709{
7710 return cmd.write(connection);
7711}
7712
7717
7719 map_name{map_name}
7720{
7721}
7722
7724{
7725 yarp::os::idl::WireWriter writer(connection);
7726 if (!writer.writeListHeader(s_cmd_len)) {
7727 return false;
7728 }
7729 return write(writer);
7730}
7731
7733{
7734 yarp::os::idl::WireReader reader(connection);
7735 if (!reader.readListHeader()) {
7736 reader.fail();
7737 return false;
7738 }
7739 return read(reader);
7740}
7741
7743{
7744 if (!writeTag(writer)) {
7745 return false;
7746 }
7747 if (!writeArgs(writer)) {
7748 return false;
7749 }
7750 return true;
7751}
7752
7754{
7755 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7756 return false;
7757 }
7758 return true;
7759}
7760
7762{
7763 if (!writer.writeString(map_name)) {
7764 return false;
7765 }
7766 return true;
7767}
7768
7770{
7771 if (!readTag(reader)) {
7772 return false;
7773 }
7774 if (!readArgs(reader)) {
7775 return false;
7776 }
7777 return true;
7778}
7779
7781{
7782 std::string tag = reader.readTag(s_tag_len);
7783 if (reader.isError()) {
7784 return false;
7785 }
7786 if (tag != s_tag) {
7787 reader.fail();
7788 return false;
7789 }
7790 return true;
7791}
7792
7794{
7795 if (reader.noMore()) {
7796 reader.fail();
7797 return false;
7798 }
7799 if (!reader.readString(map_name)) {
7800 reader.fail();
7801 return false;
7802 }
7803 if (!reader.noMore()) {
7804 reader.fail();
7805 return false;
7806 }
7807 return true;
7808}
7809
7811{
7812 yarp::os::idl::WireWriter writer(connection);
7813 return write(writer);
7814}
7815
7817{
7818 yarp::os::idl::WireReader reader(connection);
7819 return read(reader);
7820}
7821
7823{
7824 if (!writer.isNull()) {
7825 if (!writer.write(return_helper)) {
7826 return false;
7827 }
7828 }
7829 return true;
7830}
7831
7833{
7834 if (reader.noMore()) {
7835 reader.fail();
7836 return false;
7837 }
7838 if (!reader.read(return_helper)) {
7839 reader.fail();
7840 return false;
7841 }
7842 return true;
7843}
7844
7849
7850// save_maps_collection_RPC helper class implementation
7852 cmd{maps_collection_file}
7853{
7854}
7855
7857{
7858 return cmd.write(connection);
7859}
7860
7862{
7863 return reply.read(connection);
7864}
7865
7867 maps_collection_file{maps_collection_file}
7868{
7869}
7870
7872{
7873 yarp::os::idl::WireWriter writer(connection);
7874 if (!writer.writeListHeader(s_cmd_len)) {
7875 return false;
7876 }
7877 return write(writer);
7878}
7879
7881{
7882 yarp::os::idl::WireReader reader(connection);
7883 if (!reader.readListHeader()) {
7884 reader.fail();
7885 return false;
7886 }
7887 return read(reader);
7888}
7889
7891{
7892 if (!writeTag(writer)) {
7893 return false;
7894 }
7895 if (!writeArgs(writer)) {
7896 return false;
7897 }
7898 return true;
7899}
7900
7902{
7903 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7904 return false;
7905 }
7906 return true;
7907}
7908
7910{
7911 if (!writer.writeString(maps_collection_file)) {
7912 return false;
7913 }
7914 return true;
7915}
7916
7918{
7919 if (!readTag(reader)) {
7920 return false;
7921 }
7922 if (!readArgs(reader)) {
7923 return false;
7924 }
7925 return true;
7926}
7927
7929{
7930 std::string tag = reader.readTag(s_tag_len);
7931 if (reader.isError()) {
7932 return false;
7933 }
7934 if (tag != s_tag) {
7935 reader.fail();
7936 return false;
7937 }
7938 return true;
7939}
7940
7942{
7943 if (reader.noMore()) {
7944 reader.fail();
7945 return false;
7946 }
7947 if (!reader.readString(maps_collection_file)) {
7948 reader.fail();
7949 return false;
7950 }
7951 if (!reader.noMore()) {
7952 reader.fail();
7953 return false;
7954 }
7955 return true;
7956}
7957
7959{
7960 yarp::os::idl::WireWriter writer(connection);
7961 return write(writer);
7962}
7963
7965{
7966 yarp::os::idl::WireReader reader(connection);
7967 return read(reader);
7968}
7969
7971{
7972 if (!writer.isNull()) {
7973 if (!writer.write(return_helper)) {
7974 return false;
7975 }
7976 }
7977 return true;
7978}
7979
7981{
7982 if (reader.noMore()) {
7983 reader.fail();
7984 return false;
7985 }
7986 if (!reader.read(return_helper)) {
7987 reader.fail();
7988 return false;
7989 }
7990 return true;
7991}
7992
7997
7998// load_maps_collection_RPC helper class implementation
8000 cmd{maps_collection_file}
8001{
8002}
8003
8005{
8006 return cmd.write(connection);
8007}
8008
8010{
8011 return reply.read(connection);
8012}
8013
8015 maps_collection_file{maps_collection_file}
8016{
8017}
8018
8020{
8021 yarp::os::idl::WireWriter writer(connection);
8022 if (!writer.writeListHeader(s_cmd_len)) {
8023 return false;
8024 }
8025 return write(writer);
8026}
8027
8029{
8030 yarp::os::idl::WireReader reader(connection);
8031 if (!reader.readListHeader()) {
8032 reader.fail();
8033 return false;
8034 }
8035 return read(reader);
8036}
8037
8039{
8040 if (!writeTag(writer)) {
8041 return false;
8042 }
8043 if (!writeArgs(writer)) {
8044 return false;
8045 }
8046 return true;
8047}
8048
8050{
8051 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8052 return false;
8053 }
8054 return true;
8055}
8056
8058{
8059 if (!writer.writeString(maps_collection_file)) {
8060 return false;
8061 }
8062 return true;
8063}
8064
8066{
8067 if (!readTag(reader)) {
8068 return false;
8069 }
8070 if (!readArgs(reader)) {
8071 return false;
8072 }
8073 return true;
8074}
8075
8077{
8078 std::string tag = reader.readTag(s_tag_len);
8079 if (reader.isError()) {
8080 return false;
8081 }
8082 if (tag != s_tag) {
8083 reader.fail();
8084 return false;
8085 }
8086 return true;
8087}
8088
8090{
8091 if (reader.noMore()) {
8092 reader.fail();
8093 return false;
8094 }
8095 if (!reader.readString(maps_collection_file)) {
8096 reader.fail();
8097 return false;
8098 }
8099 if (!reader.noMore()) {
8100 reader.fail();
8101 return false;
8102 }
8103 return true;
8104}
8105
8107{
8108 yarp::os::idl::WireWriter writer(connection);
8109 return write(writer);
8110}
8111
8113{
8114 yarp::os::idl::WireReader reader(connection);
8115 return read(reader);
8116}
8117
8119{
8120 if (!writer.isNull()) {
8121 if (!writer.write(return_helper)) {
8122 return false;
8123 }
8124 }
8125 return true;
8126}
8127
8129{
8130 if (reader.noMore()) {
8131 reader.fail();
8132 return false;
8133 }
8134 if (!reader.read(return_helper)) {
8135 reader.fail();
8136 return false;
8137 }
8138 return true;
8139}
8140
8145
8146// save_locations_and_extras_RPC helper class implementation
8148 cmd{locations_collection_file}
8149{
8150}
8151
8153{
8154 return cmd.write(connection);
8155}
8156
8161
8162IMap2DMsgs_save_locations_and_extras_RPC_helper::Command::Command(const std::string& locations_collection_file) :
8163 locations_collection_file{locations_collection_file}
8164{
8165}
8166
8168{
8169 yarp::os::idl::WireWriter writer(connection);
8170 if (!writer.writeListHeader(s_cmd_len)) {
8171 return false;
8172 }
8173 return write(writer);
8174}
8175
8177{
8178 yarp::os::idl::WireReader reader(connection);
8179 if (!reader.readListHeader()) {
8180 reader.fail();
8181 return false;
8182 }
8183 return read(reader);
8184}
8185
8187{
8188 if (!writeTag(writer)) {
8189 return false;
8190 }
8191 if (!writeArgs(writer)) {
8192 return false;
8193 }
8194 return true;
8195}
8196
8198{
8199 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8200 return false;
8201 }
8202 return true;
8203}
8204
8206{
8207 if (!writer.writeString(locations_collection_file)) {
8208 return false;
8209 }
8210 return true;
8211}
8212
8214{
8215 if (!readTag(reader)) {
8216 return false;
8217 }
8218 if (!readArgs(reader)) {
8219 return false;
8220 }
8221 return true;
8222}
8223
8225{
8226 std::string tag = reader.readTag(s_tag_len);
8227 if (reader.isError()) {
8228 return false;
8229 }
8230 if (tag != s_tag) {
8231 reader.fail();
8232 return false;
8233 }
8234 return true;
8235}
8236
8238{
8239 if (reader.noMore()) {
8240 reader.fail();
8241 return false;
8242 }
8243 if (!reader.readString(locations_collection_file)) {
8244 reader.fail();
8245 return false;
8246 }
8247 if (!reader.noMore()) {
8248 reader.fail();
8249 return false;
8250 }
8251 return true;
8252}
8253
8255{
8256 yarp::os::idl::WireWriter writer(connection);
8257 return write(writer);
8258}
8259
8261{
8262 yarp::os::idl::WireReader reader(connection);
8263 return read(reader);
8264}
8265
8267{
8268 if (!writer.isNull()) {
8269 if (!writer.write(return_helper)) {
8270 return false;
8271 }
8272 }
8273 return true;
8274}
8275
8277{
8278 if (reader.noMore()) {
8279 reader.fail();
8280 return false;
8281 }
8282 if (!reader.read(return_helper)) {
8283 reader.fail();
8284 return false;
8285 }
8286 return true;
8287}
8288
8293
8294// load_locations_and_extras_RPC helper class implementation
8296 cmd{locations_collection_file}
8297{
8298}
8299
8301{
8302 return cmd.write(connection);
8303}
8304
8309
8310IMap2DMsgs_load_locations_and_extras_RPC_helper::Command::Command(const std::string& locations_collection_file) :
8311 locations_collection_file{locations_collection_file}
8312{
8313}
8314
8316{
8317 yarp::os::idl::WireWriter writer(connection);
8318 if (!writer.writeListHeader(s_cmd_len)) {
8319 return false;
8320 }
8321 return write(writer);
8322}
8323
8325{
8326 yarp::os::idl::WireReader reader(connection);
8327 if (!reader.readListHeader()) {
8328 reader.fail();
8329 return false;
8330 }
8331 return read(reader);
8332}
8333
8335{
8336 if (!writeTag(writer)) {
8337 return false;
8338 }
8339 if (!writeArgs(writer)) {
8340 return false;
8341 }
8342 return true;
8343}
8344
8346{
8347 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8348 return false;
8349 }
8350 return true;
8351}
8352
8354{
8355 if (!writer.writeString(locations_collection_file)) {
8356 return false;
8357 }
8358 return true;
8359}
8360
8362{
8363 if (!readTag(reader)) {
8364 return false;
8365 }
8366 if (!readArgs(reader)) {
8367 return false;
8368 }
8369 return true;
8370}
8371
8373{
8374 std::string tag = reader.readTag(s_tag_len);
8375 if (reader.isError()) {
8376 return false;
8377 }
8378 if (tag != s_tag) {
8379 reader.fail();
8380 return false;
8381 }
8382 return true;
8383}
8384
8386{
8387 if (reader.noMore()) {
8388 reader.fail();
8389 return false;
8390 }
8391 if (!reader.readString(locations_collection_file)) {
8392 reader.fail();
8393 return false;
8394 }
8395 if (!reader.noMore()) {
8396 reader.fail();
8397 return false;
8398 }
8399 return true;
8400}
8401
8403{
8404 yarp::os::idl::WireWriter writer(connection);
8405 return write(writer);
8406}
8407
8409{
8410 yarp::os::idl::WireReader reader(connection);
8411 return read(reader);
8412}
8413
8415{
8416 if (!writer.isNull()) {
8417 if (!writer.write(return_helper)) {
8418 return false;
8419 }
8420 }
8421 return true;
8422}
8423
8425{
8426 if (reader.noMore()) {
8427 reader.fail();
8428 return false;
8429 }
8430 if (!reader.read(return_helper)) {
8431 reader.fail();
8432 return false;
8433 }
8434 return true;
8435}
8436
8441
8442// save_map_to_disk_RPC helper class implementation
8443IMap2DMsgs_save_map_to_disk_RPC_helper::IMap2DMsgs_save_map_to_disk_RPC_helper(const std::string& map_name, const std::string& file_name) :
8444 cmd{map_name, file_name}
8445{
8446}
8447
8449{
8450 return cmd.write(connection);
8451}
8452
8454{
8455 return reply.read(connection);
8456}
8457
8458IMap2DMsgs_save_map_to_disk_RPC_helper::Command::Command(const std::string& map_name, const std::string& file_name) :
8459 map_name{map_name},
8460 file_name{file_name}
8461{
8462}
8463
8465{
8466 yarp::os::idl::WireWriter writer(connection);
8467 if (!writer.writeListHeader(s_cmd_len)) {
8468 return false;
8469 }
8470 return write(writer);
8471}
8472
8474{
8475 yarp::os::idl::WireReader reader(connection);
8476 if (!reader.readListHeader()) {
8477 reader.fail();
8478 return false;
8479 }
8480 return read(reader);
8481}
8482
8484{
8485 if (!writeTag(writer)) {
8486 return false;
8487 }
8488 if (!writeArgs(writer)) {
8489 return false;
8490 }
8491 return true;
8492}
8493
8495{
8496 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8497 return false;
8498 }
8499 return true;
8500}
8501
8503{
8504 if (!writer.writeString(map_name)) {
8505 return false;
8506 }
8507 if (!writer.writeString(file_name)) {
8508 return false;
8509 }
8510 return true;
8511}
8512
8514{
8515 if (!readTag(reader)) {
8516 return false;
8517 }
8518 if (!readArgs(reader)) {
8519 return false;
8520 }
8521 return true;
8522}
8523
8525{
8526 std::string tag = reader.readTag(s_tag_len);
8527 if (reader.isError()) {
8528 return false;
8529 }
8530 if (tag != s_tag) {
8531 reader.fail();
8532 return false;
8533 }
8534 return true;
8535}
8536
8538{
8539 if (reader.noMore()) {
8540 reader.fail();
8541 return false;
8542 }
8543 if (!reader.readString(map_name)) {
8544 reader.fail();
8545 return false;
8546 }
8547 if (reader.noMore()) {
8548 reader.fail();
8549 return false;
8550 }
8551 if (!reader.readString(file_name)) {
8552 reader.fail();
8553 return false;
8554 }
8555 if (!reader.noMore()) {
8556 reader.fail();
8557 return false;
8558 }
8559 return true;
8560}
8561
8563{
8564 yarp::os::idl::WireWriter writer(connection);
8565 return write(writer);
8566}
8567
8569{
8570 yarp::os::idl::WireReader reader(connection);
8571 return read(reader);
8572}
8573
8575{
8576 if (!writer.isNull()) {
8577 if (!writer.write(return_helper)) {
8578 return false;
8579 }
8580 }
8581 return true;
8582}
8583
8585{
8586 if (reader.noMore()) {
8587 reader.fail();
8588 return false;
8589 }
8590 if (!reader.read(return_helper)) {
8591 reader.fail();
8592 return false;
8593 }
8594 return true;
8595}
8596
8601
8602// load_map_from_disk_RPC helper class implementation
8604 cmd{file_name}
8605{
8606}
8607
8609{
8610 return cmd.write(connection);
8611}
8612
8614{
8615 return reply.read(connection);
8616}
8617
8619 file_name{file_name}
8620{
8621}
8622
8624{
8625 yarp::os::idl::WireWriter writer(connection);
8626 if (!writer.writeListHeader(s_cmd_len)) {
8627 return false;
8628 }
8629 return write(writer);
8630}
8631
8633{
8634 yarp::os::idl::WireReader reader(connection);
8635 if (!reader.readListHeader()) {
8636 reader.fail();
8637 return false;
8638 }
8639 return read(reader);
8640}
8641
8643{
8644 if (!writeTag(writer)) {
8645 return false;
8646 }
8647 if (!writeArgs(writer)) {
8648 return false;
8649 }
8650 return true;
8651}
8652
8654{
8655 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8656 return false;
8657 }
8658 return true;
8659}
8660
8662{
8663 if (!writer.writeString(file_name)) {
8664 return false;
8665 }
8666 return true;
8667}
8668
8670{
8671 if (!readTag(reader)) {
8672 return false;
8673 }
8674 if (!readArgs(reader)) {
8675 return false;
8676 }
8677 return true;
8678}
8679
8681{
8682 std::string tag = reader.readTag(s_tag_len);
8683 if (reader.isError()) {
8684 return false;
8685 }
8686 if (tag != s_tag) {
8687 reader.fail();
8688 return false;
8689 }
8690 return true;
8691}
8692
8694{
8695 if (reader.noMore()) {
8696 reader.fail();
8697 return false;
8698 }
8699 if (!reader.readString(file_name)) {
8700 reader.fail();
8701 return false;
8702 }
8703 if (!reader.noMore()) {
8704 reader.fail();
8705 return false;
8706 }
8707 return true;
8708}
8709
8711{
8712 yarp::os::idl::WireWriter writer(connection);
8713 return write(writer);
8714}
8715
8717{
8718 yarp::os::idl::WireReader reader(connection);
8719 return read(reader);
8720}
8721
8723{
8724 if (!writer.isNull()) {
8725 if (!writer.write(return_helper)) {
8726 return false;
8727 }
8728 }
8729 return true;
8730}
8731
8733{
8734 if (reader.noMore()) {
8735 reader.fail();
8736 return false;
8737 }
8738 if (!reader.read(return_helper)) {
8739 reader.fail();
8740 return false;
8741 }
8742 return true;
8743}
8744
8749
8750// enable_maps_compression_RPC helper class implementation
8752 cmd{enable_compression}
8753{
8754}
8755
8757{
8758 return cmd.write(connection);
8759}
8760
8765
8767 enable_compression{enable_compression}
8768{
8769}
8770
8772{
8773 yarp::os::idl::WireWriter writer(connection);
8774 if (!writer.writeListHeader(s_cmd_len)) {
8775 return false;
8776 }
8777 return write(writer);
8778}
8779
8781{
8782 yarp::os::idl::WireReader reader(connection);
8783 if (!reader.readListHeader()) {
8784 reader.fail();
8785 return false;
8786 }
8787 return read(reader);
8788}
8789
8791{
8792 if (!writeTag(writer)) {
8793 return false;
8794 }
8795 if (!writeArgs(writer)) {
8796 return false;
8797 }
8798 return true;
8799}
8800
8802{
8803 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8804 return false;
8805 }
8806 return true;
8807}
8808
8810{
8811 if (!writer.writeBool(enable_compression)) {
8812 return false;
8813 }
8814 return true;
8815}
8816
8818{
8819 if (!readTag(reader)) {
8820 return false;
8821 }
8822 if (!readArgs(reader)) {
8823 return false;
8824 }
8825 return true;
8826}
8827
8829{
8830 std::string tag = reader.readTag(s_tag_len);
8831 if (reader.isError()) {
8832 return false;
8833 }
8834 if (tag != s_tag) {
8835 reader.fail();
8836 return false;
8837 }
8838 return true;
8839}
8840
8842{
8843 if (reader.noMore()) {
8844 reader.fail();
8845 return false;
8846 }
8847 if (!reader.readBool(enable_compression)) {
8848 reader.fail();
8849 return false;
8850 }
8851 if (!reader.noMore()) {
8852 reader.fail();
8853 return false;
8854 }
8855 return true;
8856}
8857
8859{
8860 yarp::os::idl::WireWriter writer(connection);
8861 return write(writer);
8862}
8863
8865{
8866 yarp::os::idl::WireReader reader(connection);
8867 return read(reader);
8868}
8869
8871{
8872 if (!writer.isNull()) {
8873 if (!writer.write(return_helper)) {
8874 return false;
8875 }
8876 }
8877 return true;
8878}
8879
8881{
8882 if (reader.noMore()) {
8883 reader.fail();
8884 return false;
8885 }
8886 if (!reader.read(return_helper)) {
8887 reader.fail();
8888 return false;
8889 }
8890 return true;
8891}
8892
8897
8898// reload_maps_collection_RPC helper class implementation
8900{
8901 return cmd.write(connection);
8902}
8903
8908
8910{
8911 yarp::os::idl::WireWriter writer(connection);
8912 if (!writer.writeListHeader(s_cmd_len)) {
8913 return false;
8914 }
8915 return write(writer);
8916}
8917
8919{
8920 yarp::os::idl::WireReader reader(connection);
8921 if (!reader.readListHeader()) {
8922 reader.fail();
8923 return false;
8924 }
8925 return read(reader);
8926}
8927
8929{
8930 if (!writeTag(writer)) {
8931 return false;
8932 }
8933 if (!writeArgs(writer)) {
8934 return false;
8935 }
8936 return true;
8937}
8938
8940{
8941 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8942 return false;
8943 }
8944 return true;
8945}
8946
8948{
8949 return true;
8950}
8951
8953{
8954 if (!readTag(reader)) {
8955 return false;
8956 }
8957 if (!readArgs(reader)) {
8958 return false;
8959 }
8960 return true;
8961}
8962
8964{
8965 std::string tag = reader.readTag(s_tag_len);
8966 if (reader.isError()) {
8967 return false;
8968 }
8969 if (tag != s_tag) {
8970 reader.fail();
8971 return false;
8972 }
8973 return true;
8974}
8975
8977{
8978 if (!reader.noMore()) {
8979 reader.fail();
8980 return false;
8981 }
8982 return true;
8983}
8984
8986{
8987 yarp::os::idl::WireWriter writer(connection);
8988 return write(writer);
8989}
8990
8992{
8993 yarp::os::idl::WireReader reader(connection);
8994 return read(reader);
8995}
8996
8998{
8999 if (!writer.isNull()) {
9000 if (!writer.write(return_helper)) {
9001 return false;
9002 }
9003 }
9004 return true;
9005}
9006
9008{
9009 if (reader.noMore()) {
9010 reader.fail();
9011 return false;
9012 }
9013 if (!reader.read(return_helper)) {
9014 reader.fail();
9015 return false;
9016 }
9017 return true;
9018}
9019
9024
9025// reload_locations_and_extras_RPC helper class implementation
9027{
9028 return cmd.write(connection);
9029}
9030
9035
9037{
9038 yarp::os::idl::WireWriter writer(connection);
9039 if (!writer.writeListHeader(s_cmd_len)) {
9040 return false;
9041 }
9042 return write(writer);
9043}
9044
9046{
9047 yarp::os::idl::WireReader reader(connection);
9048 if (!reader.readListHeader()) {
9049 reader.fail();
9050 return false;
9051 }
9052 return read(reader);
9053}
9054
9056{
9057 if (!writeTag(writer)) {
9058 return false;
9059 }
9060 if (!writeArgs(writer)) {
9061 return false;
9062 }
9063 return true;
9064}
9065
9067{
9068 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
9069 return false;
9070 }
9071 return true;
9072}
9073
9075{
9076 return true;
9077}
9078
9080{
9081 if (!readTag(reader)) {
9082 return false;
9083 }
9084 if (!readArgs(reader)) {
9085 return false;
9086 }
9087 return true;
9088}
9089
9091{
9092 std::string tag = reader.readTag(s_tag_len);
9093 if (reader.isError()) {
9094 return false;
9095 }
9096 if (tag != s_tag) {
9097 reader.fail();
9098 return false;
9099 }
9100 return true;
9101}
9102
9104{
9105 if (!reader.noMore()) {
9106 reader.fail();
9107 return false;
9108 }
9109 return true;
9110}
9111
9113{
9114 yarp::os::idl::WireWriter writer(connection);
9115 return write(writer);
9116}
9117
9123
9125{
9126 if (!writer.isNull()) {
9127 if (!writer.write(return_helper)) {
9128 return false;
9129 }
9130 }
9131 return true;
9132}
9133
9135{
9136 if (reader.noMore()) {
9137 reader.fail();
9138 return false;
9139 }
9140 if (!reader.read(return_helper)) {
9141 reader.fail();
9142 return false;
9143 }
9144 return true;
9145}
9146
9151
9152// Constructor
9154{
9155 yarp().setOwner(*this);
9156}
9157
9159{
9160 if (!yarp().canWrite()) {
9161 yError("Missing server method '%s'?", IMap2DMsgs_clear_all_maps_RPC_helper::s_prototype);
9162 }
9164 bool ok = yarp().write(helper, helper);
9166}
9167
9169{
9170 if (!yarp().canWrite()) {
9171 yError("Missing server method '%s'?", IMap2DMsgs_store_map_RPC_helper::s_prototype);
9172 }
9173 IMap2DMsgs_store_map_RPC_helper helper{themap};
9174 bool ok = yarp().write(helper, helper);
9176}
9177
9178return_get_map IMap2DMsgs::get_map_RPC(const std::string& map_name)
9179{
9180 if (!yarp().canWrite()) {
9181 yError("Missing server method '%s'?", IMap2DMsgs_get_map_RPC_helper::s_prototype);
9182 }
9183 IMap2DMsgs_get_map_RPC_helper helper{map_name};
9184 bool ok = yarp().write(helper, helper);
9185 if (!ok) {
9186 return_get_map failed_reply{};
9188 return failed_reply;
9189 }
9190 return helper.reply.return_helper;
9191}
9192
9194{
9195 if (!yarp().canWrite()) {
9196 yError("Missing server method '%s'?", IMap2DMsgs_get_map_names_RPC_helper::s_prototype);
9197 }
9199 bool ok = yarp().write(helper, helper);
9200 if (!ok) {
9201 return_get_map_names failed_reply{};
9203 return failed_reply;
9204 }
9205 return helper.reply.return_helper;
9206}
9207
9209{
9210 if (!yarp().canWrite()) {
9211 yError("Missing server method '%s'?", IMap2DMsgs_remove_map_RPC_helper::s_prototype);
9212 }
9213 IMap2DMsgs_remove_map_RPC_helper helper{map_name};
9214 bool ok = yarp().write(helper, helper);
9216}
9217
9219{
9220 if (!yarp().canWrite()) {
9221 yError("Missing server method '%s'?", IMap2DMsgs_store_object_RPC_helper::s_prototype);
9222 }
9223 IMap2DMsgs_store_object_RPC_helper helper{object_name, loc};
9224 bool ok = yarp().write(helper, helper);
9226}
9227
9229{
9230 if (!yarp().canWrite()) {
9231 yError("Missing server method '%s'?", IMap2DMsgs_store_location_RPC_helper::s_prototype);
9232 }
9233 IMap2DMsgs_store_location_RPC_helper helper{location_name, loc};
9234 bool ok = yarp().write(helper, helper);
9236}
9237
9239{
9240 if (!yarp().canWrite()) {
9241 yError("Missing server method '%s'?", IMap2DMsgs_store_area_RPC_helper::s_prototype);
9242 }
9243 IMap2DMsgs_store_area_RPC_helper helper{area_name, area};
9244 bool ok = yarp().write(helper, helper);
9246}
9247
9249{
9250 if (!yarp().canWrite()) {
9251 yError("Missing server method '%s'?", IMap2DMsgs_store_path_RPC_helper::s_prototype);
9252 }
9253 IMap2DMsgs_store_path_RPC_helper helper{path_name, path};
9254 bool ok = yarp().write(helper, helper);
9256}
9257
9258return_get_object IMap2DMsgs::get_object_RPC(const std::string& object_name)
9259{
9260 if (!yarp().canWrite()) {
9261 yError("Missing server method '%s'?", IMap2DMsgs_get_object_RPC_helper::s_prototype);
9262 }
9263 IMap2DMsgs_get_object_RPC_helper helper{object_name};
9264 bool ok = yarp().write(helper, helper);
9265 if (!ok) {
9266 return_get_object failed_reply{};
9268 return failed_reply;
9269 }
9270 return helper.reply.return_helper;
9271}
9272
9273return_get_location IMap2DMsgs::get_location_RPC(const std::string& location_name)
9274{
9275 if (!yarp().canWrite()) {
9276 yError("Missing server method '%s'?", IMap2DMsgs_get_location_RPC_helper::s_prototype);
9277 }
9278 IMap2DMsgs_get_location_RPC_helper helper{location_name};
9279 bool ok = yarp().write(helper, helper);
9280 if (!ok) {
9281 return_get_location failed_reply{};
9283 return failed_reply;
9284 }
9285 return helper.reply.return_helper;
9286}
9287
9288return_get_area IMap2DMsgs::get_area_RPC(const std::string& area_name)
9289{
9290 if (!yarp().canWrite()) {
9291 yError("Missing server method '%s'?", IMap2DMsgs_get_area_RPC_helper::s_prototype);
9292 }
9293 IMap2DMsgs_get_area_RPC_helper helper{area_name};
9294 bool ok = yarp().write(helper, helper);
9295 if (!ok) {
9296 return_get_area failed_reply{};
9298 return failed_reply;
9299 }
9300 return helper.reply.return_helper;
9301}
9302
9303return_get_path IMap2DMsgs::get_path_RPC(const std::string& path_name)
9304{
9305 if (!yarp().canWrite()) {
9306 yError("Missing server method '%s'?", IMap2DMsgs_get_path_RPC_helper::s_prototype);
9307 }
9308 IMap2DMsgs_get_path_RPC_helper helper{path_name};
9309 bool ok = yarp().write(helper, helper);
9310 if (!ok) {
9311 return_get_path failed_reply{};
9313 return failed_reply;
9314 }
9315 return helper.reply.return_helper;
9316}
9317
9319{
9320 if (!yarp().canWrite()) {
9321 yError("Missing server method '%s'?", IMap2DMsgs_get_objects_list_RPC_helper::s_prototype);
9322 }
9324 bool ok = yarp().write(helper, helper);
9325 if (!ok) {
9326 return_get_objects_list failed_reply{};
9328 return failed_reply;
9329 }
9330 return helper.reply.return_helper;
9331}
9332
9334{
9335 if (!yarp().canWrite()) {
9336 yError("Missing server method '%s'?", IMap2DMsgs_get_locations_list_RPC_helper::s_prototype);
9337 }
9339 bool ok = yarp().write(helper, helper);
9340 if (!ok) {
9341 return_get_locations_list failed_reply{};
9343 return failed_reply;
9344 }
9345 return helper.reply.return_helper;
9346}
9347
9349{
9350 if (!yarp().canWrite()) {
9351 yError("Missing server method '%s'?", IMap2DMsgs_get_areas_list_RPC_helper::s_prototype);
9352 }
9354 bool ok = yarp().write(helper, helper);
9355 if (!ok) {
9356 return_get_areas_list failed_reply{};
9358 return failed_reply;
9359 }
9360 return helper.reply.return_helper;
9361}
9362
9364{
9365 if (!yarp().canWrite()) {
9366 yError("Missing server method '%s'?", IMap2DMsgs_get_paths_list_RPC_helper::s_prototype);
9367 }
9369 bool ok = yarp().write(helper, helper);
9370 if (!ok) {
9371 return_get_paths_list failed_reply{};
9373 return failed_reply;
9374 }
9375 return helper.reply.return_helper;
9376}
9377
9379{
9380 if (!yarp().canWrite()) {
9381 yError("Missing server method '%s'?", IMap2DMsgs_get_all_objects_RPC_helper::s_prototype);
9382 }
9384 bool ok = yarp().write(helper, helper);
9385 if (!ok) {
9386 return_get_all_objects failed_reply{};
9388 return failed_reply;
9389 }
9390 return helper.reply.return_helper;
9391}
9392
9394{
9395 if (!yarp().canWrite()) {
9396 yError("Missing server method '%s'?", IMap2DMsgs_get_all_locations_RPC_helper::s_prototype);
9397 }
9399 bool ok = yarp().write(helper, helper);
9400 if (!ok) {
9401 return_get_all_locations failed_reply{};
9403 return failed_reply;
9404 }
9405 return helper.reply.return_helper;
9406}
9407
9409{
9410 if (!yarp().canWrite()) {
9411 yError("Missing server method '%s'?", IMap2DMsgs_get_all_areas_RPC_helper::s_prototype);
9412 }
9414 bool ok = yarp().write(helper, helper);
9415 if (!ok) {
9416 return_get_all_areas failed_reply{};
9418 return failed_reply;
9419 }
9420 return helper.reply.return_helper;
9421}
9422
9424{
9425 if (!yarp().canWrite()) {
9426 yError("Missing server method '%s'?", IMap2DMsgs_get_all_paths_RPC_helper::s_prototype);
9427 }
9429 bool ok = yarp().write(helper, helper);
9430 if (!ok) {
9431 return_get_all_paths failed_reply{};
9433 return failed_reply;
9434 }
9435 return helper.reply.return_helper;
9436}
9437
9438yarp::dev::ReturnValue IMap2DMsgs::rename_location_RPC(const std::string& original_name, const std::string& new_name)
9439{
9440 if (!yarp().canWrite()) {
9441 yError("Missing server method '%s'?", IMap2DMsgs_rename_location_RPC_helper::s_prototype);
9442 }
9443 IMap2DMsgs_rename_location_RPC_helper helper{original_name, new_name};
9444 bool ok = yarp().write(helper, helper);
9446}
9447
9449{
9450 if (!yarp().canWrite()) {
9451 yError("Missing server method '%s'?", IMap2DMsgs_delete_object_RPC_helper::s_prototype);
9452 }
9453 IMap2DMsgs_delete_object_RPC_helper helper{object_name};
9454 bool ok = yarp().write(helper, helper);
9456}
9457
9459{
9460 if (!yarp().canWrite()) {
9461 yError("Missing server method '%s'?", IMap2DMsgs_delete_location_RPC_helper::s_prototype);
9462 }
9463 IMap2DMsgs_delete_location_RPC_helper helper{location_name};
9464 bool ok = yarp().write(helper, helper);
9466}
9467
9469{
9470 if (!yarp().canWrite()) {
9471 yError("Missing server method '%s'?", IMap2DMsgs_delete_path_RPC_helper::s_prototype);
9472 }
9473 IMap2DMsgs_delete_path_RPC_helper helper{path_name};
9474 bool ok = yarp().write(helper, helper);
9476}
9477
9478yarp::dev::ReturnValue IMap2DMsgs::rename_object_RPC(const std::string& original_name, const std::string& new_name)
9479{
9480 if (!yarp().canWrite()) {
9481 yError("Missing server method '%s'?", IMap2DMsgs_rename_object_RPC_helper::s_prototype);
9482 }
9483 IMap2DMsgs_rename_object_RPC_helper helper{original_name, new_name};
9484 bool ok = yarp().write(helper, helper);
9486}
9487
9488yarp::dev::ReturnValue IMap2DMsgs::rename_area_RPC(const std::string& original_name, const std::string& new_name)
9489{
9490 if (!yarp().canWrite()) {
9491 yError("Missing server method '%s'?", IMap2DMsgs_rename_area_RPC_helper::s_prototype);
9492 }
9493 IMap2DMsgs_rename_area_RPC_helper helper{original_name, new_name};
9494 bool ok = yarp().write(helper, helper);
9496}
9497
9498yarp::dev::ReturnValue IMap2DMsgs::rename_path_RPC(const std::string& original_name, const std::string& new_name)
9499{
9500 if (!yarp().canWrite()) {
9501 yError("Missing server method '%s'?", IMap2DMsgs_rename_path_RPC_helper::s_prototype);
9502 }
9503 IMap2DMsgs_rename_path_RPC_helper helper{original_name, new_name};
9504 bool ok = yarp().write(helper, helper);
9506}
9507
9509{
9510 if (!yarp().canWrite()) {
9511 yError("Missing server method '%s'?", IMap2DMsgs_delete_area_RPC_helper::s_prototype);
9512 }
9513 IMap2DMsgs_delete_area_RPC_helper helper{area_name};
9514 bool ok = yarp().write(helper, helper);
9516}
9517
9519{
9520 if (!yarp().canWrite()) {
9521 yError("Missing server method '%s'?", IMap2DMsgs_clear_all_objects_RPC_helper::s_prototype);
9522 }
9524 bool ok = yarp().write(helper, helper);
9526}
9527
9529{
9530 if (!yarp().canWrite()) {
9531 yError("Missing server method '%s'?", IMap2DMsgs_clear_all_locations_RPC_helper::s_prototype);
9532 }
9534 bool ok = yarp().write(helper, helper);
9536}
9537
9539{
9540 if (!yarp().canWrite()) {
9541 yError("Missing server method '%s'?", IMap2DMsgs_clear_all_areas_RPC_helper::s_prototype);
9542 }
9544 bool ok = yarp().write(helper, helper);
9546}
9547
9549{
9550 if (!yarp().canWrite()) {
9551 yError("Missing server method '%s'?", IMap2DMsgs_clear_all_paths_RPC_helper::s_prototype);
9552 }
9554 bool ok = yarp().write(helper, helper);
9556}
9557
9567
9569{
9570 if (!yarp().canWrite()) {
9572 }
9574 bool ok = yarp().write(helper, helper);
9576}
9577
9578yarp::dev::ReturnValue IMap2DMsgs::save_maps_collection_RPC(const std::string& maps_collection_file)
9579{
9580 if (!yarp().canWrite()) {
9582 }
9583 IMap2DMsgs_save_maps_collection_RPC_helper helper{maps_collection_file};
9584 bool ok = yarp().write(helper, helper);
9586}
9587
9588yarp::dev::ReturnValue IMap2DMsgs::load_maps_collection_RPC(const std::string& maps_collection_file)
9589{
9590 if (!yarp().canWrite()) {
9592 }
9593 IMap2DMsgs_load_maps_collection_RPC_helper helper{maps_collection_file};
9594 bool ok = yarp().write(helper, helper);
9596}
9597
9598yarp::dev::ReturnValue IMap2DMsgs::save_locations_and_extras_RPC(const std::string& locations_collection_file)
9599{
9600 if (!yarp().canWrite()) {
9602 }
9603 IMap2DMsgs_save_locations_and_extras_RPC_helper helper{locations_collection_file};
9604 bool ok = yarp().write(helper, helper);
9606}
9607
9608yarp::dev::ReturnValue IMap2DMsgs::load_locations_and_extras_RPC(const std::string& locations_collection_file)
9609{
9610 if (!yarp().canWrite()) {
9612 }
9613 IMap2DMsgs_load_locations_and_extras_RPC_helper helper{locations_collection_file};
9614 bool ok = yarp().write(helper, helper);
9616}
9617
9618yarp::dev::ReturnValue IMap2DMsgs::save_map_to_disk_RPC(const std::string& map_name, const std::string& file_name)
9619{
9620 if (!yarp().canWrite()) {
9621 yError("Missing server method '%s'?", IMap2DMsgs_save_map_to_disk_RPC_helper::s_prototype);
9622 }
9623 IMap2DMsgs_save_map_to_disk_RPC_helper helper{map_name, file_name};
9624 bool ok = yarp().write(helper, helper);
9626}
9627
9629{
9630 if (!yarp().canWrite()) {
9631 yError("Missing server method '%s'?", IMap2DMsgs_load_map_from_disk_RPC_helper::s_prototype);
9632 }
9634 bool ok = yarp().write(helper, helper);
9636}
9637
9639{
9640 if (!yarp().canWrite()) {
9642 }
9643 IMap2DMsgs_enable_maps_compression_RPC_helper helper{enable_compression};
9644 bool ok = yarp().write(helper, helper);
9646}
9647
9649{
9650 if (!yarp().canWrite()) {
9652 }
9654 bool ok = yarp().write(helper, helper);
9656}
9657
9667
9668// help method
9669std::vector<std::string> IMap2DMsgs::help(const std::string& functionName)
9670{
9671 bool showAll = (functionName == "--all");
9672 std::vector<std::string> helpString;
9673 if (showAll) {
9674 helpString.emplace_back("*** Available commands:");
9675 helpString.emplace_back(IMap2DMsgs_clear_all_maps_RPC_helper::s_tag);
9676 helpString.emplace_back(IMap2DMsgs_store_map_RPC_helper::s_tag);
9677 helpString.emplace_back(IMap2DMsgs_get_map_RPC_helper::s_tag);
9678 helpString.emplace_back(IMap2DMsgs_get_map_names_RPC_helper::s_tag);
9679 helpString.emplace_back(IMap2DMsgs_remove_map_RPC_helper::s_tag);
9680 helpString.emplace_back(IMap2DMsgs_store_object_RPC_helper::s_tag);
9681 helpString.emplace_back(IMap2DMsgs_store_location_RPC_helper::s_tag);
9682 helpString.emplace_back(IMap2DMsgs_store_area_RPC_helper::s_tag);
9683 helpString.emplace_back(IMap2DMsgs_store_path_RPC_helper::s_tag);
9684 helpString.emplace_back(IMap2DMsgs_get_object_RPC_helper::s_tag);
9685 helpString.emplace_back(IMap2DMsgs_get_location_RPC_helper::s_tag);
9686 helpString.emplace_back(IMap2DMsgs_get_area_RPC_helper::s_tag);
9687 helpString.emplace_back(IMap2DMsgs_get_path_RPC_helper::s_tag);
9688 helpString.emplace_back(IMap2DMsgs_get_objects_list_RPC_helper::s_tag);
9689 helpString.emplace_back(IMap2DMsgs_get_locations_list_RPC_helper::s_tag);
9690 helpString.emplace_back(IMap2DMsgs_get_areas_list_RPC_helper::s_tag);
9691 helpString.emplace_back(IMap2DMsgs_get_paths_list_RPC_helper::s_tag);
9692 helpString.emplace_back(IMap2DMsgs_get_all_objects_RPC_helper::s_tag);
9693 helpString.emplace_back(IMap2DMsgs_get_all_locations_RPC_helper::s_tag);
9694 helpString.emplace_back(IMap2DMsgs_get_all_areas_RPC_helper::s_tag);
9695 helpString.emplace_back(IMap2DMsgs_get_all_paths_RPC_helper::s_tag);
9696 helpString.emplace_back(IMap2DMsgs_rename_location_RPC_helper::s_tag);
9697 helpString.emplace_back(IMap2DMsgs_delete_object_RPC_helper::s_tag);
9698 helpString.emplace_back(IMap2DMsgs_delete_location_RPC_helper::s_tag);
9699 helpString.emplace_back(IMap2DMsgs_delete_path_RPC_helper::s_tag);
9700 helpString.emplace_back(IMap2DMsgs_rename_object_RPC_helper::s_tag);
9701 helpString.emplace_back(IMap2DMsgs_rename_area_RPC_helper::s_tag);
9702 helpString.emplace_back(IMap2DMsgs_rename_path_RPC_helper::s_tag);
9703 helpString.emplace_back(IMap2DMsgs_delete_area_RPC_helper::s_tag);
9704 helpString.emplace_back(IMap2DMsgs_clear_all_objects_RPC_helper::s_tag);
9705 helpString.emplace_back(IMap2DMsgs_clear_all_locations_RPC_helper::s_tag);
9706 helpString.emplace_back(IMap2DMsgs_clear_all_areas_RPC_helper::s_tag);
9707 helpString.emplace_back(IMap2DMsgs_clear_all_paths_RPC_helper::s_tag);
9714 helpString.emplace_back(IMap2DMsgs_save_map_to_disk_RPC_helper::s_tag);
9715 helpString.emplace_back(IMap2DMsgs_load_map_from_disk_RPC_helper::s_tag);
9719 helpString.emplace_back("help");
9720 } else {
9721 if (functionName == IMap2DMsgs_clear_all_maps_RPC_helper::s_tag) {
9723 }
9724 if (functionName == IMap2DMsgs_store_map_RPC_helper::s_tag) {
9725 helpString.emplace_back(IMap2DMsgs_store_map_RPC_helper::s_prototype);
9726 }
9727 if (functionName == IMap2DMsgs_get_map_RPC_helper::s_tag) {
9728 helpString.emplace_back(IMap2DMsgs_get_map_RPC_helper::s_prototype);
9729 }
9730 if (functionName == IMap2DMsgs_get_map_names_RPC_helper::s_tag) {
9731 helpString.emplace_back(IMap2DMsgs_get_map_names_RPC_helper::s_prototype);
9732 }
9733 if (functionName == IMap2DMsgs_remove_map_RPC_helper::s_tag) {
9734 helpString.emplace_back(IMap2DMsgs_remove_map_RPC_helper::s_prototype);
9735 }
9736 if (functionName == IMap2DMsgs_store_object_RPC_helper::s_tag) {
9737 helpString.emplace_back(IMap2DMsgs_store_object_RPC_helper::s_prototype);
9738 }
9739 if (functionName == IMap2DMsgs_store_location_RPC_helper::s_tag) {
9741 }
9742 if (functionName == IMap2DMsgs_store_area_RPC_helper::s_tag) {
9743 helpString.emplace_back(IMap2DMsgs_store_area_RPC_helper::s_prototype);
9744 }
9745 if (functionName == IMap2DMsgs_store_path_RPC_helper::s_tag) {
9746 helpString.emplace_back(IMap2DMsgs_store_path_RPC_helper::s_prototype);
9747 }
9748 if (functionName == IMap2DMsgs_get_object_RPC_helper::s_tag) {
9749 helpString.emplace_back(IMap2DMsgs_get_object_RPC_helper::s_prototype);
9750 }
9751 if (functionName == IMap2DMsgs_get_location_RPC_helper::s_tag) {
9752 helpString.emplace_back(IMap2DMsgs_get_location_RPC_helper::s_prototype);
9753 }
9754 if (functionName == IMap2DMsgs_get_area_RPC_helper::s_tag) {
9755 helpString.emplace_back(IMap2DMsgs_get_area_RPC_helper::s_prototype);
9756 }
9757 if (functionName == IMap2DMsgs_get_path_RPC_helper::s_tag) {
9758 helpString.emplace_back(IMap2DMsgs_get_path_RPC_helper::s_prototype);
9759 }
9762 }
9765 }
9766 if (functionName == IMap2DMsgs_get_areas_list_RPC_helper::s_tag) {
9768 }
9769 if (functionName == IMap2DMsgs_get_paths_list_RPC_helper::s_tag) {
9771 }
9774 }
9777 }
9778 if (functionName == IMap2DMsgs_get_all_areas_RPC_helper::s_tag) {
9779 helpString.emplace_back(IMap2DMsgs_get_all_areas_RPC_helper::s_prototype);
9780 }
9781 if (functionName == IMap2DMsgs_get_all_paths_RPC_helper::s_tag) {
9782 helpString.emplace_back(IMap2DMsgs_get_all_paths_RPC_helper::s_prototype);
9783 }
9786 }
9787 if (functionName == IMap2DMsgs_delete_object_RPC_helper::s_tag) {
9788 helpString.emplace_back(IMap2DMsgs_delete_object_RPC_helper::s_prototype);
9789 }
9792 }
9793 if (functionName == IMap2DMsgs_delete_path_RPC_helper::s_tag) {
9794 helpString.emplace_back(IMap2DMsgs_delete_path_RPC_helper::s_prototype);
9795 }
9796 if (functionName == IMap2DMsgs_rename_object_RPC_helper::s_tag) {
9797 helpString.emplace_back(IMap2DMsgs_rename_object_RPC_helper::s_prototype);
9798 }
9799 if (functionName == IMap2DMsgs_rename_area_RPC_helper::s_tag) {
9800 helpString.emplace_back(IMap2DMsgs_rename_area_RPC_helper::s_prototype);
9801 }
9802 if (functionName == IMap2DMsgs_rename_path_RPC_helper::s_tag) {
9803 helpString.emplace_back(IMap2DMsgs_rename_path_RPC_helper::s_prototype);
9804 }
9805 if (functionName == IMap2DMsgs_delete_area_RPC_helper::s_tag) {
9806 helpString.emplace_back(IMap2DMsgs_delete_area_RPC_helper::s_prototype);
9807 }
9810 }
9813 }
9816 }
9819 }
9822 }
9825 }
9828 }
9831 }
9834 }
9837 }
9840 }
9843 }
9846 }
9849 }
9852 }
9853 if (functionName == "help") {
9854 helpString.emplace_back("std::vector<std::string> help(const std::string& functionName = \"--all\")");
9855 helpString.emplace_back("Return list of available commands, or help message for a specific function");
9856 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");
9857 helpString.emplace_back("@return list of strings (one string per line)");
9858 }
9859 }
9860 if (helpString.empty()) {
9861 helpString.emplace_back("Command not found");
9862 }
9863 return helpString;
9864}
9865
9866// read from ConnectionReader
9868{
9869 constexpr size_t max_tag_len = 6;
9870 size_t tag_len = 1;
9871
9872 yarp::os::idl::WireReader reader(connection);
9873 reader.expectAccept();
9874 if (!reader.readListHeader()) {
9875 reader.fail();
9876 return false;
9877 }
9878
9879 std::string tag = reader.readTag(1);
9880 bool direct = (tag == "__direct__");
9881 if (direct) {
9882 tag = reader.readTag(1);
9883 }
9884 while (tag_len <= max_tag_len && !reader.isError()) {
9885 if(tag == "getRemoteProtocolVersion") {
9886 if (!reader.noMore()) {
9887 yError("Reader invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
9888 reader.fail();
9889 return false;
9890 }
9891
9892 auto proto = getLocalProtocolVersion();
9893
9894 yarp::os::idl::WireWriter writer(reader);
9895 if (!writer.writeListHeader(1)) {
9896 yWarning("Writer invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
9897 return false;}
9898 if (!writer.write(proto)) {
9899 yWarning("Writer invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
9900 return false;
9901 }
9902 reader.accept();
9903 return true;
9904 }
9907 if (!helper.cmd.readArgs(reader)) {
9908 return false;
9909 }
9910
9911 helper.call(this);
9912
9913 yarp::os::idl::WireWriter writer(reader);
9914 if (!helper.reply.write(writer)) {
9915 return false;
9916 }
9917 reader.accept();
9918 return true;
9919 }
9922 if (!helper.cmd.readArgs(reader)) {
9923 return false;
9924 }
9925
9926 helper.call(this);
9927
9928 yarp::os::idl::WireWriter writer(reader);
9929 if (!helper.reply.write(writer)) {
9930 return false;
9931 }
9932 reader.accept();
9933 return true;
9934 }
9937 if (!helper.cmd.readArgs(reader)) {
9938 return false;
9939 }
9940
9941 helper.call(this);
9942
9943 yarp::os::idl::WireWriter writer(reader);
9944 if (!helper.reply.write(writer)) {
9945 return false;
9946 }
9947 reader.accept();
9948 return true;
9949 }
9952 if (!helper.cmd.readArgs(reader)) {
9953 return false;
9954 }
9955
9956 helper.call(this);
9957
9958 yarp::os::idl::WireWriter writer(reader);
9959 if (!helper.reply.write(writer)) {
9960 return false;
9961 }
9962 reader.accept();
9963 return true;
9964 }
9967 if (!helper.cmd.readArgs(reader)) {
9968 return false;
9969 }
9970
9971 helper.call(this);
9972
9973 yarp::os::idl::WireWriter writer(reader);
9974 if (!helper.reply.write(writer)) {
9975 return false;
9976 }
9977 reader.accept();
9978 return true;
9979 }
9982 if (!helper.cmd.readArgs(reader)) {
9983 return false;
9984 }
9985
9986 helper.call(this);
9987
9988 yarp::os::idl::WireWriter writer(reader);
9989 if (!helper.reply.write(writer)) {
9990 return false;
9991 }
9992 reader.accept();
9993 return true;
9994 }
9997 if (!helper.cmd.readArgs(reader)) {
9998 return false;
9999 }
10000
10001 helper.call(this);
10002
10003 yarp::os::idl::WireWriter writer(reader);
10004 if (!helper.reply.write(writer)) {
10005 return false;
10006 }
10007 reader.accept();
10008 return true;
10009 }
10012 if (!helper.cmd.readArgs(reader)) {
10013 return false;
10014 }
10015
10016 helper.call(this);
10017
10018 yarp::os::idl::WireWriter writer(reader);
10019 if (!helper.reply.write(writer)) {
10020 return false;
10021 }
10022 reader.accept();
10023 return true;
10024 }
10027 if (!helper.cmd.readArgs(reader)) {
10028 return false;
10029 }
10030
10031 helper.call(this);
10032
10033 yarp::os::idl::WireWriter writer(reader);
10034 if (!helper.reply.write(writer)) {
10035 return false;
10036 }
10037 reader.accept();
10038 return true;
10039 }
10042 if (!helper.cmd.readArgs(reader)) {
10043 return false;
10044 }
10045
10046 helper.call(this);
10047
10048 yarp::os::idl::WireWriter writer(reader);
10049 if (!helper.reply.write(writer)) {
10050 return false;
10051 }
10052 reader.accept();
10053 return true;
10054 }
10057 if (!helper.cmd.readArgs(reader)) {
10058 return false;
10059 }
10060
10061 helper.call(this);
10062
10063 yarp::os::idl::WireWriter writer(reader);
10064 if (!helper.reply.write(writer)) {
10065 return false;
10066 }
10067 reader.accept();
10068 return true;
10069 }
10072 if (!helper.cmd.readArgs(reader)) {
10073 return false;
10074 }
10075
10076 helper.call(this);
10077
10078 yarp::os::idl::WireWriter writer(reader);
10079 if (!helper.reply.write(writer)) {
10080 return false;
10081 }
10082 reader.accept();
10083 return true;
10084 }
10087 if (!helper.cmd.readArgs(reader)) {
10088 return false;
10089 }
10090
10091 helper.call(this);
10092
10093 yarp::os::idl::WireWriter writer(reader);
10094 if (!helper.reply.write(writer)) {
10095 return false;
10096 }
10097 reader.accept();
10098 return true;
10099 }
10102 if (!helper.cmd.readArgs(reader)) {
10103 return false;
10104 }
10105
10106 helper.call(this);
10107
10108 yarp::os::idl::WireWriter writer(reader);
10109 if (!helper.reply.write(writer)) {
10110 return false;
10111 }
10112 reader.accept();
10113 return true;
10114 }
10117 if (!helper.cmd.readArgs(reader)) {
10118 return false;
10119 }
10120
10121 helper.call(this);
10122
10123 yarp::os::idl::WireWriter writer(reader);
10124 if (!helper.reply.write(writer)) {
10125 return false;
10126 }
10127 reader.accept();
10128 return true;
10129 }
10132 if (!helper.cmd.readArgs(reader)) {
10133 return false;
10134 }
10135
10136 helper.call(this);
10137
10138 yarp::os::idl::WireWriter writer(reader);
10139 if (!helper.reply.write(writer)) {
10140 return false;
10141 }
10142 reader.accept();
10143 return true;
10144 }
10147 if (!helper.cmd.readArgs(reader)) {
10148 return false;
10149 }
10150
10151 helper.call(this);
10152
10153 yarp::os::idl::WireWriter writer(reader);
10154 if (!helper.reply.write(writer)) {
10155 return false;
10156 }
10157 reader.accept();
10158 return true;
10159 }
10162 if (!helper.cmd.readArgs(reader)) {
10163 return false;
10164 }
10165
10166 helper.call(this);
10167
10168 yarp::os::idl::WireWriter writer(reader);
10169 if (!helper.reply.write(writer)) {
10170 return false;
10171 }
10172 reader.accept();
10173 return true;
10174 }
10177 if (!helper.cmd.readArgs(reader)) {
10178 return false;
10179 }
10180
10181 helper.call(this);
10182
10183 yarp::os::idl::WireWriter writer(reader);
10184 if (!helper.reply.write(writer)) {
10185 return false;
10186 }
10187 reader.accept();
10188 return true;
10189 }
10192 if (!helper.cmd.readArgs(reader)) {
10193 return false;
10194 }
10195
10196 helper.call(this);
10197
10198 yarp::os::idl::WireWriter writer(reader);
10199 if (!helper.reply.write(writer)) {
10200 return false;
10201 }
10202 reader.accept();
10203 return true;
10204 }
10207 if (!helper.cmd.readArgs(reader)) {
10208 return false;
10209 }
10210
10211 helper.call(this);
10212
10213 yarp::os::idl::WireWriter writer(reader);
10214 if (!helper.reply.write(writer)) {
10215 return false;
10216 }
10217 reader.accept();
10218 return true;
10219 }
10222 if (!helper.cmd.readArgs(reader)) {
10223 return false;
10224 }
10225
10226 helper.call(this);
10227
10228 yarp::os::idl::WireWriter writer(reader);
10229 if (!helper.reply.write(writer)) {
10230 return false;
10231 }
10232 reader.accept();
10233 return true;
10234 }
10237 if (!helper.cmd.readArgs(reader)) {
10238 return false;
10239 }
10240
10241 helper.call(this);
10242
10243 yarp::os::idl::WireWriter writer(reader);
10244 if (!helper.reply.write(writer)) {
10245 return false;
10246 }
10247 reader.accept();
10248 return true;
10249 }
10252 if (!helper.cmd.readArgs(reader)) {
10253 return false;
10254 }
10255
10256 helper.call(this);
10257
10258 yarp::os::idl::WireWriter writer(reader);
10259 if (!helper.reply.write(writer)) {
10260 return false;
10261 }
10262 reader.accept();
10263 return true;
10264 }
10267 if (!helper.cmd.readArgs(reader)) {
10268 return false;
10269 }
10270
10271 helper.call(this);
10272
10273 yarp::os::idl::WireWriter writer(reader);
10274 if (!helper.reply.write(writer)) {
10275 return false;
10276 }
10277 reader.accept();
10278 return true;
10279 }
10282 if (!helper.cmd.readArgs(reader)) {
10283 return false;
10284 }
10285
10286 helper.call(this);
10287
10288 yarp::os::idl::WireWriter writer(reader);
10289 if (!helper.reply.write(writer)) {
10290 return false;
10291 }
10292 reader.accept();
10293 return true;
10294 }
10297 if (!helper.cmd.readArgs(reader)) {
10298 return false;
10299 }
10300
10301 helper.call(this);
10302
10303 yarp::os::idl::WireWriter writer(reader);
10304 if (!helper.reply.write(writer)) {
10305 return false;
10306 }
10307 reader.accept();
10308 return true;
10309 }
10312 if (!helper.cmd.readArgs(reader)) {
10313 return false;
10314 }
10315
10316 helper.call(this);
10317
10318 yarp::os::idl::WireWriter writer(reader);
10319 if (!helper.reply.write(writer)) {
10320 return false;
10321 }
10322 reader.accept();
10323 return true;
10324 }
10327 if (!helper.cmd.readArgs(reader)) {
10328 return false;
10329 }
10330
10331 helper.call(this);
10332
10333 yarp::os::idl::WireWriter writer(reader);
10334 if (!helper.reply.write(writer)) {
10335 return false;
10336 }
10337 reader.accept();
10338 return true;
10339 }
10342 if (!helper.cmd.readArgs(reader)) {
10343 return false;
10344 }
10345
10346 helper.call(this);
10347
10348 yarp::os::idl::WireWriter writer(reader);
10349 if (!helper.reply.write(writer)) {
10350 return false;
10351 }
10352 reader.accept();
10353 return true;
10354 }
10357 if (!helper.cmd.readArgs(reader)) {
10358 return false;
10359 }
10360
10361 helper.call(this);
10362
10363 yarp::os::idl::WireWriter writer(reader);
10364 if (!helper.reply.write(writer)) {
10365 return false;
10366 }
10367 reader.accept();
10368 return true;
10369 }
10372 if (!helper.cmd.readArgs(reader)) {
10373 return false;
10374 }
10375
10376 helper.call(this);
10377
10378 yarp::os::idl::WireWriter writer(reader);
10379 if (!helper.reply.write(writer)) {
10380 return false;
10381 }
10382 reader.accept();
10383 return true;
10384 }
10387 if (!helper.cmd.readArgs(reader)) {
10388 return false;
10389 }
10390
10391 helper.call(this);
10392
10393 yarp::os::idl::WireWriter writer(reader);
10394 if (!helper.reply.write(writer)) {
10395 return false;
10396 }
10397 reader.accept();
10398 return true;
10399 }
10402 if (!helper.cmd.readArgs(reader)) {
10403 return false;
10404 }
10405
10406 helper.call(this);
10407
10408 yarp::os::idl::WireWriter writer(reader);
10409 if (!helper.reply.write(writer)) {
10410 return false;
10411 }
10412 reader.accept();
10413 return true;
10414 }
10417 if (!helper.cmd.readArgs(reader)) {
10418 return false;
10419 }
10420
10421 helper.call(this);
10422
10423 yarp::os::idl::WireWriter writer(reader);
10424 if (!helper.reply.write(writer)) {
10425 return false;
10426 }
10427 reader.accept();
10428 return true;
10429 }
10432 if (!helper.cmd.readArgs(reader)) {
10433 return false;
10434 }
10435
10436 helper.call(this);
10437
10438 yarp::os::idl::WireWriter writer(reader);
10439 if (!helper.reply.write(writer)) {
10440 return false;
10441 }
10442 reader.accept();
10443 return true;
10444 }
10447 if (!helper.cmd.readArgs(reader)) {
10448 return false;
10449 }
10450
10451 helper.call(this);
10452
10453 yarp::os::idl::WireWriter writer(reader);
10454 if (!helper.reply.write(writer)) {
10455 return false;
10456 }
10457 reader.accept();
10458 return true;
10459 }
10462 if (!helper.cmd.readArgs(reader)) {
10463 return false;
10464 }
10465
10466 helper.call(this);
10467
10468 yarp::os::idl::WireWriter writer(reader);
10469 if (!helper.reply.write(writer)) {
10470 return false;
10471 }
10472 reader.accept();
10473 return true;
10474 }
10477 if (!helper.cmd.readArgs(reader)) {
10478 return false;
10479 }
10480
10481 helper.call(this);
10482
10483 yarp::os::idl::WireWriter writer(reader);
10484 if (!helper.reply.write(writer)) {
10485 return false;
10486 }
10487 reader.accept();
10488 return true;
10489 }
10492 if (!helper.cmd.readArgs(reader)) {
10493 return false;
10494 }
10495
10496 helper.call(this);
10497
10498 yarp::os::idl::WireWriter writer(reader);
10499 if (!helper.reply.write(writer)) {
10500 return false;
10501 }
10502 reader.accept();
10503 return true;
10504 }
10507 if (!helper.cmd.readArgs(reader)) {
10508 return false;
10509 }
10510
10511 helper.call(this);
10512
10513 yarp::os::idl::WireWriter writer(reader);
10514 if (!helper.reply.write(writer)) {
10515 return false;
10516 }
10517 reader.accept();
10518 return true;
10519 }
10522 if (!helper.cmd.readArgs(reader)) {
10523 return false;
10524 }
10525
10526 helper.call(this);
10527
10528 yarp::os::idl::WireWriter writer(reader);
10529 if (!helper.reply.write(writer)) {
10530 return false;
10531 }
10532 reader.accept();
10533 return true;
10534 }
10537 if (!helper.cmd.readArgs(reader)) {
10538 return false;
10539 }
10540
10541 helper.call(this);
10542
10543 yarp::os::idl::WireWriter writer(reader);
10544 if (!helper.reply.write(writer)) {
10545 return false;
10546 }
10547 reader.accept();
10548 return true;
10549 }
10552 if (!helper.cmd.readArgs(reader)) {
10553 return false;
10554 }
10555
10556 helper.call(this);
10557
10558 yarp::os::idl::WireWriter writer(reader);
10559 if (!helper.reply.write(writer)) {
10560 return false;
10561 }
10562 reader.accept();
10563 return true;
10564 }
10565 if (tag == "help") {
10566 std::string functionName;
10567 if (!reader.readString(functionName)) {
10568 functionName = "--all";
10569 }
10570 auto help_strings = help(functionName);
10571 yarp::os::idl::WireWriter writer(reader);
10572 if (!writer.isNull()) {
10573 if (!writer.writeListHeader(2)) {
10574 return false;
10575 }
10576 if (!writer.writeTag("many", 1, 0)) {
10577 return false;
10578 }
10579 if (!writer.writeListBegin(0, help_strings.size())) {
10580 return false;
10581 }
10582 for (const auto& help_string : help_strings) {
10583 if (!writer.writeString(help_string)) {
10584 return false;
10585 }
10586 }
10587 if (!writer.writeListEnd()) {
10588 return false;
10589 }
10590 }
10591 reader.accept();
10592 return true;
10593 }
10594 if (reader.noMore()) {
10595 reader.fail();
10596 return false;
10597 }
10598 std::string next_tag = reader.readTag(1);
10599 if (next_tag.empty()) {
10600 break;
10601 }
10602 tag.append("_").append(next_tag);
10603 tag_len = std::count(tag.begin(), tag.end(), '_') + 1;
10604 }
10605 return false;
10606}
#define yError(...)
Definition Log.h:361
#define __YFUNCTION__
Definition Log.h:24
#define yWarning(...)
Definition Log.h:340
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool 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 write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool 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(*)() funcptr_t
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
static constexpr const char * s_help
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 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 write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool 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
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.
static constexpr const char * s_tag
static constexpr size_t s_tag_len
static constexpr size_t s_cmd_len
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.
yarp::os::ApplicationNetworkProtocolVersion helper_proto
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 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 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 write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool readTag(yarp::os::idl::WireReader &reader)
bool 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 const char * s_tag
return_get_all_objects(*)() funcptr_t
static constexpr const char * s_prototype
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr size_t s_reply_len
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 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 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 write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_prototype
static constexpr const char * s_help
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
static constexpr size_t s_tag_len
static constexpr size_t s_reply_len
static constexpr size_t s_cmd_len
return_get_object(*)(const std::string &) funcptr_t
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_tag
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 writeArgs(const yarp::os::idl::WireWriter &writer) const
bool readArgs(yarp::os::idl::WireReader &reader)
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
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
static constexpr size_t s_reply_len
return_get_objects_list(*)() funcptr_t
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
static constexpr const char * s_tag
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 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 readArgs(yarp::os::idl::WireReader &reader)
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.
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 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 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 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 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 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 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
static constexpr const char * s_help
static constexpr const char * s_prototype
static constexpr size_t s_cmd_len
static constexpr const char * s_tag
yarp::dev::ReturnValue(*)(const std::string &, 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 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 writeArgs(const yarp::os::idl::WireWriter &writer) const
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool readTag(yarp::os::idl::WireReader &reader)
bool readArgs(yarp::os::idl::WireReader &reader)
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
yarp::dev::Nav2D::Map2DObject loc
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 size_t s_cmd_len
static constexpr size_t s_tag_len
yarp::dev::ReturnValue(*)(const std::string &, const yarp::dev::Nav2D::Map2DObject &) funcptr_t
static constexpr const char * s_help
static constexpr size_t s_reply_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.
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 return_get_objects_list get_objects_list_RPC()
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 yarp::dev::ReturnValue store_object_RPC(const std::string &object_name, const yarp::dev::Nav2D::Map2DObject &loc)
virtual return_get_all_areas get_all_areas_RPC()
virtual yarp::dev::ReturnValue store_map_RPC(const yarp::dev::Nav2D::MapGrid2D &themap)
virtual yarp::os::ApplicationNetworkProtocolVersion getLocalProtocolVersion()
virtual yarp::dev::ReturnValue rename_location_RPC(const std::string &original_name, const std::string &new_name)
virtual yarp::dev::ReturnValue reload_locations_and_extras_RPC()
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 bool checkProtocolVersion()
virtual return_get_path get_path_RPC(const std::string &path_name)
virtual return_get_object get_object_RPC(const std::string &object_name)
virtual yarp::dev::ReturnValue store_path_RPC(const std::string &path_name, const yarp::dev::Nav2D::Map2DPath &path)
virtual yarp::dev::ReturnValue delete_object_RPC(const std::string &object_name)
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 yarp::dev::ReturnValue reload_maps_collection_RPC()
virtual yarp::dev::ReturnValue clear_all_objects_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 yarp::dev::ReturnValue rename_object_RPC(const std::string &original_name, const std::string &new_name)
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 return_get_all_objects get_all_objects_RPC()
virtual yarp::dev::ReturnValue clear_map_temporary_flags_RPC(const std::string &map_name)
virtual yarp::os::ApplicationNetworkProtocolVersion getRemoteProtocolVersion()
yarp::dev::ReturnValue retval
yarp::dev::ReturnValue retval
yarp::dev::ReturnValue retval
yarp::dev::ReturnValue retval
yarp::dev::ReturnValue retval
yarp::dev::ReturnValue retval
yarp::dev::ReturnValue retval
yarp::dev::ReturnValue retval
yarp::dev::ReturnValue retval
yarp::dev::ReturnValue retval
yarp::dev::ReturnValue retval
yarp::dev::ReturnValue retval
@ return_value_error_nws_nwc_communication_error
Method is not (yet) implemented.
An interface for reading from a network connection.
An interface for writing to a network connection.
This is a base class for objects that can be both read from and be written to the YARP network.
Definition Portable.h:25
yarp::os::WireLink & yarp()
Get YARP state associated with this object.
Definition Wire.h:28
A "tamed" Portable, that promises to serialize itself in an IDL-friendly way.
IDL-friendly connection reader.
Definition WireReader.h:27
bool 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
#define yCError(component,...)
#define YARP_LOG_COMPONENT(name,...)
The main, catch-all namespace for YARP.
Definition dirs.h:16
#define YARP_VERSION_PATCH
Definition version.h:12
#define YARP_VERSION_MAJOR
Definition version.h:10
#define YARP_VERSION_MINOR
Definition version.h:11