[*] Renaming in dap_circular_buffer

core/circular_buffer.h

+//
+//  CircularBuffer.h
+//
+//  Created by 罗亮富(Roen)zxllf23@163.com on 14-1-14.
+//  Copyright (c) 2014年 All rights reserved.
+//
+//  Note: Edited by Kurotych Anatolii
+
+#ifndef YYDJ_Roen_CircularBuffer_h
+#define YYDJ_Roen_CircularBuffer_h
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+
+/*
+ A circular buffer(circular queue, cyclic buffer or ring buffer), is a data structure that uses a single, fixed-size buffer as if it were connected end-to-end. This structure lends itself easily to buffering data streams. visit https://en.wikipedia.org/wiki/Circular_buffer to see more information.
+ */
+
+typedef struct s_circularBuffer* CircularBuffer;
+
+// Construct CircularBuffer with ‘size' in byte. You must call CircularBufferFree() in balance for destruction.
+extern CircularBuffer CircularBufferCreate(size_t size);
+
+// Destruct CircularBuffer
+extern void CircularBufferFree(CircularBuffer cBuf);
+
+// Reset the CircularBuffer
+extern void CircularBufferReset(CircularBuffer cBuf);
+
+//get the capacity of CircularBuffer
+extern size_t CircularBufferGetCapacity(CircularBuffer cBuf);
+
+//get occupied data size of CircularBuffer
+extern size_t CircularBufferGetDataSize(CircularBuffer cBuf);
+
+// Push data to the tail of a circular buffer from 'src' with 'length' size in byte.
+extern void CircularBufferPush(CircularBuffer cBuf,void *src, size_t length);
+
+// Pop data from a circular buffer to 'dataOut'  with wished 'length' size in byte,return the actual data size in byte popped out,which is less or equal to the input 'length parameter.
+extern size_t CircularBufferPop(CircularBuffer cBuf, size_t length, void *dataOut);
+
+// Read data from a circular buffer to 'dataOut'  with wished 'length' size in byte,return the actual data size in byte popped out,which is less or equal to the input 'length parameter.
+extern size_t CircularBufferRead(CircularBuffer cBuf, size_t length, void *dataOut);
+
+#ifdef __unix__
+// Write data from a cicrular buffer to file descriptor. This is non blocking operation ( use flags MSG_DONTWAIT | MSG_NOSIGNAL )
+// if >= 0 return write data count
+// <= 0 reserved for errors
+extern int CircularBufferWriteInSocket(CircularBuffer cBuf, int sockfd);
+#endif
+
+//for test purpose, print the circular buffer's data content by printf(...); the 'hex' parameters indicates that if the data should be printed in asscii string or hex data format.
+extern void CircularBufferPrint(CircularBuffer cBuf, bool hex);
+#endif

core/dap_circular_buffer.c

@@ -25,44 +25,44 @@ struct s_circularBuffer{
 
 };
 
-extern CircularBuffer CircularBufferCreate(size_t size)
+extern circular_buffer_t circular_buffer_create(size_t size)
 {
     size_t totalSize = sizeof(struct s_circularBuffer) + size;
     void *p = malloc(totalSize);
-    CircularBuffer buffer = (CircularBuffer)p;
+    circular_buffer_t buffer = (circular_buffer_t)p;
     buffer->buffer = p + sizeof(struct s_circularBuffer);
     buffer->capacity = size;
-    CircularBufferReset(buffer);
+    circular_buffer_reset(buffer);
     return buffer;
 }
 
-void CircularBufferFree(CircularBuffer cBuf)
+void circular_buffer_free(circular_buffer_t cBuf)
 {
-    CircularBufferReset(cBuf);
+    circular_buffer_reset(cBuf);
     cBuf->capacity = 0;
     cBuf->dataSize = 0;
     cBuf->buffer = NULL;
     free(cBuf);
 }
 
-void CircularBufferReset(CircularBuffer cBuf)
+void circular_buffer_reset(circular_buffer_t cBuf)
 {
     cBuf->headOffset = -1;
     cBuf->tailOffset = -1;
     cBuf->dataSize = 0;
 }
 
-size_t CircularBufferGetCapacity(CircularBuffer cBuf)
+size_t circular_buffer_get_capacity(circular_buffer_t cBuf)
 {
     return cBuf->capacity;
 }
 
-size_t CircularBufferGetDataSize(CircularBuffer cBuf)
+size_t circular_buffer_get_data_size(circular_buffer_t cBuf)
 {
     return cBuf->dataSize;
 }
 
-void CircularBufferPush(CircularBuffer cBuf,void *src, size_t length)
+void circular_buffer_push(circular_buffer_t cBuf,void *src, size_t length)
 {
     if(length == 0)
         return;
@@ -133,7 +133,7 @@ void CircularBufferPush(CircularBuffer cBuf,void *src, size_t length)
 #include <sys/types.h>
 #include <sys/socket.h>
 
-int CircularBufferWriteInSocket(CircularBuffer cBuf, int sockfd)
+int circular_buffer_write_In_socket(circular_buffer_t cBuf, int sockfd)
 {
     if(cBuf->dataSize == 0) {
         return 0;
@@ -181,7 +181,7 @@ int CircularBufferWriteInSocket(CircularBuffer cBuf, int sockfd)
 
             if(rdLen < (ssize_t)countBytesToEnd) {
                 log_it(L_WARNING, "rdLen < countBytesToEnd");
-                CircularBufferPop(cBuf, rdLen, NULL);
+                circular_buffer_pop(cBuf, rdLen, NULL);
                 return rdLen;
             }
 
@@ -215,7 +215,7 @@ int CircularBufferWriteInSocket(CircularBuffer cBuf, int sockfd)
 
 #endif
 
-size_t inter_circularBuffer_read(CircularBuffer cBuf, size_t length, void *dataOut, bool resetHead)
+size_t inter_circularBuffer_read(circular_buffer_t cBuf, size_t length, void *dataOut, bool resetHead)
 {
     if(cBuf->dataSize == 0 || length == 0)
         return 0;
@@ -284,29 +284,29 @@ size_t inter_circularBuffer_read(CircularBuffer cBuf, size_t length, void *dataO
 }
 
 
-size_t CircularBufferPop(CircularBuffer cBuf, size_t length, void *dataOut)
+size_t circular_buffer_pop(circular_buffer_t cBuf, size_t length, void *dataOut)
 {
     return inter_circularBuffer_read(cBuf,length,dataOut,true);
 }
 
-size_t CircularBufferRead(CircularBuffer cBuf, size_t length, void *dataOut)
+size_t circular_buffer_read(circular_buffer_t cBuf, size_t length, void *dataOut)
 {
     return inter_circularBuffer_read(cBuf,length,dataOut,false);
 }
 
 
 //print circular buffer's content into str,
-void CircularBufferPrint(CircularBuffer cBuf, bool hex)
+void circular_buffer_print(circular_buffer_t cBuf, bool hex)
 {
     u_int8_t *b = cBuf->buffer;
-    size_t cSize = CircularBufferGetCapacity(cBuf);
+    size_t cSize = circular_buffer_get_capacity(cBuf);
     char *str = malloc(2*cSize+1);
 
     char c;
 
     for(size_t i=0; i<cSize; i++)
     {
-        if(CircularBufferGetDataSize(cBuf) == 0)
+        if(circular_buffer_get_data_size(cBuf) == 0)
         {
             c = '_';
         }
@@ -330,7 +330,7 @@ void CircularBufferPrint(CircularBuffer cBuf, bool hex)
             sprintf(str+i*2, "%c|",c);
     }
 
-    printf("CircularBuffer: %s <size %zu dataSize:%zu>\n",str,CircularBufferGetCapacity(cBuf),CircularBufferGetDataSize(cBuf));
+    printf("CircularBuffer: %s <size %zu dataSize:%zu>\n",str,circular_buffer_get_capacity(cBuf),circular_buffer_get_data_size(cBuf));
 
     free(str);
 }

core/dap_circular_buffer.h

@@ -4,6 +4,7 @@
 //  Created by 罗亮富(Roen)zxllf23@163.com on 14-1-14.
 //  Copyright (c) 2014年 All rights reserved.
 //
+//  Note: edited by Anatolii Kurotych
 
 #ifndef YYDJ_Roen_CircularBuffer_h
 #define YYDJ_Roen_CircularBuffer_h
@@ -15,37 +16,37 @@
  A circular buffer(circular queue, cyclic buffer or ring buffer), is a data structure that uses a single, fixed-size buffer as if it were connected end-to-end. This structure lends itself easily to buffering data streams. visit https://en.wikipedia.org/wiki/Circular_buffer to see more information.
  */
 
-typedef struct s_circularBuffer* CircularBuffer;
+typedef struct s_circularBuffer* circular_buffer_t;
 
 // Construct CircularBuffer with ‘size' in byte. You must call CircularBufferFree() in balance for destruction.
-extern CircularBuffer CircularBufferCreate(size_t size);
+extern circular_buffer_t circular_buffer_create(size_t size);
 
 // Destruct CircularBuffer
-extern void CircularBufferFree(CircularBuffer cBuf);
+extern void circular_buffer_free(circular_buffer_t cBuf);
 
 // Reset the CircularBuffer
-extern void CircularBufferReset(CircularBuffer cBuf);
+extern void circular_buffer_reset(circular_buffer_t cBuf);
 
 //get the capacity of CircularBuffer
-extern size_t CircularBufferGetCapacity(CircularBuffer cBuf);
+extern size_t circular_buffer_get_capacity(circular_buffer_t cBuf);
 
 //get occupied data size of CircularBuffer
-extern size_t CircularBufferGetDataSize(CircularBuffer cBuf);
+extern size_t circular_buffer_get_data_size(circular_buffer_t cBuf);
 
 // Push data to the tail of a circular buffer from 'src' with 'length' size in byte.
-extern void CircularBufferPush(CircularBuffer cBuf,void *src, size_t length);
+extern void circular_buffer_push(circular_buffer_t cBuf,void *src, size_t length);
 
 // Pop data from a circular buffer to 'dataOut'  with wished 'length' size in byte,return the actual data size in byte popped out,which is less or equal to the input 'length parameter.
-extern size_t CircularBufferPop(CircularBuffer cBuf, size_t length, void *dataOut);
+extern size_t circular_buffer_pop(circular_buffer_t cBuf, size_t length, void *dataOut);
 
 // Read data from a circular buffer to 'dataOut'  with wished 'length' size in byte,return the actual data size in byte popped out,which is less or equal to the input 'length parameter.
-extern size_t CircularBufferRead(CircularBuffer cBuf, size_t length, void *dataOut);
+extern size_t circular_buffer_read(circular_buffer_t cBuf, size_t length, void *dataOut);
 
 //for test purpose, print the circular buffer's data content by printf(...); the 'hex' parameters indicates that if the data should be printed in asscii string or hex data format.
-extern void CircularBufferPrint(CircularBuffer cBuf, bool hex);
+extern void circular_buffer_print(circular_buffer_t cBuf, bool hex);
 
 #ifdef __unix__
 // Read data from a circular buffer to socketFd
-extern int CircularBufferWriteInSocket(CircularBuffer cBuf, int sockfd);
+extern int circular_buffer_write_In_socket(circular_buffer_t cBuf, int sockfd);
 #endif
 #endif

test/core/dap_circular_test.c

@@ -12,17 +12,17 @@ static char *chars_string = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNO
 void dap_circular_test_simple()
 {
     const int buf_size = 8;
-    CircularBuffer cb = CircularBufferCreate(buf_size);
+    circular_buffer_t cb = circular_buffer_create(buf_size);
 
-    CircularBufferPush(cb, chars_string, buf_size);
+    circular_buffer_push(cb, chars_string, buf_size);
 
     int fd[2];
     socketpair(PF_LOCAL, SOCK_STREAM, 0, fd);
 
-    int ret = CircularBufferWriteInSocket(cb, fd[0]);
+    int ret = circular_buffer_write_In_socket(cb, fd[0]);
     dap_assert(ret == buf_size, "Check ret write in socket");
 
-    ret = CircularBufferWriteInSocket(cb, fd[0]);
+    ret = circular_buffer_write_In_socket(cb, fd[0]);
     dap_assert(ret == 0, "Check ret write in socket");
     char result_buff[MAX_RESULT_BUF_LEN] = {0};
     ssize_t res = read(fd[1], result_buff, 44);
@@ -31,11 +31,11 @@ void dap_circular_test_simple()
 
     dap_assert(dap_strn_equals(result_buff, chars_string, buf_size),
                "Check result buf");
-    dap_assert(CircularBufferGetDataSize(cb) == 0, "Check data size");
+    dap_assert(circular_buffer_get_data_size(cb) == 0, "Check data size");
 
     close(fd[0]);
     close(fd[1]);
-    CircularBufferFree(cb);
+    circular_buffer_free(cb);
     dap_pass_msg("Test simple");
 }
 
@@ -44,18 +44,18 @@ void dap_circular_test_double_write()
     const int buf_size = 8;
     const char* expected_string = "0123456701";
     int expected_string_len = strlen(expected_string);
-    CircularBuffer cb = CircularBufferCreate(buf_size);
+    circular_buffer_t cb = circular_buffer_create(buf_size);
 
-    CircularBufferPush(cb, chars_string, buf_size);
+    circular_buffer_push(cb, chars_string, buf_size);
 
     int fd[2];
     socketpair(PF_LOCAL, SOCK_STREAM, 0, fd);
 
-    int ret = CircularBufferWriteInSocket(cb, fd[0]);
+    int ret = circular_buffer_write_In_socket(cb, fd[0]);
 
-    CircularBufferPush(cb, chars_string, 2);
+    circular_buffer_push(cb, chars_string, 2);
 
-    ret = CircularBufferWriteInSocket(cb, fd[0]);
+    ret = circular_buffer_write_In_socket(cb, fd[0]);
     dap_assert(ret == 2, "Check ret write in socket");
 
     char result_buff[MAX_RESULT_BUF_LEN] = {0};
@@ -65,10 +65,10 @@ void dap_circular_test_double_write()
 
     dap_assert(dap_str_equals(result_buff, expected_string),
                "Check result buf");
-    dap_assert(CircularBufferGetDataSize(cb) == 0, "Check data size");
+    dap_assert(circular_buffer_get_data_size(cb) == 0, "Check data size");
     dap_pass_msg("Double write");
 
-    CircularBufferFree(cb);
+    circular_buffer_free(cb);
     close(fd[0]);
     close(fd[1]);
 }
@@ -78,11 +78,11 @@ void dap_circular_test_defrag_write()
     const int buf_size = 8;
     const char* expected_string = "56701201";
     int expected_string_len = strlen(expected_string);
-    CircularBuffer cb = CircularBufferCreate(buf_size);
+    circular_buffer_t cb = circular_buffer_create(buf_size);
 
-    CircularBufferPush(cb, chars_string, buf_size);
-    CircularBufferPop(cb, 5, NULL);
-    CircularBufferPush(cb, chars_string, 3);
+    circular_buffer_push(cb, chars_string, buf_size);
+    circular_buffer_pop(cb, 5, NULL);
+    circular_buffer_push(cb, chars_string, 3);
     // expected string here 567012
 
 
@@ -90,14 +90,14 @@ void dap_circular_test_defrag_write()
     socketpair(PF_LOCAL, SOCK_STREAM, 0, fd);
 
     // write 567012
-    int ret = CircularBufferWriteInSocket(cb, fd[0]);
+    int ret = circular_buffer_write_In_socket(cb, fd[0]);
     dap_assert(ret == 6, "Check ret write in socket");
 
     // push 01
-    CircularBufferPush(cb, chars_string, 2);
+    circular_buffer_push(cb, chars_string, 2);
 
     // write 01
-    ret = CircularBufferWriteInSocket(cb, fd[0]);
+    ret = circular_buffer_write_In_socket(cb, fd[0]);
     dap_assert(ret == 2, "Check ret write in socket");
 
     char result_buff[MAX_RESULT_BUF_LEN] = {0};
@@ -109,8 +109,8 @@ void dap_circular_test_defrag_write()
                "Check result buf");
 
     dap_pass_msg("Double write");
-    dap_assert(CircularBufferGetDataSize(cb) == 0, "Check data size");
-    CircularBufferFree(cb);
+    dap_assert(circular_buffer_get_data_size(cb) == 0, "Check data size");
+    circular_buffer_free(cb);
     close(fd[0]);
     close(fd[1]);
 }
@@ -118,9 +118,9 @@ void dap_circular_test_defrag_write()
 void dap_circular_test_write_bad_socket()
 {
     const int buf_size = 8;
-    CircularBuffer cb = CircularBufferCreate(buf_size);
+    circular_buffer_t cb = circular_buffer_create(buf_size);
 
-    CircularBufferPush(cb, chars_string, buf_size);
+    circular_buffer_push(cb, chars_string, buf_size);
 
     int fd[2];
     socketpair(PF_LOCAL, SOCK_STREAM, 0, fd);
@@ -128,10 +128,10 @@ void dap_circular_test_write_bad_socket()
     socketpair(PF_LOCAL, SOCK_STREAM, 0, fd2);
 
     close(fd[0]);
-    int ret = CircularBufferWriteInSocket(cb, fd[0]);
+    int ret = circular_buffer_write_In_socket(cb, fd[0]);
     dap_assert(ret == -1, "Check ret write in socket");
 
-    ret = CircularBufferWriteInSocket(cb, fd2[0]);
+    ret = circular_buffer_write_In_socket(cb, fd2[0]);
     dap_assert(ret == 8, "Check ret write in socket");
     char result_buff[MAX_RESULT_BUF_LEN] = {0};
     ssize_t res = read(fd2[1], result_buff, MAX_RESULT_BUF_LEN);
@@ -141,13 +141,13 @@ void dap_circular_test_write_bad_socket()
     dap_assert(dap_strn_equals(result_buff, chars_string, buf_size),
                "Check result buf");
 
-    ret = CircularBufferWriteInSocket(cb, fd2[0]);
+    ret = circular_buffer_write_In_socket(cb, fd2[0]);
     dap_assert(ret == 0, "Check zero write");
-    dap_assert(CircularBufferGetDataSize(cb) == 0, "Check data size");
+    dap_assert(circular_buffer_get_data_size(cb) == 0, "Check data size");
     close(fd[1]);
     close(fd2[0]);
     close(fd2[1]);
-    CircularBufferFree(cb);
+    circular_buffer_free(cb);
     dap_pass_msg("Test simple");
 }
 
@@ -160,7 +160,7 @@ void dap_circular_load_test()
     const char *digits = "123456789";
 
     const int buf_size = strlen(digits);
-    CircularBuffer cb = CircularBufferCreate(buf_size);
+    circular_buffer_t cb = circular_buffer_create(buf_size);
 
     int fd[2];
     socketpair(PF_LOCAL, SOCK_STREAM, 0, fd);
@@ -168,22 +168,22 @@ void dap_circular_load_test()
     int count_writed_bytes = 0;
 
     // defrag buffer
-    CircularBufferPush(cb, (void*)digits, strlen(digits));
-    CircularBufferPop(cb, strlen(digits) - 1, NULL);
-    CircularBufferPush(cb, (void*)digits, 3);
+    circular_buffer_push(cb, (void*)digits, strlen(digits));
+    circular_buffer_pop(cb, strlen(digits) - 1, NULL);
+    circular_buffer_push(cb, (void*)digits, 3);
     count_writed_bytes = 4;
 
     char expectedBuffer[MAX_RESULT_BUF_LEN];
-    CircularBufferRead(cb, count_writed_bytes, expectedBuffer);
+    circular_buffer_read(cb, count_writed_bytes, expectedBuffer);
 
     int count_write_bytes = 4;
     do {
-        int r = CircularBufferWriteInSocket(cb, fd[0]);
+        int r = circular_buffer_write_In_socket(cb, fd[0]);
         dap_assert_PIF(r == count_write_bytes, "Check write bytes");
-        dap_assert_PIF(CircularBufferGetDataSize(cb) == 0, "buf size must be 0!");
+        dap_assert_PIF(circular_buffer_get_data_size(cb) == 0, "buf size must be 0!");
 
         count_write_bytes = rand() % strlen(digits);
-        CircularBufferPush(cb, (void*)digits, count_write_bytes);
+        circular_buffer_push(cb, (void*)digits, count_write_bytes);
         strncat(expectedBuffer, digits, count_write_bytes);
         count_writed_bytes += count_write_bytes;
     } while (--iterations);
@@ -195,7 +195,7 @@ void dap_circular_load_test()
 
     dap_assert(memcmp(expectedBuffer, result_buff, res) == 0, "Check expected and result buffer");
 
-    CircularBufferFree(cb);
+    circular_buffer_free(cb);
     close(fd[0]);
     close(fd[1]);
 }