aboutsummaryrefslogtreecommitdiffstats
path: root/lcmtype/grid_map_t.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'lcmtype/grid_map_t.cpp')
-rw-r--r--lcmtype/grid_map_t.cpp417
1 files changed, 417 insertions, 0 deletions
diff --git a/lcmtype/grid_map_t.cpp b/lcmtype/grid_map_t.cpp
new file mode 100644
index 0000000..870fd4e
--- /dev/null
+++ b/lcmtype/grid_map_t.cpp
@@ -0,0 +1,417 @@
1// THIS IS AN AUTOMATICALLY GENERATED FILE. DO NOT MODIFY
2// BY HAND!!
3//
4// Generated by lcm-gen
5
6#include "grid_map_t.h"
7#include <string.h>
8
9static int __grid_map_t_hash_computed;
10static uint64_t __grid_map_t_hash;
11
12uint64_t __grid_map_t_hash_recursive(const __lcm_hash_ptr *p) {
13 const __lcm_hash_ptr *fp;
14 for (fp = p; fp != NULL; fp = fp->parent)
15 if (fp->v == __grid_map_t_get_hash)
16 return 0;
17
18 __lcm_hash_ptr cp;
19 cp.parent = p;
20 cp.v = (void *)__grid_map_t_get_hash;
21 (void)cp;
22
23 uint64_t hash =
24 (uint64_t)0x3b95cdd95c1cd816LL + __int64_t_hash_recursive(&cp) +
25 __int8_t_hash_recursive(&cp) + __double_hash_recursive(&cp) +
26 __double_hash_recursive(&cp) + __double_hash_recursive(&cp) +
27 __int32_t_hash_recursive(&cp) + __int32_t_hash_recursive(&cp) +
28 __int32_t_hash_recursive(&cp) + __string_hash_recursive(&cp) +
29 __byte_hash_recursive(&cp);
30
31 return (hash << 1) + ((hash >> 63) & 1);
32}
33
34int64_t __grid_map_t_get_hash(void) {
35 if (!__grid_map_t_hash_computed) {
36 __grid_map_t_hash = (int64_t)__grid_map_t_hash_recursive(NULL);
37 __grid_map_t_hash_computed = 1;
38 }
39
40 return __grid_map_t_hash;
41}
42
43int __grid_map_t_encode_array(void *buf, int offset, int maxlen,
44 const grid_map_t *p, int elements) {
45 int pos = 0, element;
46 int thislen;
47
48 for (element = 0; element < elements; element++) {
49
50 thislen = __int64_t_encode_array(buf, offset + pos, maxlen - pos,
51 &(p[element].utime), 1);
52 if (thislen < 0)
53 return thislen;
54 else
55 pos += thislen;
56
57 thislen = __int8_t_encode_array(buf, offset + pos, maxlen - pos,
58 &(p[element].encoding), 1);
59 if (thislen < 0)
60 return thislen;
61 else
62 pos += thislen;
63
64 thislen = __double_encode_array(buf, offset + pos, maxlen - pos,
65 &(p[element].x0), 1);
66 if (thislen < 0)
67 return thislen;
68 else
69 pos += thislen;
70
71 thislen = __double_encode_array(buf, offset + pos, maxlen - pos,
72 &(p[element].y0), 1);
73 if (thislen < 0)
74 return thislen;
75 else
76 pos += thislen;
77
78 thislen = __double_encode_array(buf, offset + pos, maxlen - pos,
79 &(p[element].meters_per_pixel), 1);
80 if (thislen < 0)
81 return thislen;
82 else
83 pos += thislen;
84
85 thislen = __int32_t_encode_array(buf, offset + pos, maxlen - pos,
86 &(p[element].width), 1);
87 if (thislen < 0)
88 return thislen;
89 else
90 pos += thislen;
91
92 thislen = __int32_t_encode_array(buf, offset + pos, maxlen - pos,
93 &(p[element].height), 1);
94 if (thislen < 0)
95 return thislen;
96 else
97 pos += thislen;
98
99 thislen = __int32_t_encode_array(buf, offset + pos, maxlen - pos,
100 &(p[element].datalen), 1);
101 if (thislen < 0)
102 return thislen;
103 else
104 pos += thislen;
105
106 thislen = __string_encode_array(buf, offset + pos, maxlen - pos,
107 &(p[element].src), 1);
108 if (thislen < 0)
109 return thislen;
110 else
111 pos += thislen;
112
113 thislen = __byte_encode_array(buf, offset + pos, maxlen - pos,
114 p[element].dst, p[element].datalen);
115 if (thislen < 0)
116 return thislen;
117 else
118 pos += thislen;
119 }
120 return pos;
121}
122
123int grid_map_t_encode(void *buf, int offset, int maxlen, const grid_map_t *p) {
124 int pos = 0, thislen;
125 int64_t hash = __grid_map_t_get_hash();
126
127 thislen = __int64_t_encode_array(buf, offset + pos, maxlen - pos, &hash, 1);
128 if (thislen < 0)
129 return thislen;
130 else
131 pos += thislen;
132
133 thislen = __grid_map_t_encode_array(buf, offset + pos, maxlen - pos, p, 1);
134 if (thislen < 0)
135 return thislen;
136 else
137 pos += thislen;
138
139 return pos;
140}
141
142int __grid_map_t_encoded_array_size(const grid_map_t *p, int elements) {
143 int size = 0, element;
144 for (element = 0; element < elements; element++) {
145
146 size += __int64_t_encoded_array_size(&(p[element].utime), 1);
147
148 size += __int8_t_encoded_array_size(&(p[element].encoding), 1);
149
150 size += __double_encoded_array_size(&(p[element].x0), 1);
151
152 size += __double_encoded_array_size(&(p[element].y0), 1);
153
154 size += __double_encoded_array_size(&(p[element].meters_per_pixel), 1);
155
156 size += __int32_t_encoded_array_size(&(p[element].width), 1);
157
158 size += __int32_t_encoded_array_size(&(p[element].height), 1);
159
160 size += __int32_t_encoded_array_size(&(p[element].datalen), 1);
161
162 size += __string_encoded_array_size(&(p[element].src), 1);
163
164 size += __byte_encoded_array_size(p[element].dst, p[element].datalen);
165 }
166 return size;
167}
168
169int grid_map_t_encoded_size(const grid_map_t *p) {
170 return 8 + __grid_map_t_encoded_array_size(p, 1);
171}
172
173int __grid_map_t_decode_array(const void *buf, int offset, int maxlen,
174 grid_map_t *p, int elements) {
175 int pos = 0, thislen, element;
176
177 for (element = 0; element < elements; element++) {
178
179 thislen = __int64_t_decode_array(buf, offset + pos, maxlen - pos,
180 &(p[element].utime), 1);
181 if (thislen < 0)
182 return thislen;
183 else
184 pos += thislen;
185
186 thislen = __int8_t_decode_array(buf, offset + pos, maxlen - pos,
187 &(p[element].encoding), 1);
188 if (thislen < 0)
189 return thislen;
190 else
191 pos += thislen;
192
193 thislen = __double_decode_array(buf, offset + pos, maxlen - pos,
194 &(p[element].x0), 1);
195 if (thislen < 0)
196 return thislen;
197 else
198 pos += thislen;
199
200 thislen = __double_decode_array(buf, offset + pos, maxlen - pos,
201 &(p[element].y0), 1);
202 if (thislen < 0)
203 return thislen;
204 else
205 pos += thislen;
206
207 thislen = __double_decode_array(buf, offset + pos, maxlen - pos,
208 &(p[element].meters_per_pixel), 1);
209 if (thislen < 0)
210 return thislen;
211 else
212 pos += thislen;
213
214 thislen = __int32_t_decode_array(buf, offset + pos, maxlen - pos,
215 &(p[element].width), 1);
216 if (thislen < 0)
217 return thislen;
218 else
219 pos += thislen;
220
221 thislen = __int32_t_decode_array(buf, offset + pos, maxlen - pos,
222 &(p[element].height), 1);
223 if (thislen < 0)
224 return thislen;
225 else
226 pos += thislen;
227
228 thislen = __int32_t_decode_array(buf, offset + pos, maxlen - pos,
229 &(p[element].datalen), 1);
230 if (thislen < 0)
231 return thislen;
232 else
233 pos += thislen;
234
235 thislen = __string_decode_array(buf, offset + pos, maxlen - pos,
236 &(p[element].src), 1);
237 if (thislen < 0)
238 return thislen;
239 else
240 pos += thislen;
241
242 p[element].dst =
243 (uint8_t *)lcm_malloc(sizeof(uint8_t) * p[element].datalen);
244 thislen = __byte_decode_array(buf, offset + pos, maxlen - pos,
245 p[element].dst, p[element].datalen);
246 if (thislen < 0)
247 return thislen;
248 else
249 pos += thislen;
250 }
251 return pos;
252}
253
254int __grid_map_t_decode_array_cleanup(grid_map_t *p, int elements) {
255 int element;
256 for (element = 0; element < elements; element++) {
257
258 __int64_t_decode_array_cleanup(&(p[element].utime), 1);
259
260 __int8_t_decode_array_cleanup(&(p[element].encoding), 1);
261
262 __double_decode_array_cleanup(&(p[element].x0), 1);
263
264 __double_decode_array_cleanup(&(p[element].y0), 1);
265
266 __double_decode_array_cleanup(&(p[element].meters_per_pixel), 1);
267
268 __int32_t_decode_array_cleanup(&(p[element].width), 1);
269
270 __int32_t_decode_array_cleanup(&(p[element].height), 1);
271
272 __int32_t_decode_array_cleanup(&(p[element].datalen), 1);
273
274 __string_decode_array_cleanup(&(p[element].src), 1);
275
276 __byte_decode_array_cleanup(p[element].dst, p[element].datalen);
277 if (p[element].dst)
278 free(p[element].dst);
279 }
280 return 0;
281}
282
283int grid_map_t_decode(const void *buf, int offset, int maxlen, grid_map_t *p) {
284 int pos = 0, thislen;
285 int64_t hash = __grid_map_t_get_hash();
286
287 int64_t this_hash;
288 thislen =
289 __int64_t_decode_array(buf, offset + pos, maxlen - pos, &this_hash, 1);
290 if (thislen < 0)
291 return thislen;
292 else
293 pos += thislen;
294 if (this_hash != hash)
295 return -1;
296
297 thislen = __grid_map_t_decode_array(buf, offset + pos, maxlen - pos, p, 1);
298 if (thislen < 0)
299 return thislen;
300 else
301 pos += thislen;
302
303 return pos;
304}
305
306int grid_map_t_decode_cleanup(grid_map_t *p) {
307 return __grid_map_t_decode_array_cleanup(p, 1);
308}
309
310int __grid_map_t_clone_array(const grid_map_t *p, grid_map_t *q, int elements) {
311 int element;
312 for (element = 0; element < elements; element++) {
313
314 __int64_t_clone_array(&(p[element].utime), &(q[element].utime), 1);
315
316 __int8_t_clone_array(&(p[element].encoding), &(q[element].encoding), 1);
317
318 __double_clone_array(&(p[element].x0), &(q[element].x0), 1);
319
320 __double_clone_array(&(p[element].y0), &(q[element].y0), 1);
321
322 __double_clone_array(&(p[element].meters_per_pixel),
323 &(q[element].meters_per_pixel), 1);
324
325 __int32_t_clone_array(&(p[element].width), &(q[element].width), 1);
326
327 __int32_t_clone_array(&(p[element].height), &(q[element].height), 1);
328
329 __int32_t_clone_array(&(p[element].datalen), &(q[element].datalen), 1);
330
331 __string_clone_array(&(p[element].src), &(q[element].src), 1);
332
333 q[element].dst =
334 (uint8_t *)lcm_malloc(sizeof(uint8_t) * q[element].datalen);
335 __byte_clone_array(p[element].dst, q[element].dst, p[element].datalen);
336 }
337 return 0;
338}
339
340grid_map_t *grid_map_t_copy(const grid_map_t *p) {
341 grid_map_t *q = (grid_map_t *)malloc(sizeof(grid_map_t));
342 __grid_map_t_clone_array(p, q, 1);
343 return q;
344}
345
346void grid_map_t_destroy(grid_map_t *p) {
347 __grid_map_t_decode_array_cleanup(p, 1);
348 free(p);
349}
350
351int grid_map_t_publish(lcm_t *lc, const char *channel, const grid_map_t *p) {
352 int max_data_size = grid_map_t_encoded_size(p);
353 uint8_t *buf = (uint8_t *)malloc(max_data_size);
354 if (!buf)
355 return -1;
356 int data_size = grid_map_t_encode(buf, 0, max_data_size, p);
357 if (data_size < 0) {
358 free(buf);
359 return data_size;
360 }
361 int status = lcm_publish(lc, channel, buf, data_size);
362 free(buf);
363 return status;
364}
365
366struct _grid_map_t_subscription_t {
367 grid_map_t_handler_t user_handler;
368 void *userdata;
369 lcm_subscription_t *lc_h;
370};
371static void grid_map_t_handler_stub(const lcm_recv_buf_t *rbuf,
372 const char *channel, void *userdata) {
373 int status;
374 grid_map_t p;
375 memset(&p, 0, sizeof(grid_map_t));
376 status = grid_map_t_decode(rbuf->data, 0, rbuf->data_size, &p);
377 if (status < 0) {
378 fprintf(stderr, "error %d decoding grid_map_t!!!\n", status);
379 return;
380 }
381
382 grid_map_t_subscription_t *h = (grid_map_t_subscription_t *)userdata;
383 h->user_handler(rbuf, channel, &p, h->userdata);
384
385 grid_map_t_decode_cleanup(&p);
386}
387
388grid_map_t_subscription_t *grid_map_t_subscribe(lcm_t *lcm, const char *channel,
389 grid_map_t_handler_t f,
390 void *userdata) {
391 grid_map_t_subscription_t *n =
392 (grid_map_t_subscription_t *)malloc(sizeof(grid_map_t_subscription_t));
393 n->user_handler = f;
394 n->userdata = userdata;
395 n->lc_h = lcm_subscribe(lcm, channel, grid_map_t_handler_stub, n);
396 if (n->lc_h == NULL) {
397 fprintf(stderr, "couldn't reg grid_map_t LCM handler!\n");
398 free(n);
399 return NULL;
400 }
401 return n;
402}
403
404int grid_map_t_subscription_set_queue_capacity(grid_map_t_subscription_t *subs,
405 int num_messages) {
406 return lcm_subscription_set_queue_capacity(subs->lc_h, num_messages);
407}
408
409int grid_map_t_unsubscribe(lcm_t *lcm, grid_map_t_subscription_t *hid) {
410 int status = lcm_unsubscribe(lcm, hid->lc_h);
411 if (0 != status) {
412 fprintf(stderr, "couldn't unsubscribe grid_map_t_handler %p!\n", hid);
413 return -1;
414 }
415 free(hid);
416 return 0;
417}
generated by cgit v1.2.3-70-g09d2 (git 2.46.0) at 2025-04-12 07:30:15 +0800