YARP
Yet Another Robot Platform
 
Loading...
Searching...
No Matches
IMap2DMsgs.cpp
Go to the documentation of this file.
1/*
2 * SPDX-FileCopyrightText: 2006-2021 Istituto Italiano di Tecnologia (IIT)
3 * SPDX-License-Identifier: BSD-3-Clause
4 */
5
6// Autogenerated by Thrift Compiler (0.14.1-yarped)
7//
8// This is an automatically generated file.
9// It could get re-generated if the ALLOW_IDL_GENERATION flag is on.
10
11#include <yarp/conf/version.h>
12#include <IMap2DMsgs.h>
14#include <yarp/os/LogStream.h>
15
17
18#include <algorithm>
19
20namespace
21{
22 YARP_LOG_COMPONENT(SERVICE_LOG_COMPONENT, "IMap2DMsgs")
23}
24
25//IMap2DMsgs_getRemoteProtocolVersion_helper declaration
36
38{
39 yarp::os::idl::WireWriter writer(connection);
40 if (!writer.writeListHeader(1)) {
41 return false;
42 }
43 if (!writer.writeString("getRemoteProtocolVersion")) {
44 return false;
45 }
46 return true;
47}
48
49bool IMap2DMsgs_getRemoteProtocolVersion_helper ::read(yarp::os::ConnectionReader & connection)
50 {
51 yarp::os::idl::WireReader reader(connection);
52 if (!reader.readListHeader()) {
53 reader.fail();
54 return false;
55 }
56
57 if (!helper_proto.read(connection)) {
58 reader.fail();
59 return false;
60 }
61 return true;
62}
63
64//ProtocolVersion, client side
66 {
67 if(!yarp().canWrite()) {
68 yError(" Missing server method IMap2DMsgs::getRemoteProtocolVersion");
69 }
71 bool ok = yarp().write(helper, helper);
72 if (ok) {
73 return helper.helper_proto;}
74 else {
76 return failureproto;}
77}
78
79//ProtocolVersion, client side
81 {
82 auto locproto = this->getLocalProtocolVersion();
83 auto remproto = this->getRemoteProtocolVersion();
84 if (remproto.protocol_version != locproto.protocol_version)
85 {
86 yCError(SERVICE_LOG_COMPONENT) << "Invalid communication protocol.";
87 yCError(SERVICE_LOG_COMPONENT) << "Local Protocol Version: " << locproto.toString();
88 yCError(SERVICE_LOG_COMPONENT) << "Remote Protocol Version: " << remproto.toString();
89 return false;
90 }
91 return true;
92}
93
94//ProtocolVersion, server side
96{
98 //myproto.protocol_version using default value = 0
99 //to change this value add the following line to the .thrift file:
100 //const i16 protocol_version = <your_number_here>
101 myproto.protocol_version = 0;
105 return myproto;
106}
107
108// clear_all_maps_RPC helper class declaration
110 public yarp::os::Portable
111{
112public:
114 bool write(yarp::os::ConnectionWriter& connection) const override;
115 bool read(yarp::os::ConnectionReader& connection) override;
116
117 class Command :
119 {
120 public:
121 Command() = default;
122 ~Command() override = default;
123
124 bool write(yarp::os::ConnectionWriter& connection) const override;
125 bool read(yarp::os::ConnectionReader& connection) override;
126
127 bool write(const yarp::os::idl::WireWriter& writer) const override;
128 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
129 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
130
131 bool read(yarp::os::idl::WireReader& reader) override;
134 };
135
136 class Reply :
138 {
139 public:
140 Reply() = default;
141 ~Reply() override = default;
142
143 bool write(yarp::os::ConnectionWriter& connection) const override;
144 bool read(yarp::os::ConnectionReader& connection) override;
145
146 bool write(const yarp::os::idl::WireWriter& writer) const override;
147 bool read(yarp::os::idl::WireReader& reader) override;
148
150 };
151
153 void call(IMap2DMsgs* ptr);
154
157
158 static constexpr const char* s_tag{"clear_all_maps_RPC"};
159 static constexpr size_t s_tag_len{4};
160 static constexpr size_t s_cmd_len{4};
161 static constexpr size_t s_reply_len{1};
162 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::clear_all_maps_RPC()"};
163 static constexpr const char* s_help{""};
164};
165
166// store_map_RPC helper class declaration
168 public yarp::os::Portable
169{
170public:
173 bool write(yarp::os::ConnectionWriter& connection) const override;
174 bool read(yarp::os::ConnectionReader& connection) override;
175
176 class Command :
178 {
179 public:
180 Command() = default;
182
183 ~Command() override = default;
184
185 bool write(yarp::os::ConnectionWriter& connection) const override;
186 bool read(yarp::os::ConnectionReader& connection) override;
187
188 bool write(const yarp::os::idl::WireWriter& writer) const override;
189 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
190 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
191
192 bool read(yarp::os::idl::WireReader& reader) override;
195
197 };
198
199 class Reply :
201 {
202 public:
203 Reply() = default;
204 ~Reply() override = default;
205
206 bool write(yarp::os::ConnectionWriter& connection) const override;
207 bool read(yarp::os::ConnectionReader& connection) override;
208
209 bool write(const yarp::os::idl::WireWriter& writer) const override;
210 bool read(yarp::os::idl::WireReader& reader) override;
211
213 };
214
216 void call(IMap2DMsgs* ptr);
217
220
221 static constexpr const char* s_tag{"store_map_RPC"};
222 static constexpr size_t s_tag_len{3};
223 static constexpr size_t s_cmd_len{4};
224 static constexpr size_t s_reply_len{1};
225 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::store_map_RPC(const yarp::dev::Nav2D::MapGrid2D& themap)"};
226 static constexpr const char* s_help{""};
227};
228
229// get_map_RPC helper class declaration
231 public yarp::os::Portable
232{
233public:
235 explicit IMap2DMsgs_get_map_RPC_helper(const std::string& map_name);
236 bool write(yarp::os::ConnectionWriter& connection) const override;
237 bool read(yarp::os::ConnectionReader& connection) override;
238
239 class Command :
241 {
242 public:
243 Command() = default;
244 explicit Command(const std::string& map_name);
245
246 ~Command() override = default;
247
248 bool write(yarp::os::ConnectionWriter& connection) const override;
249 bool read(yarp::os::ConnectionReader& connection) override;
250
251 bool write(const yarp::os::idl::WireWriter& writer) const override;
252 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
253 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
254
255 bool read(yarp::os::idl::WireReader& reader) override;
258
259 std::string map_name{};
260 };
261
262 class Reply :
264 {
265 public:
266 Reply() = default;
267 ~Reply() override = default;
268
269 bool write(yarp::os::ConnectionWriter& connection) const override;
270 bool read(yarp::os::ConnectionReader& connection) override;
271
272 bool write(const yarp::os::idl::WireWriter& writer) const override;
273 bool read(yarp::os::idl::WireReader& reader) override;
274
276 };
277
278 using funcptr_t = return_get_map (*)(const std::string&);
279 void call(IMap2DMsgs* ptr);
280
283
284 static constexpr const char* s_tag{"get_map_RPC"};
285 static constexpr size_t s_tag_len{3};
286 static constexpr size_t s_cmd_len{4};
287 static constexpr size_t s_reply_len{2};
288 static constexpr const char* s_prototype{"return_get_map IMap2DMsgs::get_map_RPC(const std::string& map_name)"};
289 static constexpr const char* s_help{""};
290};
291
292// get_map_names_RPC helper class declaration
294 public yarp::os::Portable
295{
296public:
298 bool write(yarp::os::ConnectionWriter& connection) const override;
299 bool read(yarp::os::ConnectionReader& connection) override;
300
301 class Command :
303 {
304 public:
305 Command() = default;
306 ~Command() override = default;
307
308 bool write(yarp::os::ConnectionWriter& connection) const override;
309 bool read(yarp::os::ConnectionReader& connection) override;
310
311 bool write(const yarp::os::idl::WireWriter& writer) const override;
312 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
313 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
314
315 bool read(yarp::os::idl::WireReader& reader) override;
318 };
319
320 class Reply :
322 {
323 public:
324 Reply() = default;
325 ~Reply() override = default;
326
327 bool write(yarp::os::ConnectionWriter& connection) const override;
328 bool read(yarp::os::ConnectionReader& connection) override;
329
330 bool write(const yarp::os::idl::WireWriter& writer) const override;
331 bool read(yarp::os::idl::WireReader& reader) override;
332
334 };
335
337 void call(IMap2DMsgs* ptr);
338
341
342 static constexpr const char* s_tag{"get_map_names_RPC"};
343 static constexpr size_t s_tag_len{4};
344 static constexpr size_t s_cmd_len{4};
345 static constexpr size_t s_reply_len{2};
346 static constexpr const char* s_prototype{"return_get_map_names IMap2DMsgs::get_map_names_RPC()"};
347 static constexpr const char* s_help{""};
348};
349
350// remove_map_RPC helper class declaration
352 public yarp::os::Portable
353{
354public:
356 explicit IMap2DMsgs_remove_map_RPC_helper(const std::string& map_name);
357 bool write(yarp::os::ConnectionWriter& connection) const override;
358 bool read(yarp::os::ConnectionReader& connection) override;
359
360 class Command :
362 {
363 public:
364 Command() = default;
365 explicit Command(const std::string& map_name);
366
367 ~Command() override = default;
368
369 bool write(yarp::os::ConnectionWriter& connection) const override;
370 bool read(yarp::os::ConnectionReader& connection) override;
371
372 bool write(const yarp::os::idl::WireWriter& writer) const override;
373 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
374 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
375
376 bool read(yarp::os::idl::WireReader& reader) override;
379
380 std::string map_name{};
381 };
382
383 class Reply :
385 {
386 public:
387 Reply() = default;
388 ~Reply() override = default;
389
390 bool write(yarp::os::ConnectionWriter& connection) const override;
391 bool read(yarp::os::ConnectionReader& connection) override;
392
393 bool write(const yarp::os::idl::WireWriter& writer) const override;
394 bool read(yarp::os::idl::WireReader& reader) override;
395
397 };
398
399 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&);
400 void call(IMap2DMsgs* ptr);
401
404
405 static constexpr const char* s_tag{"remove_map_RPC"};
406 static constexpr size_t s_tag_len{3};
407 static constexpr size_t s_cmd_len{4};
408 static constexpr size_t s_reply_len{1};
409 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::remove_map_RPC(const std::string& map_name)"};
410 static constexpr const char* s_help{""};
411};
412
413// store_object_RPC helper class declaration
415 public yarp::os::Portable
416{
417public:
419 IMap2DMsgs_store_object_RPC_helper(const std::string& object_name, const yarp::dev::Nav2D::Map2DObject& loc);
420 bool write(yarp::os::ConnectionWriter& connection) const override;
421 bool read(yarp::os::ConnectionReader& connection) override;
422
423 class Command :
425 {
426 public:
427 Command() = default;
428 Command(const std::string& object_name, const yarp::dev::Nav2D::Map2DObject& loc);
429
430 ~Command() override = default;
431
432 bool write(yarp::os::ConnectionWriter& connection) const override;
433 bool read(yarp::os::ConnectionReader& connection) override;
434
435 bool write(const yarp::os::idl::WireWriter& writer) const override;
436 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
437 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
438
439 bool read(yarp::os::idl::WireReader& reader) override;
442
443 std::string object_name{};
445 };
446
447 class Reply :
449 {
450 public:
451 Reply() = default;
452 ~Reply() override = default;
453
454 bool write(yarp::os::ConnectionWriter& connection) const override;
455 bool read(yarp::os::ConnectionReader& connection) override;
456
457 bool write(const yarp::os::idl::WireWriter& writer) const override;
458 bool read(yarp::os::idl::WireReader& reader) override;
459
461 };
462
463 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&, const yarp::dev::Nav2D::Map2DObject&);
464 void call(IMap2DMsgs* ptr);
465
468
469 static constexpr const char* s_tag{"store_object_RPC"};
470 static constexpr size_t s_tag_len{3};
471 static constexpr size_t s_cmd_len{5};
472 static constexpr size_t s_reply_len{1};
473 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::store_object_RPC(const std::string& object_name, const yarp::dev::Nav2D::Map2DObject& loc)"};
474 static constexpr const char* s_help{""};
475};
476
477// store_location_RPC helper class declaration
479 public yarp::os::Portable
480{
481public:
483 IMap2DMsgs_store_location_RPC_helper(const std::string& location_name, const yarp::dev::Nav2D::Map2DLocation& loc);
484 bool write(yarp::os::ConnectionWriter& connection) const override;
485 bool read(yarp::os::ConnectionReader& connection) override;
486
487 class Command :
489 {
490 public:
491 Command() = default;
492 Command(const std::string& location_name, const yarp::dev::Nav2D::Map2DLocation& loc);
493
494 ~Command() override = default;
495
496 bool write(yarp::os::ConnectionWriter& connection) const override;
497 bool read(yarp::os::ConnectionReader& connection) override;
498
499 bool write(const yarp::os::idl::WireWriter& writer) const override;
500 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
501 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
502
503 bool read(yarp::os::idl::WireReader& reader) override;
506
507 std::string location_name{};
509 };
510
511 class Reply :
513 {
514 public:
515 Reply() = default;
516 ~Reply() override = default;
517
518 bool write(yarp::os::ConnectionWriter& connection) const override;
519 bool read(yarp::os::ConnectionReader& connection) override;
520
521 bool write(const yarp::os::idl::WireWriter& writer) const override;
522 bool read(yarp::os::idl::WireReader& reader) override;
523
525 };
526
527 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&, const yarp::dev::Nav2D::Map2DLocation&);
528 void call(IMap2DMsgs* ptr);
529
532
533 static constexpr const char* s_tag{"store_location_RPC"};
534 static constexpr size_t s_tag_len{3};
535 static constexpr size_t s_cmd_len{5};
536 static constexpr size_t s_reply_len{1};
537 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::store_location_RPC(const std::string& location_name, const yarp::dev::Nav2D::Map2DLocation& loc)"};
538 static constexpr const char* s_help{""};
539};
540
541// store_area_RPC helper class declaration
543 public yarp::os::Portable
544{
545public:
547 IMap2DMsgs_store_area_RPC_helper(const std::string& area_name, const yarp::dev::Nav2D::Map2DArea& area);
548 bool write(yarp::os::ConnectionWriter& connection) const override;
549 bool read(yarp::os::ConnectionReader& connection) override;
550
551 class Command :
553 {
554 public:
555 Command() = default;
556 Command(const std::string& area_name, const yarp::dev::Nav2D::Map2DArea& area);
557
558 ~Command() override = default;
559
560 bool write(yarp::os::ConnectionWriter& connection) const override;
561 bool read(yarp::os::ConnectionReader& connection) override;
562
563 bool write(const yarp::os::idl::WireWriter& writer) const override;
564 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
565 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
566
567 bool read(yarp::os::idl::WireReader& reader) override;
570
571 std::string area_name{};
573 };
574
575 class Reply :
577 {
578 public:
579 Reply() = default;
580 ~Reply() override = default;
581
582 bool write(yarp::os::ConnectionWriter& connection) const override;
583 bool read(yarp::os::ConnectionReader& connection) override;
584
585 bool write(const yarp::os::idl::WireWriter& writer) const override;
586 bool read(yarp::os::idl::WireReader& reader) override;
587
589 };
590
591 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&, const yarp::dev::Nav2D::Map2DArea&);
592 void call(IMap2DMsgs* ptr);
593
596
597 static constexpr const char* s_tag{"store_area_RPC"};
598 static constexpr size_t s_tag_len{3};
599 static constexpr size_t s_cmd_len{5};
600 static constexpr size_t s_reply_len{1};
601 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::store_area_RPC(const std::string& area_name, const yarp::dev::Nav2D::Map2DArea& area)"};
602 static constexpr const char* s_help{""};
603};
604
605// store_path_RPC helper class declaration
607 public yarp::os::Portable
608{
609public:
611 IMap2DMsgs_store_path_RPC_helper(const std::string& path_name, const yarp::dev::Nav2D::Map2DPath& path);
612 bool write(yarp::os::ConnectionWriter& connection) const override;
613 bool read(yarp::os::ConnectionReader& connection) override;
614
615 class Command :
617 {
618 public:
619 Command() = default;
620 Command(const std::string& path_name, const yarp::dev::Nav2D::Map2DPath& path);
621
622 ~Command() override = default;
623
624 bool write(yarp::os::ConnectionWriter& connection) const override;
625 bool read(yarp::os::ConnectionReader& connection) override;
626
627 bool write(const yarp::os::idl::WireWriter& writer) const override;
628 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
629 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
630
631 bool read(yarp::os::idl::WireReader& reader) override;
634
635 std::string path_name{};
637 };
638
639 class Reply :
641 {
642 public:
643 Reply() = default;
644 ~Reply() override = default;
645
646 bool write(yarp::os::ConnectionWriter& connection) const override;
647 bool read(yarp::os::ConnectionReader& connection) override;
648
649 bool write(const yarp::os::idl::WireWriter& writer) const override;
650 bool read(yarp::os::idl::WireReader& reader) override;
651
653 };
654
655 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&, const yarp::dev::Nav2D::Map2DPath&);
656 void call(IMap2DMsgs* ptr);
657
660
661 static constexpr const char* s_tag{"store_path_RPC"};
662 static constexpr size_t s_tag_len{3};
663 static constexpr size_t s_cmd_len{5};
664 static constexpr size_t s_reply_len{1};
665 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::store_path_RPC(const std::string& path_name, const yarp::dev::Nav2D::Map2DPath& path)"};
666 static constexpr const char* s_help{""};
667};
668
669// get_object_RPC helper class declaration
671 public yarp::os::Portable
672{
673public:
675 explicit IMap2DMsgs_get_object_RPC_helper(const std::string& object_name);
676 bool write(yarp::os::ConnectionWriter& connection) const override;
677 bool read(yarp::os::ConnectionReader& connection) override;
678
679 class Command :
681 {
682 public:
683 Command() = default;
684 explicit Command(const std::string& object_name);
685
686 ~Command() override = default;
687
688 bool write(yarp::os::ConnectionWriter& connection) const override;
689 bool read(yarp::os::ConnectionReader& connection) override;
690
691 bool write(const yarp::os::idl::WireWriter& writer) const override;
692 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
693 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
694
695 bool read(yarp::os::idl::WireReader& reader) override;
698
699 std::string object_name{};
700 };
701
702 class Reply :
704 {
705 public:
706 Reply() = default;
707 ~Reply() override = default;
708
709 bool write(yarp::os::ConnectionWriter& connection) const override;
710 bool read(yarp::os::ConnectionReader& connection) override;
711
712 bool write(const yarp::os::idl::WireWriter& writer) const override;
713 bool read(yarp::os::idl::WireReader& reader) override;
714
716 };
717
718 using funcptr_t = return_get_object (*)(const std::string&);
719 void call(IMap2DMsgs* ptr);
720
723
724 static constexpr const char* s_tag{"get_object_RPC"};
725 static constexpr size_t s_tag_len{3};
726 static constexpr size_t s_cmd_len{4};
727 static constexpr size_t s_reply_len{2};
728 static constexpr const char* s_prototype{"return_get_object IMap2DMsgs::get_object_RPC(const std::string& object_name)"};
729 static constexpr const char* s_help{""};
730};
731
732// get_location_RPC helper class declaration
734 public yarp::os::Portable
735{
736public:
738 explicit IMap2DMsgs_get_location_RPC_helper(const std::string& location_name);
739 bool write(yarp::os::ConnectionWriter& connection) const override;
740 bool read(yarp::os::ConnectionReader& connection) override;
741
742 class Command :
744 {
745 public:
746 Command() = default;
747 explicit Command(const std::string& location_name);
748
749 ~Command() override = default;
750
751 bool write(yarp::os::ConnectionWriter& connection) const override;
752 bool read(yarp::os::ConnectionReader& connection) override;
753
754 bool write(const yarp::os::idl::WireWriter& writer) const override;
755 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
756 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
757
758 bool read(yarp::os::idl::WireReader& reader) override;
761
762 std::string location_name{};
763 };
764
765 class Reply :
767 {
768 public:
769 Reply() = default;
770 ~Reply() override = default;
771
772 bool write(yarp::os::ConnectionWriter& connection) const override;
773 bool read(yarp::os::ConnectionReader& connection) override;
774
775 bool write(const yarp::os::idl::WireWriter& writer) const override;
776 bool read(yarp::os::idl::WireReader& reader) override;
777
779 };
780
781 using funcptr_t = return_get_location (*)(const std::string&);
782 void call(IMap2DMsgs* ptr);
783
786
787 static constexpr const char* s_tag{"get_location_RPC"};
788 static constexpr size_t s_tag_len{3};
789 static constexpr size_t s_cmd_len{4};
790 static constexpr size_t s_reply_len{2};
791 static constexpr const char* s_prototype{"return_get_location IMap2DMsgs::get_location_RPC(const std::string& location_name)"};
792 static constexpr const char* s_help{""};
793};
794
795// get_area_RPC helper class declaration
797 public yarp::os::Portable
798{
799public:
801 explicit IMap2DMsgs_get_area_RPC_helper(const std::string& area_name);
802 bool write(yarp::os::ConnectionWriter& connection) const override;
803 bool read(yarp::os::ConnectionReader& connection) override;
804
805 class Command :
807 {
808 public:
809 Command() = default;
810 explicit Command(const std::string& area_name);
811
812 ~Command() override = default;
813
814 bool write(yarp::os::ConnectionWriter& connection) const override;
815 bool read(yarp::os::ConnectionReader& connection) override;
816
817 bool write(const yarp::os::idl::WireWriter& writer) const override;
818 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
819 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
820
821 bool read(yarp::os::idl::WireReader& reader) override;
824
825 std::string area_name{};
826 };
827
828 class Reply :
830 {
831 public:
832 Reply() = default;
833 ~Reply() override = default;
834
835 bool write(yarp::os::ConnectionWriter& connection) const override;
836 bool read(yarp::os::ConnectionReader& connection) override;
837
838 bool write(const yarp::os::idl::WireWriter& writer) const override;
839 bool read(yarp::os::idl::WireReader& reader) override;
840
842 };
843
844 using funcptr_t = return_get_area (*)(const std::string&);
845 void call(IMap2DMsgs* ptr);
846
849
850 static constexpr const char* s_tag{"get_area_RPC"};
851 static constexpr size_t s_tag_len{3};
852 static constexpr size_t s_cmd_len{4};
853 static constexpr size_t s_reply_len{2};
854 static constexpr const char* s_prototype{"return_get_area IMap2DMsgs::get_area_RPC(const std::string& area_name)"};
855 static constexpr const char* s_help{""};
856};
857
858// get_path_RPC helper class declaration
860 public yarp::os::Portable
861{
862public:
864 explicit IMap2DMsgs_get_path_RPC_helper(const std::string& path_name);
865 bool write(yarp::os::ConnectionWriter& connection) const override;
866 bool read(yarp::os::ConnectionReader& connection) override;
867
868 class Command :
870 {
871 public:
872 Command() = default;
873 explicit Command(const std::string& path_name);
874
875 ~Command() override = default;
876
877 bool write(yarp::os::ConnectionWriter& connection) const override;
878 bool read(yarp::os::ConnectionReader& connection) override;
879
880 bool write(const yarp::os::idl::WireWriter& writer) const override;
881 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
882 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
883
884 bool read(yarp::os::idl::WireReader& reader) override;
887
888 std::string path_name{};
889 };
890
891 class Reply :
893 {
894 public:
895 Reply() = default;
896 ~Reply() override = default;
897
898 bool write(yarp::os::ConnectionWriter& connection) const override;
899 bool read(yarp::os::ConnectionReader& connection) override;
900
901 bool write(const yarp::os::idl::WireWriter& writer) const override;
902 bool read(yarp::os::idl::WireReader& reader) override;
903
905 };
906
907 using funcptr_t = return_get_path (*)(const std::string&);
908 void call(IMap2DMsgs* ptr);
909
912
913 static constexpr const char* s_tag{"get_path_RPC"};
914 static constexpr size_t s_tag_len{3};
915 static constexpr size_t s_cmd_len{4};
916 static constexpr size_t s_reply_len{2};
917 static constexpr const char* s_prototype{"return_get_path IMap2DMsgs::get_path_RPC(const std::string& path_name)"};
918 static constexpr const char* s_help{""};
919};
920
921// get_objects_list_RPC helper class declaration
923 public yarp::os::Portable
924{
925public:
927 bool write(yarp::os::ConnectionWriter& connection) const override;
928 bool read(yarp::os::ConnectionReader& connection) override;
929
930 class Command :
932 {
933 public:
934 Command() = default;
935 ~Command() override = default;
936
937 bool write(yarp::os::ConnectionWriter& connection) const override;
938 bool read(yarp::os::ConnectionReader& connection) override;
939
940 bool write(const yarp::os::idl::WireWriter& writer) const override;
941 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
942 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
943
944 bool read(yarp::os::idl::WireReader& reader) override;
947 };
948
949 class Reply :
951 {
952 public:
953 Reply() = default;
954 ~Reply() override = default;
955
956 bool write(yarp::os::ConnectionWriter& connection) const override;
957 bool read(yarp::os::ConnectionReader& connection) override;
958
959 bool write(const yarp::os::idl::WireWriter& writer) const override;
960 bool read(yarp::os::idl::WireReader& reader) override;
961
963 };
964
966 void call(IMap2DMsgs* ptr);
967
970
971 static constexpr const char* s_tag{"get_objects_list_RPC"};
972 static constexpr size_t s_tag_len{4};
973 static constexpr size_t s_cmd_len{4};
974 static constexpr size_t s_reply_len{2};
975 static constexpr const char* s_prototype{"return_get_objects_list IMap2DMsgs::get_objects_list_RPC()"};
976 static constexpr const char* s_help{""};
977};
978
979// get_locations_list_RPC helper class declaration
981 public yarp::os::Portable
982{
983public:
985 bool write(yarp::os::ConnectionWriter& connection) const override;
986 bool read(yarp::os::ConnectionReader& connection) override;
987
988 class Command :
990 {
991 public:
992 Command() = default;
993 ~Command() override = default;
994
995 bool write(yarp::os::ConnectionWriter& connection) const override;
996 bool read(yarp::os::ConnectionReader& connection) override;
997
998 bool write(const yarp::os::idl::WireWriter& writer) const override;
999 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1000 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1001
1002 bool read(yarp::os::idl::WireReader& reader) override;
1003 bool readTag(yarp::os::idl::WireReader& reader);
1004 bool readArgs(yarp::os::idl::WireReader& reader);
1005 };
1006
1007 class Reply :
1009 {
1010 public:
1011 Reply() = default;
1012 ~Reply() override = default;
1013
1014 bool write(yarp::os::ConnectionWriter& connection) const override;
1015 bool read(yarp::os::ConnectionReader& connection) override;
1016
1017 bool write(const yarp::os::idl::WireWriter& writer) const override;
1018 bool read(yarp::os::idl::WireReader& reader) override;
1019
1021 };
1022
1024 void call(IMap2DMsgs* ptr);
1025
1028
1029 static constexpr const char* s_tag{"get_locations_list_RPC"};
1030 static constexpr size_t s_tag_len{4};
1031 static constexpr size_t s_cmd_len{4};
1032 static constexpr size_t s_reply_len{2};
1033 static constexpr const char* s_prototype{"return_get_locations_list IMap2DMsgs::get_locations_list_RPC()"};
1034 static constexpr const char* s_help{""};
1035};
1036
1037// get_areas_list_RPC helper class declaration
1039 public yarp::os::Portable
1040{
1041public:
1043 bool write(yarp::os::ConnectionWriter& connection) const override;
1044 bool read(yarp::os::ConnectionReader& connection) override;
1045
1046 class Command :
1048 {
1049 public:
1050 Command() = default;
1051 ~Command() override = default;
1052
1053 bool write(yarp::os::ConnectionWriter& connection) const override;
1054 bool read(yarp::os::ConnectionReader& connection) override;
1055
1056 bool write(const yarp::os::idl::WireWriter& writer) const override;
1057 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1058 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1059
1060 bool read(yarp::os::idl::WireReader& reader) override;
1061 bool readTag(yarp::os::idl::WireReader& reader);
1062 bool readArgs(yarp::os::idl::WireReader& reader);
1063 };
1064
1065 class Reply :
1067 {
1068 public:
1069 Reply() = default;
1070 ~Reply() override = default;
1071
1072 bool write(yarp::os::ConnectionWriter& connection) const override;
1073 bool read(yarp::os::ConnectionReader& connection) override;
1074
1075 bool write(const yarp::os::idl::WireWriter& writer) const override;
1076 bool read(yarp::os::idl::WireReader& reader) override;
1077
1079 };
1080
1082 void call(IMap2DMsgs* ptr);
1083
1086
1087 static constexpr const char* s_tag{"get_areas_list_RPC"};
1088 static constexpr size_t s_tag_len{4};
1089 static constexpr size_t s_cmd_len{4};
1090 static constexpr size_t s_reply_len{2};
1091 static constexpr const char* s_prototype{"return_get_areas_list IMap2DMsgs::get_areas_list_RPC()"};
1092 static constexpr const char* s_help{""};
1093};
1094
1095// get_paths_list_RPC helper class declaration
1097 public yarp::os::Portable
1098{
1099public:
1101 bool write(yarp::os::ConnectionWriter& connection) const override;
1102 bool read(yarp::os::ConnectionReader& connection) override;
1103
1104 class Command :
1106 {
1107 public:
1108 Command() = default;
1109 ~Command() override = default;
1110
1111 bool write(yarp::os::ConnectionWriter& connection) const override;
1112 bool read(yarp::os::ConnectionReader& connection) override;
1113
1114 bool write(const yarp::os::idl::WireWriter& writer) const override;
1115 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1116 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1117
1118 bool read(yarp::os::idl::WireReader& reader) override;
1119 bool readTag(yarp::os::idl::WireReader& reader);
1120 bool readArgs(yarp::os::idl::WireReader& reader);
1121 };
1122
1123 class Reply :
1125 {
1126 public:
1127 Reply() = default;
1128 ~Reply() override = default;
1129
1130 bool write(yarp::os::ConnectionWriter& connection) const override;
1131 bool read(yarp::os::ConnectionReader& connection) override;
1132
1133 bool write(const yarp::os::idl::WireWriter& writer) const override;
1134 bool read(yarp::os::idl::WireReader& reader) override;
1135
1137 };
1138
1140 void call(IMap2DMsgs* ptr);
1141
1144
1145 static constexpr const char* s_tag{"get_paths_list_RPC"};
1146 static constexpr size_t s_tag_len{4};
1147 static constexpr size_t s_cmd_len{4};
1148 static constexpr size_t s_reply_len{2};
1149 static constexpr const char* s_prototype{"return_get_paths_list IMap2DMsgs::get_paths_list_RPC()"};
1150 static constexpr const char* s_help{""};
1151};
1152
1153// get_all_objects_RPC helper class declaration
1155 public yarp::os::Portable
1156{
1157public:
1159 bool write(yarp::os::ConnectionWriter& connection) const override;
1160 bool read(yarp::os::ConnectionReader& connection) override;
1161
1162 class Command :
1164 {
1165 public:
1166 Command() = default;
1167 ~Command() override = default;
1168
1169 bool write(yarp::os::ConnectionWriter& connection) const override;
1170 bool read(yarp::os::ConnectionReader& connection) override;
1171
1172 bool write(const yarp::os::idl::WireWriter& writer) const override;
1173 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1174 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1175
1176 bool read(yarp::os::idl::WireReader& reader) override;
1177 bool readTag(yarp::os::idl::WireReader& reader);
1178 bool readArgs(yarp::os::idl::WireReader& reader);
1179 };
1180
1181 class Reply :
1183 {
1184 public:
1185 Reply() = default;
1186 ~Reply() override = default;
1187
1188 bool write(yarp::os::ConnectionWriter& connection) const override;
1189 bool read(yarp::os::ConnectionReader& connection) override;
1190
1191 bool write(const yarp::os::idl::WireWriter& writer) const override;
1192 bool read(yarp::os::idl::WireReader& reader) override;
1193
1195 };
1196
1198 void call(IMap2DMsgs* ptr);
1199
1202
1203 static constexpr const char* s_tag{"get_all_objects_RPC"};
1204 static constexpr size_t s_tag_len{4};
1205 static constexpr size_t s_cmd_len{4};
1206 static constexpr size_t s_reply_len{2};
1207 static constexpr const char* s_prototype{"return_get_all_objects IMap2DMsgs::get_all_objects_RPC()"};
1208 static constexpr const char* s_help{""};
1209};
1210
1211// get_all_locations_RPC helper class declaration
1213 public yarp::os::Portable
1214{
1215public:
1217 bool write(yarp::os::ConnectionWriter& connection) const override;
1218 bool read(yarp::os::ConnectionReader& connection) override;
1219
1220 class Command :
1222 {
1223 public:
1224 Command() = default;
1225 ~Command() override = default;
1226
1227 bool write(yarp::os::ConnectionWriter& connection) const override;
1228 bool read(yarp::os::ConnectionReader& connection) override;
1229
1230 bool write(const yarp::os::idl::WireWriter& writer) const override;
1231 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1232 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1233
1234 bool read(yarp::os::idl::WireReader& reader) override;
1235 bool readTag(yarp::os::idl::WireReader& reader);
1236 bool readArgs(yarp::os::idl::WireReader& reader);
1237 };
1238
1239 class Reply :
1241 {
1242 public:
1243 Reply() = default;
1244 ~Reply() override = default;
1245
1246 bool write(yarp::os::ConnectionWriter& connection) const override;
1247 bool read(yarp::os::ConnectionReader& connection) override;
1248
1249 bool write(const yarp::os::idl::WireWriter& writer) const override;
1250 bool read(yarp::os::idl::WireReader& reader) override;
1251
1253 };
1254
1256 void call(IMap2DMsgs* ptr);
1257
1260
1261 static constexpr const char* s_tag{"get_all_locations_RPC"};
1262 static constexpr size_t s_tag_len{4};
1263 static constexpr size_t s_cmd_len{4};
1264 static constexpr size_t s_reply_len{2};
1265 static constexpr const char* s_prototype{"return_get_all_locations IMap2DMsgs::get_all_locations_RPC()"};
1266 static constexpr const char* s_help{""};
1267};
1268
1269// get_all_areas_RPC helper class declaration
1271 public yarp::os::Portable
1272{
1273public:
1275 bool write(yarp::os::ConnectionWriter& connection) const override;
1276 bool read(yarp::os::ConnectionReader& connection) override;
1277
1278 class Command :
1280 {
1281 public:
1282 Command() = default;
1283 ~Command() override = default;
1284
1285 bool write(yarp::os::ConnectionWriter& connection) const override;
1286 bool read(yarp::os::ConnectionReader& connection) override;
1287
1288 bool write(const yarp::os::idl::WireWriter& writer) const override;
1289 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1290 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1291
1292 bool read(yarp::os::idl::WireReader& reader) override;
1293 bool readTag(yarp::os::idl::WireReader& reader);
1294 bool readArgs(yarp::os::idl::WireReader& reader);
1295 };
1296
1297 class Reply :
1299 {
1300 public:
1301 Reply() = default;
1302 ~Reply() override = default;
1303
1304 bool write(yarp::os::ConnectionWriter& connection) const override;
1305 bool read(yarp::os::ConnectionReader& connection) override;
1306
1307 bool write(const yarp::os::idl::WireWriter& writer) const override;
1308 bool read(yarp::os::idl::WireReader& reader) override;
1309
1311 };
1312
1314 void call(IMap2DMsgs* ptr);
1315
1318
1319 static constexpr const char* s_tag{"get_all_areas_RPC"};
1320 static constexpr size_t s_tag_len{4};
1321 static constexpr size_t s_cmd_len{4};
1322 static constexpr size_t s_reply_len{2};
1323 static constexpr const char* s_prototype{"return_get_all_areas IMap2DMsgs::get_all_areas_RPC()"};
1324 static constexpr const char* s_help{""};
1325};
1326
1327// get_all_paths_RPC helper class declaration
1329 public yarp::os::Portable
1330{
1331public:
1333 bool write(yarp::os::ConnectionWriter& connection) const override;
1334 bool read(yarp::os::ConnectionReader& connection) override;
1335
1336 class Command :
1338 {
1339 public:
1340 Command() = default;
1341 ~Command() override = default;
1342
1343 bool write(yarp::os::ConnectionWriter& connection) const override;
1344 bool read(yarp::os::ConnectionReader& connection) override;
1345
1346 bool write(const yarp::os::idl::WireWriter& writer) const override;
1347 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1348 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1349
1350 bool read(yarp::os::idl::WireReader& reader) override;
1351 bool readTag(yarp::os::idl::WireReader& reader);
1352 bool readArgs(yarp::os::idl::WireReader& reader);
1353 };
1354
1355 class Reply :
1357 {
1358 public:
1359 Reply() = default;
1360 ~Reply() override = default;
1361
1362 bool write(yarp::os::ConnectionWriter& connection) const override;
1363 bool read(yarp::os::ConnectionReader& connection) override;
1364
1365 bool write(const yarp::os::idl::WireWriter& writer) const override;
1366 bool read(yarp::os::idl::WireReader& reader) override;
1367
1369 };
1370
1372 void call(IMap2DMsgs* ptr);
1373
1376
1377 static constexpr const char* s_tag{"get_all_paths_RPC"};
1378 static constexpr size_t s_tag_len{4};
1379 static constexpr size_t s_cmd_len{4};
1380 static constexpr size_t s_reply_len{2};
1381 static constexpr const char* s_prototype{"return_get_all_paths IMap2DMsgs::get_all_paths_RPC()"};
1382 static constexpr const char* s_help{""};
1383};
1384
1385// rename_location_RPC helper class declaration
1387 public yarp::os::Portable
1388{
1389public:
1391 IMap2DMsgs_rename_location_RPC_helper(const std::string& original_name, const std::string& new_name);
1392 bool write(yarp::os::ConnectionWriter& connection) const override;
1393 bool read(yarp::os::ConnectionReader& connection) override;
1394
1395 class Command :
1397 {
1398 public:
1399 Command() = default;
1400 Command(const std::string& original_name, const std::string& new_name);
1401
1402 ~Command() override = default;
1403
1404 bool write(yarp::os::ConnectionWriter& connection) const override;
1405 bool read(yarp::os::ConnectionReader& connection) override;
1406
1407 bool write(const yarp::os::idl::WireWriter& writer) const override;
1408 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1409 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1410
1411 bool read(yarp::os::idl::WireReader& reader) override;
1412 bool readTag(yarp::os::idl::WireReader& reader);
1413 bool readArgs(yarp::os::idl::WireReader& reader);
1414
1415 std::string original_name{};
1416 std::string new_name{};
1417 };
1418
1419 class Reply :
1421 {
1422 public:
1423 Reply() = default;
1424 ~Reply() override = default;
1425
1426 bool write(yarp::os::ConnectionWriter& connection) const override;
1427 bool read(yarp::os::ConnectionReader& connection) override;
1428
1429 bool write(const yarp::os::idl::WireWriter& writer) const override;
1430 bool read(yarp::os::idl::WireReader& reader) override;
1431
1433 };
1434
1435 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&, const std::string&);
1436 void call(IMap2DMsgs* ptr);
1437
1440
1441 static constexpr const char* s_tag{"rename_location_RPC"};
1442 static constexpr size_t s_tag_len{3};
1443 static constexpr size_t s_cmd_len{5};
1444 static constexpr size_t s_reply_len{1};
1445 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::rename_location_RPC(const std::string& original_name, const std::string& new_name)"};
1446 static constexpr const char* s_help{""};
1447};
1448
1449// delete_object_RPC helper class declaration
1451 public yarp::os::Portable
1452{
1453public:
1455 explicit IMap2DMsgs_delete_object_RPC_helper(const std::string& object_name);
1456 bool write(yarp::os::ConnectionWriter& connection) const override;
1457 bool read(yarp::os::ConnectionReader& connection) override;
1458
1459 class Command :
1461 {
1462 public:
1463 Command() = default;
1464 explicit Command(const std::string& object_name);
1465
1466 ~Command() override = default;
1467
1468 bool write(yarp::os::ConnectionWriter& connection) const override;
1469 bool read(yarp::os::ConnectionReader& connection) override;
1470
1471 bool write(const yarp::os::idl::WireWriter& writer) const override;
1472 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1473 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1474
1475 bool read(yarp::os::idl::WireReader& reader) override;
1476 bool readTag(yarp::os::idl::WireReader& reader);
1477 bool readArgs(yarp::os::idl::WireReader& reader);
1478
1479 std::string object_name{};
1480 };
1481
1482 class Reply :
1484 {
1485 public:
1486 Reply() = default;
1487 ~Reply() override = default;
1488
1489 bool write(yarp::os::ConnectionWriter& connection) const override;
1490 bool read(yarp::os::ConnectionReader& connection) override;
1491
1492 bool write(const yarp::os::idl::WireWriter& writer) const override;
1493 bool read(yarp::os::idl::WireReader& reader) override;
1494
1496 };
1497
1498 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&);
1499 void call(IMap2DMsgs* ptr);
1500
1503
1504 static constexpr const char* s_tag{"delete_object_RPC"};
1505 static constexpr size_t s_tag_len{3};
1506 static constexpr size_t s_cmd_len{4};
1507 static constexpr size_t s_reply_len{1};
1508 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::delete_object_RPC(const std::string& object_name)"};
1509 static constexpr const char* s_help{""};
1510};
1511
1512// delete_location_RPC helper class declaration
1514 public yarp::os::Portable
1515{
1516public:
1518 explicit IMap2DMsgs_delete_location_RPC_helper(const std::string& location_name);
1519 bool write(yarp::os::ConnectionWriter& connection) const override;
1520 bool read(yarp::os::ConnectionReader& connection) override;
1521
1522 class Command :
1524 {
1525 public:
1526 Command() = default;
1527 explicit Command(const std::string& location_name);
1528
1529 ~Command() override = default;
1530
1531 bool write(yarp::os::ConnectionWriter& connection) const override;
1532 bool read(yarp::os::ConnectionReader& connection) override;
1533
1534 bool write(const yarp::os::idl::WireWriter& writer) const override;
1535 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1536 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1537
1538 bool read(yarp::os::idl::WireReader& reader) override;
1539 bool readTag(yarp::os::idl::WireReader& reader);
1540 bool readArgs(yarp::os::idl::WireReader& reader);
1541
1542 std::string location_name{};
1543 };
1544
1545 class Reply :
1547 {
1548 public:
1549 Reply() = default;
1550 ~Reply() override = default;
1551
1552 bool write(yarp::os::ConnectionWriter& connection) const override;
1553 bool read(yarp::os::ConnectionReader& connection) override;
1554
1555 bool write(const yarp::os::idl::WireWriter& writer) const override;
1556 bool read(yarp::os::idl::WireReader& reader) override;
1557
1559 };
1560
1561 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&);
1562 void call(IMap2DMsgs* ptr);
1563
1566
1567 static constexpr const char* s_tag{"delete_location_RPC"};
1568 static constexpr size_t s_tag_len{3};
1569 static constexpr size_t s_cmd_len{4};
1570 static constexpr size_t s_reply_len{1};
1571 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::delete_location_RPC(const std::string& location_name)"};
1572 static constexpr const char* s_help{""};
1573};
1574
1575// delete_path_RPC helper class declaration
1577 public yarp::os::Portable
1578{
1579public:
1581 explicit IMap2DMsgs_delete_path_RPC_helper(const std::string& path_name);
1582 bool write(yarp::os::ConnectionWriter& connection) const override;
1583 bool read(yarp::os::ConnectionReader& connection) override;
1584
1585 class Command :
1587 {
1588 public:
1589 Command() = default;
1590 explicit Command(const std::string& path_name);
1591
1592 ~Command() override = default;
1593
1594 bool write(yarp::os::ConnectionWriter& connection) const override;
1595 bool read(yarp::os::ConnectionReader& connection) override;
1596
1597 bool write(const yarp::os::idl::WireWriter& writer) const override;
1598 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1599 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1600
1601 bool read(yarp::os::idl::WireReader& reader) override;
1602 bool readTag(yarp::os::idl::WireReader& reader);
1603 bool readArgs(yarp::os::idl::WireReader& reader);
1604
1605 std::string path_name{};
1606 };
1607
1608 class Reply :
1610 {
1611 public:
1612 Reply() = default;
1613 ~Reply() override = default;
1614
1615 bool write(yarp::os::ConnectionWriter& connection) const override;
1616 bool read(yarp::os::ConnectionReader& connection) override;
1617
1618 bool write(const yarp::os::idl::WireWriter& writer) const override;
1619 bool read(yarp::os::idl::WireReader& reader) override;
1620
1622 };
1623
1624 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&);
1625 void call(IMap2DMsgs* ptr);
1626
1629
1630 static constexpr const char* s_tag{"delete_path_RPC"};
1631 static constexpr size_t s_tag_len{3};
1632 static constexpr size_t s_cmd_len{4};
1633 static constexpr size_t s_reply_len{1};
1634 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::delete_path_RPC(const std::string& path_name)"};
1635 static constexpr const char* s_help{""};
1636};
1637
1638// rename_object_RPC helper class declaration
1640 public yarp::os::Portable
1641{
1642public:
1644 IMap2DMsgs_rename_object_RPC_helper(const std::string& original_name, const std::string& new_name);
1645 bool write(yarp::os::ConnectionWriter& connection) const override;
1646 bool read(yarp::os::ConnectionReader& connection) override;
1647
1648 class Command :
1650 {
1651 public:
1652 Command() = default;
1653 Command(const std::string& original_name, const std::string& new_name);
1654
1655 ~Command() override = default;
1656
1657 bool write(yarp::os::ConnectionWriter& connection) const override;
1658 bool read(yarp::os::ConnectionReader& connection) override;
1659
1660 bool write(const yarp::os::idl::WireWriter& writer) const override;
1661 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1662 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1663
1664 bool read(yarp::os::idl::WireReader& reader) override;
1665 bool readTag(yarp::os::idl::WireReader& reader);
1666 bool readArgs(yarp::os::idl::WireReader& reader);
1667
1668 std::string original_name{};
1669 std::string new_name{};
1670 };
1671
1672 class Reply :
1674 {
1675 public:
1676 Reply() = default;
1677 ~Reply() override = default;
1678
1679 bool write(yarp::os::ConnectionWriter& connection) const override;
1680 bool read(yarp::os::ConnectionReader& connection) override;
1681
1682 bool write(const yarp::os::idl::WireWriter& writer) const override;
1683 bool read(yarp::os::idl::WireReader& reader) override;
1684
1686 };
1687
1688 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&, const std::string&);
1689 void call(IMap2DMsgs* ptr);
1690
1693
1694 static constexpr const char* s_tag{"rename_object_RPC"};
1695 static constexpr size_t s_tag_len{3};
1696 static constexpr size_t s_cmd_len{5};
1697 static constexpr size_t s_reply_len{1};
1698 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::rename_object_RPC(const std::string& original_name, const std::string& new_name)"};
1699 static constexpr const char* s_help{""};
1700};
1701
1702// rename_area_RPC helper class declaration
1704 public yarp::os::Portable
1705{
1706public:
1708 IMap2DMsgs_rename_area_RPC_helper(const std::string& original_name, const std::string& new_name);
1709 bool write(yarp::os::ConnectionWriter& connection) const override;
1710 bool read(yarp::os::ConnectionReader& connection) override;
1711
1712 class Command :
1714 {
1715 public:
1716 Command() = default;
1717 Command(const std::string& original_name, const std::string& new_name);
1718
1719 ~Command() override = default;
1720
1721 bool write(yarp::os::ConnectionWriter& connection) const override;
1722 bool read(yarp::os::ConnectionReader& connection) override;
1723
1724 bool write(const yarp::os::idl::WireWriter& writer) const override;
1725 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1726 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1727
1728 bool read(yarp::os::idl::WireReader& reader) override;
1729 bool readTag(yarp::os::idl::WireReader& reader);
1730 bool readArgs(yarp::os::idl::WireReader& reader);
1731
1732 std::string original_name{};
1733 std::string new_name{};
1734 };
1735
1736 class Reply :
1738 {
1739 public:
1740 Reply() = default;
1741 ~Reply() override = default;
1742
1743 bool write(yarp::os::ConnectionWriter& connection) const override;
1744 bool read(yarp::os::ConnectionReader& connection) override;
1745
1746 bool write(const yarp::os::idl::WireWriter& writer) const override;
1747 bool read(yarp::os::idl::WireReader& reader) override;
1748
1750 };
1751
1752 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&, const std::string&);
1753 void call(IMap2DMsgs* ptr);
1754
1757
1758 static constexpr const char* s_tag{"rename_area_RPC"};
1759 static constexpr size_t s_tag_len{3};
1760 static constexpr size_t s_cmd_len{5};
1761 static constexpr size_t s_reply_len{1};
1762 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::rename_area_RPC(const std::string& original_name, const std::string& new_name)"};
1763 static constexpr const char* s_help{""};
1764};
1765
1766// rename_path_RPC helper class declaration
1768 public yarp::os::Portable
1769{
1770public:
1772 IMap2DMsgs_rename_path_RPC_helper(const std::string& original_name, const std::string& new_name);
1773 bool write(yarp::os::ConnectionWriter& connection) const override;
1774 bool read(yarp::os::ConnectionReader& connection) override;
1775
1776 class Command :
1778 {
1779 public:
1780 Command() = default;
1781 Command(const std::string& original_name, const std::string& new_name);
1782
1783 ~Command() override = default;
1784
1785 bool write(yarp::os::ConnectionWriter& connection) const override;
1786 bool read(yarp::os::ConnectionReader& connection) override;
1787
1788 bool write(const yarp::os::idl::WireWriter& writer) const override;
1789 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1790 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1791
1792 bool read(yarp::os::idl::WireReader& reader) override;
1793 bool readTag(yarp::os::idl::WireReader& reader);
1794 bool readArgs(yarp::os::idl::WireReader& reader);
1795
1796 std::string original_name{};
1797 std::string new_name{};
1798 };
1799
1800 class Reply :
1802 {
1803 public:
1804 Reply() = default;
1805 ~Reply() override = default;
1806
1807 bool write(yarp::os::ConnectionWriter& connection) const override;
1808 bool read(yarp::os::ConnectionReader& connection) override;
1809
1810 bool write(const yarp::os::idl::WireWriter& writer) const override;
1811 bool read(yarp::os::idl::WireReader& reader) override;
1812
1814 };
1815
1816 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&, const std::string&);
1817 void call(IMap2DMsgs* ptr);
1818
1821
1822 static constexpr const char* s_tag{"rename_path_RPC"};
1823 static constexpr size_t s_tag_len{3};
1824 static constexpr size_t s_cmd_len{5};
1825 static constexpr size_t s_reply_len{1};
1826 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::rename_path_RPC(const std::string& original_name, const std::string& new_name)"};
1827 static constexpr const char* s_help{""};
1828};
1829
1830// delete_area_RPC helper class declaration
1832 public yarp::os::Portable
1833{
1834public:
1836 explicit IMap2DMsgs_delete_area_RPC_helper(const std::string& area_name);
1837 bool write(yarp::os::ConnectionWriter& connection) const override;
1838 bool read(yarp::os::ConnectionReader& connection) override;
1839
1840 class Command :
1842 {
1843 public:
1844 Command() = default;
1845 explicit Command(const std::string& area_name);
1846
1847 ~Command() override = default;
1848
1849 bool write(yarp::os::ConnectionWriter& connection) const override;
1850 bool read(yarp::os::ConnectionReader& connection) override;
1851
1852 bool write(const yarp::os::idl::WireWriter& writer) const override;
1853 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1854 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1855
1856 bool read(yarp::os::idl::WireReader& reader) override;
1857 bool readTag(yarp::os::idl::WireReader& reader);
1858 bool readArgs(yarp::os::idl::WireReader& reader);
1859
1860 std::string area_name{};
1861 };
1862
1863 class Reply :
1865 {
1866 public:
1867 Reply() = default;
1868 ~Reply() override = default;
1869
1870 bool write(yarp::os::ConnectionWriter& connection) const override;
1871 bool read(yarp::os::ConnectionReader& connection) override;
1872
1873 bool write(const yarp::os::idl::WireWriter& writer) const override;
1874 bool read(yarp::os::idl::WireReader& reader) override;
1875
1877 };
1878
1879 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&);
1880 void call(IMap2DMsgs* ptr);
1881
1884
1885 static constexpr const char* s_tag{"delete_area_RPC"};
1886 static constexpr size_t s_tag_len{3};
1887 static constexpr size_t s_cmd_len{4};
1888 static constexpr size_t s_reply_len{1};
1889 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::delete_area_RPC(const std::string& area_name)"};
1890 static constexpr const char* s_help{""};
1891};
1892
1893// clear_all_objects_RPC helper class declaration
1895 public yarp::os::Portable
1896{
1897public:
1899 bool write(yarp::os::ConnectionWriter& connection) const override;
1900 bool read(yarp::os::ConnectionReader& connection) override;
1901
1902 class Command :
1904 {
1905 public:
1906 Command() = default;
1907 ~Command() override = default;
1908
1909 bool write(yarp::os::ConnectionWriter& connection) const override;
1910 bool read(yarp::os::ConnectionReader& connection) override;
1911
1912 bool write(const yarp::os::idl::WireWriter& writer) const override;
1913 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1914 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1915
1916 bool read(yarp::os::idl::WireReader& reader) override;
1917 bool readTag(yarp::os::idl::WireReader& reader);
1918 bool readArgs(yarp::os::idl::WireReader& reader);
1919 };
1920
1921 class Reply :
1923 {
1924 public:
1925 Reply() = default;
1926 ~Reply() override = default;
1927
1928 bool write(yarp::os::ConnectionWriter& connection) const override;
1929 bool read(yarp::os::ConnectionReader& connection) override;
1930
1931 bool write(const yarp::os::idl::WireWriter& writer) const override;
1932 bool read(yarp::os::idl::WireReader& reader) override;
1933
1935 };
1936
1938 void call(IMap2DMsgs* ptr);
1939
1942
1943 static constexpr const char* s_tag{"clear_all_objects_RPC"};
1944 static constexpr size_t s_tag_len{4};
1945 static constexpr size_t s_cmd_len{4};
1946 static constexpr size_t s_reply_len{1};
1947 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::clear_all_objects_RPC()"};
1948 static constexpr const char* s_help{""};
1949};
1950
1951// clear_all_locations_RPC helper class declaration
1953 public yarp::os::Portable
1954{
1955public:
1957 bool write(yarp::os::ConnectionWriter& connection) const override;
1958 bool read(yarp::os::ConnectionReader& connection) override;
1959
1960 class Command :
1962 {
1963 public:
1964 Command() = default;
1965 ~Command() override = default;
1966
1967 bool write(yarp::os::ConnectionWriter& connection) const override;
1968 bool read(yarp::os::ConnectionReader& connection) override;
1969
1970 bool write(const yarp::os::idl::WireWriter& writer) const override;
1971 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
1972 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
1973
1974 bool read(yarp::os::idl::WireReader& reader) override;
1975 bool readTag(yarp::os::idl::WireReader& reader);
1976 bool readArgs(yarp::os::idl::WireReader& reader);
1977 };
1978
1979 class Reply :
1981 {
1982 public:
1983 Reply() = default;
1984 ~Reply() override = default;
1985
1986 bool write(yarp::os::ConnectionWriter& connection) const override;
1987 bool read(yarp::os::ConnectionReader& connection) override;
1988
1989 bool write(const yarp::os::idl::WireWriter& writer) const override;
1990 bool read(yarp::os::idl::WireReader& reader) override;
1991
1993 };
1994
1996 void call(IMap2DMsgs* ptr);
1997
2000
2001 static constexpr const char* s_tag{"clear_all_locations_RPC"};
2002 static constexpr size_t s_tag_len{4};
2003 static constexpr size_t s_cmd_len{4};
2004 static constexpr size_t s_reply_len{1};
2005 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::clear_all_locations_RPC()"};
2006 static constexpr const char* s_help{""};
2007};
2008
2009// clear_all_areas_RPC helper class declaration
2011 public yarp::os::Portable
2012{
2013public:
2015 bool write(yarp::os::ConnectionWriter& connection) const override;
2016 bool read(yarp::os::ConnectionReader& connection) override;
2017
2018 class Command :
2020 {
2021 public:
2022 Command() = default;
2023 ~Command() override = default;
2024
2025 bool write(yarp::os::ConnectionWriter& connection) const override;
2026 bool read(yarp::os::ConnectionReader& connection) override;
2027
2028 bool write(const yarp::os::idl::WireWriter& writer) const override;
2029 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2030 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2031
2032 bool read(yarp::os::idl::WireReader& reader) override;
2033 bool readTag(yarp::os::idl::WireReader& reader);
2034 bool readArgs(yarp::os::idl::WireReader& reader);
2035 };
2036
2037 class Reply :
2039 {
2040 public:
2041 Reply() = default;
2042 ~Reply() override = default;
2043
2044 bool write(yarp::os::ConnectionWriter& connection) const override;
2045 bool read(yarp::os::ConnectionReader& connection) override;
2046
2047 bool write(const yarp::os::idl::WireWriter& writer) const override;
2048 bool read(yarp::os::idl::WireReader& reader) override;
2049
2051 };
2052
2054 void call(IMap2DMsgs* ptr);
2055
2058
2059 static constexpr const char* s_tag{"clear_all_areas_RPC"};
2060 static constexpr size_t s_tag_len{4};
2061 static constexpr size_t s_cmd_len{4};
2062 static constexpr size_t s_reply_len{1};
2063 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::clear_all_areas_RPC()"};
2064 static constexpr const char* s_help{""};
2065};
2066
2067// clear_all_paths_RPC helper class declaration
2069 public yarp::os::Portable
2070{
2071public:
2073 bool write(yarp::os::ConnectionWriter& connection) const override;
2074 bool read(yarp::os::ConnectionReader& connection) override;
2075
2076 class Command :
2078 {
2079 public:
2080 Command() = default;
2081 ~Command() override = default;
2082
2083 bool write(yarp::os::ConnectionWriter& connection) const override;
2084 bool read(yarp::os::ConnectionReader& connection) override;
2085
2086 bool write(const yarp::os::idl::WireWriter& writer) const override;
2087 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2088 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2089
2090 bool read(yarp::os::idl::WireReader& reader) override;
2091 bool readTag(yarp::os::idl::WireReader& reader);
2092 bool readArgs(yarp::os::idl::WireReader& reader);
2093 };
2094
2095 class Reply :
2097 {
2098 public:
2099 Reply() = default;
2100 ~Reply() override = default;
2101
2102 bool write(yarp::os::ConnectionWriter& connection) const override;
2103 bool read(yarp::os::ConnectionReader& connection) override;
2104
2105 bool write(const yarp::os::idl::WireWriter& writer) const override;
2106 bool read(yarp::os::idl::WireReader& reader) override;
2107
2109 };
2110
2112 void call(IMap2DMsgs* ptr);
2113
2116
2117 static constexpr const char* s_tag{"clear_all_paths_RPC"};
2118 static constexpr size_t s_tag_len{4};
2119 static constexpr size_t s_cmd_len{4};
2120 static constexpr size_t s_reply_len{1};
2121 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::clear_all_paths_RPC()"};
2122 static constexpr const char* s_help{""};
2123};
2124
2125// clear_all_maps_temporary_flags_RPC helper class declaration
2127 public yarp::os::Portable
2128{
2129public:
2131 bool write(yarp::os::ConnectionWriter& connection) const override;
2132 bool read(yarp::os::ConnectionReader& connection) override;
2133
2134 class Command :
2136 {
2137 public:
2138 Command() = default;
2139 ~Command() override = default;
2140
2141 bool write(yarp::os::ConnectionWriter& connection) const override;
2142 bool read(yarp::os::ConnectionReader& connection) override;
2143
2144 bool write(const yarp::os::idl::WireWriter& writer) const override;
2145 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2146 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2147
2148 bool read(yarp::os::idl::WireReader& reader) override;
2149 bool readTag(yarp::os::idl::WireReader& reader);
2150 bool readArgs(yarp::os::idl::WireReader& reader);
2151 };
2152
2153 class Reply :
2155 {
2156 public:
2157 Reply() = default;
2158 ~Reply() override = default;
2159
2160 bool write(yarp::os::ConnectionWriter& connection) const override;
2161 bool read(yarp::os::ConnectionReader& connection) override;
2162
2163 bool write(const yarp::os::idl::WireWriter& writer) const override;
2164 bool read(yarp::os::idl::WireReader& reader) override;
2165
2167 };
2168
2170 void call(IMap2DMsgs* ptr);
2171
2174
2175 static constexpr const char* s_tag{"clear_all_maps_temporary_flags_RPC"};
2176 static constexpr size_t s_tag_len{6};
2177 static constexpr size_t s_cmd_len{6};
2178 static constexpr size_t s_reply_len{1};
2179 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::clear_all_maps_temporary_flags_RPC()"};
2180 static constexpr const char* s_help{""};
2181};
2182
2183// clear_map_temporary_flags_RPC helper class declaration
2185 public yarp::os::Portable
2186{
2187public:
2189 explicit IMap2DMsgs_clear_map_temporary_flags_RPC_helper(const std::string& map_name);
2190 bool write(yarp::os::ConnectionWriter& connection) const override;
2191 bool read(yarp::os::ConnectionReader& connection) override;
2192
2193 class Command :
2195 {
2196 public:
2197 Command() = default;
2198 explicit Command(const std::string& map_name);
2199
2200 ~Command() override = default;
2201
2202 bool write(yarp::os::ConnectionWriter& connection) const override;
2203 bool read(yarp::os::ConnectionReader& connection) override;
2204
2205 bool write(const yarp::os::idl::WireWriter& writer) const override;
2206 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2207 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2208
2209 bool read(yarp::os::idl::WireReader& reader) override;
2210 bool readTag(yarp::os::idl::WireReader& reader);
2211 bool readArgs(yarp::os::idl::WireReader& reader);
2212
2213 std::string map_name{};
2214 };
2215
2216 class Reply :
2218 {
2219 public:
2220 Reply() = default;
2221 ~Reply() override = default;
2222
2223 bool write(yarp::os::ConnectionWriter& connection) const override;
2224 bool read(yarp::os::ConnectionReader& connection) override;
2225
2226 bool write(const yarp::os::idl::WireWriter& writer) const override;
2227 bool read(yarp::os::idl::WireReader& reader) override;
2228
2230 };
2231
2232 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&);
2233 void call(IMap2DMsgs* ptr);
2234
2237
2238 static constexpr const char* s_tag{"clear_map_temporary_flags_RPC"};
2239 static constexpr size_t s_tag_len{5};
2240 static constexpr size_t s_cmd_len{6};
2241 static constexpr size_t s_reply_len{1};
2242 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::clear_map_temporary_flags_RPC(const std::string& map_name)"};
2243 static constexpr const char* s_help{""};
2244};
2245
2246// save_maps_collection_RPC helper class declaration
2248 public yarp::os::Portable
2249{
2250public:
2252 explicit IMap2DMsgs_save_maps_collection_RPC_helper(const std::string& maps_collection_file);
2253 bool write(yarp::os::ConnectionWriter& connection) const override;
2254 bool read(yarp::os::ConnectionReader& connection) override;
2255
2256 class Command :
2258 {
2259 public:
2260 Command() = default;
2261 explicit Command(const std::string& maps_collection_file);
2262
2263 ~Command() override = default;
2264
2265 bool write(yarp::os::ConnectionWriter& connection) const override;
2266 bool read(yarp::os::ConnectionReader& connection) override;
2267
2268 bool write(const yarp::os::idl::WireWriter& writer) const override;
2269 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2270 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2271
2272 bool read(yarp::os::idl::WireReader& reader) override;
2273 bool readTag(yarp::os::idl::WireReader& reader);
2274 bool readArgs(yarp::os::idl::WireReader& reader);
2275
2277 };
2278
2279 class Reply :
2281 {
2282 public:
2283 Reply() = default;
2284 ~Reply() override = default;
2285
2286 bool write(yarp::os::ConnectionWriter& connection) const override;
2287 bool read(yarp::os::ConnectionReader& connection) override;
2288
2289 bool write(const yarp::os::idl::WireWriter& writer) const override;
2290 bool read(yarp::os::idl::WireReader& reader) override;
2291
2293 };
2294
2295 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&);
2296 void call(IMap2DMsgs* ptr);
2297
2300
2301 static constexpr const char* s_tag{"save_maps_collection_RPC"};
2302 static constexpr size_t s_tag_len{4};
2303 static constexpr size_t s_cmd_len{5};
2304 static constexpr size_t s_reply_len{1};
2305 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::save_maps_collection_RPC(const std::string& maps_collection_file)"};
2306 static constexpr const char* s_help{""};
2307};
2308
2309// load_maps_collection_RPC helper class declaration
2311 public yarp::os::Portable
2312{
2313public:
2315 explicit IMap2DMsgs_load_maps_collection_RPC_helper(const std::string& maps_collection_file);
2316 bool write(yarp::os::ConnectionWriter& connection) const override;
2317 bool read(yarp::os::ConnectionReader& connection) override;
2318
2319 class Command :
2321 {
2322 public:
2323 Command() = default;
2324 explicit Command(const std::string& maps_collection_file);
2325
2326 ~Command() override = default;
2327
2328 bool write(yarp::os::ConnectionWriter& connection) const override;
2329 bool read(yarp::os::ConnectionReader& connection) override;
2330
2331 bool write(const yarp::os::idl::WireWriter& writer) const override;
2332 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2333 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2334
2335 bool read(yarp::os::idl::WireReader& reader) override;
2336 bool readTag(yarp::os::idl::WireReader& reader);
2337 bool readArgs(yarp::os::idl::WireReader& reader);
2338
2340 };
2341
2342 class Reply :
2344 {
2345 public:
2346 Reply() = default;
2347 ~Reply() override = default;
2348
2349 bool write(yarp::os::ConnectionWriter& connection) const override;
2350 bool read(yarp::os::ConnectionReader& connection) override;
2351
2352 bool write(const yarp::os::idl::WireWriter& writer) const override;
2353 bool read(yarp::os::idl::WireReader& reader) override;
2354
2356 };
2357
2358 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&);
2359 void call(IMap2DMsgs* ptr);
2360
2363
2364 static constexpr const char* s_tag{"load_maps_collection_RPC"};
2365 static constexpr size_t s_tag_len{4};
2366 static constexpr size_t s_cmd_len{5};
2367 static constexpr size_t s_reply_len{1};
2368 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::load_maps_collection_RPC(const std::string& maps_collection_file)"};
2369 static constexpr const char* s_help{""};
2370};
2371
2372// save_locations_and_extras_RPC helper class declaration
2374 public yarp::os::Portable
2375{
2376public:
2378 explicit IMap2DMsgs_save_locations_and_extras_RPC_helper(const std::string& locations_collection_file);
2379 bool write(yarp::os::ConnectionWriter& connection) const override;
2380 bool read(yarp::os::ConnectionReader& connection) override;
2381
2382 class Command :
2384 {
2385 public:
2386 Command() = default;
2387 explicit Command(const std::string& locations_collection_file);
2388
2389 ~Command() override = default;
2390
2391 bool write(yarp::os::ConnectionWriter& connection) const override;
2392 bool read(yarp::os::ConnectionReader& connection) override;
2393
2394 bool write(const yarp::os::idl::WireWriter& writer) const override;
2395 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2396 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2397
2398 bool read(yarp::os::idl::WireReader& reader) override;
2399 bool readTag(yarp::os::idl::WireReader& reader);
2400 bool readArgs(yarp::os::idl::WireReader& reader);
2401
2403 };
2404
2405 class Reply :
2407 {
2408 public:
2409 Reply() = default;
2410 ~Reply() override = default;
2411
2412 bool write(yarp::os::ConnectionWriter& connection) const override;
2413 bool read(yarp::os::ConnectionReader& connection) override;
2414
2415 bool write(const yarp::os::idl::WireWriter& writer) const override;
2416 bool read(yarp::os::idl::WireReader& reader) override;
2417
2419 };
2420
2421 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&);
2422 void call(IMap2DMsgs* ptr);
2423
2426
2427 static constexpr const char* s_tag{"save_locations_and_extras_RPC"};
2428 static constexpr size_t s_tag_len{5};
2429 static constexpr size_t s_cmd_len{6};
2430 static constexpr size_t s_reply_len{1};
2431 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::save_locations_and_extras_RPC(const std::string& locations_collection_file)"};
2432 static constexpr const char* s_help{""};
2433};
2434
2435// load_locations_and_extras_RPC helper class declaration
2437 public yarp::os::Portable
2438{
2439public:
2441 explicit IMap2DMsgs_load_locations_and_extras_RPC_helper(const std::string& locations_collection_file);
2442 bool write(yarp::os::ConnectionWriter& connection) const override;
2443 bool read(yarp::os::ConnectionReader& connection) override;
2444
2445 class Command :
2447 {
2448 public:
2449 Command() = default;
2450 explicit Command(const std::string& locations_collection_file);
2451
2452 ~Command() override = default;
2453
2454 bool write(yarp::os::ConnectionWriter& connection) const override;
2455 bool read(yarp::os::ConnectionReader& connection) override;
2456
2457 bool write(const yarp::os::idl::WireWriter& writer) const override;
2458 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2459 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2460
2461 bool read(yarp::os::idl::WireReader& reader) override;
2462 bool readTag(yarp::os::idl::WireReader& reader);
2463 bool readArgs(yarp::os::idl::WireReader& reader);
2464
2466 };
2467
2468 class Reply :
2470 {
2471 public:
2472 Reply() = default;
2473 ~Reply() override = default;
2474
2475 bool write(yarp::os::ConnectionWriter& connection) const override;
2476 bool read(yarp::os::ConnectionReader& connection) override;
2477
2478 bool write(const yarp::os::idl::WireWriter& writer) const override;
2479 bool read(yarp::os::idl::WireReader& reader) override;
2480
2482 };
2483
2484 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&);
2485 void call(IMap2DMsgs* ptr);
2486
2489
2490 static constexpr const char* s_tag{"load_locations_and_extras_RPC"};
2491 static constexpr size_t s_tag_len{5};
2492 static constexpr size_t s_cmd_len{6};
2493 static constexpr size_t s_reply_len{1};
2494 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::load_locations_and_extras_RPC(const std::string& locations_collection_file)"};
2495 static constexpr const char* s_help{""};
2496};
2497
2498// save_map_to_disk_RPC helper class declaration
2500 public yarp::os::Portable
2501{
2502public:
2504 IMap2DMsgs_save_map_to_disk_RPC_helper(const std::string& map_name, const std::string& file_name);
2505 bool write(yarp::os::ConnectionWriter& connection) const override;
2506 bool read(yarp::os::ConnectionReader& connection) override;
2507
2508 class Command :
2510 {
2511 public:
2512 Command() = default;
2513 Command(const std::string& map_name, const std::string& file_name);
2514
2515 ~Command() override = default;
2516
2517 bool write(yarp::os::ConnectionWriter& connection) const override;
2518 bool read(yarp::os::ConnectionReader& connection) override;
2519
2520 bool write(const yarp::os::idl::WireWriter& writer) const override;
2521 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2522 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2523
2524 bool read(yarp::os::idl::WireReader& reader) override;
2525 bool readTag(yarp::os::idl::WireReader& reader);
2526 bool readArgs(yarp::os::idl::WireReader& reader);
2527
2528 std::string map_name{};
2529 std::string file_name{};
2530 };
2531
2532 class Reply :
2534 {
2535 public:
2536 Reply() = default;
2537 ~Reply() override = default;
2538
2539 bool write(yarp::os::ConnectionWriter& connection) const override;
2540 bool read(yarp::os::ConnectionReader& connection) override;
2541
2542 bool write(const yarp::os::idl::WireWriter& writer) const override;
2543 bool read(yarp::os::idl::WireReader& reader) override;
2544
2546 };
2547
2548 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&, const std::string&);
2549 void call(IMap2DMsgs* ptr);
2550
2553
2554 static constexpr const char* s_tag{"save_map_to_disk_RPC"};
2555 static constexpr size_t s_tag_len{5};
2556 static constexpr size_t s_cmd_len{7};
2557 static constexpr size_t s_reply_len{1};
2558 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)"};
2559 static constexpr const char* s_help{""};
2560};
2561
2562// load_map_from_disk_RPC helper class declaration
2564 public yarp::os::Portable
2565{
2566public:
2568 explicit IMap2DMsgs_load_map_from_disk_RPC_helper(const std::string& file_name);
2569 bool write(yarp::os::ConnectionWriter& connection) const override;
2570 bool read(yarp::os::ConnectionReader& connection) override;
2571
2572 class Command :
2574 {
2575 public:
2576 Command() = default;
2577 explicit Command(const std::string& file_name);
2578
2579 ~Command() override = default;
2580
2581 bool write(yarp::os::ConnectionWriter& connection) const override;
2582 bool read(yarp::os::ConnectionReader& connection) override;
2583
2584 bool write(const yarp::os::idl::WireWriter& writer) const override;
2585 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2586 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2587
2588 bool read(yarp::os::idl::WireReader& reader) override;
2589 bool readTag(yarp::os::idl::WireReader& reader);
2590 bool readArgs(yarp::os::idl::WireReader& reader);
2591
2592 std::string file_name{};
2593 };
2594
2595 class Reply :
2597 {
2598 public:
2599 Reply() = default;
2600 ~Reply() override = default;
2601
2602 bool write(yarp::os::ConnectionWriter& connection) const override;
2603 bool read(yarp::os::ConnectionReader& connection) override;
2604
2605 bool write(const yarp::os::idl::WireWriter& writer) const override;
2606 bool read(yarp::os::idl::WireReader& reader) override;
2607
2609 };
2610
2611 using funcptr_t = yarp::dev::ReturnValue (*)(const std::string&);
2612 void call(IMap2DMsgs* ptr);
2613
2616
2617 static constexpr const char* s_tag{"load_map_from_disk_RPC"};
2618 static constexpr size_t s_tag_len{5};
2619 static constexpr size_t s_cmd_len{6};
2620 static constexpr size_t s_reply_len{1};
2621 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::load_map_from_disk_RPC(const std::string& file_name)"};
2622 static constexpr const char* s_help{""};
2623};
2624
2625// enable_maps_compression_RPC helper class declaration
2627 public yarp::os::Portable
2628{
2629public:
2631 explicit IMap2DMsgs_enable_maps_compression_RPC_helper(const bool enable_compression);
2632 bool write(yarp::os::ConnectionWriter& connection) const override;
2633 bool read(yarp::os::ConnectionReader& connection) override;
2634
2635 class Command :
2637 {
2638 public:
2639 Command() = default;
2640 explicit Command(const bool enable_compression);
2641
2642 ~Command() override = default;
2643
2644 bool write(yarp::os::ConnectionWriter& connection) const override;
2645 bool read(yarp::os::ConnectionReader& connection) override;
2646
2647 bool write(const yarp::os::idl::WireWriter& writer) const override;
2648 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2649 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2650
2651 bool read(yarp::os::idl::WireReader& reader) override;
2652 bool readTag(yarp::os::idl::WireReader& reader);
2653 bool readArgs(yarp::os::idl::WireReader& reader);
2654
2656 };
2657
2658 class Reply :
2660 {
2661 public:
2662 Reply() = default;
2663 ~Reply() override = default;
2664
2665 bool write(yarp::os::ConnectionWriter& connection) const override;
2666 bool read(yarp::os::ConnectionReader& connection) override;
2667
2668 bool write(const yarp::os::idl::WireWriter& writer) const override;
2669 bool read(yarp::os::idl::WireReader& reader) override;
2670
2672 };
2673
2674 using funcptr_t = yarp::dev::ReturnValue (*)(const bool);
2675 void call(IMap2DMsgs* ptr);
2676
2679
2680 static constexpr const char* s_tag{"enable_maps_compression_RPC"};
2681 static constexpr size_t s_tag_len{4};
2682 static constexpr size_t s_cmd_len{5};
2683 static constexpr size_t s_reply_len{1};
2684 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::enable_maps_compression_RPC(const bool enable_compression)"};
2685 static constexpr const char* s_help{""};
2686};
2687
2688// reload_maps_collection_RPC helper class declaration
2690 public yarp::os::Portable
2691{
2692public:
2694 bool write(yarp::os::ConnectionWriter& connection) const override;
2695 bool read(yarp::os::ConnectionReader& connection) override;
2696
2697 class Command :
2699 {
2700 public:
2701 Command() = default;
2702 ~Command() override = default;
2703
2704 bool write(yarp::os::ConnectionWriter& connection) const override;
2705 bool read(yarp::os::ConnectionReader& connection) override;
2706
2707 bool write(const yarp::os::idl::WireWriter& writer) const override;
2708 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2709 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2710
2711 bool read(yarp::os::idl::WireReader& reader) override;
2712 bool readTag(yarp::os::idl::WireReader& reader);
2713 bool readArgs(yarp::os::idl::WireReader& reader);
2714 };
2715
2716 class Reply :
2718 {
2719 public:
2720 Reply() = default;
2721 ~Reply() override = default;
2722
2723 bool write(yarp::os::ConnectionWriter& connection) const override;
2724 bool read(yarp::os::ConnectionReader& connection) override;
2725
2726 bool write(const yarp::os::idl::WireWriter& writer) const override;
2727 bool read(yarp::os::idl::WireReader& reader) override;
2728
2730 };
2731
2733 void call(IMap2DMsgs* ptr);
2734
2737
2738 static constexpr const char* s_tag{"reload_maps_collection_RPC"};
2739 static constexpr size_t s_tag_len{4};
2740 static constexpr size_t s_cmd_len{4};
2741 static constexpr size_t s_reply_len{1};
2742 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::reload_maps_collection_RPC()"};
2743 static constexpr const char* s_help{""};
2744};
2745
2746// reload_locations_and_extras_RPC helper class declaration
2748 public yarp::os::Portable
2749{
2750public:
2752 bool write(yarp::os::ConnectionWriter& connection) const override;
2753 bool read(yarp::os::ConnectionReader& connection) override;
2754
2755 class Command :
2757 {
2758 public:
2759 Command() = default;
2760 ~Command() override = default;
2761
2762 bool write(yarp::os::ConnectionWriter& connection) const override;
2763 bool read(yarp::os::ConnectionReader& connection) override;
2764
2765 bool write(const yarp::os::idl::WireWriter& writer) const override;
2766 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
2767 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
2768
2769 bool read(yarp::os::idl::WireReader& reader) override;
2770 bool readTag(yarp::os::idl::WireReader& reader);
2771 bool readArgs(yarp::os::idl::WireReader& reader);
2772 };
2773
2774 class Reply :
2776 {
2777 public:
2778 Reply() = default;
2779 ~Reply() override = default;
2780
2781 bool write(yarp::os::ConnectionWriter& connection) const override;
2782 bool read(yarp::os::ConnectionReader& connection) override;
2783
2784 bool write(const yarp::os::idl::WireWriter& writer) const override;
2785 bool read(yarp::os::idl::WireReader& reader) override;
2786
2788 };
2789
2791 void call(IMap2DMsgs* ptr);
2792
2795
2796 static constexpr const char* s_tag{"reload_locations_and_extras_RPC"};
2797 static constexpr size_t s_tag_len{5};
2798 static constexpr size_t s_cmd_len{5};
2799 static constexpr size_t s_reply_len{1};
2800 static constexpr const char* s_prototype{"yarp::dev::ReturnValue IMap2DMsgs::reload_locations_and_extras_RPC()"};
2801 static constexpr const char* s_help{""};
2802};
2803
2804// clear_all_maps_RPC helper class implementation
2806{
2807 return cmd.write(connection);
2808}
2809
2811{
2812 return reply.read(connection);
2813}
2814
2816{
2817 yarp::os::idl::WireWriter writer(connection);
2818 if (!writer.writeListHeader(s_cmd_len)) {
2819 return false;
2820 }
2821 return write(writer);
2822}
2823
2825{
2826 yarp::os::idl::WireReader reader(connection);
2827 if (!reader.readListHeader()) {
2828 reader.fail();
2829 return false;
2830 }
2831 return read(reader);
2832}
2833
2835{
2836 if (!writeTag(writer)) {
2837 return false;
2838 }
2839 if (!writeArgs(writer)) {
2840 return false;
2841 }
2842 return true;
2843}
2844
2846{
2847 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2848 return false;
2849 }
2850 return true;
2851}
2852
2854{
2855 return true;
2856}
2857
2859{
2860 if (!readTag(reader)) {
2861 return false;
2862 }
2863 if (!readArgs(reader)) {
2864 return false;
2865 }
2866 return true;
2867}
2868
2870{
2871 std::string tag = reader.readTag(s_tag_len);
2872 if (reader.isError()) {
2873 return false;
2874 }
2875 if (tag != s_tag) {
2876 reader.fail();
2877 return false;
2878 }
2879 return true;
2880}
2881
2883{
2884 if (!reader.noMore()) {
2885 reader.fail();
2886 return false;
2887 }
2888 return true;
2889}
2890
2892{
2893 yarp::os::idl::WireWriter writer(connection);
2894 return write(writer);
2895}
2896
2898{
2899 yarp::os::idl::WireReader reader(connection);
2900 return read(reader);
2901}
2902
2904{
2905 if (!writer.isNull()) {
2906 if (!writer.write(return_helper)) {
2907 return false;
2908 }
2909 }
2910 return true;
2911}
2912
2914{
2915 if (reader.noMore()) {
2916 reader.fail();
2917 return false;
2918 }
2919 if (!reader.read(return_helper)) {
2920 reader.fail();
2921 return false;
2922 }
2923 return true;
2924}
2925
2930
2931// store_map_RPC helper class implementation
2936
2938{
2939 return cmd.write(connection);
2940}
2941
2943{
2944 return reply.read(connection);
2945}
2946
2951
2953{
2954 yarp::os::idl::WireWriter writer(connection);
2955 if (!writer.writeListHeader(s_cmd_len)) {
2956 return false;
2957 }
2958 return write(writer);
2959}
2960
2962{
2963 yarp::os::idl::WireReader reader(connection);
2964 if (!reader.readListHeader()) {
2965 reader.fail();
2966 return false;
2967 }
2968 return read(reader);
2969}
2970
2972{
2973 if (!writeTag(writer)) {
2974 return false;
2975 }
2976 if (!writeArgs(writer)) {
2977 return false;
2978 }
2979 return true;
2980}
2981
2983{
2984 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2985 return false;
2986 }
2987 return true;
2988}
2989
2991{
2992 if (!writer.writeNested(themap)) {
2993 return false;
2994 }
2995 return true;
2996}
2997
2999{
3000 if (!readTag(reader)) {
3001 return false;
3002 }
3003 if (!readArgs(reader)) {
3004 return false;
3005 }
3006 return true;
3007}
3008
3010{
3011 std::string tag = reader.readTag(s_tag_len);
3012 if (reader.isError()) {
3013 return false;
3014 }
3015 if (tag != s_tag) {
3016 reader.fail();
3017 return false;
3018 }
3019 return true;
3020}
3021
3023{
3024 if (reader.noMore()) {
3025 reader.fail();
3026 return false;
3027 }
3028 if (!reader.readNested(themap)) {
3029 reader.fail();
3030 return false;
3031 }
3032 if (!reader.noMore()) {
3033 reader.fail();
3034 return false;
3035 }
3036 return true;
3037}
3038
3040{
3041 yarp::os::idl::WireWriter writer(connection);
3042 return write(writer);
3043}
3044
3046{
3047 yarp::os::idl::WireReader reader(connection);
3048 return read(reader);
3049}
3050
3052{
3053 if (!writer.isNull()) {
3054 if (!writer.write(return_helper)) {
3055 return false;
3056 }
3057 }
3058 return true;
3059}
3060
3062{
3063 if (reader.noMore()) {
3064 reader.fail();
3065 return false;
3066 }
3067 if (!reader.read(return_helper)) {
3068 reader.fail();
3069 return false;
3070 }
3071 return true;
3072}
3073
3078
3079// get_map_RPC helper class implementation
3081 cmd{map_name}
3082{
3083}
3084
3086{
3087 return cmd.write(connection);
3088}
3089
3091{
3092 return reply.read(connection);
3093}
3094
3096 map_name{map_name}
3097{
3098}
3099
3101{
3102 yarp::os::idl::WireWriter writer(connection);
3103 if (!writer.writeListHeader(s_cmd_len)) {
3104 return false;
3105 }
3106 return write(writer);
3107}
3108
3110{
3111 yarp::os::idl::WireReader reader(connection);
3112 if (!reader.readListHeader()) {
3113 reader.fail();
3114 return false;
3115 }
3116 return read(reader);
3117}
3118
3120{
3121 if (!writeTag(writer)) {
3122 return false;
3123 }
3124 if (!writeArgs(writer)) {
3125 return false;
3126 }
3127 return true;
3128}
3129
3131{
3132 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3133 return false;
3134 }
3135 return true;
3136}
3137
3139{
3140 if (!writer.writeString(map_name)) {
3141 return false;
3142 }
3143 return true;
3144}
3145
3147{
3148 if (!readTag(reader)) {
3149 return false;
3150 }
3151 if (!readArgs(reader)) {
3152 return false;
3153 }
3154 return true;
3155}
3156
3158{
3159 std::string tag = reader.readTag(s_tag_len);
3160 if (reader.isError()) {
3161 return false;
3162 }
3163 if (tag != s_tag) {
3164 reader.fail();
3165 return false;
3166 }
3167 return true;
3168}
3169
3171{
3172 if (reader.noMore()) {
3173 reader.fail();
3174 return false;
3175 }
3176 if (!reader.readString(map_name)) {
3177 reader.fail();
3178 return false;
3179 }
3180 if (!reader.noMore()) {
3181 reader.fail();
3182 return false;
3183 }
3184 return true;
3185}
3186
3188{
3189 yarp::os::idl::WireWriter writer(connection);
3190 return write(writer);
3191}
3192
3194{
3195 yarp::os::idl::WireReader reader(connection);
3196 return read(reader);
3197}
3198
3200{
3201 if (!writer.isNull()) {
3202 if (!writer.writeListHeader(s_reply_len)) {
3203 return false;
3204 }
3205 if (!writer.write(return_helper)) {
3206 return false;
3207 }
3208 }
3209 return true;
3210}
3211
3213{
3214 if (!reader.readListReturn()) {
3215 return false;
3216 }
3217 if (reader.noMore()) {
3218 reader.fail();
3219 return false;
3220 }
3221 if (!reader.read(return_helper)) {
3222 reader.fail();
3223 return false;
3224 }
3225 return true;
3226}
3227
3232
3233// get_map_names_RPC helper class implementation
3235{
3236 return cmd.write(connection);
3237}
3238
3240{
3241 return reply.read(connection);
3242}
3243
3245{
3246 yarp::os::idl::WireWriter writer(connection);
3247 if (!writer.writeListHeader(s_cmd_len)) {
3248 return false;
3249 }
3250 return write(writer);
3251}
3252
3254{
3255 yarp::os::idl::WireReader reader(connection);
3256 if (!reader.readListHeader()) {
3257 reader.fail();
3258 return false;
3259 }
3260 return read(reader);
3261}
3262
3264{
3265 if (!writeTag(writer)) {
3266 return false;
3267 }
3268 if (!writeArgs(writer)) {
3269 return false;
3270 }
3271 return true;
3272}
3273
3275{
3276 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3277 return false;
3278 }
3279 return true;
3280}
3281
3283{
3284 return true;
3285}
3286
3288{
3289 if (!readTag(reader)) {
3290 return false;
3291 }
3292 if (!readArgs(reader)) {
3293 return false;
3294 }
3295 return true;
3296}
3297
3299{
3300 std::string tag = reader.readTag(s_tag_len);
3301 if (reader.isError()) {
3302 return false;
3303 }
3304 if (tag != s_tag) {
3305 reader.fail();
3306 return false;
3307 }
3308 return true;
3309}
3310
3312{
3313 if (!reader.noMore()) {
3314 reader.fail();
3315 return false;
3316 }
3317 return true;
3318}
3319
3321{
3322 yarp::os::idl::WireWriter writer(connection);
3323 return write(writer);
3324}
3325
3327{
3328 yarp::os::idl::WireReader reader(connection);
3329 return read(reader);
3330}
3331
3333{
3334 if (!writer.isNull()) {
3335 if (!writer.writeListHeader(s_reply_len)) {
3336 return false;
3337 }
3338 if (!writer.write(return_helper)) {
3339 return false;
3340 }
3341 }
3342 return true;
3343}
3344
3346{
3347 if (!reader.readListReturn()) {
3348 return false;
3349 }
3350 if (reader.noMore()) {
3351 reader.fail();
3352 return false;
3353 }
3354 if (!reader.read(return_helper)) {
3355 reader.fail();
3356 return false;
3357 }
3358 return true;
3359}
3360
3365
3366// remove_map_RPC helper class implementation
3368 cmd{map_name}
3369{
3370}
3371
3373{
3374 return cmd.write(connection);
3375}
3376
3378{
3379 return reply.read(connection);
3380}
3381
3383 map_name{map_name}
3384{
3385}
3386
3388{
3389 yarp::os::idl::WireWriter writer(connection);
3390 if (!writer.writeListHeader(s_cmd_len)) {
3391 return false;
3392 }
3393 return write(writer);
3394}
3395
3397{
3398 yarp::os::idl::WireReader reader(connection);
3399 if (!reader.readListHeader()) {
3400 reader.fail();
3401 return false;
3402 }
3403 return read(reader);
3404}
3405
3407{
3408 if (!writeTag(writer)) {
3409 return false;
3410 }
3411 if (!writeArgs(writer)) {
3412 return false;
3413 }
3414 return true;
3415}
3416
3418{
3419 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3420 return false;
3421 }
3422 return true;
3423}
3424
3426{
3427 if (!writer.writeString(map_name)) {
3428 return false;
3429 }
3430 return true;
3431}
3432
3434{
3435 if (!readTag(reader)) {
3436 return false;
3437 }
3438 if (!readArgs(reader)) {
3439 return false;
3440 }
3441 return true;
3442}
3443
3445{
3446 std::string tag = reader.readTag(s_tag_len);
3447 if (reader.isError()) {
3448 return false;
3449 }
3450 if (tag != s_tag) {
3451 reader.fail();
3452 return false;
3453 }
3454 return true;
3455}
3456
3458{
3459 if (reader.noMore()) {
3460 reader.fail();
3461 return false;
3462 }
3463 if (!reader.readString(map_name)) {
3464 reader.fail();
3465 return false;
3466 }
3467 if (!reader.noMore()) {
3468 reader.fail();
3469 return false;
3470 }
3471 return true;
3472}
3473
3475{
3476 yarp::os::idl::WireWriter writer(connection);
3477 return write(writer);
3478}
3479
3481{
3482 yarp::os::idl::WireReader reader(connection);
3483 return read(reader);
3484}
3485
3487{
3488 if (!writer.isNull()) {
3489 if (!writer.write(return_helper)) {
3490 return false;
3491 }
3492 }
3493 return true;
3494}
3495
3497{
3498 if (reader.noMore()) {
3499 reader.fail();
3500 return false;
3501 }
3502 if (!reader.read(return_helper)) {
3503 reader.fail();
3504 return false;
3505 }
3506 return true;
3507}
3508
3513
3514// store_object_RPC helper class implementation
3516 cmd{object_name, loc}
3517{
3518}
3519
3521{
3522 return cmd.write(connection);
3523}
3524
3526{
3527 return reply.read(connection);
3528}
3529
3531 object_name{object_name},
3532 loc{loc}
3533{
3534}
3535
3537{
3538 yarp::os::idl::WireWriter writer(connection);
3539 if (!writer.writeListHeader(s_cmd_len)) {
3540 return false;
3541 }
3542 return write(writer);
3543}
3544
3546{
3547 yarp::os::idl::WireReader reader(connection);
3548 if (!reader.readListHeader()) {
3549 reader.fail();
3550 return false;
3551 }
3552 return read(reader);
3553}
3554
3556{
3557 if (!writeTag(writer)) {
3558 return false;
3559 }
3560 if (!writeArgs(writer)) {
3561 return false;
3562 }
3563 return true;
3564}
3565
3567{
3568 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3569 return false;
3570 }
3571 return true;
3572}
3573
3575{
3576 if (!writer.writeString(object_name)) {
3577 return false;
3578 }
3579 if (!writer.writeNested(loc)) {
3580 return false;
3581 }
3582 return true;
3583}
3584
3586{
3587 if (!readTag(reader)) {
3588 return false;
3589 }
3590 if (!readArgs(reader)) {
3591 return false;
3592 }
3593 return true;
3594}
3595
3597{
3598 std::string tag = reader.readTag(s_tag_len);
3599 if (reader.isError()) {
3600 return false;
3601 }
3602 if (tag != s_tag) {
3603 reader.fail();
3604 return false;
3605 }
3606 return true;
3607}
3608
3610{
3611 if (reader.noMore()) {
3612 reader.fail();
3613 return false;
3614 }
3615 if (!reader.readString(object_name)) {
3616 reader.fail();
3617 return false;
3618 }
3619 if (reader.noMore()) {
3620 reader.fail();
3621 return false;
3622 }
3623 if (!reader.readNested(loc)) {
3624 reader.fail();
3625 return false;
3626 }
3627 if (!reader.noMore()) {
3628 reader.fail();
3629 return false;
3630 }
3631 return true;
3632}
3633
3635{
3636 yarp::os::idl::WireWriter writer(connection);
3637 return write(writer);
3638}
3639
3641{
3642 yarp::os::idl::WireReader reader(connection);
3643 return read(reader);
3644}
3645
3647{
3648 if (!writer.isNull()) {
3649 if (!writer.write(return_helper)) {
3650 return false;
3651 }
3652 }
3653 return true;
3654}
3655
3657{
3658 if (reader.noMore()) {
3659 reader.fail();
3660 return false;
3661 }
3662 if (!reader.read(return_helper)) {
3663 reader.fail();
3664 return false;
3665 }
3666 return true;
3667}
3668
3673
3674// store_location_RPC helper class implementation
3676 cmd{location_name, loc}
3677{
3678}
3679
3681{
3682 return cmd.write(connection);
3683}
3684
3686{
3687 return reply.read(connection);
3688}
3689
3691 location_name{location_name},
3692 loc{loc}
3693{
3694}
3695
3697{
3698 yarp::os::idl::WireWriter writer(connection);
3699 if (!writer.writeListHeader(s_cmd_len)) {
3700 return false;
3701 }
3702 return write(writer);
3703}
3704
3706{
3707 yarp::os::idl::WireReader reader(connection);
3708 if (!reader.readListHeader()) {
3709 reader.fail();
3710 return false;
3711 }
3712 return read(reader);
3713}
3714
3716{
3717 if (!writeTag(writer)) {
3718 return false;
3719 }
3720 if (!writeArgs(writer)) {
3721 return false;
3722 }
3723 return true;
3724}
3725
3727{
3728 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3729 return false;
3730 }
3731 return true;
3732}
3733
3735{
3736 if (!writer.writeString(location_name)) {
3737 return false;
3738 }
3739 if (!writer.writeNested(loc)) {
3740 return false;
3741 }
3742 return true;
3743}
3744
3746{
3747 if (!readTag(reader)) {
3748 return false;
3749 }
3750 if (!readArgs(reader)) {
3751 return false;
3752 }
3753 return true;
3754}
3755
3757{
3758 std::string tag = reader.readTag(s_tag_len);
3759 if (reader.isError()) {
3760 return false;
3761 }
3762 if (tag != s_tag) {
3763 reader.fail();
3764 return false;
3765 }
3766 return true;
3767}
3768
3770{
3771 if (reader.noMore()) {
3772 reader.fail();
3773 return false;
3774 }
3775 if (!reader.readString(location_name)) {
3776 reader.fail();
3777 return false;
3778 }
3779 if (reader.noMore()) {
3780 reader.fail();
3781 return false;
3782 }
3783 if (!reader.readNested(loc)) {
3784 reader.fail();
3785 return false;
3786 }
3787 if (!reader.noMore()) {
3788 reader.fail();
3789 return false;
3790 }
3791 return true;
3792}
3793
3795{
3796 yarp::os::idl::WireWriter writer(connection);
3797 return write(writer);
3798}
3799
3801{
3802 yarp::os::idl::WireReader reader(connection);
3803 return read(reader);
3804}
3805
3807{
3808 if (!writer.isNull()) {
3809 if (!writer.write(return_helper)) {
3810 return false;
3811 }
3812 }
3813 return true;
3814}
3815
3817{
3818 if (reader.noMore()) {
3819 reader.fail();
3820 return false;
3821 }
3822 if (!reader.read(return_helper)) {
3823 reader.fail();
3824 return false;
3825 }
3826 return true;
3827}
3828
3833
3834// store_area_RPC helper class implementation
3836 cmd{area_name, area}
3837{
3838}
3839
3841{
3842 return cmd.write(connection);
3843}
3844
3846{
3847 return reply.read(connection);
3848}
3849
3851 area_name{area_name},
3852 area{area}
3853{
3854}
3855
3857{
3858 yarp::os::idl::WireWriter writer(connection);
3859 if (!writer.writeListHeader(s_cmd_len)) {
3860 return false;
3861 }
3862 return write(writer);
3863}
3864
3866{
3867 yarp::os::idl::WireReader reader(connection);
3868 if (!reader.readListHeader()) {
3869 reader.fail();
3870 return false;
3871 }
3872 return read(reader);
3873}
3874
3876{
3877 if (!writeTag(writer)) {
3878 return false;
3879 }
3880 if (!writeArgs(writer)) {
3881 return false;
3882 }
3883 return true;
3884}
3885
3887{
3888 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
3889 return false;
3890 }
3891 return true;
3892}
3893
3895{
3896 if (!writer.writeString(area_name)) {
3897 return false;
3898 }
3899 if (!writer.writeNested(area)) {
3900 return false;
3901 }
3902 return true;
3903}
3904
3906{
3907 if (!readTag(reader)) {
3908 return false;
3909 }
3910 if (!readArgs(reader)) {
3911 return false;
3912 }
3913 return true;
3914}
3915
3917{
3918 std::string tag = reader.readTag(s_tag_len);
3919 if (reader.isError()) {
3920 return false;
3921 }
3922 if (tag != s_tag) {
3923 reader.fail();
3924 return false;
3925 }
3926 return true;
3927}
3928
3930{
3931 if (reader.noMore()) {
3932 reader.fail();
3933 return false;
3934 }
3935 if (!reader.readString(area_name)) {
3936 reader.fail();
3937 return false;
3938 }
3939 if (reader.noMore()) {
3940 reader.fail();
3941 return false;
3942 }
3943 if (!reader.readNested(area)) {
3944 reader.fail();
3945 return false;
3946 }
3947 if (!reader.noMore()) {
3948 reader.fail();
3949 return false;
3950 }
3951 return true;
3952}
3953
3955{
3956 yarp::os::idl::WireWriter writer(connection);
3957 return write(writer);
3958}
3959
3961{
3962 yarp::os::idl::WireReader reader(connection);
3963 return read(reader);
3964}
3965
3967{
3968 if (!writer.isNull()) {
3969 if (!writer.write(return_helper)) {
3970 return false;
3971 }
3972 }
3973 return true;
3974}
3975
3977{
3978 if (reader.noMore()) {
3979 reader.fail();
3980 return false;
3981 }
3982 if (!reader.read(return_helper)) {
3983 reader.fail();
3984 return false;
3985 }
3986 return true;
3987}
3988
3993
3994// store_path_RPC helper class implementation
3996 cmd{path_name, path}
3997{
3998}
3999
4001{
4002 return cmd.write(connection);
4003}
4004
4006{
4007 return reply.read(connection);
4008}
4009
4011 path_name{path_name},
4012 path{path}
4013{
4014}
4015
4017{
4018 yarp::os::idl::WireWriter writer(connection);
4019 if (!writer.writeListHeader(s_cmd_len)) {
4020 return false;
4021 }
4022 return write(writer);
4023}
4024
4026{
4027 yarp::os::idl::WireReader reader(connection);
4028 if (!reader.readListHeader()) {
4029 reader.fail();
4030 return false;
4031 }
4032 return read(reader);
4033}
4034
4036{
4037 if (!writeTag(writer)) {
4038 return false;
4039 }
4040 if (!writeArgs(writer)) {
4041 return false;
4042 }
4043 return true;
4044}
4045
4047{
4048 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4049 return false;
4050 }
4051 return true;
4052}
4053
4055{
4056 if (!writer.writeString(path_name)) {
4057 return false;
4058 }
4059 if (!writer.writeNested(path)) {
4060 return false;
4061 }
4062 return true;
4063}
4064
4066{
4067 if (!readTag(reader)) {
4068 return false;
4069 }
4070 if (!readArgs(reader)) {
4071 return false;
4072 }
4073 return true;
4074}
4075
4077{
4078 std::string tag = reader.readTag(s_tag_len);
4079 if (reader.isError()) {
4080 return false;
4081 }
4082 if (tag != s_tag) {
4083 reader.fail();
4084 return false;
4085 }
4086 return true;
4087}
4088
4090{
4091 if (reader.noMore()) {
4092 reader.fail();
4093 return false;
4094 }
4095 if (!reader.readString(path_name)) {
4096 reader.fail();
4097 return false;
4098 }
4099 if (reader.noMore()) {
4100 reader.fail();
4101 return false;
4102 }
4103 if (!reader.readNested(path)) {
4104 reader.fail();
4105 return false;
4106 }
4107 if (!reader.noMore()) {
4108 reader.fail();
4109 return false;
4110 }
4111 return true;
4112}
4113
4115{
4116 yarp::os::idl::WireWriter writer(connection);
4117 return write(writer);
4118}
4119
4121{
4122 yarp::os::idl::WireReader reader(connection);
4123 return read(reader);
4124}
4125
4127{
4128 if (!writer.isNull()) {
4129 if (!writer.write(return_helper)) {
4130 return false;
4131 }
4132 }
4133 return true;
4134}
4135
4137{
4138 if (reader.noMore()) {
4139 reader.fail();
4140 return false;
4141 }
4142 if (!reader.read(return_helper)) {
4143 reader.fail();
4144 return false;
4145 }
4146 return true;
4147}
4148
4153
4154// get_object_RPC helper class implementation
4156 cmd{object_name}
4157{
4158}
4159
4161{
4162 return cmd.write(connection);
4163}
4164
4166{
4167 return reply.read(connection);
4168}
4169
4171 object_name{object_name}
4172{
4173}
4174
4176{
4177 yarp::os::idl::WireWriter writer(connection);
4178 if (!writer.writeListHeader(s_cmd_len)) {
4179 return false;
4180 }
4181 return write(writer);
4182}
4183
4185{
4186 yarp::os::idl::WireReader reader(connection);
4187 if (!reader.readListHeader()) {
4188 reader.fail();
4189 return false;
4190 }
4191 return read(reader);
4192}
4193
4195{
4196 if (!writeTag(writer)) {
4197 return false;
4198 }
4199 if (!writeArgs(writer)) {
4200 return false;
4201 }
4202 return true;
4203}
4204
4206{
4207 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4208 return false;
4209 }
4210 return true;
4211}
4212
4214{
4215 if (!writer.writeString(object_name)) {
4216 return false;
4217 }
4218 return true;
4219}
4220
4222{
4223 if (!readTag(reader)) {
4224 return false;
4225 }
4226 if (!readArgs(reader)) {
4227 return false;
4228 }
4229 return true;
4230}
4231
4233{
4234 std::string tag = reader.readTag(s_tag_len);
4235 if (reader.isError()) {
4236 return false;
4237 }
4238 if (tag != s_tag) {
4239 reader.fail();
4240 return false;
4241 }
4242 return true;
4243}
4244
4246{
4247 if (reader.noMore()) {
4248 reader.fail();
4249 return false;
4250 }
4251 if (!reader.readString(object_name)) {
4252 reader.fail();
4253 return false;
4254 }
4255 if (!reader.noMore()) {
4256 reader.fail();
4257 return false;
4258 }
4259 return true;
4260}
4261
4263{
4264 yarp::os::idl::WireWriter writer(connection);
4265 return write(writer);
4266}
4267
4269{
4270 yarp::os::idl::WireReader reader(connection);
4271 return read(reader);
4272}
4273
4275{
4276 if (!writer.isNull()) {
4277 if (!writer.writeListHeader(s_reply_len)) {
4278 return false;
4279 }
4280 if (!writer.write(return_helper)) {
4281 return false;
4282 }
4283 }
4284 return true;
4285}
4286
4288{
4289 if (!reader.readListReturn()) {
4290 return false;
4291 }
4292 if (reader.noMore()) {
4293 reader.fail();
4294 return false;
4295 }
4296 if (!reader.read(return_helper)) {
4297 reader.fail();
4298 return false;
4299 }
4300 return true;
4301}
4302
4307
4308// get_location_RPC helper class implementation
4310 cmd{location_name}
4311{
4312}
4313
4315{
4316 return cmd.write(connection);
4317}
4318
4320{
4321 return reply.read(connection);
4322}
4323
4325 location_name{location_name}
4326{
4327}
4328
4330{
4331 yarp::os::idl::WireWriter writer(connection);
4332 if (!writer.writeListHeader(s_cmd_len)) {
4333 return false;
4334 }
4335 return write(writer);
4336}
4337
4339{
4340 yarp::os::idl::WireReader reader(connection);
4341 if (!reader.readListHeader()) {
4342 reader.fail();
4343 return false;
4344 }
4345 return read(reader);
4346}
4347
4349{
4350 if (!writeTag(writer)) {
4351 return false;
4352 }
4353 if (!writeArgs(writer)) {
4354 return false;
4355 }
4356 return true;
4357}
4358
4360{
4361 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4362 return false;
4363 }
4364 return true;
4365}
4366
4368{
4369 if (!writer.writeString(location_name)) {
4370 return false;
4371 }
4372 return true;
4373}
4374
4376{
4377 if (!readTag(reader)) {
4378 return false;
4379 }
4380 if (!readArgs(reader)) {
4381 return false;
4382 }
4383 return true;
4384}
4385
4387{
4388 std::string tag = reader.readTag(s_tag_len);
4389 if (reader.isError()) {
4390 return false;
4391 }
4392 if (tag != s_tag) {
4393 reader.fail();
4394 return false;
4395 }
4396 return true;
4397}
4398
4400{
4401 if (reader.noMore()) {
4402 reader.fail();
4403 return false;
4404 }
4405 if (!reader.readString(location_name)) {
4406 reader.fail();
4407 return false;
4408 }
4409 if (!reader.noMore()) {
4410 reader.fail();
4411 return false;
4412 }
4413 return true;
4414}
4415
4417{
4418 yarp::os::idl::WireWriter writer(connection);
4419 return write(writer);
4420}
4421
4423{
4424 yarp::os::idl::WireReader reader(connection);
4425 return read(reader);
4426}
4427
4429{
4430 if (!writer.isNull()) {
4431 if (!writer.writeListHeader(s_reply_len)) {
4432 return false;
4433 }
4434 if (!writer.write(return_helper)) {
4435 return false;
4436 }
4437 }
4438 return true;
4439}
4440
4442{
4443 if (!reader.readListReturn()) {
4444 return false;
4445 }
4446 if (reader.noMore()) {
4447 reader.fail();
4448 return false;
4449 }
4450 if (!reader.read(return_helper)) {
4451 reader.fail();
4452 return false;
4453 }
4454 return true;
4455}
4456
4461
4462// get_area_RPC helper class implementation
4464 cmd{area_name}
4465{
4466}
4467
4469{
4470 return cmd.write(connection);
4471}
4472
4474{
4475 return reply.read(connection);
4476}
4477
4479 area_name{area_name}
4480{
4481}
4482
4484{
4485 yarp::os::idl::WireWriter writer(connection);
4486 if (!writer.writeListHeader(s_cmd_len)) {
4487 return false;
4488 }
4489 return write(writer);
4490}
4491
4493{
4494 yarp::os::idl::WireReader reader(connection);
4495 if (!reader.readListHeader()) {
4496 reader.fail();
4497 return false;
4498 }
4499 return read(reader);
4500}
4501
4503{
4504 if (!writeTag(writer)) {
4505 return false;
4506 }
4507 if (!writeArgs(writer)) {
4508 return false;
4509 }
4510 return true;
4511}
4512
4514{
4515 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4516 return false;
4517 }
4518 return true;
4519}
4520
4522{
4523 if (!writer.writeString(area_name)) {
4524 return false;
4525 }
4526 return true;
4527}
4528
4530{
4531 if (!readTag(reader)) {
4532 return false;
4533 }
4534 if (!readArgs(reader)) {
4535 return false;
4536 }
4537 return true;
4538}
4539
4541{
4542 std::string tag = reader.readTag(s_tag_len);
4543 if (reader.isError()) {
4544 return false;
4545 }
4546 if (tag != s_tag) {
4547 reader.fail();
4548 return false;
4549 }
4550 return true;
4551}
4552
4554{
4555 if (reader.noMore()) {
4556 reader.fail();
4557 return false;
4558 }
4559 if (!reader.readString(area_name)) {
4560 reader.fail();
4561 return false;
4562 }
4563 if (!reader.noMore()) {
4564 reader.fail();
4565 return false;
4566 }
4567 return true;
4568}
4569
4571{
4572 yarp::os::idl::WireWriter writer(connection);
4573 return write(writer);
4574}
4575
4577{
4578 yarp::os::idl::WireReader reader(connection);
4579 return read(reader);
4580}
4581
4583{
4584 if (!writer.isNull()) {
4585 if (!writer.writeListHeader(s_reply_len)) {
4586 return false;
4587 }
4588 if (!writer.write(return_helper)) {
4589 return false;
4590 }
4591 }
4592 return true;
4593}
4594
4596{
4597 if (!reader.readListReturn()) {
4598 return false;
4599 }
4600 if (reader.noMore()) {
4601 reader.fail();
4602 return false;
4603 }
4604 if (!reader.read(return_helper)) {
4605 reader.fail();
4606 return false;
4607 }
4608 return true;
4609}
4610
4615
4616// get_path_RPC helper class implementation
4618 cmd{path_name}
4619{
4620}
4621
4623{
4624 return cmd.write(connection);
4625}
4626
4628{
4629 return reply.read(connection);
4630}
4631
4633 path_name{path_name}
4634{
4635}
4636
4638{
4639 yarp::os::idl::WireWriter writer(connection);
4640 if (!writer.writeListHeader(s_cmd_len)) {
4641 return false;
4642 }
4643 return write(writer);
4644}
4645
4647{
4648 yarp::os::idl::WireReader reader(connection);
4649 if (!reader.readListHeader()) {
4650 reader.fail();
4651 return false;
4652 }
4653 return read(reader);
4654}
4655
4657{
4658 if (!writeTag(writer)) {
4659 return false;
4660 }
4661 if (!writeArgs(writer)) {
4662 return false;
4663 }
4664 return true;
4665}
4666
4668{
4669 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4670 return false;
4671 }
4672 return true;
4673}
4674
4676{
4677 if (!writer.writeString(path_name)) {
4678 return false;
4679 }
4680 return true;
4681}
4682
4684{
4685 if (!readTag(reader)) {
4686 return false;
4687 }
4688 if (!readArgs(reader)) {
4689 return false;
4690 }
4691 return true;
4692}
4693
4695{
4696 std::string tag = reader.readTag(s_tag_len);
4697 if (reader.isError()) {
4698 return false;
4699 }
4700 if (tag != s_tag) {
4701 reader.fail();
4702 return false;
4703 }
4704 return true;
4705}
4706
4708{
4709 if (reader.noMore()) {
4710 reader.fail();
4711 return false;
4712 }
4713 if (!reader.readString(path_name)) {
4714 reader.fail();
4715 return false;
4716 }
4717 if (!reader.noMore()) {
4718 reader.fail();
4719 return false;
4720 }
4721 return true;
4722}
4723
4725{
4726 yarp::os::idl::WireWriter writer(connection);
4727 return write(writer);
4728}
4729
4731{
4732 yarp::os::idl::WireReader reader(connection);
4733 return read(reader);
4734}
4735
4737{
4738 if (!writer.isNull()) {
4739 if (!writer.writeListHeader(s_reply_len)) {
4740 return false;
4741 }
4742 if (!writer.write(return_helper)) {
4743 return false;
4744 }
4745 }
4746 return true;
4747}
4748
4750{
4751 if (!reader.readListReturn()) {
4752 return false;
4753 }
4754 if (reader.noMore()) {
4755 reader.fail();
4756 return false;
4757 }
4758 if (!reader.read(return_helper)) {
4759 reader.fail();
4760 return false;
4761 }
4762 return true;
4763}
4764
4769
4770// get_objects_list_RPC helper class implementation
4772{
4773 return cmd.write(connection);
4774}
4775
4777{
4778 return reply.read(connection);
4779}
4780
4782{
4783 yarp::os::idl::WireWriter writer(connection);
4784 if (!writer.writeListHeader(s_cmd_len)) {
4785 return false;
4786 }
4787 return write(writer);
4788}
4789
4791{
4792 yarp::os::idl::WireReader reader(connection);
4793 if (!reader.readListHeader()) {
4794 reader.fail();
4795 return false;
4796 }
4797 return read(reader);
4798}
4799
4801{
4802 if (!writeTag(writer)) {
4803 return false;
4804 }
4805 if (!writeArgs(writer)) {
4806 return false;
4807 }
4808 return true;
4809}
4810
4812{
4813 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4814 return false;
4815 }
4816 return true;
4817}
4818
4820{
4821 return true;
4822}
4823
4825{
4826 if (!readTag(reader)) {
4827 return false;
4828 }
4829 if (!readArgs(reader)) {
4830 return false;
4831 }
4832 return true;
4833}
4834
4836{
4837 std::string tag = reader.readTag(s_tag_len);
4838 if (reader.isError()) {
4839 return false;
4840 }
4841 if (tag != s_tag) {
4842 reader.fail();
4843 return false;
4844 }
4845 return true;
4846}
4847
4849{
4850 if (!reader.noMore()) {
4851 reader.fail();
4852 return false;
4853 }
4854 return true;
4855}
4856
4858{
4859 yarp::os::idl::WireWriter writer(connection);
4860 return write(writer);
4861}
4862
4864{
4865 yarp::os::idl::WireReader reader(connection);
4866 return read(reader);
4867}
4868
4870{
4871 if (!writer.isNull()) {
4872 if (!writer.writeListHeader(s_reply_len)) {
4873 return false;
4874 }
4875 if (!writer.write(return_helper)) {
4876 return false;
4877 }
4878 }
4879 return true;
4880}
4881
4883{
4884 if (!reader.readListReturn()) {
4885 return false;
4886 }
4887 if (reader.noMore()) {
4888 reader.fail();
4889 return false;
4890 }
4891 if (!reader.read(return_helper)) {
4892 reader.fail();
4893 return false;
4894 }
4895 return true;
4896}
4897
4902
4903// get_locations_list_RPC helper class implementation
4905{
4906 return cmd.write(connection);
4907}
4908
4910{
4911 return reply.read(connection);
4912}
4913
4915{
4916 yarp::os::idl::WireWriter writer(connection);
4917 if (!writer.writeListHeader(s_cmd_len)) {
4918 return false;
4919 }
4920 return write(writer);
4921}
4922
4924{
4925 yarp::os::idl::WireReader reader(connection);
4926 if (!reader.readListHeader()) {
4927 reader.fail();
4928 return false;
4929 }
4930 return read(reader);
4931}
4932
4934{
4935 if (!writeTag(writer)) {
4936 return false;
4937 }
4938 if (!writeArgs(writer)) {
4939 return false;
4940 }
4941 return true;
4942}
4943
4945{
4946 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
4947 return false;
4948 }
4949 return true;
4950}
4951
4953{
4954 return true;
4955}
4956
4958{
4959 if (!readTag(reader)) {
4960 return false;
4961 }
4962 if (!readArgs(reader)) {
4963 return false;
4964 }
4965 return true;
4966}
4967
4969{
4970 std::string tag = reader.readTag(s_tag_len);
4971 if (reader.isError()) {
4972 return false;
4973 }
4974 if (tag != s_tag) {
4975 reader.fail();
4976 return false;
4977 }
4978 return true;
4979}
4980
4982{
4983 if (!reader.noMore()) {
4984 reader.fail();
4985 return false;
4986 }
4987 return true;
4988}
4989
4991{
4992 yarp::os::idl::WireWriter writer(connection);
4993 return write(writer);
4994}
4995
4997{
4998 yarp::os::idl::WireReader reader(connection);
4999 return read(reader);
5000}
5001
5003{
5004 if (!writer.isNull()) {
5005 if (!writer.writeListHeader(s_reply_len)) {
5006 return false;
5007 }
5008 if (!writer.write(return_helper)) {
5009 return false;
5010 }
5011 }
5012 return true;
5013}
5014
5016{
5017 if (!reader.readListReturn()) {
5018 return false;
5019 }
5020 if (reader.noMore()) {
5021 reader.fail();
5022 return false;
5023 }
5024 if (!reader.read(return_helper)) {
5025 reader.fail();
5026 return false;
5027 }
5028 return true;
5029}
5030
5035
5036// get_areas_list_RPC helper class implementation
5038{
5039 return cmd.write(connection);
5040}
5041
5043{
5044 return reply.read(connection);
5045}
5046
5048{
5049 yarp::os::idl::WireWriter writer(connection);
5050 if (!writer.writeListHeader(s_cmd_len)) {
5051 return false;
5052 }
5053 return write(writer);
5054}
5055
5057{
5058 yarp::os::idl::WireReader reader(connection);
5059 if (!reader.readListHeader()) {
5060 reader.fail();
5061 return false;
5062 }
5063 return read(reader);
5064}
5065
5067{
5068 if (!writeTag(writer)) {
5069 return false;
5070 }
5071 if (!writeArgs(writer)) {
5072 return false;
5073 }
5074 return true;
5075}
5076
5078{
5079 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5080 return false;
5081 }
5082 return true;
5083}
5084
5086{
5087 return true;
5088}
5089
5091{
5092 if (!readTag(reader)) {
5093 return false;
5094 }
5095 if (!readArgs(reader)) {
5096 return false;
5097 }
5098 return true;
5099}
5100
5102{
5103 std::string tag = reader.readTag(s_tag_len);
5104 if (reader.isError()) {
5105 return false;
5106 }
5107 if (tag != s_tag) {
5108 reader.fail();
5109 return false;
5110 }
5111 return true;
5112}
5113
5115{
5116 if (!reader.noMore()) {
5117 reader.fail();
5118 return false;
5119 }
5120 return true;
5121}
5122
5124{
5125 yarp::os::idl::WireWriter writer(connection);
5126 return write(writer);
5127}
5128
5130{
5131 yarp::os::idl::WireReader reader(connection);
5132 return read(reader);
5133}
5134
5136{
5137 if (!writer.isNull()) {
5138 if (!writer.writeListHeader(s_reply_len)) {
5139 return false;
5140 }
5141 if (!writer.write(return_helper)) {
5142 return false;
5143 }
5144 }
5145 return true;
5146}
5147
5149{
5150 if (!reader.readListReturn()) {
5151 return false;
5152 }
5153 if (reader.noMore()) {
5154 reader.fail();
5155 return false;
5156 }
5157 if (!reader.read(return_helper)) {
5158 reader.fail();
5159 return false;
5160 }
5161 return true;
5162}
5163
5168
5169// get_paths_list_RPC helper class implementation
5171{
5172 return cmd.write(connection);
5173}
5174
5176{
5177 return reply.read(connection);
5178}
5179
5181{
5182 yarp::os::idl::WireWriter writer(connection);
5183 if (!writer.writeListHeader(s_cmd_len)) {
5184 return false;
5185 }
5186 return write(writer);
5187}
5188
5190{
5191 yarp::os::idl::WireReader reader(connection);
5192 if (!reader.readListHeader()) {
5193 reader.fail();
5194 return false;
5195 }
5196 return read(reader);
5197}
5198
5200{
5201 if (!writeTag(writer)) {
5202 return false;
5203 }
5204 if (!writeArgs(writer)) {
5205 return false;
5206 }
5207 return true;
5208}
5209
5211{
5212 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5213 return false;
5214 }
5215 return true;
5216}
5217
5219{
5220 return true;
5221}
5222
5224{
5225 if (!readTag(reader)) {
5226 return false;
5227 }
5228 if (!readArgs(reader)) {
5229 return false;
5230 }
5231 return true;
5232}
5233
5235{
5236 std::string tag = reader.readTag(s_tag_len);
5237 if (reader.isError()) {
5238 return false;
5239 }
5240 if (tag != s_tag) {
5241 reader.fail();
5242 return false;
5243 }
5244 return true;
5245}
5246
5248{
5249 if (!reader.noMore()) {
5250 reader.fail();
5251 return false;
5252 }
5253 return true;
5254}
5255
5257{
5258 yarp::os::idl::WireWriter writer(connection);
5259 return write(writer);
5260}
5261
5263{
5264 yarp::os::idl::WireReader reader(connection);
5265 return read(reader);
5266}
5267
5269{
5270 if (!writer.isNull()) {
5271 if (!writer.writeListHeader(s_reply_len)) {
5272 return false;
5273 }
5274 if (!writer.write(return_helper)) {
5275 return false;
5276 }
5277 }
5278 return true;
5279}
5280
5282{
5283 if (!reader.readListReturn()) {
5284 return false;
5285 }
5286 if (reader.noMore()) {
5287 reader.fail();
5288 return false;
5289 }
5290 if (!reader.read(return_helper)) {
5291 reader.fail();
5292 return false;
5293 }
5294 return true;
5295}
5296
5301
5302// get_all_objects_RPC helper class implementation
5304{
5305 return cmd.write(connection);
5306}
5307
5309{
5310 return reply.read(connection);
5311}
5312
5314{
5315 yarp::os::idl::WireWriter writer(connection);
5316 if (!writer.writeListHeader(s_cmd_len)) {
5317 return false;
5318 }
5319 return write(writer);
5320}
5321
5323{
5324 yarp::os::idl::WireReader reader(connection);
5325 if (!reader.readListHeader()) {
5326 reader.fail();
5327 return false;
5328 }
5329 return read(reader);
5330}
5331
5333{
5334 if (!writeTag(writer)) {
5335 return false;
5336 }
5337 if (!writeArgs(writer)) {
5338 return false;
5339 }
5340 return true;
5341}
5342
5344{
5345 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5346 return false;
5347 }
5348 return true;
5349}
5350
5352{
5353 return true;
5354}
5355
5357{
5358 if (!readTag(reader)) {
5359 return false;
5360 }
5361 if (!readArgs(reader)) {
5362 return false;
5363 }
5364 return true;
5365}
5366
5368{
5369 std::string tag = reader.readTag(s_tag_len);
5370 if (reader.isError()) {
5371 return false;
5372 }
5373 if (tag != s_tag) {
5374 reader.fail();
5375 return false;
5376 }
5377 return true;
5378}
5379
5381{
5382 if (!reader.noMore()) {
5383 reader.fail();
5384 return false;
5385 }
5386 return true;
5387}
5388
5390{
5391 yarp::os::idl::WireWriter writer(connection);
5392 return write(writer);
5393}
5394
5396{
5397 yarp::os::idl::WireReader reader(connection);
5398 return read(reader);
5399}
5400
5402{
5403 if (!writer.isNull()) {
5404 if (!writer.writeListHeader(s_reply_len)) {
5405 return false;
5406 }
5407 if (!writer.write(return_helper)) {
5408 return false;
5409 }
5410 }
5411 return true;
5412}
5413
5415{
5416 if (!reader.readListReturn()) {
5417 return false;
5418 }
5419 if (reader.noMore()) {
5420 reader.fail();
5421 return false;
5422 }
5423 if (!reader.read(return_helper)) {
5424 reader.fail();
5425 return false;
5426 }
5427 return true;
5428}
5429
5434
5435// get_all_locations_RPC helper class implementation
5437{
5438 return cmd.write(connection);
5439}
5440
5442{
5443 return reply.read(connection);
5444}
5445
5447{
5448 yarp::os::idl::WireWriter writer(connection);
5449 if (!writer.writeListHeader(s_cmd_len)) {
5450 return false;
5451 }
5452 return write(writer);
5453}
5454
5456{
5457 yarp::os::idl::WireReader reader(connection);
5458 if (!reader.readListHeader()) {
5459 reader.fail();
5460 return false;
5461 }
5462 return read(reader);
5463}
5464
5466{
5467 if (!writeTag(writer)) {
5468 return false;
5469 }
5470 if (!writeArgs(writer)) {
5471 return false;
5472 }
5473 return true;
5474}
5475
5477{
5478 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5479 return false;
5480 }
5481 return true;
5482}
5483
5485{
5486 return true;
5487}
5488
5490{
5491 if (!readTag(reader)) {
5492 return false;
5493 }
5494 if (!readArgs(reader)) {
5495 return false;
5496 }
5497 return true;
5498}
5499
5501{
5502 std::string tag = reader.readTag(s_tag_len);
5503 if (reader.isError()) {
5504 return false;
5505 }
5506 if (tag != s_tag) {
5507 reader.fail();
5508 return false;
5509 }
5510 return true;
5511}
5512
5514{
5515 if (!reader.noMore()) {
5516 reader.fail();
5517 return false;
5518 }
5519 return true;
5520}
5521
5523{
5524 yarp::os::idl::WireWriter writer(connection);
5525 return write(writer);
5526}
5527
5529{
5530 yarp::os::idl::WireReader reader(connection);
5531 return read(reader);
5532}
5533
5535{
5536 if (!writer.isNull()) {
5537 if (!writer.writeListHeader(s_reply_len)) {
5538 return false;
5539 }
5540 if (!writer.write(return_helper)) {
5541 return false;
5542 }
5543 }
5544 return true;
5545}
5546
5548{
5549 if (!reader.readListReturn()) {
5550 return false;
5551 }
5552 if (reader.noMore()) {
5553 reader.fail();
5554 return false;
5555 }
5556 if (!reader.read(return_helper)) {
5557 reader.fail();
5558 return false;
5559 }
5560 return true;
5561}
5562
5567
5568// get_all_areas_RPC helper class implementation
5570{
5571 return cmd.write(connection);
5572}
5573
5575{
5576 return reply.read(connection);
5577}
5578
5580{
5581 yarp::os::idl::WireWriter writer(connection);
5582 if (!writer.writeListHeader(s_cmd_len)) {
5583 return false;
5584 }
5585 return write(writer);
5586}
5587
5589{
5590 yarp::os::idl::WireReader reader(connection);
5591 if (!reader.readListHeader()) {
5592 reader.fail();
5593 return false;
5594 }
5595 return read(reader);
5596}
5597
5599{
5600 if (!writeTag(writer)) {
5601 return false;
5602 }
5603 if (!writeArgs(writer)) {
5604 return false;
5605 }
5606 return true;
5607}
5608
5610{
5611 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5612 return false;
5613 }
5614 return true;
5615}
5616
5618{
5619 return true;
5620}
5621
5623{
5624 if (!readTag(reader)) {
5625 return false;
5626 }
5627 if (!readArgs(reader)) {
5628 return false;
5629 }
5630 return true;
5631}
5632
5634{
5635 std::string tag = reader.readTag(s_tag_len);
5636 if (reader.isError()) {
5637 return false;
5638 }
5639 if (tag != s_tag) {
5640 reader.fail();
5641 return false;
5642 }
5643 return true;
5644}
5645
5647{
5648 if (!reader.noMore()) {
5649 reader.fail();
5650 return false;
5651 }
5652 return true;
5653}
5654
5656{
5657 yarp::os::idl::WireWriter writer(connection);
5658 return write(writer);
5659}
5660
5662{
5663 yarp::os::idl::WireReader reader(connection);
5664 return read(reader);
5665}
5666
5668{
5669 if (!writer.isNull()) {
5670 if (!writer.writeListHeader(s_reply_len)) {
5671 return false;
5672 }
5673 if (!writer.write(return_helper)) {
5674 return false;
5675 }
5676 }
5677 return true;
5678}
5679
5681{
5682 if (!reader.readListReturn()) {
5683 return false;
5684 }
5685 if (reader.noMore()) {
5686 reader.fail();
5687 return false;
5688 }
5689 if (!reader.read(return_helper)) {
5690 reader.fail();
5691 return false;
5692 }
5693 return true;
5694}
5695
5700
5701// get_all_paths_RPC helper class implementation
5703{
5704 return cmd.write(connection);
5705}
5706
5708{
5709 return reply.read(connection);
5710}
5711
5713{
5714 yarp::os::idl::WireWriter writer(connection);
5715 if (!writer.writeListHeader(s_cmd_len)) {
5716 return false;
5717 }
5718 return write(writer);
5719}
5720
5722{
5723 yarp::os::idl::WireReader reader(connection);
5724 if (!reader.readListHeader()) {
5725 reader.fail();
5726 return false;
5727 }
5728 return read(reader);
5729}
5730
5732{
5733 if (!writeTag(writer)) {
5734 return false;
5735 }
5736 if (!writeArgs(writer)) {
5737 return false;
5738 }
5739 return true;
5740}
5741
5743{
5744 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5745 return false;
5746 }
5747 return true;
5748}
5749
5751{
5752 return true;
5753}
5754
5756{
5757 if (!readTag(reader)) {
5758 return false;
5759 }
5760 if (!readArgs(reader)) {
5761 return false;
5762 }
5763 return true;
5764}
5765
5767{
5768 std::string tag = reader.readTag(s_tag_len);
5769 if (reader.isError()) {
5770 return false;
5771 }
5772 if (tag != s_tag) {
5773 reader.fail();
5774 return false;
5775 }
5776 return true;
5777}
5778
5780{
5781 if (!reader.noMore()) {
5782 reader.fail();
5783 return false;
5784 }
5785 return true;
5786}
5787
5789{
5790 yarp::os::idl::WireWriter writer(connection);
5791 return write(writer);
5792}
5793
5795{
5796 yarp::os::idl::WireReader reader(connection);
5797 return read(reader);
5798}
5799
5801{
5802 if (!writer.isNull()) {
5803 if (!writer.writeListHeader(s_reply_len)) {
5804 return false;
5805 }
5806 if (!writer.write(return_helper)) {
5807 return false;
5808 }
5809 }
5810 return true;
5811}
5812
5814{
5815 if (!reader.readListReturn()) {
5816 return false;
5817 }
5818 if (reader.noMore()) {
5819 reader.fail();
5820 return false;
5821 }
5822 if (!reader.read(return_helper)) {
5823 reader.fail();
5824 return false;
5825 }
5826 return true;
5827}
5828
5833
5834// rename_location_RPC helper class implementation
5835IMap2DMsgs_rename_location_RPC_helper::IMap2DMsgs_rename_location_RPC_helper(const std::string& original_name, const std::string& new_name) :
5836 cmd{original_name, new_name}
5837{
5838}
5839
5841{
5842 return cmd.write(connection);
5843}
5844
5846{
5847 return reply.read(connection);
5848}
5849
5850IMap2DMsgs_rename_location_RPC_helper::Command::Command(const std::string& original_name, const std::string& new_name) :
5851 original_name{original_name},
5852 new_name{new_name}
5853{
5854}
5855
5857{
5858 yarp::os::idl::WireWriter writer(connection);
5859 if (!writer.writeListHeader(s_cmd_len)) {
5860 return false;
5861 }
5862 return write(writer);
5863}
5864
5866{
5867 yarp::os::idl::WireReader reader(connection);
5868 if (!reader.readListHeader()) {
5869 reader.fail();
5870 return false;
5871 }
5872 return read(reader);
5873}
5874
5876{
5877 if (!writeTag(writer)) {
5878 return false;
5879 }
5880 if (!writeArgs(writer)) {
5881 return false;
5882 }
5883 return true;
5884}
5885
5887{
5888 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
5889 return false;
5890 }
5891 return true;
5892}
5893
5895{
5896 if (!writer.writeString(original_name)) {
5897 return false;
5898 }
5899 if (!writer.writeString(new_name)) {
5900 return false;
5901 }
5902 return true;
5903}
5904
5906{
5907 if (!readTag(reader)) {
5908 return false;
5909 }
5910 if (!readArgs(reader)) {
5911 return false;
5912 }
5913 return true;
5914}
5915
5917{
5918 std::string tag = reader.readTag(s_tag_len);
5919 if (reader.isError()) {
5920 return false;
5921 }
5922 if (tag != s_tag) {
5923 reader.fail();
5924 return false;
5925 }
5926 return true;
5927}
5928
5930{
5931 if (reader.noMore()) {
5932 reader.fail();
5933 return false;
5934 }
5935 if (!reader.readString(original_name)) {
5936 reader.fail();
5937 return false;
5938 }
5939 if (reader.noMore()) {
5940 reader.fail();
5941 return false;
5942 }
5943 if (!reader.readString(new_name)) {
5944 reader.fail();
5945 return false;
5946 }
5947 if (!reader.noMore()) {
5948 reader.fail();
5949 return false;
5950 }
5951 return true;
5952}
5953
5955{
5956 yarp::os::idl::WireWriter writer(connection);
5957 return write(writer);
5958}
5959
5961{
5962 yarp::os::idl::WireReader reader(connection);
5963 return read(reader);
5964}
5965
5967{
5968 if (!writer.isNull()) {
5969 if (!writer.write(return_helper)) {
5970 return false;
5971 }
5972 }
5973 return true;
5974}
5975
5977{
5978 if (reader.noMore()) {
5979 reader.fail();
5980 return false;
5981 }
5982 if (!reader.read(return_helper)) {
5983 reader.fail();
5984 return false;
5985 }
5986 return true;
5987}
5988
5993
5994// delete_object_RPC helper class implementation
5996 cmd{object_name}
5997{
5998}
5999
6001{
6002 return cmd.write(connection);
6003}
6004
6006{
6007 return reply.read(connection);
6008}
6009
6011 object_name{object_name}
6012{
6013}
6014
6016{
6017 yarp::os::idl::WireWriter writer(connection);
6018 if (!writer.writeListHeader(s_cmd_len)) {
6019 return false;
6020 }
6021 return write(writer);
6022}
6023
6025{
6026 yarp::os::idl::WireReader reader(connection);
6027 if (!reader.readListHeader()) {
6028 reader.fail();
6029 return false;
6030 }
6031 return read(reader);
6032}
6033
6035{
6036 if (!writeTag(writer)) {
6037 return false;
6038 }
6039 if (!writeArgs(writer)) {
6040 return false;
6041 }
6042 return true;
6043}
6044
6046{
6047 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6048 return false;
6049 }
6050 return true;
6051}
6052
6054{
6055 if (!writer.writeString(object_name)) {
6056 return false;
6057 }
6058 return true;
6059}
6060
6062{
6063 if (!readTag(reader)) {
6064 return false;
6065 }
6066 if (!readArgs(reader)) {
6067 return false;
6068 }
6069 return true;
6070}
6071
6073{
6074 std::string tag = reader.readTag(s_tag_len);
6075 if (reader.isError()) {
6076 return false;
6077 }
6078 if (tag != s_tag) {
6079 reader.fail();
6080 return false;
6081 }
6082 return true;
6083}
6084
6086{
6087 if (reader.noMore()) {
6088 reader.fail();
6089 return false;
6090 }
6091 if (!reader.readString(object_name)) {
6092 reader.fail();
6093 return false;
6094 }
6095 if (!reader.noMore()) {
6096 reader.fail();
6097 return false;
6098 }
6099 return true;
6100}
6101
6103{
6104 yarp::os::idl::WireWriter writer(connection);
6105 return write(writer);
6106}
6107
6109{
6110 yarp::os::idl::WireReader reader(connection);
6111 return read(reader);
6112}
6113
6115{
6116 if (!writer.isNull()) {
6117 if (!writer.write(return_helper)) {
6118 return false;
6119 }
6120 }
6121 return true;
6122}
6123
6125{
6126 if (reader.noMore()) {
6127 reader.fail();
6128 return false;
6129 }
6130 if (!reader.read(return_helper)) {
6131 reader.fail();
6132 return false;
6133 }
6134 return true;
6135}
6136
6141
6142// delete_location_RPC helper class implementation
6144 cmd{location_name}
6145{
6146}
6147
6149{
6150 return cmd.write(connection);
6151}
6152
6154{
6155 return reply.read(connection);
6156}
6157
6159 location_name{location_name}
6160{
6161}
6162
6164{
6165 yarp::os::idl::WireWriter writer(connection);
6166 if (!writer.writeListHeader(s_cmd_len)) {
6167 return false;
6168 }
6169 return write(writer);
6170}
6171
6173{
6174 yarp::os::idl::WireReader reader(connection);
6175 if (!reader.readListHeader()) {
6176 reader.fail();
6177 return false;
6178 }
6179 return read(reader);
6180}
6181
6183{
6184 if (!writeTag(writer)) {
6185 return false;
6186 }
6187 if (!writeArgs(writer)) {
6188 return false;
6189 }
6190 return true;
6191}
6192
6194{
6195 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6196 return false;
6197 }
6198 return true;
6199}
6200
6202{
6203 if (!writer.writeString(location_name)) {
6204 return false;
6205 }
6206 return true;
6207}
6208
6210{
6211 if (!readTag(reader)) {
6212 return false;
6213 }
6214 if (!readArgs(reader)) {
6215 return false;
6216 }
6217 return true;
6218}
6219
6221{
6222 std::string tag = reader.readTag(s_tag_len);
6223 if (reader.isError()) {
6224 return false;
6225 }
6226 if (tag != s_tag) {
6227 reader.fail();
6228 return false;
6229 }
6230 return true;
6231}
6232
6234{
6235 if (reader.noMore()) {
6236 reader.fail();
6237 return false;
6238 }
6239 if (!reader.readString(location_name)) {
6240 reader.fail();
6241 return false;
6242 }
6243 if (!reader.noMore()) {
6244 reader.fail();
6245 return false;
6246 }
6247 return true;
6248}
6249
6251{
6252 yarp::os::idl::WireWriter writer(connection);
6253 return write(writer);
6254}
6255
6257{
6258 yarp::os::idl::WireReader reader(connection);
6259 return read(reader);
6260}
6261
6263{
6264 if (!writer.isNull()) {
6265 if (!writer.write(return_helper)) {
6266 return false;
6267 }
6268 }
6269 return true;
6270}
6271
6273{
6274 if (reader.noMore()) {
6275 reader.fail();
6276 return false;
6277 }
6278 if (!reader.read(return_helper)) {
6279 reader.fail();
6280 return false;
6281 }
6282 return true;
6283}
6284
6289
6290// delete_path_RPC helper class implementation
6292 cmd{path_name}
6293{
6294}
6295
6297{
6298 return cmd.write(connection);
6299}
6300
6302{
6303 return reply.read(connection);
6304}
6305
6307 path_name{path_name}
6308{
6309}
6310
6312{
6313 yarp::os::idl::WireWriter writer(connection);
6314 if (!writer.writeListHeader(s_cmd_len)) {
6315 return false;
6316 }
6317 return write(writer);
6318}
6319
6321{
6322 yarp::os::idl::WireReader reader(connection);
6323 if (!reader.readListHeader()) {
6324 reader.fail();
6325 return false;
6326 }
6327 return read(reader);
6328}
6329
6331{
6332 if (!writeTag(writer)) {
6333 return false;
6334 }
6335 if (!writeArgs(writer)) {
6336 return false;
6337 }
6338 return true;
6339}
6340
6342{
6343 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6344 return false;
6345 }
6346 return true;
6347}
6348
6350{
6351 if (!writer.writeString(path_name)) {
6352 return false;
6353 }
6354 return true;
6355}
6356
6358{
6359 if (!readTag(reader)) {
6360 return false;
6361 }
6362 if (!readArgs(reader)) {
6363 return false;
6364 }
6365 return true;
6366}
6367
6369{
6370 std::string tag = reader.readTag(s_tag_len);
6371 if (reader.isError()) {
6372 return false;
6373 }
6374 if (tag != s_tag) {
6375 reader.fail();
6376 return false;
6377 }
6378 return true;
6379}
6380
6382{
6383 if (reader.noMore()) {
6384 reader.fail();
6385 return false;
6386 }
6387 if (!reader.readString(path_name)) {
6388 reader.fail();
6389 return false;
6390 }
6391 if (!reader.noMore()) {
6392 reader.fail();
6393 return false;
6394 }
6395 return true;
6396}
6397
6399{
6400 yarp::os::idl::WireWriter writer(connection);
6401 return write(writer);
6402}
6403
6405{
6406 yarp::os::idl::WireReader reader(connection);
6407 return read(reader);
6408}
6409
6411{
6412 if (!writer.isNull()) {
6413 if (!writer.write(return_helper)) {
6414 return false;
6415 }
6416 }
6417 return true;
6418}
6419
6421{
6422 if (reader.noMore()) {
6423 reader.fail();
6424 return false;
6425 }
6426 if (!reader.read(return_helper)) {
6427 reader.fail();
6428 return false;
6429 }
6430 return true;
6431}
6432
6437
6438// rename_object_RPC helper class implementation
6439IMap2DMsgs_rename_object_RPC_helper::IMap2DMsgs_rename_object_RPC_helper(const std::string& original_name, const std::string& new_name) :
6440 cmd{original_name, new_name}
6441{
6442}
6443
6445{
6446 return cmd.write(connection);
6447}
6448
6450{
6451 return reply.read(connection);
6452}
6453
6454IMap2DMsgs_rename_object_RPC_helper::Command::Command(const std::string& original_name, const std::string& new_name) :
6455 original_name{original_name},
6456 new_name{new_name}
6457{
6458}
6459
6461{
6462 yarp::os::idl::WireWriter writer(connection);
6463 if (!writer.writeListHeader(s_cmd_len)) {
6464 return false;
6465 }
6466 return write(writer);
6467}
6468
6470{
6471 yarp::os::idl::WireReader reader(connection);
6472 if (!reader.readListHeader()) {
6473 reader.fail();
6474 return false;
6475 }
6476 return read(reader);
6477}
6478
6480{
6481 if (!writeTag(writer)) {
6482 return false;
6483 }
6484 if (!writeArgs(writer)) {
6485 return false;
6486 }
6487 return true;
6488}
6489
6491{
6492 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6493 return false;
6494 }
6495 return true;
6496}
6497
6499{
6500 if (!writer.writeString(original_name)) {
6501 return false;
6502 }
6503 if (!writer.writeString(new_name)) {
6504 return false;
6505 }
6506 return true;
6507}
6508
6510{
6511 if (!readTag(reader)) {
6512 return false;
6513 }
6514 if (!readArgs(reader)) {
6515 return false;
6516 }
6517 return true;
6518}
6519
6521{
6522 std::string tag = reader.readTag(s_tag_len);
6523 if (reader.isError()) {
6524 return false;
6525 }
6526 if (tag != s_tag) {
6527 reader.fail();
6528 return false;
6529 }
6530 return true;
6531}
6532
6534{
6535 if (reader.noMore()) {
6536 reader.fail();
6537 return false;
6538 }
6539 if (!reader.readString(original_name)) {
6540 reader.fail();
6541 return false;
6542 }
6543 if (reader.noMore()) {
6544 reader.fail();
6545 return false;
6546 }
6547 if (!reader.readString(new_name)) {
6548 reader.fail();
6549 return false;
6550 }
6551 if (!reader.noMore()) {
6552 reader.fail();
6553 return false;
6554 }
6555 return true;
6556}
6557
6559{
6560 yarp::os::idl::WireWriter writer(connection);
6561 return write(writer);
6562}
6563
6565{
6566 yarp::os::idl::WireReader reader(connection);
6567 return read(reader);
6568}
6569
6571{
6572 if (!writer.isNull()) {
6573 if (!writer.write(return_helper)) {
6574 return false;
6575 }
6576 }
6577 return true;
6578}
6579
6581{
6582 if (reader.noMore()) {
6583 reader.fail();
6584 return false;
6585 }
6586 if (!reader.read(return_helper)) {
6587 reader.fail();
6588 return false;
6589 }
6590 return true;
6591}
6592
6597
6598// rename_area_RPC helper class implementation
6599IMap2DMsgs_rename_area_RPC_helper::IMap2DMsgs_rename_area_RPC_helper(const std::string& original_name, const std::string& new_name) :
6600 cmd{original_name, new_name}
6601{
6602}
6603
6605{
6606 return cmd.write(connection);
6607}
6608
6610{
6611 return reply.read(connection);
6612}
6613
6614IMap2DMsgs_rename_area_RPC_helper::Command::Command(const std::string& original_name, const std::string& new_name) :
6615 original_name{original_name},
6616 new_name{new_name}
6617{
6618}
6619
6621{
6622 yarp::os::idl::WireWriter writer(connection);
6623 if (!writer.writeListHeader(s_cmd_len)) {
6624 return false;
6625 }
6626 return write(writer);
6627}
6628
6630{
6631 yarp::os::idl::WireReader reader(connection);
6632 if (!reader.readListHeader()) {
6633 reader.fail();
6634 return false;
6635 }
6636 return read(reader);
6637}
6638
6640{
6641 if (!writeTag(writer)) {
6642 return false;
6643 }
6644 if (!writeArgs(writer)) {
6645 return false;
6646 }
6647 return true;
6648}
6649
6651{
6652 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6653 return false;
6654 }
6655 return true;
6656}
6657
6659{
6660 if (!writer.writeString(original_name)) {
6661 return false;
6662 }
6663 if (!writer.writeString(new_name)) {
6664 return false;
6665 }
6666 return true;
6667}
6668
6670{
6671 if (!readTag(reader)) {
6672 return false;
6673 }
6674 if (!readArgs(reader)) {
6675 return false;
6676 }
6677 return true;
6678}
6679
6681{
6682 std::string tag = reader.readTag(s_tag_len);
6683 if (reader.isError()) {
6684 return false;
6685 }
6686 if (tag != s_tag) {
6687 reader.fail();
6688 return false;
6689 }
6690 return true;
6691}
6692
6694{
6695 if (reader.noMore()) {
6696 reader.fail();
6697 return false;
6698 }
6699 if (!reader.readString(original_name)) {
6700 reader.fail();
6701 return false;
6702 }
6703 if (reader.noMore()) {
6704 reader.fail();
6705 return false;
6706 }
6707 if (!reader.readString(new_name)) {
6708 reader.fail();
6709 return false;
6710 }
6711 if (!reader.noMore()) {
6712 reader.fail();
6713 return false;
6714 }
6715 return true;
6716}
6717
6719{
6720 yarp::os::idl::WireWriter writer(connection);
6721 return write(writer);
6722}
6723
6725{
6726 yarp::os::idl::WireReader reader(connection);
6727 return read(reader);
6728}
6729
6731{
6732 if (!writer.isNull()) {
6733 if (!writer.write(return_helper)) {
6734 return false;
6735 }
6736 }
6737 return true;
6738}
6739
6741{
6742 if (reader.noMore()) {
6743 reader.fail();
6744 return false;
6745 }
6746 if (!reader.read(return_helper)) {
6747 reader.fail();
6748 return false;
6749 }
6750 return true;
6751}
6752
6757
6758// rename_path_RPC helper class implementation
6759IMap2DMsgs_rename_path_RPC_helper::IMap2DMsgs_rename_path_RPC_helper(const std::string& original_name, const std::string& new_name) :
6760 cmd{original_name, new_name}
6761{
6762}
6763
6765{
6766 return cmd.write(connection);
6767}
6768
6770{
6771 return reply.read(connection);
6772}
6773
6774IMap2DMsgs_rename_path_RPC_helper::Command::Command(const std::string& original_name, const std::string& new_name) :
6775 original_name{original_name},
6776 new_name{new_name}
6777{
6778}
6779
6781{
6782 yarp::os::idl::WireWriter writer(connection);
6783 if (!writer.writeListHeader(s_cmd_len)) {
6784 return false;
6785 }
6786 return write(writer);
6787}
6788
6790{
6791 yarp::os::idl::WireReader reader(connection);
6792 if (!reader.readListHeader()) {
6793 reader.fail();
6794 return false;
6795 }
6796 return read(reader);
6797}
6798
6800{
6801 if (!writeTag(writer)) {
6802 return false;
6803 }
6804 if (!writeArgs(writer)) {
6805 return false;
6806 }
6807 return true;
6808}
6809
6811{
6812 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6813 return false;
6814 }
6815 return true;
6816}
6817
6819{
6820 if (!writer.writeString(original_name)) {
6821 return false;
6822 }
6823 if (!writer.writeString(new_name)) {
6824 return false;
6825 }
6826 return true;
6827}
6828
6830{
6831 if (!readTag(reader)) {
6832 return false;
6833 }
6834 if (!readArgs(reader)) {
6835 return false;
6836 }
6837 return true;
6838}
6839
6841{
6842 std::string tag = reader.readTag(s_tag_len);
6843 if (reader.isError()) {
6844 return false;
6845 }
6846 if (tag != s_tag) {
6847 reader.fail();
6848 return false;
6849 }
6850 return true;
6851}
6852
6854{
6855 if (reader.noMore()) {
6856 reader.fail();
6857 return false;
6858 }
6859 if (!reader.readString(original_name)) {
6860 reader.fail();
6861 return false;
6862 }
6863 if (reader.noMore()) {
6864 reader.fail();
6865 return false;
6866 }
6867 if (!reader.readString(new_name)) {
6868 reader.fail();
6869 return false;
6870 }
6871 if (!reader.noMore()) {
6872 reader.fail();
6873 return false;
6874 }
6875 return true;
6876}
6877
6879{
6880 yarp::os::idl::WireWriter writer(connection);
6881 return write(writer);
6882}
6883
6885{
6886 yarp::os::idl::WireReader reader(connection);
6887 return read(reader);
6888}
6889
6891{
6892 if (!writer.isNull()) {
6893 if (!writer.write(return_helper)) {
6894 return false;
6895 }
6896 }
6897 return true;
6898}
6899
6901{
6902 if (reader.noMore()) {
6903 reader.fail();
6904 return false;
6905 }
6906 if (!reader.read(return_helper)) {
6907 reader.fail();
6908 return false;
6909 }
6910 return true;
6911}
6912
6917
6918// delete_area_RPC helper class implementation
6920 cmd{area_name}
6921{
6922}
6923
6925{
6926 return cmd.write(connection);
6927}
6928
6930{
6931 return reply.read(connection);
6932}
6933
6935 area_name{area_name}
6936{
6937}
6938
6940{
6941 yarp::os::idl::WireWriter writer(connection);
6942 if (!writer.writeListHeader(s_cmd_len)) {
6943 return false;
6944 }
6945 return write(writer);
6946}
6947
6949{
6950 yarp::os::idl::WireReader reader(connection);
6951 if (!reader.readListHeader()) {
6952 reader.fail();
6953 return false;
6954 }
6955 return read(reader);
6956}
6957
6959{
6960 if (!writeTag(writer)) {
6961 return false;
6962 }
6963 if (!writeArgs(writer)) {
6964 return false;
6965 }
6966 return true;
6967}
6968
6970{
6971 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
6972 return false;
6973 }
6974 return true;
6975}
6976
6978{
6979 if (!writer.writeString(area_name)) {
6980 return false;
6981 }
6982 return true;
6983}
6984
6986{
6987 if (!readTag(reader)) {
6988 return false;
6989 }
6990 if (!readArgs(reader)) {
6991 return false;
6992 }
6993 return true;
6994}
6995
6997{
6998 std::string tag = reader.readTag(s_tag_len);
6999 if (reader.isError()) {
7000 return false;
7001 }
7002 if (tag != s_tag) {
7003 reader.fail();
7004 return false;
7005 }
7006 return true;
7007}
7008
7010{
7011 if (reader.noMore()) {
7012 reader.fail();
7013 return false;
7014 }
7015 if (!reader.readString(area_name)) {
7016 reader.fail();
7017 return false;
7018 }
7019 if (!reader.noMore()) {
7020 reader.fail();
7021 return false;
7022 }
7023 return true;
7024}
7025
7027{
7028 yarp::os::idl::WireWriter writer(connection);
7029 return write(writer);
7030}
7031
7033{
7034 yarp::os::idl::WireReader reader(connection);
7035 return read(reader);
7036}
7037
7039{
7040 if (!writer.isNull()) {
7041 if (!writer.write(return_helper)) {
7042 return false;
7043 }
7044 }
7045 return true;
7046}
7047
7049{
7050 if (reader.noMore()) {
7051 reader.fail();
7052 return false;
7053 }
7054 if (!reader.read(return_helper)) {
7055 reader.fail();
7056 return false;
7057 }
7058 return true;
7059}
7060
7065
7066// clear_all_objects_RPC helper class implementation
7068{
7069 return cmd.write(connection);
7070}
7071
7073{
7074 return reply.read(connection);
7075}
7076
7078{
7079 yarp::os::idl::WireWriter writer(connection);
7080 if (!writer.writeListHeader(s_cmd_len)) {
7081 return false;
7082 }
7083 return write(writer);
7084}
7085
7087{
7088 yarp::os::idl::WireReader reader(connection);
7089 if (!reader.readListHeader()) {
7090 reader.fail();
7091 return false;
7092 }
7093 return read(reader);
7094}
7095
7097{
7098 if (!writeTag(writer)) {
7099 return false;
7100 }
7101 if (!writeArgs(writer)) {
7102 return false;
7103 }
7104 return true;
7105}
7106
7108{
7109 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7110 return false;
7111 }
7112 return true;
7113}
7114
7116{
7117 return true;
7118}
7119
7121{
7122 if (!readTag(reader)) {
7123 return false;
7124 }
7125 if (!readArgs(reader)) {
7126 return false;
7127 }
7128 return true;
7129}
7130
7132{
7133 std::string tag = reader.readTag(s_tag_len);
7134 if (reader.isError()) {
7135 return false;
7136 }
7137 if (tag != s_tag) {
7138 reader.fail();
7139 return false;
7140 }
7141 return true;
7142}
7143
7145{
7146 if (!reader.noMore()) {
7147 reader.fail();
7148 return false;
7149 }
7150 return true;
7151}
7152
7154{
7155 yarp::os::idl::WireWriter writer(connection);
7156 return write(writer);
7157}
7158
7160{
7161 yarp::os::idl::WireReader reader(connection);
7162 return read(reader);
7163}
7164
7166{
7167 if (!writer.isNull()) {
7168 if (!writer.write(return_helper)) {
7169 return false;
7170 }
7171 }
7172 return true;
7173}
7174
7176{
7177 if (reader.noMore()) {
7178 reader.fail();
7179 return false;
7180 }
7181 if (!reader.read(return_helper)) {
7182 reader.fail();
7183 return false;
7184 }
7185 return true;
7186}
7187
7192
7193// clear_all_locations_RPC helper class implementation
7195{
7196 return cmd.write(connection);
7197}
7198
7200{
7201 return reply.read(connection);
7202}
7203
7205{
7206 yarp::os::idl::WireWriter writer(connection);
7207 if (!writer.writeListHeader(s_cmd_len)) {
7208 return false;
7209 }
7210 return write(writer);
7211}
7212
7214{
7215 yarp::os::idl::WireReader reader(connection);
7216 if (!reader.readListHeader()) {
7217 reader.fail();
7218 return false;
7219 }
7220 return read(reader);
7221}
7222
7224{
7225 if (!writeTag(writer)) {
7226 return false;
7227 }
7228 if (!writeArgs(writer)) {
7229 return false;
7230 }
7231 return true;
7232}
7233
7235{
7236 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7237 return false;
7238 }
7239 return true;
7240}
7241
7243{
7244 return true;
7245}
7246
7248{
7249 if (!readTag(reader)) {
7250 return false;
7251 }
7252 if (!readArgs(reader)) {
7253 return false;
7254 }
7255 return true;
7256}
7257
7259{
7260 std::string tag = reader.readTag(s_tag_len);
7261 if (reader.isError()) {
7262 return false;
7263 }
7264 if (tag != s_tag) {
7265 reader.fail();
7266 return false;
7267 }
7268 return true;
7269}
7270
7272{
7273 if (!reader.noMore()) {
7274 reader.fail();
7275 return false;
7276 }
7277 return true;
7278}
7279
7281{
7282 yarp::os::idl::WireWriter writer(connection);
7283 return write(writer);
7284}
7285
7287{
7288 yarp::os::idl::WireReader reader(connection);
7289 return read(reader);
7290}
7291
7293{
7294 if (!writer.isNull()) {
7295 if (!writer.write(return_helper)) {
7296 return false;
7297 }
7298 }
7299 return true;
7300}
7301
7303{
7304 if (reader.noMore()) {
7305 reader.fail();
7306 return false;
7307 }
7308 if (!reader.read(return_helper)) {
7309 reader.fail();
7310 return false;
7311 }
7312 return true;
7313}
7314
7319
7320// clear_all_areas_RPC helper class implementation
7322{
7323 return cmd.write(connection);
7324}
7325
7327{
7328 return reply.read(connection);
7329}
7330
7332{
7333 yarp::os::idl::WireWriter writer(connection);
7334 if (!writer.writeListHeader(s_cmd_len)) {
7335 return false;
7336 }
7337 return write(writer);
7338}
7339
7341{
7342 yarp::os::idl::WireReader reader(connection);
7343 if (!reader.readListHeader()) {
7344 reader.fail();
7345 return false;
7346 }
7347 return read(reader);
7348}
7349
7351{
7352 if (!writeTag(writer)) {
7353 return false;
7354 }
7355 if (!writeArgs(writer)) {
7356 return false;
7357 }
7358 return true;
7359}
7360
7362{
7363 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7364 return false;
7365 }
7366 return true;
7367}
7368
7370{
7371 return true;
7372}
7373
7375{
7376 if (!readTag(reader)) {
7377 return false;
7378 }
7379 if (!readArgs(reader)) {
7380 return false;
7381 }
7382 return true;
7383}
7384
7386{
7387 std::string tag = reader.readTag(s_tag_len);
7388 if (reader.isError()) {
7389 return false;
7390 }
7391 if (tag != s_tag) {
7392 reader.fail();
7393 return false;
7394 }
7395 return true;
7396}
7397
7399{
7400 if (!reader.noMore()) {
7401 reader.fail();
7402 return false;
7403 }
7404 return true;
7405}
7406
7408{
7409 yarp::os::idl::WireWriter writer(connection);
7410 return write(writer);
7411}
7412
7414{
7415 yarp::os::idl::WireReader reader(connection);
7416 return read(reader);
7417}
7418
7420{
7421 if (!writer.isNull()) {
7422 if (!writer.write(return_helper)) {
7423 return false;
7424 }
7425 }
7426 return true;
7427}
7428
7430{
7431 if (reader.noMore()) {
7432 reader.fail();
7433 return false;
7434 }
7435 if (!reader.read(return_helper)) {
7436 reader.fail();
7437 return false;
7438 }
7439 return true;
7440}
7441
7446
7447// clear_all_paths_RPC helper class implementation
7449{
7450 return cmd.write(connection);
7451}
7452
7454{
7455 return reply.read(connection);
7456}
7457
7459{
7460 yarp::os::idl::WireWriter writer(connection);
7461 if (!writer.writeListHeader(s_cmd_len)) {
7462 return false;
7463 }
7464 return write(writer);
7465}
7466
7468{
7469 yarp::os::idl::WireReader reader(connection);
7470 if (!reader.readListHeader()) {
7471 reader.fail();
7472 return false;
7473 }
7474 return read(reader);
7475}
7476
7478{
7479 if (!writeTag(writer)) {
7480 return false;
7481 }
7482 if (!writeArgs(writer)) {
7483 return false;
7484 }
7485 return true;
7486}
7487
7489{
7490 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7491 return false;
7492 }
7493 return true;
7494}
7495
7497{
7498 return true;
7499}
7500
7502{
7503 if (!readTag(reader)) {
7504 return false;
7505 }
7506 if (!readArgs(reader)) {
7507 return false;
7508 }
7509 return true;
7510}
7511
7513{
7514 std::string tag = reader.readTag(s_tag_len);
7515 if (reader.isError()) {
7516 return false;
7517 }
7518 if (tag != s_tag) {
7519 reader.fail();
7520 return false;
7521 }
7522 return true;
7523}
7524
7526{
7527 if (!reader.noMore()) {
7528 reader.fail();
7529 return false;
7530 }
7531 return true;
7532}
7533
7535{
7536 yarp::os::idl::WireWriter writer(connection);
7537 return write(writer);
7538}
7539
7541{
7542 yarp::os::idl::WireReader reader(connection);
7543 return read(reader);
7544}
7545
7547{
7548 if (!writer.isNull()) {
7549 if (!writer.write(return_helper)) {
7550 return false;
7551 }
7552 }
7553 return true;
7554}
7555
7557{
7558 if (reader.noMore()) {
7559 reader.fail();
7560 return false;
7561 }
7562 if (!reader.read(return_helper)) {
7563 reader.fail();
7564 return false;
7565 }
7566 return true;
7567}
7568
7573
7574// clear_all_maps_temporary_flags_RPC helper class implementation
7579
7584
7586{
7587 yarp::os::idl::WireWriter writer(connection);
7588 if (!writer.writeListHeader(s_cmd_len)) {
7589 return false;
7590 }
7591 return write(writer);
7592}
7593
7595{
7596 yarp::os::idl::WireReader reader(connection);
7597 if (!reader.readListHeader()) {
7598 reader.fail();
7599 return false;
7600 }
7601 return read(reader);
7602}
7603
7605{
7606 if (!writeTag(writer)) {
7607 return false;
7608 }
7609 if (!writeArgs(writer)) {
7610 return false;
7611 }
7612 return true;
7613}
7614
7616{
7617 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7618 return false;
7619 }
7620 return true;
7621}
7622
7624{
7625 return true;
7626}
7627
7629{
7630 if (!readTag(reader)) {
7631 return false;
7632 }
7633 if (!readArgs(reader)) {
7634 return false;
7635 }
7636 return true;
7637}
7638
7640{
7641 std::string tag = reader.readTag(s_tag_len);
7642 if (reader.isError()) {
7643 return false;
7644 }
7645 if (tag != s_tag) {
7646 reader.fail();
7647 return false;
7648 }
7649 return true;
7650}
7651
7653{
7654 if (!reader.noMore()) {
7655 reader.fail();
7656 return false;
7657 }
7658 return true;
7659}
7660
7662{
7663 yarp::os::idl::WireWriter writer(connection);
7664 return write(writer);
7665}
7666
7672
7674{
7675 if (!writer.isNull()) {
7676 if (!writer.write(return_helper)) {
7677 return false;
7678 }
7679 }
7680 return true;
7681}
7682
7684{
7685 if (reader.noMore()) {
7686 reader.fail();
7687 return false;
7688 }
7689 if (!reader.read(return_helper)) {
7690 reader.fail();
7691 return false;
7692 }
7693 return true;
7694}
7695
7700
7701// clear_map_temporary_flags_RPC helper class implementation
7706
7708{
7709 return cmd.write(connection);
7710}
7711
7716
7718 map_name{map_name}
7719{
7720}
7721
7723{
7724 yarp::os::idl::WireWriter writer(connection);
7725 if (!writer.writeListHeader(s_cmd_len)) {
7726 return false;
7727 }
7728 return write(writer);
7729}
7730
7732{
7733 yarp::os::idl::WireReader reader(connection);
7734 if (!reader.readListHeader()) {
7735 reader.fail();
7736 return false;
7737 }
7738 return read(reader);
7739}
7740
7742{
7743 if (!writeTag(writer)) {
7744 return false;
7745 }
7746 if (!writeArgs(writer)) {
7747 return false;
7748 }
7749 return true;
7750}
7751
7753{
7754 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7755 return false;
7756 }
7757 return true;
7758}
7759
7761{
7762 if (!writer.writeString(map_name)) {
7763 return false;
7764 }
7765 return true;
7766}
7767
7769{
7770 if (!readTag(reader)) {
7771 return false;
7772 }
7773 if (!readArgs(reader)) {
7774 return false;
7775 }
7776 return true;
7777}
7778
7780{
7781 std::string tag = reader.readTag(s_tag_len);
7782 if (reader.isError()) {
7783 return false;
7784 }
7785 if (tag != s_tag) {
7786 reader.fail();
7787 return false;
7788 }
7789 return true;
7790}
7791
7793{
7794 if (reader.noMore()) {
7795 reader.fail();
7796 return false;
7797 }
7798 if (!reader.readString(map_name)) {
7799 reader.fail();
7800 return false;
7801 }
7802 if (!reader.noMore()) {
7803 reader.fail();
7804 return false;
7805 }
7806 return true;
7807}
7808
7810{
7811 yarp::os::idl::WireWriter writer(connection);
7812 return write(writer);
7813}
7814
7816{
7817 yarp::os::idl::WireReader reader(connection);
7818 return read(reader);
7819}
7820
7822{
7823 if (!writer.isNull()) {
7824 if (!writer.write(return_helper)) {
7825 return false;
7826 }
7827 }
7828 return true;
7829}
7830
7832{
7833 if (reader.noMore()) {
7834 reader.fail();
7835 return false;
7836 }
7837 if (!reader.read(return_helper)) {
7838 reader.fail();
7839 return false;
7840 }
7841 return true;
7842}
7843
7848
7849// save_maps_collection_RPC helper class implementation
7851 cmd{maps_collection_file}
7852{
7853}
7854
7856{
7857 return cmd.write(connection);
7858}
7859
7861{
7862 return reply.read(connection);
7863}
7864
7866 maps_collection_file{maps_collection_file}
7867{
7868}
7869
7871{
7872 yarp::os::idl::WireWriter writer(connection);
7873 if (!writer.writeListHeader(s_cmd_len)) {
7874 return false;
7875 }
7876 return write(writer);
7877}
7878
7880{
7881 yarp::os::idl::WireReader reader(connection);
7882 if (!reader.readListHeader()) {
7883 reader.fail();
7884 return false;
7885 }
7886 return read(reader);
7887}
7888
7890{
7891 if (!writeTag(writer)) {
7892 return false;
7893 }
7894 if (!writeArgs(writer)) {
7895 return false;
7896 }
7897 return true;
7898}
7899
7901{
7902 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
7903 return false;
7904 }
7905 return true;
7906}
7907
7909{
7910 if (!writer.writeString(maps_collection_file)) {
7911 return false;
7912 }
7913 return true;
7914}
7915
7917{
7918 if (!readTag(reader)) {
7919 return false;
7920 }
7921 if (!readArgs(reader)) {
7922 return false;
7923 }
7924 return true;
7925}
7926
7928{
7929 std::string tag = reader.readTag(s_tag_len);
7930 if (reader.isError()) {
7931 return false;
7932 }
7933 if (tag != s_tag) {
7934 reader.fail();
7935 return false;
7936 }
7937 return true;
7938}
7939
7941{
7942 if (reader.noMore()) {
7943 reader.fail();
7944 return false;
7945 }
7946 if (!reader.readString(maps_collection_file)) {
7947 reader.fail();
7948 return false;
7949 }
7950 if (!reader.noMore()) {
7951 reader.fail();
7952 return false;
7953 }
7954 return true;
7955}
7956
7958{
7959 yarp::os::idl::WireWriter writer(connection);
7960 return write(writer);
7961}
7962
7964{
7965 yarp::os::idl::WireReader reader(connection);
7966 return read(reader);
7967}
7968
7970{
7971 if (!writer.isNull()) {
7972 if (!writer.write(return_helper)) {
7973 return false;
7974 }
7975 }
7976 return true;
7977}
7978
7980{
7981 if (reader.noMore()) {
7982 reader.fail();
7983 return false;
7984 }
7985 if (!reader.read(return_helper)) {
7986 reader.fail();
7987 return false;
7988 }
7989 return true;
7990}
7991
7996
7997// load_maps_collection_RPC helper class implementation
7999 cmd{maps_collection_file}
8000{
8001}
8002
8004{
8005 return cmd.write(connection);
8006}
8007
8009{
8010 return reply.read(connection);
8011}
8012
8014 maps_collection_file{maps_collection_file}
8015{
8016}
8017
8019{
8020 yarp::os::idl::WireWriter writer(connection);
8021 if (!writer.writeListHeader(s_cmd_len)) {
8022 return false;
8023 }
8024 return write(writer);
8025}
8026
8028{
8029 yarp::os::idl::WireReader reader(connection);
8030 if (!reader.readListHeader()) {
8031 reader.fail();
8032 return false;
8033 }
8034 return read(reader);
8035}
8036
8038{
8039 if (!writeTag(writer)) {
8040 return false;
8041 }
8042 if (!writeArgs(writer)) {
8043 return false;
8044 }
8045 return true;
8046}
8047
8049{
8050 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8051 return false;
8052 }
8053 return true;
8054}
8055
8057{
8058 if (!writer.writeString(maps_collection_file)) {
8059 return false;
8060 }
8061 return true;
8062}
8063
8065{
8066 if (!readTag(reader)) {
8067 return false;
8068 }
8069 if (!readArgs(reader)) {
8070 return false;
8071 }
8072 return true;
8073}
8074
8076{
8077 std::string tag = reader.readTag(s_tag_len);
8078 if (reader.isError()) {
8079 return false;
8080 }
8081 if (tag != s_tag) {
8082 reader.fail();
8083 return false;
8084 }
8085 return true;
8086}
8087
8089{
8090 if (reader.noMore()) {
8091 reader.fail();
8092 return false;
8093 }
8094 if (!reader.readString(maps_collection_file)) {
8095 reader.fail();
8096 return false;
8097 }
8098 if (!reader.noMore()) {
8099 reader.fail();
8100 return false;
8101 }
8102 return true;
8103}
8104
8106{
8107 yarp::os::idl::WireWriter writer(connection);
8108 return write(writer);
8109}
8110
8112{
8113 yarp::os::idl::WireReader reader(connection);
8114 return read(reader);
8115}
8116
8118{
8119 if (!writer.isNull()) {
8120 if (!writer.write(return_helper)) {
8121 return false;
8122 }
8123 }
8124 return true;
8125}
8126
8128{
8129 if (reader.noMore()) {
8130 reader.fail();
8131 return false;
8132 }
8133 if (!reader.read(return_helper)) {
8134 reader.fail();
8135 return false;
8136 }
8137 return true;
8138}
8139
8144
8145// save_locations_and_extras_RPC helper class implementation
8147 cmd{locations_collection_file}
8148{
8149}
8150
8152{
8153 return cmd.write(connection);
8154}
8155
8160
8161IMap2DMsgs_save_locations_and_extras_RPC_helper::Command::Command(const std::string& locations_collection_file) :
8162 locations_collection_file{locations_collection_file}
8163{
8164}
8165
8167{
8168 yarp::os::idl::WireWriter writer(connection);
8169 if (!writer.writeListHeader(s_cmd_len)) {
8170 return false;
8171 }
8172 return write(writer);
8173}
8174
8176{
8177 yarp::os::idl::WireReader reader(connection);
8178 if (!reader.readListHeader()) {
8179 reader.fail();
8180 return false;
8181 }
8182 return read(reader);
8183}
8184
8186{
8187 if (!writeTag(writer)) {
8188 return false;
8189 }
8190 if (!writeArgs(writer)) {
8191 return false;
8192 }
8193 return true;
8194}
8195
8197{
8198 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8199 return false;
8200 }
8201 return true;
8202}
8203
8205{
8206 if (!writer.writeString(locations_collection_file)) {
8207 return false;
8208 }
8209 return true;
8210}
8211
8213{
8214 if (!readTag(reader)) {
8215 return false;
8216 }
8217 if (!readArgs(reader)) {
8218 return false;
8219 }
8220 return true;
8221}
8222
8224{
8225 std::string tag = reader.readTag(s_tag_len);
8226 if (reader.isError()) {
8227 return false;
8228 }
8229 if (tag != s_tag) {
8230 reader.fail();
8231 return false;
8232 }
8233 return true;
8234}
8235
8237{
8238 if (reader.noMore()) {
8239 reader.fail();
8240 return false;
8241 }
8242 if (!reader.readString(locations_collection_file)) {
8243 reader.fail();
8244 return false;
8245 }
8246 if (!reader.noMore()) {
8247 reader.fail();
8248 return false;
8249 }
8250 return true;
8251}
8252
8254{
8255 yarp::os::idl::WireWriter writer(connection);
8256 return write(writer);
8257}
8258
8260{
8261 yarp::os::idl::WireReader reader(connection);
8262 return read(reader);
8263}
8264
8266{
8267 if (!writer.isNull()) {
8268 if (!writer.write(return_helper)) {
8269 return false;
8270 }
8271 }
8272 return true;
8273}
8274
8276{
8277 if (reader.noMore()) {
8278 reader.fail();
8279 return false;
8280 }
8281 if (!reader.read(return_helper)) {
8282 reader.fail();
8283 return false;
8284 }
8285 return true;
8286}
8287
8292
8293// load_locations_and_extras_RPC helper class implementation
8295 cmd{locations_collection_file}
8296{
8297}
8298
8300{
8301 return cmd.write(connection);
8302}
8303
8308
8309IMap2DMsgs_load_locations_and_extras_RPC_helper::Command::Command(const std::string& locations_collection_file) :
8310 locations_collection_file{locations_collection_file}
8311{
8312}
8313
8315{
8316 yarp::os::idl::WireWriter writer(connection);
8317 if (!writer.writeListHeader(s_cmd_len)) {
8318 return false;
8319 }
8320 return write(writer);
8321}
8322
8324{
8325 yarp::os::idl::WireReader reader(connection);
8326 if (!reader.readListHeader()) {
8327 reader.fail();
8328 return false;
8329 }
8330 return read(reader);
8331}
8332
8334{
8335 if (!writeTag(writer)) {
8336 return false;
8337 }
8338 if (!writeArgs(writer)) {
8339 return false;
8340 }
8341 return true;
8342}
8343
8345{
8346 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8347 return false;
8348 }
8349 return true;
8350}
8351
8353{
8354 if (!writer.writeString(locations_collection_file)) {
8355 return false;
8356 }
8357 return true;
8358}
8359
8361{
8362 if (!readTag(reader)) {
8363 return false;
8364 }
8365 if (!readArgs(reader)) {
8366 return false;
8367 }
8368 return true;
8369}
8370
8372{
8373 std::string tag = reader.readTag(s_tag_len);
8374 if (reader.isError()) {
8375 return false;
8376 }
8377 if (tag != s_tag) {
8378 reader.fail();
8379 return false;
8380 }
8381 return true;
8382}
8383
8385{
8386 if (reader.noMore()) {
8387 reader.fail();
8388 return false;
8389 }
8390 if (!reader.readString(locations_collection_file)) {
8391 reader.fail();
8392 return false;
8393 }
8394 if (!reader.noMore()) {
8395 reader.fail();
8396 return false;
8397 }
8398 return true;
8399}
8400
8402{
8403 yarp::os::idl::WireWriter writer(connection);
8404 return write(writer);
8405}
8406
8408{
8409 yarp::os::idl::WireReader reader(connection);
8410 return read(reader);
8411}
8412
8414{
8415 if (!writer.isNull()) {
8416 if (!writer.write(return_helper)) {
8417 return false;
8418 }
8419 }
8420 return true;
8421}
8422
8424{
8425 if (reader.noMore()) {
8426 reader.fail();
8427 return false;
8428 }
8429 if (!reader.read(return_helper)) {
8430 reader.fail();
8431 return false;
8432 }
8433 return true;
8434}
8435
8440
8441// save_map_to_disk_RPC helper class implementation
8442IMap2DMsgs_save_map_to_disk_RPC_helper::IMap2DMsgs_save_map_to_disk_RPC_helper(const std::string& map_name, const std::string& file_name) :
8443 cmd{map_name, file_name}
8444{
8445}
8446
8448{
8449 return cmd.write(connection);
8450}
8451
8453{
8454 return reply.read(connection);
8455}
8456
8457IMap2DMsgs_save_map_to_disk_RPC_helper::Command::Command(const std::string& map_name, const std::string& file_name) :
8458 map_name{map_name},
8459 file_name{file_name}
8460{
8461}
8462
8464{
8465 yarp::os::idl::WireWriter writer(connection);
8466 if (!writer.writeListHeader(s_cmd_len)) {
8467 return false;
8468 }
8469 return write(writer);
8470}
8471
8473{
8474 yarp::os::idl::WireReader reader(connection);
8475 if (!reader.readListHeader()) {
8476 reader.fail();
8477 return false;
8478 }
8479 return read(reader);
8480}
8481
8483{
8484 if (!writeTag(writer)) {
8485 return false;
8486 }
8487 if (!writeArgs(writer)) {
8488 return false;
8489 }
8490 return true;
8491}
8492
8494{
8495 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8496 return false;
8497 }
8498 return true;
8499}
8500
8502{
8503 if (!writer.writeString(map_name)) {
8504 return false;
8505 }
8506 if (!writer.writeString(file_name)) {
8507 return false;
8508 }
8509 return true;
8510}
8511
8513{
8514 if (!readTag(reader)) {
8515 return false;
8516 }
8517 if (!readArgs(reader)) {
8518 return false;
8519 }
8520 return true;
8521}
8522
8524{
8525 std::string tag = reader.readTag(s_tag_len);
8526 if (reader.isError()) {
8527 return false;
8528 }
8529 if (tag != s_tag) {
8530 reader.fail();
8531 return false;
8532 }
8533 return true;
8534}
8535
8537{
8538 if (reader.noMore()) {
8539 reader.fail();
8540 return false;
8541 }
8542 if (!reader.readString(map_name)) {
8543 reader.fail();
8544 return false;
8545 }
8546 if (reader.noMore()) {
8547 reader.fail();
8548 return false;
8549 }
8550 if (!reader.readString(file_name)) {
8551 reader.fail();
8552 return false;
8553 }
8554 if (!reader.noMore()) {
8555 reader.fail();
8556 return false;
8557 }
8558 return true;
8559}
8560
8562{
8563 yarp::os::idl::WireWriter writer(connection);
8564 return write(writer);
8565}
8566
8568{
8569 yarp::os::idl::WireReader reader(connection);
8570 return read(reader);
8571}
8572
8574{
8575 if (!writer.isNull()) {
8576 if (!writer.write(return_helper)) {
8577 return false;
8578 }
8579 }
8580 return true;
8581}
8582
8584{
8585 if (reader.noMore()) {
8586 reader.fail();
8587 return false;
8588 }
8589 if (!reader.read(return_helper)) {
8590 reader.fail();
8591 return false;
8592 }
8593 return true;
8594}
8595
8600
8601// load_map_from_disk_RPC helper class implementation
8603 cmd{file_name}
8604{
8605}
8606
8608{
8609 return cmd.write(connection);
8610}
8611
8613{
8614 return reply.read(connection);
8615}
8616
8618 file_name{file_name}
8619{
8620}
8621
8623{
8624 yarp::os::idl::WireWriter writer(connection);
8625 if (!writer.writeListHeader(s_cmd_len)) {
8626 return false;
8627 }
8628 return write(writer);
8629}
8630
8632{
8633 yarp::os::idl::WireReader reader(connection);
8634 if (!reader.readListHeader()) {
8635 reader.fail();
8636 return false;
8637 }
8638 return read(reader);
8639}
8640
8642{
8643 if (!writeTag(writer)) {
8644 return false;
8645 }
8646 if (!writeArgs(writer)) {
8647 return false;
8648 }
8649 return true;
8650}
8651
8653{
8654 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8655 return false;
8656 }
8657 return true;
8658}
8659
8661{
8662 if (!writer.writeString(file_name)) {
8663 return false;
8664 }
8665 return true;
8666}
8667
8669{
8670 if (!readTag(reader)) {
8671 return false;
8672 }
8673 if (!readArgs(reader)) {
8674 return false;
8675 }
8676 return true;
8677}
8678
8680{
8681 std::string tag = reader.readTag(s_tag_len);
8682 if (reader.isError()) {
8683 return false;
8684 }
8685 if (tag != s_tag) {
8686 reader.fail();
8687 return false;
8688 }
8689 return true;
8690}
8691
8693{
8694 if (reader.noMore()) {
8695 reader.fail();
8696 return false;
8697 }
8698 if (!reader.readString(file_name)) {
8699 reader.fail();
8700 return false;
8701 }
8702 if (!reader.noMore()) {
8703 reader.fail();
8704 return false;
8705 }
8706 return true;
8707}
8708
8710{
8711 yarp::os::idl::WireWriter writer(connection);
8712 return write(writer);
8713}
8714
8716{
8717 yarp::os::idl::WireReader reader(connection);
8718 return read(reader);
8719}
8720
8722{
8723 if (!writer.isNull()) {
8724 if (!writer.write(return_helper)) {
8725 return false;
8726 }
8727 }
8728 return true;
8729}
8730
8732{
8733 if (reader.noMore()) {
8734 reader.fail();
8735 return false;
8736 }
8737 if (!reader.read(return_helper)) {
8738 reader.fail();
8739 return false;
8740 }
8741 return true;
8742}
8743
8748
8749// enable_maps_compression_RPC helper class implementation
8751 cmd{enable_compression}
8752{
8753}
8754
8756{
8757 return cmd.write(connection);
8758}
8759
8764
8766 enable_compression{enable_compression}
8767{
8768}
8769
8771{
8772 yarp::os::idl::WireWriter writer(connection);
8773 if (!writer.writeListHeader(s_cmd_len)) {
8774 return false;
8775 }
8776 return write(writer);
8777}
8778
8780{
8781 yarp::os::idl::WireReader reader(connection);
8782 if (!reader.readListHeader()) {
8783 reader.fail();
8784 return false;
8785 }
8786 return read(reader);
8787}
8788
8790{
8791 if (!writeTag(writer)) {
8792 return false;
8793 }
8794 if (!writeArgs(writer)) {
8795 return false;
8796 }
8797 return true;
8798}
8799
8801{
8802 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8803 return false;
8804 }
8805 return true;
8806}
8807
8809{
8810 if (!writer.writeBool(enable_compression)) {
8811 return false;
8812 }
8813 return true;
8814}
8815
8817{
8818 if (!readTag(reader)) {
8819 return false;
8820 }
8821 if (!readArgs(reader)) {
8822 return false;
8823 }
8824 return true;
8825}
8826
8828{
8829 std::string tag = reader.readTag(s_tag_len);
8830 if (reader.isError()) {
8831 return false;
8832 }
8833 if (tag != s_tag) {
8834 reader.fail();
8835 return false;
8836 }
8837 return true;
8838}
8839
8841{
8842 if (reader.noMore()) {
8843 reader.fail();
8844 return false;
8845 }
8846 if (!reader.readBool(enable_compression)) {
8847 reader.fail();
8848 return false;
8849 }
8850 if (!reader.noMore()) {
8851 reader.fail();
8852 return false;
8853 }
8854 return true;
8855}
8856
8858{
8859 yarp::os::idl::WireWriter writer(connection);
8860 return write(writer);
8861}
8862
8864{
8865 yarp::os::idl::WireReader reader(connection);
8866 return read(reader);
8867}
8868
8870{
8871 if (!writer.isNull()) {
8872 if (!writer.write(return_helper)) {
8873 return false;
8874 }
8875 }
8876 return true;
8877}
8878
8880{
8881 if (reader.noMore()) {
8882 reader.fail();
8883 return false;
8884 }
8885 if (!reader.read(return_helper)) {
8886 reader.fail();
8887 return false;
8888 }
8889 return true;
8890}
8891
8896
8897// reload_maps_collection_RPC helper class implementation
8899{
8900 return cmd.write(connection);
8901}
8902
8907
8909{
8910 yarp::os::idl::WireWriter writer(connection);
8911 if (!writer.writeListHeader(s_cmd_len)) {
8912 return false;
8913 }
8914 return write(writer);
8915}
8916
8918{
8919 yarp::os::idl::WireReader reader(connection);
8920 if (!reader.readListHeader()) {
8921 reader.fail();
8922 return false;
8923 }
8924 return read(reader);
8925}
8926
8928{
8929 if (!writeTag(writer)) {
8930 return false;
8931 }
8932 if (!writeArgs(writer)) {
8933 return false;
8934 }
8935 return true;
8936}
8937
8939{
8940 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
8941 return false;
8942 }
8943 return true;
8944}
8945
8947{
8948 return true;
8949}
8950
8952{
8953 if (!readTag(reader)) {
8954 return false;
8955 }
8956 if (!readArgs(reader)) {
8957 return false;
8958 }
8959 return true;
8960}
8961
8963{
8964 std::string tag = reader.readTag(s_tag_len);
8965 if (reader.isError()) {
8966 return false;
8967 }
8968 if (tag != s_tag) {
8969 reader.fail();
8970 return false;
8971 }
8972 return true;
8973}
8974
8976{
8977 if (!reader.noMore()) {
8978 reader.fail();
8979 return false;
8980 }
8981 return true;
8982}
8983
8985{
8986 yarp::os::idl::WireWriter writer(connection);
8987 return write(writer);
8988}
8989
8991{
8992 yarp::os::idl::WireReader reader(connection);
8993 return read(reader);
8994}
8995
8997{
8998 if (!writer.isNull()) {
8999 if (!writer.write(return_helper)) {
9000 return false;
9001 }
9002 }
9003 return true;
9004}
9005
9007{
9008 if (reader.noMore()) {
9009 reader.fail();
9010 return false;
9011 }
9012 if (!reader.read(return_helper)) {
9013 reader.fail();
9014 return false;
9015 }
9016 return true;
9017}
9018
9023
9024// reload_locations_and_extras_RPC helper class implementation
9026{
9027 return cmd.write(connection);
9028}
9029
9034
9036{
9037 yarp::os::idl::WireWriter writer(connection);
9038 if (!writer.writeListHeader(s_cmd_len)) {
9039 return false;
9040 }
9041 return write(writer);
9042}
9043
9045{
9046 yarp::os::idl::WireReader reader(connection);
9047 if (!reader.readListHeader()) {
9048 reader.fail();
9049 return false;
9050 }
9051 return read(reader);
9052}
9053
9055{
9056 if (!writeTag(writer)) {
9057 return false;
9058 }
9059 if (!writeArgs(writer)) {
9060 return false;
9061 }
9062 return true;
9063}
9064
9066{
9067 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
9068 return false;
9069 }
9070 return true;
9071}
9072
9074{
9075 return true;
9076}
9077
9079{
9080 if (!readTag(reader)) {
9081 return false;
9082 }
9083 if (!readArgs(reader)) {
9084 return false;
9085 }
9086 return true;
9087}
9088
9090{
9091 std::string tag = reader.readTag(s_tag_len);
9092 if (reader.isError()) {
9093 return false;
9094 }
9095 if (tag != s_tag) {
9096 reader.fail();
9097 return false;
9098 }
9099 return true;
9100}
9101
9103{
9104 if (!reader.noMore()) {
9105 reader.fail();
9106 return false;
9107 }
9108 return true;
9109}
9110
9112{
9113 yarp::os::idl::WireWriter writer(connection);
9114 return write(writer);
9115}
9116
9122
9124{
9125 if (!writer.isNull()) {
9126 if (!writer.write(return_helper)) {
9127 return false;
9128 }
9129 }
9130 return true;
9131}
9132
9134{
9135 if (reader.noMore()) {
9136 reader.fail();
9137 return false;
9138 }
9139 if (!reader.read(return_helper)) {
9140 reader.fail();
9141 return false;
9142 }
9143 return true;
9144}
9145
9150
9151// Constructor
9153{
9154 yarp().setOwner(*this);
9155}
9156
9158{
9159 if (!yarp().canWrite()) {
9160 yError("Missing server method '%s'?", IMap2DMsgs_clear_all_maps_RPC_helper::s_prototype);
9161 }
9163 bool ok = yarp().write(helper, helper);
9164 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
9165}
9166
9168{
9169 if (!yarp().canWrite()) {
9170 yError("Missing server method '%s'?", IMap2DMsgs_store_map_RPC_helper::s_prototype);
9171 }
9172 IMap2DMsgs_store_map_RPC_helper helper{themap};
9173 bool ok = yarp().write(helper, helper);
9174 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
9175}
9176
9177return_get_map IMap2DMsgs::get_map_RPC(const std::string& map_name)
9178{
9179 if (!yarp().canWrite()) {
9180 yError("Missing server method '%s'?", IMap2DMsgs_get_map_RPC_helper::s_prototype);
9181 }
9182 IMap2DMsgs_get_map_RPC_helper helper{map_name};
9183 bool ok = yarp().write(helper, helper);
9184 return ok ? helper.reply.return_helper : return_get_map{};
9185}
9186
9188{
9189 if (!yarp().canWrite()) {
9190 yError("Missing server method '%s'?", IMap2DMsgs_get_map_names_RPC_helper::s_prototype);
9191 }
9193 bool ok = yarp().write(helper, helper);
9194 return ok ? helper.reply.return_helper : return_get_map_names{};
9195}
9196
9198{
9199 if (!yarp().canWrite()) {
9200 yError("Missing server method '%s'?", IMap2DMsgs_remove_map_RPC_helper::s_prototype);
9201 }
9202 IMap2DMsgs_remove_map_RPC_helper helper{map_name};
9203 bool ok = yarp().write(helper, helper);
9204 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
9205}
9206
9208{
9209 if (!yarp().canWrite()) {
9210 yError("Missing server method '%s'?", IMap2DMsgs_store_object_RPC_helper::s_prototype);
9211 }
9212 IMap2DMsgs_store_object_RPC_helper helper{object_name, loc};
9213 bool ok = yarp().write(helper, helper);
9214 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
9215}
9216
9218{
9219 if (!yarp().canWrite()) {
9220 yError("Missing server method '%s'?", IMap2DMsgs_store_location_RPC_helper::s_prototype);
9221 }
9222 IMap2DMsgs_store_location_RPC_helper helper{location_name, loc};
9223 bool ok = yarp().write(helper, helper);
9224 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
9225}
9226
9228{
9229 if (!yarp().canWrite()) {
9230 yError("Missing server method '%s'?", IMap2DMsgs_store_area_RPC_helper::s_prototype);
9231 }
9232 IMap2DMsgs_store_area_RPC_helper helper{area_name, area};
9233 bool ok = yarp().write(helper, helper);
9234 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
9235}
9236
9238{
9239 if (!yarp().canWrite()) {
9240 yError("Missing server method '%s'?", IMap2DMsgs_store_path_RPC_helper::s_prototype);
9241 }
9242 IMap2DMsgs_store_path_RPC_helper helper{path_name, path};
9243 bool ok = yarp().write(helper, helper);
9244 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
9245}
9246
9247return_get_object IMap2DMsgs::get_object_RPC(const std::string& object_name)
9248{
9249 if (!yarp().canWrite()) {
9250 yError("Missing server method '%s'?", IMap2DMsgs_get_object_RPC_helper::s_prototype);
9251 }
9252 IMap2DMsgs_get_object_RPC_helper helper{object_name};
9253 bool ok = yarp().write(helper, helper);
9254 return ok ? helper.reply.return_helper : return_get_object{};
9255}
9256
9257return_get_location IMap2DMsgs::get_location_RPC(const std::string& location_name)
9258{
9259 if (!yarp().canWrite()) {
9260 yError("Missing server method '%s'?", IMap2DMsgs_get_location_RPC_helper::s_prototype);
9261 }
9262 IMap2DMsgs_get_location_RPC_helper helper{location_name};
9263 bool ok = yarp().write(helper, helper);
9264 return ok ? helper.reply.return_helper : return_get_location{};
9265}
9266
9267return_get_area IMap2DMsgs::get_area_RPC(const std::string& area_name)
9268{
9269 if (!yarp().canWrite()) {
9270 yError("Missing server method '%s'?", IMap2DMsgs_get_area_RPC_helper::s_prototype);
9271 }
9272 IMap2DMsgs_get_area_RPC_helper helper{area_name};
9273 bool ok = yarp().write(helper, helper);
9274 return ok ? helper.reply.return_helper : return_get_area{};
9275}
9276
9277return_get_path IMap2DMsgs::get_path_RPC(const std::string& path_name)
9278{
9279 if (!yarp().canWrite()) {
9280 yError("Missing server method '%s'?", IMap2DMsgs_get_path_RPC_helper::s_prototype);
9281 }
9282 IMap2DMsgs_get_path_RPC_helper helper{path_name};
9283 bool ok = yarp().write(helper, helper);
9284 return ok ? helper.reply.return_helper : return_get_path{};
9285}
9286
9288{
9289 if (!yarp().canWrite()) {
9290 yError("Missing server method '%s'?", IMap2DMsgs_get_objects_list_RPC_helper::s_prototype);
9291 }
9293 bool ok = yarp().write(helper, helper);
9294 return ok ? helper.reply.return_helper : return_get_objects_list{};
9295}
9296
9298{
9299 if (!yarp().canWrite()) {
9300 yError("Missing server method '%s'?", IMap2DMsgs_get_locations_list_RPC_helper::s_prototype);
9301 }
9303 bool ok = yarp().write(helper, helper);
9304 return ok ? helper.reply.return_helper : return_get_locations_list{};
9305}
9306
9308{
9309 if (!yarp().canWrite()) {
9310 yError("Missing server method '%s'?", IMap2DMsgs_get_areas_list_RPC_helper::s_prototype);
9311 }
9313 bool ok = yarp().write(helper, helper);
9314 return ok ? helper.reply.return_helper : return_get_areas_list{};
9315}
9316
9318{
9319 if (!yarp().canWrite()) {
9320 yError("Missing server method '%s'?", IMap2DMsgs_get_paths_list_RPC_helper::s_prototype);
9321 }
9323 bool ok = yarp().write(helper, helper);
9324 return ok ? helper.reply.return_helper : return_get_paths_list{};
9325}
9326
9328{
9329 if (!yarp().canWrite()) {
9330 yError("Missing server method '%s'?", IMap2DMsgs_get_all_objects_RPC_helper::s_prototype);
9331 }
9333 bool ok = yarp().write(helper, helper);
9334 return ok ? helper.reply.return_helper : return_get_all_objects{};
9335}
9336
9338{
9339 if (!yarp().canWrite()) {
9340 yError("Missing server method '%s'?", IMap2DMsgs_get_all_locations_RPC_helper::s_prototype);
9341 }
9343 bool ok = yarp().write(helper, helper);
9344 return ok ? helper.reply.return_helper : return_get_all_locations{};
9345}
9346
9348{
9349 if (!yarp().canWrite()) {
9350 yError("Missing server method '%s'?", IMap2DMsgs_get_all_areas_RPC_helper::s_prototype);
9351 }
9353 bool ok = yarp().write(helper, helper);
9354 return ok ? helper.reply.return_helper : return_get_all_areas{};
9355}
9356
9358{
9359 if (!yarp().canWrite()) {
9360 yError("Missing server method '%s'?", IMap2DMsgs_get_all_paths_RPC_helper::s_prototype);
9361 }
9363 bool ok = yarp().write(helper, helper);
9364 return ok ? helper.reply.return_helper : return_get_all_paths{};
9365}
9366
9367yarp::dev::ReturnValue IMap2DMsgs::rename_location_RPC(const std::string& original_name, const std::string& new_name)
9368{
9369 if (!yarp().canWrite()) {
9370 yError("Missing server method '%s'?", IMap2DMsgs_rename_location_RPC_helper::s_prototype);
9371 }
9372 IMap2DMsgs_rename_location_RPC_helper helper{original_name, new_name};
9373 bool ok = yarp().write(helper, helper);
9374 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
9375}
9376
9378{
9379 if (!yarp().canWrite()) {
9380 yError("Missing server method '%s'?", IMap2DMsgs_delete_object_RPC_helper::s_prototype);
9381 }
9382 IMap2DMsgs_delete_object_RPC_helper helper{object_name};
9383 bool ok = yarp().write(helper, helper);
9384 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
9385}
9386
9388{
9389 if (!yarp().canWrite()) {
9390 yError("Missing server method '%s'?", IMap2DMsgs_delete_location_RPC_helper::s_prototype);
9391 }
9392 IMap2DMsgs_delete_location_RPC_helper helper{location_name};
9393 bool ok = yarp().write(helper, helper);
9394 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
9395}
9396
9398{
9399 if (!yarp().canWrite()) {
9400 yError("Missing server method '%s'?", IMap2DMsgs_delete_path_RPC_helper::s_prototype);
9401 }
9402 IMap2DMsgs_delete_path_RPC_helper helper{path_name};
9403 bool ok = yarp().write(helper, helper);
9404 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
9405}
9406
9407yarp::dev::ReturnValue IMap2DMsgs::rename_object_RPC(const std::string& original_name, const std::string& new_name)
9408{
9409 if (!yarp().canWrite()) {
9410 yError("Missing server method '%s'?", IMap2DMsgs_rename_object_RPC_helper::s_prototype);
9411 }
9412 IMap2DMsgs_rename_object_RPC_helper helper{original_name, new_name};
9413 bool ok = yarp().write(helper, helper);
9414 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
9415}
9416
9417yarp::dev::ReturnValue IMap2DMsgs::rename_area_RPC(const std::string& original_name, const std::string& new_name)
9418{
9419 if (!yarp().canWrite()) {
9420 yError("Missing server method '%s'?", IMap2DMsgs_rename_area_RPC_helper::s_prototype);
9421 }
9422 IMap2DMsgs_rename_area_RPC_helper helper{original_name, new_name};
9423 bool ok = yarp().write(helper, helper);
9424 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
9425}
9426
9427yarp::dev::ReturnValue IMap2DMsgs::rename_path_RPC(const std::string& original_name, const std::string& new_name)
9428{
9429 if (!yarp().canWrite()) {
9430 yError("Missing server method '%s'?", IMap2DMsgs_rename_path_RPC_helper::s_prototype);
9431 }
9432 IMap2DMsgs_rename_path_RPC_helper helper{original_name, new_name};
9433 bool ok = yarp().write(helper, helper);
9434 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
9435}
9436
9438{
9439 if (!yarp().canWrite()) {
9440 yError("Missing server method '%s'?", IMap2DMsgs_delete_area_RPC_helper::s_prototype);
9441 }
9442 IMap2DMsgs_delete_area_RPC_helper helper{area_name};
9443 bool ok = yarp().write(helper, helper);
9444 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
9445}
9446
9448{
9449 if (!yarp().canWrite()) {
9450 yError("Missing server method '%s'?", IMap2DMsgs_clear_all_objects_RPC_helper::s_prototype);
9451 }
9453 bool ok = yarp().write(helper, helper);
9454 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
9455}
9456
9458{
9459 if (!yarp().canWrite()) {
9460 yError("Missing server method '%s'?", IMap2DMsgs_clear_all_locations_RPC_helper::s_prototype);
9461 }
9463 bool ok = yarp().write(helper, helper);
9464 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
9465}
9466
9468{
9469 if (!yarp().canWrite()) {
9470 yError("Missing server method '%s'?", IMap2DMsgs_clear_all_areas_RPC_helper::s_prototype);
9471 }
9473 bool ok = yarp().write(helper, helper);
9474 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
9475}
9476
9478{
9479 if (!yarp().canWrite()) {
9480 yError("Missing server method '%s'?", IMap2DMsgs_clear_all_paths_RPC_helper::s_prototype);
9481 }
9483 bool ok = yarp().write(helper, helper);
9484 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
9485}
9486
9488{
9489 if (!yarp().canWrite()) {
9491 }
9493 bool ok = yarp().write(helper, helper);
9494 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
9495}
9496
9498{
9499 if (!yarp().canWrite()) {
9501 }
9503 bool ok = yarp().write(helper, helper);
9504 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
9505}
9506
9507yarp::dev::ReturnValue IMap2DMsgs::save_maps_collection_RPC(const std::string& maps_collection_file)
9508{
9509 if (!yarp().canWrite()) {
9511 }
9512 IMap2DMsgs_save_maps_collection_RPC_helper helper{maps_collection_file};
9513 bool ok = yarp().write(helper, helper);
9514 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
9515}
9516
9517yarp::dev::ReturnValue IMap2DMsgs::load_maps_collection_RPC(const std::string& maps_collection_file)
9518{
9519 if (!yarp().canWrite()) {
9521 }
9522 IMap2DMsgs_load_maps_collection_RPC_helper helper{maps_collection_file};
9523 bool ok = yarp().write(helper, helper);
9524 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
9525}
9526
9527yarp::dev::ReturnValue IMap2DMsgs::save_locations_and_extras_RPC(const std::string& locations_collection_file)
9528{
9529 if (!yarp().canWrite()) {
9531 }
9532 IMap2DMsgs_save_locations_and_extras_RPC_helper helper{locations_collection_file};
9533 bool ok = yarp().write(helper, helper);
9534 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
9535}
9536
9537yarp::dev::ReturnValue IMap2DMsgs::load_locations_and_extras_RPC(const std::string& locations_collection_file)
9538{
9539 if (!yarp().canWrite()) {
9541 }
9542 IMap2DMsgs_load_locations_and_extras_RPC_helper helper{locations_collection_file};
9543 bool ok = yarp().write(helper, helper);
9544 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
9545}
9546
9547yarp::dev::ReturnValue IMap2DMsgs::save_map_to_disk_RPC(const std::string& map_name, const std::string& file_name)
9548{
9549 if (!yarp().canWrite()) {
9550 yError("Missing server method '%s'?", IMap2DMsgs_save_map_to_disk_RPC_helper::s_prototype);
9551 }
9552 IMap2DMsgs_save_map_to_disk_RPC_helper helper{map_name, file_name};
9553 bool ok = yarp().write(helper, helper);
9554 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
9555}
9556
9558{
9559 if (!yarp().canWrite()) {
9560 yError("Missing server method '%s'?", IMap2DMsgs_load_map_from_disk_RPC_helper::s_prototype);
9561 }
9563 bool ok = yarp().write(helper, helper);
9564 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
9565}
9566
9568{
9569 if (!yarp().canWrite()) {
9571 }
9572 IMap2DMsgs_enable_maps_compression_RPC_helper helper{enable_compression};
9573 bool ok = yarp().write(helper, helper);
9574 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
9575}
9576
9578{
9579 if (!yarp().canWrite()) {
9581 }
9583 bool ok = yarp().write(helper, helper);
9584 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
9585}
9586
9588{
9589 if (!yarp().canWrite()) {
9591 }
9593 bool ok = yarp().write(helper, helper);
9594 return ok ? helper.reply.return_helper : yarp::dev::ReturnValue{};
9595}
9596
9597// help method
9598std::vector<std::string> IMap2DMsgs::help(const std::string& functionName)
9599{
9600 bool showAll = (functionName == "--all");
9601 std::vector<std::string> helpString;
9602 if (showAll) {
9603 helpString.emplace_back("*** Available commands:");
9604 helpString.emplace_back(IMap2DMsgs_clear_all_maps_RPC_helper::s_tag);
9605 helpString.emplace_back(IMap2DMsgs_store_map_RPC_helper::s_tag);
9606 helpString.emplace_back(IMap2DMsgs_get_map_RPC_helper::s_tag);
9607 helpString.emplace_back(IMap2DMsgs_get_map_names_RPC_helper::s_tag);
9608 helpString.emplace_back(IMap2DMsgs_remove_map_RPC_helper::s_tag);
9609 helpString.emplace_back(IMap2DMsgs_store_object_RPC_helper::s_tag);
9610 helpString.emplace_back(IMap2DMsgs_store_location_RPC_helper::s_tag);
9611 helpString.emplace_back(IMap2DMsgs_store_area_RPC_helper::s_tag);
9612 helpString.emplace_back(IMap2DMsgs_store_path_RPC_helper::s_tag);
9613 helpString.emplace_back(IMap2DMsgs_get_object_RPC_helper::s_tag);
9614 helpString.emplace_back(IMap2DMsgs_get_location_RPC_helper::s_tag);
9615 helpString.emplace_back(IMap2DMsgs_get_area_RPC_helper::s_tag);
9616 helpString.emplace_back(IMap2DMsgs_get_path_RPC_helper::s_tag);
9617 helpString.emplace_back(IMap2DMsgs_get_objects_list_RPC_helper::s_tag);
9618 helpString.emplace_back(IMap2DMsgs_get_locations_list_RPC_helper::s_tag);
9619 helpString.emplace_back(IMap2DMsgs_get_areas_list_RPC_helper::s_tag);
9620 helpString.emplace_back(IMap2DMsgs_get_paths_list_RPC_helper::s_tag);
9621 helpString.emplace_back(IMap2DMsgs_get_all_objects_RPC_helper::s_tag);
9622 helpString.emplace_back(IMap2DMsgs_get_all_locations_RPC_helper::s_tag);
9623 helpString.emplace_back(IMap2DMsgs_get_all_areas_RPC_helper::s_tag);
9624 helpString.emplace_back(IMap2DMsgs_get_all_paths_RPC_helper::s_tag);
9625 helpString.emplace_back(IMap2DMsgs_rename_location_RPC_helper::s_tag);
9626 helpString.emplace_back(IMap2DMsgs_delete_object_RPC_helper::s_tag);
9627 helpString.emplace_back(IMap2DMsgs_delete_location_RPC_helper::s_tag);
9628 helpString.emplace_back(IMap2DMsgs_delete_path_RPC_helper::s_tag);
9629 helpString.emplace_back(IMap2DMsgs_rename_object_RPC_helper::s_tag);
9630 helpString.emplace_back(IMap2DMsgs_rename_area_RPC_helper::s_tag);
9631 helpString.emplace_back(IMap2DMsgs_rename_path_RPC_helper::s_tag);
9632 helpString.emplace_back(IMap2DMsgs_delete_area_RPC_helper::s_tag);
9633 helpString.emplace_back(IMap2DMsgs_clear_all_objects_RPC_helper::s_tag);
9634 helpString.emplace_back(IMap2DMsgs_clear_all_locations_RPC_helper::s_tag);
9635 helpString.emplace_back(IMap2DMsgs_clear_all_areas_RPC_helper::s_tag);
9636 helpString.emplace_back(IMap2DMsgs_clear_all_paths_RPC_helper::s_tag);
9643 helpString.emplace_back(IMap2DMsgs_save_map_to_disk_RPC_helper::s_tag);
9644 helpString.emplace_back(IMap2DMsgs_load_map_from_disk_RPC_helper::s_tag);
9648 helpString.emplace_back("help");
9649 } else {
9650 if (functionName == IMap2DMsgs_clear_all_maps_RPC_helper::s_tag) {
9652 }
9653 if (functionName == IMap2DMsgs_store_map_RPC_helper::s_tag) {
9654 helpString.emplace_back(IMap2DMsgs_store_map_RPC_helper::s_prototype);
9655 }
9656 if (functionName == IMap2DMsgs_get_map_RPC_helper::s_tag) {
9657 helpString.emplace_back(IMap2DMsgs_get_map_RPC_helper::s_prototype);
9658 }
9659 if (functionName == IMap2DMsgs_get_map_names_RPC_helper::s_tag) {
9660 helpString.emplace_back(IMap2DMsgs_get_map_names_RPC_helper::s_prototype);
9661 }
9662 if (functionName == IMap2DMsgs_remove_map_RPC_helper::s_tag) {
9663 helpString.emplace_back(IMap2DMsgs_remove_map_RPC_helper::s_prototype);
9664 }
9665 if (functionName == IMap2DMsgs_store_object_RPC_helper::s_tag) {
9666 helpString.emplace_back(IMap2DMsgs_store_object_RPC_helper::s_prototype);
9667 }
9668 if (functionName == IMap2DMsgs_store_location_RPC_helper::s_tag) {
9670 }
9671 if (functionName == IMap2DMsgs_store_area_RPC_helper::s_tag) {
9672 helpString.emplace_back(IMap2DMsgs_store_area_RPC_helper::s_prototype);
9673 }
9674 if (functionName == IMap2DMsgs_store_path_RPC_helper::s_tag) {
9675 helpString.emplace_back(IMap2DMsgs_store_path_RPC_helper::s_prototype);
9676 }
9677 if (functionName == IMap2DMsgs_get_object_RPC_helper::s_tag) {
9678 helpString.emplace_back(IMap2DMsgs_get_object_RPC_helper::s_prototype);
9679 }
9680 if (functionName == IMap2DMsgs_get_location_RPC_helper::s_tag) {
9681 helpString.emplace_back(IMap2DMsgs_get_location_RPC_helper::s_prototype);
9682 }
9683 if (functionName == IMap2DMsgs_get_area_RPC_helper::s_tag) {
9684 helpString.emplace_back(IMap2DMsgs_get_area_RPC_helper::s_prototype);
9685 }
9686 if (functionName == IMap2DMsgs_get_path_RPC_helper::s_tag) {
9687 helpString.emplace_back(IMap2DMsgs_get_path_RPC_helper::s_prototype);
9688 }
9691 }
9694 }
9695 if (functionName == IMap2DMsgs_get_areas_list_RPC_helper::s_tag) {
9697 }
9698 if (functionName == IMap2DMsgs_get_paths_list_RPC_helper::s_tag) {
9700 }
9703 }
9706 }
9707 if (functionName == IMap2DMsgs_get_all_areas_RPC_helper::s_tag) {
9708 helpString.emplace_back(IMap2DMsgs_get_all_areas_RPC_helper::s_prototype);
9709 }
9710 if (functionName == IMap2DMsgs_get_all_paths_RPC_helper::s_tag) {
9711 helpString.emplace_back(IMap2DMsgs_get_all_paths_RPC_helper::s_prototype);
9712 }
9715 }
9716 if (functionName == IMap2DMsgs_delete_object_RPC_helper::s_tag) {
9717 helpString.emplace_back(IMap2DMsgs_delete_object_RPC_helper::s_prototype);
9718 }
9721 }
9722 if (functionName == IMap2DMsgs_delete_path_RPC_helper::s_tag) {
9723 helpString.emplace_back(IMap2DMsgs_delete_path_RPC_helper::s_prototype);
9724 }
9725 if (functionName == IMap2DMsgs_rename_object_RPC_helper::s_tag) {
9726 helpString.emplace_back(IMap2DMsgs_rename_object_RPC_helper::s_prototype);
9727 }
9728 if (functionName == IMap2DMsgs_rename_area_RPC_helper::s_tag) {
9729 helpString.emplace_back(IMap2DMsgs_rename_area_RPC_helper::s_prototype);
9730 }
9731 if (functionName == IMap2DMsgs_rename_path_RPC_helper::s_tag) {
9732 helpString.emplace_back(IMap2DMsgs_rename_path_RPC_helper::s_prototype);
9733 }
9734 if (functionName == IMap2DMsgs_delete_area_RPC_helper::s_tag) {
9735 helpString.emplace_back(IMap2DMsgs_delete_area_RPC_helper::s_prototype);
9736 }
9739 }
9742 }
9745 }
9748 }
9751 }
9754 }
9757 }
9760 }
9763 }
9766 }
9769 }
9772 }
9775 }
9778 }
9781 }
9782 if (functionName == "help") {
9783 helpString.emplace_back("std::vector<std::string> help(const std::string& functionName = \"--all\")");
9784 helpString.emplace_back("Return list of available commands, or help message for a specific function");
9785 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");
9786 helpString.emplace_back("@return list of strings (one string per line)");
9787 }
9788 }
9789 if (helpString.empty()) {
9790 helpString.emplace_back("Command not found");
9791 }
9792 return helpString;
9793}
9794
9795// read from ConnectionReader
9797{
9798 constexpr size_t max_tag_len = 6;
9799 size_t tag_len = 1;
9800
9801 yarp::os::idl::WireReader reader(connection);
9802 reader.expectAccept();
9803 if (!reader.readListHeader()) {
9804 reader.fail();
9805 return false;
9806 }
9807
9808 std::string tag = reader.readTag(1);
9809 bool direct = (tag == "__direct__");
9810 if (direct) {
9811 tag = reader.readTag(1);
9812 }
9813 while (tag_len <= max_tag_len && !reader.isError()) {
9814 if(tag == "getRemoteProtocolVersion") {
9815 if (!reader.noMore()) {
9816 yError("Reader invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
9817 reader.fail();
9818 return false;
9819 }
9820
9821 auto proto = getLocalProtocolVersion();
9822
9823 yarp::os::idl::WireWriter writer(reader);
9824 if (!writer.writeListHeader(1)) {
9825 yWarning("Writer invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
9826 return false;}
9827 if (!writer.write(proto)) {
9828 yWarning("Writer invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
9829 return false;
9830 }
9831 reader.accept();
9832 return true;
9833 }
9836 if (!helper.cmd.readArgs(reader)) {
9837 return false;
9838 }
9839
9840 helper.call(this);
9841
9842 yarp::os::idl::WireWriter writer(reader);
9843 if (!helper.reply.write(writer)) {
9844 return false;
9845 }
9846 reader.accept();
9847 return true;
9848 }
9851 if (!helper.cmd.readArgs(reader)) {
9852 return false;
9853 }
9854
9855 helper.call(this);
9856
9857 yarp::os::idl::WireWriter writer(reader);
9858 if (!helper.reply.write(writer)) {
9859 return false;
9860 }
9861 reader.accept();
9862 return true;
9863 }
9866 if (!helper.cmd.readArgs(reader)) {
9867 return false;
9868 }
9869
9870 helper.call(this);
9871
9872 yarp::os::idl::WireWriter writer(reader);
9873 if (!helper.reply.write(writer)) {
9874 return false;
9875 }
9876 reader.accept();
9877 return true;
9878 }
9881 if (!helper.cmd.readArgs(reader)) {
9882 return false;
9883 }
9884
9885 helper.call(this);
9886
9887 yarp::os::idl::WireWriter writer(reader);
9888 if (!helper.reply.write(writer)) {
9889 return false;
9890 }
9891 reader.accept();
9892 return true;
9893 }
9896 if (!helper.cmd.readArgs(reader)) {
9897 return false;
9898 }
9899
9900 helper.call(this);
9901
9902 yarp::os::idl::WireWriter writer(reader);
9903 if (!helper.reply.write(writer)) {
9904 return false;
9905 }
9906 reader.accept();
9907 return true;
9908 }
9911 if (!helper.cmd.readArgs(reader)) {
9912 return false;
9913 }
9914
9915 helper.call(this);
9916
9917 yarp::os::idl::WireWriter writer(reader);
9918 if (!helper.reply.write(writer)) {
9919 return false;
9920 }
9921 reader.accept();
9922 return true;
9923 }
9926 if (!helper.cmd.readArgs(reader)) {
9927 return false;
9928 }
9929
9930 helper.call(this);
9931
9932 yarp::os::idl::WireWriter writer(reader);
9933 if (!helper.reply.write(writer)) {
9934 return false;
9935 }
9936 reader.accept();
9937 return true;
9938 }
9941 if (!helper.cmd.readArgs(reader)) {
9942 return false;
9943 }
9944
9945 helper.call(this);
9946
9947 yarp::os::idl::WireWriter writer(reader);
9948 if (!helper.reply.write(writer)) {
9949 return false;
9950 }
9951 reader.accept();
9952 return true;
9953 }
9956 if (!helper.cmd.readArgs(reader)) {
9957 return false;
9958 }
9959
9960 helper.call(this);
9961
9962 yarp::os::idl::WireWriter writer(reader);
9963 if (!helper.reply.write(writer)) {
9964 return false;
9965 }
9966 reader.accept();
9967 return true;
9968 }
9971 if (!helper.cmd.readArgs(reader)) {
9972 return false;
9973 }
9974
9975 helper.call(this);
9976
9977 yarp::os::idl::WireWriter writer(reader);
9978 if (!helper.reply.write(writer)) {
9979 return false;
9980 }
9981 reader.accept();
9982 return true;
9983 }
9986 if (!helper.cmd.readArgs(reader)) {
9987 return false;
9988 }
9989
9990 helper.call(this);
9991
9992 yarp::os::idl::WireWriter writer(reader);
9993 if (!helper.reply.write(writer)) {
9994 return false;
9995 }
9996 reader.accept();
9997 return true;
9998 }
10001 if (!helper.cmd.readArgs(reader)) {
10002 return false;
10003 }
10004
10005 helper.call(this);
10006
10007 yarp::os::idl::WireWriter writer(reader);
10008 if (!helper.reply.write(writer)) {
10009 return false;
10010 }
10011 reader.accept();
10012 return true;
10013 }
10016 if (!helper.cmd.readArgs(reader)) {
10017 return false;
10018 }
10019
10020 helper.call(this);
10021
10022 yarp::os::idl::WireWriter writer(reader);
10023 if (!helper.reply.write(writer)) {
10024 return false;
10025 }
10026 reader.accept();
10027 return true;
10028 }
10031 if (!helper.cmd.readArgs(reader)) {
10032 return false;
10033 }
10034
10035 helper.call(this);
10036
10037 yarp::os::idl::WireWriter writer(reader);
10038 if (!helper.reply.write(writer)) {
10039 return false;
10040 }
10041 reader.accept();
10042 return true;
10043 }
10046 if (!helper.cmd.readArgs(reader)) {
10047 return false;
10048 }
10049
10050 helper.call(this);
10051
10052 yarp::os::idl::WireWriter writer(reader);
10053 if (!helper.reply.write(writer)) {
10054 return false;
10055 }
10056 reader.accept();
10057 return true;
10058 }
10061 if (!helper.cmd.readArgs(reader)) {
10062 return false;
10063 }
10064
10065 helper.call(this);
10066
10067 yarp::os::idl::WireWriter writer(reader);
10068 if (!helper.reply.write(writer)) {
10069 return false;
10070 }
10071 reader.accept();
10072 return true;
10073 }
10076 if (!helper.cmd.readArgs(reader)) {
10077 return false;
10078 }
10079
10080 helper.call(this);
10081
10082 yarp::os::idl::WireWriter writer(reader);
10083 if (!helper.reply.write(writer)) {
10084 return false;
10085 }
10086 reader.accept();
10087 return true;
10088 }
10091 if (!helper.cmd.readArgs(reader)) {
10092 return false;
10093 }
10094
10095 helper.call(this);
10096
10097 yarp::os::idl::WireWriter writer(reader);
10098 if (!helper.reply.write(writer)) {
10099 return false;
10100 }
10101 reader.accept();
10102 return true;
10103 }
10106 if (!helper.cmd.readArgs(reader)) {
10107 return false;
10108 }
10109
10110 helper.call(this);
10111
10112 yarp::os::idl::WireWriter writer(reader);
10113 if (!helper.reply.write(writer)) {
10114 return false;
10115 }
10116 reader.accept();
10117 return true;
10118 }
10121 if (!helper.cmd.readArgs(reader)) {
10122 return false;
10123 }
10124
10125 helper.call(this);
10126
10127 yarp::os::idl::WireWriter writer(reader);
10128 if (!helper.reply.write(writer)) {
10129 return false;
10130 }
10131 reader.accept();
10132 return true;
10133 }
10136 if (!helper.cmd.readArgs(reader)) {
10137 return false;
10138 }
10139
10140 helper.call(this);
10141
10142 yarp::os::idl::WireWriter writer(reader);
10143 if (!helper.reply.write(writer)) {
10144 return false;
10145 }
10146 reader.accept();
10147 return true;
10148 }
10151 if (!helper.cmd.readArgs(reader)) {
10152 return false;
10153 }
10154
10155 helper.call(this);
10156
10157 yarp::os::idl::WireWriter writer(reader);
10158 if (!helper.reply.write(writer)) {
10159 return false;
10160 }
10161 reader.accept();
10162 return true;
10163 }
10166 if (!helper.cmd.readArgs(reader)) {
10167 return false;
10168 }
10169
10170 helper.call(this);
10171
10172 yarp::os::idl::WireWriter writer(reader);
10173 if (!helper.reply.write(writer)) {
10174 return false;
10175 }
10176 reader.accept();
10177 return true;
10178 }
10181 if (!helper.cmd.readArgs(reader)) {
10182 return false;
10183 }
10184
10185 helper.call(this);
10186
10187 yarp::os::idl::WireWriter writer(reader);
10188 if (!helper.reply.write(writer)) {
10189 return false;
10190 }
10191 reader.accept();
10192 return true;
10193 }
10196 if (!helper.cmd.readArgs(reader)) {
10197 return false;
10198 }
10199
10200 helper.call(this);
10201
10202 yarp::os::idl::WireWriter writer(reader);
10203 if (!helper.reply.write(writer)) {
10204 return false;
10205 }
10206 reader.accept();
10207 return true;
10208 }
10211 if (!helper.cmd.readArgs(reader)) {
10212 return false;
10213 }
10214
10215 helper.call(this);
10216
10217 yarp::os::idl::WireWriter writer(reader);
10218 if (!helper.reply.write(writer)) {
10219 return false;
10220 }
10221 reader.accept();
10222 return true;
10223 }
10226 if (!helper.cmd.readArgs(reader)) {
10227 return false;
10228 }
10229
10230 helper.call(this);
10231
10232 yarp::os::idl::WireWriter writer(reader);
10233 if (!helper.reply.write(writer)) {
10234 return false;
10235 }
10236 reader.accept();
10237 return true;
10238 }
10241 if (!helper.cmd.readArgs(reader)) {
10242 return false;
10243 }
10244
10245 helper.call(this);
10246
10247 yarp::os::idl::WireWriter writer(reader);
10248 if (!helper.reply.write(writer)) {
10249 return false;
10250 }
10251 reader.accept();
10252 return true;
10253 }
10256 if (!helper.cmd.readArgs(reader)) {
10257 return false;
10258 }
10259
10260 helper.call(this);
10261
10262 yarp::os::idl::WireWriter writer(reader);
10263 if (!helper.reply.write(writer)) {
10264 return false;
10265 }
10266 reader.accept();
10267 return true;
10268 }
10271 if (!helper.cmd.readArgs(reader)) {
10272 return false;
10273 }
10274
10275 helper.call(this);
10276
10277 yarp::os::idl::WireWriter writer(reader);
10278 if (!helper.reply.write(writer)) {
10279 return false;
10280 }
10281 reader.accept();
10282 return true;
10283 }
10286 if (!helper.cmd.readArgs(reader)) {
10287 return false;
10288 }
10289
10290 helper.call(this);
10291
10292 yarp::os::idl::WireWriter writer(reader);
10293 if (!helper.reply.write(writer)) {
10294 return false;
10295 }
10296 reader.accept();
10297 return true;
10298 }
10301 if (!helper.cmd.readArgs(reader)) {
10302 return false;
10303 }
10304
10305 helper.call(this);
10306
10307 yarp::os::idl::WireWriter writer(reader);
10308 if (!helper.reply.write(writer)) {
10309 return false;
10310 }
10311 reader.accept();
10312 return true;
10313 }
10316 if (!helper.cmd.readArgs(reader)) {
10317 return false;
10318 }
10319
10320 helper.call(this);
10321
10322 yarp::os::idl::WireWriter writer(reader);
10323 if (!helper.reply.write(writer)) {
10324 return false;
10325 }
10326 reader.accept();
10327 return true;
10328 }
10331 if (!helper.cmd.readArgs(reader)) {
10332 return false;
10333 }
10334
10335 helper.call(this);
10336
10337 yarp::os::idl::WireWriter writer(reader);
10338 if (!helper.reply.write(writer)) {
10339 return false;
10340 }
10341 reader.accept();
10342 return true;
10343 }
10346 if (!helper.cmd.readArgs(reader)) {
10347 return false;
10348 }
10349
10350 helper.call(this);
10351
10352 yarp::os::idl::WireWriter writer(reader);
10353 if (!helper.reply.write(writer)) {
10354 return false;
10355 }
10356 reader.accept();
10357 return true;
10358 }
10361 if (!helper.cmd.readArgs(reader)) {
10362 return false;
10363 }
10364
10365 helper.call(this);
10366
10367 yarp::os::idl::WireWriter writer(reader);
10368 if (!helper.reply.write(writer)) {
10369 return false;
10370 }
10371 reader.accept();
10372 return true;
10373 }
10376 if (!helper.cmd.readArgs(reader)) {
10377 return false;
10378 }
10379
10380 helper.call(this);
10381
10382 yarp::os::idl::WireWriter writer(reader);
10383 if (!helper.reply.write(writer)) {
10384 return false;
10385 }
10386 reader.accept();
10387 return true;
10388 }
10391 if (!helper.cmd.readArgs(reader)) {
10392 return false;
10393 }
10394
10395 helper.call(this);
10396
10397 yarp::os::idl::WireWriter writer(reader);
10398 if (!helper.reply.write(writer)) {
10399 return false;
10400 }
10401 reader.accept();
10402 return true;
10403 }
10406 if (!helper.cmd.readArgs(reader)) {
10407 return false;
10408 }
10409
10410 helper.call(this);
10411
10412 yarp::os::idl::WireWriter writer(reader);
10413 if (!helper.reply.write(writer)) {
10414 return false;
10415 }
10416 reader.accept();
10417 return true;
10418 }
10421 if (!helper.cmd.readArgs(reader)) {
10422 return false;
10423 }
10424
10425 helper.call(this);
10426
10427 yarp::os::idl::WireWriter writer(reader);
10428 if (!helper.reply.write(writer)) {
10429 return false;
10430 }
10431 reader.accept();
10432 return true;
10433 }
10436 if (!helper.cmd.readArgs(reader)) {
10437 return false;
10438 }
10439
10440 helper.call(this);
10441
10442 yarp::os::idl::WireWriter writer(reader);
10443 if (!helper.reply.write(writer)) {
10444 return false;
10445 }
10446 reader.accept();
10447 return true;
10448 }
10451 if (!helper.cmd.readArgs(reader)) {
10452 return false;
10453 }
10454
10455 helper.call(this);
10456
10457 yarp::os::idl::WireWriter writer(reader);
10458 if (!helper.reply.write(writer)) {
10459 return false;
10460 }
10461 reader.accept();
10462 return true;
10463 }
10466 if (!helper.cmd.readArgs(reader)) {
10467 return false;
10468 }
10469
10470 helper.call(this);
10471
10472 yarp::os::idl::WireWriter writer(reader);
10473 if (!helper.reply.write(writer)) {
10474 return false;
10475 }
10476 reader.accept();
10477 return true;
10478 }
10481 if (!helper.cmd.readArgs(reader)) {
10482 return false;
10483 }
10484
10485 helper.call(this);
10486
10487 yarp::os::idl::WireWriter writer(reader);
10488 if (!helper.reply.write(writer)) {
10489 return false;
10490 }
10491 reader.accept();
10492 return true;
10493 }
10494 if (tag == "help") {
10495 std::string functionName;
10496 if (!reader.readString(functionName)) {
10497 functionName = "--all";
10498 }
10499 auto help_strings = help(functionName);
10500 yarp::os::idl::WireWriter writer(reader);
10501 if (!writer.isNull()) {
10502 if (!writer.writeListHeader(2)) {
10503 return false;
10504 }
10505 if (!writer.writeTag("many", 1, 0)) {
10506 return false;
10507 }
10508 if (!writer.writeListBegin(0, help_strings.size())) {
10509 return false;
10510 }
10511 for (const auto& help_string : help_strings) {
10512 if (!writer.writeString(help_string)) {
10513 return false;
10514 }
10515 }
10516 if (!writer.writeListEnd()) {
10517 return false;
10518 }
10519 }
10520 reader.accept();
10521 return true;
10522 }
10523 if (reader.noMore()) {
10524 reader.fail();
10525 return false;
10526 }
10527 std::string next_tag = reader.readTag(1);
10528 if (next_tag.empty()) {
10529 break;
10530 }
10531 tag.append("_").append(next_tag);
10532 tag_len = std::count(tag.begin(), tag.end(), '_') + 1;
10533 }
10534 return false;
10535}
#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()
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