YARP
Yet Another Robot Platform
 
Loading...
Searching...
No Matches
SensorRPCData.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// This is an automatically generated file.
9// It could get re-generated if the ALLOW_IDL_GENERATION flag is on.
10
11#include <SensorRPCData.h>
12
13// Constructor with field values
14SensorRPCData::SensorRPCData(const std::vector<SensorMetadata>& ThreeAxisGyroscopes,
15 const std::vector<SensorMetadata>& ThreeAxisLinearAccelerometers,
16 const std::vector<SensorMetadata>& ThreeAxisMagnetometers,
17 const std::vector<SensorMetadata>& OrientationSensors,
18 const std::vector<SensorMetadata>& TemperatureSensors,
19 const std::vector<SensorMetadata>& SixAxisForceTorqueSensors,
20 const std::vector<SensorMetadata>& ContactLoadCellArrays,
21 const std::vector<SensorMetadata>& EncoderArrays,
22 const std::vector<SensorMetadata>& SkinPatches,
23 const std::vector<SensorMetadata>& PositionSensors,
24 const std::vector<SensorMetadata>& LinearVelocitySensors,
25 const std::vector<SensorMetadata>& ThreeAxisAngularAccelerometers) :
26 WirePortable(),
39{
40}
41
42// Read structure on a Wire
44{
45 if (!read_ThreeAxisGyroscopes(reader)) {
46 return false;
47 }
48 if (!read_ThreeAxisLinearAccelerometers(reader)) {
49 return false;
50 }
51 if (!read_ThreeAxisMagnetometers(reader)) {
52 return false;
53 }
54 if (!read_OrientationSensors(reader)) {
55 return false;
56 }
57 if (!read_TemperatureSensors(reader)) {
58 return false;
59 }
60 if (!read_SixAxisForceTorqueSensors(reader)) {
61 return false;
62 }
63 if (!read_ContactLoadCellArrays(reader)) {
64 return false;
65 }
66 if (!read_EncoderArrays(reader)) {
67 return false;
68 }
69 if (!read_SkinPatches(reader)) {
70 return false;
71 }
72 if (!read_PositionSensors(reader)) {
73 return false;
74 }
75 if (!read_LinearVelocitySensors(reader)) {
76 return false;
77 }
78 if (!read_ThreeAxisAngularAccelerometers(reader)) {
79 return false;
80 }
81 if (reader.isError()) {
82 return false;
83 }
84 return true;
85}
86
87// Read structure on a Connection
89{
90 yarp::os::idl::WireReader reader(connection);
91 if (!reader.readListHeader(12)) {
92 return false;
93 }
94 if (!read(reader)) {
95 return false;
96 }
97 return true;
98}
99
100// Write structure on a Wire
102{
103 if (!write_ThreeAxisGyroscopes(writer)) {
104 return false;
105 }
106 if (!write_ThreeAxisLinearAccelerometers(writer)) {
107 return false;
108 }
109 if (!write_ThreeAxisMagnetometers(writer)) {
110 return false;
111 }
112 if (!write_OrientationSensors(writer)) {
113 return false;
114 }
115 if (!write_TemperatureSensors(writer)) {
116 return false;
117 }
118 if (!write_SixAxisForceTorqueSensors(writer)) {
119 return false;
120 }
121 if (!write_ContactLoadCellArrays(writer)) {
122 return false;
123 }
124 if (!write_EncoderArrays(writer)) {
125 return false;
126 }
127 if (!write_SkinPatches(writer)) {
128 return false;
129 }
130 if (!write_PositionSensors(writer)) {
131 return false;
132 }
133 if (!write_LinearVelocitySensors(writer)) {
134 return false;
135 }
136 if (!write_ThreeAxisAngularAccelerometers(writer)) {
137 return false;
138 }
139 if (writer.isError()) {
140 return false;
141 }
142 return true;
143}
144
145// Write structure on a Connection
147{
148 yarp::os::idl::WireWriter writer(connection);
149 if (!writer.writeListHeader(12)) {
150 return false;
151 }
152 if (!write(writer)) {
153 return false;
154 }
155 return true;
156}
157
158// Convert to a printable string
159std::string SensorRPCData::toString() const
160{
162 if (!yarp::os::Portable::copyPortable(*this, b)) {
163 return {};
164 }
165 return b.toString();
166}
167
168// read ThreeAxisGyroscopes field
169bool SensorRPCData::read_ThreeAxisGyroscopes(yarp::os::idl::WireReader& reader)
170{
171 if (reader.noMore()) {
172 reader.fail();
173 return false;
174 }
175 {
176 size_t _csize;
178 reader.readListBegin(_etype, _csize);
179 // WireReader removes BOTTLE_TAG_LIST from the tag
180 constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
181 if constexpr (expected_tag != 0) {
182 if (_csize != 0 && _etype.code != expected_tag) {
183 return false;
184 }
185 }
186 ThreeAxisGyroscopes.resize(_csize);
187 for (size_t _i0 = 0; _i0 < _csize; ++_i0) {
188 if (reader.noMore()) {
189 reader.fail();
190 return false;
191 }
192 if (!reader.readNested(ThreeAxisGyroscopes[_i0])) {
193 reader.fail();
194 return false;
195 }
196 }
197 reader.readListEnd();
198 }
199 return true;
200}
201
202// write ThreeAxisGyroscopes field
203bool SensorRPCData::write_ThreeAxisGyroscopes(const yarp::os::idl::WireWriter& writer) const
204{
206 return false;
207 }
208 for (const auto& _item : ThreeAxisGyroscopes) {
209 if (!writer.writeNested(_item)) {
210 return false;
211 }
212 }
213 if (!writer.writeListEnd()) {
214 return false;
215 }
216 return true;
217}
218
219// read (nested) ThreeAxisGyroscopes field
220bool SensorRPCData::nested_read_ThreeAxisGyroscopes(yarp::os::idl::WireReader& reader)
221{
222 if (reader.noMore()) {
223 reader.fail();
224 return false;
225 }
226 {
227 size_t _csize;
229 reader.readListBegin(_etype, _csize);
230 // WireReader removes BOTTLE_TAG_LIST from the tag
231 constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
232 if constexpr (expected_tag != 0) {
233 if (_csize != 0 && _etype.code != expected_tag) {
234 return false;
235 }
236 }
237 ThreeAxisGyroscopes.resize(_csize);
238 for (size_t _i0 = 0; _i0 < _csize; ++_i0) {
239 if (reader.noMore()) {
240 reader.fail();
241 return false;
242 }
243 if (!reader.readNested(ThreeAxisGyroscopes[_i0])) {
244 reader.fail();
245 return false;
246 }
247 }
248 reader.readListEnd();
249 }
250 return true;
251}
252
253// write (nested) ThreeAxisGyroscopes field
254bool SensorRPCData::nested_write_ThreeAxisGyroscopes(const yarp::os::idl::WireWriter& writer) const
255{
257 return false;
258 }
259 for (const auto& _item : ThreeAxisGyroscopes) {
260 if (!writer.writeNested(_item)) {
261 return false;
262 }
263 }
264 if (!writer.writeListEnd()) {
265 return false;
266 }
267 return true;
268}
269
270// read ThreeAxisLinearAccelerometers field
271bool SensorRPCData::read_ThreeAxisLinearAccelerometers(yarp::os::idl::WireReader& reader)
272{
273 if (reader.noMore()) {
274 reader.fail();
275 return false;
276 }
277 {
278 size_t _csize;
280 reader.readListBegin(_etype, _csize);
281 // WireReader removes BOTTLE_TAG_LIST from the tag
282 constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
283 if constexpr (expected_tag != 0) {
284 if (_csize != 0 && _etype.code != expected_tag) {
285 return false;
286 }
287 }
288 ThreeAxisLinearAccelerometers.resize(_csize);
289 for (size_t _i0 = 0; _i0 < _csize; ++_i0) {
290 if (reader.noMore()) {
291 reader.fail();
292 return false;
293 }
294 if (!reader.readNested(ThreeAxisLinearAccelerometers[_i0])) {
295 reader.fail();
296 return false;
297 }
298 }
299 reader.readListEnd();
300 }
301 return true;
302}
303
304// write ThreeAxisLinearAccelerometers field
305bool SensorRPCData::write_ThreeAxisLinearAccelerometers(const yarp::os::idl::WireWriter& writer) const
306{
308 return false;
309 }
310 for (const auto& _item : ThreeAxisLinearAccelerometers) {
311 if (!writer.writeNested(_item)) {
312 return false;
313 }
314 }
315 if (!writer.writeListEnd()) {
316 return false;
317 }
318 return true;
319}
320
321// read (nested) ThreeAxisLinearAccelerometers field
322bool SensorRPCData::nested_read_ThreeAxisLinearAccelerometers(yarp::os::idl::WireReader& reader)
323{
324 if (reader.noMore()) {
325 reader.fail();
326 return false;
327 }
328 {
329 size_t _csize;
331 reader.readListBegin(_etype, _csize);
332 // WireReader removes BOTTLE_TAG_LIST from the tag
333 constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
334 if constexpr (expected_tag != 0) {
335 if (_csize != 0 && _etype.code != expected_tag) {
336 return false;
337 }
338 }
339 ThreeAxisLinearAccelerometers.resize(_csize);
340 for (size_t _i0 = 0; _i0 < _csize; ++_i0) {
341 if (reader.noMore()) {
342 reader.fail();
343 return false;
344 }
345 if (!reader.readNested(ThreeAxisLinearAccelerometers[_i0])) {
346 reader.fail();
347 return false;
348 }
349 }
350 reader.readListEnd();
351 }
352 return true;
353}
354
355// write (nested) ThreeAxisLinearAccelerometers field
356bool SensorRPCData::nested_write_ThreeAxisLinearAccelerometers(const yarp::os::idl::WireWriter& writer) const
357{
359 return false;
360 }
361 for (const auto& _item : ThreeAxisLinearAccelerometers) {
362 if (!writer.writeNested(_item)) {
363 return false;
364 }
365 }
366 if (!writer.writeListEnd()) {
367 return false;
368 }
369 return true;
370}
371
372// read ThreeAxisMagnetometers field
373bool SensorRPCData::read_ThreeAxisMagnetometers(yarp::os::idl::WireReader& reader)
374{
375 if (reader.noMore()) {
376 reader.fail();
377 return false;
378 }
379 {
380 size_t _csize;
382 reader.readListBegin(_etype, _csize);
383 // WireReader removes BOTTLE_TAG_LIST from the tag
384 constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
385 if constexpr (expected_tag != 0) {
386 if (_csize != 0 && _etype.code != expected_tag) {
387 return false;
388 }
389 }
390 ThreeAxisMagnetometers.resize(_csize);
391 for (size_t _i0 = 0; _i0 < _csize; ++_i0) {
392 if (reader.noMore()) {
393 reader.fail();
394 return false;
395 }
396 if (!reader.readNested(ThreeAxisMagnetometers[_i0])) {
397 reader.fail();
398 return false;
399 }
400 }
401 reader.readListEnd();
402 }
403 return true;
404}
405
406// write ThreeAxisMagnetometers field
407bool SensorRPCData::write_ThreeAxisMagnetometers(const yarp::os::idl::WireWriter& writer) const
408{
410 return false;
411 }
412 for (const auto& _item : ThreeAxisMagnetometers) {
413 if (!writer.writeNested(_item)) {
414 return false;
415 }
416 }
417 if (!writer.writeListEnd()) {
418 return false;
419 }
420 return true;
421}
422
423// read (nested) ThreeAxisMagnetometers field
424bool SensorRPCData::nested_read_ThreeAxisMagnetometers(yarp::os::idl::WireReader& reader)
425{
426 if (reader.noMore()) {
427 reader.fail();
428 return false;
429 }
430 {
431 size_t _csize;
433 reader.readListBegin(_etype, _csize);
434 // WireReader removes BOTTLE_TAG_LIST from the tag
435 constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
436 if constexpr (expected_tag != 0) {
437 if (_csize != 0 && _etype.code != expected_tag) {
438 return false;
439 }
440 }
441 ThreeAxisMagnetometers.resize(_csize);
442 for (size_t _i0 = 0; _i0 < _csize; ++_i0) {
443 if (reader.noMore()) {
444 reader.fail();
445 return false;
446 }
447 if (!reader.readNested(ThreeAxisMagnetometers[_i0])) {
448 reader.fail();
449 return false;
450 }
451 }
452 reader.readListEnd();
453 }
454 return true;
455}
456
457// write (nested) ThreeAxisMagnetometers field
458bool SensorRPCData::nested_write_ThreeAxisMagnetometers(const yarp::os::idl::WireWriter& writer) const
459{
461 return false;
462 }
463 for (const auto& _item : ThreeAxisMagnetometers) {
464 if (!writer.writeNested(_item)) {
465 return false;
466 }
467 }
468 if (!writer.writeListEnd()) {
469 return false;
470 }
471 return true;
472}
473
474// read OrientationSensors field
475bool SensorRPCData::read_OrientationSensors(yarp::os::idl::WireReader& reader)
476{
477 if (reader.noMore()) {
478 reader.fail();
479 return false;
480 }
481 {
482 size_t _csize;
484 reader.readListBegin(_etype, _csize);
485 // WireReader removes BOTTLE_TAG_LIST from the tag
486 constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
487 if constexpr (expected_tag != 0) {
488 if (_csize != 0 && _etype.code != expected_tag) {
489 return false;
490 }
491 }
492 OrientationSensors.resize(_csize);
493 for (size_t _i0 = 0; _i0 < _csize; ++_i0) {
494 if (reader.noMore()) {
495 reader.fail();
496 return false;
497 }
498 if (!reader.readNested(OrientationSensors[_i0])) {
499 reader.fail();
500 return false;
501 }
502 }
503 reader.readListEnd();
504 }
505 return true;
506}
507
508// write OrientationSensors field
509bool SensorRPCData::write_OrientationSensors(const yarp::os::idl::WireWriter& writer) const
510{
512 return false;
513 }
514 for (const auto& _item : OrientationSensors) {
515 if (!writer.writeNested(_item)) {
516 return false;
517 }
518 }
519 if (!writer.writeListEnd()) {
520 return false;
521 }
522 return true;
523}
524
525// read (nested) OrientationSensors field
526bool SensorRPCData::nested_read_OrientationSensors(yarp::os::idl::WireReader& reader)
527{
528 if (reader.noMore()) {
529 reader.fail();
530 return false;
531 }
532 {
533 size_t _csize;
535 reader.readListBegin(_etype, _csize);
536 // WireReader removes BOTTLE_TAG_LIST from the tag
537 constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
538 if constexpr (expected_tag != 0) {
539 if (_csize != 0 && _etype.code != expected_tag) {
540 return false;
541 }
542 }
543 OrientationSensors.resize(_csize);
544 for (size_t _i0 = 0; _i0 < _csize; ++_i0) {
545 if (reader.noMore()) {
546 reader.fail();
547 return false;
548 }
549 if (!reader.readNested(OrientationSensors[_i0])) {
550 reader.fail();
551 return false;
552 }
553 }
554 reader.readListEnd();
555 }
556 return true;
557}
558
559// write (nested) OrientationSensors field
560bool SensorRPCData::nested_write_OrientationSensors(const yarp::os::idl::WireWriter& writer) const
561{
563 return false;
564 }
565 for (const auto& _item : OrientationSensors) {
566 if (!writer.writeNested(_item)) {
567 return false;
568 }
569 }
570 if (!writer.writeListEnd()) {
571 return false;
572 }
573 return true;
574}
575
576// read TemperatureSensors field
577bool SensorRPCData::read_TemperatureSensors(yarp::os::idl::WireReader& reader)
578{
579 if (reader.noMore()) {
580 reader.fail();
581 return false;
582 }
583 {
584 size_t _csize;
586 reader.readListBegin(_etype, _csize);
587 // WireReader removes BOTTLE_TAG_LIST from the tag
588 constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
589 if constexpr (expected_tag != 0) {
590 if (_csize != 0 && _etype.code != expected_tag) {
591 return false;
592 }
593 }
594 TemperatureSensors.resize(_csize);
595 for (size_t _i0 = 0; _i0 < _csize; ++_i0) {
596 if (reader.noMore()) {
597 reader.fail();
598 return false;
599 }
600 if (!reader.readNested(TemperatureSensors[_i0])) {
601 reader.fail();
602 return false;
603 }
604 }
605 reader.readListEnd();
606 }
607 return true;
608}
609
610// write TemperatureSensors field
611bool SensorRPCData::write_TemperatureSensors(const yarp::os::idl::WireWriter& writer) const
612{
614 return false;
615 }
616 for (const auto& _item : TemperatureSensors) {
617 if (!writer.writeNested(_item)) {
618 return false;
619 }
620 }
621 if (!writer.writeListEnd()) {
622 return false;
623 }
624 return true;
625}
626
627// read (nested) TemperatureSensors field
628bool SensorRPCData::nested_read_TemperatureSensors(yarp::os::idl::WireReader& reader)
629{
630 if (reader.noMore()) {
631 reader.fail();
632 return false;
633 }
634 {
635 size_t _csize;
637 reader.readListBegin(_etype, _csize);
638 // WireReader removes BOTTLE_TAG_LIST from the tag
639 constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
640 if constexpr (expected_tag != 0) {
641 if (_csize != 0 && _etype.code != expected_tag) {
642 return false;
643 }
644 }
645 TemperatureSensors.resize(_csize);
646 for (size_t _i0 = 0; _i0 < _csize; ++_i0) {
647 if (reader.noMore()) {
648 reader.fail();
649 return false;
650 }
651 if (!reader.readNested(TemperatureSensors[_i0])) {
652 reader.fail();
653 return false;
654 }
655 }
656 reader.readListEnd();
657 }
658 return true;
659}
660
661// write (nested) TemperatureSensors field
662bool SensorRPCData::nested_write_TemperatureSensors(const yarp::os::idl::WireWriter& writer) const
663{
665 return false;
666 }
667 for (const auto& _item : TemperatureSensors) {
668 if (!writer.writeNested(_item)) {
669 return false;
670 }
671 }
672 if (!writer.writeListEnd()) {
673 return false;
674 }
675 return true;
676}
677
678// read SixAxisForceTorqueSensors field
679bool SensorRPCData::read_SixAxisForceTorqueSensors(yarp::os::idl::WireReader& reader)
680{
681 if (reader.noMore()) {
682 reader.fail();
683 return false;
684 }
685 {
686 size_t _csize;
688 reader.readListBegin(_etype, _csize);
689 // WireReader removes BOTTLE_TAG_LIST from the tag
690 constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
691 if constexpr (expected_tag != 0) {
692 if (_csize != 0 && _etype.code != expected_tag) {
693 return false;
694 }
695 }
696 SixAxisForceTorqueSensors.resize(_csize);
697 for (size_t _i0 = 0; _i0 < _csize; ++_i0) {
698 if (reader.noMore()) {
699 reader.fail();
700 return false;
701 }
702 if (!reader.readNested(SixAxisForceTorqueSensors[_i0])) {
703 reader.fail();
704 return false;
705 }
706 }
707 reader.readListEnd();
708 }
709 return true;
710}
711
712// write SixAxisForceTorqueSensors field
713bool SensorRPCData::write_SixAxisForceTorqueSensors(const yarp::os::idl::WireWriter& writer) const
714{
716 return false;
717 }
718 for (const auto& _item : SixAxisForceTorqueSensors) {
719 if (!writer.writeNested(_item)) {
720 return false;
721 }
722 }
723 if (!writer.writeListEnd()) {
724 return false;
725 }
726 return true;
727}
728
729// read (nested) SixAxisForceTorqueSensors field
730bool SensorRPCData::nested_read_SixAxisForceTorqueSensors(yarp::os::idl::WireReader& reader)
731{
732 if (reader.noMore()) {
733 reader.fail();
734 return false;
735 }
736 {
737 size_t _csize;
739 reader.readListBegin(_etype, _csize);
740 // WireReader removes BOTTLE_TAG_LIST from the tag
741 constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
742 if constexpr (expected_tag != 0) {
743 if (_csize != 0 && _etype.code != expected_tag) {
744 return false;
745 }
746 }
747 SixAxisForceTorqueSensors.resize(_csize);
748 for (size_t _i0 = 0; _i0 < _csize; ++_i0) {
749 if (reader.noMore()) {
750 reader.fail();
751 return false;
752 }
753 if (!reader.readNested(SixAxisForceTorqueSensors[_i0])) {
754 reader.fail();
755 return false;
756 }
757 }
758 reader.readListEnd();
759 }
760 return true;
761}
762
763// write (nested) SixAxisForceTorqueSensors field
764bool SensorRPCData::nested_write_SixAxisForceTorqueSensors(const yarp::os::idl::WireWriter& writer) const
765{
767 return false;
768 }
769 for (const auto& _item : SixAxisForceTorqueSensors) {
770 if (!writer.writeNested(_item)) {
771 return false;
772 }
773 }
774 if (!writer.writeListEnd()) {
775 return false;
776 }
777 return true;
778}
779
780// read ContactLoadCellArrays field
781bool SensorRPCData::read_ContactLoadCellArrays(yarp::os::idl::WireReader& reader)
782{
783 if (reader.noMore()) {
784 reader.fail();
785 return false;
786 }
787 {
788 size_t _csize;
790 reader.readListBegin(_etype, _csize);
791 // WireReader removes BOTTLE_TAG_LIST from the tag
792 constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
793 if constexpr (expected_tag != 0) {
794 if (_csize != 0 && _etype.code != expected_tag) {
795 return false;
796 }
797 }
798 ContactLoadCellArrays.resize(_csize);
799 for (size_t _i0 = 0; _i0 < _csize; ++_i0) {
800 if (reader.noMore()) {
801 reader.fail();
802 return false;
803 }
804 if (!reader.readNested(ContactLoadCellArrays[_i0])) {
805 reader.fail();
806 return false;
807 }
808 }
809 reader.readListEnd();
810 }
811 return true;
812}
813
814// write ContactLoadCellArrays field
815bool SensorRPCData::write_ContactLoadCellArrays(const yarp::os::idl::WireWriter& writer) const
816{
818 return false;
819 }
820 for (const auto& _item : ContactLoadCellArrays) {
821 if (!writer.writeNested(_item)) {
822 return false;
823 }
824 }
825 if (!writer.writeListEnd()) {
826 return false;
827 }
828 return true;
829}
830
831// read (nested) ContactLoadCellArrays field
832bool SensorRPCData::nested_read_ContactLoadCellArrays(yarp::os::idl::WireReader& reader)
833{
834 if (reader.noMore()) {
835 reader.fail();
836 return false;
837 }
838 {
839 size_t _csize;
841 reader.readListBegin(_etype, _csize);
842 // WireReader removes BOTTLE_TAG_LIST from the tag
843 constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
844 if constexpr (expected_tag != 0) {
845 if (_csize != 0 && _etype.code != expected_tag) {
846 return false;
847 }
848 }
849 ContactLoadCellArrays.resize(_csize);
850 for (size_t _i0 = 0; _i0 < _csize; ++_i0) {
851 if (reader.noMore()) {
852 reader.fail();
853 return false;
854 }
855 if (!reader.readNested(ContactLoadCellArrays[_i0])) {
856 reader.fail();
857 return false;
858 }
859 }
860 reader.readListEnd();
861 }
862 return true;
863}
864
865// write (nested) ContactLoadCellArrays field
866bool SensorRPCData::nested_write_ContactLoadCellArrays(const yarp::os::idl::WireWriter& writer) const
867{
869 return false;
870 }
871 for (const auto& _item : ContactLoadCellArrays) {
872 if (!writer.writeNested(_item)) {
873 return false;
874 }
875 }
876 if (!writer.writeListEnd()) {
877 return false;
878 }
879 return true;
880}
881
882// read EncoderArrays field
883bool SensorRPCData::read_EncoderArrays(yarp::os::idl::WireReader& reader)
884{
885 if (reader.noMore()) {
886 reader.fail();
887 return false;
888 }
889 {
890 size_t _csize;
892 reader.readListBegin(_etype, _csize);
893 // WireReader removes BOTTLE_TAG_LIST from the tag
894 constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
895 if constexpr (expected_tag != 0) {
896 if (_csize != 0 && _etype.code != expected_tag) {
897 return false;
898 }
899 }
900 EncoderArrays.resize(_csize);
901 for (size_t _i0 = 0; _i0 < _csize; ++_i0) {
902 if (reader.noMore()) {
903 reader.fail();
904 return false;
905 }
906 if (!reader.readNested(EncoderArrays[_i0])) {
907 reader.fail();
908 return false;
909 }
910 }
911 reader.readListEnd();
912 }
913 return true;
914}
915
916// write EncoderArrays field
917bool SensorRPCData::write_EncoderArrays(const yarp::os::idl::WireWriter& writer) const
918{
919 if (!writer.writeListBegin(BOTTLE_TAG_LIST, EncoderArrays.size())) {
920 return false;
921 }
922 for (const auto& _item : EncoderArrays) {
923 if (!writer.writeNested(_item)) {
924 return false;
925 }
926 }
927 if (!writer.writeListEnd()) {
928 return false;
929 }
930 return true;
931}
932
933// read (nested) EncoderArrays field
934bool SensorRPCData::nested_read_EncoderArrays(yarp::os::idl::WireReader& reader)
935{
936 if (reader.noMore()) {
937 reader.fail();
938 return false;
939 }
940 {
941 size_t _csize;
943 reader.readListBegin(_etype, _csize);
944 // WireReader removes BOTTLE_TAG_LIST from the tag
945 constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
946 if constexpr (expected_tag != 0) {
947 if (_csize != 0 && _etype.code != expected_tag) {
948 return false;
949 }
950 }
951 EncoderArrays.resize(_csize);
952 for (size_t _i0 = 0; _i0 < _csize; ++_i0) {
953 if (reader.noMore()) {
954 reader.fail();
955 return false;
956 }
957 if (!reader.readNested(EncoderArrays[_i0])) {
958 reader.fail();
959 return false;
960 }
961 }
962 reader.readListEnd();
963 }
964 return true;
965}
966
967// write (nested) EncoderArrays field
968bool SensorRPCData::nested_write_EncoderArrays(const yarp::os::idl::WireWriter& writer) const
969{
970 if (!writer.writeListBegin(BOTTLE_TAG_LIST, EncoderArrays.size())) {
971 return false;
972 }
973 for (const auto& _item : EncoderArrays) {
974 if (!writer.writeNested(_item)) {
975 return false;
976 }
977 }
978 if (!writer.writeListEnd()) {
979 return false;
980 }
981 return true;
982}
983
984// read SkinPatches field
985bool SensorRPCData::read_SkinPatches(yarp::os::idl::WireReader& reader)
986{
987 if (reader.noMore()) {
988 reader.fail();
989 return false;
990 }
991 {
992 size_t _csize;
994 reader.readListBegin(_etype, _csize);
995 // WireReader removes BOTTLE_TAG_LIST from the tag
996 constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
997 if constexpr (expected_tag != 0) {
998 if (_csize != 0 && _etype.code != expected_tag) {
999 return false;
1000 }
1001 }
1002 SkinPatches.resize(_csize);
1003 for (size_t _i0 = 0; _i0 < _csize; ++_i0) {
1004 if (reader.noMore()) {
1005 reader.fail();
1006 return false;
1007 }
1008 if (!reader.readNested(SkinPatches[_i0])) {
1009 reader.fail();
1010 return false;
1011 }
1012 }
1013 reader.readListEnd();
1014 }
1015 return true;
1016}
1017
1018// write SkinPatches field
1019bool SensorRPCData::write_SkinPatches(const yarp::os::idl::WireWriter& writer) const
1020{
1021 if (!writer.writeListBegin(BOTTLE_TAG_LIST, SkinPatches.size())) {
1022 return false;
1023 }
1024 for (const auto& _item : SkinPatches) {
1025 if (!writer.writeNested(_item)) {
1026 return false;
1027 }
1028 }
1029 if (!writer.writeListEnd()) {
1030 return false;
1031 }
1032 return true;
1033}
1034
1035// read (nested) SkinPatches field
1036bool SensorRPCData::nested_read_SkinPatches(yarp::os::idl::WireReader& reader)
1037{
1038 if (reader.noMore()) {
1039 reader.fail();
1040 return false;
1041 }
1042 {
1043 size_t _csize;
1045 reader.readListBegin(_etype, _csize);
1046 // WireReader removes BOTTLE_TAG_LIST from the tag
1047 constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
1048 if constexpr (expected_tag != 0) {
1049 if (_csize != 0 && _etype.code != expected_tag) {
1050 return false;
1051 }
1052 }
1053 SkinPatches.resize(_csize);
1054 for (size_t _i0 = 0; _i0 < _csize; ++_i0) {
1055 if (reader.noMore()) {
1056 reader.fail();
1057 return false;
1058 }
1059 if (!reader.readNested(SkinPatches[_i0])) {
1060 reader.fail();
1061 return false;
1062 }
1063 }
1064 reader.readListEnd();
1065 }
1066 return true;
1067}
1068
1069// write (nested) SkinPatches field
1070bool SensorRPCData::nested_write_SkinPatches(const yarp::os::idl::WireWriter& writer) const
1071{
1072 if (!writer.writeListBegin(BOTTLE_TAG_LIST, SkinPatches.size())) {
1073 return false;
1074 }
1075 for (const auto& _item : SkinPatches) {
1076 if (!writer.writeNested(_item)) {
1077 return false;
1078 }
1079 }
1080 if (!writer.writeListEnd()) {
1081 return false;
1082 }
1083 return true;
1084}
1085
1086// read PositionSensors field
1087bool SensorRPCData::read_PositionSensors(yarp::os::idl::WireReader& reader)
1088{
1089 if (reader.noMore()) {
1090 reader.fail();
1091 return false;
1092 }
1093 {
1094 size_t _csize;
1096 reader.readListBegin(_etype, _csize);
1097 // WireReader removes BOTTLE_TAG_LIST from the tag
1098 constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
1099 if constexpr (expected_tag != 0) {
1100 if (_csize != 0 && _etype.code != expected_tag) {
1101 return false;
1102 }
1103 }
1104 PositionSensors.resize(_csize);
1105 for (size_t _i0 = 0; _i0 < _csize; ++_i0) {
1106 if (reader.noMore()) {
1107 reader.fail();
1108 return false;
1109 }
1110 if (!reader.readNested(PositionSensors[_i0])) {
1111 reader.fail();
1112 return false;
1113 }
1114 }
1115 reader.readListEnd();
1116 }
1117 return true;
1118}
1119
1120// write PositionSensors field
1121bool SensorRPCData::write_PositionSensors(const yarp::os::idl::WireWriter& writer) const
1122{
1123 if (!writer.writeListBegin(BOTTLE_TAG_LIST, PositionSensors.size())) {
1124 return false;
1125 }
1126 for (const auto& _item : PositionSensors) {
1127 if (!writer.writeNested(_item)) {
1128 return false;
1129 }
1130 }
1131 if (!writer.writeListEnd()) {
1132 return false;
1133 }
1134 return true;
1135}
1136
1137// read (nested) PositionSensors field
1138bool SensorRPCData::nested_read_PositionSensors(yarp::os::idl::WireReader& reader)
1139{
1140 if (reader.noMore()) {
1141 reader.fail();
1142 return false;
1143 }
1144 {
1145 size_t _csize;
1147 reader.readListBegin(_etype, _csize);
1148 // WireReader removes BOTTLE_TAG_LIST from the tag
1149 constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
1150 if constexpr (expected_tag != 0) {
1151 if (_csize != 0 && _etype.code != expected_tag) {
1152 return false;
1153 }
1154 }
1155 PositionSensors.resize(_csize);
1156 for (size_t _i0 = 0; _i0 < _csize; ++_i0) {
1157 if (reader.noMore()) {
1158 reader.fail();
1159 return false;
1160 }
1161 if (!reader.readNested(PositionSensors[_i0])) {
1162 reader.fail();
1163 return false;
1164 }
1165 }
1166 reader.readListEnd();
1167 }
1168 return true;
1169}
1170
1171// write (nested) PositionSensors field
1172bool SensorRPCData::nested_write_PositionSensors(const yarp::os::idl::WireWriter& writer) const
1173{
1174 if (!writer.writeListBegin(BOTTLE_TAG_LIST, PositionSensors.size())) {
1175 return false;
1176 }
1177 for (const auto& _item : PositionSensors) {
1178 if (!writer.writeNested(_item)) {
1179 return false;
1180 }
1181 }
1182 if (!writer.writeListEnd()) {
1183 return false;
1184 }
1185 return true;
1186}
1187
1188// read LinearVelocitySensors field
1189bool SensorRPCData::read_LinearVelocitySensors(yarp::os::idl::WireReader& reader)
1190{
1191 if (reader.noMore()) {
1192 reader.fail();
1193 return false;
1194 }
1195 {
1196 size_t _csize;
1198 reader.readListBegin(_etype, _csize);
1199 // WireReader removes BOTTLE_TAG_LIST from the tag
1200 constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
1201 if constexpr (expected_tag != 0) {
1202 if (_csize != 0 && _etype.code != expected_tag) {
1203 return false;
1204 }
1205 }
1206 LinearVelocitySensors.resize(_csize);
1207 for (size_t _i0 = 0; _i0 < _csize; ++_i0) {
1208 if (reader.noMore()) {
1209 reader.fail();
1210 return false;
1211 }
1212 if (!reader.readNested(LinearVelocitySensors[_i0])) {
1213 reader.fail();
1214 return false;
1215 }
1216 }
1217 reader.readListEnd();
1218 }
1219 return true;
1220}
1221
1222// write LinearVelocitySensors field
1223bool SensorRPCData::write_LinearVelocitySensors(const yarp::os::idl::WireWriter& writer) const
1224{
1226 return false;
1227 }
1228 for (const auto& _item : LinearVelocitySensors) {
1229 if (!writer.writeNested(_item)) {
1230 return false;
1231 }
1232 }
1233 if (!writer.writeListEnd()) {
1234 return false;
1235 }
1236 return true;
1237}
1238
1239// read (nested) LinearVelocitySensors field
1240bool SensorRPCData::nested_read_LinearVelocitySensors(yarp::os::idl::WireReader& reader)
1241{
1242 if (reader.noMore()) {
1243 reader.fail();
1244 return false;
1245 }
1246 {
1247 size_t _csize;
1249 reader.readListBegin(_etype, _csize);
1250 // WireReader removes BOTTLE_TAG_LIST from the tag
1251 constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
1252 if constexpr (expected_tag != 0) {
1253 if (_csize != 0 && _etype.code != expected_tag) {
1254 return false;
1255 }
1256 }
1257 LinearVelocitySensors.resize(_csize);
1258 for (size_t _i0 = 0; _i0 < _csize; ++_i0) {
1259 if (reader.noMore()) {
1260 reader.fail();
1261 return false;
1262 }
1263 if (!reader.readNested(LinearVelocitySensors[_i0])) {
1264 reader.fail();
1265 return false;
1266 }
1267 }
1268 reader.readListEnd();
1269 }
1270 return true;
1271}
1272
1273// write (nested) LinearVelocitySensors field
1274bool SensorRPCData::nested_write_LinearVelocitySensors(const yarp::os::idl::WireWriter& writer) const
1275{
1277 return false;
1278 }
1279 for (const auto& _item : LinearVelocitySensors) {
1280 if (!writer.writeNested(_item)) {
1281 return false;
1282 }
1283 }
1284 if (!writer.writeListEnd()) {
1285 return false;
1286 }
1287 return true;
1288}
1289
1290// read ThreeAxisAngularAccelerometers field
1291bool SensorRPCData::read_ThreeAxisAngularAccelerometers(yarp::os::idl::WireReader& reader)
1292{
1293 if (reader.noMore()) {
1294 reader.fail();
1295 return false;
1296 }
1297 {
1298 size_t _csize;
1300 reader.readListBegin(_etype, _csize);
1301 // WireReader removes BOTTLE_TAG_LIST from the tag
1302 constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
1303 if constexpr (expected_tag != 0) {
1304 if (_csize != 0 && _etype.code != expected_tag) {
1305 return false;
1306 }
1307 }
1308 ThreeAxisAngularAccelerometers.resize(_csize);
1309 for (size_t _i0 = 0; _i0 < _csize; ++_i0) {
1310 if (reader.noMore()) {
1311 reader.fail();
1312 return false;
1313 }
1314 if (!reader.readNested(ThreeAxisAngularAccelerometers[_i0])) {
1315 reader.fail();
1316 return false;
1317 }
1318 }
1319 reader.readListEnd();
1320 }
1321 return true;
1322}
1323
1324// write ThreeAxisAngularAccelerometers field
1325bool SensorRPCData::write_ThreeAxisAngularAccelerometers(const yarp::os::idl::WireWriter& writer) const
1326{
1328 return false;
1329 }
1330 for (const auto& _item : ThreeAxisAngularAccelerometers) {
1331 if (!writer.writeNested(_item)) {
1332 return false;
1333 }
1334 }
1335 if (!writer.writeListEnd()) {
1336 return false;
1337 }
1338 return true;
1339}
1340
1341// read (nested) ThreeAxisAngularAccelerometers field
1342bool SensorRPCData::nested_read_ThreeAxisAngularAccelerometers(yarp::os::idl::WireReader& reader)
1343{
1344 if (reader.noMore()) {
1345 reader.fail();
1346 return false;
1347 }
1348 {
1349 size_t _csize;
1351 reader.readListBegin(_etype, _csize);
1352 // WireReader removes BOTTLE_TAG_LIST from the tag
1353 constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
1354 if constexpr (expected_tag != 0) {
1355 if (_csize != 0 && _etype.code != expected_tag) {
1356 return false;
1357 }
1358 }
1359 ThreeAxisAngularAccelerometers.resize(_csize);
1360 for (size_t _i0 = 0; _i0 < _csize; ++_i0) {
1361 if (reader.noMore()) {
1362 reader.fail();
1363 return false;
1364 }
1365 if (!reader.readNested(ThreeAxisAngularAccelerometers[_i0])) {
1366 reader.fail();
1367 return false;
1368 }
1369 }
1370 reader.readListEnd();
1371 }
1372 return true;
1373}
1374
1375// write (nested) ThreeAxisAngularAccelerometers field
1376bool SensorRPCData::nested_write_ThreeAxisAngularAccelerometers(const yarp::os::idl::WireWriter& writer) const
1377{
1379 return false;
1380 }
1381 for (const auto& _item : ThreeAxisAngularAccelerometers) {
1382 if (!writer.writeNested(_item)) {
1383 return false;
1384 }
1385 }
1386 if (!writer.writeListEnd()) {
1387 return false;
1388 }
1389 return true;
1390}
#define BOTTLE_TAG_LIST
Definition Bottle.h:29
@ ThreeAxisAngularAccelerometers
@ ThreeAxisLinearAccelerometers
std::vector< SensorMetadata > SkinPatches
bool read(yarp::os::idl::WireReader &reader) override
std::vector< SensorMetadata > ContactLoadCellArrays
std::string toString() const
std::vector< SensorMetadata > ThreeAxisAngularAccelerometers
bool write(const yarp::os::idl::WireWriter &writer) const override
std::vector< SensorMetadata > EncoderArrays
std::vector< SensorMetadata > PositionSensors
std::vector< SensorMetadata > ThreeAxisGyroscopes
std::vector< SensorMetadata > ThreeAxisLinearAccelerometers
std::vector< SensorMetadata > LinearVelocitySensors
std::vector< SensorMetadata > ThreeAxisMagnetometers
std::vector< SensorMetadata > OrientationSensors
SensorRPCData()=default
std::vector< SensorMetadata > SixAxisForceTorqueSensors
std::vector< SensorMetadata > TemperatureSensors
A simple collection of objects that can be described and transmitted in a portable way.
Definition Bottle.h:64
std::string toString() const override
Gives a human-readable textual representation of the bottle.
Definition Bottle.cpp:212
An interface for reading from a network connection.
An interface for writing to a network connection.
static bool copyPortable(const PortWriter &writer, PortReader &reader)
Copy one portable to another, via writing and reading.
Definition Portable.cpp:16
IDL-friendly connection reader.
Definition WireReader.h:27
bool readNested(WirePortable &obj)
void readListBegin(yarp::os::idl::WireState &nstate, size_t &len)
IDL-friendly state.
Definition WireState.h:17
IDL-friendly connection writer.
Definition WireWriter.h:28
bool writeListHeader(int len) const
bool writeNested(const WirePortable &obj) const
bool writeListBegin(int tag, size_t len) const