00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00035 #include <string.h>
00036 #include "lcmtypes_laser_t.h"
00037
00038 static int __lcmtypes_laser_t_hash_computed;
00039 static int64_t __lcmtypes_laser_t_hash;
00040
00041 int64_t __lcmtypes_laser_t_hash_recursive(const __lcm_hash_ptr *p)
00042 {
00043 const __lcm_hash_ptr *fp;
00044 for (fp = p; fp != NULL; fp = fp->parent)
00045 if (fp->v == __lcmtypes_laser_t_get_hash)
00046 return 0;
00047
00048 const __lcm_hash_ptr cp = { p, (void*)__lcmtypes_laser_t_get_hash };
00049 (void) cp;
00050
00051 int64_t hash = 0xf1e8ba118c05af46LL
00052 + __int64_t_hash_recursive(&cp)
00053 + __int32_t_hash_recursive(&cp)
00054 + __float_hash_recursive(&cp)
00055 + __int32_t_hash_recursive(&cp)
00056 + __float_hash_recursive(&cp)
00057 + __float_hash_recursive(&cp)
00058 + __float_hash_recursive(&cp)
00059 ;
00060
00061 return (hash<<1) + ((hash>>63)&1);
00062 }
00063
00064 int64_t __lcmtypes_laser_t_get_hash(void)
00065 {
00066 if (!__lcmtypes_laser_t_hash_computed) {
00067 __lcmtypes_laser_t_hash = __lcmtypes_laser_t_hash_recursive(NULL);
00068 __lcmtypes_laser_t_hash_computed = 1;
00069 }
00070
00071 return __lcmtypes_laser_t_hash;
00072 }
00073
00074 int __lcmtypes_laser_t_encode_array(void *buf, int offset, int maxlen, const lcmtypes_laser_t *p, int elements)
00075 {
00076 int pos = 0, thislen, element;
00077
00078 for (element = 0; element < elements; element++) {
00079
00080 thislen = __int64_t_encode_array(buf, offset + pos, maxlen - pos, &(p[element].utime), 1);
00081 if (thislen < 0) return thislen; else pos += thislen;
00082
00083 thislen = __int32_t_encode_array(buf, offset + pos, maxlen - pos, &(p[element].nranges), 1);
00084 if (thislen < 0) return thislen; else pos += thislen;
00085
00086 thislen = __float_encode_array(buf, offset + pos, maxlen - pos, p[element].ranges, p[element].nranges);
00087 if (thislen < 0) return thislen; else pos += thislen;
00088
00089 thislen = __int32_t_encode_array(buf, offset + pos, maxlen - pos, &(p[element].nintensities), 1);
00090 if (thislen < 0) return thislen; else pos += thislen;
00091
00092 thislen = __float_encode_array(buf, offset + pos, maxlen - pos, p[element].intensities, p[element].nintensities);
00093 if (thislen < 0) return thislen; else pos += thislen;
00094
00095 thislen = __float_encode_array(buf, offset + pos, maxlen - pos, &(p[element].rad0), 1);
00096 if (thislen < 0) return thislen; else pos += thislen;
00097
00098 thislen = __float_encode_array(buf, offset + pos, maxlen - pos, &(p[element].radstep), 1);
00099 if (thislen < 0) return thislen; else pos += thislen;
00100
00101 }
00102 return pos;
00103 }
00104
00105 int lcmtypes_laser_t_encode(void *buf, int offset, int maxlen, const lcmtypes_laser_t *p)
00106 {
00107 int pos = 0, thislen;
00108 int64_t hash = __lcmtypes_laser_t_get_hash();
00109
00110 thislen = __int64_t_encode_array(buf, offset + pos, maxlen - pos, &hash, 1);
00111 if (thislen < 0) return thislen; else pos += thislen;
00112
00113 thislen = __lcmtypes_laser_t_encode_array(buf, offset + pos, maxlen - pos, p, 1);
00114 if (thislen < 0) return thislen; else pos += thislen;
00115
00116 return pos;
00117 }
00118
00119 int __lcmtypes_laser_t_encoded_array_size(const lcmtypes_laser_t *p, int elements)
00120 {
00121 int size = 0, element;
00122 for (element = 0; element < elements; element++) {
00123
00124 size += __int64_t_encoded_array_size(&(p[element].utime), 1);
00125
00126 size += __int32_t_encoded_array_size(&(p[element].nranges), 1);
00127
00128 size += __float_encoded_array_size(p[element].ranges, p[element].nranges);
00129
00130 size += __int32_t_encoded_array_size(&(p[element].nintensities), 1);
00131
00132 size += __float_encoded_array_size(p[element].intensities, p[element].nintensities);
00133
00134 size += __float_encoded_array_size(&(p[element].rad0), 1);
00135
00136 size += __float_encoded_array_size(&(p[element].radstep), 1);
00137
00138 }
00139 return size;
00140 }
00141
00142 int lcmtypes_laser_t_encoded_size(const lcmtypes_laser_t *p)
00143 {
00144 return 8 + __lcmtypes_laser_t_encoded_array_size(p, 1);
00145 }
00146
00147 int __lcmtypes_laser_t_decode_array(const void *buf, int offset, int maxlen, lcmtypes_laser_t *p, int elements)
00148 {
00149 int pos = 0, thislen, element;
00150
00151 for (element = 0; element < elements; element++) {
00152
00153 thislen = __int64_t_decode_array(buf, offset + pos, maxlen - pos, &(p[element].utime), 1);
00154 if (thislen < 0) return thislen; else pos += thislen;
00155
00156 thislen = __int32_t_decode_array(buf, offset + pos, maxlen - pos, &(p[element].nranges), 1);
00157 if (thislen < 0) return thislen; else pos += thislen;
00158
00159 p[element].ranges = (float*) lcm_malloc(sizeof(float) * p[element].nranges);
00160 thislen = __float_decode_array(buf, offset + pos, maxlen - pos, p[element].ranges, p[element].nranges);
00161 if (thislen < 0) return thislen; else pos += thislen;
00162
00163 thislen = __int32_t_decode_array(buf, offset + pos, maxlen - pos, &(p[element].nintensities), 1);
00164 if (thislen < 0) return thislen; else pos += thislen;
00165
00166 p[element].intensities = (float*) lcm_malloc(sizeof(float) * p[element].nintensities);
00167 thislen = __float_decode_array(buf, offset + pos, maxlen - pos, p[element].intensities, p[element].nintensities);
00168 if (thislen < 0) return thislen; else pos += thislen;
00169
00170 thislen = __float_decode_array(buf, offset + pos, maxlen - pos, &(p[element].rad0), 1);
00171 if (thislen < 0) return thislen; else pos += thislen;
00172
00173 thislen = __float_decode_array(buf, offset + pos, maxlen - pos, &(p[element].radstep), 1);
00174 if (thislen < 0) return thislen; else pos += thislen;
00175
00176 }
00177 return pos;
00178 }
00179
00180 int __lcmtypes_laser_t_decode_array_cleanup(lcmtypes_laser_t *p, int elements)
00181 {
00182 int element;
00183 for (element = 0; element < elements; element++) {
00184
00185 __int64_t_decode_array_cleanup(&(p[element].utime), 1);
00186
00187 __int32_t_decode_array_cleanup(&(p[element].nranges), 1);
00188
00189 __float_decode_array_cleanup(p[element].ranges, p[element].nranges);
00190 if (p[element].ranges) free(p[element].ranges);
00191
00192 __int32_t_decode_array_cleanup(&(p[element].nintensities), 1);
00193
00194 __float_decode_array_cleanup(p[element].intensities, p[element].nintensities);
00195 if (p[element].intensities) free(p[element].intensities);
00196
00197 __float_decode_array_cleanup(&(p[element].rad0), 1);
00198
00199 __float_decode_array_cleanup(&(p[element].radstep), 1);
00200
00201 }
00202 return 0;
00203 }
00204
00205 int lcmtypes_laser_t_decode(const void *buf, int offset, int maxlen, lcmtypes_laser_t *p)
00206 {
00207 int pos = 0, thislen;
00208 int64_t hash = __lcmtypes_laser_t_get_hash();
00209
00210 int64_t this_hash;
00211 thislen = __int64_t_decode_array(buf, offset + pos, maxlen - pos, &this_hash, 1);
00212 if (thislen < 0) return thislen; else pos += thislen;
00213 if (this_hash != hash) return -1;
00214
00215 thislen = __lcmtypes_laser_t_decode_array(buf, offset + pos, maxlen - pos, p, 1);
00216 if (thislen < 0) return thislen; else pos += thislen;
00217
00218 return pos;
00219 }
00220
00221 int lcmtypes_laser_t_decode_cleanup(lcmtypes_laser_t *p)
00222 {
00223 return __lcmtypes_laser_t_decode_array_cleanup(p, 1);
00224 }
00225
00226 int __lcmtypes_laser_t_clone_array(const lcmtypes_laser_t *p, lcmtypes_laser_t *q, int elements)
00227 {
00228 int element;
00229 for (element = 0; element < elements; element++) {
00230
00231 __int64_t_clone_array(&(p[element].utime), &(q[element].utime), 1);
00232
00233 __int32_t_clone_array(&(p[element].nranges), &(q[element].nranges), 1);
00234
00235 q[element].ranges = (float*) lcm_malloc(sizeof(float) * q[element].nranges);
00236 __float_clone_array(p[element].ranges, q[element].ranges, p[element].nranges);
00237
00238 __int32_t_clone_array(&(p[element].nintensities), &(q[element].nintensities), 1);
00239
00240 q[element].intensities = (float*) lcm_malloc(sizeof(float) * q[element].nintensities);
00241 __float_clone_array(p[element].intensities, q[element].intensities, p[element].nintensities);
00242
00243 __float_clone_array(&(p[element].rad0), &(q[element].rad0), 1);
00244
00245 __float_clone_array(&(p[element].radstep), &(q[element].radstep), 1);
00246
00247 }
00248 return 0;
00249 }
00250
00251 lcmtypes_laser_t *lcmtypes_laser_t_copy(const lcmtypes_laser_t *p)
00252 {
00253 lcmtypes_laser_t *q = (lcmtypes_laser_t*) malloc(sizeof(lcmtypes_laser_t));
00254 __lcmtypes_laser_t_clone_array(p, q, 1);
00255 return q;
00256 }
00257
00258 void lcmtypes_laser_t_destroy(lcmtypes_laser_t *p)
00259 {
00260 __lcmtypes_laser_t_decode_array_cleanup(p, 1);
00261 free(p);
00262 }