YARP
Yet Another Robot Platform
 
Loading...
Searching...
No Matches
yCalibrationParameters.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 double param1,
16 const double param2,
17 const double param3,
18 const double param4,
19 const double param5,
20 const double paramZero) :
21 WirePortable(),
22 type(type),
23 param1(param1),
24 param2(param2),
25 param3(param3),
26 param4(param4),
27 param5(param5),
28 paramZero(paramZero)
29{
30}
31
32// Read structure on a Wire
34{
35 if (!read_type(reader)) {
36 return false;
37 }
38 if (!read_param1(reader)) {
39 return false;
40 }
41 if (!read_param2(reader)) {
42 return false;
43 }
44 if (!read_param3(reader)) {
45 return false;
46 }
47 if (!read_param4(reader)) {
48 return false;
49 }
50 if (!read_param5(reader)) {
51 return false;
52 }
53 if (!read_paramZero(reader)) {
54 return false;
55 }
56 if (reader.isError()) {
57 return false;
58 }
59 return true;
60}
61
62// Read structure on a Connection
64{
65 yarp::os::idl::WireReader reader(connection);
66 if (!reader.readListHeader(7)) {
67 return false;
68 }
69 if (!read(reader)) {
70 return false;
71 }
72 return true;
73}
74
75// Write structure on a Wire
77{
78 if (!write_type(writer)) {
79 return false;
80 }
81 if (!write_param1(writer)) {
82 return false;
83 }
84 if (!write_param2(writer)) {
85 return false;
86 }
87 if (!write_param3(writer)) {
88 return false;
89 }
90 if (!write_param4(writer)) {
91 return false;
92 }
93 if (!write_param5(writer)) {
94 return false;
95 }
96 if (!write_paramZero(writer)) {
97 return false;
98 }
99 if (writer.isError()) {
100 return false;
101 }
102 return true;
103}
104
105// Write structure on a Connection
107{
108 yarp::os::idl::WireWriter writer(connection);
109 if (!writer.writeListHeader(7)) {
110 return false;
111 }
112 if (!write(writer)) {
113 return false;
114 }
115 return true;
116}
117
118// Convert to a printable string
120{
122 if (!yarp::os::Portable::copyPortable(*this, b)) {
123 return {};
124 }
125 return b.toString();
126}
127
128// read type field
129bool yCalibrationParameters::read_type(yarp::os::idl::WireReader& reader)
130{
131 if (reader.noMore()) {
132 reader.fail();
133 return false;
134 }
135 if (!reader.readI32(type)) {
136 reader.fail();
137 return false;
138 }
139 return true;
140}
141
142// write type field
143bool yCalibrationParameters::write_type(const yarp::os::idl::WireWriter& writer) const
144{
145 if (!writer.writeI32(type)) {
146 return false;
147 }
148 return true;
149}
150
151// read (nested) type field
152bool yCalibrationParameters::nested_read_type(yarp::os::idl::WireReader& reader)
153{
154 if (reader.noMore()) {
155 reader.fail();
156 return false;
157 }
158 if (!reader.readI32(type)) {
159 reader.fail();
160 return false;
161 }
162 return true;
163}
164
165// write (nested) type field
166bool yCalibrationParameters::nested_write_type(const yarp::os::idl::WireWriter& writer) const
167{
168 if (!writer.writeI32(type)) {
169 return false;
170 }
171 return true;
172}
173
174// read param1 field
175bool yCalibrationParameters::read_param1(yarp::os::idl::WireReader& reader)
176{
177 if (reader.noMore()) {
178 reader.fail();
179 return false;
180 }
181 if (!reader.readFloat64(param1)) {
182 reader.fail();
183 return false;
184 }
185 return true;
186}
187
188// write param1 field
189bool yCalibrationParameters::write_param1(const yarp::os::idl::WireWriter& writer) const
190{
191 if (!writer.writeFloat64(param1)) {
192 return false;
193 }
194 return true;
195}
196
197// read (nested) param1 field
198bool yCalibrationParameters::nested_read_param1(yarp::os::idl::WireReader& reader)
199{
200 if (reader.noMore()) {
201 reader.fail();
202 return false;
203 }
204 if (!reader.readFloat64(param1)) {
205 reader.fail();
206 return false;
207 }
208 return true;
209}
210
211// write (nested) param1 field
212bool yCalibrationParameters::nested_write_param1(const yarp::os::idl::WireWriter& writer) const
213{
214 if (!writer.writeFloat64(param1)) {
215 return false;
216 }
217 return true;
218}
219
220// read param2 field
221bool yCalibrationParameters::read_param2(yarp::os::idl::WireReader& reader)
222{
223 if (reader.noMore()) {
224 reader.fail();
225 return false;
226 }
227 if (!reader.readFloat64(param2)) {
228 reader.fail();
229 return false;
230 }
231 return true;
232}
233
234// write param2 field
235bool yCalibrationParameters::write_param2(const yarp::os::idl::WireWriter& writer) const
236{
237 if (!writer.writeFloat64(param2)) {
238 return false;
239 }
240 return true;
241}
242
243// read (nested) param2 field
244bool yCalibrationParameters::nested_read_param2(yarp::os::idl::WireReader& reader)
245{
246 if (reader.noMore()) {
247 reader.fail();
248 return false;
249 }
250 if (!reader.readFloat64(param2)) {
251 reader.fail();
252 return false;
253 }
254 return true;
255}
256
257// write (nested) param2 field
258bool yCalibrationParameters::nested_write_param2(const yarp::os::idl::WireWriter& writer) const
259{
260 if (!writer.writeFloat64(param2)) {
261 return false;
262 }
263 return true;
264}
265
266// read param3 field
267bool yCalibrationParameters::read_param3(yarp::os::idl::WireReader& reader)
268{
269 if (reader.noMore()) {
270 reader.fail();
271 return false;
272 }
273 if (!reader.readFloat64(param3)) {
274 reader.fail();
275 return false;
276 }
277 return true;
278}
279
280// write param3 field
281bool yCalibrationParameters::write_param3(const yarp::os::idl::WireWriter& writer) const
282{
283 if (!writer.writeFloat64(param3)) {
284 return false;
285 }
286 return true;
287}
288
289// read (nested) param3 field
290bool yCalibrationParameters::nested_read_param3(yarp::os::idl::WireReader& reader)
291{
292 if (reader.noMore()) {
293 reader.fail();
294 return false;
295 }
296 if (!reader.readFloat64(param3)) {
297 reader.fail();
298 return false;
299 }
300 return true;
301}
302
303// write (nested) param3 field
304bool yCalibrationParameters::nested_write_param3(const yarp::os::idl::WireWriter& writer) const
305{
306 if (!writer.writeFloat64(param3)) {
307 return false;
308 }
309 return true;
310}
311
312// read param4 field
313bool yCalibrationParameters::read_param4(yarp::os::idl::WireReader& reader)
314{
315 if (reader.noMore()) {
316 reader.fail();
317 return false;
318 }
319 if (!reader.readFloat64(param4)) {
320 reader.fail();
321 return false;
322 }
323 return true;
324}
325
326// write param4 field
327bool yCalibrationParameters::write_param4(const yarp::os::idl::WireWriter& writer) const
328{
329 if (!writer.writeFloat64(param4)) {
330 return false;
331 }
332 return true;
333}
334
335// read (nested) param4 field
336bool yCalibrationParameters::nested_read_param4(yarp::os::idl::WireReader& reader)
337{
338 if (reader.noMore()) {
339 reader.fail();
340 return false;
341 }
342 if (!reader.readFloat64(param4)) {
343 reader.fail();
344 return false;
345 }
346 return true;
347}
348
349// write (nested) param4 field
350bool yCalibrationParameters::nested_write_param4(const yarp::os::idl::WireWriter& writer) const
351{
352 if (!writer.writeFloat64(param4)) {
353 return false;
354 }
355 return true;
356}
357
358// read param5 field
359bool yCalibrationParameters::read_param5(yarp::os::idl::WireReader& reader)
360{
361 if (reader.noMore()) {
362 reader.fail();
363 return false;
364 }
365 if (!reader.readFloat64(param5)) {
366 reader.fail();
367 return false;
368 }
369 return true;
370}
371
372// write param5 field
373bool yCalibrationParameters::write_param5(const yarp::os::idl::WireWriter& writer) const
374{
375 if (!writer.writeFloat64(param5)) {
376 return false;
377 }
378 return true;
379}
380
381// read (nested) param5 field
382bool yCalibrationParameters::nested_read_param5(yarp::os::idl::WireReader& reader)
383{
384 if (reader.noMore()) {
385 reader.fail();
386 return false;
387 }
388 if (!reader.readFloat64(param5)) {
389 reader.fail();
390 return false;
391 }
392 return true;
393}
394
395// write (nested) param5 field
396bool yCalibrationParameters::nested_write_param5(const yarp::os::idl::WireWriter& writer) const
397{
398 if (!writer.writeFloat64(param5)) {
399 return false;
400 }
401 return true;
402}
403
404// read paramZero field
405bool yCalibrationParameters::read_paramZero(yarp::os::idl::WireReader& reader)
406{
407 if (reader.noMore()) {
408 reader.fail();
409 return false;
410 }
411 if (!reader.readFloat64(paramZero)) {
412 reader.fail();
413 return false;
414 }
415 return true;
416}
417
418// write paramZero field
419bool yCalibrationParameters::write_paramZero(const yarp::os::idl::WireWriter& writer) const
420{
421 if (!writer.writeFloat64(paramZero)) {
422 return false;
423 }
424 return true;
425}
426
427// read (nested) paramZero field
428bool yCalibrationParameters::nested_read_paramZero(yarp::os::idl::WireReader& reader)
429{
430 if (reader.noMore()) {
431 reader.fail();
432 return false;
433 }
434 if (!reader.readFloat64(paramZero)) {
435 reader.fail();
436 return false;
437 }
438 return true;
439}
440
441// write (nested) paramZero field
442bool yCalibrationParameters::nested_write_paramZero(const yarp::os::idl::WireWriter& writer) const
443{
444 if (!writer.writeFloat64(paramZero)) {
445 return false;
446 }
447 return true;
448}
bool read(yarp::os::idl::WireReader &reader) override
bool write(const yarp::os::idl::WireWriter &writer) const override
yCalibrationParameters()=default
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 readI32(std::int32_t &x)
bool readFloat64(yarp::conf::float64_t &x)
IDL-friendly connection writer.
Definition WireWriter.h:28
bool writeI32(std::int32_t x, bool skip_tag=false) const
bool writeListHeader(int len) const
bool writeFloat64(yarp::conf::float64_t x, bool skip_tag=false) const