YARP
Yet Another Robot Platform
 
Loading...
Searching...
No Matches
return_getCurrentImpedanceLimit.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
12
13// Constructor with field values
15 const double min_stiffness,
16 const double max_stiffness,
17 const double min_damping,
18 const double max_damping) :
19 WirePortable(),
20 ret(ret),
21 min_stiffness(min_stiffness),
22 max_stiffness(max_stiffness),
23 min_damping(min_damping),
24 max_damping(max_damping)
25{
26}
27
28// Read structure on a Wire
30{
31 if (!nested_read_ret(reader)) {
32 return false;
33 }
34 if (!read_min_stiffness(reader)) {
35 return false;
36 }
37 if (!read_max_stiffness(reader)) {
38 return false;
39 }
40 if (!read_min_damping(reader)) {
41 return false;
42 }
43 if (!read_max_damping(reader)) {
44 return false;
45 }
46 if (reader.isError()) {
47 return false;
48 }
49 return true;
50}
51
52// Read structure on a Connection
54{
55 yarp::os::idl::WireReader reader(connection);
56 if (!reader.readListHeader(5)) {
57 return false;
58 }
59 if (!read(reader)) {
60 return false;
61 }
62 return true;
63}
64
65// Write structure on a Wire
67{
68 if (!nested_write_ret(writer)) {
69 return false;
70 }
71 if (!write_min_stiffness(writer)) {
72 return false;
73 }
74 if (!write_max_stiffness(writer)) {
75 return false;
76 }
77 if (!write_min_damping(writer)) {
78 return false;
79 }
80 if (!write_max_damping(writer)) {
81 return false;
82 }
83 if (writer.isError()) {
84 return false;
85 }
86 return true;
87}
88
89// Write structure on a Connection
91{
92 yarp::os::idl::WireWriter writer(connection);
93 if (!writer.writeListHeader(5)) {
94 return false;
95 }
96 if (!write(writer)) {
97 return false;
98 }
99 return true;
100}
101
102// Convert to a printable string
104{
106 if (!yarp::os::Portable::copyPortable(*this, b)) {
107 return {};
108 }
109 return b.toString();
110}
111
112// read ret field
113bool return_getCurrentImpedanceLimit::read_ret(yarp::os::idl::WireReader& reader)
114{
115 if (reader.noMore()) {
116 reader.fail();
117 return false;
118 }
119 if (!reader.read(ret)) {
120 reader.fail();
121 return false;
122 }
123 return true;
124}
125
126// write ret field
127bool return_getCurrentImpedanceLimit::write_ret(const yarp::os::idl::WireWriter& writer) const
128{
129 if (!writer.write(ret)) {
130 return false;
131 }
132 return true;
133}
134
135// read (nested) ret field
136bool return_getCurrentImpedanceLimit::nested_read_ret(yarp::os::idl::WireReader& reader)
137{
138 if (reader.noMore()) {
139 reader.fail();
140 return false;
141 }
142 if (!reader.readNested(ret)) {
143 reader.fail();
144 return false;
145 }
146 return true;
147}
148
149// write (nested) ret field
150bool return_getCurrentImpedanceLimit::nested_write_ret(const yarp::os::idl::WireWriter& writer) const
151{
152 if (!writer.writeNested(ret)) {
153 return false;
154 }
155 return true;
156}
157
158// read min_stiffness field
159bool return_getCurrentImpedanceLimit::read_min_stiffness(yarp::os::idl::WireReader& reader)
160{
161 if (reader.noMore()) {
162 reader.fail();
163 return false;
164 }
165 if (!reader.readFloat64(min_stiffness)) {
166 reader.fail();
167 return false;
168 }
169 return true;
170}
171
172// write min_stiffness field
173bool return_getCurrentImpedanceLimit::write_min_stiffness(const yarp::os::idl::WireWriter& writer) const
174{
175 if (!writer.writeFloat64(min_stiffness)) {
176 return false;
177 }
178 return true;
179}
180
181// read (nested) min_stiffness field
182bool return_getCurrentImpedanceLimit::nested_read_min_stiffness(yarp::os::idl::WireReader& reader)
183{
184 if (reader.noMore()) {
185 reader.fail();
186 return false;
187 }
188 if (!reader.readFloat64(min_stiffness)) {
189 reader.fail();
190 return false;
191 }
192 return true;
193}
194
195// write (nested) min_stiffness field
196bool return_getCurrentImpedanceLimit::nested_write_min_stiffness(const yarp::os::idl::WireWriter& writer) const
197{
198 if (!writer.writeFloat64(min_stiffness)) {
199 return false;
200 }
201 return true;
202}
203
204// read max_stiffness field
205bool return_getCurrentImpedanceLimit::read_max_stiffness(yarp::os::idl::WireReader& reader)
206{
207 if (reader.noMore()) {
208 reader.fail();
209 return false;
210 }
211 if (!reader.readFloat64(max_stiffness)) {
212 reader.fail();
213 return false;
214 }
215 return true;
216}
217
218// write max_stiffness field
219bool return_getCurrentImpedanceLimit::write_max_stiffness(const yarp::os::idl::WireWriter& writer) const
220{
221 if (!writer.writeFloat64(max_stiffness)) {
222 return false;
223 }
224 return true;
225}
226
227// read (nested) max_stiffness field
228bool return_getCurrentImpedanceLimit::nested_read_max_stiffness(yarp::os::idl::WireReader& reader)
229{
230 if (reader.noMore()) {
231 reader.fail();
232 return false;
233 }
234 if (!reader.readFloat64(max_stiffness)) {
235 reader.fail();
236 return false;
237 }
238 return true;
239}
240
241// write (nested) max_stiffness field
242bool return_getCurrentImpedanceLimit::nested_write_max_stiffness(const yarp::os::idl::WireWriter& writer) const
243{
244 if (!writer.writeFloat64(max_stiffness)) {
245 return false;
246 }
247 return true;
248}
249
250// read min_damping field
251bool return_getCurrentImpedanceLimit::read_min_damping(yarp::os::idl::WireReader& reader)
252{
253 if (reader.noMore()) {
254 reader.fail();
255 return false;
256 }
257 if (!reader.readFloat64(min_damping)) {
258 reader.fail();
259 return false;
260 }
261 return true;
262}
263
264// write min_damping field
265bool return_getCurrentImpedanceLimit::write_min_damping(const yarp::os::idl::WireWriter& writer) const
266{
267 if (!writer.writeFloat64(min_damping)) {
268 return false;
269 }
270 return true;
271}
272
273// read (nested) min_damping field
274bool return_getCurrentImpedanceLimit::nested_read_min_damping(yarp::os::idl::WireReader& reader)
275{
276 if (reader.noMore()) {
277 reader.fail();
278 return false;
279 }
280 if (!reader.readFloat64(min_damping)) {
281 reader.fail();
282 return false;
283 }
284 return true;
285}
286
287// write (nested) min_damping field
288bool return_getCurrentImpedanceLimit::nested_write_min_damping(const yarp::os::idl::WireWriter& writer) const
289{
290 if (!writer.writeFloat64(min_damping)) {
291 return false;
292 }
293 return true;
294}
295
296// read max_damping field
297bool return_getCurrentImpedanceLimit::read_max_damping(yarp::os::idl::WireReader& reader)
298{
299 if (reader.noMore()) {
300 reader.fail();
301 return false;
302 }
303 if (!reader.readFloat64(max_damping)) {
304 reader.fail();
305 return false;
306 }
307 return true;
308}
309
310// write max_damping field
311bool return_getCurrentImpedanceLimit::write_max_damping(const yarp::os::idl::WireWriter& writer) const
312{
313 if (!writer.writeFloat64(max_damping)) {
314 return false;
315 }
316 return true;
317}
318
319// read (nested) max_damping field
320bool return_getCurrentImpedanceLimit::nested_read_max_damping(yarp::os::idl::WireReader& reader)
321{
322 if (reader.noMore()) {
323 reader.fail();
324 return false;
325 }
326 if (!reader.readFloat64(max_damping)) {
327 reader.fail();
328 return false;
329 }
330 return true;
331}
332
333// write (nested) max_damping field
334bool return_getCurrentImpedanceLimit::nested_write_max_damping(const yarp::os::idl::WireWriter& writer) const
335{
336 if (!writer.writeFloat64(max_damping)) {
337 return false;
338 }
339 return true;
340}
bool read(yarp::os::idl::WireReader &reader) override
bool write(const yarp::os::idl::WireWriter &writer) const override
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)
bool read(WirePortable &obj)
bool readFloat64(yarp::conf::float64_t &x)
IDL-friendly connection writer.
Definition WireWriter.h:28
bool write(const WirePortable &obj) const
bool writeListHeader(int len) const
bool writeFloat64(yarp::conf::float64_t x, bool skip_tag=false) const
bool writeNested(const WirePortable &obj) const