YARP
Yet Another Robot Platform
 
Loading...
Searching...
No Matches
return_getMotorEncoderTimedAll.cpp
Go to the documentation of this file.
1/*
2 * SPDX-FileCopyrightText: 2006-2021 Istituto Italiano di Tecnologia (IIT)
3 * SPDX-License-Identifier: BSD-3-Clause
4 */
5
6// Autogenerated by Thrift Compiler (0.14.1-yarped)
7//
8// This is an automatically generated file.
9// It could get re-generated if the ALLOW_IDL_GENERATION flag is on.
10
12
13// Constructor with field values
15 const std::vector<double>& val,
16 const std::vector<double>& time) :
17 WirePortable(),
18 ret(ret),
19 val(val),
20 time(time)
21{
22}
23
24// Read structure on a Wire
26{
27 if (!nested_read_ret(reader)) {
28 return false;
29 }
30 if (!read_val(reader)) {
31 return false;
32 }
33 if (!read_time(reader)) {
34 return false;
35 }
36 if (reader.isError()) {
37 return false;
38 }
39 return true;
40}
41
42// Read structure on a Connection
44{
45 yarp::os::idl::WireReader reader(connection);
46 if (!reader.readListHeader(3)) {
47 return false;
48 }
49 if (!read(reader)) {
50 return false;
51 }
52 return true;
53}
54
55// Write structure on a Wire
57{
58 if (!nested_write_ret(writer)) {
59 return false;
60 }
61 if (!write_val(writer)) {
62 return false;
63 }
64 if (!write_time(writer)) {
65 return false;
66 }
67 if (writer.isError()) {
68 return false;
69 }
70 return true;
71}
72
73// Write structure on a Connection
75{
76 yarp::os::idl::WireWriter writer(connection);
77 if (!writer.writeListHeader(3)) {
78 return false;
79 }
80 if (!write(writer)) {
81 return false;
82 }
83 return true;
84}
85
86// Convert to a printable string
88{
90 if (!yarp::os::Portable::copyPortable(*this, b)) {
91 return {};
92 }
93 return b.toString();
94}
95
96// read ret field
97bool return_getMotorEncoderTimedAll::read_ret(yarp::os::idl::WireReader& reader)
98{
99 if (reader.noMore()) {
100 reader.fail();
101 return false;
102 }
103 if (!reader.read(ret)) {
104 reader.fail();
105 return false;
106 }
107 return true;
108}
109
110// write ret field
111bool return_getMotorEncoderTimedAll::write_ret(const yarp::os::idl::WireWriter& writer) const
112{
113 if (!writer.write(ret)) {
114 return false;
115 }
116 return true;
117}
118
119// read (nested) ret field
120bool return_getMotorEncoderTimedAll::nested_read_ret(yarp::os::idl::WireReader& reader)
121{
122 if (reader.noMore()) {
123 reader.fail();
124 return false;
125 }
126 if (!reader.readNested(ret)) {
127 reader.fail();
128 return false;
129 }
130 return true;
131}
132
133// write (nested) ret field
134bool return_getMotorEncoderTimedAll::nested_write_ret(const yarp::os::idl::WireWriter& writer) const
135{
136 if (!writer.writeNested(ret)) {
137 return false;
138 }
139 return true;
140}
141
142// read val field
143bool return_getMotorEncoderTimedAll::read_val(yarp::os::idl::WireReader& reader)
144{
145 if (reader.noMore()) {
146 reader.fail();
147 return false;
148 }
149 {
150 size_t _csize;
152 reader.readListBegin(_etype, _csize);
153 // WireReader removes BOTTLE_TAG_LIST from the tag
154 constexpr int expected_tag = ((BOTTLE_TAG_FLOAT64) & (~BOTTLE_TAG_LIST));
155 if constexpr (expected_tag != 0) {
156 if (_csize != 0 && _etype.code != expected_tag) {
157 return false;
158 }
159 }
160 val.resize(_csize);
161 if (_csize != 0 && !reader.readBlock(reinterpret_cast<char*>(val.data()), val.size() * sizeof(double))) {
162 return false;
163 }
164 reader.readListEnd();
165 }
166 return true;
167}
168
169// write val field
170bool return_getMotorEncoderTimedAll::write_val(const yarp::os::idl::WireWriter& writer) const
171{
172 if (!writer.writeListBegin(BOTTLE_TAG_FLOAT64, val.size())) {
173 return false;
174 }
175 if (!writer.writeBlock(reinterpret_cast<const char*>(val.data()), val.size() * sizeof(double))) {
176 return false;
177 }
178 if (!writer.writeListEnd()) {
179 return false;
180 }
181 return true;
182}
183
184// read (nested) val field
185bool return_getMotorEncoderTimedAll::nested_read_val(yarp::os::idl::WireReader& reader)
186{
187 if (reader.noMore()) {
188 reader.fail();
189 return false;
190 }
191 {
192 size_t _csize;
194 reader.readListBegin(_etype, _csize);
195 // WireReader removes BOTTLE_TAG_LIST from the tag
196 constexpr int expected_tag = ((BOTTLE_TAG_FLOAT64) & (~BOTTLE_TAG_LIST));
197 if constexpr (expected_tag != 0) {
198 if (_csize != 0 && _etype.code != expected_tag) {
199 return false;
200 }
201 }
202 val.resize(_csize);
203 if (_csize != 0 && !reader.readBlock(reinterpret_cast<char*>(val.data()), val.size() * sizeof(double))) {
204 return false;
205 }
206 reader.readListEnd();
207 }
208 return true;
209}
210
211// write (nested) val field
212bool return_getMotorEncoderTimedAll::nested_write_val(const yarp::os::idl::WireWriter& writer) const
213{
214 if (!writer.writeListBegin(BOTTLE_TAG_FLOAT64, val.size())) {
215 return false;
216 }
217 if (!writer.writeBlock(reinterpret_cast<const char*>(val.data()), val.size() * sizeof(double))) {
218 return false;
219 }
220 if (!writer.writeListEnd()) {
221 return false;
222 }
223 return true;
224}
225
226// read time field
227bool return_getMotorEncoderTimedAll::read_time(yarp::os::idl::WireReader& reader)
228{
229 if (reader.noMore()) {
230 reader.fail();
231 return false;
232 }
233 {
234 size_t _csize;
236 reader.readListBegin(_etype, _csize);
237 // WireReader removes BOTTLE_TAG_LIST from the tag
238 constexpr int expected_tag = ((BOTTLE_TAG_FLOAT64) & (~BOTTLE_TAG_LIST));
239 if constexpr (expected_tag != 0) {
240 if (_csize != 0 && _etype.code != expected_tag) {
241 return false;
242 }
243 }
244 time.resize(_csize);
245 if (_csize != 0 && !reader.readBlock(reinterpret_cast<char*>(time.data()), time.size() * sizeof(double))) {
246 return false;
247 }
248 reader.readListEnd();
249 }
250 return true;
251}
252
253// write time field
254bool return_getMotorEncoderTimedAll::write_time(const yarp::os::idl::WireWriter& writer) const
255{
256 if (!writer.writeListBegin(BOTTLE_TAG_FLOAT64, time.size())) {
257 return false;
258 }
259 if (!writer.writeBlock(reinterpret_cast<const char*>(time.data()), time.size() * sizeof(double))) {
260 return false;
261 }
262 if (!writer.writeListEnd()) {
263 return false;
264 }
265 return true;
266}
267
268// read (nested) time field
269bool return_getMotorEncoderTimedAll::nested_read_time(yarp::os::idl::WireReader& reader)
270{
271 if (reader.noMore()) {
272 reader.fail();
273 return false;
274 }
275 {
276 size_t _csize;
278 reader.readListBegin(_etype, _csize);
279 // WireReader removes BOTTLE_TAG_LIST from the tag
280 constexpr int expected_tag = ((BOTTLE_TAG_FLOAT64) & (~BOTTLE_TAG_LIST));
281 if constexpr (expected_tag != 0) {
282 if (_csize != 0 && _etype.code != expected_tag) {
283 return false;
284 }
285 }
286 time.resize(_csize);
287 if (_csize != 0 && !reader.readBlock(reinterpret_cast<char*>(time.data()), time.size() * sizeof(double))) {
288 return false;
289 }
290 reader.readListEnd();
291 }
292 return true;
293}
294
295// write (nested) time field
296bool return_getMotorEncoderTimedAll::nested_write_time(const yarp::os::idl::WireWriter& writer) const
297{
298 if (!writer.writeListBegin(BOTTLE_TAG_FLOAT64, time.size())) {
299 return false;
300 }
301 if (!writer.writeBlock(reinterpret_cast<const char*>(time.data()), time.size() * sizeof(double))) {
302 return false;
303 }
304 if (!writer.writeListEnd()) {
305 return false;
306 }
307 return true;
308}
#define BOTTLE_TAG_FLOAT64
Definition Bottle.h:26
#define BOTTLE_TAG_LIST
Definition Bottle.h:29
bool write(const yarp::os::idl::WireWriter &writer) const override
bool read(yarp::os::idl::WireReader &reader) override
A simple collection of objects that can be described and transmitted in a portable way.
Definition Bottle.h:65
std::string toString() const override
Gives a human-readable textual representation of the bottle.
Definition Bottle.cpp:217
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)
bool readBlock(char *const data, size_t len)
bool read(WirePortable &obj)
IDL-friendly state.
Definition WireState.h:17
IDL-friendly connection writer.
Definition WireWriter.h:28
bool write(const WirePortable &obj) const
bool writeListHeader(int len) const
bool writeBlock(const char *data, size_t len) const
bool writeNested(const WirePortable &obj) const
bool writeListBegin(int tag, size_t len) const