Release 1.0.0 (#15)

* Modified the project strucure and updated the README with more info about the lib. (#7)

* Ref #3327. Added, documented and tested type: int8.

* #3328 Refactor headers

* Ref #3328. Refactor sources.

* #3328. Added documentation.

* Changes for accepting Pull Request #7

* Changes (2) for accepting Pull Request #7

* Added native string serialization (#8)

* Refs #3327. Added string serialization

* Added security and refactor/added tests (#9)

* Refs #3390. Modify error checker, refactor project layout. Refactor serialization test. Refs #3389 Fix issue: now a serialization will be perform after any serialization error.

* Template tests

* Refs #3397. Refactored and improved tests.

* Refs #3397 #3389. API security changes. Added endianness tests.

* Added data_size checks. Added Sequence overflow test.

* Refs #3397. Change var name max_size -> array_size

* Refs #3397. Added functions to manage error/endianness

* Refs #3397. Moved check_buffer function to a common file

* Refs #3397. Modify array_capacity parameter position.

* Refs #3397. Refactor define names in test.

* Updated README with the new types.

* Refs #3397. Removed MicroState. Added a copy MicroBuffer function.

* Refs #3397. Updated README. Removed set_valid function.

* Refs #3397. Added error description to README.md

* Refs #3408. Modified DLL exports (#10)

* Added mc prefix to MicroCDR (#11)

* Refs #3436. MicroBuffer => mcMicroBuffer

* Refs #3436. Added -mc at deserialization functions.

* Refs #3436. Added -mc at serialization functions.

* Recovered internal functions names.

* Refs #3436. Rename common functions.

* Refs #3436. Added mc preffix to endianness.

* Refs #3436. Added mc to README and example.

* Refs #3436. Modify mcMicroBuffer to mcBuffer

* Refs #3436. micro_buffer to buffer function names

* Refs #3436. Fix error.

* Refs #3436. Fix mc prefix at mrEndianness. Minor correction

* Fix windows warning

* Fix warnings

* Fix warnings

* Feature/prefix change (#13)

* Refs #3451. mc_ prefix to ucdr_ prefix

* Refs #3451. Modified dll export name

* Refs #3458. Updated internal symbols with prefix.

* #3451. Updated include path (#14)

* #3451. Updated include path

* Fixed cmake install

Author: lemunozm

.gitignore

@@ -1,3 +1,5 @@
 build
 examples/performance_cmp_versions
 .vscode
+.color_coded
+.ycm_extra_conf.py

CMakeLists.txt

@@ -68,7 +68,14 @@ endif()
 ###############################################################################
 
 # Library
-add_library(${PROJECT_NAME} src/c/microcdr.c)
+add_library(${PROJECT_NAME}
+    src/c/common.c
+    src/c/types/basic.c
+    src/c/types/string.c
+    src/c/types/array.c
+    src/c/types/sequence.c
+    )
+
 set_common_compile_options(${PROJECT_NAME})
 set_target_properties(${PROJECT_NAME} PROPERTIES
     VERSION ${PROJECT_VERSION}
@@ -114,8 +121,8 @@ else()
 endif()
 
 # Config.h
-configure_file(${PROJECT_SOURCE_DIR}/include/${PROJECT_NAME}/config.h.in
-    ${PROJECT_BINARY_DIR}/include/${PROJECT_NAME}/config.h
+configure_file(${PROJECT_SOURCE_DIR}/include/ucdr/config.h.in
+    ${PROJECT_BINARY_DIR}/include/ucdr/config.h
 )
 
 ###############################################################################
@@ -154,22 +161,22 @@ install(TARGETS ${PROJECT_NAME}
     )
 
 # Install includes
-install(DIRECTORY ${PROJECT_SOURCE_DIR}/include/${PROJECT_NAME}/
-    DESTINATION ${INCLUDE_INSTALL_DIR}/${PROJECT_NAME}
+install(DIRECTORY ${PROJECT_SOURCE_DIR}/include/ucdr/
+    DESTINATION ${INCLUDE_INSTALL_DIR}/ucdr
     FILES_MATCHING PATTERN "*.h"
     )
 
 # Install config.h
-install(FILES ${PROJECT_BINARY_DIR}/include/${PROJECT_NAME}/config.h
-    DESTINATION ${INCLUDE_INSTALL_DIR}/${PROJECT_NAME}
+install(FILES ${PROJECT_BINARY_DIR}/include/ucdr/config.h
+    DESTINATION ${INCLUDE_INSTALL_DIR}/ucdr
     )
 
 # Export library
 install(EXPORT ${PROJECT_NAME}Targets
     DESTINATION ${LIB_INSTALL_DIR}/${PROJECT_NAME}/cmake
     )
 
-# Package configuration 
+# Package configuration
 include(CMakePackageConfigHelpers)
 configure_package_config_file(${PROJECT_SOURCE_DIR}/cmake/packaging/Config.cmake.in
     ${PROJECT_BINARY_DIR}/cmake/config/${PROJECT_NAME}Config.cmake

README.md

@@ -2,18 +2,17 @@
 
 <a href="http://www.eprosima.com"><img src="https://encrypted-tbn3.gstatic.com/images?q=tbn:ANd9GcSd0PDlVz1U_7MgdTe0FRIWD0Jc9_YH-gGi0ZpLkr-qgCI6ZEoJZ5GBqQ" align="left" hspace="8" vspace="2" width="100" height="100" ></a>
 
-*eProsima microCDR* is a C library implementing the CDR standard serialization methods.
+*eProsima MicroCDR* is a *C* library implementing the *CDR* standard serialization methods.
 This library is focused on embedded and resource-limited systems.
 
-*microCDR* uses a static buffer, is always aligned, and allow to serialize and deserialize in both, big endianness and little endianness.
-For more information about the API of *microCDR* check ...?
+*MicroCDR* uses a static buffer, and allow to serialize and deserialize in both, big endianness and little endianness.
 
 ## Usage examples
 This is a code example showing the serialization and deserialization of a string.
-As *microCDR* uses a static buffer, that means the user has to provide a defined buffer and its size during the *MicroBuffer* creation.
+As *MicroCDR* uses a static buffer, that means the user has to provide a defined buffer and its size during the *ucdrBuffer* creation.
 
 ```c
-    #include <microcdr/microcdr.h>
+    #include <ucdr/microcdr.h>
     #include <stdio.h>
 
     #define BUFFER_LENGTH 256
@@ -24,20 +23,20 @@ As *microCDR* uses a static buffer, that means the user has to provide a defined
         uint8_t buffer[BUFFER_LENGTH];
 
         // Structs for handle the buffer.
-        MicroBuffer writer;
-        MicroBuffer reader;
+        ucdrBuffer writer;
+        ucdrBuffer reader;
 
         // Initialize the MicroBuffers for working with an user-managed buffer.
-        init_micro_buffer(&writer, buffer, BUFFER_LENGTH);
-        init_micro_buffer(&reader, buffer, BUFFER_LENGTH);
+        ucdr_init_buffer(&writer, buffer, BUFFER_LENGTH);
+        ucdr_init_buffer(&reader, buffer, BUFFER_LENGTH);
 
         // Serialize data
-        char input[16] = "Hello microCDR!"; //16 characters
-        serialize_array_char(&writer, input, 16);
+        char input[16] = "Hello MicroCDR!"; //16 characters
+        ucdr_serialize_array_char(&writer, input, 16);
 
         // Deserialize data
         char output[16];
-        deserialize_array_char(&reader, output, 16);
+        ucdr_deserialize_array_char(&reader, output, 16);
 
         printf("Input: %s\n", input);
         printf("Output: %s\n", output);
@@ -46,11 +45,138 @@ As *microCDR* uses a static buffer, that means the user has to provide a defined
     }
 ```
 
-Note: to change the default endianness of functions without the *endian* tag, use the *endianness* member of the *Microbuffer* structure.
+## API functions
 
+```c
+void ucdr_init_buffer        (ucdrBuffer* mb, uint8_t* data, const uint32_t size);
+void ucdr_init_buffer_offset (ucdrBuffer* mb, uint8_t* data, const uint32_t size, uint32_t offset);
+```
+Initialize a `ucdrBuffer` structure, the main struct of *MicroCDR*.
+- `mb`: the `ucdrBuffer` struct
+- `data`: the buffer that the `ucdrBuffer` will use.
+- `size`: the size of the buffer that the `ucdrBuffer` will use.
+- `offset`: where the serialization/deserialization will start.
+Initially, the serialization/deserialization starts at the beginning of the buffer.
+
+---
+
+```c
+void ucdr_copy_buffer (ucdrBuffer* mb_dest, const ucdrBuffer* mb_source);
+```
+Copy a `ucdrBuffer` structure data to another `ucdrBuffer` structure.
+- `mb_dest`: the destination `ucdrBuffer` struct.
+- `mb_source`: the origin initialized `ucdrBuffer` struct.
+
+---
+
+```c
+void ucdr_reset_buffer       (ucdrBuffer* mb);
+void ucdr_reset_buffer_offset(ucdrBuffer* mb, const uint32_t offset);
+```
+Reset the `ucdrBuffer` as the same state that it was created.
+- `mb`: the `ucdrBuffer` struct.
+- `offset`: where the serialization/deserialization will start.
+Initially, the serialization/deserialization starts at the beginning of the buffer.
+
+---
+
+```c
+void ucdr_align_to (ucdrBuffer* mb, const uint32_t alignment);
+```
+Align the ucdrBuffer to an `alignment` position.
+After call this function, the serialization pointer will be moved only if the current `ucdrBuffer` was not aligment to the passed value.
+
+- `mb`: the `ucdrBuffer` struct
+- `alignment`: the alignment value used.
+
+---
+
+```c
+uint32_t ucdr_aligment(uint32_t buffer_position, const uint32_t data_size);
+```
+Returns the aligment necessary to serialize/deserialize a type with `data_size` size.
+
+- `buffer_position`: the current serialization/deserialization position of the `ucdrBuffer`. (Typically  `mb->iterator - mb->init`).
+- `data_size`: the bytes of the data that you are asking for.
 
-## Supported types
-The types supported in *microCDR* are presented in the following table. For each of them exists a serialization and a deserialization function.
+---
+
+```c
+uint32_t ucdr_buffer_alignment(const ucdrBuffer* mb, const uint32_t data_size);
+```
+Returns the aligment necessary to serialize/deserialize a type with `data_size` size into the `ucdrBuffer` given.
+
+- `mb`: the `ucdrBuffer` struct to ask the alignment.
+- `data_size`: the bytes of the data that you are asking for.
+---
+
+```c
+size_t ucdr_buffer_size(const ucdrBuffer* mb);
+```
+Returns the memory size of the buffer.
+- `mb`: the `ucdrBuffer` struct
+
+---
+
+```c
+size_t ucdr_buffer_length(const ucdrBuffer* mb);
+```
+Returns the size of the serialized/deserialized data.
+- `mb`: the `ucdrBuffer` struct
+
+---
+
+```c
+size_t ucdr_buffer_remaining(const ucdrBuffer* mb);
+```
+Returns the remaining size for the serializing/deserializing.
+- `mb`: the `ucdrBuffer` struct
+
+---
+
+```c
+ucdrEndianness ucdr_buffer_endianness(const ucdrBuffer* mb);
+```
+Returns the serialization/deserialization endianness.
+- `mb`: the `ucdrBuffer` struct
+
+---
+
+```c
+bool ucdr_buffer_error(const ucdrBuffer* mb);
+```
+Returns the status error of the `ucdrBuffer`.
+- `mb`: the `ucdrBuffer` struct
+
+
+### Serialization/deserialization functions
+Adding to this, there is a big set of functions for deserialize and deserialize different kind of types:
+- Basics: `bool`, `char`, `int8_t`, `uint8_t`,`int16_t`, `uint16_t`,`int32_t`, `uint32_t`,`int64_t`, `uint64_t`,`float`, `double`.
+- Arrays: Any fixed size of basics types.
+- Sequence: Similar to arrays, but the information about the size is serialized along with the data.
+
+### Endianness
+*MicroCDR* supports little and big endianness.
+The configuration can be done by cmake with the cmake `__BIG_ENDIAN__` variable.
+A `0` value implies that the serialization will performed into a little endian machine, and `1` into a big endian machine.
+
+The default endianness serialization can be choosen by setting the `endianness` parameter of a `ucdrBuffer`  to `UCDR_BIG_ENDIANNESS` or `UCDR_LITTLE_ENDIANNESS`.
+Also, there are a functions that allow to force an endianness in their serialization/deserialization.
+These functions contains the name `endiannness` in their signature.
+
+### Error
+All serialization/deserialization functions return a boolean indicating the result of their operations.
+When a serialization/deserialization could not be possible (the type can not be serialized, or the capacity of the destination buffer is not enough),
+an status error is setted into the `ucdrBuffer`.
+If a `ucdrBuffer` has an error state, the next serialization/deserialization operations will not works and will return `false` in their execution.
+A buffer marked with an error can be used, but any serialization/deserialization operation over it will not produce any effect.
+
+If is kwown that an operation can fails over a `ucdrBuffer`, and its necessary to continue with the serialization/deserialization if it happens,
+the `ucdrBuffer` state can be saved using the `ucdr_copy_buffer` function.
+After the application of the wrong serialization/deserialization, only the `ucdrBuffer` that performed the operation will have a dirty state.
+
+## Serialization/deserialization list
+The available modes of serialization/deserializations in *MicroCDR* are shown in the following table.
 
 
 | Type                 | Endianness |
@@ -75,6 +201,8 @@ The types supported in *microCDR* are presented in the following table. For each
 | float                | endianness |
 | double               |            |
 | double               | endianness |
+| string               |            |
+| string               | endianness |
 | bool array           |            |
 | char array           |            |
 | int8 array           |            |
@@ -96,9 +224,13 @@ The types supported in *microCDR* are presented in the following table. For each
 | double array         |            |
 | double array         | endianness |
 | bool sequence        |            |
+| bool sequence        | endianness |
 | char sequence        |            |
+| char sequence        | endianness |
 | int8 sequence        |            |
+| int8 sequence        | endianness |
 | uint8 sequence       |            |
+| uint8 sequence       | endianness |
 | int16 sequence       |            |
 | int16 sequence       | endianness |
 | uint16 sequence      |            |
@@ -115,3 +247,4 @@ The types supported in *microCDR* are presented in the following table. For each
 | float sequence       | endianness |
 | double sequence      |            |
 | double sequence      | endianness |
+

examples/basic.c

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <microcdr/microcdr.h>
+#include <ucdr/microcdr.h>
 #include <stdio.h>
 
 #define BUFFER_LENGTH 256
@@ -23,20 +23,20 @@ int main()
     uint8_t buffer[BUFFER_LENGTH];
 
     // Structs for handle the buffer.
-    MicroBuffer writer;
-    MicroBuffer reader;
+    ucdrBuffer writer;
+    ucdrBuffer reader;
 
     // Initialize the MicroBuffers for working with an user-managed buffer.
-    init_micro_buffer(&writer, buffer, BUFFER_LENGTH);
-    init_micro_buffer(&reader, buffer, BUFFER_LENGTH);
+    ucdr_init_buffer(&writer, buffer, BUFFER_LENGTH);
+    ucdr_init_buffer(&reader, buffer, BUFFER_LENGTH);
 
     // Serialize data
-    char input[16] = "Hello microCDR!"; //16 characters
-    serialize_array_char(&writer, input, 16);
+    char input[16] = "Hello MicroCDR!"; //16 characters
+    ucdr_serialize_array_char(&writer, input, 16);
 
     // Deserialize data
     char output[16];
-    deserialize_array_char(&reader, output, 16);
+    ucdr_deserialize_array_char(&reader, output, 16);
 
     printf("Input: %s\n", input);
     printf("Output: %s\n", output);