rsys

commit 03b5f7c650e8419ca9f6244d94a8e7ab9c61c1bb
parent 9c5aa667b93e1cf5d378c1abdf673eeaeb600469
Author: vaplv <vaplv@free.fr>
Date:   Fri, 26 May 2017 14:32:23 +0200

Update the API of the big_buffer at function

The function does not copy anymore the fetched data; it returns a
constant pointer toward it.

Diffstat:
M
src/big_buffer.h
 | 
22
++++++----------------
M
src/test_big_buffer.c
 | 
67
+++++++++++++++++++++++++++++--------------------------------------

2 files changed, 35 insertions(+), 54 deletions(-)
diff --git a/src/big_buffer.h b/src/big_buffer.h
@@ -409,27 +409,17 @@ error:
   goto exit;
 }
 
-static INLINE res_T
-BIGBUF_FUNC__(at)(struct BIGBUF__* bigbuf, const size_t at, BIGBUF_DATA* data)
+static INLINE const BIGBUF_DATA*
+BIGBUF_FUNC__(at)(struct BIGBUF__* bigbuf, const size_t at)
 {
-  res_T res = RES_OK;
-  ASSERT(bigbuf && data);
-
-  if(at >= bigbuf->size) {
-    res = RES_BAD_ARG;
-    goto error;
-  }
+  res_T res = RES_OK; (void)res;
+  ASSERT(bigbuf && data && at < bigbuf->size);
 
   res = BIGBUF_FUNC__(fetch__)(bigbuf, at);
-  if(res != RES_OK) goto error;
+  ASSERT(res == RES_OK);
 
   ASSERT(at >= bigbuf->buf_index);
-  *data = bigbuf->buf.data[at - bigbuf->buf_index];
-
-exit:
-  return res;
-error:
-  goto exit;
+  return bigbuf->buf.data + at - bigbuf->buf_index;
 }
 
 #undef BIGBUF_ALIGNMENT
diff --git a/src/test_big_buffer.c b/src/test_big_buffer.c
@@ -55,16 +55,15 @@ test_byte(struct mem_allocator* allocator)
   }
 
   CHECK(bigbuf_byte_size_get(&bytes), 32);
-  CHECK(bigbuf_byte_at(&bytes, 32, &byte), RES_BAD_ARG);
 
   FOR_EACH(i, 0, bigbuf_byte_size_get(&bytes)) {
-    CHECK(bigbuf_byte_at(&bytes, i, &byte), RES_OK);
+    byte = *bigbuf_byte_at(&bytes, i);
     CHECK((size_t)byte, i);
   }
 
   FOR_EACH(i, 0, 16) {
     size_t id = (size_t)(rand_canonic() * (double)bigbuf_byte_size_get(&bytes));
-    CHECK(bigbuf_byte_at(&bytes, id, &byte), RES_OK);
+    byte = *bigbuf_byte_at(&bytes, id);
     CHECK((size_t)byte, id);
   }
 
@@ -74,47 +73,44 @@ test_byte(struct mem_allocator* allocator)
   }
 
   FOR_EACH(i, 0, bigbuf_byte_size_get(&bytes)) {
-    CHECK(bigbuf_byte_at(&bytes, i, &byte), RES_OK);
+    byte = *bigbuf_byte_at(&bytes, i);
     CHECK((size_t)byte, i);
   }
 
   CHECK(bigbuf_byte_size_get(&bytes), 64);
-  CHECK(bigbuf_byte_at(&bytes, 61, &byte), RES_OK);
+  byte = *bigbuf_byte_at(&bytes, 61);
 
   CHECK(bigbuf_byte_resize(&bytes, 63), RES_OK);
   CHECK(bigbuf_byte_size_get(&bytes), 63);
-  CHECK(bigbuf_byte_at(&bytes, 64, &byte), RES_BAD_ARG);
-  CHECK(bigbuf_byte_at(&bytes, 63, &byte), RES_BAD_ARG);
-  CHECK(bigbuf_byte_at(&bytes, 62, &byte), RES_OK);
+  byte = *bigbuf_byte_at(&bytes, 62);
   CHECK(byte, 62);
 
   byte = 63;
   CHECK(bigbuf_byte_push_back(&bytes, &byte), RES_OK);
   CHECK(bigbuf_byte_size_get(&bytes), 64);
   FOR_EACH(i, 0, bigbuf_byte_size_get(&bytes)) {
-    CHECK(bigbuf_byte_at(&bytes, i, &byte), RES_OK);
+    byte = *bigbuf_byte_at(&bytes, i);
     CHECK((size_t)byte, i);
   }
 
   CHECK(bigbuf_byte_resize(&bytes, 32), RES_OK);
   CHECK(bigbuf_byte_resize(&bytes, 32), RES_OK);
-  CHECK(bigbuf_byte_at(&bytes, 32, &byte), RES_BAD_ARG);
 
-  CHECK(bigbuf_byte_at(&bytes, 31, &byte), RES_OK);
+  byte = *bigbuf_byte_at(&bytes, 31);
   CHECK(byte, 31);
   FOR_EACH(i, 0, 32) {
     byte = (char)(i + 32);
     CHECK(bigbuf_byte_push_back(&bytes, &byte), RES_OK);
   }
   FOR_EACH(i, 0, bigbuf_byte_size_get(&bytes)) {
-    CHECK(bigbuf_byte_at(&bytes, i, &byte), RES_OK);
+    byte = *bigbuf_byte_at(&bytes, i);
     CHECK((size_t)byte, i);
   }
 
   CHECK(bigbuf_byte_resize(&bytes, 128), RES_OK);
   CHECK(bigbuf_byte_size_get(&bytes), 128);
   FOR_EACH(i, 0, bigbuf_byte_size_get(&bytes)) {
-    CHECK(bigbuf_byte_at(&bytes, i, &byte), RES_OK);
+    byte = *bigbuf_byte_at(&bytes, i);
     if(i < 64) {
       CHECK((size_t)byte, i);
     } else {
@@ -126,17 +122,16 @@ test_byte(struct mem_allocator* allocator)
   FOR_EACH(i, 0, 64) {
     byte = (char)(i+64);
     CHECK(bigbuf_byte_set(&bytes, (size_t)byte, &byte), RES_OK);
-    CHECK(bigbuf_byte_at(&bytes, (size_t)byte - 1, &byte), RES_OK);
+    byte = *bigbuf_byte_at(&bytes, (size_t)byte - 1);
     CHECK((size_t)byte, i+63);
   }
   FOR_EACH(i, 0, bigbuf_byte_size_get(&bytes)) {
-    CHECK(bigbuf_byte_at(&bytes, i, &byte), RES_OK);
+    byte = *bigbuf_byte_at(&bytes, i);
     CHECK((size_t)byte, i);
   }
 
   CHECK(bigbuf_byte_clear(&bytes), RES_OK);
   CHECK(bigbuf_byte_size_get(&bytes), 0);
-  CHECK(bigbuf_byte_at(&bytes, 0, &byte), RES_BAD_ARG);
   CHECK(bigbuf_byte_set(&bytes, 0, &byte), RES_BAD_ARG);
   FOR_EACH(i, 0, 16) {
     byte = (char)i;
@@ -144,7 +139,7 @@ test_byte(struct mem_allocator* allocator)
   }
   CHECK(bigbuf_byte_size_get(&bytes), 16);
   FOR_EACH(i, 0, bigbuf_byte_size_get(&bytes)) {
-    CHECK(bigbuf_byte_at(&bytes, i, &byte), RES_OK);
+    byte = *bigbuf_byte_at(&bytes, i);
     CHECK((size_t)byte, i);
   }
 
@@ -171,7 +166,7 @@ test_integer(struct mem_allocator* allocator)
 
   FOR_EACH(i, 0, 666) {
     size_t id = (size_t)(rand_canonic() * (double)bigbuf_integer_size_get(&ints));
-    CHECK(bigbuf_integer_at(&ints, id, &integer), RES_OK);
+    integer = *bigbuf_integer_at(&ints, id);
     CHECK((size_t)integer, id);
   }
 
@@ -182,7 +177,7 @@ test_integer(struct mem_allocator* allocator)
 
   CHECK(bigbuf_integer_size_get(&ints), 1665);
   FOR_EACH(i, 0, bigbuf_integer_size_get(&ints)) {
-    CHECK(bigbuf_integer_at(&ints, i, &integer), RES_OK);
+    integer = *bigbuf_integer_at(&ints, i);
     CHECK((size_t)integer, i);
   }
 
@@ -194,7 +189,7 @@ test_integer(struct mem_allocator* allocator)
 
   FOR_EACH(i, 0, 666) {
     size_t id = (size_t)(rand_canonic() * (double)bigbuf_integer_size_get(&ints));
-    CHECK(bigbuf_integer_at(&ints, id, &integer), RES_OK);
+    integer = *bigbuf_integer_at(&ints, id);
     CHECK((size_t)integer, id);
   }
 
@@ -211,30 +206,29 @@ test_integer(struct mem_allocator* allocator)
   CHECK(bigbuf_integer_size_get(&ints2), 2689);
 
   FOR_EACH(i, 0, bigbuf_integer_size_get(&ints2)) {
-    CHECK(bigbuf_integer_at(&ints2, i, &integer), RES_OK);
+    integer = *bigbuf_integer_at(&ints2, i);
     CHECK((size_t)integer, i);
   }
 
   CHECK(bigbuf_integer_resize(&ints2, 999), RES_OK);
   CHECK(bigbuf_integer_size_get(&ints2), 999);
   FOR_EACH(i, 0, bigbuf_integer_size_get(&ints2)) {
-    CHECK(bigbuf_integer_at(&ints2, i, &integer), RES_OK);
+    integer = *bigbuf_integer_at(&ints2, i);
     integer = -integer;
     CHECK(bigbuf_integer_set(&ints2, i, &integer), RES_OK);
     if(i) {
-      CHECK(bigbuf_integer_at(&ints2, i-1, &integer), RES_OK);
+      integer = *bigbuf_integer_at(&ints2, i-1);
       CHECK(integer, 1 - (int)i);
     }
   }
 
   FOR_EACH(i, 0, bigbuf_integer_size_get(&ints2)) {
-    CHECK(bigbuf_integer_at(&ints2, i, &integer), RES_OK);
+    integer = *bigbuf_integer_at(&ints2, i);
     CHECK(integer, -(int)i);
   }
 
   CHECK(bigbuf_integer_clear(&ints2), RES_OK);
   CHECK(bigbuf_integer_size_get(&ints2), 0);
-  CHECK(bigbuf_integer_at(&ints2, 0, &integer), RES_BAD_ARG);
   CHECK(bigbuf_integer_set(&ints2, 0, &integer), RES_BAD_ARG);
   FOR_EACH(i, 0, 64) {
     integer = (int)i;
@@ -242,7 +236,7 @@ test_integer(struct mem_allocator* allocator)
   }
   CHECK(bigbuf_integer_size_get(&ints2), 64);
   FOR_EACH(i, 0, bigbuf_integer_size_get(&ints2)) {
-    CHECK(bigbuf_integer_at(&ints2, i, &integer), RES_OK);
+    integer = *bigbuf_integer_at(&ints2, i);
     CHECK(integer, (int)i);
   }
 
@@ -273,7 +267,7 @@ test_real(struct mem_allocator* allocator)
 
   FOR_EACH(i, 0, 10) {
     size_t id = (size_t)(rand_canonic() * (double)bigbuf_real_size_get(&reals));
-    CHECK(bigbuf_real_at(&reals, id, &real), RES_OK);
+    real = *bigbuf_real_at(&reals, id);
     CHECK(real, (double)id/100.0);
   }
 
@@ -293,28 +287,26 @@ test_real(struct mem_allocator* allocator)
   CHECK(bigbuf_real_size_get(&reals2), 6000);
 
   FOR_EACH(i, 0, bigbuf_real_size_get(&reals)) {
-    CHECK(bigbuf_real_at(&reals, i, &real), RES_OK);
+    real = *bigbuf_real_at(&reals, i);
     CHECK(real, (double)i/100.0);
   }
 
   FOR_EACH(i, 0, 300) {
     size_t id = (size_t)(rand_canonic() * (double)bigbuf_real_size_get(&reals2));
-    CHECK(bigbuf_real_at(&reals2, id, &real), RES_OK);
+    real = *bigbuf_real_at(&reals2, id);
     CHECK(real, (double)id/100.0);
   }
 
-  CHECK(bigbuf_real_at(&reals2, 5990, &real), RES_OK);
+  real = *bigbuf_real_at(&reals2, 5990);
   CHECK(real, 59.90);
   CHECK(bigbuf_real_resize(&reals2, 5992), RES_OK);
-  CHECK(bigbuf_real_at(&reals2, 5990, &real), RES_OK);
+  real = *bigbuf_real_at(&reals2, 5990);
   CHECK(real, 59.90);
   CHECK(bigbuf_real_resize(&reals2, 5990), RES_OK);
-  CHECK(bigbuf_real_at(&reals2, 5990, &real), RES_BAD_ARG);
-  CHECK(bigbuf_real_at(&reals2, 5989, &real), RES_OK);
+  real = *bigbuf_real_at(&reals2, 5989);
   CHECK(real, 59.89);
   CHECK(bigbuf_real_resize(&reals2, 5985), RES_OK);
-  CHECK(bigbuf_real_at(&reals2, 5985, &real), RES_BAD_ARG);
-  CHECK(bigbuf_real_at(&reals2, 5984, &real), RES_OK);
+  real = *bigbuf_real_at(&reals2, 5984);
   CHECK(real, 59.84);
 
   FOR_EACH(i, 0, sizeof(ids)/sizeof(size_t)) {
@@ -326,7 +318,7 @@ test_real(struct mem_allocator* allocator)
   CHECK(bigbuf_real_size_get(&reals2), 5985);
   FOR_EACH(i, 0, bigbuf_real_size_get(&reals2)) {
     size_t j;
-    CHECK(bigbuf_real_at(&reals2, i, &real), RES_OK);
+    real = *bigbuf_real_at(&reals2, i);
 
     FOR_EACH(j, 0, sizeof(ids)/sizeof(size_t)) {
       if(i == ids[j]) break;
@@ -341,7 +333,6 @@ test_real(struct mem_allocator* allocator)
 
   CHECK(bigbuf_real_clear(&reals2), RES_OK);
   CHECK(bigbuf_real_size_get(&reals2), 0);
-  CHECK(bigbuf_real_at(&reals2, 0, &real), RES_BAD_ARG);
   CHECK(bigbuf_real_set(&reals2, 0, &real), RES_BAD_ARG);
   FOR_EACH(i, 0, 64) {
     real = (double)i;
@@ -349,7 +340,7 @@ test_real(struct mem_allocator* allocator)
   }
   CHECK(bigbuf_real_size_get(&reals2), 64);
   FOR_EACH(i, 0, bigbuf_real_size_get(&reals2)) {
-    CHECK(bigbuf_real_at(&reals2, i, &real), RES_OK);
+    real = *bigbuf_real_at(&reals2, i);
     CHECK(real, (double)i);
   }