chore: new formatting for pointers and references

include/pauldb/storage.h

@@ -13,47 +13,47 @@ extern "C"
     /* --- Page Management --- */
     typedef struct Page Page;
 
-    Page *
+    Page*
     page_create(uint32_t page_id);
 
     int
-    page_insert(Page * p, const void * data, size_t len);
+    page_insert(Page* p, const void* data, size_t len);
 
-    void *
+    void*
-    page_get(Page * p, uint16_t slot_id, size_t * out_len);
+    page_get(Page* p, uint16_t slot_id, size_t* out_len);
 
     void
-    page_free(Page * p);
+    page_free(Page* p);
 
     /* --- Heap (Multi-Page Row Store / Delta) --- */
     typedef struct Heap Heap;
 
-    Heap *
+    Heap*
     heap_create(void);
 
     int
-    heap_insert(Heap * h, const void * data, size_t len);
+    heap_insert(Heap* h, const void* data, size_t len);
 
     void
-    heap_full_scan(Heap * h, void (*callback)(const void *, size_t));
+    heap_full_scan(Heap* h, void (*callback)(const void*, size_t));
 
     void
-    heap_free(Heap * h);
+    heap_free(Heap* h);
 
     /* --- B+Tree Index --- */
     typedef struct BTree BTree;
 
-    BTree *
+    BTree*
     btree_create(void);
 
     int
-    btree_insert(BTree * bt, int64_t key, uint32_t page_id, uint16_t slot_id);
+    btree_insert(BTree* bt, int64_t key, uint32_t page_id, uint16_t slot_id);
 
     int
-    btree_lookup(BTree * bt, int64_t key, uint32_t * out_page, uint16_t * out_slot);
+    btree_lookup(BTree* bt, int64_t key, uint32_t* out_page, uint16_t* out_slot);
 
     void
-    btree_free(BTree * bt);
+    btree_free(BTree* bt);
 
 #ifdef __cplusplus
 }

src/storage/page.c

@@ -45,23 +45,23 @@ struct Page
 
 /* ---- Hilfsfunktionen ---- */
 
-static PageHeader *
+static PageHeader*
-header(Page * p)
+header(Page* p)
 {
-    return (PageHeader *) p->raw;
+    return (PageHeader*) p->raw;
 }
 
 /* ---- API ---- */
 
-Page *
+Page*
 page_create(uint32_t page_id)
 {
-    Page * p = malloc(sizeof(Page));
+    Page* p = malloc(sizeof(Page));
     if (!p) return NULL;
 
     memset(p->raw, 0, PAGE_SIZE);
 
-    PageHeader * h = header(p);
+    PageHeader* h = header(p);
     h->page_id = page_id;
     h->num_slots = 0;
     h->free_space_offset = PAGE_SIZE;
@@ -70,16 +70,16 @@ page_create(uint32_t page_id)
 }
 
 void
-page_free(Page * p)
+page_free(Page* p)
 {
     free(p);
 }
 
 /* page_insert und page_get folgen im naechsten TDD-Zyklus */
 int
-page_insert(Page * p, const void * data, size_t len)
+page_insert(Page* p, const void* data, size_t len)
 {
-    PageHeader * h = header(p);
+    PageHeader* h = header(p);
 
     /* Wo endet der letzte Slot? */
     size_t slots_end = sizeof(PageHeader) + ((h->num_slots + 1) * sizeof(Slot));
@@ -92,7 +92,7 @@ page_insert(Page * p, const void * data, size_t len)
     memcpy(p->raw + h->free_space_offset, data, len);
 
     /* Neuen Slot anlegen */
-    Slot * s = (Slot *) (p->raw + sizeof(PageHeader)) + h->num_slots;
+    Slot* s = (Slot*) (p->raw + sizeof(PageHeader)) + h->num_slots;
     s->offset = h->free_space_offset;
     s->length = (uint16_t) len;
 
@@ -103,14 +103,14 @@ page_insert(Page * p, const void * data, size_t len)
     return (int) slot_id;
 }
 
-void *
+void*
-page_get(Page * p, uint16_t slot_id, size_t * out_len)
+page_get(Page* p, uint16_t slot_id, size_t* out_len)
 {
-    PageHeader * h = header(p);
+    PageHeader* h = header(p);
 
     if (slot_id >= h->num_slots) return NULL; /* Slot existiert nicht */
 
-    Slot * s = (Slot *) (p->raw + sizeof(PageHeader)) + slot_id;
+    Slot* s = (Slot*) (p->raw + sizeof(PageHeader)) + slot_id;
 
     if (out_len) *out_len = s->length;
 

test/storage/test_page.c

@@ -13,7 +13,7 @@
 static void
 test_create_returns_non_null(void)
 {
-    Page * p = page_create(42);
+    Page* p = page_create(42);
     assert(p != NULL);
     page_free(p);
     printf("  OK: page_create(42) returns non-NULL\n");
@@ -22,7 +22,7 @@ test_create_returns_non_null(void)
 static void
 test_insert_returns_slot_id(void)
 {
-    Page * p = page_create(4);
+    Page* p = page_create(4);
     int slot_id = page_insert(p, "Hallo", 5);
     assert(slot_id == 0);
     page_free(p);
@@ -32,13 +32,13 @@ test_insert_returns_slot_id(void)
 static void
 test_insert_and_get(void)
 {
-    Page * p = page_create(1);
+    Page* p = page_create(1);
 
     int slot = page_insert(p, "ABAP", 4);
     assert(slot == 0);
 
     size_t len = 0;
-    void * result = page_get(p, 0, &len);
+    void* result = page_get(p, 0, &len);
     assert(result != NULL);
     assert(len == 4);
     assert(memcmp(result, "ABAP", 4) == 0);
@@ -50,7 +50,7 @@ test_insert_and_get(void)
 static void
 test_multiple_inserts(void)
 {
-    Page * p = page_create(2);
+    Page* p = page_create(2);
 
     assert(page_insert(p, "ABAP", 4) == 0);
     assert(page_insert(p, "HANA", 4) == 1);
@@ -68,7 +68,7 @@ test_multiple_inserts(void)
 static void
 test_invalid_slot_returns_null(void)
 {
-    Page * p = page_create(3);
+    Page* p = page_create(3);
     assert(page_get(p, 99, NULL) == NULL);
     page_free(p);
     printf("  OK: invalid slot returns NULL\n");