Call UUID lambdas

This reverts commit 1cdb08a81a.

.gitea/workflows/release.yml

@@ -0,0 +1,81 @@
+name: Release
+
+on:
+  push:
+    branches:
+      - main  # or your default branch
+
+jobs:
+  release:
+    runs-on: self-hosted
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+            fetch-depth: 0   # fetch full history
+            tags: true       # fetch all tags
+
+      - name: Check/Create Tag
+        id: tag
+        run: |
+          VERSION=$(cat VERSION | tr -d '[:space:]')  # read version and trim whitespace
+          echo "Version: $VERSION"
+
+          if git rev-parse "v$VERSION" >/dev/null 2>&1; then
+            echo "Tag v$VERSION already exists. Skipping release."
+            exit 0
+          fi
+
+          # Tag does not exist → create it
+          echo "Creating tag v$VERSION"
+          git tag "v$VERSION"
+          git push origin "v$VERSION"
+
+          echo "version=$VERSION" >> $GITHUB_OUTPUT
+
+      - name: Build Artifacts
+        if: steps.tag.outputs.version
+        run: |
+          chmod +x ./package
+          ./package
+          ls -l dist/
+
+      - name: Create Release
+        if: steps.tag.outputs.version
+        id: create_release
+        run: |
+          VERSION="${{ steps.tag.outputs.version }}"
+          RESPONSE=$(curl -s -X POST \
+            -H "Authorization: token ${{ secrets.GITEA_TOKEN }}" \
+            -H "Content-Type: application/json" \
+            "https://git.thewizardapprentice.com/api/v1/repos/${{ gitea.repository }}/releases" \
+            -d '{
+              "tag_name": "v'"$VERSION"'",
+              "name": "wapp-v'"$VERSION"'",
+              "body": "Automated release for wapp-v'"$VERSION"'",
+              "draft": false,
+              "prerelease": false
+            }')
+
+          echo "$RESPONSE"
+          RELEASE_ID=$(echo $RESPONSE | jq -r '.id')
+          echo "release_id=$RELEASE_ID" >> $GITHUB_OUTPUT
+
+      - name: Upload Artifacts
+        if: steps.tag.outputs.version
+        run: |
+          RELEASE_ID="${{ steps.create_release.outputs.release_id }}"
+          for FILE in dist/*; do
+            FILENAME=$(basename "$FILE")
+            echo "Uploading $FILENAME"
+            curl -X POST \
+              -H "Authorization: token ${{ secrets.GITEA_TOKEN }}" \
+              -H "Content-Type: application/octet-stream" \
+              --data-binary @"$FILE" \
+              "https://git.thewizardapprentice.com/api/v1/repos/${{ gitea.repository }}/releases/$RELEASE_ID/assets?name=$FILENAME"
+          done
+
+      - name: Cleanup
+        if: steps.tag.outputs.version
+        run: rm -rf dist/*

LICENSE

@@ -0,0 +1,201 @@
+                             Apache License
+                       Version 2.0, January 2004
+                    http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+  "License" shall mean the terms and conditions for use, reproduction,
+  and distribution as defined by Sections 1 through 9 of this document.
+
+  "Licensor" shall mean the copyright owner or entity authorized by
+  the copyright owner that is granting the License.
+
+  "Legal Entity" shall mean the union of the acting entity and all
+  other entities that control, are controlled by, or are under common
+  control with that entity. For the purposes of this definition,
+  "control" means (i) the power, direct or indirect, to cause the
+  direction or management of such entity, whether by contract or
+  otherwise, or (ii) ownership of fifty percent (50%) or more of the
+  outstanding shares, or (iii) beneficial ownership of such entity.
+
+  "You" (or "Your") shall mean an individual or Legal Entity
+  exercising permissions granted by this License.
+
+  "Source" form shall mean the preferred form for making modifications,
+  including but not limited to software source code, documentation
+  source, and configuration files.
+
+  "Object" form shall mean any form resulting from mechanical
+  transformation or translation of a Source form, including but
+  not limited to compiled object code, generated documentation,
+  and conversions to other media types.
+
+  "Work" shall mean the work of authorship, whether in Source or
+  Object form, made available under the License, as indicated by a
+  copyright notice that is included in or attached to the work
+  (an example is provided in the Appendix below).
+
+  "Derivative Works" shall mean any work, whether in Source or Object
+  form, that is based on (or derived from) the Work and for which the
+  editorial revisions, annotations, elaborations, or other modifications
+  represent, as a whole, an original work of authorship. For the purposes
+  of this License, Derivative Works shall not include works that remain
+  separable from, or merely link (or bind by name) to the interfaces of,
+  the Work and Derivative Works thereof.
+
+  "Contribution" shall mean any work of authorship, including
+  the original version of the Work and any modifications or additions
+  to that Work or Derivative Works thereof, that is intentionally
+  submitted to Licensor for inclusion in the Work by the copyright owner
+  or by an individual or Legal Entity authorized to submit on behalf of
+  the copyright owner. For the purposes of this definition, "submitted"
+  means any form of electronic, verbal, or written communication sent
+  to the Licensor or its representatives, including but not limited to
+  communication on electronic mailing lists, source code control systems,
+  and issue tracking systems that are managed by, or on behalf of, the
+  Licensor for the purpose of discussing and improving the Work, but
+  excluding communication that is conspicuously marked or otherwise
+  designated in writing by the copyright owner as "Not a Contribution."
+
+  "Contributor" shall mean Licensor and any individual or Legal Entity
+  on behalf of whom a Contribution has been received by Licensor and
+  subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+  this License, each Contributor hereby grants to You a perpetual,
+  worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+  copyright license to reproduce, prepare Derivative Works of,
+  publicly display, publicly perform, sublicense, and distribute the
+  Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+  this License, each Contributor hereby grants to You a perpetual,
+  worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+  (except as stated in this section) patent license to make, have made,
+  use, offer to sell, sell, import, and otherwise transfer the Work,
+  where such license applies only to those patent claims licensable
+  by such Contributor that are necessarily infringed by their
+  Contribution(s) alone or by combination of their Contribution(s)
+  with the Work to which such Contribution(s) was submitted. If You
+  institute patent litigation against any entity (including a
+  cross-claim or counterclaim in a lawsuit) alleging that the Work
+  or a Contribution incorporated within the Work constitutes direct
+  or contributory patent infringement, then any patent licenses
+  granted to You under this License for that Work shall terminate
+  as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+  Work or Derivative Works thereof in any medium, with or without
+  modifications, and in Source or Object form, provided that You
+  meet the following conditions:
+
+  (a) You must give any other recipients of the Work or
+      Derivative Works a copy of this License; and
+
+  (b) You must cause any modified files to carry prominent notices
+      stating that You changed the files; and
+
+  (c) You must retain, in the Source form of any Derivative Works
+      that You distribute, all copyright, patent, trademark, and
+      attribution notices from the Source form of the Work,
+      excluding those notices that do not pertain to any part of
+      the Derivative Works; and
+
+  (d) If the Work includes a "NOTICE" text file as part of its
+      distribution, then any Derivative Works that You distribute must
+      include a readable copy of the attribution notices contained
+      within such NOTICE file, excluding those notices that do not
+      pertain to any part of the Derivative Works, in at least one
+      of the following places: within a NOTICE text file distributed
+      as part of the Derivative Works; within the Source form or
+      documentation, if provided along with the Derivative Works; or,
+      within a display generated by the Derivative Works, if and
+      wherever such third-party notices normally appear. The contents
+      of the NOTICE file are for informational purposes only and
+      do not modify the License. You may add Your own attribution
+      notices within Derivative Works that You distribute, alongside
+      or as an addendum to the NOTICE text from the Work, provided
+      that such additional attribution notices cannot be construed
+      as modifying the License.
+
+  You may add Your own copyright statement to Your modifications and
+  may provide additional or different license terms and conditions
+  for use, reproduction, or distribution of Your modifications, or
+  for any such Derivative Works as a whole, provided Your use,
+  reproduction, and distribution of the Work otherwise complies with
+  the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+  any Contribution intentionally submitted for inclusion in the Work
+  by You to the Licensor shall be under the terms and conditions of
+  this License, without any additional terms or conditions.
+  Notwithstanding the above, nothing herein shall supersede or modify
+  the terms of any separate license agreement you may have executed
+  with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+  names, trademarks, service marks, or product names of the Licensor,
+  except as required for reasonable and customary use in describing the
+  origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+  agreed to in writing, Licensor provides the Work (and each
+  Contributor provides its Contributions) on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied, including, without limitation, any warranties or conditions
+  of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+  PARTICULAR PURPOSE. You are solely responsible for determining the
+  appropriateness of using or redistributing the Work and assume any
+  risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+  whether in tort (including negligence), contract, or otherwise,
+  unless required by applicable law (such as deliberate and grossly
+  negligent acts) or agreed to in writing, shall any Contributor be
+  liable to You for damages, including any direct, indirect, special,
+  incidental, or consequential damages of any character arising as a
+  result of this License or out of the use or inability to use the
+  Work (including but not limited to damages for loss of goodwill,
+  work stoppage, computer failure or malfunction, or any and all
+  other commercial damages or losses), even if such Contributor
+  has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+  the Work or Derivative Works thereof, You may choose to offer,
+  and charge a fee for, acceptance of support, warranty, indemnity,
+  or other liability obligations and/or rights consistent with this
+  License. However, in accepting such obligations, You may act only
+  on Your own behalf and on Your sole responsibility, not on behalf
+  of any other Contributor, and only if You agree to indemnify,
+  defend, and hold each Contributor harmless for any liability
+  incurred by, or claims asserted against, such Contributor by reason
+  of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+  To apply the Apache License to your work, attach the following
+  boilerplate notice, with the fields enclosed by brackets "[]"
+  replaced with your own identifying information. (Don't include
+  the brackets!)  The text should be enclosed in the appropriate
+  comment syntax for the file format. We also recommend that a
+  file or class name and description of purpose be included on the
+  same "printed page" as the copyright notice for easier
+  identification within third-party archives.
+
+Copyright [2026] [Abdelrahman Said]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

Makefile

@@ -10,7 +10,7 @@ INSTALL_PREFIX = dist
 RUNTIME_ASSERT = true
 
 # Internal variables
-override CFLAGS              = -Wall -Wextra -Werror -pedantic -Isrc -D_LARGEFILE64_SOURCE
+override CFLAGS              = -Wall -Wextra -Werror -pedantic -Isrc
 override LIBFLAGS            = -fPIC
 override CSTD               := -std=gnu11
 override CXXSTD             := -std=gnu++11
@@ -46,7 +46,7 @@ endif
 
 # Disable runtime asserts
 ifeq ($(RUNTIME_ASSERT), false)
-	override BUILD_FLAGS += WAPP_NO_RUNTIME_ASSERT
+	override BUILD_FLAGS += -DWAPP_NO_RUNTIME_ASSERT
 endif
 
 ifeq ($(CC),gcc)

README.md

@@ -1,3 +1,5 @@
 # Wizard Apprentice Standard Library
 
-A group of utilities for C/C++ projects
+**Wizard Apprentice Standard Library** (`wapp`) is a lightweight collection of reusable utilities for **C and C++** projects.
+
+For more information about the library and how to use it, check the [wiki](https://git.thewizardapprentice.com/abdelrahman/wizapp-stdlib/wiki).

VERSION

@@ -0,0 +1 @@
+1.0.3

package

@@ -0,0 +1,11 @@
+#!/bin/bash
+
+cp -r src wapp
+
+mkdir -p dist
+
+ARCHIVE_NAME="wapp-v$(cat VERSION)"
+tar -czvf dist/$ARCHIVE_NAME.tar.gz wapp
+zip -r dist/$ARCHIVE_NAME.zip wapp
+
+rm -rf wapp

src/base/array/array.c

@@ -105,7 +105,7 @@ void _array_copy_capped(GenericArray dst, const GenericArray src, u64 item_size)
 }
 
 GenericArray _array_append_alloc(const Allocator *allocator, GenericArray array, void *value,
-                                 u64 item_size, ArrayInitFlags flags) {
+                                 ArrayInitFlags flags, u64 item_size) {
 	wapp_runtime_assert(allocator != NULL && array != NULL, "`allocator` and `array` should not be NULL");
 	_array_validate(array, item_size);
 
@@ -114,8 +114,8 @@ GenericArray _array_append_alloc(const Allocator *allocator, GenericArray array,
 	ArrayHeader *header = _array_header(array);
 	if (header->count >= header->capacity) {
 		u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(header->capacity * 2);
-		output           = (GenericArray )_array_alloc_capacity(allocator, new_capacity, header->item_size,
+		output           = (GenericArray )_array_alloc_capacity(allocator, new_capacity, flags,
-		                                                        flags);
+		                                                        header->item_size);
 		if (!output) {
 			output = array;
 			goto RETURN_ARRAY_APPEND_ALLOC;
@@ -134,7 +134,7 @@ RETURN_ARRAY_APPEND_ALLOC:
 }
 
 GenericArray _array_extend_alloc(const Allocator *allocator, GenericArray dst, const GenericArray src,
-                                 u64 item_size, ArrayInitFlags flags) {
+                                 ArrayInitFlags flags, u64 item_size) {
 	wapp_runtime_assert(allocator != NULL && dst != NULL && src != NULL, "`allocator`, `dst` and `src` should not be NULL");
 	_array_validate(dst, item_size);
 	_array_validate(src, item_size);
@@ -147,7 +147,7 @@ GenericArray _array_extend_alloc(const Allocator *allocator, GenericArray dst, c
 	if (src_header->count >= remaining_capacity) {
 		u64 new_capacity  = wapp_misc_utils_u64_round_up_pow2(dst_header->capacity * 2);
 		output            = (GenericArray )_array_alloc_capacity(allocator, new_capacity,
-		                                                         dst_header->item_size, flags);
+		                                                         flags, dst_header->item_size);
 		if (!output) {
 			output = dst;
 			goto RETURN_ARRAY_EXTEND_ALLOC;
@@ -166,7 +166,7 @@ RETURN_ARRAY_EXTEND_ALLOC:
 }
 
 GenericArray _array_copy_alloc(const Allocator *allocator, GenericArray dst, const GenericArray src,
-                               u64 item_size, ArrayInitFlags flags) {
+                               ArrayInitFlags flags, u64 item_size) {
 	wapp_runtime_assert(allocator != NULL && dst != NULL && src != NULL, "`allocator`, `dst` and `src` should not be NULL");
 	_array_validate(dst, item_size);
 	_array_validate(src, item_size);
@@ -178,7 +178,7 @@ GenericArray _array_copy_alloc(const Allocator *allocator, GenericArray dst, con
 	if (src_header->count >= dst_header->capacity) {
 		u64 new_capacity  = wapp_misc_utils_u64_round_up_pow2(dst_header->capacity * 2);
 		output            = (GenericArray )_array_alloc_capacity(allocator, new_capacity,
-		                                                         src_header->item_size, flags);
+		                                                         flags, src_header->item_size);
 		if (!output) {
 			output = dst;
 			goto RETURN_ARRAY_COPY_ALLOC;
@@ -220,28 +220,45 @@ u64 _array_calc_alloc_size(u64 capacity, u64 item_size) {
 	return sizeof(ArrayHeader) + item_size * capacity;
 }
 
-GenericArray _array_alloc_capacity(const Allocator *allocator, u64 capacity, u64 item_size,
+GenericArray _array_alloc_capacity(const Allocator *allocator, u64 capacity, ArrayInitFlags flags,
-                                   ArrayInitFlags flags) {
+                                   u64 item_size) {
 	wapp_runtime_assert(allocator != NULL, "`allocator` should not be NULL");
 
 	GenericArray output = NULL;
 
 	u64 allocation_size = _array_calc_alloc_size(capacity, item_size);
-	ArrayHeader *header = wapp_mem_allocator_alloc(allocator, allocation_size);
+	void *buffer        = wapp_mem_allocator_alloc(allocator, allocation_size);
-	if (!header) {
+	if (!buffer) {
 		goto RETURN_ARRAY_ALLOC;
 	}
 
-	output            = (u8 *)(header + 1);
+	output = _array_from_preallocated_buffer(buffer, allocation_size, flags, item_size);
-	header->magic     = WAPP_ARRAY_MAGIC;
-	header->count     = flags & ARRAY_INIT_FILLED ? capacity : 0;
-	header->capacity  = capacity;
-	header->item_size = item_size;
 
 RETURN_ARRAY_ALLOC:
 	return output;
 }
 
+
+GenericArray _array_from_preallocated_buffer(void *buffer, u64 buffer_size, ArrayInitFlags flags,
+                                             u64 item_size) {
+	wapp_runtime_assert(buffer != NULL, "`buffer` should not be NULL");
+
+	i64 data_buffer_size = (i64)buffer_size - (i64)(sizeof(ArrayHeader));
+	if (data_buffer_size <= 0) {
+		return NULL;
+	}
+
+	u64 item_capacity   = (u64)data_buffer_size / item_size;
+	ArrayHeader *header = (ArrayHeader *)buffer;
+	GenericArray output = (u8 *)(header + 1);
+	header->magic       = WAPP_ARRAY_MAGIC;
+	header->count       = flags & ARRAY_INIT_FILLED ? item_capacity : 0;
+	header->capacity    = item_capacity;
+	header->item_size   = item_size;
+
+	return output;
+}
+
 wapp_persist inline void _array_validate(const GenericArray array, u64 item_size) {
 	ArrayHeader *header = _array_header(array);
 	wapp_runtime_assert(WAPP_ARRAY_MAGIC == header->magic, "`array` is not a valid wapp array");

src/base/array/array.h

@@ -17,9 +17,6 @@ BEGIN_C_LINKAGE
 #define _calc_array_count(TYPE, ...) wapp_misc_utils_va_args_count(TYPE, __VA_ARGS__)
 #define _calc_array_capacity(TYPE, ...) wapp_misc_utils_u64_round_up_pow2(_calc_array_count(TYPE, __VA_ARGS__) * 2)
 
-#define wapp_array_alloc_capacity(TYPE, ALLOCATOR_PTR, CAPACITY, FLAGS)    \
-	((TYPE *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(TYPE), FLAGS))
-
 typedef struct Str8 Str8;
 
 // NOTE (Abdelrahman): Typedefs to distinguish arrays from regular pointers
@@ -138,43 +135,48 @@ typedef enum {
 	                    sizeof(TYPE)))
 #define wapp_array_set(TYPE, ARRAY, INDEX, VALUE_PTR)                                              \
 	(_array_set((GenericArray)ARRAY,                                                                 \
-	           INDEX,                                                                                \
+	            INDEX,                                                                               \
-	           (u8 *)VALUE_PTR,                                                                      \
+	            (u8 *)VALUE_PTR,                                                                     \
-	           sizeof(TYPE)))
+	            sizeof(TYPE)))
 #define wapp_array_append_capped(TYPE, ARRAY, VALUE_PTR)                                           \
 	(_array_append_capped((GenericArray)ARRAY,                                                       \
-	                     (u8 *)VALUE_PTR,                                                            \
+	                      (u8 *)VALUE_PTR,                                                           \
-	                     sizeof(TYPE)))
+	                      sizeof(TYPE)))
 #define wapp_array_extend_capped(TYPE, DST_ARRAY, SRC_ARRAY)                                       \
 	(_array_extend_capped((GenericArray)DST_ARRAY,                                                   \
-	                     (GenericArray)SRC_ARRAY,                                                    \
+	                      (GenericArray)SRC_ARRAY,                                                   \
-	                     sizeof(TYPE)))
+	                      sizeof(TYPE)))
 #define wapp_array_copy_capped(TYPE, DST_ARRAY, SRC_ARRAY)                                         \
 	(_array_copy_capped((GenericArray)DST_ARRAY,                                                     \
-	                   (GenericArray)SRC_ARRAY,                                                      \
+	                    (GenericArray)SRC_ARRAY,                                                     \
-	                   sizeof(TYPE)))
+	                    sizeof(TYPE)))
 #define wapp_array_append_alloc(TYPE, ALLOCATOR_PTR, ARRAY, VALUE_PTR, FLAGS)                      \
 	((TYPE *)_array_append_alloc(ALLOCATOR_PTR,                                                      \
-	                            (GenericArray)ARRAY,                                                 \
+	                             (GenericArray)ARRAY,                                                \
-	                            (u8 *)VALUE_PTR,                                                     \
+	                             (u8 *)VALUE_PTR,                                                    \
-	                            sizeof(TYPE),                                                        \
+	                             FLAGS,                                                              \
-	                            FLAGS))
+	                             sizeof(TYPE)))
 #define wapp_array_extend_alloc(TYPE, ALLOCATOR_PTR, DST_ARRAY, SRC_ARRAY, FLAGS)                  \
 	((TYPE *)_array_extend_alloc(ALLOCATOR_PTR,                                                      \
-	                            (GenericArray)DST_ARRAY,                                             \
+	                             (GenericArray)DST_ARRAY,                                            \
-	                            (GenericArray)SRC_ARRAY,                                             \
+	                             (GenericArray)SRC_ARRAY,                                            \
-	                            sizeof(TYPE),                                                        \
+	                             FLAGS,                                                              \
-	                            FLAGS))
+	                             sizeof(TYPE)))
 #define wapp_array_copy_alloc(TYPE, ALLOCATOR_PTR, DST_ARRAY, SRC_ARRAY, FLAGS)                    \
 	((TYPE *)_array_copy_alloc(ALLOCATOR_PTR,                                                        \
-	                          (GenericArray)DST_ARRAY,                                               \
+	                           (GenericArray)DST_ARRAY,                                              \
-	                          (GenericArray)SRC_ARRAY,                                               \
+	                           (GenericArray)SRC_ARRAY,                                              \
-	                          sizeof(TYPE),                                                          \
+	                           FLAGS,                                                                \
-	                          FLAGS))
+	                           sizeof(TYPE)))
 #define wapp_array_clear(TYPE, ARRAY)                                                              \
 	(_array_clear((GenericArray)ARRAY,                                                               \
 	             sizeof(TYPE)))
 #define wapp_array_calc_alloc_size(TYPE, CAPACITY) _array_calc_alloc_size(CAPACITY, sizeof(TYPE))
+#define wapp_array_alloc_capacity(TYPE, ALLOCATOR_PTR, CAPACITY, FLAGS)                            \
+	((TYPE *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, FLAGS, sizeof(TYPE)))
+#define wapp_array_from_preallcated_buffer(TYPE, BUFFER, BUFFER_SIZE)                              \
+	((TYPE *)_array_from_preallcated_buffer(BUFFER, BUFFER_SIZE, sizeof(TYPE)))
+
 
 typedef struct header ArrayHeader;
 struct header {
@@ -194,16 +196,18 @@ void         _array_append_capped(GenericArray array, void *value, u64 item_size
 void         _array_extend_capped(GenericArray dst, const GenericArray src, u64 item_size);
 void         _array_copy_capped(GenericArray dst, const GenericArray src, u64 item_size);
 GenericArray _array_append_alloc(const Allocator *allocator, GenericArray array, void *value,
-                                 u64 item_size, ArrayInitFlags flags);
+                                 ArrayInitFlags flags, u64 item_size);
 GenericArray _array_extend_alloc(const Allocator *allocator, GenericArray dst, const GenericArray src,
-                                 u64 item_size, ArrayInitFlags flags);
+                                 ArrayInitFlags flags, u64 item_size);
 GenericArray _array_copy_alloc(const Allocator *allocator, GenericArray dst, const GenericArray src,
-                               u64 item_size, ArrayInitFlags flags);
+                               ArrayInitFlags flags, u64 item_size);
 void        *_array_pop(GenericArray array, u64 item_size);
 void         _array_clear(GenericArray array, u64 item_size);
 u64          _array_calc_alloc_size(u64 capacity, u64 item_size);
-GenericArray _array_alloc_capacity(const Allocator *allocator, u64 capacity, u64 item_size,
+GenericArray _array_alloc_capacity(const Allocator *allocator, u64 capacity, ArrayInitFlags flags,
-                                   ArrayInitFlags flags);
+                                   u64 item_size);
+GenericArray _array_from_preallocated_buffer(void *buffer, u64 buffer_size, ArrayInitFlags flags,
+                                             u64 item_size);
 
 #ifdef WAPP_PLATFORM_CPP
 END_C_LINKAGE

src/base/queue/queue.c

@@ -3,24 +3,83 @@
 #include "queue.h"
 #include "../array/array.h"
 #include "../../common/assert/assert.h"
+#include "../../common/misc/misc_utils.h"
 #include <string.h>
 
-void _queue_pop_front(GenericQueue *queue, void *output, u64 item_size) {
+void _queue_push(GenericQueue *queue, void *item, u64 item_size) {
-	wapp_debug_assert(queue != NULL && output != NULL, "`queue` and `output` should not be NULL");
+	wapp_debug_assert(queue != NULL, "`queue` should not be NULL");
 	wapp_runtime_assert(item_size == wapp_array_item_size(queue->items), "Invalid type");
 
-	memcpy(output, queue->items, item_size);
+	u64 capacity = wapp_array_capacity(queue->items);
+	if (queue->count >= capacity) { return; }
 
-	// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
+	u64 index = (queue->back)++;
-	// MSVC Spectre mitigation warnings
+	_array_set(queue->items, index, item, item_size);
-	u64 new_count = wapp_array_count(queue->items) - 1;
+	++(queue->count);
-	u64 index     = 0;
+
-	b8 running    = index < new_count;
+	if (queue->back >= capacity) {
-	while (running) {
+		queue->back = 0;
-		_array_set(queue->items, index, _array_get(queue->items, index + 1, item_size), item_size);
+	}
-		++index;
+}
-		running = index < new_count;
+
+GenericQueue *_queue_push_alloc(const Allocator *allocator, GenericQueue *queue, void *item, u64 item_size) {
+	wapp_debug_assert(allocator != NULL && queue != NULL && item != NULL,
+	                  "`allocator`, `queue` and `item` should not be NULL");
+	wapp_runtime_assert(item_size == wapp_array_item_size(queue->items), "Invalid type");
+
+	GenericQueue *output = queue;
+
+	u64 capacity = wapp_array_capacity(queue->items);
+	if (queue->count >= capacity) {
+		u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(capacity * 2);
+		u64 array_size   = _array_calc_alloc_size(new_capacity, item_size);
+		u64 alloc_size   = sizeof(GenericQueue) + array_size;
+		void *buffer     = wapp_mem_allocator_alloc(allocator, alloc_size);
+		if (!buffer) {
+			goto RETURN_QUEUE_PUSH_ALLOC;
+		}
+
+		memset((void *)buffer, 0, alloc_size);
+
+		output        = (GenericQueue *)buffer;
+		output->items = _array_from_preallocated_buffer((void *)(output + 1), array_size, ARRAY_INIT_FILLED, item_size);
+
+		// NOTE (Abdelrahman): When the queue is full, the front and back indices should
+		// always be the same
+		u64 front_count     = capacity - queue->front;
+		u64 back_count      = queue->back;
+		void *copy_boundary = (void *)((uptr)(queue->items) + (queue->front * item_size));
+
+		memcpy(output->items, copy_boundary, front_count * item_size);
+		if (back_count > 0) {
+			void *back_copy_dst = (void *)((uptr)(output->items) + (front_count * item_size));
+			memcpy(back_copy_dst, queue->items, back_count * item_size);
+		}
+
+		output->front = 0;
+		output->back  = front_count + back_count;
+		output->count = queue->count;
 	}
 
-	wapp_array_set_count(queue->items, new_count);
+	_queue_push(output, item, item_size);
+
+RETURN_QUEUE_PUSH_ALLOC:
+	return output;
+}
+
+void *_queue_pop(GenericQueue *queue, u64 item_size) {
+	wapp_debug_assert(queue != NULL, "`queue` should not be NULL");
+	wapp_runtime_assert(item_size == wapp_array_item_size(queue->items), "Invalid type");
+
+	if (queue->count == 0) { return NULL; }
+
+	u64 index = (queue->front)++;
+	--(queue->count);
+
+	u64 capacity = wapp_array_capacity(queue->items);
+	if (queue->front >= capacity) {
+		queue->front = 0;
+	}
+
+	return _array_get(queue->items, index, item_size);
 }

src/base/queue/queue.h

@@ -4,6 +4,7 @@
 #define QUEUE_H
 
 #include "../array/array.h"
+#include "../mem/allocator/mem_allocator.h"
 #include "../../common/aliases/aliases.h"
 #include "../../common/platform/platform.h"
 
@@ -13,6 +14,9 @@ BEGIN_C_LINKAGE
 
 typedef struct {
 	GenericArray items;
+	u64 front;
+	u64 back;
+	u64 count;
 } GenericQueue;
 
 // NOTE (Abdelrahman): GenericQueue typedefs for readability
@@ -38,41 +42,56 @@ typedef GenericQueue Str8Queue;
 
 #ifdef WAPP_PLATFORM_CPP
 #define wapp_queue(TYPE, CAPACITY) ([&]() {                                                        \
-	wapp_persist GenericArray arr   = wapp_array_with_capacity(TYPE, CAPACITY, ARRAY_INIT_NONE);     \
+	wapp_persist GenericArray arr   = wapp_array_with_capacity(TYPE, CAPACITY, ARRAY_INIT_FILLED);   \
-	wapp_persist GenericQueue queue = {arr};                                                         \
+	wapp_persist GenericQueue queue = {                                                              \
+		arr,                                                                                           \
+		0,                                                                                             \
+		0,                                                                                             \
+		0,                                                                                             \
+	};                                                                                               \
                                                                                                    \
 	return queue;                                                                                    \
 }())
 #define wapp_queue_alloc(TYPE, ALLOCATOR_PTR, CAPACITY) ([&]() {                                   \
 	wapp_persist GenericQueue queue = {                                                              \
-		wapp_array_alloc_capacity(TYPE, ALLOCATOR_PTR, CAPACITY, ARRAY_INIT_NONE)                      \
+		wapp_array_alloc_capacity(TYPE, ALLOCATOR_PTR, CAPACITY, ARRAY_INIT_FILLED),                   \
+		0,                                                                                             \
+		0,                                                                                             \
+		0,                                                                                             \
 	};                                                                                               \
                                                                                                    \
 	return queue;                                                                                    \
 }())
 #else
 #define wapp_queue(TYPE, CAPACITY) ((GenericQueue){                                                \
-	.items = wapp_array_with_capacity(TYPE, CAPACITY, ARRAY_INIT_NONE)                               \
+	.items = wapp_array_with_capacity(TYPE, CAPACITY, ARRAY_INIT_FILLED),                            \
+	.front = 0,                                                                                      \
+	.back  = 0,                                                                                      \
+	.count = 0,                                                                                      \
 })
 #define wapp_queue_alloc(TYPE, ALLOCATOR_PTR, CAPACITY) ((GenericQueue){                           \
-	.items = wapp_array_alloc_capacity(TYPE, ALLOCATOR_PTR, CAPACITY, ARRAY_INIT_NONE)               \
+	.items = wapp_array_alloc_capacity(TYPE, ALLOCATOR_PTR, CAPACITY, ARRAY_INIT_FILLED),            \
+	.front = 0,                                                                                      \
+	.back  = 0,                                                                                      \
+	.count = 0,                                                                                      \
 })
 #endif // !WAPP_PLATFORM_CPP
 
-#define wapp_queue_count(QUEUE_PTR) (wapp_array_count((QUEUE_PTR)->items))
 #define wapp_queue_capacity(QUEUE_PTR) (wapp_array_capacity((QUEUE_PTR)->items))
 #define wapp_queue_item_size(QUEUE_PTR) (wapp_array_item_size((QUEUE_PTR)->items))
-#define wapp_queue_push_back(TYPE, QUEUE_PTR, VALUE_PTR) (                                         \
+#define wapp_queue_push(TYPE, QUEUE_PTR, VALUE_PTR) (                                              \
-	wapp_array_append_capped(TYPE, (QUEUE_PTR)->items, VALUE_PTR)                                    \
+	_queue_push(QUEUE_PTR, VALUE_PTR, sizeof(TYPE))                                                  \
 )
-#define wapp_queue_push_back_alloc(TYPE, ALLOCATOR_PTR, QUEUE_PTR, VALUE_PTR) (                    \
+#define wapp_queue_push_alloc(TYPE, ALLOCATOR_PTR, QUEUE_PTR, VALUE_PTR) (                         \
-	wapp_array_append_alloc(TYPE, ALLOCATOR_PTR, (QUEUE_PTR)->items, VALUE_PTR)                      \
+	_queue_push_alloc(ALLOCATOR_PTR, QUEUE_PTR, VALUE_PTR, sizeof(TYPE))                             \
 )
-#define wapp_queue_pop_front(TYPE, QUEUE_PTR, OUTPUT_PTR) (                                        \
+#define wapp_queue_pop(TYPE, QUEUE_PTR) (                                                          \
-	_queue_pop_front(QUEUE_PTR, OUTPUT_PTR, sizeof(TYPE))                                            \
+	(TYPE *)_queue_pop(QUEUE_PTR, sizeof(TYPE))                                                      \
 )
 
-void _queue_pop_front(GenericQueue *queue, void *output, u64 item_size);
+void _queue_push(GenericQueue *queue, void *item, u64 item_size);
+GenericQueue *_queue_push_alloc(const Allocator *allocator, GenericQueue *queue, void *item, u64 item_size);
+void *_queue_pop(GenericQueue *queue, u64 item_size);
 
 #ifdef WAPP_PLATFORM_CPP
 END_C_LINKAGE

src/os/file/posix/file_posix.c

@@ -16,6 +16,7 @@
 #define lseek64 lseek
 #endif // !WAPP_PLATFORM_APPLE
 
+#define __USE_LARGEFILE64
 #include <fcntl.h>
 #include <unistd.h>
 #include <sys/types.h>

src/uuid/uuid.h

@@ -20,11 +20,24 @@ struct WUUID {
 	Str8 uuid;
 };
 
+// TODO (Abdelrahman): Update UUID implementation to work properly with C++ and tests for validation
+
+#ifdef WAPP_PLATFORM_CPP
+#define wapp_uuid_gen_uuid4() ([&](){           \
+	wapp_persist WUUID uuid = wapp_uuid_create(); \
+	return *(wapp_uuid_init_uuid4(&uuid))         \
+}())
+#else
 #define wapp_uuid_gen_uuid4() *(wapp_uuid_init_uuid4(&wapp_uuid_create()))
+#endif
 
 /* Low level UUID API */
 
+#ifdef WAPP_PLATFORM_CPP
+#define wapp_uuid_create() ([&](){ return WUUID{wapp_str8_buf(UUID_BUF_LENGTH)}; }())
+#else
 #define wapp_uuid_create() ((WUUID){.uuid = wapp_str8_buf(UUID_BUF_LENGTH)})
+#endif
 
 // Just returns the same pointer that was passed in with the UUID initialised.
 // Fails when passed a NULL pointer.

tests/queue/test_queue.c

@@ -3,61 +3,96 @@
 #include "wapp.h"
 #include "test_queue.h"
 
-wapp_persist Allocator arena = {0};
+#define CAPACITY 8
-wapp_persist I32Queue queue;
 
-TestFuncResult test_queue_push_back(void) {
+TestFuncResult test_queue_push(void) {
-	arena = wapp_mem_arena_allocator_init(MB(64));
+	I32Queue queue = wapp_queue(i32, CAPACITY);
+
+	for (u64 i = 0; i < CAPACITY; ++i) {
+		i32 item = (i32)i;
+		wapp_queue_push(i32, &queue, &item);
+	}
 
 	b8 result = true;
-	queue     = wapp_queue_alloc(i32, &arena, 64);
+	for (u64 i = 0; i < CAPACITY; ++i) {
-
+		i32 *value = ((i32 *)(queue.items)) + i;
-	result = result && queue.items != NULL && wapp_queue_capacity(&queue) == 64 && wapp_queue_count(&queue) == 0;
+		result = result && value != NULL && *value == (i32)i;
-
+	}
-	i32 n1 = 1;
-	i32 n2 = 2;
-	i32 n3 = 3;
-	i32 n4 = 4;
-	i32 n5 = 5;
-
-	wapp_queue_push_back(i32, &queue, &n1);
-	result = result && wapp_queue_count(&queue) == 1;
-
-	wapp_queue_push_back(i32, &queue, &n2);
-	result = result && wapp_queue_count(&queue) == 2;
-
-	wapp_queue_push_back(i32, &queue, &n3);
-	result = result && wapp_queue_count(&queue) == 3;
-
-	wapp_queue_push_back(i32, &queue, &n4);
-	result = result && wapp_queue_count(&queue) == 4;
-
-	wapp_queue_push_back(i32, &queue, &n5);
-	result = result && wapp_queue_count(&queue) == 5;
 
 	return wapp_tester_result(result);
 }
 
-TestFuncResult test_queue_pop_front(void) {
+TestFuncResult test_queue_push_alloc(void) {
+	Allocator arena = wapp_mem_arena_allocator_init(MiB(64));
+	I32Queue queue  = wapp_queue(i32, CAPACITY);
+
+	for (u64 i = 0; i < CAPACITY; ++i) {
+		i32 item = (i32)i;
+		wapp_queue_push(i32, &queue, &item);
+	}
+
 	b8 result = true;
-	i32 num;
+	i32 item  = 8;
+	u64 new_capacity = CAPACITY * 2;
+	I32Queue *new_queue = wapp_queue_push_alloc(i32, &arena, &queue, &item);
+	if (new_queue && new_queue != &queue) {
+		queue = *new_queue;
+	}
+	u64 capacity = wapp_queue_capacity(&queue);
+	result = result && capacity == new_capacity;
 
-	wapp_queue_pop_front(i32, &queue, &num);
+	for (u64 i = 0; i < 2; ++i) {
-	result = result && num == 1;
+		wapp_queue_pop(i32, &queue);
+	}
 
-	wapp_queue_pop_front(i32, &queue, &num);
+	u64 remaining = wapp_queue_capacity(&queue) - queue.count;
-	result = result && num == 2;
+	for (u64 i = 0; i < remaining; ++i) {
+		item = remaining + i;
+		wapp_queue_push(i32, &queue, &item);
+	}
 
-	wapp_queue_pop_front(i32, &queue, &num);
+	++item;
-	result = result && num == 3;
+	new_queue = wapp_queue_push_alloc(i32, &arena, &queue, &item);
+	if (new_queue && new_queue != &queue) {
+		queue = *new_queue;
+	}
 
-	wapp_queue_pop_front(i32, &queue, &num);
+	result = result && wapp_queue_capacity(&queue) == new_capacity * 2;
-	result = result && num == 4;
 
-	wapp_queue_pop_front(i32, &queue, &num);
+	i32 *arr = (i32 *)queue.items;
-	result = result && num == 5;
+	for (u64 i = 0; i < queue.count; ++i) {
+		// NOTE (Abdelrahman): First queue value is currently 2
+		result = result && arr[i] == (i32)(2 + i);
+	}
 
 	wapp_mem_arena_allocator_destroy(&arena);
 
 	return wapp_tester_result(result);
 }
+
+TestFuncResult test_queue_pop(void) {
+	I32Queue queue = wapp_queue(i32, CAPACITY);
+	for (u64 i = 0; i < CAPACITY; ++i) {
+		i32 item = (i32)i;
+		wapp_queue_push(i32, &queue, &item);
+	}
+
+	b8 result      = true;
+	u64 half_count = queue.count / 2;
+	for (u64 i = 0; i < half_count; ++i) {
+		i32 *value = wapp_queue_pop(i32, &queue);
+		result = result && value != NULL && *value == (i32)i;
+	}
+
+	for (u64 i = 0; i < half_count; ++i) {
+		i32 item = (i32)i + CAPACITY;
+		wapp_queue_push(i32, &queue, &item);
+	}
+
+	for (u64 i = 0; i < CAPACITY; ++i) {
+		i32 *value = wapp_queue_pop(i32, &queue);
+		result = result && value != NULL && *value == (i32)half_count + (i32)i;
+	}
+
+	return wapp_tester_result(result);
+}

tests/queue/test_queue.cc

@@ -1,61 +1,96 @@
 #include "wapp.h"
 #include "test_queue.h"
 
-wapp_persist Allocator arena = {};
+#define CAPACITY 8
-wapp_persist I32Queue queue;
 
-TestFuncResult test_queue_push_back(void) {
+TestFuncResult test_queue_push(void) {
-	arena = wapp_mem_arena_allocator_init(MB(64));
+	I32Queue queue = wapp_queue(i32, CAPACITY);
+
+	for (u64 i = 0; i < CAPACITY; ++i) {
+		i32 item = (i32)i;
+		wapp_queue_push(i32, &queue, &item);
+	}
 
 	b8 result = true;
-	queue     = wapp_queue_alloc(i32, &arena, 64);
+	for (u64 i = 0; i < CAPACITY; ++i) {
-
+		i32 *value = ((i32 *)(queue.items)) + i;
-	result = result && queue.items != NULL && wapp_queue_capacity(&queue) == 64 && wapp_queue_count(&queue) == 0;
+		result = result && value != NULL && *value == (i32)i;
-
+	}
-	i32 n1 = 1;
-	i32 n2 = 2;
-	i32 n3 = 3;
-	i32 n4 = 4;
-	i32 n5 = 5;
-
-	wapp_queue_push_back(i32, &queue, &n1);
-	result = result && wapp_queue_count(&queue) == 1;
-
-	wapp_queue_push_back(i32, &queue, &n2);
-	result = result && wapp_queue_count(&queue) == 2;
-
-	wapp_queue_push_back(i32, &queue, &n3);
-	result = result && wapp_queue_count(&queue) == 3;
-
-	wapp_queue_push_back(i32, &queue, &n4);
-	result = result && wapp_queue_count(&queue) == 4;
-
-	wapp_queue_push_back(i32, &queue, &n5);
-	result = result && wapp_queue_count(&queue) == 5;
 
 	return wapp_tester_result(result);
 }
 
-TestFuncResult test_queue_pop_front(void) {
+TestFuncResult test_queue_push_alloc(void) {
+	Allocator arena = wapp_mem_arena_allocator_init(MiB(64));
+	I32Queue queue  = wapp_queue(i32, CAPACITY);
+
+	for (u64 i = 0; i < CAPACITY; ++i) {
+		i32 item = (i32)i;
+		wapp_queue_push(i32, &queue, &item);
+	}
+
 	b8 result = true;
-	i32 num;
+	i32 item  = 8;
+	u64 new_capacity = CAPACITY * 2;
+	I32Queue *new_queue = wapp_queue_push_alloc(i32, &arena, &queue, &item);
+	if (new_queue && new_queue != &queue) {
+		queue = *new_queue;
+	}
+	u64 capacity = wapp_queue_capacity(&queue);
+	result = result && capacity == new_capacity;
 
-	wapp_queue_pop_front(i32, &queue, &num);
+	for (u64 i = 0; i < 2; ++i) {
-	result = result && num == 1;
+		wapp_queue_pop(i32, &queue);
+	}
 
-	wapp_queue_pop_front(i32, &queue, &num);
+	u64 remaining = wapp_queue_capacity(&queue) - queue.count;
-	result = result && num == 2;
+	for (u64 i = 0; i < remaining; ++i) {
+		item = remaining + i;
+		wapp_queue_push(i32, &queue, &item);
+	}
 
-	wapp_queue_pop_front(i32, &queue, &num);
+	++item;
-	result = result && num == 3;
+	new_queue = wapp_queue_push_alloc(i32, &arena, &queue, &item);
+	if (new_queue && new_queue != &queue) {
+		queue = *new_queue;
+	}
 
-	wapp_queue_pop_front(i32, &queue, &num);
+	result = result && wapp_queue_capacity(&queue) == new_capacity * 2;
-	result = result && num == 4;
 
-	wapp_queue_pop_front(i32, &queue, &num);
+	i32 *arr = (i32 *)queue.items;
-	result = result && num == 5;
+	for (u64 i = 0; i < queue.count; ++i) {
+		// NOTE (Abdelrahman): First queue value is currently 2
+		result = result && arr[i] == (i32)(2 + i);
+	}
 
 	wapp_mem_arena_allocator_destroy(&arena);
 
 	return wapp_tester_result(result);
 }
+
+TestFuncResult test_queue_pop(void) {
+	I32Queue queue = wapp_queue(i32, CAPACITY);
+	for (u64 i = 0; i < CAPACITY; ++i) {
+		i32 item = (i32)i;
+		wapp_queue_push(i32, &queue, &item);
+	}
+
+	b8 result      = true;
+	u64 half_count = queue.count / 2;
+	for (u64 i = 0; i < half_count; ++i) {
+		i32 *value = wapp_queue_pop(i32, &queue);
+		result = result && value != NULL && *value == (i32)i;
+	}
+
+	for (u64 i = 0; i < half_count; ++i) {
+		i32 item = (i32)i + CAPACITY;
+		wapp_queue_push(i32, &queue, &item);
+	}
+
+	for (u64 i = 0; i < CAPACITY; ++i) {
+		i32 *value = wapp_queue_pop(i32, &queue);
+		result = result && value != NULL && *value == (i32)half_count + (i32)i;
+	}
+
+	return wapp_tester_result(result);
+}

tests/queue/test_queue.h

@@ -5,7 +5,8 @@
 
 #include "wapp.h"
 
-TestFuncResult test_queue_push_back(void);
+TestFuncResult test_queue_push(void);
-TestFuncResult test_queue_pop_front(void);
+TestFuncResult test_queue_push_alloc(void);
+TestFuncResult test_queue_pop(void);
 
 #endif // !TEST_QUEUE_H

tests/wapptest.c

@@ -44,8 +44,9 @@ int main(void) {
 		test_i32_array_copy_alloc,
 		test_i32_array_pop,
 		test_i32_array_clear,
-		test_queue_push_back,
+		test_queue_push,
-		test_queue_pop_front,
+		test_queue_push_alloc,
+		test_queue_pop,
 		test_str8_lit,
 		test_str8_lit_ro,
 		test_str8_buf,

tests/wapptest.cc

@@ -44,8 +44,9 @@ int main(void) {
 		test_i32_array_copy_alloc,
 		test_i32_array_pop,
 		test_i32_array_clear,
-		test_queue_push_back,
+		test_queue_push,
-		test_queue_pop_front,
+		test_queue_push_alloc,
+		test_queue_pop,
 		test_str8_lit,
 		test_str8_lit_ro,
 		test_str8_buf,