..............

driver.c

@@ -14,14 +14,25 @@ main(void)
   rb_init(&rb, 10, malloc, sizeof(int));
 
   int data[] = { 5, 6, 7, 8 };
-  rb_push(&rb, (void *)data, 4, memcpy);
+  printf("Address at data first element: %p\n", &data[0]);
+  printf("Address at internal first element: %p\n", &rb.buffer);
+  // rb_push(&rb, data, 4, memcpy);
+  rb_push_back(&rb, data, memcpy);
+
+  // Print addresses of data
+  for(int i = 0; i < 4; i++) {
+    printf("Address: %u\n", &data[i]);
+  }
+
+  print_seq(data, 4);
+  print_seq(rb.buffer, 4);
 
   int dest[5];
-  rb_read(&rb, (void *)dest, 5);
+  // rb_read(&rb, (void *)dest, 5);
 
-  for (int i = 0; i < 5; i++) {
-    printf("Data: %d\n", dest[i]);
-  }
+  // for (int i = 0; i < 5; i++) {
+  //   printf("Data: %d\n", dest[i]);
+  // }
 
   rb_destroy(&rb, free);
 

ringbuf.c

@@ -7,18 +7,20 @@
 #include "ringbuf.h"
 
 void
-rb_init(struct RingBuf *rb, rb_size_t capacity, ALLOC_T malloc_fn, rb_size_t struct_size)
+rb_init(struct RingBuf *rb, rb_size_t capacity, ALLOC_T malloc_fn,
+        rb_size_t struct_size)
 {
   rb->struct_size = struct_size;
   rb->capacity = capacity;
   rb->write_idx = 0;
   rb->read_idx = 0;
   rb->buffer = malloc_fn(capacity * struct_size); /* Calloc? */
+  rb->buffer_end = rb->buffer + (capacity * struct_size);
 
   // Read from buffer at max position to force a segfault if theres an issue
   printf("Reading from buffer at position %d\n",
          rb->capacity * rb->struct_size);
-  void *top = rb->buffer[rb->capacity * rb->struct_size];
+  void *top = rb->buffer + (rb->capacity * rb->struct_size);
   printf("Buffer top successfully read at virtual address: %p\n", &top);
 
   printf("Initialized ring buffer. Capacit: %d, struct_size: %d, total: %d\n",
@@ -32,15 +34,48 @@ rb_destroy(struct RingBuf *rb, void(free)())
 }
 
 enum WriteResult
-rb_push(struct RingBuf *rb, void *data[], rb_size_t amount, MEMCPY_T memcpy_fn)
+rb_push_back(struct RingBuf *rb, const void *item, MEMCPY_T memcpy_fn)
 {
-  printf("\nWriting %d elements\n", amount);
-  return Ok;
+  // if(rb->count == rb->capacity){
+  //     // handle error
+  // }
+
+  memcpy_fn(rb->write_head, item, rb->size);
+
+  rb->write_head = (char *)rb->write_head + rb->size;
+
+  if(rb->write_head == rb->buffer_end)
+    rb->write_head = rb->buffer;
+
+  rb->count++;
 }
 
+// void rb_pop_front(struct RingBuf *rb, void *item)
+// {
+//     if(cb->count == 0){
+//         // handle error
+//     }
+//     memcpy(item, cb->tail, cb->sz);
+//     cb->tail = (char*)cb->tail + cb->sz;
+//     if(cb->tail == cb->buffer_end)
+//         cb->tail = cb->buffer;
+//     cb->count--;
+// }
+
 void
 rb_read(struct RingBuf *rb, void *dest, int amount)
 {
   printf("\nReading %d elements\n", amount);
-  for(int i = 0; i < amount; i++) { }
+  for(int i = 0; i < amount; i++) {
+  }
+}
+
+void
+print_seq(void *begin, int amount)
+{
+  printf("\nPrinting sequence\n");
+  for(int i = 0; i < amount; i++) {
+    int *val = (int *)(begin + 4 * i);
+    printf("V: %d, A: %u\n", *val, val);
+  }
 }

ringbuf.h

@@ -16,11 +16,14 @@ typedef void *(*MEMCPY_T)(void *, const void *, rb_size_t);
 struct RingBuf {
   rb_size_t struct_size; /* Size of the struct */
   rb_size_t capacity;    /* The physical capacity of the entire ringbuf */
-  rb_size_t size;    /* The current size of the ring buffer */
+  rb_size_t size;        /* The current size of the ring buffer */
+  void     *write_head;  /* Address of the write head */
   rb_size_t write_idx;   /* The write head */
   rb_size_t read_idx;    /* THe read head */
-  void    **buffer;      /* The actual data */
-};
+  rb_size_t count;       /* The number of elements in the buffer */
+  void     *buffer;      /* The actual data */
+  void     *buffer_end;  /* The end of the buffer */
+} __attribute__((packed));
 
 enum WriteResult { CollisionError, Ok };
 
@@ -29,11 +32,16 @@ void rb_init(struct RingBuf *rb, rb_size_t capacity, void *(*alloc)(rb_size_t),
              rb_size_t struct_size);
 
 /** Insert data to the ring buffer */
-enum WriteResult rb_push(struct RingBuf *rb, void *data[], rb_size_t amount,
+enum WriteResult rb_push(struct RingBuf *rb, void *data, rb_size_t amount,
                          void *(*memcpy)(void *, const void *, rb_size_t));
 
+enum WriteResult rb_push_back(struct RingBuf *rb, const void *item,
+                              MEMCPY_T memcpy_fn);
+
 /** Read data from the ring buffer */
 void rb_read(struct RingBuf *rb, void *dest, int amount);
 
 /** Free the ring buffer */
 void rb_destroy(struct RingBuf *rb, void(free)());
+
+void print_seq(void *begin, int amount);