YARP
Yet Another Robot Platform
 
Loading...
Searching...
No Matches
FakeBatteryService.cpp
Go to the documentation of this file.
1/*
2 * SPDX-FileCopyrightText: 2006-2021 Istituto Italiano di Tecnologia (IIT)
3 * SPDX-License-Identifier: BSD-3-Clause
4 */
5
6// Autogenerated by Thrift (based on compiler 0.14.1-yarped)
7// yarpidl_thrift version 2.0 - 11/11/2026
8// Protocol version: protocol_version=0, yarp_major=4, yarp_minor=0, yarp_patch=2
9// This is an automatically generated file.
10// It could get re-generated if the ALLOW_IDL_GENERATION flag is on.
11
12#include <yarp/conf/version.h>
13#include <FakeBatteryService.h>
15#include <yarp/os/LogStream.h>
16
18
19#include <algorithm>
20
21namespace
22{
23 YARP_LOG_COMPONENT(SERVICE_LOG_COMPONENT, "FakeBatteryService")
24}
25
26//FakeBatteryService_getRemoteProtocolVersion_helper declaration
37
39{
40 yarp::os::idl::WireWriter writer(connection);
41 if (!writer.writeListHeader(1)) {
42 return false;
43 }
44 if (!writer.writeString("getRemoteProtocolVersion")) {
45 return false;
46 }
47 return true;
48}
49
50bool FakeBatteryService_getRemoteProtocolVersion_helper ::read(yarp::os::ConnectionReader & connection)
51 {
52 yarp::os::idl::WireReader reader(connection);
53 if (!reader.readListHeader()) {
54 reader.fail();
55 return false;
56 }
57
58 if (!helper_proto.read(connection)) {
59 reader.fail();
60 return false;
61 }
62 return true;
63}
64
65//ProtocolVersion, client side
67 {
68 if(!yarp().canWrite()) {
69 yError(" Missing server method FakeBatteryService::getRemoteProtocolVersion");
70 }
72 bool ok = yarp().write(helper, helper);
73 if (ok) {
74 return helper.helper_proto;}
75 else {
77 return failureproto;}
78}
79
80//ProtocolVersion, client side
82 {
83 auto locproto = this->getLocalProtocolVersion();
84 auto remproto = this->getRemoteProtocolVersion();
85 if (remproto.protocol_version != locproto.protocol_version)
86 {
87 yCError(SERVICE_LOG_COMPONENT) << "Invalid communication protocol.";
88 yCError(SERVICE_LOG_COMPONENT) << "Local Protocol Version: " << locproto.toString();
89 yCError(SERVICE_LOG_COMPONENT) << "Remote Protocol Version: " << remproto.toString();
90 return false;
91 }
92 return true;
93}
94
95//ProtocolVersion, server side
97{
99 //myproto.protocol_version using default value = 0
100 //to change this value add the following line to the .thrift file:
101 //const i16 protocol_version = <your_number_here>
102 myproto.protocol_version = 0;
106 return myproto;
107}
108
109// setBatteryVoltage helper class declaration
111 public yarp::os::Portable
112{
113public:
115 explicit FakeBatteryService_setBatteryVoltage_helper(const double voltage);
116 bool write(yarp::os::ConnectionWriter& connection) const override;
117 bool read(yarp::os::ConnectionReader& connection) override;
118
119 class Command :
121 {
122 public:
123 Command() = default;
124 explicit Command(const double voltage);
125
126 ~Command() override = default;
127
128 bool write(yarp::os::ConnectionWriter& connection) const override;
129 bool read(yarp::os::ConnectionReader& connection) override;
130
131 bool write(const yarp::os::idl::WireWriter& writer) const override;
132 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
133 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
134
135 bool read(yarp::os::idl::WireReader& reader) override;
138
139 double voltage{0.0};
140 };
141
142 class Reply :
144 {
145 public:
146 Reply() = default;
147 ~Reply() override = default;
148
149 bool write(yarp::os::ConnectionWriter& connection) const override;
150 bool read(yarp::os::ConnectionReader& connection) override;
151
152 bool write(const yarp::os::idl::WireWriter& writer) const override;
153 bool read(yarp::os::idl::WireReader& reader) override;
154 };
155
156 using funcptr_t = void (*)(const double);
157 void call(FakeBatteryService* ptr) const;
158
161
162 static constexpr const char* s_tag{"setBatteryVoltage"};
163 static constexpr size_t s_tag_len{1};
164 static constexpr size_t s_cmd_len{2};
165 static constexpr size_t s_reply_len{0};
166 static constexpr const char* s_prototype{"void FakeBatteryService::setBatteryVoltage(const double voltage)"};
167 static constexpr const char* s_help{""};
168};
169
170// setBatteryCurrent helper class declaration
172 public yarp::os::Portable
173{
174public:
176 explicit FakeBatteryService_setBatteryCurrent_helper(const double current);
177 bool write(yarp::os::ConnectionWriter& connection) const override;
178 bool read(yarp::os::ConnectionReader& connection) override;
179
180 class Command :
182 {
183 public:
184 Command() = default;
185 explicit Command(const double current);
186
187 ~Command() override = default;
188
189 bool write(yarp::os::ConnectionWriter& connection) const override;
190 bool read(yarp::os::ConnectionReader& connection) override;
191
192 bool write(const yarp::os::idl::WireWriter& writer) const override;
193 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
194 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
195
196 bool read(yarp::os::idl::WireReader& reader) override;
199
200 double current{0.0};
201 };
202
203 class Reply :
205 {
206 public:
207 Reply() = default;
208 ~Reply() override = default;
209
210 bool write(yarp::os::ConnectionWriter& connection) const override;
211 bool read(yarp::os::ConnectionReader& connection) override;
212
213 bool write(const yarp::os::idl::WireWriter& writer) const override;
214 bool read(yarp::os::idl::WireReader& reader) override;
215 };
216
217 using funcptr_t = void (*)(const double);
218 void call(FakeBatteryService* ptr) const;
219
222
223 static constexpr const char* s_tag{"setBatteryCurrent"};
224 static constexpr size_t s_tag_len{1};
225 static constexpr size_t s_cmd_len{2};
226 static constexpr size_t s_reply_len{0};
227 static constexpr const char* s_prototype{"void FakeBatteryService::setBatteryCurrent(const double current)"};
228 static constexpr const char* s_help{""};
229};
230
231// setBatteryCharge helper class declaration
233 public yarp::os::Portable
234{
235public:
237 explicit FakeBatteryService_setBatteryCharge_helper(const double charge);
238 bool write(yarp::os::ConnectionWriter& connection) const override;
239 bool read(yarp::os::ConnectionReader& connection) override;
240
241 class Command :
243 {
244 public:
245 Command() = default;
246 explicit Command(const double charge);
247
248 ~Command() override = default;
249
250 bool write(yarp::os::ConnectionWriter& connection) const override;
251 bool read(yarp::os::ConnectionReader& connection) override;
252
253 bool write(const yarp::os::idl::WireWriter& writer) const override;
254 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
255 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
256
257 bool read(yarp::os::idl::WireReader& reader) override;
260
261 double charge{0.0};
262 };
263
264 class Reply :
266 {
267 public:
268 Reply() = default;
269 ~Reply() override = default;
270
271 bool write(yarp::os::ConnectionWriter& connection) const override;
272 bool read(yarp::os::ConnectionReader& connection) override;
273
274 bool write(const yarp::os::idl::WireWriter& writer) const override;
275 bool read(yarp::os::idl::WireReader& reader) override;
276 };
277
278 using funcptr_t = void (*)(const double);
279 void call(FakeBatteryService* ptr) const;
280
283
284 static constexpr const char* s_tag{"setBatteryCharge"};
285 static constexpr size_t s_tag_len{1};
286 static constexpr size_t s_cmd_len{2};
287 static constexpr size_t s_reply_len{0};
288 static constexpr const char* s_prototype{"void FakeBatteryService::setBatteryCharge(const double charge)"};
289 static constexpr const char* s_help{""};
290};
291
292// setBatteryStatus helper class declaration
294 public yarp::os::Portable
295{
296public:
299 bool write(yarp::os::ConnectionWriter& connection) const override;
300 bool read(yarp::os::ConnectionReader& connection) override;
301
302 class Command :
304 {
305 public:
306 Command() = default;
308
309 ~Command() override = default;
310
311 bool write(yarp::os::ConnectionWriter& connection) const override;
312 bool read(yarp::os::ConnectionReader& connection) override;
313
314 bool write(const yarp::os::idl::WireWriter& writer) const override;
315 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
316 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
317
318 bool read(yarp::os::idl::WireReader& reader) override;
321
323 };
324
325 class Reply :
327 {
328 public:
329 Reply() = default;
330 ~Reply() override = default;
331
332 bool write(yarp::os::ConnectionWriter& connection) const override;
333 bool read(yarp::os::ConnectionReader& connection) override;
334
335 bool write(const yarp::os::idl::WireWriter& writer) const override;
336 bool read(yarp::os::idl::WireReader& reader) override;
337 };
338
340 void call(FakeBatteryService* ptr) const;
341
344
345 static constexpr const char* s_tag{"setBatteryStatus"};
346 static constexpr size_t s_tag_len{1};
347 static constexpr size_t s_cmd_len{2};
348 static constexpr size_t s_reply_len{0};
349 static constexpr const char* s_prototype{"void FakeBatteryService::setBatteryStatus(const yarp::dev::IBattery::Battery_status status)"};
350 static constexpr const char* s_help{""};
351};
352
353// setBatteryInfo helper class declaration
355 public yarp::os::Portable
356{
357public:
359 explicit FakeBatteryService_setBatteryInfo_helper(const std::string& info);
360 bool write(yarp::os::ConnectionWriter& connection) const override;
361 bool read(yarp::os::ConnectionReader& connection) override;
362
363 class Command :
365 {
366 public:
367 Command() = default;
368 explicit Command(const std::string& info);
369
370 ~Command() override = default;
371
372 bool write(yarp::os::ConnectionWriter& connection) const override;
373 bool read(yarp::os::ConnectionReader& connection) override;
374
375 bool write(const yarp::os::idl::WireWriter& writer) const override;
376 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
377 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
378
379 bool read(yarp::os::idl::WireReader& reader) override;
382
383 std::string info{};
384 };
385
386 class Reply :
388 {
389 public:
390 Reply() = default;
391 ~Reply() override = default;
392
393 bool write(yarp::os::ConnectionWriter& connection) const override;
394 bool read(yarp::os::ConnectionReader& connection) override;
395
396 bool write(const yarp::os::idl::WireWriter& writer) const override;
397 bool read(yarp::os::idl::WireReader& reader) override;
398 };
399
400 using funcptr_t = void (*)(const std::string&);
401 void call(FakeBatteryService* ptr) const;
402
405
406 static constexpr const char* s_tag{"setBatteryInfo"};
407 static constexpr size_t s_tag_len{1};
408 static constexpr size_t s_cmd_len{2};
409 static constexpr size_t s_reply_len{0};
410 static constexpr const char* s_prototype{"void FakeBatteryService::setBatteryInfo(const std::string& info)"};
411 static constexpr const char* s_help{""};
412};
413
414// setBatteryTemperature helper class declaration
416 public yarp::os::Portable
417{
418public:
420 explicit FakeBatteryService_setBatteryTemperature_helper(const double temperature);
421 bool write(yarp::os::ConnectionWriter& connection) const override;
422 bool read(yarp::os::ConnectionReader& connection) override;
423
424 class Command :
426 {
427 public:
428 Command() = default;
429 explicit Command(const double temperature);
430
431 ~Command() override = default;
432
433 bool write(yarp::os::ConnectionWriter& connection) const override;
434 bool read(yarp::os::ConnectionReader& connection) override;
435
436 bool write(const yarp::os::idl::WireWriter& writer) const override;
437 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
438 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
439
440 bool read(yarp::os::idl::WireReader& reader) override;
443
444 double temperature{0.0};
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 };
460
461 using funcptr_t = void (*)(const double);
462 void call(FakeBatteryService* ptr) const;
463
466
467 static constexpr const char* s_tag{"setBatteryTemperature"};
468 static constexpr size_t s_tag_len{1};
469 static constexpr size_t s_cmd_len{2};
470 static constexpr size_t s_reply_len{0};
471 static constexpr const char* s_prototype{"void FakeBatteryService::setBatteryTemperature(const double temperature)"};
472 static constexpr const char* s_help{""};
473};
474
475// getBatteryVoltage helper class declaration
477 public yarp::os::Portable
478{
479public:
481 bool write(yarp::os::ConnectionWriter& connection) const override;
482 bool read(yarp::os::ConnectionReader& connection) override;
483
484 class Command :
486 {
487 public:
488 Command() = default;
489 ~Command() override = default;
490
491 bool write(yarp::os::ConnectionWriter& connection) const override;
492 bool read(yarp::os::ConnectionReader& connection) override;
493
494 bool write(const yarp::os::idl::WireWriter& writer) const override;
495 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
496 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
497
498 bool read(yarp::os::idl::WireReader& reader) override;
501 };
502
503 class Reply :
505 {
506 public:
507 Reply() = default;
508 ~Reply() override = default;
509
510 bool write(yarp::os::ConnectionWriter& connection) const override;
511 bool read(yarp::os::ConnectionReader& connection) override;
512
513 bool write(const yarp::os::idl::WireWriter& writer) const override;
514 bool read(yarp::os::idl::WireReader& reader) override;
515
516 double return_helper{0.0};
517 };
518
519 using funcptr_t = double (*)();
520 void call(FakeBatteryService* ptr);
521
524
525 static constexpr const char* s_tag{"getBatteryVoltage"};
526 static constexpr size_t s_tag_len{1};
527 static constexpr size_t s_cmd_len{1};
528 static constexpr size_t s_reply_len{1};
529 static constexpr const char* s_prototype{"double FakeBatteryService::getBatteryVoltage()"};
530 static constexpr const char* s_help{""};
531};
532
533// getBatteryCurrent helper class declaration
535 public yarp::os::Portable
536{
537public:
539 bool write(yarp::os::ConnectionWriter& connection) const override;
540 bool read(yarp::os::ConnectionReader& connection) override;
541
542 class Command :
544 {
545 public:
546 Command() = default;
547 ~Command() override = default;
548
549 bool write(yarp::os::ConnectionWriter& connection) const override;
550 bool read(yarp::os::ConnectionReader& connection) override;
551
552 bool write(const yarp::os::idl::WireWriter& writer) const override;
553 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
554 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
555
556 bool read(yarp::os::idl::WireReader& reader) override;
559 };
560
561 class Reply :
563 {
564 public:
565 Reply() = default;
566 ~Reply() override = default;
567
568 bool write(yarp::os::ConnectionWriter& connection) const override;
569 bool read(yarp::os::ConnectionReader& connection) override;
570
571 bool write(const yarp::os::idl::WireWriter& writer) const override;
572 bool read(yarp::os::idl::WireReader& reader) override;
573
574 double return_helper{0.0};
575 };
576
577 using funcptr_t = double (*)();
578 void call(FakeBatteryService* ptr);
579
582
583 static constexpr const char* s_tag{"getBatteryCurrent"};
584 static constexpr size_t s_tag_len{1};
585 static constexpr size_t s_cmd_len{1};
586 static constexpr size_t s_reply_len{1};
587 static constexpr const char* s_prototype{"double FakeBatteryService::getBatteryCurrent()"};
588 static constexpr const char* s_help{""};
589};
590
591// getBatteryCharge helper class declaration
593 public yarp::os::Portable
594{
595public:
597 bool write(yarp::os::ConnectionWriter& connection) const override;
598 bool read(yarp::os::ConnectionReader& connection) override;
599
600 class Command :
602 {
603 public:
604 Command() = default;
605 ~Command() override = default;
606
607 bool write(yarp::os::ConnectionWriter& connection) const override;
608 bool read(yarp::os::ConnectionReader& connection) override;
609
610 bool write(const yarp::os::idl::WireWriter& writer) const override;
611 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
612 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
613
614 bool read(yarp::os::idl::WireReader& reader) override;
617 };
618
619 class Reply :
621 {
622 public:
623 Reply() = default;
624 ~Reply() override = default;
625
626 bool write(yarp::os::ConnectionWriter& connection) const override;
627 bool read(yarp::os::ConnectionReader& connection) override;
628
629 bool write(const yarp::os::idl::WireWriter& writer) const override;
630 bool read(yarp::os::idl::WireReader& reader) override;
631
632 double return_helper{0.0};
633 };
634
635 using funcptr_t = double (*)();
636 void call(FakeBatteryService* ptr);
637
640
641 static constexpr const char* s_tag{"getBatteryCharge"};
642 static constexpr size_t s_tag_len{1};
643 static constexpr size_t s_cmd_len{1};
644 static constexpr size_t s_reply_len{1};
645 static constexpr const char* s_prototype{"double FakeBatteryService::getBatteryCharge()"};
646 static constexpr const char* s_help{""};
647};
648
649// getBatteryStatus helper class declaration
651 public yarp::os::Portable
652{
653public:
655 bool write(yarp::os::ConnectionWriter& connection) const override;
656 bool read(yarp::os::ConnectionReader& connection) override;
657
658 class Command :
660 {
661 public:
662 Command() = default;
663 ~Command() override = default;
664
665 bool write(yarp::os::ConnectionWriter& connection) const override;
666 bool read(yarp::os::ConnectionReader& connection) override;
667
668 bool write(const yarp::os::idl::WireWriter& writer) const override;
669 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
670 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
671
672 bool read(yarp::os::idl::WireReader& reader) override;
675 };
676
677 class Reply :
679 {
680 public:
681 Reply() = default;
682 ~Reply() override = default;
683
684 bool write(yarp::os::ConnectionWriter& connection) const override;
685 bool read(yarp::os::ConnectionReader& connection) override;
686
687 bool write(const yarp::os::idl::WireWriter& writer) const override;
688 bool read(yarp::os::idl::WireReader& reader) override;
689
691 };
692
694 void call(FakeBatteryService* ptr);
695
698
699 static constexpr const char* s_tag{"getBatteryStatus"};
700 static constexpr size_t s_tag_len{1};
701 static constexpr size_t s_cmd_len{1};
702 static constexpr size_t s_reply_len{1};
703 static constexpr const char* s_prototype{"yarp::dev::IBattery::Battery_status FakeBatteryService::getBatteryStatus()"};
704 static constexpr const char* s_help{""};
705};
706
707// getBatteryStatusString helper class declaration
709 public yarp::os::Portable
710{
711public:
713 bool write(yarp::os::ConnectionWriter& connection) const override;
714 bool read(yarp::os::ConnectionReader& connection) override;
715
716 class Command :
718 {
719 public:
720 Command() = default;
721 ~Command() override = default;
722
723 bool write(yarp::os::ConnectionWriter& connection) const override;
724 bool read(yarp::os::ConnectionReader& connection) override;
725
726 bool write(const yarp::os::idl::WireWriter& writer) const override;
727 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
728 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
729
730 bool read(yarp::os::idl::WireReader& reader) override;
733 };
734
735 class Reply :
737 {
738 public:
739 Reply() = default;
740 ~Reply() override = default;
741
742 bool write(yarp::os::ConnectionWriter& connection) const override;
743 bool read(yarp::os::ConnectionReader& connection) override;
744
745 bool write(const yarp::os::idl::WireWriter& writer) const override;
746 bool read(yarp::os::idl::WireReader& reader) override;
747
748 std::string return_helper{};
749 };
750
751 using funcptr_t = std::string (*)();
752 void call(FakeBatteryService* ptr);
753
756
757 static constexpr const char* s_tag{"getBatteryStatusString"};
758 static constexpr size_t s_tag_len{1};
759 static constexpr size_t s_cmd_len{1};
760 static constexpr size_t s_reply_len{1};
761 static constexpr const char* s_prototype{"std::string FakeBatteryService::getBatteryStatusString()"};
762 static constexpr const char* s_help{""};
763};
764
765// getBatteryInfo helper class declaration
767 public yarp::os::Portable
768{
769public:
771 bool write(yarp::os::ConnectionWriter& connection) const override;
772 bool read(yarp::os::ConnectionReader& connection) override;
773
774 class Command :
776 {
777 public:
778 Command() = default;
779 ~Command() override = default;
780
781 bool write(yarp::os::ConnectionWriter& connection) const override;
782 bool read(yarp::os::ConnectionReader& connection) override;
783
784 bool write(const yarp::os::idl::WireWriter& writer) const override;
785 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
786 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
787
788 bool read(yarp::os::idl::WireReader& reader) override;
791 };
792
793 class Reply :
795 {
796 public:
797 Reply() = default;
798 ~Reply() override = default;
799
800 bool write(yarp::os::ConnectionWriter& connection) const override;
801 bool read(yarp::os::ConnectionReader& connection) override;
802
803 bool write(const yarp::os::idl::WireWriter& writer) const override;
804 bool read(yarp::os::idl::WireReader& reader) override;
805
806 std::string return_helper{};
807 };
808
809 using funcptr_t = std::string (*)();
810 void call(FakeBatteryService* ptr);
811
814
815 static constexpr const char* s_tag{"getBatteryInfo"};
816 static constexpr size_t s_tag_len{1};
817 static constexpr size_t s_cmd_len{1};
818 static constexpr size_t s_reply_len{1};
819 static constexpr const char* s_prototype{"std::string FakeBatteryService::getBatteryInfo()"};
820 static constexpr const char* s_help{""};
821};
822
823// getBatteryTemperature helper class declaration
825 public yarp::os::Portable
826{
827public:
829 bool write(yarp::os::ConnectionWriter& connection) const override;
830 bool read(yarp::os::ConnectionReader& connection) override;
831
832 class Command :
834 {
835 public:
836 Command() = default;
837 ~Command() override = default;
838
839 bool write(yarp::os::ConnectionWriter& connection) const override;
840 bool read(yarp::os::ConnectionReader& connection) override;
841
842 bool write(const yarp::os::idl::WireWriter& writer) const override;
843 bool writeTag(const yarp::os::idl::WireWriter& writer) const;
844 bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
845
846 bool read(yarp::os::idl::WireReader& reader) override;
849 };
850
851 class Reply :
853 {
854 public:
855 Reply() = default;
856 ~Reply() override = default;
857
858 bool write(yarp::os::ConnectionWriter& connection) const override;
859 bool read(yarp::os::ConnectionReader& connection) override;
860
861 bool write(const yarp::os::idl::WireWriter& writer) const override;
862 bool read(yarp::os::idl::WireReader& reader) override;
863
864 double return_helper{0.0};
865 };
866
867 using funcptr_t = double (*)();
868 void call(FakeBatteryService* ptr);
869
872
873 static constexpr const char* s_tag{"getBatteryTemperature"};
874 static constexpr size_t s_tag_len{1};
875 static constexpr size_t s_cmd_len{1};
876 static constexpr size_t s_reply_len{1};
877 static constexpr const char* s_prototype{"double FakeBatteryService::getBatteryTemperature()"};
878 static constexpr const char* s_help{""};
879};
880
881// setBatteryVoltage helper class implementation
886
888{
889 return cmd.write(connection);
890}
891
896
898 voltage{voltage}
899{
900}
901
903{
904 yarp::os::idl::WireWriter writer(connection);
905 if (!writer.writeListHeader(s_cmd_len)) {
906 return false;
907 }
908 return write(writer);
909}
910
912{
913 yarp::os::idl::WireReader reader(connection);
914 if (!reader.readListHeader()) {
915 reader.fail();
916 return false;
917 }
918 return read(reader);
919}
920
922{
923 if (!writeTag(writer)) {
924 return false;
925 }
926 if (!writeArgs(writer)) {
927 return false;
928 }
929 return true;
930}
931
933{
934 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
935 return false;
936 }
937 return true;
938}
939
941{
942 if (!writer.writeFloat64(voltage)) {
943 return false;
944 }
945 return true;
946}
947
949{
950 if (!readTag(reader)) {
951 return false;
952 }
953 if (!readArgs(reader)) {
954 return false;
955 }
956 return true;
957}
958
960{
961 std::string tag = reader.readTag(s_tag_len);
962 if (reader.isError()) {
963 return false;
964 }
965 if (tag != s_tag) {
966 reader.fail();
967 return false;
968 }
969 return true;
970}
971
973{
974 if (reader.noMore()) {
975 reader.fail();
976 return false;
977 }
978 if (!reader.readFloat64(voltage)) {
979 reader.fail();
980 return false;
981 }
982 if (!reader.noMore()) {
983 reader.fail();
984 return false;
985 }
986 return true;
987}
988
990{
991 yarp::os::idl::WireWriter writer(connection);
992 return write(writer);
993}
994
1000
1002{
1003 if (!writer.isNull()) {
1004 if (!writer.writeOnewayResponse()) {
1005 return false;
1006 }
1007 }
1008 return true;
1009}
1010
1012{
1013 return true;
1014}
1015
1020
1021// setBatteryCurrent helper class implementation
1026
1028{
1029 return cmd.write(connection);
1030}
1031
1036
1038 current{current}
1039{
1040}
1041
1043{
1044 yarp::os::idl::WireWriter writer(connection);
1045 if (!writer.writeListHeader(s_cmd_len)) {
1046 return false;
1047 }
1048 return write(writer);
1049}
1050
1052{
1053 yarp::os::idl::WireReader reader(connection);
1054 if (!reader.readListHeader()) {
1055 reader.fail();
1056 return false;
1057 }
1058 return read(reader);
1059}
1060
1062{
1063 if (!writeTag(writer)) {
1064 return false;
1065 }
1066 if (!writeArgs(writer)) {
1067 return false;
1068 }
1069 return true;
1070}
1071
1073{
1074 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1075 return false;
1076 }
1077 return true;
1078}
1079
1081{
1082 if (!writer.writeFloat64(current)) {
1083 return false;
1084 }
1085 return true;
1086}
1087
1089{
1090 if (!readTag(reader)) {
1091 return false;
1092 }
1093 if (!readArgs(reader)) {
1094 return false;
1095 }
1096 return true;
1097}
1098
1100{
1101 std::string tag = reader.readTag(s_tag_len);
1102 if (reader.isError()) {
1103 return false;
1104 }
1105 if (tag != s_tag) {
1106 reader.fail();
1107 return false;
1108 }
1109 return true;
1110}
1111
1113{
1114 if (reader.noMore()) {
1115 reader.fail();
1116 return false;
1117 }
1118 if (!reader.readFloat64(current)) {
1119 reader.fail();
1120 return false;
1121 }
1122 if (!reader.noMore()) {
1123 reader.fail();
1124 return false;
1125 }
1126 return true;
1127}
1128
1130{
1131 yarp::os::idl::WireWriter writer(connection);
1132 return write(writer);
1133}
1134
1136{
1137 yarp::os::idl::WireReader reader(connection);
1138 return read(reader);
1139}
1140
1142{
1143 if (!writer.isNull()) {
1144 if (!writer.writeOnewayResponse()) {
1145 return false;
1146 }
1147 }
1148 return true;
1149}
1150
1152{
1153 return true;
1154}
1155
1160
1161// setBatteryCharge helper class implementation
1166
1168{
1169 return cmd.write(connection);
1170}
1171
1173{
1174 return reply.read(connection);
1175}
1176
1178 charge{charge}
1179{
1180}
1181
1183{
1184 yarp::os::idl::WireWriter writer(connection);
1185 if (!writer.writeListHeader(s_cmd_len)) {
1186 return false;
1187 }
1188 return write(writer);
1189}
1190
1192{
1193 yarp::os::idl::WireReader reader(connection);
1194 if (!reader.readListHeader()) {
1195 reader.fail();
1196 return false;
1197 }
1198 return read(reader);
1199}
1200
1202{
1203 if (!writeTag(writer)) {
1204 return false;
1205 }
1206 if (!writeArgs(writer)) {
1207 return false;
1208 }
1209 return true;
1210}
1211
1213{
1214 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1215 return false;
1216 }
1217 return true;
1218}
1219
1221{
1222 if (!writer.writeFloat64(charge)) {
1223 return false;
1224 }
1225 return true;
1226}
1227
1229{
1230 if (!readTag(reader)) {
1231 return false;
1232 }
1233 if (!readArgs(reader)) {
1234 return false;
1235 }
1236 return true;
1237}
1238
1240{
1241 std::string tag = reader.readTag(s_tag_len);
1242 if (reader.isError()) {
1243 return false;
1244 }
1245 if (tag != s_tag) {
1246 reader.fail();
1247 return false;
1248 }
1249 return true;
1250}
1251
1253{
1254 if (reader.noMore()) {
1255 reader.fail();
1256 return false;
1257 }
1258 if (!reader.readFloat64(charge)) {
1259 reader.fail();
1260 return false;
1261 }
1262 if (!reader.noMore()) {
1263 reader.fail();
1264 return false;
1265 }
1266 return true;
1267}
1268
1270{
1271 yarp::os::idl::WireWriter writer(connection);
1272 return write(writer);
1273}
1274
1276{
1277 yarp::os::idl::WireReader reader(connection);
1278 return read(reader);
1279}
1280
1282{
1283 if (!writer.isNull()) {
1284 if (!writer.writeOnewayResponse()) {
1285 return false;
1286 }
1287 }
1288 return true;
1289}
1290
1292{
1293 return true;
1294}
1295
1300
1301// setBatteryStatus helper class implementation
1306
1308{
1309 return cmd.write(connection);
1310}
1311
1313{
1314 return reply.read(connection);
1315}
1316
1321
1323{
1324 yarp::os::idl::WireWriter writer(connection);
1325 if (!writer.writeListHeader(s_cmd_len)) {
1326 return false;
1327 }
1328 return write(writer);
1329}
1330
1332{
1333 yarp::os::idl::WireReader reader(connection);
1334 if (!reader.readListHeader()) {
1335 reader.fail();
1336 return false;
1337 }
1338 return read(reader);
1339}
1340
1342{
1343 if (!writeTag(writer)) {
1344 return false;
1345 }
1346 if (!writeArgs(writer)) {
1347 return false;
1348 }
1349 return true;
1350}
1351
1353{
1354 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1355 return false;
1356 }
1357 return true;
1358}
1359
1361{
1362 if (!writer.writeVocab32(static_cast<yarp::conf::vocab32_t>(status))) {
1363 return false;
1364 }
1365 return true;
1366}
1367
1369{
1370 if (!readTag(reader)) {
1371 return false;
1372 }
1373 if (!readArgs(reader)) {
1374 return false;
1375 }
1376 return true;
1377}
1378
1380{
1381 std::string tag = reader.readTag(s_tag_len);
1382 if (reader.isError()) {
1383 return false;
1384 }
1385 if (tag != s_tag) {
1386 reader.fail();
1387 return false;
1388 }
1389 return true;
1390}
1391
1393{
1394 if (reader.noMore()) {
1395 reader.fail();
1396 return false;
1397 }
1398 yarp::conf::vocab32_t _ecast;
1399 if (!reader.readVocab32(_ecast)) {
1400 reader.fail();
1401 return false;
1402 }
1403 status = static_cast<yarp::dev::IBattery::Battery_status>(_ecast);
1404 if (!reader.noMore()) {
1405 reader.fail();
1406 return false;
1407 }
1408 return true;
1409}
1410
1412{
1413 yarp::os::idl::WireWriter writer(connection);
1414 return write(writer);
1415}
1416
1418{
1419 yarp::os::idl::WireReader reader(connection);
1420 return read(reader);
1421}
1422
1424{
1425 if (!writer.isNull()) {
1426 if (!writer.writeOnewayResponse()) {
1427 return false;
1428 }
1429 }
1430 return true;
1431}
1432
1434{
1435 return true;
1436}
1437
1442
1443// setBatteryInfo helper class implementation
1448
1450{
1451 return cmd.write(connection);
1452}
1453
1455{
1456 return reply.read(connection);
1457}
1458
1463
1465{
1466 yarp::os::idl::WireWriter writer(connection);
1467 if (!writer.writeListHeader(s_cmd_len)) {
1468 return false;
1469 }
1470 return write(writer);
1471}
1472
1474{
1475 yarp::os::idl::WireReader reader(connection);
1476 if (!reader.readListHeader()) {
1477 reader.fail();
1478 return false;
1479 }
1480 return read(reader);
1481}
1482
1484{
1485 if (!writeTag(writer)) {
1486 return false;
1487 }
1488 if (!writeArgs(writer)) {
1489 return false;
1490 }
1491 return true;
1492}
1493
1495{
1496 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1497 return false;
1498 }
1499 return true;
1500}
1501
1503{
1504 if (!writer.writeString(info)) {
1505 return false;
1506 }
1507 return true;
1508}
1509
1511{
1512 if (!readTag(reader)) {
1513 return false;
1514 }
1515 if (!readArgs(reader)) {
1516 return false;
1517 }
1518 return true;
1519}
1520
1522{
1523 std::string tag = reader.readTag(s_tag_len);
1524 if (reader.isError()) {
1525 return false;
1526 }
1527 if (tag != s_tag) {
1528 reader.fail();
1529 return false;
1530 }
1531 return true;
1532}
1533
1535{
1536 if (reader.noMore()) {
1537 reader.fail();
1538 return false;
1539 }
1540 if (!reader.readString(info)) {
1541 reader.fail();
1542 return false;
1543 }
1544 if (!reader.noMore()) {
1545 reader.fail();
1546 return false;
1547 }
1548 return true;
1549}
1550
1552{
1553 yarp::os::idl::WireWriter writer(connection);
1554 return write(writer);
1555}
1556
1558{
1559 yarp::os::idl::WireReader reader(connection);
1560 return read(reader);
1561}
1562
1564{
1565 if (!writer.isNull()) {
1566 if (!writer.writeOnewayResponse()) {
1567 return false;
1568 }
1569 }
1570 return true;
1571}
1572
1574{
1575 return true;
1576}
1577
1582
1583// setBatteryTemperature helper class implementation
1588
1590{
1591 return cmd.write(connection);
1592}
1593
1598
1600 temperature{temperature}
1601{
1602}
1603
1605{
1606 yarp::os::idl::WireWriter writer(connection);
1607 if (!writer.writeListHeader(s_cmd_len)) {
1608 return false;
1609 }
1610 return write(writer);
1611}
1612
1614{
1615 yarp::os::idl::WireReader reader(connection);
1616 if (!reader.readListHeader()) {
1617 reader.fail();
1618 return false;
1619 }
1620 return read(reader);
1621}
1622
1624{
1625 if (!writeTag(writer)) {
1626 return false;
1627 }
1628 if (!writeArgs(writer)) {
1629 return false;
1630 }
1631 return true;
1632}
1633
1635{
1636 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1637 return false;
1638 }
1639 return true;
1640}
1641
1643{
1644 if (!writer.writeFloat64(temperature)) {
1645 return false;
1646 }
1647 return true;
1648}
1649
1651{
1652 if (!readTag(reader)) {
1653 return false;
1654 }
1655 if (!readArgs(reader)) {
1656 return false;
1657 }
1658 return true;
1659}
1660
1662{
1663 std::string tag = reader.readTag(s_tag_len);
1664 if (reader.isError()) {
1665 return false;
1666 }
1667 if (tag != s_tag) {
1668 reader.fail();
1669 return false;
1670 }
1671 return true;
1672}
1673
1675{
1676 if (reader.noMore()) {
1677 reader.fail();
1678 return false;
1679 }
1680 if (!reader.readFloat64(temperature)) {
1681 reader.fail();
1682 return false;
1683 }
1684 if (!reader.noMore()) {
1685 reader.fail();
1686 return false;
1687 }
1688 return true;
1689}
1690
1692{
1693 yarp::os::idl::WireWriter writer(connection);
1694 return write(writer);
1695}
1696
1698{
1699 yarp::os::idl::WireReader reader(connection);
1700 return read(reader);
1701}
1702
1704{
1705 if (!writer.isNull()) {
1706 if (!writer.writeOnewayResponse()) {
1707 return false;
1708 }
1709 }
1710 return true;
1711}
1712
1714{
1715 return true;
1716}
1717
1722
1723// getBatteryVoltage helper class implementation
1725{
1726 return cmd.write(connection);
1727}
1728
1733
1735{
1736 yarp::os::idl::WireWriter writer(connection);
1737 if (!writer.writeListHeader(s_cmd_len)) {
1738 return false;
1739 }
1740 return write(writer);
1741}
1742
1744{
1745 yarp::os::idl::WireReader reader(connection);
1746 if (!reader.readListHeader()) {
1747 reader.fail();
1748 return false;
1749 }
1750 return read(reader);
1751}
1752
1754{
1755 if (!writeTag(writer)) {
1756 return false;
1757 }
1758 if (!writeArgs(writer)) {
1759 return false;
1760 }
1761 return true;
1762}
1763
1765{
1766 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1767 return false;
1768 }
1769 return true;
1770}
1771
1773{
1774 return true;
1775}
1776
1778{
1779 if (!readTag(reader)) {
1780 return false;
1781 }
1782 if (!readArgs(reader)) {
1783 return false;
1784 }
1785 return true;
1786}
1787
1789{
1790 std::string tag = reader.readTag(s_tag_len);
1791 if (reader.isError()) {
1792 return false;
1793 }
1794 if (tag != s_tag) {
1795 reader.fail();
1796 return false;
1797 }
1798 return true;
1799}
1800
1802{
1803 if (!reader.noMore()) {
1804 reader.fail();
1805 return false;
1806 }
1807 return true;
1808}
1809
1811{
1812 yarp::os::idl::WireWriter writer(connection);
1813 return write(writer);
1814}
1815
1817{
1818 yarp::os::idl::WireReader reader(connection);
1819 return read(reader);
1820}
1821
1823{
1824 if (!writer.isNull()) {
1825 if (!writer.writeListHeader(s_reply_len)) {
1826 return false;
1827 }
1828 if (!writer.writeFloat64(return_helper)) {
1829 return false;
1830 }
1831 }
1832 return true;
1833}
1834
1836{
1837 if (!reader.readListReturn()) {
1838 return false;
1839 }
1840 if (reader.noMore()) {
1841 reader.fail();
1842 return false;
1843 }
1844 if (!reader.readFloat64(return_helper)) {
1845 reader.fail();
1846 return false;
1847 }
1848 return true;
1849}
1850
1855
1856// getBatteryCurrent helper class implementation
1858{
1859 return cmd.write(connection);
1860}
1861
1866
1868{
1869 yarp::os::idl::WireWriter writer(connection);
1870 if (!writer.writeListHeader(s_cmd_len)) {
1871 return false;
1872 }
1873 return write(writer);
1874}
1875
1877{
1878 yarp::os::idl::WireReader reader(connection);
1879 if (!reader.readListHeader()) {
1880 reader.fail();
1881 return false;
1882 }
1883 return read(reader);
1884}
1885
1887{
1888 if (!writeTag(writer)) {
1889 return false;
1890 }
1891 if (!writeArgs(writer)) {
1892 return false;
1893 }
1894 return true;
1895}
1896
1898{
1899 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
1900 return false;
1901 }
1902 return true;
1903}
1904
1906{
1907 return true;
1908}
1909
1911{
1912 if (!readTag(reader)) {
1913 return false;
1914 }
1915 if (!readArgs(reader)) {
1916 return false;
1917 }
1918 return true;
1919}
1920
1922{
1923 std::string tag = reader.readTag(s_tag_len);
1924 if (reader.isError()) {
1925 return false;
1926 }
1927 if (tag != s_tag) {
1928 reader.fail();
1929 return false;
1930 }
1931 return true;
1932}
1933
1935{
1936 if (!reader.noMore()) {
1937 reader.fail();
1938 return false;
1939 }
1940 return true;
1941}
1942
1944{
1945 yarp::os::idl::WireWriter writer(connection);
1946 return write(writer);
1947}
1948
1950{
1951 yarp::os::idl::WireReader reader(connection);
1952 return read(reader);
1953}
1954
1956{
1957 if (!writer.isNull()) {
1958 if (!writer.writeListHeader(s_reply_len)) {
1959 return false;
1960 }
1961 if (!writer.writeFloat64(return_helper)) {
1962 return false;
1963 }
1964 }
1965 return true;
1966}
1967
1969{
1970 if (!reader.readListReturn()) {
1971 return false;
1972 }
1973 if (reader.noMore()) {
1974 reader.fail();
1975 return false;
1976 }
1977 if (!reader.readFloat64(return_helper)) {
1978 reader.fail();
1979 return false;
1980 }
1981 return true;
1982}
1983
1988
1989// getBatteryCharge helper class implementation
1991{
1992 return cmd.write(connection);
1993}
1994
1996{
1997 return reply.read(connection);
1998}
1999
2001{
2002 yarp::os::idl::WireWriter writer(connection);
2003 if (!writer.writeListHeader(s_cmd_len)) {
2004 return false;
2005 }
2006 return write(writer);
2007}
2008
2010{
2011 yarp::os::idl::WireReader reader(connection);
2012 if (!reader.readListHeader()) {
2013 reader.fail();
2014 return false;
2015 }
2016 return read(reader);
2017}
2018
2020{
2021 if (!writeTag(writer)) {
2022 return false;
2023 }
2024 if (!writeArgs(writer)) {
2025 return false;
2026 }
2027 return true;
2028}
2029
2031{
2032 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2033 return false;
2034 }
2035 return true;
2036}
2037
2039{
2040 return true;
2041}
2042
2044{
2045 if (!readTag(reader)) {
2046 return false;
2047 }
2048 if (!readArgs(reader)) {
2049 return false;
2050 }
2051 return true;
2052}
2053
2055{
2056 std::string tag = reader.readTag(s_tag_len);
2057 if (reader.isError()) {
2058 return false;
2059 }
2060 if (tag != s_tag) {
2061 reader.fail();
2062 return false;
2063 }
2064 return true;
2065}
2066
2068{
2069 if (!reader.noMore()) {
2070 reader.fail();
2071 return false;
2072 }
2073 return true;
2074}
2075
2077{
2078 yarp::os::idl::WireWriter writer(connection);
2079 return write(writer);
2080}
2081
2083{
2084 yarp::os::idl::WireReader reader(connection);
2085 return read(reader);
2086}
2087
2089{
2090 if (!writer.isNull()) {
2091 if (!writer.writeListHeader(s_reply_len)) {
2092 return false;
2093 }
2094 if (!writer.writeFloat64(return_helper)) {
2095 return false;
2096 }
2097 }
2098 return true;
2099}
2100
2102{
2103 if (!reader.readListReturn()) {
2104 return false;
2105 }
2106 if (reader.noMore()) {
2107 reader.fail();
2108 return false;
2109 }
2110 if (!reader.readFloat64(return_helper)) {
2111 reader.fail();
2112 return false;
2113 }
2114 return true;
2115}
2116
2121
2122// getBatteryStatus helper class implementation
2124{
2125 return cmd.write(connection);
2126}
2127
2129{
2130 return reply.read(connection);
2131}
2132
2134{
2135 yarp::os::idl::WireWriter writer(connection);
2136 if (!writer.writeListHeader(s_cmd_len)) {
2137 return false;
2138 }
2139 return write(writer);
2140}
2141
2143{
2144 yarp::os::idl::WireReader reader(connection);
2145 if (!reader.readListHeader()) {
2146 reader.fail();
2147 return false;
2148 }
2149 return read(reader);
2150}
2151
2153{
2154 if (!writeTag(writer)) {
2155 return false;
2156 }
2157 if (!writeArgs(writer)) {
2158 return false;
2159 }
2160 return true;
2161}
2162
2164{
2165 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2166 return false;
2167 }
2168 return true;
2169}
2170
2172{
2173 return true;
2174}
2175
2177{
2178 if (!readTag(reader)) {
2179 return false;
2180 }
2181 if (!readArgs(reader)) {
2182 return false;
2183 }
2184 return true;
2185}
2186
2188{
2189 std::string tag = reader.readTag(s_tag_len);
2190 if (reader.isError()) {
2191 return false;
2192 }
2193 if (tag != s_tag) {
2194 reader.fail();
2195 return false;
2196 }
2197 return true;
2198}
2199
2201{
2202 if (!reader.noMore()) {
2203 reader.fail();
2204 return false;
2205 }
2206 return true;
2207}
2208
2210{
2211 yarp::os::idl::WireWriter writer(connection);
2212 return write(writer);
2213}
2214
2216{
2217 yarp::os::idl::WireReader reader(connection);
2218 return read(reader);
2219}
2220
2222{
2223 if (!writer.isNull()) {
2224 if (!writer.writeListHeader(s_reply_len)) {
2225 return false;
2226 }
2227 if (!writer.writeVocab32(static_cast<yarp::conf::vocab32_t>(return_helper))) {
2228 return false;
2229 }
2230 }
2231 return true;
2232}
2233
2235{
2236 if (!reader.readListReturn()) {
2237 return false;
2238 }
2239 if (reader.noMore()) {
2240 reader.fail();
2241 return false;
2242 }
2243 yarp::conf::vocab32_t _ecast;
2244 if (!reader.readVocab32(_ecast)) {
2245 reader.fail();
2246 return false;
2247 }
2248 return_helper = static_cast<yarp::dev::IBattery::Battery_status>(_ecast);
2249 return true;
2250}
2251
2256
2257// getBatteryStatusString helper class implementation
2259{
2260 return cmd.write(connection);
2261}
2262
2267
2269{
2270 yarp::os::idl::WireWriter writer(connection);
2271 if (!writer.writeListHeader(s_cmd_len)) {
2272 return false;
2273 }
2274 return write(writer);
2275}
2276
2278{
2279 yarp::os::idl::WireReader reader(connection);
2280 if (!reader.readListHeader()) {
2281 reader.fail();
2282 return false;
2283 }
2284 return read(reader);
2285}
2286
2288{
2289 if (!writeTag(writer)) {
2290 return false;
2291 }
2292 if (!writeArgs(writer)) {
2293 return false;
2294 }
2295 return true;
2296}
2297
2299{
2300 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2301 return false;
2302 }
2303 return true;
2304}
2305
2307{
2308 return true;
2309}
2310
2312{
2313 if (!readTag(reader)) {
2314 return false;
2315 }
2316 if (!readArgs(reader)) {
2317 return false;
2318 }
2319 return true;
2320}
2321
2323{
2324 std::string tag = reader.readTag(s_tag_len);
2325 if (reader.isError()) {
2326 return false;
2327 }
2328 if (tag != s_tag) {
2329 reader.fail();
2330 return false;
2331 }
2332 return true;
2333}
2334
2336{
2337 if (!reader.noMore()) {
2338 reader.fail();
2339 return false;
2340 }
2341 return true;
2342}
2343
2345{
2346 yarp::os::idl::WireWriter writer(connection);
2347 return write(writer);
2348}
2349
2355
2357{
2358 if (!writer.isNull()) {
2359 if (!writer.writeListHeader(s_reply_len)) {
2360 return false;
2361 }
2362 if (!writer.writeString(return_helper)) {
2363 return false;
2364 }
2365 }
2366 return true;
2367}
2368
2370{
2371 if (!reader.readListReturn()) {
2372 return false;
2373 }
2374 if (reader.noMore()) {
2375 reader.fail();
2376 return false;
2377 }
2378 if (!reader.readString(return_helper)) {
2379 reader.fail();
2380 return false;
2381 }
2382 return true;
2383}
2384
2389
2390// getBatteryInfo helper class implementation
2392{
2393 return cmd.write(connection);
2394}
2395
2397{
2398 return reply.read(connection);
2399}
2400
2402{
2403 yarp::os::idl::WireWriter writer(connection);
2404 if (!writer.writeListHeader(s_cmd_len)) {
2405 return false;
2406 }
2407 return write(writer);
2408}
2409
2411{
2412 yarp::os::idl::WireReader reader(connection);
2413 if (!reader.readListHeader()) {
2414 reader.fail();
2415 return false;
2416 }
2417 return read(reader);
2418}
2419
2421{
2422 if (!writeTag(writer)) {
2423 return false;
2424 }
2425 if (!writeArgs(writer)) {
2426 return false;
2427 }
2428 return true;
2429}
2430
2432{
2433 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2434 return false;
2435 }
2436 return true;
2437}
2438
2440{
2441 return true;
2442}
2443
2445{
2446 if (!readTag(reader)) {
2447 return false;
2448 }
2449 if (!readArgs(reader)) {
2450 return false;
2451 }
2452 return true;
2453}
2454
2456{
2457 std::string tag = reader.readTag(s_tag_len);
2458 if (reader.isError()) {
2459 return false;
2460 }
2461 if (tag != s_tag) {
2462 reader.fail();
2463 return false;
2464 }
2465 return true;
2466}
2467
2469{
2470 if (!reader.noMore()) {
2471 reader.fail();
2472 return false;
2473 }
2474 return true;
2475}
2476
2478{
2479 yarp::os::idl::WireWriter writer(connection);
2480 return write(writer);
2481}
2482
2484{
2485 yarp::os::idl::WireReader reader(connection);
2486 return read(reader);
2487}
2488
2490{
2491 if (!writer.isNull()) {
2492 if (!writer.writeListHeader(s_reply_len)) {
2493 return false;
2494 }
2495 if (!writer.writeString(return_helper)) {
2496 return false;
2497 }
2498 }
2499 return true;
2500}
2501
2503{
2504 if (!reader.readListReturn()) {
2505 return false;
2506 }
2507 if (reader.noMore()) {
2508 reader.fail();
2509 return false;
2510 }
2511 if (!reader.readString(return_helper)) {
2512 reader.fail();
2513 return false;
2514 }
2515 return true;
2516}
2517
2522
2523// getBatteryTemperature helper class implementation
2525{
2526 return cmd.write(connection);
2527}
2528
2533
2535{
2536 yarp::os::idl::WireWriter writer(connection);
2537 if (!writer.writeListHeader(s_cmd_len)) {
2538 return false;
2539 }
2540 return write(writer);
2541}
2542
2544{
2545 yarp::os::idl::WireReader reader(connection);
2546 if (!reader.readListHeader()) {
2547 reader.fail();
2548 return false;
2549 }
2550 return read(reader);
2551}
2552
2554{
2555 if (!writeTag(writer)) {
2556 return false;
2557 }
2558 if (!writeArgs(writer)) {
2559 return false;
2560 }
2561 return true;
2562}
2563
2565{
2566 if (!writer.writeTag(s_tag, 1, s_tag_len)) {
2567 return false;
2568 }
2569 return true;
2570}
2571
2573{
2574 return true;
2575}
2576
2578{
2579 if (!readTag(reader)) {
2580 return false;
2581 }
2582 if (!readArgs(reader)) {
2583 return false;
2584 }
2585 return true;
2586}
2587
2589{
2590 std::string tag = reader.readTag(s_tag_len);
2591 if (reader.isError()) {
2592 return false;
2593 }
2594 if (tag != s_tag) {
2595 reader.fail();
2596 return false;
2597 }
2598 return true;
2599}
2600
2602{
2603 if (!reader.noMore()) {
2604 reader.fail();
2605 return false;
2606 }
2607 return true;
2608}
2609
2611{
2612 yarp::os::idl::WireWriter writer(connection);
2613 return write(writer);
2614}
2615
2617{
2618 yarp::os::idl::WireReader reader(connection);
2619 return read(reader);
2620}
2621
2623{
2624 if (!writer.isNull()) {
2625 if (!writer.writeListHeader(s_reply_len)) {
2626 return false;
2627 }
2628 if (!writer.writeFloat64(return_helper)) {
2629 return false;
2630 }
2631 }
2632 return true;
2633}
2634
2636{
2637 if (!reader.readListReturn()) {
2638 return false;
2639 }
2640 if (reader.noMore()) {
2641 reader.fail();
2642 return false;
2643 }
2644 if (!reader.readFloat64(return_helper)) {
2645 reader.fail();
2646 return false;
2647 }
2648 return true;
2649}
2650
2655
2656// Constructor
2658{
2659 yarp().setOwner(*this);
2660}
2661
2663{
2664 if (!yarp().canWrite()) {
2666 }
2668 yarp().write(helper);
2669}
2670
2672{
2673 if (!yarp().canWrite()) {
2675 }
2677 yarp().write(helper);
2678}
2679
2681{
2682 if (!yarp().canWrite()) {
2684 }
2686 yarp().write(helper);
2687}
2688
2690{
2691 if (!yarp().canWrite()) {
2693 }
2695 yarp().write(helper);
2696}
2697
2699{
2700 if (!yarp().canWrite()) {
2701 yError("Missing server method '%s'?", FakeBatteryService_setBatteryInfo_helper::s_prototype);
2702 }
2704 yarp().write(helper);
2705}
2706
2707void FakeBatteryService::setBatteryTemperature(const double temperature)
2708{
2709 if (!yarp().canWrite()) {
2711 }
2713 yarp().write(helper);
2714}
2715
2717{
2718 if (!yarp().canWrite()) {
2720 }
2722 bool ok = yarp().write(helper, helper);
2723 return ok ? helper.reply.return_helper : double{};
2724}
2725
2727{
2728 if (!yarp().canWrite()) {
2730 }
2732 bool ok = yarp().write(helper, helper);
2733 return ok ? helper.reply.return_helper : double{};
2734}
2735
2737{
2738 if (!yarp().canWrite()) {
2740 }
2742 bool ok = yarp().write(helper, helper);
2743 return ok ? helper.reply.return_helper : double{};
2744}
2745
2747{
2748 if (!yarp().canWrite()) {
2750 }
2752 bool ok = yarp().write(helper, helper);
2753 return ok ? helper.reply.return_helper : yarp::dev::IBattery::Battery_status{};
2754}
2755
2757{
2758 if (!yarp().canWrite()) {
2760 }
2762 bool ok = yarp().write(helper, helper);
2763 return ok ? helper.reply.return_helper : std::string{};
2764}
2765
2767{
2768 if (!yarp().canWrite()) {
2769 yError("Missing server method '%s'?", FakeBatteryService_getBatteryInfo_helper::s_prototype);
2770 }
2772 bool ok = yarp().write(helper, helper);
2773 return ok ? helper.reply.return_helper : std::string{};
2774}
2775
2777{
2778 if (!yarp().canWrite()) {
2780 }
2782 bool ok = yarp().write(helper, helper);
2783 return ok ? helper.reply.return_helper : double{};
2784}
2785
2786// help method
2787std::vector<std::string> FakeBatteryService::help(const std::string& functionName)
2788{
2789 bool showAll = (functionName == "--all");
2790 std::vector<std::string> helpString;
2791 if (showAll) {
2792 helpString.emplace_back("*** Available commands:");
2797 helpString.emplace_back(FakeBatteryService_setBatteryInfo_helper::s_tag);
2804 helpString.emplace_back(FakeBatteryService_getBatteryInfo_helper::s_tag);
2806 helpString.emplace_back("help");
2807 } else {
2810 }
2813 }
2816 }
2819 }
2822 }
2825 }
2828 }
2831 }
2834 }
2837 }
2840 }
2843 }
2846 }
2847 if (functionName == "help") {
2848 helpString.emplace_back("std::vector<std::string> help(const std::string& functionName = \"--all\")");
2849 helpString.emplace_back("Return list of available commands, or help message for a specific function");
2850 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");
2851 helpString.emplace_back("@return list of strings (one string per line)");
2852 }
2853 }
2854 if (helpString.empty()) {
2855 helpString.emplace_back("Command not found");
2856 }
2857 return helpString;
2858}
2859
2860// read from ConnectionReader
2862{
2863 constexpr size_t max_tag_len = 1;
2864 size_t tag_len = 1;
2865
2866 yarp::os::idl::WireReader reader(connection);
2867 reader.expectAccept();
2868 if (!reader.readListHeader()) {
2869 reader.fail();
2870 return false;
2871 }
2872
2873 std::string tag = reader.readTag(1);
2874 bool direct = (tag == "__direct__");
2875 if (direct) {
2876 tag = reader.readTag(1);
2877 }
2878 while (tag_len <= max_tag_len && !reader.isError()) {
2879 if(tag == "getRemoteProtocolVersion") {
2880 if (!reader.noMore()) {
2881 yError("Reader invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
2882 reader.fail();
2883 return false;
2884 }
2885
2886 auto proto = getLocalProtocolVersion();
2887
2888 yarp::os::idl::WireWriter writer(reader);
2889 if (!writer.writeListHeader(1)) {
2890 yWarning("Writer invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
2891 return false;}
2892 if (!writer.write(proto)) {
2893 yWarning("Writer invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
2894 return false;
2895 }
2896 reader.accept();
2897 return true;
2898 }
2901 if (!helper.cmd.readArgs(reader)) {
2902 return false;
2903 }
2904
2905 if (!direct) {
2906 yarp().callback(helper, *this, "__direct__");
2907 } else {
2908 helper.call(this);
2909 }
2910
2911 yarp::os::idl::WireWriter writer(reader);
2912 if (!helper.reply.write(writer)) {
2913 return false;
2914 }
2915 reader.accept();
2916 return true;
2917 }
2920 if (!helper.cmd.readArgs(reader)) {
2921 return false;
2922 }
2923
2924 if (!direct) {
2925 yarp().callback(helper, *this, "__direct__");
2926 } else {
2927 helper.call(this);
2928 }
2929
2930 yarp::os::idl::WireWriter writer(reader);
2931 if (!helper.reply.write(writer)) {
2932 return false;
2933 }
2934 reader.accept();
2935 return true;
2936 }
2939 if (!helper.cmd.readArgs(reader)) {
2940 return false;
2941 }
2942
2943 if (!direct) {
2944 yarp().callback(helper, *this, "__direct__");
2945 } else {
2946 helper.call(this);
2947 }
2948
2949 yarp::os::idl::WireWriter writer(reader);
2950 if (!helper.reply.write(writer)) {
2951 return false;
2952 }
2953 reader.accept();
2954 return true;
2955 }
2958 if (!helper.cmd.readArgs(reader)) {
2959 return false;
2960 }
2961
2962 if (!direct) {
2963 yarp().callback(helper, *this, "__direct__");
2964 } else {
2965 helper.call(this);
2966 }
2967
2968 yarp::os::idl::WireWriter writer(reader);
2969 if (!helper.reply.write(writer)) {
2970 return false;
2971 }
2972 reader.accept();
2973 return true;
2974 }
2977 if (!helper.cmd.readArgs(reader)) {
2978 return false;
2979 }
2980
2981 if (!direct) {
2982 yarp().callback(helper, *this, "__direct__");
2983 } else {
2984 helper.call(this);
2985 }
2986
2987 yarp::os::idl::WireWriter writer(reader);
2988 if (!helper.reply.write(writer)) {
2989 return false;
2990 }
2991 reader.accept();
2992 return true;
2993 }
2996 if (!helper.cmd.readArgs(reader)) {
2997 return false;
2998 }
2999
3000 if (!direct) {
3001 yarp().callback(helper, *this, "__direct__");
3002 } else {
3003 helper.call(this);
3004 }
3005
3006 yarp::os::idl::WireWriter writer(reader);
3007 if (!helper.reply.write(writer)) {
3008 return false;
3009 }
3010 reader.accept();
3011 return true;
3012 }
3015 if (!helper.cmd.readArgs(reader)) {
3016 return false;
3017 }
3018
3019 helper.call(this);
3020
3021 yarp::os::idl::WireWriter writer(reader);
3022 if (!helper.reply.write(writer)) {
3023 return false;
3024 }
3025 reader.accept();
3026 return true;
3027 }
3030 if (!helper.cmd.readArgs(reader)) {
3031 return false;
3032 }
3033
3034 helper.call(this);
3035
3036 yarp::os::idl::WireWriter writer(reader);
3037 if (!helper.reply.write(writer)) {
3038 return false;
3039 }
3040 reader.accept();
3041 return true;
3042 }
3045 if (!helper.cmd.readArgs(reader)) {
3046 return false;
3047 }
3048
3049 helper.call(this);
3050
3051 yarp::os::idl::WireWriter writer(reader);
3052 if (!helper.reply.write(writer)) {
3053 return false;
3054 }
3055 reader.accept();
3056 return true;
3057 }
3060 if (!helper.cmd.readArgs(reader)) {
3061 return false;
3062 }
3063
3064 helper.call(this);
3065
3066 yarp::os::idl::WireWriter writer(reader);
3067 if (!helper.reply.write(writer)) {
3068 return false;
3069 }
3070 reader.accept();
3071 return true;
3072 }
3075 if (!helper.cmd.readArgs(reader)) {
3076 return false;
3077 }
3078
3079 helper.call(this);
3080
3081 yarp::os::idl::WireWriter writer(reader);
3082 if (!helper.reply.write(writer)) {
3083 return false;
3084 }
3085 reader.accept();
3086 return true;
3087 }
3090 if (!helper.cmd.readArgs(reader)) {
3091 return false;
3092 }
3093
3094 helper.call(this);
3095
3096 yarp::os::idl::WireWriter writer(reader);
3097 if (!helper.reply.write(writer)) {
3098 return false;
3099 }
3100 reader.accept();
3101 return true;
3102 }
3105 if (!helper.cmd.readArgs(reader)) {
3106 return false;
3107 }
3108
3109 helper.call(this);
3110
3111 yarp::os::idl::WireWriter writer(reader);
3112 if (!helper.reply.write(writer)) {
3113 return false;
3114 }
3115 reader.accept();
3116 return true;
3117 }
3118 if (tag == "help") {
3119 std::string functionName;
3120 if (!reader.readString(functionName)) {
3121 functionName = "--all";
3122 }
3123 auto help_strings = help(functionName);
3124 yarp::os::idl::WireWriter writer(reader);
3125 if (!writer.isNull()) {
3126 if (!writer.writeListHeader(2)) {
3127 return false;
3128 }
3129 if (!writer.writeTag("many", 1, 0)) {
3130 return false;
3131 }
3132 if (!writer.writeListBegin(0, help_strings.size())) {
3133 return false;
3134 }
3135 for (const auto& help_string : help_strings) {
3136 if (!writer.writeString(help_string)) {
3137 return false;
3138 }
3139 }
3140 if (!writer.writeListEnd()) {
3141 return false;
3142 }
3143 }
3144 reader.accept();
3145 return true;
3146 }
3147 if (reader.noMore()) {
3148 reader.fail();
3149 return false;
3150 }
3151 std::string next_tag = reader.readTag(1);
3152 if (next_tag.empty()) {
3153 break;
3154 }
3155 tag.append("_").append(next_tag);
3156 tag_len = std::count(tag.begin(), tag.end(), '_') + 1;
3157 }
3158 return false;
3159}
#define yError(...)
Definition Log.h:361
#define __YFUNCTION__
Definition Log.h:24
#define yWarning(...)
Definition Log.h:340
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 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.
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 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.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool readTag(yarp::os::idl::WireReader &reader)
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool 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.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool 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 writeTag(const yarp::os::idl::WireWriter &writer) const
bool readArgs(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.
yarp::dev::IBattery::Battery_status return_helper
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
yarp::dev::IBattery::Battery_status(*)() funcptr_t
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
yarp::os::ApplicationNetworkProtocolVersion helper_proto
bool readArgs(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.
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.
void call(FakeBatteryService *ptr) 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 writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
void call(FakeBatteryService *ptr) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool readArgs(yarp::os::idl::WireReader &reader)
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
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 write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
void call(FakeBatteryService *ptr) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool writeTag(const yarp::os::idl::WireWriter &writer) const
bool readArgs(yarp::os::idl::WireReader &reader)
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 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.
void call(FakeBatteryService *ptr) const
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
void(*)(const yarp::dev::IBattery::Battery_status) 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 read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool writeArgs(const yarp::os::idl::WireWriter &writer) const
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
bool write(yarp::os::ConnectionWriter &connection) const override
Write this object to a network connection.
bool 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 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 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.
void call(FakeBatteryService *ptr) 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.
virtual std::string getBatteryInfo()
virtual void setBatteryStatus(const yarp::dev::IBattery::Battery_status status)
virtual double getBatteryVoltage()
virtual void setBatteryInfo(const std::string &info)
virtual bool checkProtocolVersion()
virtual void setBatteryTemperature(const double temperature)
virtual double getBatteryCharge()
virtual yarp::dev::IBattery::Battery_status getBatteryStatus()
bool read(yarp::os::ConnectionReader &connection) override
Read this object from a network connection.
virtual void setBatteryCharge(const double charge)
virtual yarp::os::ApplicationNetworkProtocolVersion getLocalProtocolVersion()
virtual std::string getBatteryStatusString()
virtual yarp::os::ApplicationNetworkProtocolVersion getRemoteProtocolVersion()
virtual void setBatteryVoltage(const double voltage)
virtual double getBatteryCurrent()
virtual std::vector< std::string > help(const std::string &functionName="--all")
virtual void setBatteryCurrent(const double current)
virtual double getBatteryTemperature()
An interface for reading from a network connection.
An interface for writing to a network connection.
This is a base class for objects that can be both read from and be written to the YARP network.
Definition Portable.h:25
yarp::os::WireLink & yarp()
Get YARP state associated with this object.
Definition Wire.h:28
A "tamed" Portable, that promises to serialize itself in an IDL-friendly way.
IDL-friendly connection reader.
Definition WireReader.h:27
bool readVocab32(yarp::conf::vocab32_t &x)
bool readString(std::string &str, bool *is_vocab=nullptr)
std::string readTag(size_t len=static_cast< size_t >(-1))
bool readFloat64(yarp::conf::float64_t &x)
IDL-friendly connection writer.
Definition WireWriter.h:28
bool writeVocab32(yarp::conf::vocab32_t x, bool skip_tag=false) const
bool write(const WirePortable &obj) const
bool writeListHeader(int len) const
bool writeTag(const char *tag, int split, int len) const
bool writeFloat64(yarp::conf::float64_t x, bool skip_tag=false) const
bool writeOnewayResponse() const
bool writeString(const std::string &str, bool skip_tag=false) const
bool writeListBegin(int tag, size_t len) const
#define yCError(component,...)
#define YARP_LOG_COMPONENT(name,...)
std::int32_t vocab32_t
Definition numeric.h:78
The main, catch-all namespace for YARP.
Definition dirs.h:16
#define YARP_VERSION_PATCH
Definition version.h:12
#define YARP_VERSION_MAJOR
Definition version.h:10
#define YARP_VERSION_MINOR
Definition version.h:11