basic.c

00001 // Copyright 2017 Proyectos y Sistemas de Mantenimiento SL (eProsima).
00002 //
00003 // Licensed under the Apache License, Version 2.0 (the "License");
00004 // you may not use this file except in compliance with the License.
00005 // You may obtain a copy of the License at
00006 //
00007 //     http://www.apache.org/licenses/LICENSE-2.0
00008 //
00009 // Unless required by applicable law or agreed to in writing, software
00010 // distributed under the License is distributed on an "AS IS" BASIS,
00011 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00012 // See the License for the specific language governing permissions and
00013 // limitations under the License.
00014 
00015 #include <ucdr/types/basic.h>
00016 #include "../common_internals.h"
00017 #include "basic_internals.h"
00018 
00019 #include <string.h>
00020 
00021 
00022 // -------------------------------------------------------------------
00023 //                INTERNAL SERIALIZATION IMPLEMENTATION
00024 // -------------------------------------------------------------------
00025 
00026 bool ucdr_serialize_byte_1(ucdrBuffer* mb, const uint8_t* byte)
00027 {
00028     uint32_t data_size = sizeof(uint8_t);
00029     if(ucdr_check_buffer(mb, data_size))
00030     {
00031         *mb->iterator = *byte;
00032 
00033         mb->iterator += data_size;
00034         mb->last_data_size = data_size;
00035     }
00036     return !mb->error;
00037 }
00038 
00039 bool ucdr_serialize_byte_2(ucdrBuffer* mb, const ucdrEndianness endianness, const uint16_t* bytes)
00040 {
00041     uint32_t data_size = sizeof(uint16_t);
00042     uint32_t alignment = ucdr_buffer_alignment(mb, data_size);
00043 
00044     if(ucdr_check_buffer(mb, alignment + data_size))
00045     {
00046         mb->iterator += alignment;
00047 
00048         if(UCDR_MACHINE_ENDIANNESS == endianness)
00049         {
00050             memcpy(mb->iterator, bytes, data_size);
00051         }
00052         else
00053         {
00054             uint8_t* bytes_pointer = (uint8_t*)bytes;
00055             *mb->iterator = *(bytes_pointer + 1);
00056             *(mb->iterator + 1) = *bytes_pointer;
00057         }
00058 
00059         mb->iterator += data_size;
00060         mb->last_data_size = data_size;
00061     }
00062     return !mb->error;
00063 }
00064 
00065 bool ucdr_serialize_byte_4(ucdrBuffer* mb, const ucdrEndianness endianness, const uint32_t* bytes)
00066 {
00067     uint32_t data_size = sizeof(uint32_t);
00068     uint32_t alignment = ucdr_buffer_alignment(mb, data_size);
00069 
00070     if(ucdr_check_buffer(mb, alignment + data_size))
00071     {
00072         mb->iterator += alignment;
00073 
00074         if(UCDR_MACHINE_ENDIANNESS == endianness)
00075         {
00076             memcpy(mb->iterator, bytes, data_size);
00077         }
00078         else
00079         {
00080             uint8_t* bytes_pointer = (uint8_t*)bytes;
00081             *mb->iterator = *(bytes_pointer + 3);
00082             *(mb->iterator + 1) = *(bytes_pointer + 2);
00083             *(mb->iterator + 2) = *(bytes_pointer + 1);
00084             *(mb->iterator + 3) = *bytes_pointer;
00085         }
00086 
00087         mb->iterator += data_size;
00088         mb->last_data_size = data_size;
00089     }
00090     return !mb->error;
00091 }
00092 
00093 bool ucdr_serialize_byte_8(ucdrBuffer* mb, const ucdrEndianness endianness, const uint64_t* bytes)
00094 {
00095     uint32_t data_size = sizeof(uint64_t);
00096     uint32_t alignment = ucdr_buffer_alignment(mb, data_size);
00097 
00098     if(ucdr_check_buffer(mb, alignment + data_size))
00099     {
00100         mb->iterator += alignment;
00101 
00102         if(UCDR_MACHINE_ENDIANNESS == endianness)
00103         {
00104             memcpy(mb->iterator, bytes, data_size);
00105         }
00106         else
00107         {
00108             uint8_t* bytes_pointer = (uint8_t*)bytes;
00109             *mb->iterator = *(bytes_pointer + 7);
00110             *(mb->iterator + 1) = *(bytes_pointer + 6);
00111             *(mb->iterator + 2) = *(bytes_pointer + 5);
00112             *(mb->iterator + 3) = *(bytes_pointer + 4);
00113             *(mb->iterator + 4) = *(bytes_pointer + 3);
00114             *(mb->iterator + 5) = *(bytes_pointer + 2);
00115             *(mb->iterator + 6) = *(bytes_pointer + 1);
00116             *(mb->iterator + 7) = *bytes_pointer;
00117         }
00118 
00119         mb->iterator += data_size;
00120         mb->last_data_size = data_size;
00121     }
00122     return !mb->error;
00123 }
00124 
00125 bool ucdr_deserialize_byte_1(ucdrBuffer* mb, uint8_t* byte)
00126 {
00127     uint32_t data_size = sizeof(uint8_t);
00128     if(ucdr_check_buffer(mb, data_size))
00129     {
00130         *byte = *mb->iterator;
00131 
00132         mb->iterator += data_size;
00133         mb->last_data_size = data_size;
00134     }
00135     return !mb->error;
00136 }
00137 
00138 bool ucdr_deserialize_byte_2(ucdrBuffer* mb, const ucdrEndianness endianness, uint16_t* bytes)
00139 {
00140     uint32_t data_size = sizeof(uint16_t);
00141     uint32_t alignment = ucdr_buffer_alignment(mb, data_size);
00142 
00143     if(ucdr_check_buffer(mb, alignment + data_size))
00144     {
00145         mb->iterator += alignment;
00146 
00147         if(UCDR_MACHINE_ENDIANNESS == endianness)
00148         {
00149             memcpy(bytes, mb->iterator, data_size);
00150         }
00151         else
00152         {
00153             uint8_t* bytes_pointer = (uint8_t*)bytes;
00154             *bytes_pointer = *(mb->iterator + 1);
00155             *(bytes_pointer + 1) = *mb->iterator ;
00156         }
00157 
00158         mb->iterator += data_size;
00159         mb->last_data_size = data_size;
00160     }
00161     return !mb->error;
00162 }
00163 
00164 bool ucdr_deserialize_byte_4(ucdrBuffer* mb, const ucdrEndianness endianness, uint32_t* bytes)
00165 {
00166     uint32_t data_size = sizeof(uint32_t);
00167     uint32_t alignment = ucdr_buffer_alignment(mb, data_size);
00168 
00169     if(ucdr_check_buffer(mb, alignment + data_size))
00170     {
00171         mb->iterator += alignment;
00172 
00173         if(UCDR_MACHINE_ENDIANNESS == endianness)
00174         {
00175             memcpy(bytes, mb->iterator, data_size);
00176         }
00177         else
00178         {
00179             uint8_t* bytes_pointer = (uint8_t*)bytes;
00180             *bytes_pointer = *(mb->iterator + 3);
00181             *(bytes_pointer + 1) = *(mb->iterator + 2);
00182             *(bytes_pointer + 2) = *(mb->iterator + 1);
00183             *(bytes_pointer + 3) = *mb->iterator;
00184         }
00185 
00186         mb->iterator += data_size;
00187         mb->last_data_size = data_size;
00188     }
00189     return !mb->error;
00190 }
00191 
00192 bool ucdr_deserialize_byte_8(ucdrBuffer* mb, const ucdrEndianness endianness, uint64_t* bytes)
00193 {
00194     uint32_t data_size = sizeof(uint64_t);
00195     uint32_t alignment = ucdr_buffer_alignment(mb, data_size);
00196 
00197     if(ucdr_check_buffer(mb, alignment + data_size))
00198     {
00199         mb->iterator += alignment;
00200 
00201         if(UCDR_MACHINE_ENDIANNESS == endianness)
00202         {
00203             memcpy(bytes, mb->iterator, data_size);
00204         }
00205         else
00206         {
00207             uint8_t* bytes_pointer = (uint8_t*)bytes;
00208             *bytes_pointer = *(mb->iterator + 7);
00209             *(bytes_pointer + 1) = *(mb->iterator + 6);
00210             *(bytes_pointer + 2) = *(mb->iterator + 5);
00211             *(bytes_pointer + 3) = *(mb->iterator + 4);
00212             *(bytes_pointer + 4) = *(mb->iterator + 3);
00213             *(bytes_pointer + 5) = *(mb->iterator + 2);
00214             *(bytes_pointer + 6) = *(mb->iterator + 1);
00215             *(bytes_pointer + 7) = *mb->iterator;
00216         }
00217 
00218         mb->iterator += data_size;
00219         mb->last_data_size = data_size;
00220     }
00221     return !mb->error;
00222 }
00223 
00224 // -------------------------------------------------------------------
00225 //                  PUBLIC SERIALIZATION IMPLEMENTATION
00226 // -------------------------------------------------------------------
00227 
00228 bool ucdr_serialize_char(ucdrBuffer* mb, const char value)
00229 {
00230     return ucdr_serialize_byte_1(mb, (uint8_t*)&value);
00231 }
00232 
00233 bool ucdr_serialize_bool(ucdrBuffer* mb, const bool value)
00234 {
00235     return ucdr_serialize_byte_1(mb, (uint8_t*)&value);
00236 }
00237 
00238 bool ucdr_serialize_uint8_t(ucdrBuffer* mb, const uint8_t value)
00239 {
00240     return ucdr_serialize_byte_1(mb, &value);
00241 }
00242 
00243 bool ucdr_serialize_uint16_t(ucdrBuffer* mb, const uint16_t value)
00244 {
00245     return ucdr_serialize_byte_2(mb, mb->endianness, &value);
00246 }
00247 
00248 bool ucdr_serialize_uint32_t(ucdrBuffer* mb, const uint32_t value)
00249 {
00250     return ucdr_serialize_byte_4(mb, mb->endianness, &value);
00251 }
00252 
00253 bool ucdr_serialize_uint64_t(ucdrBuffer* mb, const uint64_t value)
00254 {
00255     return ucdr_serialize_byte_8(mb, mb->endianness, &value);
00256 }
00257 
00258 bool ucdr_serialize_int8_t(ucdrBuffer* mb, const int8_t value)
00259 {
00260     return ucdr_serialize_byte_1(mb, (uint8_t*)&value);
00261 }
00262 
00263 bool ucdr_serialize_int16_t(ucdrBuffer* mb, const int16_t value)
00264 {
00265     return ucdr_serialize_byte_2(mb, mb->endianness, (uint16_t*)&value);
00266 }
00267 
00268 bool ucdr_serialize_int32_t(ucdrBuffer* mb, const int32_t value)
00269 {
00270     return ucdr_serialize_byte_4(mb, mb->endianness, (uint32_t*)&value);
00271 }
00272 
00273 bool ucdr_serialize_int64_t(ucdrBuffer* mb, const int64_t value)
00274 {
00275     return ucdr_serialize_byte_8(mb, mb->endianness, (uint64_t*)&value);
00276 }
00277 
00278 bool ucdr_serialize_float(ucdrBuffer* mb, const float value)
00279 {
00280     return ucdr_serialize_byte_4(mb, mb->endianness, (uint32_t*)&value);
00281 }
00282 
00283 bool ucdr_serialize_double(ucdrBuffer* mb, const double value)
00284 {
00285     return ucdr_serialize_byte_8(mb, mb->endianness, (uint64_t*)&value);
00286 }
00287 
00288 bool ucdr_deserialize_char(ucdrBuffer* mb, char* value)
00289 {
00290     return ucdr_deserialize_byte_1(mb, (uint8_t*)value);
00291 }
00292 
00293 bool ucdr_deserialize_bool(ucdrBuffer* mb, bool* value)
00294 {
00295     return ucdr_deserialize_byte_1(mb, (uint8_t*)value);
00296 }
00297 
00298 bool ucdr_deserialize_uint8_t(ucdrBuffer* mb, uint8_t* value)
00299 {
00300     return ucdr_deserialize_byte_1(mb, value);
00301 }
00302 
00303 bool ucdr_deserialize_uint16_t(ucdrBuffer* mb, uint16_t* value)
00304 {
00305     return ucdr_deserialize_byte_2(mb, mb->endianness, value);
00306 }
00307 
00308 bool ucdr_deserialize_uint32_t(ucdrBuffer* mb, uint32_t* value)
00309 {
00310     return ucdr_deserialize_byte_4(mb, mb->endianness, value);
00311 }
00312 
00313 bool ucdr_deserialize_uint64_t(ucdrBuffer* mb, uint64_t* value)
00314 {
00315     return ucdr_deserialize_byte_8(mb, mb->endianness, value);
00316 }
00317 
00318 bool ucdr_deserialize_int8_t(ucdrBuffer* mb, int8_t* value)
00319 {
00320     return ucdr_deserialize_byte_1(mb, (uint8_t*)value);
00321 }
00322 
00323 bool ucdr_deserialize_int16_t(ucdrBuffer* mb, int16_t* value)
00324 {
00325     return ucdr_deserialize_byte_2(mb, mb->endianness, (uint16_t*)value);
00326 }
00327 
00328 bool ucdr_deserialize_int32_t(ucdrBuffer* mb, int32_t* value)
00329 {
00330     return ucdr_deserialize_byte_4(mb, mb->endianness, (uint32_t*)value);
00331 }
00332 
00333 bool ucdr_deserialize_int64_t(ucdrBuffer* mb, int64_t* value)
00334 {
00335     return ucdr_deserialize_byte_8(mb, mb->endianness, (uint64_t*)value);
00336 }
00337 
00338 bool ucdr_deserialize_float(ucdrBuffer* mb, float* value)
00339 {
00340     return ucdr_deserialize_byte_4(mb, mb->endianness, (uint32_t*)value);
00341 }
00342 
00343 bool ucdr_deserialize_double(ucdrBuffer* mb, double* value)
00344 {
00345     return ucdr_deserialize_byte_8(mb, mb->endianness, (uint64_t*)value);
00346 }
00347 
00348 bool ucdr_serialize_endian_uint16_t(ucdrBuffer* mb, const ucdrEndianness endianness, const uint16_t value)
00349 {
00350     return ucdr_serialize_byte_2(mb, endianness, &value);
00351 }
00352 
00353 bool ucdr_serialize_endian_uint32_t(ucdrBuffer* mb, const ucdrEndianness endianness, const uint32_t value)
00354 {
00355     return ucdr_serialize_byte_4(mb, endianness, &value);
00356 }
00357 
00358 bool ucdr_serialize_endian_uint64_t(ucdrBuffer* mb, const ucdrEndianness endianness, const uint64_t value)
00359 {
00360     return ucdr_serialize_byte_8(mb, endianness, &value);
00361 }
00362 
00363 bool ucdr_serialize_endian_int16_t(ucdrBuffer* mb, const ucdrEndianness endianness, const int16_t value)
00364 {
00365     return ucdr_serialize_byte_2(mb, endianness, (uint16_t*)&value);
00366 }
00367 
00368 bool ucdr_serialize_endian_int32_t(ucdrBuffer* mb, const ucdrEndianness endianness, const int32_t value)
00369 {
00370     return ucdr_serialize_byte_4(mb, endianness, (uint32_t*)&value);
00371 }
00372 
00373 bool ucdr_serialize_endian_int64_t(ucdrBuffer* mb, const ucdrEndianness endianness, const int64_t value)
00374 {
00375     return ucdr_serialize_byte_8(mb, endianness, (uint64_t*)&value);
00376 }
00377 
00378 bool ucdr_serialize_endian_float(ucdrBuffer* mb, const ucdrEndianness endianness, const float value)
00379 {
00380     return ucdr_serialize_byte_4(mb, endianness, (uint32_t*)&value);
00381 }
00382 
00383 bool ucdr_serialize_endian_double(ucdrBuffer* mb, const ucdrEndianness endianness, const double value)
00384 {
00385     return ucdr_serialize_byte_8(mb, endianness, (uint64_t*)&value);
00386 }
00387 
00388 bool ucdr_deserialize_endian_uint16_t(ucdrBuffer* mb, const ucdrEndianness endianness, uint16_t* value)
00389 {
00390     return ucdr_deserialize_byte_2(mb, endianness, value);
00391 }
00392 
00393 bool ucdr_deserialize_endian_uint32_t(ucdrBuffer* mb, const ucdrEndianness endianness, uint32_t* value)
00394 {
00395     return ucdr_deserialize_byte_4(mb, endianness, value);
00396 }
00397 
00398 bool ucdr_deserialize_endian_uint64_t(ucdrBuffer* mb, const ucdrEndianness endianness, uint64_t* value)
00399 {
00400     return ucdr_deserialize_byte_8(mb, endianness, value);
00401 }
00402 
00403 bool ucdr_deserialize_endian_int16_t(ucdrBuffer* mb, const ucdrEndianness endianness, int16_t* value)
00404 {
00405     return ucdr_deserialize_byte_2(mb, endianness, (uint16_t*)value);
00406 }
00407 
00408 bool ucdr_deserialize_endian_int32_t(ucdrBuffer* mb, const ucdrEndianness endianness, int32_t* value)
00409 {
00410     return ucdr_deserialize_byte_4(mb, endianness, (uint32_t*)value);
00411 }
00412 
00413 bool ucdr_deserialize_endian_int64_t(ucdrBuffer* mb, const ucdrEndianness endianness, int64_t* value)
00414 {
00415     return ucdr_deserialize_byte_8(mb, endianness, (uint64_t*)value);
00416 }
00417 
00418 bool ucdr_deserialize_endian_float(ucdrBuffer* mb, const ucdrEndianness endianness, float* value)
00419 {
00420     return ucdr_deserialize_byte_4(mb, endianness, (uint32_t*)value);
00421 }
00422 
00423 bool ucdr_deserialize_endian_double(ucdrBuffer* mb, const ucdrEndianness endianness, double* value)
00424 {
00425     return ucdr_deserialize_byte_8(mb, endianness, (uint64_t*)value);
00426 }
00427