Remove _t suffix from all custom types (reserved for POSIX)

Author: cm-jones

README.md

@@ -9,24 +9,26 @@
 [![Codecov](https://codecov.io/gh/cm-jones/libdsc/branch/main/graph/badge.svg)](https://codecov.io/gh/cm-jones/libdsc)
 [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
 
-libdsc is an open-source C library that features generic implementations of several C++ Standard Library containers.
+`libdsc` is an open-source C library featuring generic and memory-safe implementations of various containers provided by the C++ Standard Library.
 
 ## Features
 
-- **Vector**: Dynamically-sized array
-- **Forward List**: Singly-linked list
-- **List**: Doubly-linked list
-- **Stack**: LIFO container
-- **Queue**: FIFO container
-- **Unordered Map**: Hash table for key-value pairs
-- **Unordered Set**: Hash table for unique elements
+`libdsc` implements the following containers:
 
-All of these implementations are:
+- `vector`: dynamically-sized array
+- `forward_list`: singly-linked list
+- `list`: doubly-linked list
+- `stack`: LIFO container
+- `queue`: FIFO container
+- `unordered_map`: hash table for key-value pairs
+- `unordered_set`: hash table for unique elements
+
+All containers are:
 
 - Generic (can store any data type)
 - Memory safe (with proper error handling)
 - Thoroughly tested
-- Performance benchmarked against C++ counterparts
+- Benchmarked against C++ Standard Library counterparts
 
 ## Installing from source
 
@@ -57,11 +59,13 @@ This will install:
 #include <libdsc/vector.h>
 #include <libdsc/list.h>
 
+// Include other containers as needed ...
+
 #include <stdio.h>
 
 int main() {
     // Create a vector of integers
-    dsc_vector_t *vec = vector_create(sizeof(int));
+    dsc_vector *vec = vector_create(sizeof(int));
 
     // Push some values
     for (size_t i = 0; i < 5; ++i) {
@@ -78,7 +82,7 @@ int main() {
     vector_destroy(vec);
 
     // Create a list of integers
-    dsc_list_t *list = list_create(sizeof(int));
+    dsc_list *list = list_create(sizeof(int));
 
     // Push some values
     for (size_t i = 0; i < 5; ++i) {
@@ -96,15 +100,15 @@ int main() {
     // Clean up
     list_destroy(list);
 
-    return 0;
+    return EXIT_SUCCESS;
 }
 ```
 
 More examples can be found in the `examples` directory.
 
 ## Testing
 
-libdsc uses Google Test for unit testing. To run the tests:
+Google Test is used for unit testing. To run the tests, after building the project:
 
 ```bash
 cd build
@@ -113,7 +117,7 @@ ctest --output-on-failure
 
 ## Benchmarking
 
-Google Benchmark is used for benchmarking libdsc containers against the equivalent containers in the C++ Standard Library. Benchmarks are run weekly and can be found in the [Actions tab](https://github.com/cm-jones/libdsc/actions/workflows/benchmark.yaml) under the Benchmarks workflow. You can also run benchmarks locally:
+Google Benchmark is used to measure the performance of libdsc's containers against their equivalents in the C++ Standard Library. Benchmarks are run weekly automatically via GitHub Actions.  You can also run the benchmarks locally:
 
 ```bash
 mkdir -p build
@@ -126,8 +130,8 @@ cd benchmarks
 
 ## Contributing
 
-See [CONTRIBUTING.md](CONTRIBUTING.md).
+Please read [CONTRIBUTING.md](CONTRIBUTING.md) carefully before you attempt to make contributions to this project.
 
 ## License
 
-This project is licensed under the GPLv3. See [LICENSE](LICENSE) for details.
+`libdsc` is licensed under the GPLv3. See [LICENSE](LICENSE) for details.

benchmarks/benchmark_forward_list.cpp

@@ -6,7 +6,7 @@
 
 // Benchmark push_front
 static void BM_ForwardListPushFront(benchmark::State &state) {
-    dsc_forward_list_t *list = forward_list_create(sizeof(int));
+    dsc_forward_list *list = forward_list_create(sizeof(int));
 
     for (auto _ : state) {
         int value = 42;
@@ -30,7 +30,7 @@ BENCHMARK(BM_StdForwardListPushFront)->Range(1, 1 << 20);
 
 // Benchmark push_front and pop_front
 static void BM_ForwardListPushPopFront(benchmark::State &state) {
-    dsc_forward_list_t *list = forward_list_create(sizeof(int));
+    dsc_forward_list *list = forward_list_create(sizeof(int));
 
     for (auto _ : state) {
         int value = 42;
@@ -55,7 +55,7 @@ BENCHMARK(BM_StdForwardListPushPopFront)->Range(1, 1 << 20);
 
 // Benchmark front access
 static void BM_ForwardListFront(benchmark::State &state) {
-    dsc_forward_list_t *list = forward_list_create(sizeof(int));
+    dsc_forward_list *list = forward_list_create(sizeof(int));
     int value = 42;
     forward_list_push_front(list, &value);
 
@@ -80,7 +80,7 @@ BENCHMARK(BM_StdForwardListFront)->Range(1 << 10, 1 << 20);
 
 // Benchmark insert_after
 static void BM_ForwardListInsertAfter(benchmark::State &state) {
-    dsc_forward_list_t *list = forward_list_create(sizeof(int));
+    dsc_forward_list *list = forward_list_create(sizeof(int));
     int value = 42;
     forward_list_push_front(list, &value);
     forward_list_node_t *pos = forward_list_begin(list);
@@ -108,7 +108,7 @@ BENCHMARK(BM_StdForwardListInsertAfter)->Range(1, 1 << 20);
 
 // Benchmark size operation
 static void BM_ForwardListSize(benchmark::State &state) {
-    dsc_forward_list_t *list = forward_list_create(sizeof(int));
+    dsc_forward_list *list = forward_list_create(sizeof(int));
     int value = 42;
     for (size_t i = 0; i < 1000; ++i) {
         forward_list_push_front(list, &value);
@@ -138,7 +138,7 @@ BENCHMARK(BM_StdForwardListSize)->Range(1 << 10, 1 << 20);
 
 // Benchmark empty check
 static void BM_ForwardListEmpty(benchmark::State &state) {
-    dsc_forward_list_t *list = forward_list_create(sizeof(int));
+    dsc_forward_list *list = forward_list_create(sizeof(int));
 
     for (auto _ : state) {
         benchmark::DoNotOptimize(forward_list_empty(list));
@@ -160,7 +160,7 @@ BENCHMARK(BM_StdForwardListEmpty)->Range(1 << 10, 1 << 20);
 
 // Benchmark erase_after operation
 static void BM_ForwardListEraseAfter(benchmark::State &state) {
-    dsc_forward_list_t *list = forward_list_create(sizeof(int));
+    dsc_forward_list *list = forward_list_create(sizeof(int));
     int value = 42;
     forward_list_push_front(list, &value);
     forward_list_node_t *pos = forward_list_begin(list);
@@ -195,7 +195,7 @@ BENCHMARK(BM_StdForwardListEraseAfter)->Range(1 << 10, 1 << 20);
 
 // Benchmark clear operation
 static void BM_ForwardListClear(benchmark::State &state) {
-    dsc_forward_list_t *list = forward_list_create(sizeof(int));
+    dsc_forward_list *list = forward_list_create(sizeof(int));
     int value = 42;
 
     for (auto _ : state) {
@@ -232,7 +232,7 @@ BENCHMARK(BM_StdForwardListClear)->Range(1 << 10, 1 << 20);
 
 // Benchmark iterator operations (begin/end traversal)
 static void BM_ForwardListTraversal(benchmark::State &state) {
-    dsc_forward_list_t *list = forward_list_create(sizeof(int));
+    dsc_forward_list *list = forward_list_create(sizeof(int));
     int value = 42;
     for (size_t i = 0; i < 1000; ++i) {
         forward_list_push_front(list, &value);

benchmarks/benchmark_list.cpp

@@ -6,7 +6,7 @@
 
 // Benchmark push_front
 static void BM_ListPushFront(benchmark::State &state) {
-    dsc_list_t *list = list_create(sizeof(int));
+    dsc_list *list = list_create(sizeof(int));
 
     for (auto _ : state) {
         int value = 42;
@@ -30,7 +30,7 @@ BENCHMARK(BM_StdListPushFront)->Range(1, 1 << 20);
 
 // Benchmark push_back
 static void BM_ListPushBack(benchmark::State &state) {
-    dsc_list_t *list = list_create(sizeof(int));
+    dsc_list *list = list_create(sizeof(int));
 
     for (auto _ : state) {
         int value = 42;
@@ -54,7 +54,7 @@ BENCHMARK(BM_StdListPushBack)->Range(1, 1 << 20);
 
 // Benchmark push_front and pop_front
 static void BM_ListPushPopFront(benchmark::State &state) {
-    dsc_list_t *list = list_create(sizeof(int));
+    dsc_list *list = list_create(sizeof(int));
 
     for (auto _ : state) {
         int value = 42;
@@ -79,7 +79,7 @@ BENCHMARK(BM_StdListPushPopFront)->Range(1, 1 << 20);
 
 // Benchmark push_back and pop_back
 static void BM_ListPushPopBack(benchmark::State &state) {
-    dsc_list_t *list = list_create(sizeof(int));
+    dsc_list *list = list_create(sizeof(int));
 
     for (auto _ : state) {
         int value = 42;
@@ -104,7 +104,7 @@ BENCHMARK(BM_StdListPushPopBack)->Range(1, 1 << 20);
 
 // Benchmark front access
 static void BM_ListFront(benchmark::State &state) {
-    dsc_list_t *list = list_create(sizeof(int));
+    dsc_list *list = list_create(sizeof(int));
     int value = 42;
     list_push_front(list, &value);
 
@@ -129,7 +129,7 @@ BENCHMARK(BM_StdListFront)->Range(1 << 10, 1 << 20);
 
 // Benchmark back access
 static void BM_ListBack(benchmark::State &state) {
-    dsc_list_t *list = list_create(sizeof(int));
+    dsc_list *list = list_create(sizeof(int));
     int value = 42;
     list_push_back(list, &value);
 
@@ -154,7 +154,7 @@ BENCHMARK(BM_StdListBack)->Range(1 << 10, 1 << 20);
 
 // Benchmark size operation
 static void BM_ListSize(benchmark::State &state) {
-    dsc_list_t *list = list_create(sizeof(int));
+    dsc_list *list = list_create(sizeof(int));
     int value = 42;
     for (size_t i = 0; i < 1000; ++i) {
         list_push_front(list, &value);
@@ -183,7 +183,7 @@ BENCHMARK(BM_StdListSize)->Range(1 << 10, 1 << 20);
 
 // Benchmark empty check
 static void BM_ListEmpty(benchmark::State &state) {
-    dsc_list_t *list = list_create(sizeof(int));
+    dsc_list *list = list_create(sizeof(int));
 
     for (auto _ : state) {
         benchmark::DoNotOptimize(list_empty(list));
@@ -205,7 +205,7 @@ BENCHMARK(BM_StdListEmpty)->Range(1 << 10, 1 << 20);
 
 // Benchmark insert operation
 static void BM_ListInsert(benchmark::State &state) {
-    dsc_list_t *list = list_create(sizeof(int));
+    dsc_list *list = list_create(sizeof(int));
     int value = 42;
 
     for (auto _ : state) {
@@ -240,7 +240,7 @@ BENCHMARK(BM_StdListInsert)->Range(1 << 10, 1 << 20);
 
 // Benchmark erase operation
 static void BM_ListErase(benchmark::State &state) {
-    dsc_list_t *list = list_create(sizeof(int));
+    dsc_list *list = list_create(sizeof(int));
     int value = 42;
     list_push_back(list, &value);
     list_push_back(list, &value);
@@ -276,7 +276,7 @@ BENCHMARK(BM_StdListErase)->Range(1 << 10, 1 << 20);
 
 // Benchmark clear operation
 static void BM_ListClear(benchmark::State &state) {
-    dsc_list_t *list = list_create(sizeof(int));
+    dsc_list *list = list_create(sizeof(int));
     int value = 42;
 
     for (auto _ : state) {
@@ -313,7 +313,7 @@ BENCHMARK(BM_StdListClear)->Range(1 << 10, 1 << 20);
 
 // Benchmark forward iterator traversal
 static void BM_ListForwardTraversal(benchmark::State &state) {
-    dsc_list_t *list = list_create(sizeof(int));
+    dsc_list *list = list_create(sizeof(int));
     int value = 42;
     for (size_t i = 0; i < 1000; ++i) {
         list_push_back(list, &value);
@@ -348,7 +348,7 @@ BENCHMARK(BM_StdListForwardTraversal)->Range(1 << 10, 1 << 20);
 
 // Benchmark reverse iterator traversal
 static void BM_ListReverseTraversal(benchmark::State &state) {
-    dsc_list_t *list = list_create(sizeof(int));
+    dsc_list *list = list_create(sizeof(int));
     int value = 42;
     for (size_t i = 0; i < 1000; ++i) {
         list_push_back(list, &value);