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_velodyne_t.h"
00037
00038 static int __lcmtypes_velodyne_t_hash_computed;
00039 static int64_t __lcmtypes_velodyne_t_hash;
00040
00041 int64_t __lcmtypes_velodyne_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_velodyne_t_get_hash)
00046 return 0;
00047
00048 const __lcm_hash_ptr cp = { p, (void*)__lcmtypes_velodyne_t_get_hash };
00049 (void) cp;
00050
00051 int64_t hash = 0xb6befe08f6d416d3LL
00052 + __int64_t_hash_recursive(&cp)
00053 + __int32_t_hash_recursive(&cp)
00054 + __byte_hash_recursive(&cp)
00055 ;
00056
00057 return (hash<<1) + ((hash>>63)&1);
00058 }
00059
00060 int64_t __lcmtypes_velodyne_t_get_hash(void)
00061 {
00062 if (!__lcmtypes_velodyne_t_hash_computed) {
00063 __lcmtypes_velodyne_t_hash = __lcmtypes_velodyne_t_hash_recursive(NULL);
00064 __lcmtypes_velodyne_t_hash_computed = 1;
00065 }
00066
00067 return __lcmtypes_velodyne_t_hash;
00068 }
00069
00070 int __lcmtypes_velodyne_t_encode_array(void *buf, int offset, int maxlen, const lcmtypes_velodyne_t *p, int elements)
00071 {
00072 int pos = 0, thislen, element;
00073
00074 for (element = 0; element < elements; element++) {
00075
00076 thislen = __int64_t_encode_array(buf, offset + pos, maxlen - pos, &(p[element].utime), 1);
00077 if (thislen < 0) return thislen; else pos += thislen;
00078
00079 thislen = __int32_t_encode_array(buf, offset + pos, maxlen - pos, &(p[element].datalen), 1);
00080 if (thislen < 0) return thislen; else pos += thislen;
00081
00082 thislen = __byte_encode_array(buf, offset + pos, maxlen - pos, p[element].data, p[element].datalen);
00083 if (thislen < 0) return thislen; else pos += thislen;
00084
00085 }
00086 return pos;
00087 }
00088
00089 int lcmtypes_velodyne_t_encode(void *buf, int offset, int maxlen, const lcmtypes_velodyne_t *p)
00090 {
00091 int pos = 0, thislen;
00092 int64_t hash = __lcmtypes_velodyne_t_get_hash();
00093
00094 thislen = __int64_t_encode_array(buf, offset + pos, maxlen - pos, &hash, 1);
00095 if (thislen < 0) return thislen; else pos += thislen;
00096
00097 thislen = __lcmtypes_velodyne_t_encode_array(buf, offset + pos, maxlen - pos, p, 1);
00098 if (thislen < 0) return thislen; else pos += thislen;
00099
00100 return pos;
00101 }
00102
00103 int __lcmtypes_velodyne_t_encoded_array_size(const lcmtypes_velodyne_t *p, int elements)
00104 {
00105 int size = 0, element;
00106 for (element = 0; element < elements; element++) {
00107
00108 size += __int64_t_encoded_array_size(&(p[element].utime), 1);
00109
00110 size += __int32_t_encoded_array_size(&(p[element].datalen), 1);
00111
00112 size += __byte_encoded_array_size(p[element].data, p[element].datalen);
00113
00114 }
00115 return size;
00116 }
00117
00118 int lcmtypes_velodyne_t_encoded_size(const lcmtypes_velodyne_t *p)
00119 {
00120 return 8 + __lcmtypes_velodyne_t_encoded_array_size(p, 1);
00121 }
00122
00123 int __lcmtypes_velodyne_t_decode_array(const void *buf, int offset, int maxlen, lcmtypes_velodyne_t *p, int elements)
00124 {
00125 int pos = 0, thislen, element;
00126
00127 for (element = 0; element < elements; element++) {
00128
00129 thislen = __int64_t_decode_array(buf, offset + pos, maxlen - pos, &(p[element].utime), 1);
00130 if (thislen < 0) return thislen; else pos += thislen;
00131
00132 thislen = __int32_t_decode_array(buf, offset + pos, maxlen - pos, &(p[element].datalen), 1);
00133 if (thislen < 0) return thislen; else pos += thislen;
00134
00135 p[element].data = (uint8_t*) lcm_malloc(sizeof(uint8_t) * p[element].datalen);
00136 thislen = __byte_decode_array(buf, offset + pos, maxlen - pos, p[element].data, p[element].datalen);
00137 if (thislen < 0) return thislen; else pos += thislen;
00138
00139 }
00140 return pos;
00141 }
00142
00143 int __lcmtypes_velodyne_t_decode_array_cleanup(lcmtypes_velodyne_t *p, int elements)
00144 {
00145 int element;
00146 for (element = 0; element < elements; element++) {
00147
00148 __int64_t_decode_array_cleanup(&(p[element].utime), 1);
00149
00150 __int32_t_decode_array_cleanup(&(p[element].datalen), 1);
00151
00152 __byte_decode_array_cleanup(p[element].data, p[element].datalen);
00153 if (p[element].data) free(p[element].data);
00154
00155 }
00156 return 0;
00157 }
00158
00159 int lcmtypes_velodyne_t_decode(const void *buf, int offset, int maxlen, lcmtypes_velodyne_t *p)
00160 {
00161 int pos = 0, thislen;
00162 int64_t hash = __lcmtypes_velodyne_t_get_hash();
00163
00164 int64_t this_hash;
00165 thislen = __int64_t_decode_array(buf, offset + pos, maxlen - pos, &this_hash, 1);
00166 if (thislen < 0) return thislen; else pos += thislen;
00167 if (this_hash != hash) return -1;
00168
00169 thislen = __lcmtypes_velodyne_t_decode_array(buf, offset + pos, maxlen - pos, p, 1);
00170 if (thislen < 0) return thislen; else pos += thislen;
00171
00172 return pos;
00173 }
00174
00175 int lcmtypes_velodyne_t_decode_cleanup(lcmtypes_velodyne_t *p)
00176 {
00177 return __lcmtypes_velodyne_t_decode_array_cleanup(p, 1);
00178 }
00179
00180 int __lcmtypes_velodyne_t_clone_array(const lcmtypes_velodyne_t *p, lcmtypes_velodyne_t *q, int elements)
00181 {
00182 int element;
00183 for (element = 0; element < elements; element++) {
00184
00185 __int64_t_clone_array(&(p[element].utime), &(q[element].utime), 1);
00186
00187 __int32_t_clone_array(&(p[element].datalen), &(q[element].datalen), 1);
00188
00189 q[element].data = (uint8_t*) lcm_malloc(sizeof(uint8_t) * q[element].datalen);
00190 __byte_clone_array(p[element].data, q[element].data, p[element].datalen);
00191
00192 }
00193 return 0;
00194 }
00195
00196 lcmtypes_velodyne_t *lcmtypes_velodyne_t_copy(const lcmtypes_velodyne_t *p)
00197 {
00198 lcmtypes_velodyne_t *q = (lcmtypes_velodyne_t*) malloc(sizeof(lcmtypes_velodyne_t));
00199 __lcmtypes_velodyne_t_clone_array(p, q, 1);
00200 return q;
00201 }
00202
00203 void lcmtypes_velodyne_t_destroy(lcmtypes_velodyne_t *p)
00204 {
00205 __lcmtypes_velodyne_t_decode_array_cleanup(p, 1);
00206 free(p);
00207 }