YARP
Yet Another Robot Platform
 
Loading...
Searching...
No Matches
yMotorTorqueParameters.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 bemf_scale,
16 const double ktau,
17 const double ktau_scale,
18 const double viscousPos,
19 const double viscousNeg,
20 const double coulombPos,
21 const double coulombNeg,
22 const double velocityThres) :
23 WirePortable(),
24 bemf(bemf),
25 bemf_scale(bemf_scale),
26 ktau(ktau),
27 ktau_scale(ktau_scale),
28 viscousPos(viscousPos),
29 viscousNeg(viscousNeg),
30 coulombPos(coulombPos),
31 coulombNeg(coulombNeg),
32 velocityThres(velocityThres)
33{
34}
35
36// Read structure on a Wire
38{
39 if (!read_bemf(reader)) {
40 return false;
41 }
42 if (!read_bemf_scale(reader)) {
43 return false;
44 }
45 if (!read_ktau(reader)) {
46 return false;
47 }
48 if (!read_ktau_scale(reader)) {
49 return false;
50 }
51 if (!read_viscousPos(reader)) {
52 return false;
53 }
54 if (!read_viscousNeg(reader)) {
55 return false;
56 }
57 if (!read_coulombPos(reader)) {
58 return false;
59 }
60 if (!read_coulombNeg(reader)) {
61 return false;
62 }
63 if (!read_velocityThres(reader)) {
64 return false;
65 }
66 if (reader.isError()) {
67 return false;
68 }
69 return true;
70}
71
72// Read structure on a Connection
74{
75 yarp::os::idl::WireReader reader(connection);
76 if (!reader.readListHeader(9)) {
77 return false;
78 }
79 if (!read(reader)) {
80 return false;
81 }
82 return true;
83}
84
85// Write structure on a Wire
87{
88 if (!write_bemf(writer)) {
89 return false;
90 }
91 if (!write_bemf_scale(writer)) {
92 return false;
93 }
94 if (!write_ktau(writer)) {
95 return false;
96 }
97 if (!write_ktau_scale(writer)) {
98 return false;
99 }
100 if (!write_viscousPos(writer)) {
101 return false;
102 }
103 if (!write_viscousNeg(writer)) {
104 return false;
105 }
106 if (!write_coulombPos(writer)) {
107 return false;
108 }
109 if (!write_coulombNeg(writer)) {
110 return false;
111 }
112 if (!write_velocityThres(writer)) {
113 return false;
114 }
115 if (writer.isError()) {
116 return false;
117 }
118 return true;
119}
120
121// Write structure on a Connection
123{
124 yarp::os::idl::WireWriter writer(connection);
125 if (!writer.writeListHeader(9)) {
126 return false;
127 }
128 if (!write(writer)) {
129 return false;
130 }
131 return true;
132}
133
134// Convert to a printable string
136{
138 if (!yarp::os::Portable::copyPortable(*this, b)) {
139 return {};
140 }
141 return b.toString();
142}
143
144// read bemf field
145bool yMotorTorqueParameters::read_bemf(yarp::os::idl::WireReader& reader)
146{
147 if (reader.noMore()) {
148 reader.fail();
149 return false;
150 }
151 if (!reader.readFloat64(bemf)) {
152 reader.fail();
153 return false;
154 }
155 return true;
156}
157
158// write bemf field
159bool yMotorTorqueParameters::write_bemf(const yarp::os::idl::WireWriter& writer) const
160{
161 if (!writer.writeFloat64(bemf)) {
162 return false;
163 }
164 return true;
165}
166
167// read (nested) bemf field
168bool yMotorTorqueParameters::nested_read_bemf(yarp::os::idl::WireReader& reader)
169{
170 if (reader.noMore()) {
171 reader.fail();
172 return false;
173 }
174 if (!reader.readFloat64(bemf)) {
175 reader.fail();
176 return false;
177 }
178 return true;
179}
180
181// write (nested) bemf field
182bool yMotorTorqueParameters::nested_write_bemf(const yarp::os::idl::WireWriter& writer) const
183{
184 if (!writer.writeFloat64(bemf)) {
185 return false;
186 }
187 return true;
188}
189
190// read bemf_scale field
191bool yMotorTorqueParameters::read_bemf_scale(yarp::os::idl::WireReader& reader)
192{
193 if (reader.noMore()) {
194 reader.fail();
195 return false;
196 }
197 if (!reader.readFloat64(bemf_scale)) {
198 reader.fail();
199 return false;
200 }
201 return true;
202}
203
204// write bemf_scale field
205bool yMotorTorqueParameters::write_bemf_scale(const yarp::os::idl::WireWriter& writer) const
206{
207 if (!writer.writeFloat64(bemf_scale)) {
208 return false;
209 }
210 return true;
211}
212
213// read (nested) bemf_scale field
214bool yMotorTorqueParameters::nested_read_bemf_scale(yarp::os::idl::WireReader& reader)
215{
216 if (reader.noMore()) {
217 reader.fail();
218 return false;
219 }
220 if (!reader.readFloat64(bemf_scale)) {
221 reader.fail();
222 return false;
223 }
224 return true;
225}
226
227// write (nested) bemf_scale field
228bool yMotorTorqueParameters::nested_write_bemf_scale(const yarp::os::idl::WireWriter& writer) const
229{
230 if (!writer.writeFloat64(bemf_scale)) {
231 return false;
232 }
233 return true;
234}
235
236// read ktau field
237bool yMotorTorqueParameters::read_ktau(yarp::os::idl::WireReader& reader)
238{
239 if (reader.noMore()) {
240 reader.fail();
241 return false;
242 }
243 if (!reader.readFloat64(ktau)) {
244 reader.fail();
245 return false;
246 }
247 return true;
248}
249
250// write ktau field
251bool yMotorTorqueParameters::write_ktau(const yarp::os::idl::WireWriter& writer) const
252{
253 if (!writer.writeFloat64(ktau)) {
254 return false;
255 }
256 return true;
257}
258
259// read (nested) ktau field
260bool yMotorTorqueParameters::nested_read_ktau(yarp::os::idl::WireReader& reader)
261{
262 if (reader.noMore()) {
263 reader.fail();
264 return false;
265 }
266 if (!reader.readFloat64(ktau)) {
267 reader.fail();
268 return false;
269 }
270 return true;
271}
272
273// write (nested) ktau field
274bool yMotorTorqueParameters::nested_write_ktau(const yarp::os::idl::WireWriter& writer) const
275{
276 if (!writer.writeFloat64(ktau)) {
277 return false;
278 }
279 return true;
280}
281
282// read ktau_scale field
283bool yMotorTorqueParameters::read_ktau_scale(yarp::os::idl::WireReader& reader)
284{
285 if (reader.noMore()) {
286 reader.fail();
287 return false;
288 }
289 if (!reader.readFloat64(ktau_scale)) {
290 reader.fail();
291 return false;
292 }
293 return true;
294}
295
296// write ktau_scale field
297bool yMotorTorqueParameters::write_ktau_scale(const yarp::os::idl::WireWriter& writer) const
298{
299 if (!writer.writeFloat64(ktau_scale)) {
300 return false;
301 }
302 return true;
303}
304
305// read (nested) ktau_scale field
306bool yMotorTorqueParameters::nested_read_ktau_scale(yarp::os::idl::WireReader& reader)
307{
308 if (reader.noMore()) {
309 reader.fail();
310 return false;
311 }
312 if (!reader.readFloat64(ktau_scale)) {
313 reader.fail();
314 return false;
315 }
316 return true;
317}
318
319// write (nested) ktau_scale field
320bool yMotorTorqueParameters::nested_write_ktau_scale(const yarp::os::idl::WireWriter& writer) const
321{
322 if (!writer.writeFloat64(ktau_scale)) {
323 return false;
324 }
325 return true;
326}
327
328// read viscousPos field
329bool yMotorTorqueParameters::read_viscousPos(yarp::os::idl::WireReader& reader)
330{
331 if (reader.noMore()) {
332 reader.fail();
333 return false;
334 }
335 if (!reader.readFloat64(viscousPos)) {
336 reader.fail();
337 return false;
338 }
339 return true;
340}
341
342// write viscousPos field
343bool yMotorTorqueParameters::write_viscousPos(const yarp::os::idl::WireWriter& writer) const
344{
345 if (!writer.writeFloat64(viscousPos)) {
346 return false;
347 }
348 return true;
349}
350
351// read (nested) viscousPos field
352bool yMotorTorqueParameters::nested_read_viscousPos(yarp::os::idl::WireReader& reader)
353{
354 if (reader.noMore()) {
355 reader.fail();
356 return false;
357 }
358 if (!reader.readFloat64(viscousPos)) {
359 reader.fail();
360 return false;
361 }
362 return true;
363}
364
365// write (nested) viscousPos field
366bool yMotorTorqueParameters::nested_write_viscousPos(const yarp::os::idl::WireWriter& writer) const
367{
368 if (!writer.writeFloat64(viscousPos)) {
369 return false;
370 }
371 return true;
372}
373
374// read viscousNeg field
375bool yMotorTorqueParameters::read_viscousNeg(yarp::os::idl::WireReader& reader)
376{
377 if (reader.noMore()) {
378 reader.fail();
379 return false;
380 }
381 if (!reader.readFloat64(viscousNeg)) {
382 reader.fail();
383 return false;
384 }
385 return true;
386}
387
388// write viscousNeg field
389bool yMotorTorqueParameters::write_viscousNeg(const yarp::os::idl::WireWriter& writer) const
390{
391 if (!writer.writeFloat64(viscousNeg)) {
392 return false;
393 }
394 return true;
395}
396
397// read (nested) viscousNeg field
398bool yMotorTorqueParameters::nested_read_viscousNeg(yarp::os::idl::WireReader& reader)
399{
400 if (reader.noMore()) {
401 reader.fail();
402 return false;
403 }
404 if (!reader.readFloat64(viscousNeg)) {
405 reader.fail();
406 return false;
407 }
408 return true;
409}
410
411// write (nested) viscousNeg field
412bool yMotorTorqueParameters::nested_write_viscousNeg(const yarp::os::idl::WireWriter& writer) const
413{
414 if (!writer.writeFloat64(viscousNeg)) {
415 return false;
416 }
417 return true;
418}
419
420// read coulombPos field
421bool yMotorTorqueParameters::read_coulombPos(yarp::os::idl::WireReader& reader)
422{
423 if (reader.noMore()) {
424 reader.fail();
425 return false;
426 }
427 if (!reader.readFloat64(coulombPos)) {
428 reader.fail();
429 return false;
430 }
431 return true;
432}
433
434// write coulombPos field
435bool yMotorTorqueParameters::write_coulombPos(const yarp::os::idl::WireWriter& writer) const
436{
437 if (!writer.writeFloat64(coulombPos)) {
438 return false;
439 }
440 return true;
441}
442
443// read (nested) coulombPos field
444bool yMotorTorqueParameters::nested_read_coulombPos(yarp::os::idl::WireReader& reader)
445{
446 if (reader.noMore()) {
447 reader.fail();
448 return false;
449 }
450 if (!reader.readFloat64(coulombPos)) {
451 reader.fail();
452 return false;
453 }
454 return true;
455}
456
457// write (nested) coulombPos field
458bool yMotorTorqueParameters::nested_write_coulombPos(const yarp::os::idl::WireWriter& writer) const
459{
460 if (!writer.writeFloat64(coulombPos)) {
461 return false;
462 }
463 return true;
464}
465
466// read coulombNeg field
467bool yMotorTorqueParameters::read_coulombNeg(yarp::os::idl::WireReader& reader)
468{
469 if (reader.noMore()) {
470 reader.fail();
471 return false;
472 }
473 if (!reader.readFloat64(coulombNeg)) {
474 reader.fail();
475 return false;
476 }
477 return true;
478}
479
480// write coulombNeg field
481bool yMotorTorqueParameters::write_coulombNeg(const yarp::os::idl::WireWriter& writer) const
482{
483 if (!writer.writeFloat64(coulombNeg)) {
484 return false;
485 }
486 return true;
487}
488
489// read (nested) coulombNeg field
490bool yMotorTorqueParameters::nested_read_coulombNeg(yarp::os::idl::WireReader& reader)
491{
492 if (reader.noMore()) {
493 reader.fail();
494 return false;
495 }
496 if (!reader.readFloat64(coulombNeg)) {
497 reader.fail();
498 return false;
499 }
500 return true;
501}
502
503// write (nested) coulombNeg field
504bool yMotorTorqueParameters::nested_write_coulombNeg(const yarp::os::idl::WireWriter& writer) const
505{
506 if (!writer.writeFloat64(coulombNeg)) {
507 return false;
508 }
509 return true;
510}
511
512// read velocityThres field
513bool yMotorTorqueParameters::read_velocityThres(yarp::os::idl::WireReader& reader)
514{
515 if (reader.noMore()) {
516 reader.fail();
517 return false;
518 }
519 if (!reader.readFloat64(velocityThres)) {
520 reader.fail();
521 return false;
522 }
523 return true;
524}
525
526// write velocityThres field
527bool yMotorTorqueParameters::write_velocityThres(const yarp::os::idl::WireWriter& writer) const
528{
529 if (!writer.writeFloat64(velocityThres)) {
530 return false;
531 }
532 return true;
533}
534
535// read (nested) velocityThres field
536bool yMotorTorqueParameters::nested_read_velocityThres(yarp::os::idl::WireReader& reader)
537{
538 if (reader.noMore()) {
539 reader.fail();
540 return false;
541 }
542 if (!reader.readFloat64(velocityThres)) {
543 reader.fail();
544 return false;
545 }
546 return true;
547}
548
549// write (nested) velocityThres field
550bool yMotorTorqueParameters::nested_write_velocityThres(const yarp::os::idl::WireWriter& writer) const
551{
552 if (!writer.writeFloat64(velocityThres)) {
553 return false;
554 }
555 return true;
556}
yMotorTorqueParameters()=default
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 readFloat64(yarp::conf::float64_t &x)
IDL-friendly connection writer.
Definition WireWriter.h:28
bool writeListHeader(int len) const
bool writeFloat64(yarp::conf::float64_t x, bool skip_tag=false) const