mtapi_network_c: network buffer implementation

mtapi_network_c/CMakeLists.txt

+project (project_embb_mtapi_network_c)
+
+file(GLOB_RECURSE EMBB_MTAPI_NETWORK_C_SOURCES "src/*.c" "src/*.h")
+file(GLOB_RECURSE EMBB_MTAPI_NETWORK_C_HEADERS "include/*.h")
+
+file(GLOB_RECURSE EMBB_MTAPI_NETWORK_TEST_SOURCES "test/*.cc" "test/*.h")
+  
+IF(MSVC8 OR MSVC9 OR MSVC10 OR MSVC11)
+FOREACH(src_tmp ${EMBB_MTAPI_NETWORK_TEST_SOURCES})
+    SET_PROPERTY(SOURCE ${src_tmp} PROPERTY LANGUAGE CXX)
+ENDFOREACH(src_tmp)
+FOREACH(src_tmp ${EMBB_MTAPI_NETWORK_C_SOURCES})
+    SET_PROPERTY(SOURCE ${src_tmp} PROPERTY LANGUAGE CXX)
+ENDFOREACH(src_tmp)
+ENDIF()
+   
+# Execute the GroupSources macro
+include(${CMAKE_SOURCE_DIR}/CMakeCommon/GroupSourcesMSVC.cmake)
+GroupSourcesMSVC(include)
+GroupSourcesMSVC(src)
+GroupSourcesMSVC(test)
+
+set (EMBB_MTAPI_NETWORK_INCLUDE_DIRS "include" "src" "test")
+include_directories(${EMBB_MTAPI_NETWORK_INCLUDE_DIRS}
+                    ${CMAKE_CURRENT_SOURCE_DIR}/../base_c/include
+                    ${CMAKE_CURRENT_BINARY_DIR}/../base_c/include
+                    ${CMAKE_CURRENT_SOURCE_DIR}/../mtapi_c/include
+                    )
+
+add_library(embb_mtapi_network_c ${EMBB_MTAPI_NETWORK_C_SOURCES} ${EMBB_MTAPI_NETWORK_C_HEADERS})
+target_link_libraries(embb_mtapi_network_c embb_mtapi_c embb_base_c)
+
+if (BUILD_TESTS STREQUAL ON)
+  include_directories(${CMAKE_CURRENT_BINARY_DIR}/../partest/include)
+  add_executable (embb_mtapi_network_c_test ${EMBB_MTAPI_NETWORK_TEST_SOURCES})
+  target_link_libraries(embb_mtapi_network_c_test embb_mtapi_network_c embb_mtapi_c partest embb_base_c ${compiler_libs})
+  CopyBin(BIN embb_mtapi_network_c_test DEST ${local_install_dir})
+endif()
+
+install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/include/
+        DESTINATION include FILES_MATCHING PATTERN "*.h")
+install(TARGETS embb_mtapi_network_c DESTINATION lib)

mtapi_network_c/src/embb_mtapi_network_buffer.c

+#include <embb_mtapi_network_buffer.h>
+#include <embb/base/c/memory_allocation.h>
+#include <string.h>
+
+void embb_mtapi_network_buffer_initialize(
+  embb_mtapi_network_buffer_t * that,
+  int capacity) {
+  that->position = 0;
+  that->size = 0;
+  that->data = embb_alloc(capacity);
+  if (NULL != that->data) {
+    that->capacity = capacity;
+  } else {
+    that->capacity = 0;
+  }
+}
+
+void embb_mtapi_network_buffer_finalize(
+  embb_mtapi_network_buffer_t * that) {
+  that->position = 0;
+  that->size = 0;
+  that->capacity = 0;
+  if (NULL != that->data) {
+    embb_free(that->data);
+    that->data = NULL;
+  }
+}
+
+int embb_mtapi_network_buffer_push_back_int8(
+  embb_mtapi_network_buffer_t * that,
+  int8_t value) {
+  if (that->size + 1 > that->capacity) {
+    return 0;
+  }
+  memcpy(that->data + that->size, &value, 1);
+  that->size += 1;
+  return 1;
+}
+
+int embb_mtapi_network_buffer_push_back_int16(
+  embb_mtapi_network_buffer_t * that,
+  int16_t value) {
+  if (that->size + 2 > that->capacity) {
+    return 0;
+  }
+  memcpy(that->data + that->size, &value, 2);
+  that->size += 2;
+  return 1;
+}
+
+int embb_mtapi_network_buffer_push_back_int32(
+  embb_mtapi_network_buffer_t * that,
+  int32_t value) {
+  if (that->size + 4 > that->capacity) {
+    return 0;
+  }
+  memcpy(that->data + that->size, &value, 4);
+  that->size += 4;
+  return 1;
+}
+
+int embb_mtapi_network_buffer_push_back_rawdata(
+  embb_mtapi_network_buffer_t * that,
+  int32_t size,
+  void * rawdata) {
+  if (that->size + size > that->capacity) {
+    return 0;
+  }
+  memcpy(that->data + that->size, rawdata, size);
+  that->size += size;
+  return 1;
+}
+
+int embb_mtapi_network_buffer_pop_front_int8(
+  embb_mtapi_network_buffer_t * that,
+  int8_t * value) {
+  if (that->position + 1 > that->size) {
+    return 0;
+  }
+  memcpy(value, that->data + that->position, 1);
+  that->position += 1;
+  return 1;
+}
+
+int embb_mtapi_network_buffer_pop_front_int16(
+  embb_mtapi_network_buffer_t * that,
+  int16_t * value) {
+  if (that->position + 2 > that->size) {
+    return 0;
+  }
+  memcpy(value, that->data + that->position, 2);
+  that->position += 2;
+  return 2;
+}
+
+int embb_mtapi_network_buffer_pop_front_int32(
+  embb_mtapi_network_buffer_t * that,
+  int32_t * value) {
+  if (that->position + 4 > that->size) {
+    return 0;
+  }
+  memcpy(value, that->data + that->position, 4);
+  that->position += 4;
+  return 4;
+}
+
+int embb_mtapi_network_buffer_pop_front_rawdata(
+  embb_mtapi_network_buffer_t * that,
+  int32_t size,
+  void * rawdata) {
+  if (that->position + size > that->size) {
+    return 0;
+  }
+  memcpy(rawdata, that->data + that->position, size);
+  that->position += size;
+  return size;
+}

mtapi_network_c/src/embb_mtapi_network_buffer.h

+/*
+ * Copyright (c) 2014, Siemens AG. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef MTAPI_C_SRC_EMBB_MTAPI_NETWORK_BUFFER_H_
+#define MTAPI_C_SRC_EMBB_MTAPI_NETWORK_BUFFER_H_
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+struct embb_mtapi_network_buffer_struct {
+  int position;
+  int size;
+  int capacity;
+  char * data;
+};
+
+typedef struct embb_mtapi_network_buffer_struct embb_mtapi_network_buffer_t;
+
+void embb_mtapi_network_buffer_initialize(
+  embb_mtapi_network_buffer_t * that,
+  int capacity
+);
+
+void embb_mtapi_network_buffer_finalize(
+  embb_mtapi_network_buffer_t * that
+);
+
+int embb_mtapi_network_buffer_push_back_int8(
+  embb_mtapi_network_buffer_t * that,
+  int8_t value
+);
+
+int embb_mtapi_network_buffer_push_back_int16(
+  embb_mtapi_network_buffer_t * that,
+  int16_t value
+);
+
+int embb_mtapi_network_buffer_push_back_int32(
+  embb_mtapi_network_buffer_t * that,
+  int32_t value
+);
+
+int embb_mtapi_network_buffer_push_back_rawdata(
+  embb_mtapi_network_buffer_t * that,
+  int32_t size,
+  void * rawdata
+);
+
+int embb_mtapi_network_buffer_pop_front_int8(
+  embb_mtapi_network_buffer_t * that,
+  int8_t * value
+);
+
+int embb_mtapi_network_buffer_pop_front_int16(
+  embb_mtapi_network_buffer_t * that,
+  int16_t * value
+);
+
+int embb_mtapi_network_buffer_pop_front_int32(
+  embb_mtapi_network_buffer_t * that,
+  int32_t * value
+);
+
+int embb_mtapi_network_buffer_pop_front_rawdata(
+  embb_mtapi_network_buffer_t * that,
+  int32_t size,
+  void * rawdata
+);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // MTAPI_C_SRC_EMBB_MTAPI_NETWORK_BUFFER_H_