Imports for Queue

include/core/Queue.h

@@ -15,17 +15,25 @@ typedef struct CoreQueueT CoreQueue;
 
 void coreInitQueue(CoreQueue* r, size_t capacity, size_t dataSize);
 void coreDestroyQueue(CoreQueue* r);
-void coreQueueAddPointer(CoreQueue* r, const void* data);
-#define coreQueueAdd(l, type, ...) coreQueueAddPointer(l, &(type){__VA_ARGS__})
-void* coreQueueGetVoidPointer(const CoreQueue* r, size_t index);
-#define coreQueueGetPointer(r, index, type)                                    \
-    ((type*)coreQueueGetVoidPointer(r, index))
-#define coreQueueGet(r, index, type) (*coreQueueGetPointer(r, index, type))
-const void* coreQueueGetVoidPointerC(const CoreQueue* r, size_t index);
-#define coreQueueGetPointerC(r, index, type)                                   \
-    ((const type*)coreQueueGetVoidPointerC(r, index))
-#define coreQueueGetC(r, index, type) (*coreQueueGetPointerC(r, index, type))
+void corePushQueueData(CoreQueue* r, const void* data);
+#define corePushQueueType(l, type, ...)                                        \
+    corePushQueueData(l, &(type){__VA_ARGS__})
+void* coreGetQueueIndex(const CoreQueue* r, size_t index);
+#define coreGetTypedQueueIndex(r, index, type)                                 \
+    (*(type*)coreGetQueueIndex(r, index))
 void coreClearQueue(CoreQueue* r);
-void coreQueueRemove(CoreQueue* r);
+void corePopQueueData(CoreQueue* r);
+
+#ifdef IMPORT_CORE
+#define Queue CoreQueue
+#define initQueue coreInitQueue
+#define destroyQueue coreDestroyQueue
+#define pushQueueData corePushQueueData
+#define pushQueueType corePushQueueType
+#define getQueueIndex coreGetQueueIndex
+#define getTypedQueueIndex coreGetTypedQueueIndex
+#define clearQueue coreClearQueue
+#define popQueueData corePopQueueData
+#endif
 
 #endif

src/Queue.c

@@ -7,49 +7,41 @@
 #include "core/ToString.h"
 #include "core/Utility.h"
 
-void coreInitQueue(CoreQueue* r, size_t capacity, size_t dataSize) {
-    *r = ((CoreQueue){0, 0, 0, capacity, dataSize, nullptr});
+void initQueue(Queue* r, size_t capacity, size_t dataSize) {
+    *r = ((Queue){0, 0, 0, capacity, dataSize, nullptr});
 }
 
-void coreDestroyQueue(CoreQueue* r) {
-    coreClearQueue(r);
-    r->dataSize = 0;
-    r->capacity = 0;
-    coreFree(r->data);
-    r->data = nullptr;
+void destroyQueue(Queue* r) {
+    cFree(r->data);
+    *r = (Queue){0};
 }
 
-static void* getPointer(const CoreQueue* r, size_t index) {
+static void* getPointer(const Queue* r, size_t index) {
     return (char*)r->data + r->dataSize * index;
 }
 
-void coreQueueAddPointer(CoreQueue* r, const void* data) {
+void pushQueueData(Queue* r, const void* data) {
     if(r->length >= r->capacity) {
         return;
     } else if(r->data == nullptr) {
-        r->data = coreAllocate(r->capacity * r->dataSize);
+        r->data = cAllocate(r->capacity * r->dataSize);
     }
     memcpy(getPointer(r, r->writeIndex), data, r->dataSize);
     r->writeIndex = (r->writeIndex + 1) % r->capacity;
     r->length++;
 }
 
-void* coreQueueGetVoidPointer(const CoreQueue* r, size_t index) {
+void* getQueueIndex(const Queue* r, size_t index) {
     return getPointer(r, (index + r->readIndex) % r->capacity);
 }
 
-const void* coreQueueGetVoidPointerC(const CoreQueue* r, size_t index) {
-    return (char*)r->data +
-           r->dataSize * ((index + r->readIndex) % r->capacity);
-}
-
-void coreClearQueue(CoreQueue* r) {
+void clearQueue(Queue* r) {
     r->writeIndex = 0;
     r->readIndex = 0;
     r->length = 0;
 }
 
-void coreQueueRemove(CoreQueue* r) {
+void popQueueData(Queue* r) {
     assert(r->length > 0);
     r->length--;
     r->readIndex = (r->readIndex + 1) % r->capacity;

src/ReadLine.c

@@ -116,7 +116,7 @@ static void unlock() {
 static void addLine() {
     addToHistory();
     lock();
-    coreQueueAddPointer(&buffer, &currentBuffer);
+    corePushQueueData(&buffer, &currentBuffer);
     unlock();
     clear();
 }
@@ -280,9 +280,9 @@ bool coreReadLine(char* buffer_, size_t n) {
         return false;
     }
     lock();
-    ConsoleLine* line = coreQueueGetVoidPointer(&buffer, 0);
+    ConsoleLine* line = coreGetQueueIndex(&buffer, 0);
     snprintf(buffer_, n, "%s", line->data);
-    coreQueueRemove(&buffer);
+    corePopQueueData(&buffer);
     unlock();
     return true;
 }

src/ToString.c

@@ -107,11 +107,10 @@ size_t coreToStringQueue(const CoreQueue* r, char* buffer, size_t n,
         end--;
         for(size_t i = 0; i < end; i++) {
             coreStringAdd(&w, &buffer, &n,
-                          c(coreQueueGetVoidPointer(r, i), buffer, n));
+                          c(coreGetQueueIndex(r, i), buffer, n));
             coreStringAdd(&w, &buffer, &n, coreToString(buffer, n, ", "));
         }
-        coreStringAdd(&w, &buffer, &n,
-                      c(coreQueueGetVoidPointer(r, end), buffer, n));
+        coreStringAdd(&w, &buffer, &n, c(coreGetQueueIndex(r, end), buffer, n));
     }
     coreStringAdd(&w, &buffer, &n, coreToString(buffer, n, "]"));
     return w;

test/modules/QueueTests.c

@@ -4,119 +4,118 @@
 #include "core/Utility.h"
 
 static void testReadAndWrite() {
-    CoreQueue r;
-    coreInitQueue(&r, 5, sizeof(size_t));
-    CORE_TEST_SIZE(0, r.length);
-    coreQueueAdd(&r, size_t, 4);
-    CORE_TEST_SIZE(1, r.length);
-    CORE_TEST_SIZE(4, coreQueueGet(&r, 0, size_t));
-    CORE_TEST_SIZE(4, coreQueueGetC(&r, 0, size_t));
-    coreQueueRemove(&r);
-    CORE_TEST_SIZE(0, r.length);
-    coreDestroyQueue(&r);
+    Queue r;
+    initQueue(&r, 5, sizeof(size_t));
+    TEST_SIZE(0, r.length);
+    pushQueueType(&r, size_t, 4);
+    TEST_SIZE(1, r.length);
+    TEST_SIZE(4, getTypedQueueIndex(&r, 0, size_t));
+    popQueueData(&r);
+    TEST_SIZE(0, r.length);
+    destroyQueue(&r);
 }
 
 static void testOverflow() {
-    CoreQueue r;
-    coreInitQueue(&r, 3, sizeof(size_t));
-    coreQueueAdd(&r, size_t, 1);
-    coreQueueAdd(&r, size_t, 2);
-    coreQueueAdd(&r, size_t, 3);
-    coreQueueAdd(&r, size_t, 4);
-    coreQueueAdd(&r, size_t, 5);
-    CORE_TEST_SIZE(3, r.length);
-    CORE_TEST_SIZE(1, coreQueueGet(&r, 0, size_t));
-    coreQueueRemove(&r);
-    CORE_TEST_SIZE(2, r.length);
-    CORE_TEST_SIZE(2, coreQueueGet(&r, 0, size_t));
-    coreQueueRemove(&r);
-    CORE_TEST_SIZE(1, r.length);
-    CORE_TEST_SIZE(3, coreQueueGet(&r, 0, size_t));
-    coreQueueRemove(&r);
-    CORE_TEST_SIZE(0, r.length);
-    coreDestroyQueue(&r);
+    Queue r;
+    initQueue(&r, 3, sizeof(size_t));
+    pushQueueType(&r, size_t, 1);
+    pushQueueType(&r, size_t, 2);
+    pushQueueType(&r, size_t, 3);
+    pushQueueType(&r, size_t, 4);
+    pushQueueType(&r, size_t, 5);
+    TEST_SIZE(3, r.length);
+    TEST_SIZE(1, getTypedQueueIndex(&r, 0, size_t));
+    popQueueData(&r);
+    TEST_SIZE(2, r.length);
+    TEST_SIZE(2, getTypedQueueIndex(&r, 0, size_t));
+    popQueueData(&r);
+    TEST_SIZE(1, r.length);
+    TEST_SIZE(3, getTypedQueueIndex(&r, 0, size_t));
+    popQueueData(&r);
+    TEST_SIZE(0, r.length);
+    destroyQueue(&r);
 }
 
 static void testRefill() {
-    CoreQueue r;
-    coreInitQueue(&r, 3, sizeof(size_t));
-    coreQueueAdd(&r, size_t, 1);
-    coreQueueAdd(&r, size_t, 2);
-    coreQueueAdd(&r, size_t, 3);
-    coreQueueAdd(&r, size_t, 4);
-    CORE_TEST_SIZE(3, r.length);
-    CORE_TEST_SIZE(1, coreQueueGet(&r, 0, size_t));
-    coreQueueRemove(&r);
-    CORE_TEST_SIZE(2, coreQueueGet(&r, 0, size_t));
-    coreQueueRemove(&r);
-    CORE_TEST_SIZE(3, coreQueueGet(&r, 0, size_t));
-    coreQueueRemove(&r);
-    CORE_TEST_SIZE(0, r.length);
-    coreQueueAdd(&r, size_t, 5);
-    coreQueueAdd(&r, size_t, 6);
-    CORE_TEST_SIZE(2, r.length);
-    CORE_TEST_SIZE(5, coreQueueGet(&r, 0, size_t));
-    coreQueueRemove(&r);
-    CORE_TEST_SIZE(6, coreQueueGet(&r, 0, size_t));
-    coreQueueRemove(&r);
-    CORE_TEST_SIZE(0, r.length);
-    coreDestroyQueue(&r);
+    Queue r;
+    initQueue(&r, 3, sizeof(size_t));
+    pushQueueType(&r, size_t, 1);
+    pushQueueType(&r, size_t, 2);
+    pushQueueType(&r, size_t, 3);
+    pushQueueType(&r, size_t, 4);
+    TEST_SIZE(3, r.length);
+    TEST_SIZE(1, getTypedQueueIndex(&r, 0, size_t));
+    popQueueData(&r);
+    TEST_SIZE(2, getTypedQueueIndex(&r, 0, size_t));
+    popQueueData(&r);
+    TEST_SIZE(3, getTypedQueueIndex(&r, 0, size_t));
+    popQueueData(&r);
+    TEST_SIZE(0, r.length);
+    pushQueueType(&r, size_t, 5);
+    pushQueueType(&r, size_t, 6);
+    TEST_SIZE(2, r.length);
+    TEST_SIZE(5, getTypedQueueIndex(&r, 0, size_t));
+    popQueueData(&r);
+    TEST_SIZE(6, getTypedQueueIndex(&r, 0, size_t));
+    popQueueData(&r);
+    TEST_SIZE(0, r.length);
+    destroyQueue(&r);
 }
 
 static void testClear() {
-    CoreQueue r;
-    coreInitQueue(&r, 3, sizeof(size_t));
-    coreQueueAdd(&r, size_t, 1);
-    coreQueueAdd(&r, size_t, 2);
-    CORE_TEST_SIZE(2, r.length);
-    coreClearQueue(&r);
-    CORE_TEST_SIZE(0, r.length);
-    coreDestroyQueue(&r);
+    Queue r;
+    initQueue(&r, 3, sizeof(size_t));
+    pushQueueType(&r, size_t, 1);
+    pushQueueType(&r, size_t, 2);
+    TEST_SIZE(2, r.length);
+    clearQueue(&r);
+    TEST_SIZE(0, r.length);
+    destroyQueue(&r);
 }
 
 static void testOverall() {
-    CoreQueue r;
-    coreInitQueue(&r, 3, sizeof(size_t));
-    coreQueueAdd(&r, size_t, 1);
-    coreQueueAdd(&r, size_t, 2);
-    coreQueueAdd(&r, size_t, 3);
+    Queue r;
+    initQueue(&r, 3, sizeof(size_t));
+    pushQueueType(&r, size_t, 1);
+    pushQueueType(&r, size_t, 2);
+    pushQueueType(&r, size_t, 3);
 
     char buffer[128];
-    coreToStringQueue(&r, buffer, sizeof(buffer), coreToStringSize);
-    CORE_TEST_STRING("[1, 2, 3]", buffer);
-    CORE_TEST_SIZE(3, r.length);
+    toString(&r, buffer, sizeof(buffer), toStringSize);
+    TEST_STRING("[1, 2, 3]", buffer);
+    TEST_SIZE(3, r.length);
 
-    coreQueueRemove(&r);
-    coreToStringQueue(&r, buffer, sizeof(buffer), coreToStringSize);
-    CORE_TEST_STRING("[2, 3]", buffer);
-    CORE_TEST_SIZE(2, r.length);
+    popQueueData(&r);
+    toString(&r, buffer, sizeof(buffer), toStringSize);
+    TEST_STRING("[2, 3]", buffer);
+    TEST_SIZE(2, r.length);
 
-    coreQueueAdd(&r, size_t, 4);
-    coreToStringQueue(&r, buffer, sizeof(buffer), coreToStringSize);
-    CORE_TEST_STRING("[2, 3, 4]", buffer);
-    CORE_TEST_SIZE(3, r.length);
+    pushQueueType(&r, size_t, 4);
+    toString(&r, buffer, sizeof(buffer), toStringSize);
+    TEST_STRING("[2, 3, 4]", buffer);
+    TEST_SIZE(3, r.length);
 
-    coreQueueRemove(&r);
-    coreToStringQueue(&r, buffer, sizeof(buffer), coreToStringSize);
-    CORE_TEST_STRING("[3, 4]", buffer);
-    CORE_TEST_SIZE(2, r.length);
+    popQueueData(&r);
+    toString(&r, buffer, sizeof(buffer), toStringSize);
+    TEST_STRING("[3, 4]", buffer);
+    TEST_SIZE(2, r.length);
 
-    coreQueueAdd(&r, size_t, 5);
-    coreToStringQueue(&r, buffer, sizeof(buffer), coreToStringSize);
-    CORE_TEST_STRING("[3, 4, 5]", buffer);
-    CORE_TEST_SIZE(3, r.length);
+    pushQueueType(&r, size_t, 5);
+    toString(&r, buffer, sizeof(buffer), toStringSize);
+    TEST_STRING("[3, 4, 5]", buffer);
+    TEST_SIZE(3, r.length);
 
-    coreQueueRemove(&r);
-    coreToStringQueue(&r, buffer, sizeof(buffer), coreToStringSize);
-    CORE_TEST_STRING("[4, 5]", buffer);
-    CORE_TEST_SIZE(2, r.length);
+    popQueueData(&r);
+    toString(&r, buffer, sizeof(buffer), toStringSize);
+    TEST_STRING("[4, 5]", buffer);
+    TEST_SIZE(2, r.length);
 
-    coreClearQueue(&r);
-    coreToStringQueue(&r, buffer, sizeof(buffer), coreToStringSize);
-    CORE_TEST_STRING("[]", buffer);
-    CORE_TEST_SIZE(0, r.length);
+    clearQueue(&r);
+    toString(&r, buffer, sizeof(buffer), toStringSize);
+    TEST_STRING("[]", buffer);
+    TEST_SIZE(0, r.length);
 
-    coreDestroyQueue(&r);
+    destroyQueue(&r);
 }
 
 void testQueue() {