[nostalgia/studio] Add version to Nostalgia Studio

This is necessary because OC array sizes are determined through the presence of the data.

.clang-tidy

@@ -4,10 +4,9 @@ Checks: '-*,
 cppcoreguidelines-interfaces-global-init,
 cppcoreguidelines-narrowing-conversions,
 cppcoreguidelines-pro-type-member-init,
-cppcoreguidelines-pro-type-static-cast-downcast,
+-cppcoreguidelines-pro-type-static-cast-downcast,
 cppcoreguidelines-slicing,
 google-default-arguments,
-google-explicit-constructor,
 google-runtime-operator,
 hicpp-exception-baseclass,
 hicpp-multiway-paths-covered,
@@ -53,6 +52,7 @@ readability-uniqueptr-delete-release,
 readability-use-anyofallof,
 cert-*,
 misc-*,
+-misc-include-cleaner
 -misc-use-anonymous-namespace,
 readability-duplicate-include,
 -misc-non-private-member-variables-in-classes,

.gitea/workflows/build.yaml

@@ -0,0 +1,19 @@
+name: Build
+run-name: ${{ gitea.actor }} build and test
+on: [push]
+
+jobs:
+  build:
+    runs-on: nostalgia
+    steps:
+      - name: Check out repository code
+        uses: actions/checkout@v3
+      - run: make purge configure-debug
+      - run: make build
+      - run: make test
+      - run: make purge configure-asan
+      - run: make build
+      - run: make test
+      - run: make purge configure-release
+      - run: make build
+      - run: make test

.gitignore

@@ -2,8 +2,10 @@
 .clangd
 .current_build
 .conanbuild
+.idea
 .mypy_cache
 .stfolder
+.stignore
 scripts/__pycache__
 CMakeLists.txt.user
 ROM.oxfs
@@ -13,8 +15,7 @@ compile_commands.json
 dist
 graph_info.json
 imgui.ini
-nostalgia.gba
-nostalgia.sav
-nostalgia_media.oxfs
+*.gba
+*.sav
 studio_state.json
 tags

.lldbinit

@@ -0,0 +1 @@
+type summary add --summary-string "${var.m_buff.m_items}" ox::String

CMakeLists.txt

@@ -11,34 +11,26 @@ endif()
 
 include(deps/buildcore/base.cmake)
 
-set(NOSTALGIA_BUILD_PLAYER ON CACHE BOOL "Build Player")
-set(NOSTALGIA_BUILD_STUDIO ON CACHE BOOL "Build Studio")
 set(OX_ENABLE_TRACEHOOK OFF CACHE BOOL "Generate OxTraceHook shared library for uprobes")
 
 if(BUILDCORE_TARGET STREQUAL "gba")
-	set(NOSTALGIA_BUILD_STUDIO OFF)
-	set(TURBINE_BUILD_TYPE "GBA")
 	include(deps/gbabuildcore/base.cmake)
 else()
-	set(TURBINE_BUILD_TYPE "Native")
 	set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 endif()
 
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
+
 if(APPLE)
 	set(CMAKE_MACOSX_RPATH OFF)
-	set(CMAKE_INSTALL_NAME_DIR "@executable_path/../Library/nostalgia")
-	set(NOSTALGIA_DIST_BIN              nostalgia-studio.app/Contents/MacOS)
-	set(NOSTALGIA_DIST_LIB              nostalgia-studio.app/Contents/Library)
-	set(NOSTALGIA_DIST_MODULE           nostalgia-studio.app/Contents/Plugins)
-	set(NOSTALGIA_DIST_RESOURCES        nostalgia-studio.app/Contents/Resources)
-	set(NOSTALGIA_DIST_MAC_APP_CONTENTS nostalgia-studio.app/Contents)
 else()
-	set(CMAKE_INSTALL_RPATH "$ORIGIN" "$ORIGIN/../lib/ox" "$ORIGIN/../lib/nostalgia" "$ORIGIN/../")
+	if(UNIX)
+		set(BUILD_SHARED_LIBS ON)
+	endif()
+	set(CMAKE_INSTALL_RPATH "$ORIGIN/../lib")
 	set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
-	set(NOSTALGIA_DIST_BIN       bin)
-	set(NOSTALGIA_DIST_LIB       lib)
-	set(NOSTALGIA_DIST_MODULE    lib/nostalgia/modules)
-	set(NOSTALGIA_DIST_RESOURCES share)
 endif()
 
 add_subdirectory(deps/ox)
@@ -50,14 +42,18 @@ add_subdirectory(deps/teagba)
 if(NOT BUILDCORE_TARGET STREQUAL "gba")
 	include_directories(
 		SYSTEM
-			deps/glfw/deps
 			deps/glfw/include
 			deps/imgui
 			deps/imgui/backends
 			deps/nfde/src/include
+			/usr/local/include
 	)
 	add_subdirectory(deps/glad)
+	set(GLFW_BUILD_EXAMPLES OFF)
+	set(GLFW_BUILD_TESTS OFF)
+	set(GLFW_BUILD_DOCS OFF)
 	add_subdirectory(deps/glfw)
+	add_subdirectory(deps/glutils)
 	add_subdirectory(deps/imgui)
 	add_subdirectory(deps/lodepng)
 	add_subdirectory(deps/nfde)

Dockerfile

@@ -31,7 +31,6 @@ RUN dnf install -y clang \
                    python3-pip \
                    libglvnd-devel \
                    gtk3-devel
-RUN pip install conan
 
 ###############################################################################
 # Install devkitARM

Makefile

@@ -1,39 +1,40 @@
-PROJECT_NAME=nostalgia
+BC_VAR_PROJECT_NAME=nostalgia
+BC_VAR_PROJECT_NAME_CAP=Nostalgia
 BUILDCORE_PATH=deps/buildcore
 include ${BUILDCORE_PATH}/base.mk
 
-ifeq ($(OS),darwin)
-	NOSTALGIA_STUDIO=./build/${HOST}/${CURRENT_BUILD}/src/nostalgia/studio/nostalgia-studio.app/Contents/MacOS/nostalgia-studio
+ifeq ($(BC_VAR_OS),darwin)
+	NOSTALGIA_STUDIO=./build/${BC_VAR_CURRENT_BUILD}/bin/${BC_VAR_PROJECT_NAME_CAP}Studio.app/Contents/MacOS/${BC_VAR_PROJECT_NAME_CAP}Studio
 	MGBA=/Applications/mGBA.app/Contents/MacOS/mGBA
 else
-	NOSTALGIA_STUDIO=./build/${HOST}/${CURRENT_BUILD}/src/nostalgia/studio/nostalgia-studio
+	NOSTALGIA_STUDIO=./build/${BC_VAR_CURRENT_BUILD}/bin/${BC_VAR_PROJECT_NAME_CAP}Studio
 	MGBA=mgba-qt
 endif
 
 .PHONY: pkg-gba
-pkg-gba: install
-	${ENV_RUN} ./scripts/pkg-gba sample_project
+pkg-gba: build
+	${BC_CMD_ENVRUN} ${BC_PY3} ./scripts/pkg-gba.py sample_project ${BC_VAR_PROJECT_NAME}
 
 .PHONY: run
 run: build
-	./build/${HOST}/${CURRENT_BUILD}/src/nostalgia/player/nostalgia sample_project
+	./build/${BC_VAR_CURRENT_BUILD}/bin/${BC_VAR_PROJECT_NAME} sample_project
 .PHONY: run-studio
 run-studio: build
 	${NOSTALGIA_STUDIO}
 .PHONY: gba-run
 gba-run: pkg-gba
-	${MGBA} nostalgia.gba
+	${MGBA} ${BC_VAR_PROJECT_NAME}.gba
 .PHONY: debug
 debug: build
-	${DEBUGGER} ./build/${HOST}/${CURRENT_BUILD}/src/nostalgia/player/nostalgia sample_project
+	${BC_CMD_HOST_DEBUGGER} ./build/${BC_VAR_CURRENT_BUILD}/bin/${BC_VAR_PROJECT_NAME} sample_project
 .PHONY: debug-studio
 debug-studio: build
-	${DEBUGGER} ${NOSTALGIA_STUDIO}
+	${BC_CMD_HOST_DEBUGGER} ${NOSTALGIA_STUDIO}
 
 .PHONY: configure-gba
 configure-gba:
-	${ENV_RUN} ${SETUP_BUILD} --toolchain=deps/gbabuildcore/cmake/modules/GBA.cmake --target=gba --current_build=0 --build_type=release --build_root=${BUILD_PATH}
+	${BC_CMD_SETUP_BUILD} --toolchain=deps/gbabuildcore/cmake/modules/GBA.cmake --target=gba --current_build=0 --build_type=release --build_root=${BC_VAR_BUILD_PATH}
 
 .PHONY: configure-gba-debug
 configure-gba-debug:
-	${ENV_RUN} ${SETUP_BUILD} --toolchain=deps/gbabuildcore/cmake/modules/GBA.cmake --target=gba --current_build=0 --build_type=debug --build_root=${BUILD_PATH}
+	${BC_CMD_SETUP_BUILD} --toolchain=deps/gbabuildcore/cmake/modules/GBA.cmake --target=gba --current_build=0 --build_type=debug --build_root=${BC_VAR_BUILD_PATH}

README.md

@@ -8,6 +8,15 @@
 * Install Ninja, Make, and CMake
 * Consider also installing ccache for faster subsequent build times
 
+### Debian
+
+For Debian (and probably other Linux distros, but the package names will
+probably differ), install the following additional packages:
+* pkg-config
+* xorg-dev
+* libgtk-3-dev
+* python3-mypy
+
 ## Build
 
 Build options: release, debug, asan, gba, gba-debug

deps/buildcore/base.mk

@@ -9,89 +9,99 @@
 ifeq (${OS},Windows_NT)
 	SHELL := powershell.exe
 	.SHELLFLAGS := -NoProfile -Command
-	OS=windows
-	HOST_ENV=${OS}
+	BC_VAR_OS=windows
 else
-	OS=$(shell uname | tr [:upper:] [:lower:])
-	HOST_ENV=${OS}-$(shell uname -m)
+	BC_VAR_OS=$(shell uname | tr [:upper:] [:lower:])
 endif
 
-DEVENV=devenv$(shell pwd | sed 's/\//-/g')
-DEVENV_IMAGE=${PROJECT_NAME}-devenv
-ifneq ($(shell which docker 2> /dev/null),)
-	ifeq ($(shell docker inspect --format="{{.State.Status}}" ${DEVENV} 2>&1),running)
-		ENV_RUN=docker exec -i -t --user $(shell id -u ${USER}) ${DEVENV}
+ifneq ($(shell which python3 2> /dev/null),)
+	BC_CMD_HOST_PY3=python3
+else
+	ifeq ($(shell python -c 'import sys; print(sys.version_info[0])'),3)
+		BC_CMD_HOST_PY3=python
+	else
+		echo 'Please install Python3 on host'
+		exit 1
 	endif
 endif
 
-ifneq ($(shell ${ENV_RUN} which python3 2> /dev/null),)
-	PYTHON3=python3
-else
-	ifeq ($(shell ${ENV_RUN} python -c 'import sys; print(sys.version_info[0])'),3)
-		PYTHON3=python
+ifdef BC_VAR_USE_DOCKER_DEVENV
+	ifneq ($(shell which docker 2> /dev/null),)
+		BC_VAR_DEVENV=devenv$(shell pwd | sed 's/\//-/g')
+		BC_VAR_DEVENV_IMAGE=${BC_VAR_PROJECT_NAME}-devenv
+		ifeq ($(shell docker inspect --format="{{.State.Status}}" ${BC_VAR_DEVENV} 2>&1),running)
+			BC_CMD_ENVRUN=docker exec -i -t --user $(shell id -u ${USER}) ${BC_VAR_DEVENV}
+		endif
 	endif
+	ifneq ($(shell ${BC_CMD_ENVRUN} which python3 2> /dev/null),)
+		BC_CMD_PY3=${BC_CMD_ENVRUN} python3
+	else
+		ifeq ($(shell ${BC_CMD_ENVRUN} python -c 'import sys; print(sys.version_info[0])'),3)
+			BC_CMD_PY3=${BC_CMD_ENVRUN} python
+		else
+			echo 'Please install Python3 in devenv'
+			exit 1
+		endif
+	endif
+else
+	BC_CMD_PY3=${BC_CMD_HOST_PY3}
 endif
 
-SCRIPTS=${BUILDCORE_PATH}/scripts
-SETUP_BUILD=${PYTHON3} ${SCRIPTS}/setup-build.py
-PYBB=${PYTHON3} ${SCRIPTS}/pybb.py
-CMAKE_BUILD=${PYBB} cmake-build
-GET_ENV=${PYBB} getenv
-CTEST=${PYBB} ctest-all
-RM_RF=${PYBB} rm
-HOST=$(shell ${PYBB} hostname)
-BUILDCORE_HOST_SPECIFIC_BUILDPATH=$(shell ${GET_ENV} BUILDCORE_HOST_SPECIFIC_BUILDPATH)
-ifneq (${BUILDCORE_HOST_SPECIFIC_BUILDPATH},)
-BUILD_PATH=build/${HOST}
-else
-BUILD_PATH=build
-endif
-ifdef USE_VCPKG
-	ifndef VCPKG_DIR_BASE
-		VCPKG_DIR_BASE=.vcpkg
-	endif
-	ifndef VCPKG_VERSION
-		VCPKG_VERSION=2020.06
-	endif
-	VCPKG_TOOLCHAIN=--toolchain=${VCPKG_DIR}/scripts/buildsystems/vcpkg.cmake
-endif
-ifeq ($(OS),darwin)
-	DEBUGGER=lldb --
-else
-	DEBUGGER=gdb --args
-endif
+BC_VAR_SCRIPTS=${BUILDCORE_PATH}/scripts
+BC_CMD_SETUP_BUILD=${BC_CMD_PY3} ${BC_VAR_SCRIPTS}/setup-build.py
+BC_CMD_PYBB=${BC_CMD_PY3} ${BC_VAR_SCRIPTS}/pybb.py
+BC_CMD_HOST_PYBB=${BC_CMD_HOST_PY3} ${BC_VAR_SCRIPTS}/pybb.py
+BC_CMD_CMAKE_BUILD=${BC_CMD_PYBB} cmake-build
+BC_CMD_GETENV=${BC_CMD_PYBB} getenv
+BC_CMD_CTEST=${BC_CMD_PYBB} ctest-all
+BC_CMD_RM_RF=${BC_CMD_PYBB} rm
+BC_CMD_MKDIR_P=${BC_CMD_PYBB} mkdir
+BC_CMD_CAT=${BC_CMD_PYBB} cat
+BC_CMD_DEBUGGER=${BC_CMD_PYBB} debug
+BC_CMD_HOST_DEBUGGER=${BC_CMD_HOST_PYBB} debug
+BC_VAR_HOSTENV=$(shell ${BC_CMD_ENVRUN} ${BC_CMD_PYBB} hostenv)
+BC_VAR_BUILD_PATH=build
+BC_VAR_CURRENT_BUILD=$(BC_VAR_HOSTENV)-$(shell ${BC_CMD_ENVRUN} ${BC_CMD_CAT} .current_build)
 
-VCPKG_DIR=$(VCPKG_DIR_BASE)/$(VCPKG_VERSION)-$(HOST_ENV)
-CURRENT_BUILD=$(HOST_ENV)-$(shell ${ENV_RUN} ${PYBB} cat .current_build)
+ifdef BC_VAR_USE_VCPKG
+ifndef BC_VAR_VCPKG_DIR_BASE
+	BC_VAR_VCPKG_DIR_BASE=.vcpkg
+endif
+ifndef BC_VAR_VCPKG_VERSION
+	BC_VAR_VCPKG_VERSION=2023.08.09
+endif
+endif
 
 .PHONY: build
 build:
-	${ENV_RUN} ${CMAKE_BUILD} ${BUILD_PATH}
+	${BC_CMD_CMAKE_BUILD} ${BC_VAR_BUILD_PATH}
 .PHONY: install
 install:
-	${ENV_RUN} ${CMAKE_BUILD} ${BUILD_PATH} install
+	${BC_CMD_CMAKE_BUILD} ${BC_VAR_BUILD_PATH} install
 .PHONY: clean
 clean:
-	${ENV_RUN} ${CMAKE_BUILD} ${BUILD_PATH} clean
+	${BC_CMD_CMAKE_BUILD} ${BC_VAR_BUILD_PATH} clean
 .PHONY: purge
 purge:
-	${ENV_RUN} ${RM_RF} .current_build
-	${ENV_RUN} ${RM_RF} ${BUILD_PATH}
-	${ENV_RUN} ${RM_RF} dist
+	${BC_CMD_RM_RF} .current_build
+	${BC_CMD_RM_RF} ${BC_VAR_BUILD_PATH}
+	${BC_CMD_RM_RF} dist
+	${BC_CMD_RM_RF} compile_commands.json
 .PHONY: test
 test: build
-	${ENV_RUN} mypy ${SCRIPTS}
-	${ENV_RUN} ${CMAKE_BUILD} ${BUILD_PATH} test
+	${BC_CMD_ENVRUN} ${BC_CMD_PY3} -m mypy ${BC_VAR_SCRIPTS}
+	${BC_CMD_CMAKE_BUILD} ${BC_VAR_BUILD_PATH} test
 .PHONY: test-verbose
 test-verbose: build
-	${ENV_RUN} ${CTEST} ${BUILD_PATH} --output-on-failure
+	${BC_CMD_CTEST} ${BC_VAR_BUILD_PATH} --output-on-failure
 .PHONY: test-rerun-verbose
 test-rerun-verbose: build
-	${ENV_RUN} ${CTEST} ${BUILD_PATH} --rerun-failed --output-on-failure
+	${BC_CMD_CTEST} ${BC_VAR_BUILD_PATH} --rerun-failed --output-on-failure
 
+ifdef BC_VAR_USE_DOCKER_DEVENV
 .PHONY: devenv-image
 devenv-image:
-	docker build . -t ${DEVENV_IMAGE}
+	docker build . -t ${BC_VAR_DEVENV_IMAGE}
 .PHONY: devenv-create
 devenv-create:
 	docker run -d \
@@ -103,73 +113,77 @@ devenv-create:
 		-v $(shell pwd):/usr/src/project \
 		-v /dev/shm:/dev/shm \
 		--restart=always \
-		--name ${DEVENV} \
-		-t ${DEVENV_IMAGE} bash
+		--name ${BC_VAR_DEVENV} \
+		-t ${BC_VAR_DEVENV_IMAGE} bash
 .PHONY: devenv-destroy
 devenv-destroy:
-	docker rm -f ${DEVENV}
-ifdef ENV_RUN
+	docker rm -f ${BC_VAR_DEVENV}
+ifdef BC_CMD_ENVRUN
 .PHONY: devenv-shell
 devenv-shell:
-	${ENV_RUN} bash
+	${BC_CMD_ENVRUN} bash
+endif
 endif
 
-ifdef USE_VCPKG
+ifdef BC_VAR_USE_VCPKG
+
+BC_VAR_VCPKG_TOOLCHAIN=--toolchain=${BC_VAR_VCPKG_DIR}/scripts/buildsystems/vcpkg.cmake
+BC_VAR_VCPKG_DIR=$(BC_VAR_VCPKG_DIR_BASE)/$(BC_VAR_VCPKG_VERSION)-$(BC_VAR_HOSTENV)
 
 .PHONY: vcpkg
-vcpkg: ${VCPKG_DIR} vcpkg-install
+vcpkg: ${BC_VAR_VCPKG_DIR} vcpkg-install
 
-${VCPKG_DIR}:
-	${ENV_RUN} ${RM_RF} ${VCPKG_DIR}
-	${ENV_RUN} mkdir -p ${VCPKG_DIR_BASE}
-	${ENV_RUN} git clone -b release --depth 1 --branch ${VCPKG_VERSION} https://github.com/microsoft/vcpkg.git ${VCPKG_DIR}
-ifneq (${OS},windows)
-	${ENV_RUN} ${VCPKG_DIR}/bootstrap-vcpkg.sh
+${BC_VAR_VCPKG_DIR}:
+	${BC_CMD_RM_RF} ${BC_VAR_VCPKG_DIR}
+	${BC_CMD_PYBB} mkdir ${BC_VAR_VCPKG_DIR_BASE}
+	${BC_CMD_ENVRUN} git clone -b release --depth 1 --branch ${BC_VAR_VCPKG_VERSION} https://github.com/microsoft/vcpkg.git ${BC_VAR_VCPKG_DIR}
+ifneq (${BC_VAR_OS},windows)
+	${BC_CMD_ENVRUN} ${BC_VAR_VCPKG_DIR}/bootstrap-vcpkg.sh
 else
-	${ENV_RUN} ${VCPKG_DIR}/bootstrap-vcpkg.bat
+	${BC_CMD_ENVRUN} ${BC_VAR_VCPKG_DIR}/bootstrap-vcpkg.bat
 endif
 
 .PHONY: vcpkg-install
 vcpkg-install:
-ifneq (${OS},windows)
-	${VCPKG_DIR}/vcpkg install ${VCPKG_PKGS}
+ifneq (${BC_VAR_OS},windows)
+	${BC_CMD_ENVRUN} ${BC_VAR_VCPKG_DIR}/vcpkg install ${BC_VAR_VCPKG_PKGS}
 else
-	${VCPKG_DIR}/vcpkg install --triplet x64-windows ${VCPKG_PKGS}
+	${BC_CMD_ENVRUN} ${BC_VAR_VCPKG_DIR}/vcpkg install --triplet x64-windows ${BC_VAR_VCPKG_PKGS}
 endif
 
-else ifdef USE_CONAN # USE_VCPKG ################################################
-
+else ifdef USE_CONAN # USE_VCPKG / USE_CONAN ####################################
 .PHONY: setup-conan
 conan-config:
-	${ENV_RUN} conan profile new ${PROJECT_NAME} --detect --force
-ifeq ($(OS),linux)
-	${ENV_RUN} conan profile update settings.compiler.libcxx=libstdc++11 ${PROJECT_NAME}
+	${BC_CMD_ENVRUN} conan profile new ${BC_VAR_PROJECT_NAME} --detect --force
+ifeq ($(BC_VAR_OS),linux)
+	${BC_CMD_ENVRUN} conan profile update settings.compiler.libcxx=libstdc++11 ${BC_VAR_PROJECT_NAME}
 else
-	${ENV_RUN} conan profile update settings.compiler.cppstd=20 ${PROJECT_NAME}
-ifeq ($(OS),windows)
-	${ENV_RUN} conan profile update settings.compiler.runtime=static ${PROJECT_NAME}
+	${BC_CMD_ENVRUN} conan profile update settings.compiler.cppstd=20 ${BC_VAR_PROJECT_NAME}
+ifeq ($(BC_VAR_OS),windows)
+	${BC_CMD_ENVRUN} conan profile update settings.compiler.runtime=static ${BC_VAR_PROJECT_NAME}
 endif
 endif
+
 .PHONY: conan
 conan:
-	${ENV_RUN} ${PYBB} conan-install ${PROJECT_NAME}
-endif # USE_VCPKG ###############################################
+	${BC_CMD_PYBB} conan-install ${BC_VAR_PROJECT_NAME}
+endif # USE_CONAN ###############################################
 
-ifeq (${OS},darwin)
+ifeq (${BC_VAR_OS},darwin)
 .PHONY: configure-xcode
 configure-xcode:
-	${ENV_RUN} ${SETUP_BUILD} ${VCPKG_TOOLCHAIN} --build_tool=xcode --current_build=0 --build_root=${BUILD_PATH}
+	${BC_CMD_SETUP_BUILD} ${BC_VAR_VCPKG_TOOLCHAIN} --build_tool=xcode --current_build=0 --build_root=${BC_VAR_BUILD_PATH}
 endif
 
 .PHONY: configure-release
 configure-release:
-	${ENV_RUN} ${SETUP_BUILD} ${VCPKG_TOOLCHAIN} --build_type=release --build_root=${BUILD_PATH}
+	${BC_CMD_SETUP_BUILD} ${BC_VAR_VCPKG_TOOLCHAIN} --build_type=release --build_root=${BC_VAR_BUILD_PATH}
 
 .PHONY: configure-debug
 configure-debug:
-	${ENV_RUN} ${SETUP_BUILD} ${VCPKG_TOOLCHAIN} --build_type=debug --build_root=${BUILD_PATH}
+	${BC_CMD_SETUP_BUILD} ${BC_VAR_VCPKG_TOOLCHAIN} --build_type=debug --build_root=${BC_VAR_BUILD_PATH}
 
 .PHONY: configure-asan
 configure-asan:
-	${ENV_RUN} ${SETUP_BUILD} ${VCPKG_TOOLCHAIN} --build_type=asan --build_root=${BUILD_PATH}
+	${BC_CMD_SETUP_BUILD} ${BC_VAR_VCPKG_TOOLCHAIN} --build_type=asan --build_root=${BC_VAR_BUILD_PATH}
 

deps/buildcore/scripts/pybb.py

@@ -18,18 +18,20 @@ import subprocess
 import sys
 from typing import List, Optional
 
-
-def mkdir(path: str):
-    if not os.path.exists(path):
-        os.mkdir(path)
+import util
 
 
-# this exists because Windows is utterly incapable of providing a proper rm -rf
-def rm(path: str):
-    if (os.path.exists(path) or os.path.islink(path)) and not os.path.isdir(path):
-        os.remove(path)
-    elif os.path.isdir(path):
-        shutil.rmtree(path)
+def mkdir(path: str) -> int:
+    try:
+        util.mkdir_p(path)
+    except Exception:
+        return 1
+    return 0
+
+
+def rm_multi(paths: List[str]):
+    for path in paths:
+        util.rm(path)
 
 
 def ctest_all() -> int:
@@ -70,16 +72,13 @@ def conan() -> int:
     err = 0
     try:
         mkdir(conan_dir)
-    except:
+    except Exception:
         return 1
     if err != 0:
         return err
     args = ['conan', 'install', '../', '--build=missing', '-pr', project_name]
     os.chdir(conan_dir)
-    err = subprocess.run(args).returncode
-    if err != 0:
-        return err
-    return 0
+    return subprocess.run(args).returncode
 
 
 def cat(paths: List[str]) -> int:
@@ -87,48 +86,67 @@ def cat(paths: List[str]) -> int:
         try:
             with open(path) as f:
                 data = f.read()
-                sys.stdout.write(data)
+                print(data)
         except FileNotFoundError:
-            sys.stderr.write('cat: {}: no such file or directory\n'.format(path))
+            sys.stderr.write(f'cat: {path}: no such file or directory\n')
             return 1
-    sys.stdout.write('\n')
     return 0
 
 
+def debug(paths: List[str]) -> int:
+    if shutil.which('gdb') is not None:
+        args = ['gdb', '--args']
+    elif shutil.which('lldb') is not None:
+        args = ['lldb', '--']
+    args.extend(paths)
+    return subprocess.run(args).returncode
+
+
 def get_env(var_name: str) -> int:
     if var_name not in os.environ:
         return 1
-    sys.stdout.write(os.environ[var_name])
+    print(os.environ[var_name])
     return 0
 
 
 def hostname() -> int:
-    sys.stdout.write(platform.node())
+    print(platform.node())
     return 0
 
 
+def host_env() -> int:
+    os_name = platform.system().lower()
+    arch = util.get_arch()
+    print(f'{os_name}-{arch}')
+    return 0
+
+
+def clarg(idx: int) -> Optional[str]:
+    return sys.argv[idx] if len(sys.argv) > idx else None
+
+
 def main() -> int:
     err = 0
     if sys.argv[1] == 'mkdir':
-        try:
-            mkdir(sys.argv[2])
-        except:
-            err = 1
+        err = mkdir(sys.argv[2])
     elif sys.argv[1] == 'rm':
-        for i in range(2, len(sys.argv)):
-            rm(sys.argv[i])
+        rm_multi(sys.argv[2:])
     elif sys.argv[1] == 'conan-install':
         err = conan()
     elif sys.argv[1] == 'ctest-all':
         err = ctest_all()
     elif sys.argv[1] == 'cmake-build':
-        err = cmake_build(sys.argv[2], sys.argv[3] if len(sys.argv) > 3 else None)
+        err = cmake_build(sys.argv[2], clarg(3))
     elif sys.argv[1] == 'cat':
         err = cat(sys.argv[2:])
+    elif sys.argv[1] == 'debug':
+        err = debug(sys.argv[2:])
     elif sys.argv[1] == 'getenv':
         err = get_env(sys.argv[2])
     elif sys.argv[1] == 'hostname':
         err = hostname()
+    elif sys.argv[1] == 'hostenv':
+        err = host_env()
     else:
         sys.stderr.write('Command not found\n')
         err = 1

deps/buildcore/scripts/setup-build.py

@@ -15,18 +15,35 @@ import shutil
 import subprocess
 import sys
 
-from pybb import mkdir, rm
+import util
 
 
 def main() -> int:
     parser = argparse.ArgumentParser()
-    parser.add_argument('--target', help='Platform target',
-                        default='{:s}-{:s}'.format(sys.platform, platform.machine()))
-    parser.add_argument('--build_type', help='Build type (asan,debug,release)', default='release')
-    parser.add_argument('--build_tool', help='Build tool (default,xcode)', default='')
-    parser.add_argument('--build_root', help='Path to the root of build directories (must be in project dir)', default='build')
-    parser.add_argument('--toolchain', help='Path to CMake toolchain file', default='')
-    parser.add_argument('--current_build', help='Indicates whether or not to make this the active build', default=1)
+    parser.add_argument(
+            '--target',
+            help='Platform target',
+            default=f'{util.get_os()}-{util.get_arch()}')
+    parser.add_argument(
+            '--build_type',
+            help='Build type (asan,debug,release)',
+            default='release')
+    parser.add_argument(
+            '--build_tool',
+            help='Build tool (default,xcode)',
+            default='')
+    parser.add_argument(
+            '--build_root',
+            help='Path to the root build directory (must be in project dir)',
+            default='build')
+    parser.add_argument(
+            '--toolchain',
+            help='Path to CMake toolchain file',
+            default='')
+    parser.add_argument(
+            '--current_build',
+            help='Indicates whether or not to make this the active build',
+            default=1)
     args = parser.parse_args()
 
     if args.build_type == 'asan':
@@ -64,10 +81,10 @@ def main() -> int:
         return 1
 
     project_dir = os.getcwd()
-    build_dir = '{:s}/{:s}/{:s}'.format(project_dir, args.build_root, build_config)
-    rm(build_dir)
+    build_dir = f'{project_dir}/{args.build_root}/{build_config}'
+    util.rm(build_dir)
     cmake_cmd = [
-        'cmake', '-S', project_dir, '-B', build_dir, build_tool,
+        'cmake', '-S', project_dir, '-B', build_dir,
         '-DCMAKE_EXPORT_COMPILE_COMMANDS=ON',
         '-DCMAKE_TOOLCHAIN_FILE={:s}'.format(args.toolchain),
         '-DCMAKE_BUILD_TYPE={:s}'.format(build_type_arg),
@@ -75,22 +92,27 @@ def main() -> int:
         '-DBUILDCORE_BUILD_CONFIG={:s}'.format(build_config),
         '-DBUILDCORE_TARGET={:s}'.format(args.target),
     ]
+    if build_tool != '':
+        cmake_cmd.append(build_tool)
     if qt_path != '':
         cmake_cmd.append(qt_path)
     if platform.system() == 'Windows':
         cmake_cmd.append('-A x64')
 
-    subprocess.run(cmake_cmd)
+    cmake_err = subprocess.run(cmake_cmd).returncode
+    if cmake_err != 0:
+        return cmake_err
 
-    mkdir('dist')
+    util.mkdir_p('dist')
     if int(args.current_build) != 0:
         cb = open('.current_build', 'w')
         cb.write(args.build_type)
         cb.close()
 
-    rm('compile_commands.json')
+    util.rm('compile_commands.json')
     if platform.system() != 'Windows':
-        os.symlink('{:s}/compile_commands.json'.format(build_dir), 'compile_commands.json')
+        os.symlink(f'{build_dir}/compile_commands.json',
+                   'compile_commands.json')
     return 0
 
 

deps/buildcore/scripts/util.py

@@ -0,0 +1,38 @@
+#
+#  Copyright 2016 - 2021 gary@drinkingtea.net
+#
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+
+import os
+import platform
+import shutil
+
+
+def mkdir_p(path: str):
+    if not os.path.exists(path):
+        os.mkdir(path)
+
+
+# this exists because Windows is utterly incapable of providing a proper rm -rf
+def rm(path: str):
+    file_exists = os.path.exists(path)
+    is_link = os.path.islink(path)
+    is_dir = os.path.isdir(path)
+    if (file_exists or is_link) and not is_dir:
+        os.remove(path)
+    elif os.path.isdir(path):
+        shutil.rmtree(path)
+
+
+def get_os() -> str:
+    return platform.system().lower()
+
+
+def get_arch() -> str:
+    arch = platform.machine()
+    if arch.lower() == 'amd64':
+        arch = 'x86_64'
+    return arch

deps/gbabuildcore/cmake/modules/GBA.cmake

@@ -24,8 +24,8 @@ add_definitions(-DARM7)
 include(FindPackageHandleStandardArgs)
 
 macro(OBJCOPY_FILE EXE_NAME)
-	set(FO ${CMAKE_CURRENT_BINARY_DIR}/${EXE_NAME}.bin)
-	set(FI ${CMAKE_CURRENT_BINARY_DIR}/${EXE_NAME})
+	set(FO ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${EXE_NAME}.bin)
+	set(FI ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${EXE_NAME})
 	message(STATUS ${FO})
 
 	# run objcopy

deps/glfw/src/CMakeLists.txt

@@ -88,7 +88,7 @@ if (CMAKE_VERSION VERSION_LESS "3.16" AND APPLE)
                                 LANGUAGE C)
 endif()
 
-add_library(glfw OBJECT ${glfw_SOURCES} ${glfw_HEADERS})
+add_library(glfw ${glfw_SOURCES} ${glfw_HEADERS})
 set_target_properties(glfw PROPERTIES
                       OUTPUT_NAME ${GLFW_LIB_NAME}
                       VERSION ${GLFW_VERSION_MAJOR}.${GLFW_VERSION_MINOR}

deps/glutils/CMakeLists.txt

@@ -0,0 +1,10 @@
+project(GlUtils CXX)
+
+add_subdirectory(src)
+
+install(
+    DIRECTORY
+        include/glutils
+    DESTINATION
+        include
+)

deps/glutils/include/glutils/glutils.hpp

@@ -9,15 +9,17 @@
 #include <glad/glad.h>
 
 #include <ox/std/bounds.hpp>
+#include <ox/std/cstringview.hpp>
 #include <ox/std/error.hpp>
+#include <ox/std/size.hpp>
 #include <ox/std/string.hpp>
 #include <ox/std/vector.hpp>
 
 namespace glutils {
 
-constexpr ox::StringView GlslVersion = "#version 330";
-
-struct Empty {};
+struct Empty {
+	virtual ~Empty() noexcept = default;
+};
 
 struct TextureBase {
 
@@ -41,6 +43,8 @@ struct TextureBase {
 		return *this;
 	}
 
+	virtual ~TextureBase() noexcept = default;
+
 };
 
 
@@ -60,7 +64,7 @@ struct GLObject: public Base {
 		o.id = 0;
 	}
 
-	~GLObject() noexcept {
+	~GLObject() noexcept override {
 		del(id);
 	}
 
@@ -107,7 +111,7 @@ extern template struct GLObject<deleteProgram>;
 extern template struct GLObject<deleteShader>;
 
 using GLBuffer = GLObject<deleteBuffer>;
-using GLFrameBuffer = GLObject<deleteBuffer>;
+using GLFrameBuffer = GLObject<deleteFrameBuffer>;
 using GLRenderBuffer = GLObject<deleteRenderBuffer>;
 using GLShader = GLObject<deleteShader>;
 using GLProgram = GLObject<deleteProgram>;
@@ -147,9 +151,7 @@ class FrameBufferBind {
 void bind(const FrameBuffer &fb) noexcept;
 
 
-ox::Result<GLProgram> buildShaderProgram(const GLchar *vert, const GLchar *frag, const GLchar *geo = nullptr) noexcept;
-
-ox::Result<GLProgram> buildShaderProgram(const ox::String &vert, const ox::String &frag, const ox::String &geo = "") noexcept;
+ox::Result<GLProgram> buildShaderProgram(ox::CStringView const&vert, ox::CStringView const&frag, ox::CStringView const&geo = "") noexcept;
 
 glutils::GLVertexArray generateVertexArrayObject() noexcept;
 
@@ -161,7 +163,9 @@ FrameBuffer generateFrameBuffer(int width, int height) noexcept;
 /**
  * Resizes a FrameBuffer, and creates if it does not already exist.
  */
-void resizeInitFrameBuffer(FrameBuffer *fb, int width, int height) noexcept;
+void resizeInitFrameBuffer(FrameBuffer &fb, int width, int height) noexcept;
+
+void resizeInitFrameBuffer(FrameBuffer &fb, ox::Size const&sz) noexcept;
 
 struct BufferSet {
 	glutils::GLVertexArray vao;
@@ -172,9 +176,9 @@ struct BufferSet {
 	ox::Vector<GLuint> elements;
 };
 
-void sendVbo(const BufferSet &bs) noexcept;
-
-void sendEbo(const BufferSet &bs) noexcept;
+void sendVbo(BufferSet const&bs) noexcept;
+                            
+void sendEbo(BufferSet const&bs) noexcept;
 
 void clearScreen() noexcept;
 

deps/glutils/src/CMakeLists.txt

@@ -3,23 +3,21 @@ add_library(
 		glutils.cpp
 )
 
+target_include_directories(
+	GlUtils PUBLIC
+		../include
+)
+
 target_link_libraries(
 	GlUtils PUBLIC
 		OxStd
 		glad
 )
 
-install(
-	FILES
-		glutils.hpp
-	DESTINATION
-		include/glutils
-)
-
 install(
 	TARGETS
 		GlUtils
 	DESTINATION
 		LIBRARY DESTINATION lib
 		ARCHIVE DESTINATION lib
-)
+)

deps/glutils/src/glutils.cpp

@@ -6,7 +6,7 @@
 #include <ox/std/bstring.hpp>
 #include <ox/std/trace.hpp>
 
-#include "glutils.hpp"
+#include "glutils/glutils.hpp"
 
 namespace glutils {
 
@@ -88,27 +88,23 @@ static ox::Result<GLShader> buildShader(
 	return shader;
 }
 
-ox::Result<GLProgram> buildShaderProgram(const GLchar *vert, const GLchar *frag, const GLchar *geo) noexcept {
+ox::Result<GLProgram> buildShaderProgram(
+		ox::CStringView const&vert,
+		ox::CStringView const&frag,
+		ox::CStringView const&geo) noexcept {
 	GLProgram prgm(glCreateProgram());
-	oxRequire(vs, buildShader(GL_VERTEX_SHADER, vert, "vshad"));
+	oxRequire(vs, buildShader(GL_VERTEX_SHADER, vert.c_str(), "vshad"));
 	glAttachShader(prgm, vs);
-	if (geo && ox_strlen(geo) != 0) {
-		oxRequire(gs, buildShader(GL_GEOMETRY_SHADER, geo, "gshad"));
+	if (geo.c_str() && geo.bytes() != 0) {
+		oxRequire(gs, buildShader(GL_GEOMETRY_SHADER, geo.c_str(), "gshad"));
 		glAttachShader(prgm, gs);
 	}
-	oxRequire(fs, buildShader(GL_FRAGMENT_SHADER, frag, "fshad"));
+	oxRequire(fs, buildShader(GL_FRAGMENT_SHADER, frag.c_str(), "fshad"));
 	glAttachShader(prgm, fs);
 	glLinkProgram(prgm);
 	return prgm;
 }
 
-ox::Result<GLProgram> buildShaderProgram(
-		const ox::String &vert,
-		const ox::String &frag,
-		const ox::String &geo) noexcept {
-	return buildShaderProgram(vert.c_str(), frag.c_str(), geo.c_str());
-}
-
 GLVertexArray generateVertexArrayObject() noexcept {
 	GLVertexArray vao;
 	glGenVertexArrays(1, &vao.id);
@@ -133,8 +129,9 @@ FrameBuffer generateFrameBuffer(int width, int height) noexcept {
 	glGenTextures(1, &fb.color.id);
 	glBindTexture(GL_TEXTURE_2D, fb.color);
 	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, nullptr);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+	glGenerateMipmap(GL_TEXTURE_2D);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR);
 	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, fb.color, 0);
 	// depth texture
 	glGenRenderbuffers(1, &fb.depth.id);
@@ -150,21 +147,23 @@ FrameBuffer generateFrameBuffer(int width, int height) noexcept {
 	return fb;
 }
 
-void resizeInitFrameBuffer(FrameBuffer *fb, int width, int height) noexcept {
-	if (!*fb) {
-		*fb = generateFrameBuffer(width, height);
+void resizeInitFrameBuffer(FrameBuffer &fb, int width, int height) noexcept {
+	if (!fb) {
+		fb = generateFrameBuffer(width, height);
 		return;
 	}
 	width = ox::max(1, width);
 	height = ox::max(1, height);
-	fb->width = width;
-	fb->height = height;
-	glBindFramebuffer(GL_FRAMEBUFFER, *fb);
+	fb.width = width;
+	fb.height = height;
+	glBindFramebuffer(GL_FRAMEBUFFER, fb);
 	// color texture
-	glBindTexture(GL_TEXTURE_2D, fb->color);
+	glBindTexture(GL_TEXTURE_2D, fb.color);
 	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, nullptr);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 	// depth texture
-	glBindRenderbuffer(GL_RENDERBUFFER, fb->depth);
+	glBindRenderbuffer(GL_RENDERBUFFER, fb.depth);
 	glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, width, height);
 	// restore primary FB
 	glBindFramebuffer(GL_FRAMEBUFFER, 0);
@@ -172,13 +171,17 @@ void resizeInitFrameBuffer(FrameBuffer *fb, int width, int height) noexcept {
 	glBindRenderbuffer(GL_RENDERBUFFER, 0);
 }
 
-void sendVbo(const BufferSet &bs) noexcept {
+void resizeInitFrameBuffer(FrameBuffer &fb, ox::Size const&sz) noexcept {
+	resizeInitFrameBuffer(fb, sz.width, sz.height);
+}
+
+void sendVbo(BufferSet const&bs) noexcept {
 	const auto bufferSize = static_cast<GLsizeiptr>(sizeof(decltype(bs.vertices)::value_type) * bs.vertices.size());
 	glBindBuffer(GL_ARRAY_BUFFER, bs.vbo);
 	glBufferData(GL_ARRAY_BUFFER, bufferSize, bs.vertices.data(), GL_DYNAMIC_DRAW);
 }
 
-void sendEbo(const BufferSet &bs) noexcept {
+void sendEbo(BufferSet const&bs) noexcept {
 	const auto bufferSize = static_cast<GLsizeiptr>(sizeof(decltype(bs.elements)::value_type) * bs.elements.size());
 	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bs.ebo);
 	glBufferData(GL_ELEMENT_ARRAY_BUFFER, bufferSize, bs.elements.data(), GL_STATIC_DRAW);

deps/imgui/CMakeLists.txt

@@ -15,3 +15,8 @@ add_library(
 		backends/imgui_impl_glfw.cpp
 		backends/imgui_impl_opengl3.cpp
 )
+
+target_include_directories(
+	imgui SYSTEM PUBLIC
+		.
+)

deps/lodepng/CMakeLists.txt

@@ -12,3 +12,11 @@ target_include_directories(
 	lodepng PUBLIC SYSTEM
 		include
 )
+
+install(
+	TARGETS
+		lodepng
+	DESTINATION
+		LIBRARY DESTINATION lib
+		ARCHIVE DESTINATION lib
+)

deps/nfde/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.2)
+cmake_minimum_required(VERSION 3.10)
 project(nativefiledialog-extended)
 
 if(NOT MSVC)
@@ -11,7 +11,7 @@ if(WIN32)
 elseif(APPLE)
   set(nfd_PLATFORM PLATFORM_MACOS)
 elseif(UNIX AND NOT APPLE)
-  set(nfd_PLATFORM PLATFORM_LINUX)
+  set(nfd_PLATFORM PLATFORM_UNIX)
 endif()
 
 message("nfd Platform: ${nfd_PLATFORM}")

deps/nfde/src/CMakeLists.txt

@@ -10,13 +10,12 @@ if(nfd_PLATFORM STREQUAL PLATFORM_WIN32)
   list(APPEND SOURCE_FILES nfd_win.cpp)
 endif()
 
-if(nfd_PLATFORM STREQUAL PLATFORM_LINUX)
+if(nfd_PLATFORM STREQUAL PLATFORM_UNIX)
   find_package(PkgConfig REQUIRED)
   # for Linux, we support GTK3 and xdg-desktop-portal
   option(NFD_PORTAL "Use xdg-desktop-portal instead of GTK" OFF)
   if(NOT NFD_PORTAL)
-    pkg_check_modules(GTK3 REQUIRED gtk+-3.0)
-    message("Using GTK version: ${GTK3_VERSION}")
+    pkg_check_modules(GTK3 REQUIRED IMPORTED_TARGET gtk+-3.0)
     list(APPEND SOURCE_FILES nfd_gtk.cpp)
   else()
     pkg_check_modules(DBUS REQUIRED dbus-1)
@@ -31,19 +30,17 @@ if(nfd_PLATFORM STREQUAL PLATFORM_MACOS)
 endif()
 
 # Define the library
-add_library(${TARGET_NAME} OBJECT
+add_library(${TARGET_NAME}
   ${SOURCE_FILES})
 
 # Allow includes from include/
 target_include_directories(${TARGET_NAME}
   PUBLIC include/)
 
-if(nfd_PLATFORM STREQUAL PLATFORM_LINUX)
+if(nfd_PLATFORM STREQUAL PLATFORM_UNIX)
   if(NOT NFD_PORTAL)
-    target_include_directories(${TARGET_NAME}
-      PRIVATE ${GTK3_INCLUDE_DIRS})
     target_link_libraries(${TARGET_NAME}
-      PRIVATE ${GTK3_LIBRARIES})
+      PRIVATE PkgConfig::GTK3)
   else()
     target_include_directories(${TARGET_NAME}
       PRIVATE ${DBUS_INCLUDE_DIRS})

deps/ox/CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.19)
 set(CMAKE_POLICY_DEFAULT_CMP0110 NEW) # requires CMake 3.19
 
-project(Ox)
+project(Ox CXX)
 
 list(APPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/modules)
 include(address_sanitizer)

deps/ox/src/ox/CMakeLists.txt

@@ -1,3 +1,18 @@
+if(${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
+	set(OX_OS_WINDOWS TRUE)
+endif()
+if(${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD")
+	set(OX_OS_FREEBSD TRUE)
+else()
+	set(OX_OS_FREEBSD FALSE)
+endif()
+
+if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
+	set(OX_OS_LINUX TRUE)
+else()
+	set(OX_OS_LINUX FALSE)
+endif()
+
 if(OX_USE_STDLIB)
 	add_subdirectory(oc)
 endif()

deps/ox/src/ox/clargs/clargs.cpp

@@ -13,7 +13,7 @@ namespace ox {
 
 ClArgs::ClArgs(int argc, const char **args) noexcept {
 	for (auto i = 0u; i < static_cast<unsigned>(argc); ++i) {
-		String arg = args[i];
+		auto arg = String(args[i]);
 		if (arg[0] == '-') {
 			while (arg[0] == '-' && arg.len()) {
 				arg = arg.substr(1);
@@ -21,7 +21,7 @@ ClArgs::ClArgs(int argc, const char **args) noexcept {
 			m_bools[arg] = true;
 			// parse additional arguments
 			if (i < static_cast<unsigned>(argc) && args[i + 1]) {
-				String val = args[i + 1];
+				auto val = String(args[i + 1]);
 				if (val.len() && val[i] != '-') {
 					if (val == "false") {
 						m_bools[arg] = false;
@@ -44,7 +44,7 @@ bool ClArgs::getBool(ox::CRStringView arg, bool defaultValue) const noexcept {
 
 String ClArgs::getString(ox::CRStringView arg, const char *defaultValue) const noexcept {
 	auto [value, err] = m_strings.at(arg);
-	return !err ? *value : defaultValue;
+	return !err ? ox::String(std::move(*value)) : ox::String(defaultValue);
 }
 
 int ClArgs::getInt(ox::CRStringView arg, int defaultValue) const noexcept {

deps/ox/src/ox/claw/CMakeLists.txt

@@ -5,7 +5,6 @@ add_library(
 		write.cpp
 )
 
-
 if(NOT MSVC)
 	target_compile_options(OxClaw PRIVATE -Wsign-conversion)
 	target_compile_options(OxClaw PRIVATE -Wconversion)
@@ -17,6 +16,17 @@ target_link_libraries(
 		$<$<BOOL:${OX_USE_STDLIB}>:OxOrganicClaw>
 )
 
+#if(OX_USE_STDLIB)
+#	add_executable(
+#		readclaw
+#			readclaw.cpp
+#	)
+#	target_link_libraries(
+#		readclaw PUBLIC
+#			OxClaw
+#	)
+#endif()
+
 install(TARGETS OxClaw
         LIBRARY DESTINATION lib
         ARCHIVE DESTINATION lib

deps/ox/src/ox/claw/read.cpp

@@ -72,15 +72,19 @@ Result<Buffer> stripClawHeader(const ox::Buffer &buff) noexcept {
 	return stripClawHeader(buff.data(), buff.size());
 }
 
-Result<ModelObject> readClaw(TypeStore *ts, const char *buff, std::size_t buffSz) noexcept {
+Result<ModelObject> readClaw(TypeStore &ts, const char *buff, std::size_t buffSz) noexcept {
 	oxRequire(header, readClawHeader(buff, buffSz));
-	oxRequire(t, ts->getLoad(header.typeName, header.typeVersion, header.typeParams));
+	auto const [t, tdErr] = ts.getLoad(header.typeName, header.typeVersion, header.typeParams);
+	if (tdErr) {
+		return OxError(3, "Could not load type descriptor");
+	}
 	ModelObject obj;
 	oxReturnError(obj.setType(t));
 	switch (header.fmt) {
 		case ClawFormat::Metal:
 		{
-			MetalClawReader reader(reinterpret_cast<const uint8_t*>(header.data), header.dataSize);
+			ox::BufferReader br(header.data, header.dataSize);
+			MetalClawReader reader(br);
 			ModelHandlerInterface handler(&reader);
 			oxReturnError(model(&handler, &obj));
 			return obj;
@@ -102,7 +106,7 @@ Result<ModelObject> readClaw(TypeStore *ts, const char *buff, std::size_t buffSz
 	return OxError(1);
 }
 
-Result<ModelObject> readClaw(TypeStore *ts, const Buffer &buff) noexcept {
+Result<ModelObject> readClaw(TypeStore &ts, const Buffer &buff) noexcept {
 	return readClaw(ts, buff.data(), buff.size());
 }
 

deps/ox/src/ox/claw/read.hpp

@@ -51,7 +51,8 @@ Error readClaw(const char *buff, std::size_t buffLen, T *val) {
 	switch (header.fmt) {
 		case ClawFormat::Metal:
 		{
-			MetalClawReader reader(reinterpret_cast<const uint8_t*>(header.data), header.dataSize);
+			ox::BufferReader br(header.data, header.dataSize);
+			MetalClawReader reader(br);
 			ModelHandlerInterface handler(&reader);
 			return model(&handler, val);
 		}
@@ -87,8 +88,8 @@ Result<T> readClaw(const Buffer &buff) {
 	return readClaw<T>(buff.data(), buff.size());
 }
 
-Result<ModelObject> readClaw(TypeStore *ts, const char *buff, std::size_t buffSz) noexcept;
+Result<ModelObject> readClaw(TypeStore &ts, const char *buff, std::size_t buffSz) noexcept;
 
-Result<ModelObject> readClaw(TypeStore *ts, const Buffer &buff) noexcept;
+Result<ModelObject> readClaw(TypeStore &ts, const Buffer &buff) noexcept;
 
 }

deps/ox/src/ox/claw/readclaw.cpp

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2015 - 2023 gary@drinkingtea.net
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#include <cstdio>
+
+#include <ox/std/reader.hpp>
+#include <ox/std/trace.hpp>
+
+#include "claw.hpp"
+
+
+int main(int argc, char **args) {
+	if (argc > 2) {
+		oxErr("Too many arguments");
+		return -1;
+	}
+	auto const file = argc == 1 ? stdin : fopen(args[1], "r");
+	if (fseek(file, 0, SEEK_END)) {
+		oxErr("Could not get file size\n");
+		return -2;
+	}
+	auto const size = static_cast<std::size_t>(ftell(file));
+	oxDebugf("{}", size);
+	return 0;
+}

deps/ox/src/ox/claw/test/CMakeLists.txt

@@ -8,7 +8,7 @@ target_link_libraries(
 		OxClaw
 )
 
-add_test("[ox/claw] ClawTest ClawHeaderReader" ClawTest ClawHeaderReader)
-add_test("[ox/claw] ClawTest ClawHeaderReader2" ClawTest ClawHeaderReader2)
-add_test("[ox/claw] ClawTest ClawWriter" ClawTest ClawWriter)
-add_test("[ox/claw] ClawTest ClawReader" ClawTest ClawReader)
+add_test("[ox/claw] ClawHeaderReader" ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/ClawTest ClawHeaderReader)
+add_test("[ox/claw] ClawHeaderReader2" ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/ClawTest ClawHeaderReader2)
+add_test("[ox/claw] ClawWriter" ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/ClawTest ClawWriter)
+add_test("[ox/claw] ClawReader" ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/ClawTest ClawReader)

deps/ox/src/ox/claw/test/tests.cpp

@@ -8,11 +8,7 @@
 
 #undef NDEBUG
 
-#include <cassert>
-#include <iostream>
 #include <map>
-#include <memory>
-#include <string>
 #include <ox/claw/format.hpp>
 #include <ox/claw/read.hpp>
 #include <ox/claw/write.hpp>
@@ -107,12 +103,12 @@ constexpr ox::Error model(T *io, ox::CommonPtrWith<TestStruct> auto *obj) {
 	return OxError(0);
 }
 
-static std::map<std::string_view, ox::Error(*)()> tests = {
+static std::map<ox::StringView, ox::Error(*)()> tests = {
 	{
 		{
 			"ClawHeaderReader",
 			[] {
-				ox::String hdr = "O1;com.drinkingtea.ox.claw.test.Header;2;";
+				constexpr auto hdr = ox::StringLiteral("O1;com.drinkingtea.ox.claw.test.Header;2;");
 				auto [ch, err] = ox::readClawHeader(hdr.c_str(), hdr.len() + 1);
 				oxAssert(err, "Error parsing header");
 				oxAssert(ch.fmt == ox::ClawFormat::Organic, "Format wrong");
@@ -124,7 +120,7 @@ static std::map<std::string_view, ox::Error(*)()> tests = {
 		{
 			"ClawHeaderReader2",
 			[] {
-				ox::String hdr = "M2;com.drinkingtea.ox.claw.test.Header2;3;";
+				constexpr auto hdr = ox::StringLiteral("M2;com.drinkingtea.ox.claw.test.Header2;3;");
 				auto [ch, err] = ox::readClawHeader(hdr.c_str(), hdr.len() + 1);
 				oxAssert(err, "Error parsing header");
 				oxAssert(ch.fmt == ox::ClawFormat::Metal, "Format wrong");
@@ -192,14 +188,14 @@ static std::map<std::string_view, ox::Error(*)()> tests = {
 };
 
 int main(int argc, const char **args) {
-	int retval = -1;
-	if (argc > 0) {
-		auto testName = args[1];
-		if (tests.find(testName) != tests.end()) {
-			retval = static_cast<int>(tests[testName]());
-		} else {
-			retval = 1;
-		}
+	if (argc < 2) {
+		oxError("Must specify test to run");
 	}
-	return retval;
+	auto const testName = args[1];
+	auto const func = tests.find(testName);
+	if (func != tests.end()) {
+		oxAssert(func->second(), "Test returned Error");
+		return 0;
+	}
+	return -1;
 }

deps/ox/src/ox/event/signal.hpp

@@ -245,7 +245,7 @@ class Signal<Error(Args...)> {
 			}
 
 			Error call(Args... args) noexcept final {
-				return f(args...);
+				return f(ox::forward<Args>(args)...);
 			}
 		};
 
@@ -260,7 +260,7 @@ class Signal<Error(Args...)> {
 			}
 
 			Error call(Args... args) noexcept final {
-				return (m_receiver->*(m_methodPtr))(args...);
+				return (m_receiver->*(m_methodPtr))(ox::forward<Args>(args)...);
 			}
 
 			void cleanup(Signal *signal) noexcept final {
@@ -286,7 +286,7 @@ class Signal<Error(Args...)> {
 			}
 
 			Error call(Args... args) noexcept final {
-				return (m_receiver->*(m_methodPtr))(args...);
+				return (m_receiver->*(m_methodPtr))(ox::forward<Args>(args)...);
 			}
 
 			void cleanup(Signal*) noexcept final {
@@ -391,14 +391,14 @@ Error Signal<Error(Args...)>::disconnectObject(const void *receiver) const noexc
 template<class... Args>
 void Signal<Error(Args...)>::emit(Args... args) const noexcept {
 	for (auto &f : m_slots) {
-		oxIgnoreError(f->call(args...));
+		oxIgnoreError(f->call(ox::forward<Args>(args)...));
 	}
 }
 
 template<class... Args>
 Error Signal<Error(Args...)>::emitCheckError(Args... args) const noexcept {
 	for (auto &f : m_slots) {
-		oxReturnError(f->call(args...));
+		oxReturnError(f->call(ox::forward<Args>(args)...));
 	}
 	return OxError(0);
 }

deps/ox/src/ox/event/test/CMakeLists.txt

@@ -7,4 +7,4 @@ add_executable(
 
 target_link_libraries(EventTest OxEvent)
 
-add_test("[ox/event] Test 1" EventTest "test1")
+add_test("[ox/event] Test 1" ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/EventTest "test1")

deps/ox/src/ox/event/test/tests.cpp

@@ -21,7 +21,7 @@ struct TestStruct: public ox::SignalHandler {
 	}
 };
 
-std::map<std::string, std::function<ox::Error()>> tests = {
+std::map<ox::StringView, std::function<ox::Error()>> tests = {
 	{
 		"test1",
 		[] {
@@ -39,12 +39,14 @@ std::map<std::string, std::function<ox::Error()>> tests = {
 };
 
 int main(int argc, const char **args) {
-	if (argc > 1) {
-		auto testName = args[1];
-		if (tests.find(testName) != tests.end()) {
-			oxAssert(tests[testName](), "Test returned Error");
-			return 0;
-		}
+	if (argc < 2) {
+		oxError("Must specify test to run");
+	}
+	auto const testName = args[1];
+	auto const func = tests.find(testName);
+	if (func != tests.end()) {
+		oxAssert(func->second(), "Test returned Error");
+		return 0;
 	}
 	return -1;
 }

deps/ox/src/ox/fs/CMakeLists.txt

@@ -16,12 +16,6 @@ if(NOT MSVC)
 endif()
 
 if(NOT OX_BARE_METAL)
-	if(NOT APPLE AND NOT MSVC)
-		target_link_libraries(
-			OxFS PUBLIC
-				stdc++fs
-		)
-	endif()
 	set_property(
 		TARGET
 			OxFS
@@ -44,7 +38,6 @@ if(NOT OX_BARE_METAL)
 	target_link_libraries(
 		oxfs-tool
 			OxFS
-			OxStd
 	)
 
 	install(

deps/ox/src/ox/fs/filestore/filestoretemplate.hpp

@@ -204,12 +204,12 @@ Error FileStoreTemplate<size_t>::format(void *buffer, std::size_t bufferSize) {
 	auto nb = new (buffer) Buffer(static_cast<size_t>(bufferSize));
 	auto fsData = nb->malloc(sizeof(FileStoreData)).value;
 	if (!fsData.valid()) {
-		oxTrace("ox::fs::FileStoreTemplate::format::fail", "Could not read data section of FileStoreData");
+		oxTrace("ox.fs.FileStoreTemplate.format.fail", "Could not read data section of FileStoreData");
 		return OxError(1, "Could not read data section of FileStoreData");
 	}
 	auto data = nb->template dataOf<FileStoreData>(fsData);
 	if (!data.valid()) {
-		oxTrace("ox::fs::FileStoreTemplate::format::fail", "Could not read data section of FileStoreData");
+		oxTrace("ox.fs.FileStoreTemplate.format.fail", "Could not read data section of FileStoreData");
 		return OxError(1, "Could not read data section of FileStoreData");
 	}
 	new (data) FileStoreData;
@@ -244,7 +244,7 @@ Error FileStoreTemplate<size_t>::decLinks(uint64_t id) {
 template<typename size_t>
 Error FileStoreTemplate<size_t>::write(uint64_t id64, const void *data, FsSize_t dataSize, uint8_t fileType) {
 	const auto id = static_cast<size_t>(id64);
-	oxTracef("ox::fs::FileStoreTemplate::write", "Attempting to write to inode {}", id);
+	oxTracef("ox.fs.FileStoreTemplate.write", "Attempting to write to inode {}", id);
 	auto existing = find(id);
 	if (!canWrite(existing, dataSize)) {
 		oxReturnError(compact());
@@ -254,10 +254,10 @@ Error FileStoreTemplate<size_t>::write(uint64_t id64, const void *data, FsSize_t
 	if (canWrite(existing, dataSize)) {
 		// delete the old node if it exists
 		if (existing.valid()) {
-			oxTracef("ox::fs::FileStoreTemplate::write", "Freeing old version of inode found at offset: {}", existing.offset());
+			oxTracef("ox.fs.FileStoreTemplate.write", "Freeing old version of inode found at offset: {}", existing.offset());
 			auto err = m_buffer->free(existing);
 			if (err) {
-				oxTrace("ox::fs::FileStoreTemplate::write::fail", "Free of old version of inode failed");
+				oxTrace("ox.fs.FileStoreTemplate.write.fail", "Free of old version of inode failed");
 				return err;
 			}
 			existing = nullptr;
@@ -266,12 +266,12 @@ Error FileStoreTemplate<size_t>::write(uint64_t id64, const void *data, FsSize_t
 		auto dest = m_buffer->malloc(dataSize).value;
 		// if first malloc failed, compact and try again
 		if (!dest.valid()) {
-			oxTrace("ox::fs::FileStoreTemplate::write", "Allocation failed, compacting");
+			oxTrace("ox.fs.FileStoreTemplate.write", "Allocation failed, compacting");
 			oxReturnError(compact());
 			dest = m_buffer->malloc(dataSize).value;
 		}
 		if (dest.valid()) {
-			oxTrace("ox::fs::FileStoreTemplate::write", "Memory allocated");
+			oxTrace("ox.fs.FileStoreTemplate.write", "Memory allocated");
 			dest->id = id;
 			dest->fileType = fileType;
 			auto destData = m_buffer->template dataOf<uint8_t>(dest);
@@ -280,26 +280,26 @@ Error FileStoreTemplate<size_t>::write(uint64_t id64, const void *data, FsSize_t
 				// write data if any was provided
 				if (data != nullptr) {
 					ox_memcpy(destData, data, dest->size());
-					oxTrace("ox::fs::FileStoreTemplate::write", "Data written");
+					oxTrace("ox.fs.FileStoreTemplate.write", "Data written");
 				}
 				auto fsData = fileStoreData();
 				if (fsData) {
-					oxTracef("ox::fs::FileStoreTemplate::write", "Searching for root node at {}", fsData->rootNode.get());
+					oxTracef("ox.fs.FileStoreTemplate.write", "Searching for root node at {}", fsData->rootNode.get());
 					auto root = m_buffer->ptr(fsData->rootNode);
 					if (root.valid()) {
-						oxTracef("ox::fs::FileStoreTemplate::write",
+						oxTracef("ox.fs.FileStoreTemplate.write",
 						         "Placing {} on {} at {}", dest->id.get(), root->id.get(), destData.offset());
 						return placeItem(dest);
 					} else {
-						oxTracef("ox::fs::FileStoreTemplate::write",
+						oxTracef("ox.fs.FileStoreTemplate.write",
 						        "Initializing root inode: {} (offset: {}, data size: {})",
 						        dest->id.get(), dest.offset(), destData.size());
 						fsData->rootNode = dest.offset();
-						oxTracef("ox::fs::FileStoreTemplate::write", "Root inode: {}", dest->id.get());
+						oxTracef("ox.fs.FileStoreTemplate.write", "Root inode: {}", dest->id.get());
 						return OxError(0);
 					}
 				} else {
-					oxTrace("ox::fs::FileStoreTemplate::write::fail", "Could not place item due to absence of FileStore header.");
+					oxTrace("ox.fs.FileStoreTemplate.write.fail", "Could not place item due to absence of FileStore header.");
 				}
 			}
 		}
@@ -315,23 +315,23 @@ Error FileStoreTemplate<size_t>::remove(uint64_t id) {
 
 template<typename size_t>
 Error FileStoreTemplate<size_t>::read(uint64_t id, void *out, FsSize_t outSize, FsSize_t *size) const {
-	oxTracef("ox::fs::FileStoreTemplate::read", "Attempting to read from inode {}", id);
+	oxTracef("ox.fs.FileStoreTemplate.read", "Attempting to read from inode {}", id);
 	auto src = find(static_cast<size_t>(id));
 	// error check
 	if (!src.valid()) {
-		oxTracef("ox::fs::FileStoreTemplate::read::fail", "Could not find requested item: {}", id);
+		oxTracef("ox.fs.FileStoreTemplate.read.fail", "Could not find requested item: {}", id);
 		return OxError(1, "Could not find requested item");
 	}
 
 	auto srcData = m_buffer->template dataOf<uint8_t>(src);
-	oxTracef("ox::fs::FileStoreTemplate::read::found", "{} found at {} with data section at {}",
+	oxTracef("ox.fs.FileStoreTemplate.read.found", "{} found at {} with data section at {}",
 	         id, src.offset(), srcData.offset());
-	oxTracef("ox::fs::FileStoreTemplate::read::outSize", "{} {} {}", srcData.offset(), srcData.size(), outSize);
+	oxTracef("ox.fs.FileStoreTemplate.read.outSize", "{} {} {}", srcData.offset(), srcData.size(), outSize);
 
 	// error check
 	if (!(srcData.valid() && srcData.size() <= outSize)) {
-		oxTracef("ox::fs::FileStoreTemplate::read::fail", "Could not read data section of item: {}", id);
-		oxTracef("ox::fs::FileStoreTemplate::read::fail",
+		oxTracef("ox.fs.FileStoreTemplate.read.fail", "Could not read data section of item: {}", id);
+		oxTracef("ox.fs.FileStoreTemplate.read.fail",
 		         "Item data section size: {}, Expected size: {}", srcData.size(), outSize);
 		return OxError(1);
 	}
@@ -346,23 +346,23 @@ Error FileStoreTemplate<size_t>::read(uint64_t id, void *out, FsSize_t outSize,
 
 template<typename size_t>
 Error FileStoreTemplate<size_t>::read(uint64_t id, FsSize_t readStart, FsSize_t readSize, void *out, FsSize_t *size) const {
-	oxTracef("ox::fs::FileStoreTemplate::read", "Attempting to read from inode {}", id);
+	oxTracef("ox.fs.FileStoreTemplate.read", "Attempting to read from inode {}", id);
 	auto src = find(static_cast<size_t>(id));
 	// error check
 	if (!src.valid()) {
-		oxTracef("ox::fs::FileStoreTemplate::read::fail", "Could not find requested item: {}", id);
+		oxTracef("ox.fs.FileStoreTemplate.read.fail", "Could not find requested item: {}", id);
 		return OxError(1);
 	}
 
 	auto srcData = m_buffer->template dataOf<uint8_t>(src);
-	oxTracef("ox::fs::FileStoreTemplate::read::found", "{} found at {} with data section at {}",
+	oxTracef("ox.fs.FileStoreTemplate.read.found", "{} found at {} with data section at {}",
 	         id, src.offset(), srcData.offset());
-	oxTracef("ox::fs::FileStoreTemplate::read::readSize", "{} {} {}", srcData.offset(), srcData.size(), readSize);
+	oxTracef("ox.fs.FileStoreTemplate.read.readSize", "{} {} {}", srcData.offset(), srcData.size(), readSize);
 
 	// error check
 	if (!(srcData.valid() && srcData.size() - readStart <= readSize)) {
-		oxTracef("ox::fs::FileStoreTemplate::read::fail", "Could not read data section of item: {}", id);
-		oxTracef("ox::fs::FileStoreTemplate::read::fail",
+		oxTracef("ox.fs.FileStoreTemplate.read.fail", "Could not read data section of item: {}", id);
+		oxTracef("ox.fs.FileStoreTemplate.read.fail",
 		         "Item data section size: {}, Expected size: {}", srcData.size(), readSize);
 		return OxError(1);
 	}
@@ -379,23 +379,23 @@ template<typename size_t>
 template<typename T>
 Error FileStoreTemplate<size_t>::read(uint64_t id, FsSize_t readStart,
                                       FsSize_t readSize, T *out, FsSize_t *size) const {
-	oxTracef("ox::fs::FileStoreTemplate::read", "Attempting to read from inode {}", id);
+	oxTracef("ox.fs.FileStoreTemplate.read", "Attempting to read from inode {}", id);
 	auto src = find(static_cast<size_t>(id));
 	// error check
 	if (!src.valid()) {
-		oxTracef("ox::fs::FileStoreTemplate::read::fail", "Could not find requested item: {}", id);
+		oxTracef("ox.fs.FileStoreTemplate.read.fail", "Could not find requested item: {}", id);
 		return OxError(1);
 	}
 
 	auto srcData = m_buffer->template dataOf<uint8_t>(src);
-	oxTracef("ox::fs::FileStoreTemplate::read::found", "{} found at {} with data section at {}",
+	oxTracef("ox.fs.FileStoreTemplate.read.found", "{} found at {} with data section at {}",
 	         id, src.offset(), srcData.offset());
-	oxTracef("ox::fs::FileStoreTemplate::read::readSize", "{} {} {}", srcData.offset(), srcData.size(), readSize);
+	oxTracef("ox.fs.FileStoreTemplate.read.readSize", "{} {} {}", srcData.offset(), srcData.size(), readSize);
 
 	// error check
 	if (!(srcData.valid() && srcData.size() - readStart <= readSize)) {
-		oxTracef("ox::fs::FileStoreTemplate::read::fail", "Could not read data section of item: {}", id);
-		oxTracef("ox::fs::FileStoreTemplate::read::fail",
+		oxTracef("ox.fs.FileStoreTemplate.read.fail", "Could not read data section of item: {}", id);
+		oxTracef("ox.fs.FileStoreTemplate.read.fail",
 		         "Item data section size: {}, Expected size: {}", srcData.size(), readSize);
 		return OxError(1);
 	}
@@ -422,9 +422,9 @@ template<typename size_t>
 Error FileStoreTemplate<size_t>::resize() {
 	oxReturnError(compact());
 	const auto newSize = static_cast<std::size_t>(size() - available());
-	oxTracef("ox::fs::FileStoreTemplate::resize", "resize to: {}", newSize);
+	oxTracef("ox.fs.FileStoreTemplate.resize", "resize to: {}", newSize);
 	oxReturnError(m_buffer->setSize(newSize));
-	oxTracef("ox::fs::FileStoreTemplate::resize", "resized to: {}", m_buffer->size());
+	oxTracef("ox.fs.FileStoreTemplate.resize", "resized to: {}", m_buffer->size());
 	return OxError(0);
 }
 
@@ -506,7 +506,7 @@ Error FileStoreTemplate<size_t>::compact() {
 		if (!item.valid()) {
 			return OxError(1);
 		}
-		oxTracef("ox::fs::FileStoreTemplate::compact::moveItem", "Moving Item: {} from {} to {}", item->id.get(), oldAddr, item.offset());
+		oxTracef("ox.fs.FileStoreTemplate.compact.moveItem", "Moving Item: {} from {} to {}", item->id.get(), oldAddr, item.offset());
 		// update rootInode if this is it
 		auto fsData = fileStoreData();
 		if (fsData && oldAddr == fsData->rootNode) {
@@ -549,7 +549,7 @@ Error FileStoreTemplate<size_t>::placeItem(ItemPtr item) {
 		fsData->rootNode = item;
 		item->left = root->left;
 		item->right = root->right;
-		oxTracef("ox::fs::FileStoreTemplate::placeItem", "Overwrote Root Item: {}", item->id.get());
+		oxTracef("ox.fs.FileStoreTemplate.placeItem", "Overwrote Root Item: {}", item->id.get());
 		return OxError(0);
 	} else {
 		return placeItem(root, item);
@@ -559,7 +559,7 @@ Error FileStoreTemplate<size_t>::placeItem(ItemPtr item) {
 template<typename size_t>
 Error FileStoreTemplate<size_t>::placeItem(ItemPtr root, ItemPtr item, int depth) {
 	if (depth > 5000) {
-		oxTrace("ox::fs::FileStoreTemplate::placeItem::fail", "Excessive recursion depth, stopping before stack overflow.");
+		oxTrace("ox.fs.FileStoreTemplate.placeItem.fail", "Excessive recursion depth, stopping before stack overflow.");
 		return OxError(2);
 	}
 	if (item->id > root->id) {
@@ -570,7 +570,7 @@ Error FileStoreTemplate<size_t>::placeItem(ItemPtr root, ItemPtr item, int depth
 				item->left = right->left;
 				item->right = right->right;
 			}
-			oxTracef("ox::fs::FileStoreTemplate::placeItem", "Placed Item: {}", item->id.get());
+			oxTracef("ox.fs.FileStoreTemplate.placeItem", "Placed Item: {}", item->id.get());
 			return OxError(0);
 		} else {
 			return placeItem(right, item, depth + 1);
@@ -583,13 +583,13 @@ Error FileStoreTemplate<size_t>::placeItem(ItemPtr root, ItemPtr item, int depth
 				item->left = left->left;
 				item->right = left->right;
 			}
-			oxTracef("ox::fs::FileStoreTemplate::placeItem", "Placed Item: {}", item->id.get());
+			oxTracef("ox.fs.FileStoreTemplate.placeItem", "Placed Item: {}", item->id.get());
 			return OxError(0);
 		} else {
 			return placeItem(left, item, depth + 1);
 		}
 	} else {
-		oxTrace("ox::fs::FileStoreTemplate::placeItem::fail", "Cannot insert an item on itself.");
+		oxTrace("ox.fs.FileStoreTemplate.placeItem.fail", "Cannot insert an item on itself.");
 		return OxError(1, "Cannot insert an item on itself.");
 	}
 }
@@ -631,14 +631,14 @@ Error FileStoreTemplate<size_t>::unplaceItem(ItemPtr item) {
 template<typename size_t>
 Error FileStoreTemplate<size_t>::unplaceItem(ItemPtr root, ItemPtr item, int depth) {
 	if (depth >= 5000) {
-		oxTrace("ox::fs::FileStoreTemplate::unplaceItem::fail", "Excessive recursion depth, stopping before stack overflow.");
+		oxTrace("ox.fs.FileStoreTemplate.unplaceItem.fail", "Excessive recursion depth, stopping before stack overflow.");
 		return OxError(1, "Excessive recursion depth, stopping before stack overflow.");
 	}
 	if (item->id > root->id) {
 		auto right = m_buffer->ptr(root->right);
 		if (right->id == item->id) {
 			root->right = 0;
-			oxTracef("ox::fs::FileStoreTemplate::unplaceItem", "Unplaced Item: {}", item->id.get());
+			oxTracef("ox.fs.FileStoreTemplate.unplaceItem", "Unplaced Item: {}", item->id.get());
 		} else {
 			return unplaceItem(right, item, depth + 1);
 		}
@@ -646,7 +646,7 @@ Error FileStoreTemplate<size_t>::unplaceItem(ItemPtr root, ItemPtr item, int dep
 		auto left = m_buffer->ptr(root->left);
 		if (left->id == item->id) {
 			root->left = 0;
-			oxTracef("ox::fs::FileStoreTemplate::unplaceItem", "Unplaced Item: {}", item->id.get());
+			oxTracef("ox.fs.FileStoreTemplate.unplaceItem", "Unplaced Item: {}", item->id.get());
 		} else {
 			return unplaceItem(left, item, depth + 1);
 		}
@@ -701,22 +701,22 @@ typename FileStoreTemplate<size_t>::ItemPtr FileStoreTemplate<size_t>::findParen
 template<typename size_t>
 typename FileStoreTemplate<size_t>::ItemPtr FileStoreTemplate<size_t>::find(ItemPtr item, InodeId_t id, int depth) const {
 	if (depth > 5000) {
-		oxTracef("ox::fs::FileStoreTemplate::find::fail", "Excessive recursion depth, stopping before stack overflow. Search for: {}", id);
+		oxTracef("ox.fs.FileStoreTemplate.find.fail", "Excessive recursion depth, stopping before stack overflow. Search for: {}", id);
 		return nullptr;
 	}
 	if (!item.valid()) {
-		oxTrace("ox::fs::FileStoreTemplate::find::fail", "item invalid");
+		oxTrace("ox.fs.FileStoreTemplate.find.fail", "item invalid");
 		return nullptr;
 	}
 	// do search
 	if (id > item->id) {
-		oxTracef("ox::fs::FileStoreTemplate::find", "Not a match, searching on {}", item->right.get());
+		oxTracef("ox.fs.FileStoreTemplate.find", "Not a match, searching on {}", item->right.get());
 		return find(m_buffer->ptr(item->right), id, depth + 1);
 	} else if (id < item->id) {
-		oxTracef("ox::fs::FileStoreTemplate::find", "Not a match, searching on {}", item->left.get());
+		oxTracef("ox.fs.FileStoreTemplate.find", "Not a match, searching on {}", item->left.get());
 		return find(m_buffer->ptr(item->left), id, depth + 1);
 	} else if (id == item->id) {
-		oxTracef("ox::fs::FileStoreTemplate::find", "Found {} at {}", id, item.offset());
+		oxTracef("ox.fs.FileStoreTemplate.find", "Found {} at {}", id, item.offset());
 		return item;
 	}
 	return nullptr;
@@ -724,7 +724,7 @@ typename FileStoreTemplate<size_t>::ItemPtr FileStoreTemplate<size_t>::find(Item
 
 template<typename size_t>
 typename FileStoreTemplate<size_t>::ItemPtr FileStoreTemplate<size_t>::find(InodeId_t id) const {
-	oxTracef("ox::fs::FileStoreTemplate::find", "Searching for inode: {}", id);
+	oxTracef("ox.fs.FileStoreTemplate.find", "Searching for inode: {}", id);
 	auto fsData = fileStoreData();
 	if (fsData) {
 		auto root = m_buffer->ptr(fsData->rootNode);
@@ -732,10 +732,10 @@ typename FileStoreTemplate<size_t>::ItemPtr FileStoreTemplate<size_t>::find(Inod
 			auto item = find(root, id);
 			return item;
 		} else {
-			oxTrace("ox::fs::FileStoreTemplate::find::fail", "No root node");
+			oxTrace("ox.fs.FileStoreTemplate.find.fail", "No root node");
 		}
 	} else {
-		oxTrace("ox::fs::FileStoreTemplate::find::fail", "No FileStore Data");
+		oxTrace("ox.fs.FileStoreTemplate.find.fail", "No FileStore Data");
 	}
 	return nullptr;
 }

deps/ox/src/ox/fs/filesystem/directory.hpp

@@ -55,7 +55,7 @@ struct OX_PACKED DirectoryEntry {
 		}
 
 		ptrarith::Ptr<DirectoryEntryData, InodeId_t> data() noexcept {
-			oxTracef("ox::fs::DirectoryEntry::data", "{} {} {}", this->fullSize(), sizeof(*this), this->size());
+			oxTracef("ox.fs.DirectoryEntry.data", "{} {} {}", this->fullSize(), sizeof(*this), this->size());
 			return ptrarith::Ptr<DirectoryEntryData, InodeId_t>(this, this->fullSize(), sizeof(*this), this->size(), this->size());
 		}
 
@@ -136,7 +136,7 @@ Directory<FileStore, InodeId_t>::Directory(FileStore fs, uint64_t inodeId) noexc
 template<typename FileStore, typename InodeId_t>
 Error Directory<FileStore, InodeId_t>::init() noexcept {
 	constexpr auto Size = sizeof(Buffer);
-	oxTracef("ox::fs::Directory::init", "Initializing Directory with Inode ID: {}", m_inodeId);
+	oxTracef("ox.fs.Directory.init", "Initializing Directory with Inode ID: {}", m_inodeId);
 	oxReturnError(m_fs.write(m_inodeId, nullptr, Size, static_cast<uint8_t>(FileType::Directory)));
 	auto buff = m_fs.read(m_inodeId).template to<Buffer>();
 	if (!buff.valid()) {
@@ -151,7 +151,7 @@ Error Directory<FileStore, InodeId_t>::init() noexcept {
 template<typename FileStore, typename InodeId_t>
 Error Directory<FileStore, InodeId_t>::mkdir(PathIterator path, bool parents, FileName *nameBuff) {
 	if (path.valid()) {
-		oxTrace("ox::fs::Directory::mkdir", path.fullPath());
+		oxTrace("ox.fs.Directory.mkdir", path.fullPath());
 		// reuse nameBuff if it has already been allocated, as it is a rather large variable
 		if (nameBuff == nullptr) {
 			nameBuff = new (ox_alloca(sizeof(FileName))) FileName;
@@ -168,7 +168,7 @@ Error Directory<FileStore, InodeId_t>::mkdir(PathIterator path, bool parents, Fi
 				return OxError(1);
 			}
 			childInode = m_fs.generateInodeId();
-			oxTracef("ox::fs::Directory::mkdir", "Generated Inode ID: {}", childInode.value);
+			oxTracef("ox.fs.Directory.mkdir", "Generated Inode ID: {}", childInode.value);
 			oxLogError(childInode.error);
 			oxReturnError(childInode.error);
 
@@ -204,33 +204,33 @@ Error Directory<FileStore, InodeId_t>::write(PathIterator path, uint64_t inode64
 
 	if (path.next().hasNext()) { // not yet at target directory, recurse to next one
 		oxReturnError(path.get(name));
-		oxTracef("ox::fs::Directory::write", "Attempting to write to next sub-Directory: {} of {}",
+		oxTracef("ox.fs.Directory.write", "Attempting to write to next sub-Directory: {} of {}",
 		         *name, path.fullPath());
 		oxRequire(nextChild, findEntry(*name));
-		oxTracef("ox::fs::Directory::write", "{}: {}", *name, nextChild);
+		oxTracef("ox.fs.Directory.write", "{}: {}", *name, nextChild);
 		if (nextChild) {
 			// reuse name because it is a rather large variable and will not be used again
 			// be attentive that this remains true
 			name = nullptr;
 			return Directory(m_fs, nextChild).write(path.next(), inode, nameBuff);
 		} else {
-			oxTracef("ox::fs::Directory::write", "{} not found and not allowed to create it.", *name);
+			oxTracef("ox.fs.Directory.write", "{} not found and not allowed to create it.", *name);
 			return OxError(1, "File not found and not allowed to create it.");
 		}
 	} else {
-		oxTrace("ox::fs::Directory::write", path.fullPath());
+		oxTrace("ox.fs.Directory.write", path.fullPath());
 		// insert the new entry on this directory
 
 		// get the name
 		oxReturnError(path.next(name));
 
 		// find existing version of directory
-		oxTracef("ox::fs::Directory::write", "Searching for directory inode {}", m_inodeId);
+		oxTracef("ox.fs.Directory.write", "Searching for directory inode {}", m_inodeId);
 		oxRequire(oldStat, m_fs.stat(m_inodeId));
-		oxTracef("ox::fs::Directory::write", "Found existing directory of size {}", oldStat.size);
+		oxTracef("ox.fs.Directory.write", "Found existing directory of size {}", oldStat.size);
 		auto old = m_fs.read(m_inodeId).template to<Buffer>();
 		if (!old.valid()) {
-			oxTrace("ox::fs::Directory::write::fail", "Could not read existing version of Directory");
+			oxTrace("ox.fs.Directory.write.fail", "Could not read existing version of Directory");
 			return OxError(1, "Could not read existing version of Directory");
 		}
 
@@ -239,20 +239,20 @@ Error Directory<FileStore, InodeId_t>::write(PathIterator path, uint64_t inode64
 		const auto newSize = oldStat.size + Buffer::spaceNeeded(entryDataSize);
 		auto cpy = ox_malloca(newSize, Buffer, *old, oldStat.size);
 		if (cpy == nullptr) {
-			oxTrace("ox::fs::Directory::write::fail", "Could not allocate memory for copy of Directory");
+			oxTrace("ox.fs.Directory.write.fail", "Could not allocate memory for copy of Directory");
 			return OxError(1, "Could not allocate memory for copy of Directory");
 		}
 
 		oxReturnError(cpy->setSize(newSize));
 		auto val = cpy->malloc(entryDataSize).value;
 		if (!val.valid()) {
-			oxTrace("ox::fs::Directory::write::fail", "Could not allocate memory for new directory entry");
+			oxTrace("ox.fs.Directory.write.fail", "Could not allocate memory for new directory entry");
 			return OxError(1, "Could not allocate memory for new directory entry");
 		}
 
-		oxTracef("ox::fs::Directory::write", "Attempting to write Directory entry: {}", name->data());
+		oxTracef("ox.fs.Directory.write", "Attempting to write Directory entry: {}", name->data());
 		oxReturnError(val->init(inode, name->data(), val.size()));
-		return m_fs.write(m_inodeId, cpy, cpy->size(), static_cast<uint8_t>(FileType::Directory));
+		return m_fs.write(m_inodeId, cpy.get(), cpy->size(), static_cast<uint8_t>(FileType::Directory));
 	}
 }
 
@@ -265,10 +265,10 @@ Error Directory<FileStore, InodeId_t>::remove(PathIterator path, FileName *nameB
 	auto &name = *nameBuff;
 	oxReturnError(path.get(&name));
 
-	oxTrace("ox::fs::Directory::remove", name);
+	oxTrace("ox.fs.Directory.remove", name);
 	auto buff = m_fs.read(m_inodeId).template to<Buffer>();
 	if (buff.valid()) {
-		oxTrace("ox::fs::Directory::remove", "Found directory buffer.");
+		oxTrace("ox.fs.Directory.remove", "Found directory buffer.");
 		for (auto i = buff->iterator(); i.valid(); i.next()) {
 			auto data = i->data();
 			if (data.valid()) {
@@ -276,11 +276,11 @@ Error Directory<FileStore, InodeId_t>::remove(PathIterator path, FileName *nameB
 					oxReturnError(buff->free(i));
 				}
 			} else {
-				oxTrace("ox::fs::Directory::remove", "INVALID DIRECTORY ENTRY");
+				oxTrace("ox.fs.Directory.remove", "INVALID DIRECTORY ENTRY");
 			}
 		}
 	} else {
-		oxTrace("ox::fs::Directory::remove::fail", "Could not find directory buffer");
+		oxTrace("ox.fs.Directory.remove.fail", "Could not find directory buffer");
 		return OxError(1, "Could not find directory buffer");
 	}
 	return OxError(0);
@@ -289,20 +289,20 @@ Error Directory<FileStore, InodeId_t>::remove(PathIterator path, FileName *nameB
 template<typename FileStore, typename InodeId_t>
 template<typename F>
 Error Directory<FileStore, InodeId_t>::ls(F cb) noexcept {
-	oxTrace("ox::fs::Directory::ls");
+	oxTrace("ox.fs.Directory.ls");
 	auto buff = m_fs.read(m_inodeId).template to<Buffer>();
 	if (!buff.valid()) {
-		oxTrace("ox::fs::Directory::ls::fail", "Could not directory buffer");
+		oxTrace("ox.fs.Directory.ls.fail", "Could not directory buffer");
 		return OxError(1, "Could not directory buffer");
 	}
 
-	oxTrace("ox::fs::Directory::ls", "Found directory buffer.");
+	oxTrace("ox.fs.Directory.ls", "Found directory buffer.");
 	for (auto i = buff->iterator(); i.valid(); i.next()) {
 		auto data = i->data();
 		if (data.valid()) {
 			oxReturnError(cb(data->name, data->inode));
 		} else {
-			oxTrace("ox::fs::Directory::ls", "INVALID DIRECTORY ENTRY");
+			oxTrace("ox.fs.Directory.ls", "INVALID DIRECTORY ENTRY");
 		}
 	}
 
@@ -311,26 +311,26 @@ Error Directory<FileStore, InodeId_t>::ls(F cb) noexcept {
 
 template<typename FileStore, typename InodeId_t>
 Result<typename FileStore::InodeId_t> Directory<FileStore, InodeId_t>::findEntry(const FileName &name) const noexcept {
-	oxTrace("ox::fs::Directory::findEntry", name);
+	oxTrace("ox.fs.Directory.findEntry", name);
 	auto buff = m_fs.read(m_inodeId).template to<Buffer>();
 	if (!buff.valid()) {
-		oxTrace("ox::fs::Directory::findEntry::fail", "Could not findEntry directory buffer");
+		oxTrace("ox.fs.Directory.findEntry.fail", "Could not findEntry directory buffer");
 		return OxError(2, "Could not findEntry directory buffer");
 	}
-	oxTracef("ox::fs::Directory::findEntry", "Found directory buffer, size: {}", buff.size());
+	oxTracef("ox.fs.Directory.findEntry", "Found directory buffer, size: {}", buff.size());
 	for (auto i = buff->iterator(); i.valid(); i.next()) {
 		auto data = i->data();
 		if (data.valid()) {
-			oxTracef("ox::fs::Directory::findEntry", "Comparing \"{}\" to \"{}\"", name, data->name);
+			oxTracef("ox.fs.Directory.findEntry", "Comparing \"{}\" to \"{}\"", name, data->name);
 			if (name == data->name) {
-				oxTracef("ox::fs::Directory::findEntry", "\"{}\" match found.", name);
+				oxTracef("ox.fs.Directory.findEntry", "\"{}\" match found.", name);
 				return static_cast<InodeId_t>(data->inode);
 			}
 		} else {
-			oxTrace("ox::fs::Directory::findEntry") << "INVALID DIRECTORY ENTRY";
+			oxTrace("ox.fs.Directory.findEntry") << "INVALID DIRECTORY ENTRY";
 		}
 	}
-	oxTrace("ox::fs::Directory::findEntry::fail", "Entry not present");
+	oxTrace("ox.fs.Directory.findEntry.fail", "Entry not present");
 	return OxError(1, "Entry not present");
 }
 

deps/ox/src/ox/fs/filesystem/filelocation.cpp

@@ -36,13 +36,6 @@ FileAddress::FileAddress(ox::CRStringView path) noexcept {
 	m_type = FileAddressType::Path;
 }
 
-FileAddress::FileAddress(char *path) noexcept {
-	auto pathSize = ox_strlen(path) + 1;
-	m_data.path = new char[pathSize];
-	memcpy(m_data.path, path, pathSize);
-	m_type = FileAddressType::Path;
-}
-
 FileAddress &FileAddress::operator=(const FileAddress &other) noexcept {
 	if (this == &other) {
 		return *this;
@@ -52,9 +45,14 @@ FileAddress &FileAddress::operator=(const FileAddress &other) noexcept {
 	switch (m_type) {
 		case FileAddressType::Path:
 		{
-			auto strSize = ox_strlen(other.m_data.path) + 1;
-			m_data.path = new char[strSize];
-			ox_memcpy(m_data.path, other.m_data.path, strSize);
+			if (other.m_data.path) {
+				auto strSize = ox_strlen(other.m_data.path) + 1;
+				m_data.path = new char[strSize];
+				ox_memcpy(m_data.path, other.m_data.path, strSize);
+			} else {
+				m_data.constPath = "";
+				m_type = FileAddressType::ConstPath;
+			}
 			break;
 		}
 		case FileAddressType::ConstPath:

deps/ox/src/ox/fs/filesystem/filelocation.hpp

@@ -25,7 +25,7 @@ enum class FileAddressType: int8_t {
 class FileAddress {
 
 	template<typename T>
-	friend constexpr Error model(T*, CommonPtrWith<FileAddress> auto*) noexcept;
+	friend constexpr Error model(T *h, CommonPtrWith<FileAddress> auto *fa) noexcept;
 
 	public:
 		static constexpr auto TypeName = "net.drinkingtea.ox.FileAddress";
@@ -59,13 +59,7 @@ class FileAddress {
 
 		explicit FileAddress(CRStringView path) noexcept;
 
-		template<std::size_t SmallStrSz>
-		explicit FileAddress(const ox::BasicString<SmallStrSz> &path) noexcept: FileAddress(StringView(path)) {
-		}
-
-		explicit FileAddress(char *path) noexcept;
-
-		explicit constexpr FileAddress(const char *path) noexcept;
+		constexpr FileAddress(ox::StringLiteral path) noexcept;
 
 		constexpr ~FileAddress() noexcept;
 
@@ -86,7 +80,6 @@ class FileAddress {
 			}
 		}
 
-		[[nodiscard]]
 		constexpr Result<uint64_t> getInode() const noexcept {
 			switch (m_type) {
 				case FileAddressType::Inode:
@@ -96,12 +89,12 @@ class FileAddress {
 			}
 		}
 
-		constexpr Result<const char*> getPath() const noexcept {
+		constexpr Result<ox::StringView> getPath() const noexcept {
 			switch (m_type) {
 				case FileAddressType::Path:
-					return m_data.path;
+					return ox::StringView(m_data.path);
 				case FileAddressType::ConstPath:
-					return m_data.constPath;
+					return ox::StringView(m_data.constPath);
 				default:
 					return OxError(1);
 			}
@@ -124,8 +117,8 @@ class FileAddress {
 
 };
 
-constexpr FileAddress::FileAddress(const char *path) noexcept {
-	m_data.constPath = path;
+constexpr FileAddress::FileAddress(ox::StringLiteral path) noexcept {
+	m_data.constPath = path.c_str();
 	m_type = FileAddressType::ConstPath;
 }
 
@@ -133,45 +126,6 @@ constexpr FileAddress::~FileAddress() noexcept {
 	cleanup();
 }
 
-template<>
-constexpr const char *getModelTypeName<FileAddress::Data>() noexcept {
-	return FileAddress::Data::TypeName;
-}
-
-template<>
-constexpr const char *getModelTypeName<FileAddress>() noexcept {
-	return FileAddress::TypeName;
-}
-
-template<typename T>
-constexpr Error model(T *io, CommonPtrWith<FileAddress::Data> auto *obj) noexcept {
-	oxReturnError(io->template setTypeInfo<FileAddress::Data>());
-	oxReturnError(io->fieldCString("path", &obj->path));
-	oxReturnError(io->fieldCString("constPath", &obj->path));
-	oxReturnError(io->field("inode", &obj->inode));
-	return OxError(0);
-}
-
-template<typename T>
-constexpr Error model(T *io, CommonPtrWith<FileAddress> auto *fa) noexcept {
-	oxReturnError(io->template setTypeInfo<FileAddress>());
-	if constexpr(T::opType() == OpType::Reflect) {
-		int8_t type = 0;
-		oxReturnError(io->field("type", &type));
-		oxReturnError(io->field("data", UnionView(&fa->m_data, 0)));
-	} else if constexpr(T::opType() == OpType::Read) {
-		auto type = static_cast<int8_t>(fa->m_type);
-		oxReturnError(io->field("type", &type));
-		fa->m_type = static_cast<FileAddressType>(type);
-		oxReturnError(io->field("data", UnionView(&fa->m_data, static_cast<int>(fa->m_type))));
-	} else if constexpr(T::opType() == OpType::Write) {
-		auto type = static_cast<int8_t>(fa->m_type);
-		oxReturnError(io->field("type", &type));
-		oxReturnError(io->field("data", UnionView(&fa->m_data, static_cast<int>(fa->m_type))));
-	}
-	return OxError(0);
-}
-
 constexpr void FileAddress::cleanup() noexcept {
 	if (m_type == FileAddressType::Path) {
 		safeDeleteArray(m_data.path);
@@ -184,4 +138,43 @@ constexpr void FileAddress::clear() noexcept {
 	m_type = FileAddressType::None;
 }
 
+template<>
+constexpr const char *getModelTypeName<FileAddress::Data>() noexcept {
+	return FileAddress::Data::TypeName;
+}
+
+template<>
+constexpr const char *getModelTypeName<FileAddress>() noexcept {
+	return FileAddress::TypeName;
+}
+
+template<typename T>
+constexpr Error model(T *h, CommonPtrWith<FileAddress::Data> auto *obj) noexcept {
+	oxReturnError(h->template setTypeInfo<FileAddress::Data>());
+	oxReturnError(h->fieldCString("path", &obj->path));
+	oxReturnError(h->fieldCString("constPath", &obj->path));
+	oxReturnError(h->field("inode", &obj->inode));
+	return {};
+}
+
+template<typename T>
+constexpr Error model(T *h, CommonPtrWith<FileAddress> auto *fa) noexcept {
+	oxReturnError(h->template setTypeInfo<FileAddress>());
+	if constexpr(T::opType() == OpType::Reflect) {
+		int8_t type = -1;
+		oxReturnError(h->field("type", &type));
+		oxReturnError(h->field("data", UnionView(&fa->m_data, type)));
+	} else if constexpr(T::opType() == OpType::Read) {
+		auto type = static_cast<int8_t>(fa->m_type);
+		oxReturnError(h->field("type", &type));
+		fa->m_type = static_cast<FileAddressType>(type);
+		oxReturnError(h->field("data", UnionView(&fa->m_data, static_cast<int>(fa->m_type))));
+	} else if constexpr(T::opType() == OpType::Write) {
+		auto const type = static_cast<int8_t>(fa->m_type);
+		oxReturnError(h->field("type", &type));
+		oxReturnError(h->field("data", UnionView(&fa->m_data, static_cast<int>(fa->m_type))));
+	}
+	return {};
+}
+
 }

deps/ox/src/ox/fs/filesystem/filesystem.hpp

@@ -9,6 +9,7 @@
 #pragma once
 
 #include <ox/std/buffer.hpp>
+#include <ox/std/span.hpp>
 
 #include <ox/fs/filestore/filestoretemplate.hpp>
 #include <ox/fs/filesystem/filelocation.hpp>
@@ -66,10 +67,18 @@ class FileSystem {
 			return writeFilePath(path, buffer, size, FileType::NormalFile);
 		}
 
+		Error write(CRStringView path, ox::Span<char> const&buff) noexcept {
+			return write(path, buff.data(), buff.size(), FileType::NormalFile);
+		}
+
 		Error write(uint64_t inode, const void *buffer, uint64_t size) noexcept {
 			return write(inode, buffer, size, FileType::NormalFile);
 		}
 
+		Error write(uint64_t inode, ox::Span<char> const&buff) noexcept {
+			return write(inode, buff.data(), buff.size(), FileType::NormalFile);
+		}
+
 		Error write(const FileAddress &addr, const void *buffer, uint64_t size, FileType fileType = FileType::NormalFile) noexcept;
 
 		inline Error write(CRStringView path, const void *buffer, uint64_t size, FileType fileType) noexcept {
@@ -165,6 +174,8 @@ class FileSystemTemplate: public MemFS {
 
 		FileSystemTemplate(void *buffer, uint64_t bufferSize, void(*freeBuffer)(char*) = detail::fsBuffFree) noexcept;
 
+		explicit FileSystemTemplate(ox::Buffer &buffer) noexcept;
+
 		explicit FileSystemTemplate(FileStore fs) noexcept;
 
 		~FileSystemTemplate() noexcept override;
@@ -238,6 +249,11 @@ FileSystemTemplate<FileStore, Directory>::FileSystemTemplate(FileStore fs) noexc
 	m_fs = fs;
 }
 
+template<typename FileStore, typename Directory>
+FileSystemTemplate<FileStore, Directory>::FileSystemTemplate(ox::Buffer &buffer) noexcept:
+		m_fs(buffer.data(), static_cast<std::size_t>(buffer.size())) {
+}
+
 template<typename FileStore, typename Directory>
 FileSystemTemplate<FileStore, Directory>::FileSystemTemplate(void *buffer, uint64_t bufferSize, void(*freeBuffer)(char*)) noexcept:
 	m_fs(buffer, static_cast<std::size_t>(bufferSize)),
@@ -262,11 +278,11 @@ Error FileSystemTemplate<FileStore, Directory>::format(void *buff, uint64_t buff
 
 	FileSystemData fd;
 	fd.rootDirInode = rootDirInode;
-	oxTracef("ox::fs::FileSystemTemplate::format", "rootDirInode: {}", fd.rootDirInode.get());
+	oxTracef("ox.fs.FileSystemTemplate.format", "rootDirInode: {}", fd.rootDirInode.get());
 	oxReturnError(fs.write(InodeFsData, &fd, sizeof(fd)));
 
 	if (!fs.read(fd.rootDirInode).valid()) {
-		oxTrace("ox::fs::FileSystemTemplate::format::error", "FileSystemTemplate::format did not correctly create root directory");
+		oxTrace("ox.fs.FileSystemTemplate.format.error", "FileSystemTemplate::format did not correctly create root directory");
 		return OxError(1);
 	}
 
@@ -275,7 +291,7 @@ Error FileSystemTemplate<FileStore, Directory>::format(void *buff, uint64_t buff
 
 template<typename FileStore, typename Directory>
 Error FileSystemTemplate<FileStore, Directory>::mkdir(CRStringView path, bool recursive) noexcept {
-	oxTracef("ox::fs::FileSystemTemplate::mkdir", "path: {}, recursive: {}", path, recursive);
+	oxTracef("ox.fs.FileSystemTemplate.mkdir", "path: {}, recursive: {}", path, recursive);
 	oxRequireM(rootDir, this->rootDir());
 	return rootDir.mkdir(path, recursive);
 }
@@ -345,7 +361,7 @@ Result<Vector<String>> FileSystemTemplate<FileStore, Directory>::ls(CRStringView
 template<typename FileStore, typename Directory>
 template<typename F>
 Error FileSystemTemplate<FileStore, Directory>::ls(CRStringView path, F cb) const {
-	oxTracef("ox::fs::FileSystemTemplate::ls", "path: {}", path);
+	oxTracef("ox.fs.FileSystemTemplate.ls", "path: {}", path);
 	oxRequire(s, stat(path));
 	Directory dir(m_fs, s.inode);
 	return dir.ls(cb);
@@ -364,7 +380,7 @@ Error FileSystemTemplate<FileStore, Directory>::remove(CRStringView path, bool r
 			return err;
 		}
 	} else {
-		oxTrace("FileSystemTemplate::remove::fail", "Tried to remove directory without recursive setting.");
+		oxTrace("FileSystemTemplate.remove.fail", "Tried to remove directory without recursive setting.");
 		return OxError(1);
 	}
 	return OxError(0);

deps/ox/src/ox/fs/filesystem/passthroughfs.cpp

@@ -24,14 +24,14 @@ PassThroughFS::PassThroughFS(CRStringView dirPath) {
 PassThroughFS::~PassThroughFS() noexcept = default;
 
 String PassThroughFS::basePath() const noexcept {
-	return m_path.string().c_str();
+	return ox::String(m_path.string().c_str());
 }
 
 Error PassThroughFS::mkdir(CRStringView path, bool recursive) noexcept {
 	bool success = false;
 	const auto p = m_path / stripSlash(path);
 	const auto u8p = p.u8string();
-	oxTrace("ox::fs::PassThroughFS::mkdir", std::bit_cast<const char*>(u8p.c_str()));
+	oxTrace("ox.fs.PassThroughFS.mkdir", std::bit_cast<const char*>(u8p.c_str()));
 	if (recursive) {
 		std::error_code ec;
 		const auto isDir = std::filesystem::is_directory(p, ec);
@@ -98,10 +98,10 @@ Result<FileStat> PassThroughFS::statPath(CRStringView path) const noexcept {
 	const auto p = m_path / stripSlash(path);
 	const FileType type = std::filesystem::is_directory(p, ec) ?
 		FileType::Directory : FileType::NormalFile;
-	oxTracef("ox::fs::PassThroughFS::statInode", "{} {}", ec.message(), path);
+	oxTracef("ox.fs.PassThroughFS.statInode", "{} {}", ec.message(), path);
 	const uint64_t size = type == FileType::Directory ? 0 : std::filesystem::file_size(p, ec);
-	oxTracef("ox::fs::PassThroughFS::statInode", "{} {}", ec.message(), path);
-	oxTracef("ox::fs::PassThroughFS::statInode::size", "{} {}", path, size);
+	oxTracef("ox.fs.PassThroughFS.statInode", "{} {}", ec.message(), path);
+	oxTracef("ox.fs.PassThroughFS.statInode.size", "{} {}", path, size);
 	oxReturnError(OxError(static_cast<ox::ErrorCode>(ec.value()), "PassThroughFS: stat failed"));
 	return FileStat{0, 0, size, type};
 }
@@ -147,12 +147,12 @@ Error PassThroughFS::readFilePath(CRStringView path, void *buffer, std::size_t b
 		const std::size_t size = static_cast<std::size_t>(file.tellg());
 		file.seekg(0, std::ios::beg);
 		if (size > buffSize) {
-			oxTracef("ox::fs::PassThroughFS::read::error", "Read failed: Buffer too small: {}", path);
+			oxTracef("ox.fs.PassThroughFS.read.error", "Read failed: Buffer too small: {}", path);
 			return OxError(1);
 		}
 		file.read(static_cast<char*>(buffer), static_cast<std::streamsize>(buffSize));
 	} catch (const std::fstream::failure &f) {
-		oxTracef("ox::fs::PassThroughFS::read::error", "Read of {} failed: {}", path, f.what());
+		oxTracef("ox.fs.PassThroughFS.read.error", "Read of {} failed: {}", path, f.what());
 		return OxError(2);
 	}
 	return OxError(0);
@@ -174,7 +174,7 @@ Error PassThroughFS::writeFilePath(CRStringView path, const void *buffer, uint64
 		std::ofstream f(p, std::ios::binary);
 		f.write(static_cast<const char*>(buffer), static_cast<std::streamsize>(size));
 	} catch (const std::fstream::failure &f) {
-		oxTracef("ox::fs::PassThroughFS::read::error", "Write of {} failed: {}", path, f.what());
+		oxTracef("ox.fs.PassThroughFS.read.error", "Write of {} failed: {}", path, f.what());
 		return OxError(1);
 	}
 	return OxError(0);
@@ -188,7 +188,7 @@ Error PassThroughFS::writeFileInode(uint64_t, const void*, uint64_t, FileType) n
 std::string_view PassThroughFS::stripSlash(StringView path) noexcept {
 	const auto pathLen = ox_strlen(path);
 	for (auto i = 0u; i < pathLen && path[0] == '/'; i++) {
-		path = path.substr(1);
+		path = substr(path, 1);
 	}
 	return {path.data(), path.bytes()};
 }

deps/ox/src/ox/fs/filesystem/pathiterator.cpp

@@ -64,11 +64,11 @@ Error PathIterator::fileName(char *out, std::size_t outSize) {
 Error PathIterator::get(char *pathOut, std::size_t pathOutSize) {
 	std::size_t size = 0;
 	if (m_iterator >= m_maxSize) {
-		oxTracef("ox::fs::PathIterator::get", "m_iterator ({}) >= m_maxSize ({})", m_iterator, m_maxSize);
+		oxTracef("ox.fs.PathIterator.get", "m_iterator ({}) >= m_maxSize ({})", m_iterator, m_maxSize);
 		return OxError(1);
 	}
 	if (!ox_strlen(&m_path[m_iterator])) {
-		oxTrace("ox::fs::PathIterator::get", "!ox_strlen(&m_path[m_iterator])");
+		oxTrace("ox.fs.PathIterator.get", "!ox_strlen(&m_path[m_iterator])");
 		return OxError(1);
 	}
 	auto start = m_iterator;

deps/ox/src/ox/fs/ptrarith/nodebuffer.hpp

@@ -37,7 +37,7 @@ class OX_PACKED NodeBuffer {
 				Iterator(NodeBuffer *buffer, ItemPtr current) noexcept {
 					m_buffer = buffer;
 					m_current = current;
-					oxTrace("ox::ptrarith::Iterator::start") << current.offset();
+					oxTrace("ox.ptrarith.Iterator.start") << current.offset();
 				}
 
 				operator const Item*() const noexcept {
@@ -77,7 +77,7 @@ class OX_PACKED NodeBuffer {
 				[[nodiscard]]
 				bool hasNext() noexcept {
 					if (m_current.valid()) {
-						oxTrace("ox::ptrarith::NodeBuffer::Iterator::hasNext::current") << m_current.offset();
+						oxTrace("ox.ptrarith.NodeBuffer.Iterator.hasNext.current") << m_current.offset();
 						auto next = m_buffer->next(m_current);
 						return next.valid() && m_buffer->firstItem() != next;
 					}
@@ -85,7 +85,7 @@ class OX_PACKED NodeBuffer {
 				}
 
 				void next() noexcept {
-					oxTrace("ox::ptrarith::NodeBuffer::Iterator::next") << m_it++;
+					oxTrace("ox.ptrarith.NodeBuffer.Iterator.next") << m_it++;
 					if (hasNext()) {
 						m_current = m_buffer->next(m_current);
 					} else {
@@ -174,12 +174,12 @@ template<typename size_t, typename Item>
 NodeBuffer<size_t, Item>::NodeBuffer(std::size_t size) noexcept {
 	m_header.size = static_cast<size_t>(size);
 	ox_memset(this + 1, 0, size - sizeof(*this));
-	oxTracef("ox::NodeBuffer::constructor", "{}", m_header.firstItem.get());
+	oxTracef("ox.NodeBuffer.constructor", "{}", m_header.firstItem.get());
 }
 
 template<typename size_t, typename Item>
 NodeBuffer<size_t, Item>::NodeBuffer(const NodeBuffer &other, std::size_t size) noexcept {
-	oxTracef("ox::ptrarith::NodeBuffer::copy", "other.m_header.firstItem: {}", other.m_header.firstItem.get());
+	oxTracef("ox.ptrarith.NodeBuffer.copy", "other.m_header.firstItem: {}", other.m_header.firstItem.get());
 	ox_memset(this + 1, 0, size - sizeof(*this));
 	ox_memcpy(this, &other, size);
 }
@@ -191,7 +191,7 @@ const typename NodeBuffer<size_t, Item>::Iterator NodeBuffer<size_t, Item>::iter
 
 template<typename size_t, typename Item>
 typename NodeBuffer<size_t, Item>::Iterator NodeBuffer<size_t, Item>::iterator() noexcept {
-	oxTracef("ox::ptrarith::NodeBuffer::iterator::size", "{}", m_header.size.get());
+	oxTracef("ox.ptrarith.NodeBuffer.iterator.size", "{}", m_header.size.get());
 	return Iterator(this, firstItem());
 }
 
@@ -267,7 +267,7 @@ typename NodeBuffer<size_t, Item>::ItemPtr NodeBuffer<size_t, Item>::ptr(size_t
 template<typename size_t, typename Item>
 Result<typename NodeBuffer<size_t, Item>::ItemPtr> NodeBuffer<size_t, Item>::malloc(std::size_t size) noexcept {
 	const auto sz = static_cast<std::size_t>(size);
-	oxTracef("ox::ptrarith::NodeBuffer::malloc", "Size: {}", sz);
+	oxTracef("ox.ptrarith.NodeBuffer.malloc", "Size: {}", sz);
 	size_t fullSize = static_cast<size_t>(sz + sizeof(Item));
 	if (m_header.size - m_header.bytesUsed >= fullSize) {
 		auto last = lastItem();
@@ -277,18 +277,18 @@ Result<typename NodeBuffer<size_t, Item>::ItemPtr> NodeBuffer<size_t, Item>::mal
 		} else {
 			// there is no first item, so this must be the first item
 			if (!m_header.firstItem) {
-				oxTrace("ox::ptrarith::NodeBuffer::malloc", "No first item, initializing.");
+				oxTrace("ox.ptrarith.NodeBuffer.malloc", "No first item, initializing.");
 				m_header.firstItem = static_cast<size_t>(sizeof(m_header));
 				addr = m_header.firstItem;
 			} else {
-				oxTrace("ox::ptrarith::NodeBuffer::malloc::fail", "NodeBuffer is in invalid state.");
+				oxTrace("ox.ptrarith.NodeBuffer.malloc.fail", "NodeBuffer is in invalid state.");
 				return OxError(1, "NodeBuffer is in invalid state.");
 			}
 		}
-		oxTracef("ox::ptrarith::NodeBuffer::malloc", "buffer size: {}; addr: {}; fullSize: {}", m_header.size.get(), addr, fullSize);
+		oxTracef("ox.ptrarith.NodeBuffer.malloc", "buffer size: {}; addr: {}; fullSize: {}", m_header.size.get(), addr, fullSize);
 		auto out = ItemPtr(this, m_header.size, addr, fullSize);
 		if (!out.valid()) {
-			oxTrace("ox::ptrarith::NodeBuffer::malloc::fail", "Unknown");
+			oxTrace("ox.ptrarith.NodeBuffer.malloc.fail", "Unknown");
 			return OxError(1, "NodeBuffer::malloc: unknown failure");
 		}
 		ox_memset(out, 0, fullSize);
@@ -301,7 +301,7 @@ Result<typename NodeBuffer<size_t, Item>::ItemPtr> NodeBuffer<size_t, Item>::mal
 		if (first.valid()) {
 			first->prev = out.offset();
 		} else {
-			oxTrace("ox::ptrarith::NodeBuffer::malloc::fail", "NodeBuffer malloc failed due to invalid first element pointer.");
+			oxTrace("ox.ptrarith.NodeBuffer.malloc.fail", "NodeBuffer malloc failed due to invalid first element pointer.");
 			return OxError(1, "NodeBuffer malloc failed due to invalid first element pointer.");
 		}
 
@@ -311,22 +311,22 @@ Result<typename NodeBuffer<size_t, Item>::ItemPtr> NodeBuffer<size_t, Item>::mal
 		} else { // check to see if this is the first allocation
 			if (out.offset() != first.offset()) {
 				// if this is not the first allocation, there should be an oldLast
-				oxTrace("ox::ptrarith::NodeBuffer::malloc::fail", "NodeBuffer malloc failed due to invalid last element pointer.");
+				oxTrace("ox.ptrarith.NodeBuffer.malloc.fail", "NodeBuffer malloc failed due to invalid last element pointer.");
 				return OxError(1, "NodeBuffer malloc failed due to invalid last element pointer.");
 			}
 			out->prev = out.offset();
 		}
 		m_header.bytesUsed += out.size();
-		oxTracef("ox::ptrarith::NodeBuffer::malloc", "Offset: {}", out.offset());
+		oxTracef("ox.ptrarith.NodeBuffer.malloc", "Offset: {}", out.offset());
 		return out;
 	}
-	oxTracef("ox::ptrarith::NodeBuffer::malloc::fail", "Insufficient space: {} needed, {} available", fullSize, available());
+	oxTracef("ox.ptrarith.NodeBuffer.malloc.fail", "Insufficient space: {} needed, {} available", fullSize, available());
 	return OxError(1);
 }
 
 template<typename size_t, typename Item>
 Error NodeBuffer<size_t, Item>::free(ItemPtr item) noexcept {
-	oxTracef("ox::ptrarith::NodeBuffer::free", "offset: {}", item.offset());
+	oxTracef("ox.ptrarith.NodeBuffer.free", "offset: {}", item.offset());
 	auto prev = this->prev(item);
 	auto next = this->next(item);
 	if (prev.valid() && next.valid()) {
@@ -338,16 +338,16 @@ Error NodeBuffer<size_t, Item>::free(ItemPtr item) noexcept {
 			}
 		} else {
 			// only one item, null out first
-			oxTrace("ox::ptrarith::NodeBuffer::free", "Nulling out firstItem.");
+			oxTrace("ox.ptrarith.NodeBuffer.free", "Nulling out firstItem.");
 			m_header.firstItem = 0;
 		}
 	} else {
 		if (!prev.valid()) {
-			oxTracef("ox::ptrarith::NodeBuffer::free::fail", "NodeBuffer free failed due to invalid prev element pointer: {}", prev.offset());
+			oxTracef("ox.ptrarith.NodeBuffer.free.fail", "NodeBuffer free failed due to invalid prev element pointer: {}", prev.offset());
 			return OxError(1);
 		}
 		if (!next.valid()) {
-			oxTracef("ox::ptrarith::NodeBuffer::free::fail", "NodeBuffer free failed due to invalid next element pointer: {}", next.offset());
+			oxTracef("ox.ptrarith.NodeBuffer.free.fail", "NodeBuffer free failed due to invalid next element pointer: {}", next.offset());
 			return OxError(1);
 		}
 	}
@@ -357,10 +357,10 @@ Error NodeBuffer<size_t, Item>::free(ItemPtr item) noexcept {
 
 template<typename size_t, typename Item>
 Error NodeBuffer<size_t, Item>::setSize(std::size_t size) noexcept {
-	oxTracef("ox::ptrarith::NodeBuffer::setSize", "{} to {}", m_header.size.get(), size);
+	oxTracef("ox.ptrarith.NodeBuffer.setSize", "{} to {}", m_header.size.get(), size);
 	auto last = lastItem();
 	auto end = last.valid() ? last.end() : sizeof(m_header);
-	oxTracef("ox::ptrarith::NodeBuffer::setSize", "end: {}", end);
+	oxTracef("ox.ptrarith.NodeBuffer.setSize", "end: {}", end);
 	if (end > size) {
 		// resizing to less than buffer size
 		return OxError(1);

deps/ox/src/ox/fs/ptrarith/ptr.hpp

@@ -224,7 +224,7 @@ constexpr const Ptr<SubT, size_t, sizeof(T)> Ptr<T, size_t, minOffset>::subPtr(s
 template<typename T, typename size_t, size_t minOffset>
 template<typename SubT>
 constexpr const Ptr<SubT, size_t, sizeof(T)> Ptr<T, size_t, minOffset>::subPtr(size_t offset) const noexcept {
-	oxTracef("ox::fs::Ptr::subPtr", "{} {} {} {} {}", m_itemOffset, this->size(), offset, m_itemSize, (m_itemSize - offset));
+	oxTracef("ox.fs.Ptr.subPtr", "{} {} {} {} {}", m_itemOffset, this->size(), offset, m_itemSize, (m_itemSize - offset));
 	return subPtr<SubT>(offset, m_itemSize - offset);
 }
 
@@ -237,7 +237,7 @@ constexpr Ptr<SubT, size_t, sizeof(T)> Ptr<T, size_t, minOffset>::subPtr(size_t
 template<typename T, typename size_t, size_t minOffset>
 template<typename SubT>
 constexpr Ptr<SubT, size_t, sizeof(T)> Ptr<T, size_t, minOffset>::subPtr(size_t offset) noexcept {
-	oxTracef("ox::fs::Ptr::subPtr", "{} {} {} {} {}", m_itemOffset, this->size(), offset, m_itemSize, (m_itemSize - offset));
+	oxTracef("ox.fs.Ptr.subPtr", "{} {} {} {} {}", m_itemOffset, this->size(), offset, m_itemSize, (m_itemSize - offset));
 	return subPtr<SubT>(offset, m_itemSize - offset);
 }
 

deps/ox/src/ox/fs/test/CMakeLists.txt

@@ -6,24 +6,23 @@ add_executable(
 target_link_libraries(
 	FSTests
 		OxFS
-		OxStd
 		OxMetalClaw
 )
 
-add_test("[ox/fs] PtrArith::setSize" FSTests PtrArith::setSize)
+add_test("[ox/fs] PtrArith::setSize" ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/FSTests PtrArith::setSize)
 
-add_test("[ox/fs] PathIterator::next1" FSTests PathIterator::next1)
-add_test("[ox/fs] PathIterator::next2" FSTests PathIterator::next2)
-add_test("[ox/fs] PathIterator::next3" FSTests PathIterator::next3)
-add_test("[ox/fs] PathIterator::next4" FSTests PathIterator::next4)
-add_test("[ox/fs] PathIterator::next5" FSTests PathIterator::next5)
-add_test("[ox/fs] PathIterator::hasNext" FSTests PathIterator::hasNext)
+add_test("[ox/fs] PathIterator::next1" ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/FSTests PathIterator::next1)
+add_test("[ox/fs] PathIterator::next2" ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/FSTests PathIterator::next2)
+add_test("[ox/fs] PathIterator::next3" ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/FSTests PathIterator::next3)
+add_test("[ox/fs] PathIterator::next4" ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/FSTests PathIterator::next4)
+add_test("[ox/fs] PathIterator::next5" ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/FSTests PathIterator::next5)
+add_test("[ox/fs] PathIterator::hasNext" ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/FSTests PathIterator::hasNext)
 
-add_test("[ox/fs] PathIterator::dirPath" FSTests PathIterator::dirPath)
-add_test("[ox/fs] PathIterator::fileName" FSTests PathIterator::fileName)
+add_test("[ox/fs] PathIterator::dirPath" ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/FSTests PathIterator::dirPath)
+add_test("[ox/fs] PathIterator::fileName" ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/FSTests PathIterator::fileName)
 
-add_test("[ox/fs] NodeBuffer::insert" FSTests "NodeBuffer::insert")
-add_test("[ox/fs] FileStore::readWrite" FSTests "FileStore::readWrite")
+add_test("[ox/fs] NodeBuffer::insert" ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/FSTests "NodeBuffer::insert")
+add_test("[ox/fs] FileStore::readWrite" ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/FSTests "FileStore::readWrite")
 
-add_test("[ox/fs] Directory" FSTests "Directory")
-add_test("[ox/fs] FileSystem" FSTests "FileSystem")
+add_test("[ox/fs] Directory" ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/FSTests "Directory")
+add_test("[ox/fs] FileSystem" ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/FSTests "FileSystem")

deps/ox/src/ox/fs/test/tests.cpp

@@ -26,11 +26,11 @@ struct OX_PACKED NodeType: public ox::ptrarith::Item<T> {
 		}
 };
 
-const std::map<std::string_view, std::function<ox::Error(std::string_view)>> tests = {
+const std::map<ox::StringView, std::function<ox::Error(ox::StringView)>> tests = {
 	{
 		{
 			"PtrArith::setSize",
-			[](std::string_view) {
+			[](ox::StringView) {
 				using BuffPtr_t = uint32_t;
 				ox::Vector<char> buff(5 * ox::units::MB);
 				auto buffer = new (buff.data()) ox::ptrarith::NodeBuffer<BuffPtr_t, NodeType<BuffPtr_t>>(buff.size());
@@ -57,8 +57,8 @@ const std::map<std::string_view, std::function<ox::Error(std::string_view)>> tes
 		},
 		{
 			"PathIterator::next1",
-			[](std::string_view) {
-				ox::String path = "/usr/share/charset.gbag";
+			[](ox::StringView) {
+				auto const path = ox::String("/usr/share/charset.gbag");
 				ox::PathIterator it(path.c_str(), path.len());
 				auto buff = static_cast<char*>(ox_alloca(path.len() + 1));
 				oxAssert(it.next(buff, path.len()) == 0 && ox_strcmp(buff, "usr") == 0, "PathIterator shows wrong next");
@@ -69,8 +69,8 @@ const std::map<std::string_view, std::function<ox::Error(std::string_view)>> tes
 		},
 		{
 			"PathIterator::next2",
-			[](std::string_view) {
-				ox::String path = "/usr/share/";
+			[](ox::StringView) {
+				auto const path = ox::String("/usr/share/");
 				ox::PathIterator it(path.c_str(), path.len());
 				auto buff = static_cast<char*>(ox_alloca(path.len() + 1));
 				oxAssert(it.next(buff, path.len()) == 0 && ox_strcmp(buff, "usr") == 0, "PathIterator shows wrong next");
@@ -80,8 +80,8 @@ const std::map<std::string_view, std::function<ox::Error(std::string_view)>> tes
 		},
 		{
 			"PathIterator::next3",
-			[](std::string_view) {
-				ox::String path = "/";
+			[](ox::StringView) {
+				auto const path = ox::String("/");
 				ox::PathIterator it(path.c_str(), path.len());
 				auto buff = static_cast<char*>(ox_alloca(path.len() + 1));
 				oxAssert(it.next(buff, path.len()) == 0 && ox_strcmp(buff, "\0") == 0, "PathIterator shows wrong next");
@@ -90,8 +90,8 @@ const std::map<std::string_view, std::function<ox::Error(std::string_view)>> tes
 		},
 		{
 			"PathIterator::next4",
-			[](std::string_view) {
-				ox::String path = "usr/share/charset.gbag";
+			[](ox::StringView) {
+				auto const path = ox::String("usr/share/charset.gbag");
 				ox::PathIterator it(path.c_str(), path.len());
 				auto buff = static_cast<char*>(ox_alloca(path.len() + 1));
 				oxAssert(it.next(buff, path.len()) == 0 && ox_strcmp(buff, "usr") == 0, "PathIterator shows wrong next");
@@ -102,8 +102,8 @@ const std::map<std::string_view, std::function<ox::Error(std::string_view)>> tes
 		},
 		{
 			"PathIterator::next5",
-			[](std::string_view) {
-				ox::String path = "usr/share/";
+			[](ox::StringView) {
+				auto const path = ox::String("usr/share/");
 				ox::PathIterator it(path.c_str(), path.len());
 				auto buff = static_cast<char*>(ox_alloca(path.len() + 1));
 				oxAssert(it.next(buff, path.len()) == 0 && ox_strcmp(buff, "usr") == 0, "PathIterator shows wrong next");
@@ -113,8 +113,8 @@ const std::map<std::string_view, std::function<ox::Error(std::string_view)>> tes
 		},
 		{
 			"PathIterator::dirPath",
-			[] (std::string_view) {
-				ox::String path = "/usr/share/charset.gbag";
+			[] (ox::StringView) {
+				auto const path = ox::String("/usr/share/charset.gbag");
 				ox::PathIterator it(path.c_str(), path.len());
 				auto buff = static_cast<char*>(ox_alloca(path.len() + 1));
 				oxAssert(it.dirPath(buff, path.len()) == 0 && ox_strcmp(buff, "/usr/share/") == 0, "PathIterator shows incorrect dir path");
@@ -123,8 +123,8 @@ const std::map<std::string_view, std::function<ox::Error(std::string_view)>> tes
 		},
 		{
 			"PathIterator::fileName",
-			[](std::string_view) {
-				ox::String path = "/usr/share/charset.gbag";
+			[](ox::StringView) {
+				auto const path = ox::String("/usr/share/charset.gbag");
 				ox::PathIterator it(path.c_str(), path.len());
 				auto buff = static_cast<char*>(ox_alloca(path.len() + 1));
 				oxAssert(it.fileName(buff, path.len()) == 0 && ox_strcmp(buff, "charset.gbag") == 0, "PathIterator shows incorrect file name");
@@ -133,7 +133,7 @@ const std::map<std::string_view, std::function<ox::Error(std::string_view)>> tes
 		},
 		{
 			"PathIterator::hasNext",
-			[](std::string_view) {
+			[](ox::StringView) {
 				const auto path = "/file1";
 				ox::PathIterator it(path, ox_strlen(path));
 				oxAssert(it.hasNext(), "PathIterator shows incorrect hasNext");
@@ -143,7 +143,7 @@ const std::map<std::string_view, std::function<ox::Error(std::string_view)>> tes
 		},
 		{
 			"Ptr::subPtr",
-			[](std::string_view) {
+			[](ox::StringView) {
 				constexpr auto buffLen = 5000;
 				ox::ptrarith::Ptr<uint8_t, uint32_t> p(ox_alloca(buffLen), buffLen, 500, 500);
 				oxAssert(p.valid(), "Ptr::subPtr: Ptr p is invalid.");
@@ -155,7 +155,7 @@ const std::map<std::string_view, std::function<ox::Error(std::string_view)>> tes
 		},
 		{
 			"NodeBuffer::insert",
-			[](std::string_view) {
+			[](ox::StringView) {
 				constexpr auto buffLen = 5000;
 				auto list = new (ox_alloca(buffLen)) ox::ptrarith::NodeBuffer<uint32_t, ox::FileStoreItem<uint32_t>>(buffLen);
 				oxAssert(list->malloc(50).value.valid(), "NodeBuffer::insert: malloc 1 failed");
@@ -168,7 +168,7 @@ const std::map<std::string_view, std::function<ox::Error(std::string_view)>> tes
 		},
 		{
 			"FileStore::readWrite",
-			[](std::string_view) {
+			[](ox::StringView) {
 				constexpr auto buffLen = 5000;
 				constexpr auto str1 = "Hello, World!";
 				constexpr auto str1Len = ox_strlen(str1) + 1;
@@ -189,26 +189,26 @@ const std::map<std::string_view, std::function<ox::Error(std::string_view)>> tes
 		},
 		{
 			"Directory",
-			[](std::string_view) {
+			[](ox::StringView) {
 				ox::Vector<uint8_t> fsBuff(5000);
 				oxAssert(ox::FileStore32::format(fsBuff.data(), fsBuff.size()), "FS format failed");
 				ox::FileStore32 fileStore(fsBuff.data(), fsBuff.size());
 				ox::Directory32 dir(fileStore, 105);
 
-				oxTrace("ox::fs::test::Directory") << "Init";
+				oxTrace("ox.fs.test.Directory") << "Init";
 				oxAssert(dir.init(), "Init failed");
 
-				oxTrace("ox::fs::test::Directory") << "write 1";
+				oxTrace("ox.fs.test.Directory") << "write 1";
 				oxAssert(dir.write("/file1", 1), "Directory write of file1 failed");
 
-				oxTrace("ox::fs::test::Directory") << "find";
+				oxTrace("ox.fs.test.Directory") << "find";
 				oxAssert(dir.find("file1").error, "Could not find file1");
 				oxAssert(dir.find("file1").value == 1, "Could not find file1");
 
-				oxTrace("ox::fs::test::Directory") << "write 2";
+				oxTrace("ox.fs.test.Directory") << "write 2";
 				oxAssert(dir.write("/file3", 3), "Directory write of file3 failed");
 
-				oxTrace("ox::fs::test::Directory") << "write 3";
+				oxTrace("ox.fs.test.Directory") << "write 3";
 				oxAssert(dir.write("/file2", 2), "Directory write of file2 failed");
 
 				return OxError(0);
@@ -216,13 +216,13 @@ const std::map<std::string_view, std::function<ox::Error(std::string_view)>> tes
 		},
 		{
 			"FileSystem",
-			[](std::string_view) {
+			[](ox::StringView) {
 				ox::Vector<uint8_t> fsBuff(5000);
-				oxTrace("ox::fs::test::FileSystem") << "format";
+				oxTrace("ox.fs.test.FileSystem") << "format";
 				oxAssert(ox::FileSystem32::format(fsBuff.data(), fsBuff.size()), "FileSystem format failed");
 				ox::FileSystem32 fs(ox::FileStore32(fsBuff.data(), fsBuff.size()));
 
-				oxTrace("ox::fs::test::FileSystem") << "mkdir";
+				oxTrace("ox.fs.test.FileSystem") << "mkdir";
 				oxAssert(fs.mkdir("/dir", true), "mkdir failed");
 				oxAssert(fs.stat("/dir").error, "mkdir failed");
 				oxAssert(fs.mkdir("/l1d1/l2d1/l3d1", true), "mkdir failed");
@@ -237,16 +237,15 @@ const std::map<std::string_view, std::function<ox::Error(std::string_view)>> tes
 };
 
 int main(int argc, const char **args) {
-	int retval = -1;
-	if (argc > 1) {
-		std::string_view testName = args[1];
-		std::string_view testArg;
-		if (args[2]) {
-			testArg = args[2];
-		}
-		if (tests.find(testName) != tests.end()) {
-			retval = static_cast<int>(tests.at(testName)(testArg));
-		}
+	if (argc < 3) {
+		oxError("Must specify test to run and test argument");
 	}
-	return retval;
+	ox::StringView const testName = args[1];
+	ox::StringView const testArg = args[2] ? args[2] : nullptr;
+	auto const func = tests.find(testName);
+	if (func != tests.end()) {
+		oxAssert(func->second(testArg), "Test returned Error");
+		return 0;
+	}
+	return -1;
 }

deps/ox/src/ox/fs/tool.cpp

@@ -67,7 +67,7 @@ static ox::Error run(int argc, const char **argv) noexcept {
 		return OxError(1);
 	}
 	const auto fsPath = argv[1];
-	ox::String subCmd = argv[2];
+	ox::String subCmd(argv[2]);
 	oxRequire(fs, loadFs(fsPath));
 	if (subCmd == "ls") {
 		return runLs(fs.get(), argc - 2, argv + 2);

deps/ox/src/ox/logconn/CMakeLists.txt

@@ -20,6 +20,8 @@ target_link_libraries(
 	OxLogConn PUBLIC
 		OxStd
 		OxMetalClaw
+		$<$<BOOL:${OX_OS_FREEBSD}>:pthread>
+		$<$<BOOL:${OX_OS_WINDOWS}>:ws2_32>
 )
 
 install(

deps/ox/src/ox/logconn/logconn.cpp

@@ -7,21 +7,38 @@
  */
 
 #ifdef OX_USE_STDLIB
-#include	<sys/socket.h>
-#include <arpa/inet.h>
-#include <netinet/in.h>
-#include <sys/types.h>
-#include <unistd.h>
 #include <cstdio>
 
-#include <ox/std/bit.hpp>
+#include <sys/types.h>
+#ifndef _WIN32
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <unistd.h>
+#else
+#include <winsock.h>
+#undef interface
+#undef min
+#undef max
+#endif
+
 
 #include "logconn.hpp"
 
+#include <ox/std/bit.hpp>
+
 namespace ox {
 
 using namespace trace;
 
+void closeSock(auto s) noexcept {
+#ifdef _WIN32
+	closesocket(s);
+#else
+	close(s);
+#endif
+}
+
 LoggerConn::LoggerConn() noexcept: m_netThread([this]{this->msgSend();}) {
 }
 
@@ -30,7 +47,7 @@ LoggerConn::~LoggerConn() noexcept {
 	m_waitCond.notify_one();
 	m_netThread.join();
 	if (m_socket) {
-		close(m_socket);
+		closeSock(m_socket);
 	}
 }
 
@@ -41,7 +58,7 @@ ox::Error LoggerConn::initConn(ox::CRStringView appName) noexcept {
 	addr.sin_port = htons(5590);
 	m_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 	oxReturnError(OxError(static_cast<ox::ErrorCode>(connect(m_socket, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)))));
-	return sendInit({.appName = appName});
+	return sendInit({.appName = ox::BasicString<128>(appName)});
 }
 
 ox::Error LoggerConn::send(const char *buff, std::size_t len) const noexcept {

deps/ox/src/ox/logconn/logconn.hpp

@@ -17,7 +17,7 @@
 #include <ox/mc/write.hpp>
 #include <ox/std/trace.hpp>
 
-#include	"circularbuff.hpp"
+#include "circularbuff.hpp"
 
 namespace ox {
 

deps/ox/src/ox/mc/err.hpp

@@ -11,9 +11,9 @@
 namespace ox {
 
 enum {
-	MC_PRESENCEMASKOUTBOUNDS = 1,
-	MC_BUFFENDED = 2,
-	MC_OUTBUFFENDED = 4
+	McPresenceMapOverflow = 1,
+	McBuffEnded = 2,
+	McOutputBuffEnded = 4
 };
 
 }

deps/ox/src/ox/mc/intops.hpp

@@ -14,6 +14,7 @@
 #include <ox/std/byteswap.hpp>
 #include <ox/std/math.hpp>
 #include <ox/std/memops.hpp>
+#include <ox/std/reader.hpp>
 
 namespace ox::mc {
 
@@ -34,7 +35,7 @@ constexpr std::size_t highestBit(I val) noexcept {
 	if constexpr(is_signed_v<I>) {
 		--shiftStart;
 	}
-	for (auto i = shiftStart; i < MaxValue<decltype(i)>; --i) {
+	for (auto i = shiftStart; i > 0; --i) {
 		const auto bitValue = (val >> i) & 1;
 		if (bitValue) {
 			highestBit = i;
@@ -63,13 +64,14 @@ struct McInt {
 
 template<typename I>
 [[nodiscard]]
-constexpr McInt encodeInteger(I input) noexcept {
+constexpr McInt encodeInteger(I pInput) noexcept {
+	auto const input = ox::ResizedInt_t<I, 64>{pInput};
 	McInt out;
 	const auto inputNegative = is_signed_v<I> && input < 0;
 	// move input to uint64_t to allow consistent bit manipulation, and to avoid
 	// overflow concerns
 	uint64_t val = 0;
-	ox_memcpy(&val, &input, sizeof(I));
+	ox_memcpy(&val, &input, sizeof(input));
 	if (val) {
 		// bits needed to represent number factoring in space possibly
 		// needed for signed bit
@@ -92,7 +94,7 @@ constexpr McInt encodeInteger(I input) noexcept {
 		}
 		if (bytes == 9) {
 			out.data[0] = bytesIndicator;
-			ox_memcpy(&out.data[1], &leVal, sizeof(I));
+			ox_memcpy(&out.data[1], &leVal, 8);
 			if (inputNegative) {
 				out.data[1] |= 0b1000'0000;
 			}
@@ -114,7 +116,7 @@ constexpr McInt encodeInteger(I input) noexcept {
  * length integer.
  */
 [[nodiscard]]
-static constexpr std::size_t countBytes(unsigned b) noexcept {
+constexpr std::size_t countBytes(unsigned b) noexcept {
 	std::size_t i = 0;
 	while ((b >> i) & 1) ++i;
 	return i + 1;
@@ -131,55 +133,60 @@ static_assert(countBytes(0b0111'1111) == 8);
 static_assert(countBytes(0b1111'1111) == 9);
 
 template<typename I>
-constexpr Result<I> decodeInteger(const uint8_t buff[9], std::size_t buffLen, std::size_t *bytesRead) noexcept {
-	const auto bytes = countBytes(buff[0]);
+constexpr Result<I> decodeInteger(Reader_c auto&rdr, std::size_t *bytesRead) noexcept {
+	uint8_t firstByte = 0;
+	oxReturnError(rdr.read(&firstByte, 1));
+	oxReturnError(rdr.seekg(-1, ox::ios_base::cur));
+	const auto bytes = countBytes(firstByte);
 	if (bytes == 9) {
 		*bytesRead = bytes;
 		I out = 0;
-		ox_memcpy(&out, &buff[1], sizeof(I));
+		oxReturnError(rdr.seekg(1, ox::ios_base::cur));
+		oxReturnError(rdr.read(&out, sizeof(I)));
 		return fromLittleEndian<I>(out);
-	} else if (buffLen >= bytes) {
-		*bytesRead = bytes;
-		uint64_t decoded = 0;
-		ox_memcpy(&decoded, &buff[0], bytes);
-		decoded >>= bytes;
-		// move sign bit
-		if constexpr(is_signed_v<I>) {
-			const auto negBit = bytes * 8 - bytes - 1;
-			// move sign
-			const auto negative = (decoded >> negBit) == 1;
-			if (negative) {
-				// fill in all bits between encoded sign and real sign with 1s
-				// split it up because the 32-bit ARM can't shift more than 32 bits
-				ox::Array<uint32_t, 2> d = {};
-				ox_memcpy(d.data(), &decoded, sizeof(decoded));
-				auto bit = negBit;
-				for (; bit < ox::min<std::size_t>(Bits<I>, 32); ++bit) {
-					d[0] |= 1 << bit;
-				}
-				bit -= 32;
-				for (; bit < Bits<I>; ++bit) {
-					d[1] |= 1 << bit;
-				}
-				I out = 0;
-				if constexpr(ox::defines::BigEndian) {
-					const auto d0Tmp = d[0];
-					d[0] = d[1];
-					d[1] = d0Tmp;
-				}
-				ox_memcpy(&out, d.data(), sizeof(out));
-				return out;
-			}
-		}
-		return static_cast<I>(decoded);
 	}
-	return OxError(1);
+	*bytesRead = bytes;
+	uint64_t decoded = 0;
+	oxReturnError(rdr.read(&decoded, bytes));
+	decoded >>= bytes;
+	// move sign bit
+	if constexpr(is_signed_v<I>) {
+		 const auto negBit = bytes * 8 - bytes - 1;
+		 // move sign
+		 const auto negative = (decoded >> negBit) == 1;
+		 if (negative) {
+			 // fill in all bits between encoded sign and real sign with 1s
+			 // split it up because the 32-bit ARM can't shift more than 32 bits
+			 ox::Array<uint32_t, 2> d = {};
+			 //d[0] = decoded & 0xffff'ffff;
+			 //d[1] = decoded >> 32;
+			 ox_memcpy(d.data(), &decoded, sizeof(decoded));
+			 auto bit = negBit;
+			 for (; bit < ox::min<std::size_t>(Bits<I>, 32); ++bit) {
+				 d[0] |= 1 << bit;
+			 }
+			 bit -= 32;
+			 for (; bit < Bits<I>; ++bit) {
+				 d[1] |= 1 << bit;
+			 }
+			 I out = 0;
+			 if constexpr(ox::defines::BigEndian) {
+				 const auto d0Tmp = d[0];
+				 d[0] = d[1];
+				 d[1] = d0Tmp;
+			 }
+			 ox_memcpy(&out, d.data(), sizeof(out));
+			 return out;
+		 }
+	}
+	return static_cast<I>(decoded);
 }
 
 template<typename I>
-constexpr Result<I> decodeInteger(McInt m) noexcept {
-	std::size_t bytesRead;
-	return decodeInteger<I>(m.data, 9, &bytesRead);
+Result<I> decodeInteger(McInt m) noexcept {
+	std::size_t bytesRead{};
+	BufferReader br(reinterpret_cast<const char*>(m.data), 9);
+	return decodeInteger<I>(br, &bytesRead);
 }
 
 }

deps/ox/src/ox/mc/presenceindicator.cpp

@@ -11,7 +11,7 @@
 
 namespace ox {
 
-template class FieldBitmapReader<uint8_t*>;
-template class FieldBitmapReader<const uint8_t*>;
+template class FieldBitmapWriterBase<uint8_t*>;
+template class FieldBitmapWriterBase<const uint8_t*>;
 
 }

deps/ox/src/ox/mc/presenceindicator.hpp

@@ -8,21 +8,77 @@
 
 #pragma once
 
+#include <ox/std/array.hpp>
+#include <ox/std/bit.hpp>
 #include <ox/std/error.hpp>
 #include <ox/std/types.hpp>
+#include <ox/std/reader.hpp>
 
 #include "err.hpp"
 
 namespace ox {
 
-template<typename T>
+template<Reader_c Reader>
 class FieldBitmapReader {
+	protected:
+		mutable std::size_t m_mapBlockIdx = ~std::size_t{0};
+		mutable uint64_t m_mapBlock = 0;
+		std::size_t m_mapStart = 0;
+		Reader &m_reader;
+
+	public:
+		explicit constexpr FieldBitmapReader(Reader &reader) noexcept;
+
+		constexpr Result<bool> get(std::size_t i) const noexcept;
+
+	private:
+		constexpr ox::Error loadMapBlock(std::size_t id) const noexcept;
+
+};
+
+template<Reader_c Reader>
+constexpr FieldBitmapReader<Reader>::FieldBitmapReader(Reader &reader) noexcept:
+	m_mapStart(reader.tellg()),
+	m_reader(reader) {
+}
+
+template<Reader_c Reader>
+constexpr Result<bool> FieldBitmapReader<Reader>::get(std::size_t idx) const noexcept {
+	constexpr auto blockBits = sizeof(m_mapBlock);
+	auto const blockIdx = idx / blockBits;
+	if (m_mapBlockIdx != blockIdx) [[unlikely]] {
+		oxReturnError(loadMapBlock(blockIdx));
+	}
+	idx %= blockBits;
+	return (m_mapBlock >> idx) & 1;
+}
+
+template<Reader_c Reader>
+constexpr ox::Error FieldBitmapReader<Reader>::loadMapBlock(std::size_t idx) const noexcept {
+	oxRequire(g, m_reader.tellg());
+	oxReturnError(m_reader.seekg(static_cast<int>(m_mapStart + idx), ox::ios_base::beg));
+	ox::Array<char, sizeof(m_mapBlock)> mapBlock{};
+	oxReturnError(m_reader.read(mapBlock.data(), sizeof(m_mapBlock)));
+	// Warning: narrow-conv
+	oxReturnError(m_reader.seekg(static_cast<int>(g), ox::ios_base::beg));
+	m_mapBlock = 0;
+	for (auto i = 0ull; auto b : mapBlock) {
+		m_mapBlock |= static_cast<uint64_t>(std::bit_cast<uint8_t>(b)) << i;
+		i += 8;
+	}
+	m_mapBlockIdx = idx;
+	return {};
+}
+
+
+template<typename T>
+class FieldBitmapWriterBase {
 	protected:
 		T m_map = nullptr;
 		std::size_t m_mapLen = 0;
 
 	public:
-		constexpr FieldBitmapReader(T map, std::size_t maxLen) noexcept;
+		constexpr FieldBitmapWriterBase(T map, std::size_t maxLen) noexcept;
 
 		constexpr auto setBuffer(T map, std::size_t maxLen) noexcept;
 
@@ -38,45 +94,45 @@ class FieldBitmapReader {
 };
 
 template<typename T>
-constexpr FieldBitmapReader<T>::FieldBitmapReader(T map, std::size_t maxLen) noexcept {
+constexpr FieldBitmapWriterBase<T>::FieldBitmapWriterBase(T map, std::size_t maxLen) noexcept {
 	m_map = map;
 	m_mapLen = maxLen;
 }
 
 template<typename T>
-constexpr auto FieldBitmapReader<T>::setBuffer(T map, std::size_t maxLen) noexcept {
+constexpr auto FieldBitmapWriterBase<T>::setBuffer(T map, std::size_t maxLen) noexcept {
 	m_map = map;
 	m_mapLen = maxLen;
 }
 
 template<typename T>
-constexpr Result<bool> FieldBitmapReader<T>::get(std::size_t i) const noexcept {
+constexpr Result<bool> FieldBitmapWriterBase<T>::get(std::size_t i) const noexcept {
 	if (i / 8 < m_mapLen) {
 		return (m_map[i / 8] >> (i % 8)) & 1;
 	} else {
-		return OxError(MC_PRESENCEMASKOUTBOUNDS);
+		return OxError(McPresenceMapOverflow);
 	}
 }
 
 template<typename T>
-constexpr void FieldBitmapReader<T>::setFields(int fields) noexcept {
+constexpr void FieldBitmapWriterBase<T>::setFields(int fields) noexcept {
 	m_mapLen = static_cast<std::size_t>((fields / 8 + 1) - (fields % 8 == 0));
 }
 
 template<typename T>
-constexpr void FieldBitmapReader<T>::setMaxLen(int maxLen) noexcept {
+constexpr void FieldBitmapWriterBase<T>::setMaxLen(int maxLen) noexcept {
 	m_mapLen = static_cast<std::size_t>(maxLen);
 }
 
 template<typename T>
-constexpr int64_t FieldBitmapReader<T>::getMaxLen() const noexcept {
+constexpr int64_t FieldBitmapWriterBase<T>::getMaxLen() const noexcept {
 	return static_cast<int64_t>(m_mapLen);
 }
 
-extern template class FieldBitmapReader<uint8_t*>;
-extern template class FieldBitmapReader<const uint8_t*>;
+extern template class FieldBitmapWriterBase<uint8_t*>;
+extern template class FieldBitmapWriterBase<const uint8_t*>;
 
-class FieldBitmap: public FieldBitmapReader<uint8_t*> {
+class FieldBitmap: public FieldBitmapWriterBase<uint8_t*> {
 
 	public:
 		constexpr FieldBitmap(uint8_t *map, std::size_t maxLen) noexcept;
@@ -85,7 +141,8 @@ class FieldBitmap: public FieldBitmapReader<uint8_t*> {
 
 };
 
-constexpr FieldBitmap::FieldBitmap(uint8_t *map, std::size_t maxLen) noexcept: FieldBitmapReader<uint8_t*>(map, maxLen) {
+constexpr FieldBitmap::FieldBitmap(uint8_t *map, std::size_t maxLen) noexcept:
+	FieldBitmapWriterBase<uint8_t*>(map, maxLen) {
 }
 
 constexpr Error FieldBitmap::set(std::size_t i, bool on) noexcept {
@@ -97,7 +154,7 @@ constexpr Error FieldBitmap::set(std::size_t i, bool on) noexcept {
 		}
 		return {};
 	} else {
-		return OxError(MC_PRESENCEMASKOUTBOUNDS);
+		return OxError(McPresenceMapOverflow);
 	}
 }
 

deps/ox/src/ox/mc/read.cpp

@@ -6,6 +6,14 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
+#include <ox/model/modelhandleradaptor.hpp>
+#include <ox/std/buffer.hpp>
+#include <ox/std/reader.hpp>
+
+#include "read.hpp"
+
 namespace ox {
 
+template class ModelHandlerInterface<MetalClawReaderTemplate<BufferReader>>;
+
 }

deps/ox/src/ox/mc/read.hpp

@@ -15,6 +15,7 @@
 #include <ox/model/types.hpp>
 #include <ox/std/buffer.hpp>
 #include <ox/std/byteswap.hpp>
+#include <ox/std/optional.hpp>
 #include <ox/std/string.hpp>
 #include <ox/std/trace.hpp>
 #include <ox/std/vector.hpp>
@@ -26,22 +27,20 @@
 
 namespace ox {
 
-template<auto HandlerMaker>
-class MetalClawReaderTemplate {
+template<Reader_c Reader>
+class MetalClawReaderTemplate: public ModelHandlerBase<MetalClawReaderTemplate<Reader>, ox::OpType::Read> {
 
 	private:
-		FieldBitmapReader<const uint8_t*> m_fieldPresence;
+		FieldBitmapReader<Reader> m_fieldPresence;
 		std::size_t m_fields = 0;
 		std::size_t m_field = 0;
-		int m_unionIdx = -1;
-		std::size_t m_buffIt = 0;
-		std::size_t m_buffLen = 0;
-		const uint8_t *m_buff = nullptr;
-		MetalClawReaderTemplate<HandlerMaker> *m_parent = nullptr;
+		ox::Optional<int> m_unionIdx;
+		Reader &m_reader;
 
 	public:
-		constexpr MetalClawReaderTemplate(const uint8_t *buff, std::size_t buffLen, int unionIdx = -1,
-		                                  MetalClawReaderTemplate<HandlerMaker> *parent = nullptr) noexcept;
+		explicit constexpr MetalClawReaderTemplate(
+				Reader &reader,
+				ox::Optional<int> const&unionIdx = {}) noexcept;
 
 		constexpr ~MetalClawReaderTemplate() noexcept;
 
@@ -95,8 +94,7 @@ class MetalClawReaderTemplate {
 		/**
 		 * Reads an string length from the current location in the buffer.
 		 */
-		[[nodiscard]]
-		constexpr StringLength stringLength(const char *name) noexcept;
+		constexpr Result<StringLength> stringLength(const char *name) noexcept;
 
 		template<typename T = std::nullptr_t>
 		constexpr ox::Error setTypeInfo(
@@ -109,7 +107,7 @@ class MetalClawReaderTemplate {
 		 * Returns a MetalClawReader to parse a child object.
 		 */
 		[[nodiscard]]
-		constexpr MetalClawReaderTemplate<HandlerMaker> child(const char *name, int unionIdx = -1) noexcept;
+		constexpr MetalClawReaderTemplate<Reader> child(const char *name, ox::Optional<int> unionIdx = {}) noexcept;
 
 		/**
 		 * Indicates whether or not the next field to be read is present.
@@ -128,142 +126,130 @@ class MetalClawReaderTemplate {
 
 		constexpr void nextField() noexcept;
 
-		[[nodiscard]]
-		static constexpr auto opType() noexcept {
-			return OpType::Read;
-		}
-
 	private:
 		template<typename I>
 		constexpr Error readInteger(I *val) noexcept;
 
 };
 
-template<auto HandlerMaker>
-constexpr MetalClawReaderTemplate<HandlerMaker>::MetalClawReaderTemplate(const uint8_t *buff, std::size_t buffLen,
-                                                                         int unionIdx,
-                                                                         MetalClawReaderTemplate *parent) noexcept:
-		m_fieldPresence(buff, buffLen),
+template<Reader_c Reader>
+constexpr MetalClawReaderTemplate<Reader>::MetalClawReaderTemplate(
+		Reader &reader,
+		ox::Optional<int> const&unionIdx) noexcept:
+		m_fieldPresence(reader),
 		m_unionIdx(unionIdx),
-		m_buffLen(buffLen),
-		m_buff(buff),
-		m_parent(parent) {
+		m_reader(reader) {
 }
 
-template<auto HandlerMaker>
-constexpr MetalClawReaderTemplate<HandlerMaker>::~MetalClawReaderTemplate() noexcept {
-	if (m_parent) {
-		m_parent->m_buffIt += m_buffIt;
-	}
+template<Reader_c Reader>
+constexpr MetalClawReaderTemplate<Reader>::~MetalClawReaderTemplate() noexcept {
 	if (m_field != m_fields) {
-		oxTrace("ox::mc::MetalClawReader::error") << "MetalClawReader: incorrect fields number given";
+		oxTrace("ox.mc.MetalClawReader.error") << "MetalClawReader: incorrect fields number given";
 	}
 }
 
-template<auto HandlerMaker>
-constexpr Error MetalClawReaderTemplate<HandlerMaker>::field(const char*, int8_t *val) noexcept {
+template<Reader_c Reader>
+constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, int8_t *val) noexcept {
 	return readInteger(val);
 }
 
-template<auto HandlerMaker>
-constexpr Error MetalClawReaderTemplate<HandlerMaker>::field(const char*, int16_t *val) noexcept {
+template<Reader_c Reader>
+constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, int16_t *val) noexcept {
 	return readInteger(val);
 }
 
-template<auto HandlerMaker>
-constexpr Error MetalClawReaderTemplate<HandlerMaker>::field(const char*, int32_t *val) noexcept {
+template<Reader_c Reader>
+constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, int32_t *val) noexcept {
 	return readInteger(val);
 }
 
-template<auto HandlerMaker>
-constexpr Error MetalClawReaderTemplate<HandlerMaker>::field(const char*, int64_t *val) noexcept {
+template<Reader_c Reader>
+constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, int64_t *val) noexcept {
 	return readInteger(val);
 }
 
 
-template<auto HandlerMaker>
-constexpr Error MetalClawReaderTemplate<HandlerMaker>::field(const char*, uint8_t *val) noexcept {
+template<Reader_c Reader>
+constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, uint8_t *val) noexcept {
 	return readInteger(val);
 }
 
-template<auto HandlerMaker>
-constexpr Error MetalClawReaderTemplate<HandlerMaker>::field(const char*, uint16_t *val) noexcept {
+template<Reader_c Reader>
+constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, uint16_t *val) noexcept {
 	return readInteger(val);
 }
 
-template<auto HandlerMaker>
-constexpr Error MetalClawReaderTemplate<HandlerMaker>::field(const char*, uint32_t *val) noexcept {
+template<Reader_c Reader>
+constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, uint32_t *val) noexcept {
 	return readInteger(val);
 }
 
-template<auto HandlerMaker>
-constexpr Error MetalClawReaderTemplate<HandlerMaker>::field(const char*, uint64_t *val) noexcept {
+template<Reader_c Reader>
+constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, uint64_t *val) noexcept {
 	return readInteger(val);
 }
 
-template<auto HandlerMaker>
-constexpr Error MetalClawReaderTemplate<HandlerMaker>::field(const char*, bool *val) noexcept {
-	if (m_unionIdx == -1 || static_cast<std::size_t>(m_unionIdx) == m_field) {
-		auto valErr = m_fieldPresence.get(static_cast<std::size_t>(m_field));
-		*val = valErr.value;
-		oxReturnError(valErr.error);
+template<Reader_c Reader>
+constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, bool *val) noexcept {
+	if (!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) {
+		auto const result = m_fieldPresence.get(static_cast<std::size_t>(m_field));
+		*val = result.value;
+		oxReturnError(result);
 	}
 	++m_field;
 	return OxError(0);
 }
 
 // array handler
-template<auto HandlerMaker>
-constexpr Error MetalClawReaderTemplate<HandlerMaker>::field(const char *name, auto *val, std::size_t valLen) noexcept {
-	if (m_unionIdx == -1 || static_cast<std::size_t>(m_unionIdx) == m_field) {
+template<Reader_c Reader>
+constexpr Error MetalClawReaderTemplate<Reader>::field(const char *name, auto *val, std::size_t valLen) noexcept {
+	if (!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) {
 		if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) {
 			// read the length
-			if (m_buffIt >= m_buffLen) {
-				return OxError(MC_BUFFENDED);
-			}
 			std::size_t bytesRead = 0;
-			oxRequire(len, mc::decodeInteger<ArrayLength>(&m_buff[m_buffIt], m_buffLen - m_buffIt, &bytesRead));
-			m_buffIt += bytesRead;
+			oxRequire(len, mc::decodeInteger<ArrayLength>(m_reader, &bytesRead));
 			// read the list
 			if (valLen >= len) {
-				auto reader = child("");
-				auto handler = HandlerMaker(&reader);
+				auto reader = child({});
+				auto &handler = *reader.interface();
 				oxReturnError(handler.setTypeInfo("List", 0, {}, static_cast<std::size_t>(len)));
 				for (std::size_t i = 0; i < len; ++i) {
-					oxReturnError(handler.field("", &val[i]));
+					oxReturnError(handler.field({}, &val[i]));
 				}
 			} else {
-				oxTrace("ox::mc::read::field(T)") << name << ", size:" << valLen;
-				return OxError(MC_OUTBUFFENDED);
+				oxTracef("ox.mc.read.field(T)", "{}, length: {}", name, valLen);
+				return OxError(McOutputBuffEnded);
 			}
 		}
 	}
 	++m_field;
-	return OxError(0);
+	return {};
 }
 
-template<auto HandlerMaker>
+template<Reader_c Reader>
 template<typename T>
-constexpr Error MetalClawReaderTemplate<HandlerMaker>::field(const char*, HashMap<String, T> *val) noexcept {
-	if (m_unionIdx == -1 || static_cast<std::size_t>(m_unionIdx) == m_field) {
+constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, HashMap<String, T> *val) noexcept {
+	if (!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) {
 		if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) {
 			// read the length
-			if (m_buffIt >= m_buffLen) {
-				return OxError(MC_BUFFENDED);
-			}
+			oxRequire(g, m_reader.tellg());
 			std::size_t bytesRead = 0;
-			oxRequire(len, mc::decodeInteger<ArrayLength>(&m_buff[m_buffIt], m_buffLen - m_buffIt, &bytesRead));
-			m_buffIt += bytesRead;
+			oxRequire(len, mc::decodeInteger<ArrayLength>(m_reader, &bytesRead));
+			oxReturnError(m_reader.seekg(g));
 			// read the list
 			auto reader = child("");
-			auto handler = HandlerMaker(&reader);
+			auto &handler = *reader.interface();
 			oxReturnError(handler.setTypeInfo("List", 0, {}, static_cast<std::size_t>(len)));
-			for (std::size_t i = 0; i < len; ++i) {
-				const auto keyLen = handler.stringLength(nullptr);
+			// this loop body needs to be in a lambda because of the potential alloca call
+			constexpr auto loopBody = [](auto &handler, auto &val) {
+				oxRequire(keyLen, handler.stringLength(nullptr));
 				auto wkey = ox_malloca(keyLen + 1, char, 0);
 				auto wkeyPtr = wkey.get();
 				oxReturnError(handler.fieldCString("", &wkeyPtr, keyLen + 1));
-				oxReturnError(handler.field("", &val->operator[](wkey.get())));
+				return handler.field("", &val[wkeyPtr]);
+			};
+			for (std::size_t i = 0; i < len; ++i) {
+				oxReturnError(loopBody(handler, *val));
 			}
 		}
 	}
@@ -271,22 +257,23 @@ constexpr Error MetalClawReaderTemplate<HandlerMaker>::field(const char*, HashMa
 	return OxError(0);
 }
 
-template<auto HandlerMaker>
+template<Reader_c Reader>
 template<typename T>
-constexpr Error MetalClawReaderTemplate<HandlerMaker>::field(const char *name, T *val) noexcept {
+constexpr Error MetalClawReaderTemplate<Reader>::field(const char *name, T *val) noexcept {
 	if constexpr(isVector_v<T>) {
-		if (m_unionIdx == -1 || static_cast<std::size_t>(m_unionIdx) == m_field) {
+		if (!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) {
 			// set size of val if the field is present, don't worry about it if not
 			if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) {
 				oxRequire(len, arrayLength(name, false));
-				val->resize(len);
+				oxReturnError(ox::resizeVector(*val, len));
+				return field(name, val->data(), val->size());
 			}
-			return field(name, val->data(), val->size());
+			oxReturnError(ox::resizeVector(*val, 0));
 		}
 		++m_field;
 		return {};
 	} else if constexpr(isArray_v<T>) {
-		if (m_unionIdx == -1 || static_cast<std::size_t>(m_unionIdx) == m_field) {
+		if (!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) {
 			// set size of val if the field is present, don't worry about it if not
 			if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) {
 				oxRequire(len, arrayLength(name, false));
@@ -299,11 +286,10 @@ constexpr Error MetalClawReaderTemplate<HandlerMaker>::field(const char *name, T
 		++m_field;
 		return {};
 	} else {
-		if ((m_unionIdx == -1 || static_cast<std::size_t>(m_unionIdx) == m_field) && val) {
+		if ((!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) && val) {
 			if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) {
 				auto reader = child("");
-				auto handler = HandlerMaker(&reader);
-				oxReturnError(model(&handler, val));
+				oxReturnError(model(reader.interface(), val));
 			}
 		}
 		++m_field;
@@ -311,44 +297,35 @@ constexpr Error MetalClawReaderTemplate<HandlerMaker>::field(const char *name, T
 	}
 }
 
-template<auto HandlerMaker>
+template<Reader_c Reader>
 template<typename U, bool force>
-constexpr Error MetalClawReaderTemplate<HandlerMaker>::field(const char*, UnionView<U, force> val) noexcept {
-	if ((m_unionIdx == -1 || static_cast<std::size_t>(m_unionIdx) == m_field) && val.get()) {
+constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, UnionView<U, force> val) noexcept {
+	if ((!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) && val.get()) {
 		if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) {
-			auto reader = child("", val.idx());
-			auto handler = HandlerMaker(&reader);
-			oxReturnError(model(&handler, val.get()));
+			auto reader = child("", ox::Optional<int>(ox::in_place, val.idx()));
+			oxReturnError(model(reader.interface(), val.get()));
 		}
 	}
 	++m_field;
-	return OxError(0);
+	return {};
 }
 
-template<auto HandlerMaker>
+template<Reader_c Reader>
 template<std::size_t SmallStringSize>
-constexpr Error MetalClawReaderTemplate<HandlerMaker>::field(const char*, BasicString<SmallStringSize> *val) noexcept {
-	if (m_unionIdx == -1 || static_cast<std::size_t>(m_unionIdx) == m_field) {
+constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, BasicString<SmallStringSize> *val) noexcept {
+	if (!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) {
 		if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) {
 			// read the length
-			if (m_buffIt >= m_buffLen) {
-				return OxError(MC_BUFFENDED);
-			}
 			std::size_t bytesRead = 0;
-			oxRequire(size, mc::decodeInteger<StringLength>(&m_buff[m_buffIt], m_buffLen - m_buffIt, &bytesRead));
-			m_buffIt += bytesRead;
+			oxRequire(size, mc::decodeInteger<StringLength>(m_reader, &bytesRead));
 			const auto cap = size;
 			*val = BasicString<SmallStringSize>(cap);
 			auto data = val->data();
 			// read the string
 			if (static_cast<StringLength>(cap) < size) {
-				return OxError(MC_OUTBUFFENDED);
+				return OxError(McOutputBuffEnded);
 			}
-			if (m_buffIt + size > m_buffLen) {
-				return OxError(MC_BUFFENDED);
-			}
-			ox_strncpy(data, &m_buff[m_buffIt], size);
-			m_buffIt += size;
+			oxReturnError(m_reader.read(data, size));
 		} else {
 			*val = "";
 		}
@@ -357,81 +334,56 @@ constexpr Error MetalClawReaderTemplate<HandlerMaker>::field(const char*, BasicS
 	return OxError(0);
 }
 
-template<auto HandlerMaker>
+template<Reader_c Reader>
 template<std::size_t L>
-constexpr Error MetalClawReaderTemplate<HandlerMaker>::field(const char *name, BString<L> *val) noexcept {
+constexpr Error MetalClawReaderTemplate<Reader>::field(const char *name, BString<L> *val) noexcept {
 	return fieldCString(name, val->data(), val->cap());
 }
 
-template<auto HandlerMaker>
-constexpr Error MetalClawReaderTemplate<HandlerMaker>::fieldCString(const char*, char *val, std::size_t buffLen) noexcept {
+template<Reader_c Reader>
+constexpr Error MetalClawReaderTemplate<Reader>::fieldCString(const char*, char *val, std::size_t buffLen) noexcept {
 	if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) {
 		// read the length
-		if (m_buffIt >= m_buffLen) {
-			return OxError(MC_BUFFENDED);
-		}
 		std::size_t bytesRead = 0;
-		auto [size, err] = mc::decodeInteger<StringLength>(&m_buff[m_buffIt], m_buffLen - m_buffIt, &bytesRead);
+		oxRequire(size, mc::decodeInteger<StringLength>(m_reader, &bytesRead));
 		if (size > buffLen) {
-			return OxError(MC_OUTBUFFENDED);
+			return OxError(McOutputBuffEnded);
 		}
-		m_buffIt += bytesRead;
-		oxReturnError(err);
 		// re-allocate in case too small
 		auto data = val;
 		// read the string
-		if (m_buffIt + size <= m_buffLen) {
-			ox_memcpy(data, &m_buff[m_buffIt], size);
-			data[size] = 0;
-			m_buffIt += size;
-		} else {
-			return OxError(MC_BUFFENDED);
-		}
+		oxReturnError(m_reader.read(data, size));
+		data[size] = 0;
 	}
 	++m_field;
 	return OxError(0);
 }
 
-template<auto HandlerMaker>
-constexpr Error MetalClawReaderTemplate<HandlerMaker>::fieldCString(const char*, char **val) noexcept {
+template<Reader_c Reader>
+constexpr Error MetalClawReaderTemplate<Reader>::fieldCString(const char*, char **val) noexcept {
 	if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) {
 		// read the length
-		if (m_buffIt >= m_buffLen) {
-			return OxError(MC_BUFFENDED);
-		}
 		std::size_t bytesRead = 0;
-		auto [size, err] = mc::decodeInteger<StringLength>(&m_buff[m_buffIt], m_buffLen - m_buffIt, &bytesRead);
-		m_buffIt += bytesRead;
-		oxReturnError(err);
+		oxRequire(size, mc::decodeInteger<StringLength>(m_reader, &bytesRead));
 		// re-allocate in case too small
 		safeDelete(*val);
 		*val = new char[size + 1];
 		auto data = *val;
 		// read the string
-		if (m_buffIt + size <= m_buffLen) {
-			ox_memcpy(data, &m_buff[m_buffIt], size);
-			data[size] = 0;
-			m_buffIt += size;
-		} else {
-			return OxError(MC_BUFFENDED);
-		}
+		oxReturnError(m_reader.read(data, size));
+		data[size] = 0;
 	}
 	++m_field;
 	return OxError(0);
 }
 
-template<auto HandlerMaker>
-constexpr Error MetalClawReaderTemplate<HandlerMaker>::fieldCString(const char*, char **val, std::size_t buffLen) noexcept {
-	if (m_unionIdx == -1 || static_cast<std::size_t>(m_unionIdx) == m_field) {
+template<Reader_c Reader>
+constexpr Error MetalClawReaderTemplate<Reader>::fieldCString(const char*, char **val, std::size_t buffLen) noexcept {
+	if (!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) {
 		if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) {
 			// read the length
-			if (m_buffIt >= m_buffLen) {
-				return OxError(MC_BUFFENDED);
-			}
 			std::size_t bytesRead = 0;
-			auto [size, err] = mc::decodeInteger<StringLength>(&m_buff[m_buffIt], m_buffLen - m_buffIt, &bytesRead);
-			m_buffIt += bytesRead;
-			oxReturnError(err);
+			oxRequire(size, mc::decodeInteger<StringLength>(m_reader, &bytesRead));
 			// re-allocate if too small
 			if (buffLen < size + 1) {
 				safeDelete(*val);
@@ -440,13 +392,8 @@ constexpr Error MetalClawReaderTemplate<HandlerMaker>::fieldCString(const char*,
 			}
 			auto data = *val;
 			// read the string
-			if (m_buffIt + size <= m_buffLen) {
-				ox_memcpy(data, &m_buff[m_buffIt], size);
-				data[size] = 0;
-				m_buffIt += size;
-			} else {
-				return OxError(MC_BUFFENDED);
-			}
+			oxReturnError(m_reader.read(data, size));
+			data[size] = 0;
 		} else {
 			auto data = *val;
 			if (data) {
@@ -458,18 +405,16 @@ constexpr Error MetalClawReaderTemplate<HandlerMaker>::fieldCString(const char*,
 	return OxError(0);
 }
 
-template<auto HandlerMaker>
-constexpr Result<ArrayLength> MetalClawReaderTemplate<HandlerMaker>::arrayLength(const char*, bool pass) noexcept {
-	if (m_unionIdx == -1 || static_cast<std::size_t>(m_unionIdx) == m_field) {
+template<Reader_c Reader>
+constexpr Result<ArrayLength> MetalClawReaderTemplate<Reader>::arrayLength(const char*, bool pass) noexcept {
+	if (!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) {
 		if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) {
 			// read the length
-			if (m_buffIt >= m_buffLen) {
-				return OxError(MC_BUFFENDED);
-			}
 			std::size_t bytesRead = 0;
-			auto out = mc::decodeInteger<ArrayLength>(&m_buff[m_buffIt], m_buffLen - m_buffIt, &bytesRead).value;
-			if (pass) {
-				m_buffIt += bytesRead;
+			oxRequire(g, m_reader.tellg());
+			oxRequire(out, mc::decodeInteger<ArrayLength>(m_reader, &bytesRead));
+			if (!pass) {
+				oxReturnError(m_reader.seekg(g));
 			}
 			return out;
 		}
@@ -477,20 +422,29 @@ constexpr Result<ArrayLength> MetalClawReaderTemplate<HandlerMaker>::arrayLength
 	return OxError(1);
 }
 
-template<auto HandlerMaker>
+template<Reader_c Reader>
+constexpr Result<StringLength> MetalClawReaderTemplate<Reader>::stringLength(const char*) noexcept {
+	if (!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) {
+		if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) {
+			// read the length
+			std::size_t bytesRead = 0;
+			auto len = mc::decodeInteger<StringLength>(m_reader, &bytesRead);
+			oxReturnError(m_reader.seekg(-static_cast<int64_t>(bytesRead), ox::ios_base::cur));
+			return len;
+		}
+	}
+	return 0;
+}
+
+template<Reader_c Reader>
 template<typename I>
-constexpr Error MetalClawReaderTemplate<HandlerMaker>::readInteger(I *val) noexcept {
-	if (m_unionIdx == -1 || static_cast<std::size_t>(m_unionIdx) == m_field) {
+constexpr Error MetalClawReaderTemplate<Reader>::readInteger(I *val) noexcept {
+	if (!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) {
 		if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) {
 			std::size_t bytesRead = 0;
-			if (m_buffIt >= m_buffLen) {
-				oxTrace("ox::MetalClaw::readInteger") << "Buffer ended";
-				return OxError(MC_BUFFENDED);
-			}
-			auto valErr = mc::decodeInteger<I>(&m_buff[m_buffIt], m_buffLen - m_buffIt, &bytesRead);
-			m_buffIt += bytesRead;
-			oxReturnError(valErr.error);
-			*val = valErr.value;
+			auto const result = mc::decodeInteger<I>(m_reader, &bytesRead);
+			oxReturnError(result);
+			*val = result.value;
 		} else {
 			*val = 0;
 		}
@@ -499,22 +453,17 @@ constexpr Error MetalClawReaderTemplate<HandlerMaker>::readInteger(I *val) noexc
 	return OxError(0);
 }
 
-template<auto HandlerMaker>
+template<Reader_c Reader>
 template<typename T, typename CB>
-constexpr Error MetalClawReaderTemplate<HandlerMaker>::field(const char*, CB cb) noexcept {
-	if (m_unionIdx == -1 || static_cast<std::size_t>(m_unionIdx) == m_field) {
+constexpr Error MetalClawReaderTemplate<Reader>::field(const char*, CB cb) noexcept {
+	if (!m_unionIdx.has_value() || static_cast<std::size_t>(*m_unionIdx) == m_field) {
 		if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) {
 			// read the length
-			if (m_buffIt >= m_buffLen) {
-				return OxError(MC_BUFFENDED);
-			}
 			std::size_t bytesRead = 0;
-			oxRequire(len, mc::decodeInteger<ArrayLength>(&m_buff[m_buffIt], m_buffLen - m_buffIt, &bytesRead));
-			m_buffIt += bytesRead;
-
+			oxRequire(len, mc::decodeInteger<ArrayLength>(m_reader, &bytesRead));
 			// read the list
 			auto reader = child("");
-			auto handler = HandlerMaker(&reader);
+			auto &handler = *reader.interface();
 			oxReturnError(handler.setTypeInfo("List", 0, {}, static_cast<std::size_t>(len)));
 			for (std::size_t i = 0; i < len; ++i) {
 				T val;
@@ -527,50 +476,38 @@ constexpr Error MetalClawReaderTemplate<HandlerMaker>::field(const char*, CB cb)
 	return OxError(0);
 }
 
-template<auto HandlerMaker>
-constexpr StringLength MetalClawReaderTemplate<HandlerMaker>::stringLength(const char*) noexcept {
-	if (m_unionIdx == -1 || static_cast<std::size_t>(m_unionIdx) == m_field) {
-		if (m_fieldPresence.get(static_cast<std::size_t>(m_field))) {
-			// read the length
-			std::size_t bytesRead = 0;
-			auto len = mc::decodeInteger<StringLength>(&m_buff[m_buffIt], m_buffLen - m_buffIt, &bytesRead);
-			return len.value;
-		}
-	}
-	return 0;
-}
-
-template<auto HandlerMaker>
+template<Reader_c Reader>
 template<typename T>
-constexpr ox::Error MetalClawReaderTemplate<HandlerMaker>::setTypeInfo(
+constexpr ox::Error MetalClawReaderTemplate<Reader>::setTypeInfo(
 		const char*, int, const Vector<String>&, std::size_t fields) noexcept {
 	m_fields = fields;
-	m_buffIt = static_cast<std::size_t>((fields / 8 + 1) - (fields % 8 == 0));
-	m_fieldPresence.setFields(static_cast<int>(fields));
-	m_fieldPresence.setMaxLen(static_cast<int>(m_buffIt));
-	return {};
+	// Warning: narrow-conv
+	return m_reader.seekg(
+			static_cast<int>((fields / 8 + 1) - (fields % 8 == 0)),
+			ox::ios_base::cur);
 }
 
-template<auto HandlerMaker>
-constexpr MetalClawReaderTemplate<HandlerMaker> MetalClawReaderTemplate<HandlerMaker>::child(const char*, int unionIdx) noexcept {
-	return MetalClawReaderTemplate<HandlerMaker>(m_buff + m_buffIt, m_buffLen - m_buffIt, unionIdx, this);
+template<Reader_c Reader>
+constexpr MetalClawReaderTemplate<Reader> MetalClawReaderTemplate<Reader>::child(
+		const char*,
+		ox::Optional<int> unionIdx) noexcept {
+	return MetalClawReaderTemplate<Reader>(m_reader, unionIdx);
 }
 
-template<auto HandlerMaker>
-constexpr bool MetalClawReaderTemplate<HandlerMaker>::fieldPresent(const char*) const noexcept {
+template<Reader_c Reader>
+constexpr bool MetalClawReaderTemplate<Reader>::fieldPresent(const char*) const noexcept {
 	return m_fieldPresence.get(static_cast<std::size_t>(m_field)).value;
 }
 
-template<auto HandlerMaker>
-constexpr bool MetalClawReaderTemplate<HandlerMaker>::fieldPresent(int fieldNo) const noexcept {
+template<Reader_c Reader>
+constexpr bool MetalClawReaderTemplate<Reader>::fieldPresent(int fieldNo) const noexcept {
 	return m_fieldPresence.get(static_cast<std::size_t>(fieldNo)).value;
 }
 
-template<auto HandlerMaker>
+template<Reader_c Reader>
 [[nodiscard]]
-constexpr int MetalClawReaderTemplate<HandlerMaker>::whichFieldPresent(const char*, const ModelUnion &u) const noexcept {
-	FieldBitmapReader<const uint8_t*> p(m_buff + m_buffIt, m_buffLen - m_buffIt);
-	p.setFields(static_cast<int>(u.fieldCount()));
+constexpr int MetalClawReaderTemplate<Reader>::whichFieldPresent(const char*, const ModelUnion &u) const noexcept {
+	FieldBitmapReader<Reader> p(m_reader);
 	for (auto i = 0u; i < u.fieldCount(); ++i) {
 		if (p.get(i)) {
 			return static_cast<int>(i);
@@ -579,19 +516,18 @@ constexpr int MetalClawReaderTemplate<HandlerMaker>::whichFieldPresent(const cha
 	return -1;
 }
 
-template<auto HandlerMaker>
-constexpr void MetalClawReaderTemplate<HandlerMaker>::nextField() noexcept {
+template<Reader_c Reader>
+constexpr void MetalClawReaderTemplate<Reader>::nextField() noexcept {
 	++m_field;
 }
 
-using MetalClawReader = MetalClawReaderTemplate<[](auto r) {
-	return ModelHandlerInterface{r};
-}>;
+using MetalClawReader = MetalClawReaderTemplate<ox::BufferReader>;
 
 template<typename T>
 Error readMC(const char *buff, std::size_t buffLen, T *val) noexcept {
-	MetalClawReader reader(reinterpret_cast<const uint8_t*>(buff), buffLen);
-	ModelHandlerInterface handler(&reader);
+	BufferReader br(buff, buffLen);
+	MetalClawReader reader(br);
+	ModelHandlerInterface<MetalClawReader, ox::OpType::Read> handler(&reader);
 	return model(&handler, val);
 }
 
@@ -607,4 +543,6 @@ Result<T> readMC(const Buffer &buff) noexcept {
 	return readMC<T>(buff.data(), buff.size());
 }
 
+extern template class ModelHandlerInterface<MetalClawReaderTemplate<BufferReader>>;
+
 }

deps/ox/src/ox/mc/test/CMakeLists.txt

@@ -8,9 +8,9 @@ target_link_libraries(
 		OxMetalClaw
 )
 
-add_test("[ox/mc] McTest Writer" McTest MetalClawWriter)
-add_test("[ox/mc] McTest Reader" McTest MetalClawReader)
-#add_test("[ox/mc] McTest MetalClawDef" McTest MetalClawDef)
-add_test("[ox/mc] McTest MetalClawModelValue" McTest MetalClawModelValue)
-add_test("[ox/mc] McTest encodeInteger" McTest encodeInteger)
-add_test("[ox/mc] McTest decodeInteger" McTest decodeInteger)
+add_test("[ox/mc] Writer" ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/McTest MetalClawWriter)
+add_test("[ox/mc] Reader" ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/McTest MetalClawReader)
+#add_test("[ox/mc] MetalClawDef" ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/McTest MetalClawDef)
+add_test("[ox/mc] MetalClawModelValue" ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/McTest MetalClawModelValue)
+add_test("[ox/mc] encodeInteger" ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/McTest encodeInteger)
+add_test("[ox/mc] decodeInteger" ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/McTest decodeInteger)

deps/ox/src/ox/mc/test/tests.cpp

@@ -18,8 +18,8 @@ union TestUnion {
 	static constexpr auto TypeName = "TestUnion";
 	static constexpr auto TypeVersion = 1;
 	bool Bool;
-	uint32_t Int = 5;
-	char *CString;
+	uint32_t Int;
+	char *CString{};
 };
 
 struct TestStructNest {
@@ -45,10 +45,11 @@ struct TestStruct {
 	int32_t Int8 = 0;
 	int unionIdx = 1;
 	TestUnion Union;
-	ox::String String = "";
+	ox::String String;
 	ox::BString<32> BString = "";
 	uint32_t List[4] = {0, 0, 0, 0};
 	ox::Vector<uint32_t> Vector = {1, 2, 3, 4, 5};
+	ox::Vector<uint32_t> Vector2 = {1, 2, 3, 4, 5};
 	ox::HashMap<ox::String, int> Map;
 	TestStructNest EmptyStruct;
 	TestStructNest Struct;
@@ -77,7 +78,6 @@ oxModelEnd()
 template<typename T>
 constexpr ox::Error model(T *io, ox::CommonPtrWith<TestStruct> auto *obj) noexcept {
 	oxReturnError(io->template setTypeInfo<TestStruct>());
-	oxReturnError(io->field("Vector", &obj->Vector));
 	oxReturnError(io->field("Bool", &obj->Bool));
 	oxReturnError(io->field("Int", &obj->Int));
 	oxReturnError(io->field("Int1", &obj->Int1));
@@ -97,23 +97,24 @@ constexpr ox::Error model(T *io, ox::CommonPtrWith<TestStruct> auto *obj) noexce
 	oxReturnError(io->field("String", &obj->String));
 	oxReturnError(io->field("BString", &obj->BString));
 	oxReturnError(io->field("List", obj->List, 4));
+	oxReturnError(io->field("Vector", &obj->Vector));
+	oxReturnError(io->field("Vector2", &obj->Vector2));
 	oxReturnError(io->field("Map", &obj->Map));
-	oxReturnError(io->field("EmptyStruct", &obj->EmptyStruct));
 	oxReturnError(io->field("Struct", &obj->Struct));
+	oxReturnError(io->field("EmptyStruct", &obj->EmptyStruct));
 	return OxError(0);
 }
 
-std::map<ox::String, ox::Error(*)()> tests = {
+std::map<ox::StringView, ox::Error(*)()> tests = {
 	{
 		{
 			"MetalClawWriter",
 			[] {
 				// This test doesn't confirm much, but it does show that the writer
 				// doesn't segfault
-				static constexpr size_t buffLen = 1024;
-				char buff[buffLen];
+				ox::Array<char, 1024> buff;
 				TestStruct ts;
-				oxReturnError(ox::writeMC(buff, buffLen, ts));
+				oxReturnError(ox::writeMC(buff.data(), buff.size(), ts));
 				oxReturnError(ox::writeMC(ts));
 				return OxError(0);
 			}
@@ -126,18 +127,19 @@ std::map<ox::String, ox::Error(*)()> tests = {
 				TestStruct testIn, testOut;
 				testIn.Bool = true;
 				testIn.Int = 42;
-				testIn.Union.Int = 42;
-				testIn.String = "Test String 0";
 				testIn.BString = "Test String 1";
+				testIn.String = "Test String 2";
+				testIn.Vector = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, };
+				testIn.Vector2 = {};
 				testIn.List[0] = 1;
 				testIn.List[1] = 2;
 				testIn.List[2] = 3;
 				testIn.List[3] = 4;
-				testIn.Map["asdf"] = 93;
-				testIn.Map["aoeu"] = 94;
-				testIn.Struct.Bool = false;
+				testIn.Struct.Bool = true;
 				testIn.Struct.Int = 300;
-				testIn.Struct.BString = "Test String 2";
+				testIn.Struct.BString = "Test String 3";
+				testIn.unionIdx = 1;
+				testIn.Union.Int = 93;
 				// run tests
 				const auto [buff, err] = ox::writeMC(testIn);
 				oxAssert(err, "writeMC failed");
@@ -160,10 +162,11 @@ std::map<ox::String, ox::Error(*)()> tests = {
 				oxAssert(testIn.List[1]             == testOut.List[1],             "List[1] value mismatch");
 				oxAssert(testIn.List[2]             == testOut.List[2],             "List[2] value mismatch");
 				oxAssert(testIn.List[3]             == testOut.List[3],             "List[3] value mismatch");
-				oxAssert(testIn.Vector[0]           == testOut.Vector[0],           "Vector[0] value mismatch");
-				oxAssert(testIn.Vector[1]           == testOut.Vector[1],           "Vector[1] value mismatch");
-				oxAssert(testIn.Vector[2]           == testOut.Vector[2],           "Vector[2] value mismatch");
-				oxAssert(testIn.Vector[3]           == testOut.Vector[3],           "Vector[3] value mismatch");
+				oxAssert(testIn.Vector.size()       == testOut.Vector.size(),       "Vector size mismatch");
+				for (auto i = 0u; i < testIn.Vector.size(); ++i) {
+					oxAssert(testIn.Vector[i]        == testOut.Vector[i],           ox::sfmt("Vector[{}] value mismatch", i));
+				}
+				oxAssert(testIn.Vector2.size()      == testOut.Vector2.size(),      "Vector2 size mismatch");
 				oxAssert(testIn.Map["asdf"]         == testOut.Map["asdf"],         "Map[\"asdf\"] value mismatch");
 				oxAssert(testIn.Map["aoeu"]         == testOut.Map["aoeu"],         "Map[\"aoeu\"] value mismatch");
 				oxAssert(testIn.EmptyStruct.Bool    == testOut.EmptyStruct.Bool,    "EmptyStruct.Bool value mismatch");
@@ -264,6 +267,9 @@ std::map<ox::String, ox::Error(*)()> tests = {
 					return OxError(0);
 				};
 				oxAssert(check(uint32_t(14)), "Decode of 14 failed.");
+				oxAssert(check(int8_t(-1)), "Decode of -1 failed.");
+				oxAssert(check(int16_t(-1)), "Decode of -1 failed.");
+				oxAssert(check(int32_t(-1)), "Decode of -1 failed.");
 				oxAssert(check(int64_t(-1)), "Decode of -1 failed.");
 				oxAssert(check(int64_t(-2)), "Decode of -2 failed.");
 				oxAssert(check(int64_t(-127)), "Decode of -127 failed.");
@@ -363,7 +369,8 @@ std::map<ox::String, ox::Error(*)()> tests = {
 				 ox::TypeStore typeStore;
 				 const auto [type, typeErr] = ox::buildTypeDef(&typeStore, &testIn);
 				 oxAssert(typeErr, "Descriptor write failed");
-				 oxReturnError(ox::walkModel<ox::MetalClawReader>(type, dataBuff, dataBuffLen,
+				 ox::BufferReader br(dataBuff, dataBuffLen);
+				 oxReturnError(ox::walkModel<ox::MetalClawReader>(type, br,
 					[](const ox::Vector<ox::FieldName>&, const ox::Vector<ox::String>&, const ox::DescriptorField &f, ox::MetalClawReader *rdr) -> ox::Error {
 						//std::cout << f.fieldName.c_str() << '\n';
 						auto fieldName = f.fieldName.c_str();
@@ -456,11 +463,14 @@ std::map<ox::String, ox::Error(*)()> tests = {
 };
 
 int main(int argc, const char **args) {
-	if (argc > 0) {
-		auto testName = args[1];
-		if (tests.find(testName) != tests.end()) {
-			oxAssert(tests[testName](), "Test failed...");
-		}
+	if (argc < 2) {
+		oxError("Must specify test to run");
 	}
-	return 0;
+	auto const testName = args[1];
+	auto const func = tests.find(testName);
+	if (func != tests.end()) {
+		oxAssert(func->second(), "Test returned Error");
+		return 0;
+	}
+	return -1;
 }

deps/ox/src/ox/mc/types.hpp

@@ -14,7 +14,7 @@
 
 namespace ox {
 
-using StringLength = uint32_t;
-using ArrayLength = uint32_t;
+using StringLength = std::size_t;
+using ArrayLength = std::size_t;
 
 }

deps/ox/src/ox/mc/write.hpp

@@ -16,6 +16,7 @@
 #include <ox/std/buffer.hpp>
 #include <ox/std/byteswap.hpp>
 #include <ox/std/hashmap.hpp>
+#include <ox/std/optional.hpp>
 #include <ox/std/string.hpp>
 #include <ox/std/types.hpp>
 #include <ox/std/units.hpp>
@@ -34,48 +35,39 @@ class MetalClawWriter {
 		ox::Vector<uint8_t, 16> m_presenceMapBuff{};
 		FieldBitmap m_fieldPresence;
 		int m_field = 0;
-		int m_unionIdx = -1;
+		ox::Optional<int> m_unionIdx;
 		std::size_t m_writerBeginP{};
 		Writer &m_writer;
 
 	public:
-		constexpr explicit MetalClawWriter(Writer &writer, int unionIdx = -1) noexcept;
+		constexpr explicit MetalClawWriter(Writer &writer, ox::Optional<int> const&unionIdx = {}) noexcept;
 
 		constexpr ~MetalClawWriter() noexcept = default;
 
-		constexpr Error field(const char*, CommonPtrWith<int8_t> auto *val) noexcept;
-		constexpr Error field(const char*, CommonPtrWith<int16_t> auto *val) noexcept;
-		constexpr Error field(const char*, CommonPtrWith<int32_t> auto *val) noexcept;
-		constexpr Error field(const char*, CommonPtrWith<int64_t> auto *val) noexcept;
+		constexpr Error field(const char*, const int8_t *val) noexcept;
+		constexpr Error field(const char*, const int16_t *val) noexcept;
+		constexpr Error field(const char*, const int32_t *val) noexcept;
+		constexpr Error field(const char*, const int64_t *val) noexcept;
 
-		constexpr Error field(const char*, CommonPtrWith<uint8_t> auto *val) noexcept;
-		constexpr Error field(const char*, CommonPtrWith<uint16_t> auto *val) noexcept;
-		constexpr Error field(const char*, CommonPtrWith<uint32_t> auto *val) noexcept;
-		constexpr Error field(const char*, CommonPtrWith<uint64_t> auto *val) noexcept;
+		constexpr Error field(const char*, const uint8_t *val) noexcept;
+		constexpr Error field(const char*, const uint16_t *val) noexcept;
+		constexpr Error field(const char*, const uint32_t *val) noexcept;
+		constexpr Error field(const char*, const uint64_t *val) noexcept;
 
-		constexpr Error field(const char*, CommonPtrWith<bool> auto *val) noexcept;
+		constexpr Error field(const char*, const bool *val) noexcept;
 
 		template<typename T>
-		constexpr Error field(const char*, T *val, std::size_t len) noexcept;
+		constexpr Error field(const char*, const T *val, std::size_t len) noexcept;
 
 		template<typename T>
 		constexpr Error field(const char *name, const HashMap<String, T> *val) noexcept;
 
-		template<typename T>
-		constexpr Error field(const char*, HashMap<String, T> *val) noexcept;
-
 		template<std::size_t SmallStringSize>
 		constexpr Error field(const char*, const BasicString<SmallStringSize> *val) noexcept;
 
 		template<std::size_t L>
 		constexpr Error field(const char*, const BString<L> *val) noexcept;
 
-		template<std::size_t SmallStringSize>
-		constexpr Error field(const char*, BasicString<SmallStringSize> *val) noexcept;
-
-		template<std::size_t L>
-		constexpr Error field(const char*, BString<L> *val) noexcept;
-
 		constexpr Error fieldCString(const char *name, const char *const*val, std::size_t buffLen) noexcept;
 
 		constexpr Error fieldCString(const char *name, const char **val) noexcept;
@@ -84,20 +76,8 @@ class MetalClawWriter {
 
 		constexpr Error fieldCString(const char *name, const char *val, std::size_t len) noexcept;
 
-		constexpr Error fieldCString(const char *name, char **val, std::size_t buffLen) noexcept {
-			return fieldCString(name, const_cast<const char**>(val), buffLen);
-		}
-
-		constexpr Error fieldCString(const char *name, char **val) noexcept {
-			return fieldCString(name, const_cast<const char**>(val));
-		}
-
-		constexpr Error fieldCString(const char *name, char *val, std::size_t buffLen) noexcept {
-			return fieldCString(name, const_cast<const char*>(val), buffLen);
-		}
-
 		template<typename T>
-		constexpr Error field(const char*, T *val) noexcept;
+		constexpr Error field(const char*, const T *val) noexcept;
 
 		template<typename U, bool force = false>
 		constexpr Error field(const char*, UnionView<U, force> val) noexcept;
@@ -135,7 +115,7 @@ class MetalClawWriter {
 	private:
 		constexpr Error appendInteger(Integer_c auto val) noexcept {
 			bool fieldSet = false;
-			if (val && (m_unionIdx == -1 || m_unionIdx == m_field)) {
+			if (val && (!m_unionIdx.has_value() || *m_unionIdx == m_field)) {
 				auto mi = mc::encodeInteger(val);
 				oxReturnError(m_writer.write(reinterpret_cast<const char*>(mi.data), mi.length));
 				fieldSet = true;
@@ -151,7 +131,7 @@ extern template class ModelHandlerInterface<MetalClawWriter<BufferWriter>>;
 extern template class ModelHandlerInterface<MetalClawWriter<CharBuffWriter>>;
 
 template<Writer_c Writer>
-constexpr MetalClawWriter<Writer>::MetalClawWriter(Writer &writer, int unionIdx) noexcept:
+constexpr MetalClawWriter<Writer>::MetalClawWriter(Writer &writer, ox::Optional<int> const&unionIdx) noexcept:
 	m_fieldPresence(m_presenceMapBuff.data(), m_presenceMapBuff.size()),
 	m_unionIdx(unionIdx),
 	m_writerBeginP(writer.tellp()),
@@ -159,48 +139,48 @@ constexpr MetalClawWriter<Writer>::MetalClawWriter(Writer &writer, int unionIdx)
 }
 
 template<Writer_c Writer>
-constexpr Error MetalClawWriter<Writer>::field(const char*, CommonPtrWith<int8_t> auto *val) noexcept {
+constexpr Error MetalClawWriter<Writer>::field(const char*, const int8_t *val) noexcept {
 	return appendInteger(*val);
 }
 
 template<Writer_c Writer>
-constexpr Error MetalClawWriter<Writer>::field(const char*, CommonPtrWith<int16_t> auto *val) noexcept {
+constexpr Error MetalClawWriter<Writer>::field(const char*, const int16_t *val) noexcept {
 	return appendInteger(*val);
 }
 
 template<Writer_c Writer>
-constexpr Error MetalClawWriter<Writer>::field(const char*, CommonPtrWith<int32_t> auto *val) noexcept {
+constexpr Error MetalClawWriter<Writer>::field(const char*, const int32_t *val) noexcept {
 	return appendInteger(*val);
 }
 
 template<Writer_c Writer>
-constexpr Error MetalClawWriter<Writer>::field(const char*, CommonPtrWith<int64_t> auto *val) noexcept {
+constexpr Error MetalClawWriter<Writer>::field(const char*, const int64_t *val) noexcept {
 	return appendInteger(*val);
 }
 
 template<Writer_c Writer>
-constexpr Error MetalClawWriter<Writer>::field(const char*, CommonPtrWith<uint8_t> auto *val) noexcept {
+constexpr Error MetalClawWriter<Writer>::field(const char*, const uint8_t *val) noexcept {
 	return appendInteger(*val);
 }
 
 template<Writer_c Writer>
-constexpr Error MetalClawWriter<Writer>::field(const char*, CommonPtrWith<uint16_t> auto *val) noexcept {
+constexpr Error MetalClawWriter<Writer>::field(const char*, const uint16_t *val) noexcept {
 	return appendInteger(*val);
 }
 
 template<Writer_c Writer>
-constexpr Error MetalClawWriter<Writer>::field(const char*, CommonPtrWith<uint32_t> auto *val) noexcept {
+constexpr Error MetalClawWriter<Writer>::field(const char*, const uint32_t *val) noexcept {
 	return appendInteger(*val);
 }
 
 template<Writer_c Writer>
-constexpr Error MetalClawWriter<Writer>::field(const char*, CommonPtrWith<uint64_t> auto *val) noexcept {
+constexpr Error MetalClawWriter<Writer>::field(const char*, const uint64_t *val) noexcept {
 	return appendInteger(*val);
 }
 
 template<Writer_c Writer>
-constexpr Error MetalClawWriter<Writer>::field(const char*, CommonPtrWith<bool> auto *val) noexcept {
-	if (m_unionIdx == -1 || m_unionIdx == m_field) {
+constexpr Error MetalClawWriter<Writer>::field(const char*, const bool *val) noexcept {
+	if (!m_unionIdx.has_value() || *m_unionIdx == m_field) {
 		oxReturnError(m_fieldPresence.set(static_cast<std::size_t>(m_field), *val));
 	}
 	++m_field;
@@ -211,7 +191,7 @@ template<Writer_c Writer>
 template<std::size_t SmallStringSize>
 constexpr Error MetalClawWriter<Writer>::field(const char*, const BasicString<SmallStringSize> *val) noexcept {
 	bool fieldSet = false;
-	if (val->len() && (m_unionIdx == -1 || m_unionIdx == m_field)) {
+	if (val->len() && (!m_unionIdx.has_value() || *m_unionIdx == m_field)) {
 		// write the length
 		const auto strLen = mc::encodeInteger(val->len());
 		oxReturnError(m_writer.write(reinterpret_cast<const char*>(strLen.data), strLen.length));
@@ -230,22 +210,10 @@ constexpr Error MetalClawWriter<Writer>::field(const char *name, const BString<L
 	return fieldCString(name, val->data(), val->cap());
 }
 
-template<Writer_c Writer>
-template<std::size_t SmallStringSize>
-constexpr Error MetalClawWriter<Writer>::field(const char *name, BasicString<SmallStringSize> *val) noexcept {
-	return field(name, const_cast<const BasicString<SmallStringSize>*>(val));
-}
-
-template<Writer_c Writer>
-template<std::size_t L>
-constexpr Error MetalClawWriter<Writer>::field(const char *name, BString<L> *val) noexcept {
-	return fieldCString(name, val->data(), val->cap());
-}
-
 template<Writer_c Writer>
 constexpr Error MetalClawWriter<Writer>::fieldCString(const char*, const char *const*val, std::size_t) noexcept {
 	bool fieldSet = false;
-	if (m_unionIdx == -1 || m_unionIdx == m_field) {
+	if (!m_unionIdx.has_value() || *m_unionIdx == m_field) {
 		const auto strLen = *val ? ox_strlen(*val) : 0;
 		// write the length
 		const auto strLenBuff = mc::encodeInteger(strLen);
@@ -272,7 +240,7 @@ constexpr Error MetalClawWriter<Writer>::fieldCString(const char *name, const ch
 template<Writer_c Writer>
 constexpr Error MetalClawWriter<Writer>::fieldCString(const char*, const char *val, std::size_t strLen) noexcept {
 	bool fieldSet = false;
-	if (strLen && (m_unionIdx == -1 || m_unionIdx == m_field)) {
+	if (strLen && (!m_unionIdx.has_value() || *m_unionIdx == m_field)) {
 		// write the length
 		const auto strLenBuff = mc::encodeInteger(strLen);
 		oxReturnError(m_writer.write(reinterpret_cast<const char*>(strLenBuff.data), strLenBuff.length));
@@ -287,21 +255,22 @@ constexpr Error MetalClawWriter<Writer>::fieldCString(const char*, const char *v
 
 template<Writer_c Writer>
 template<typename T>
-constexpr Error MetalClawWriter<Writer>::field(const char*, T *val) noexcept {
+constexpr Error MetalClawWriter<Writer>::field(const char*, const T *val) noexcept {
 	if constexpr(isVector_v<T> || isArray_v<T>) {
 		return field(nullptr, val->data(), val->size());
 	} else {
 		bool fieldSet = false;
-		if (val && (m_unionIdx == -1 || m_unionIdx == m_field)) {
+		if (val && (!m_unionIdx.has_value() || *m_unionIdx == m_field)) {
+			auto const writeIdx = m_writer.tellp();
 			MetalClawWriter<Writer> writer(m_writer);
 			ModelHandlerInterface<MetalClawWriter<Writer>> handler{&writer};
 			oxReturnError(model(&handler, val));
 			oxReturnError(writer.finalize());
-			fieldSet = true;
+			fieldSet = writeIdx != m_writer.tellp();
 		}
 		oxReturnError(m_fieldPresence.set(static_cast<std::size_t>(m_field), fieldSet));
 		++m_field;
-		return OxError(0);
+		return {};
 	}
 }
 
@@ -309,35 +278,37 @@ template<Writer_c Writer>
 template<typename U, bool force>
 constexpr Error MetalClawWriter<Writer>::field(const char*, UnionView<U, force> val) noexcept {
 	bool fieldSet = false;
-	if (val.get() && (m_unionIdx == -1 || m_unionIdx == m_field)) {
-		MetalClawWriter<Writer> writer(m_writer, val.idx());
+	if (val.get() && (!m_unionIdx.has_value() || *m_unionIdx == m_field)) {
+		auto const writeIdx = m_writer.tellp();
+		MetalClawWriter<Writer> writer(m_writer, ox::Optional<int>(ox::in_place, val.idx()));
 		ModelHandlerInterface handler{&writer};
 		oxReturnError(model(&handler, val.get()));
 		oxReturnError(writer.finalize());
-		fieldSet = true;
+		fieldSet = writeIdx != m_writer.tellp();
 	}
 	oxReturnError(m_fieldPresence.set(static_cast<std::size_t>(m_field), fieldSet));
 	++m_field;
-	return OxError(0);
+	return {};
 }
 
 template<Writer_c Writer>
 template<typename T>
-constexpr Error MetalClawWriter<Writer>::field(const char*, T *val, std::size_t len) noexcept {
+constexpr Error MetalClawWriter<Writer>::field(const char*, const T *val, std::size_t len) noexcept {
 	bool fieldSet = false;
-	if (len && (m_unionIdx == -1 || m_unionIdx == m_field)) {
+	if (len && (!m_unionIdx.has_value() || *m_unionIdx == m_field)) {
 		// write the length
 		const auto arrLen = mc::encodeInteger(len);
 		oxReturnError(m_writer.write(reinterpret_cast<const char*>(arrLen.data), arrLen.length));
+		auto const writeIdx = m_writer.tellp();
 		MetalClawWriter<Writer> writer(m_writer);
 		ModelHandlerInterface handler{&writer};
 		oxReturnError(handler.template setTypeInfo<T>("List", 0, {}, static_cast<std::size_t>(len)));
 		// write the array
-		for (std::size_t i = 0; i < len; i++) {
+		for (std::size_t i = 0; i < len; ++i) {
 			oxReturnError(handler.field("", &val[i]));
 		}
 		oxReturnError(writer.finalize());
-		fieldSet = true;
+		fieldSet = writeIdx != m_writer.tellp();
 	}
 	oxReturnError(m_fieldPresence.set(static_cast<std::size_t>(m_field), fieldSet));
 	++m_field;
@@ -350,7 +321,7 @@ constexpr Error MetalClawWriter<Writer>::field(const char*, const HashMap<String
 	const auto &keys = val->keys();
 	const auto len = keys.size();
 	bool fieldSet = false;
-	if (len && (m_unionIdx == -1 || m_unionIdx == m_field)) {
+	if (len && (!m_unionIdx.has_value() || *m_unionIdx == m_field)) {
 		// write the length
 		const auto arrLen = mc::encodeInteger(len);
 		oxReturnError(m_writer.write(reinterpret_cast<const char*>(arrLen.data), arrLen.length));
@@ -359,15 +330,19 @@ constexpr Error MetalClawWriter<Writer>::field(const char*, const HashMap<String
 		ModelHandlerInterface handler{&writer};
 		// double len for both key and value
 		oxReturnError(handler.setTypeInfo("Map", 0, {}, len * 2));
-		// write the array
-		for (std::size_t i = 0; i < len; i++) {
-			const auto &key = keys[i];
-			const auto keyLen = ox_strlen(key);
+		// this loop body needs to be in a lambda because of the potential alloca call
+		constexpr auto loopBody = [](auto &handler, auto const&key, auto const&val) -> ox::Error {
+			const auto keyLen = key.len();
 			auto wkey = ox_malloca(keyLen + 1, char, 0);
-			memcpy(wkey, key.c_str(), keyLen + 1);
+			memcpy(wkey.get(), key.c_str(), keyLen + 1);
 			oxReturnError(handler.fieldCString("", wkey.get(), keyLen));
-			oxRequireM(value, val->at(key));
-			oxReturnError(handler.field("", value));
+			oxRequireM(value, val.at(key));
+			return handler.field("", value);
+		};
+		// write the array
+		for (std::size_t i = 0; i < len; ++i) {
+			auto const&key = keys[i];
+			oxReturnError(loopBody(handler, key, *val));
 		}
 		oxReturnError(writer.finalize());
 		fieldSet = true;
@@ -377,12 +352,6 @@ constexpr Error MetalClawWriter<Writer>::field(const char*, const HashMap<String
 	return OxError(0);
 }
 
-template<Writer_c Writer>
-template<typename T>
-constexpr Error MetalClawWriter<Writer>::field(const char *name, HashMap<String, T> *val) noexcept {
-	return field(name, const_cast<const HashMap<String, T>*>(val));
-}
-
 template<Writer_c Writer>
 template<typename T>
 constexpr ox::Error MetalClawWriter<Writer>::setTypeInfo(
@@ -417,7 +386,7 @@ Result<Buffer> writeMC(Writer_c auto &writer, const auto &val) noexcept {
 	return {};
 }
 
-Result<Buffer> writeMC(const auto &val, std::size_t buffReserveSz = 2 * units::KB) noexcept {
+Result<Buffer> writeMC(auto const&val, std::size_t buffReserveSz = 2 * units::KB) noexcept {
 	Buffer buff(buffReserveSz);
 	BufferWriter bw(&buff, 0);
 	oxReturnError(writeMC(bw, val));
@@ -425,7 +394,7 @@ Result<Buffer> writeMC(const auto &val, std::size_t buffReserveSz = 2 * units::K
 	return buff;
 }
 
-Error writeMC(char *buff, std::size_t buffLen, const auto &val, std::size_t *sizeOut = nullptr) noexcept {
+Error writeMC(char *buff, std::size_t buffLen, auto const&val, std::size_t *sizeOut = nullptr) noexcept {
 	CharBuffWriter bw(buff, buffLen);
 	oxReturnError(writeMC(bw, val));
 	if (sizeOut) {

deps/ox/src/ox/model/descwrite.hpp

@@ -175,8 +175,9 @@ class TypeDescWriter {
 constexpr TypeDescWriter::TypeDescWriter(TypeStore *typeStore) noexcept: m_typeStore(typeStore) {}
 
 template<typename T>
-constexpr ox::Error TypeDescWriter::setTypeInfo(CRStringView typeName, int typeVersion,
-                                           const TypeParamPack &typeParams, std::size_t) noexcept {
+constexpr ox::Error TypeDescWriter::setTypeInfo(
+		CRStringView typeName, int typeVersion,
+      const TypeParamPack &typeParams, std::size_t) noexcept {
 	PrimitiveType pt;
 	if constexpr(is_union_v<T>) {
 		pt = PrimitiveType::Union;
@@ -197,7 +198,7 @@ constexpr Error TypeDescWriter::field(CRStringView name, const T*, std::size_t,
 		constexpr typename remove_pointer<T>::type *p = nullptr;
 		const auto t = type(p);
 		oxAssert(t != nullptr, "field(const char *name, T *val, std::size_t): Type not found or generated");
-		m_type->fieldList.emplace_back(t, name, detail::indirectionLevels_v<T> + 1, subscriptStack, buildTypeId(*t));
+		m_type->fieldList.emplace_back(t, String(name), detail::indirectionLevels_v<T> + 1, subscriptStack, buildTypeId(*t));
 		return OxError(0);
 	}
 	return OxError(1);
@@ -208,7 +209,7 @@ constexpr Error TypeDescWriter::field(CRStringView name, UnionView<T, force> val
 	if (m_type) {
 		const auto t = type(val);
 		oxAssert(t != nullptr, "field(const char *name, T val): Type not found or generated");
-		m_type->fieldList.emplace_back(t, name, 0, SubscriptStack{}, t->typeName);
+		m_type->fieldList.emplace_back(t, String(name), 0, SubscriptStack{}, ox::String(t->typeName));
 		return OxError(0);
 	}
 	return OxError(1);
@@ -218,15 +219,17 @@ template<typename T>
 constexpr Error TypeDescWriter::field(CRStringView name, const T *val) noexcept {
 	if (m_type) {
 		if constexpr(isVector_v<T> || isArray_v<T>) {
-			return field(name, val->data(), 0, detail::buildSubscriptStack(val));
+			typename T::value_type *data = nullptr;
+			return field(name, data, 0, detail::buildSubscriptStack(val));
 		} else if constexpr(isSmartPtr_v<T>) {
-			return field(name, val->get(), 0, detail::buildSubscriptStack(val));
+			typename T::value_type *data = nullptr;
+			return field(name, data, 0, detail::buildSubscriptStack(val));
 		} else if constexpr(is_pointer_v<T>) {
 			return field(name, val, 0, detail::buildSubscriptStack(val));
 		} else {
 			const auto t = type(val);
 			oxAssert(t != nullptr, "field(const char *name, T *val): Type not found or generated");
-			m_type->fieldList.emplace_back(t, name, 0, SubscriptStack{}, buildTypeId(*t));
+			m_type->fieldList.emplace_back(t, String(name), 0, SubscriptStack{}, buildTypeId(*t));
 			return {};
 		}
 	}
@@ -237,7 +240,7 @@ template<typename ...Args>
 constexpr Error TypeDescWriter::fieldCString(CRStringView name, Args&&...) noexcept {
 	constexpr auto s = "";
 	const auto t = type(s);
-	m_type->fieldList.emplace_back(t, name, 0, SubscriptStack{}, t->typeName);
+	m_type->fieldList.emplace_back(t, String(name), 0, SubscriptStack{}, ox::String(t->typeName));
 	return {};
 }
 
@@ -344,7 +347,7 @@ constexpr const DescriptorType *TypeDescWriter::getType(CRStringView tn, int typ
 		oxAssert(type != nullptr, "TypeDescWriter::getType returning null DescriptorType");
 		return type;
 	} else {
-		auto dt = ox::make_unique<DescriptorType>(tn, typeVersion, pt, typeParams);
+		auto dt = ox::make_unique<DescriptorType>(String(tn), typeVersion, pt, typeParams);
 		dt->length = b;
 		const auto out = dt.get();
 		const auto typeId = buildTypeId(tn, typeVersion, typeParams);
@@ -356,15 +359,15 @@ constexpr const DescriptorType *TypeDescWriter::getType(CRStringView tn, int typ
 template<typename T>
 constexpr Result<DescriptorType*> buildTypeDef(TypeStore *typeStore) noexcept {
 	TypeDescWriter writer(typeStore);
-	ModelHandlerInterface handler(&writer);
+	ModelHandlerInterface<TypeDescWriter, ox::OpType::Reflect> handler(&writer);
 	if (std::is_constant_evaluated()) {
 		std::allocator<T> a;
 		T *t = a.allocate(1);
 		oxReturnError(model(&handler, t));
 		a.deallocate(t, 1);
 	} else {
-		T *t = reinterpret_cast<T*>(ox_alloca(sizeof(T)));
-		oxReturnError(model(&handler, t));
+		auto t = ox_malloca(sizeof(T), T);
+		oxReturnError(model(&handler, t.get()));
 	}
 	return writer.definition();
 }
@@ -372,7 +375,7 @@ constexpr Result<DescriptorType*> buildTypeDef(TypeStore *typeStore) noexcept {
 template<typename T>
 constexpr Result<DescriptorType*> buildTypeDef(TypeStore *typeStore, T *val) noexcept {
 	TypeDescWriter writer(typeStore);
-	ModelHandlerInterface handler(&writer);
+	ModelHandlerInterface<TypeDescWriter, ox::OpType::Reflect> handler(&writer);
 	oxReturnError(model(&handler, val));
 	return writer.definition();
 }

deps/ox/src/ox/model/modelhandleradaptor.hpp

@@ -14,7 +14,7 @@
 
 namespace ox {
 
-template<typename Handler>
+template<typename Handler, OpType opType_v = Handler::opType()>
 class ModelHandlerInterface {
 	private:
 		Handler *m_handler = nullptr;
@@ -25,10 +25,18 @@ class ModelHandlerInterface {
 
 		template<typename T = std::nullptr_t>
 		constexpr ox::Error setTypeInfo(
-				const char *name = T::TypeName,
-				int version = T::TypeVersion,
-				const Vector<String> &typeParams = {},
-				std::size_t fields = ModelFieldCount_v<T>) noexcept {
+			const char* name = T::TypeName,
+			int version = T::TypeVersion,
+			const Vector<String>& typeParams = {}) noexcept {
+			return m_handler->template setTypeInfo<T>(name, version, typeParams, ModelFieldCount_v<T>);
+		}
+
+		template<typename T = std::nullptr_t>
+		constexpr ox::Error setTypeInfo(
+			const char *name,
+			int version,
+			const Vector<String>& typeParams,
+			std::size_t fields) noexcept {
 			return m_handler->template setTypeInfo<T>(name, version, typeParams, fields);
 		}
 
@@ -38,28 +46,47 @@ class ModelHandlerInterface {
 		}
 
 		template<std::size_t len>
-		constexpr Error fieldCString(const char *name, const char val[len]) noexcept {
-			return m_handler->fieldCString(name, &val[0], len);
+		constexpr Error fieldCString(const char *name, const char val[len]) noexcept requires(opType_v != OpType::Read) {
+			if constexpr(opType_v != OpType::Read) {
+				return m_handler->fieldCString(name, &val[0], len);
+			} else {
+				return {};
+			}
 		}
 
 		constexpr Error fieldCString(const char *name, char **val) noexcept {
 			return m_handler->fieldCString(name, val);
 		}
 
-		constexpr Error fieldCString(const char *name, const char *const*val) noexcept {
-			return m_handler->fieldCString(name, val);
+		constexpr Error fieldCString(const char *name, const char *const*val) noexcept requires(opType_v != OpType::Read) {
+			// this check looks pointless, but it's to address a Clang bug
+			if constexpr(opType_v != OpType::Read) {
+				return m_handler->fieldCString(name, val);
+			} else {
+				return {};
+			}
 		}
 
-		constexpr Error fieldCString(const char *name, const char **val) noexcept {
-			return m_handler->fieldCString(name, val);
+		constexpr Error fieldCString(const char *name, const char **val) noexcept requires(opType_v != OpType::Read) {
+			// this check looks pointless, but it's to address a Clang bug
+			if constexpr(opType_v != OpType::Read) {
+				return m_handler->fieldCString(name, val);
+			} else {
+				return {};
+			}
 		}
 
 		constexpr Error fieldCString(const char *name, char **val, std::size_t buffLen) noexcept {
 			return m_handler->fieldCString(name, val, buffLen);
 		}
 
-		constexpr Error fieldCString(const char *name, const char **val, std::size_t buffLen) noexcept {
-			return m_handler->fieldCString(name, val, buffLen);
+		constexpr Error fieldCString(const char *name, const char **val, std::size_t buffLen) noexcept requires(opType_v != OpType::Read) {
+			// this check looks pointless, but it's to address a Clang bug
+			if constexpr(opType_v != OpType::Read) {
+				return m_handler->fieldCString(name, val, buffLen);
+			} else {
+				return {};
+			}
 		}
 
 		constexpr Error fieldCString(const char *name, char *val, std::size_t buffLen) noexcept {
@@ -95,7 +122,7 @@ class ModelHandlerInterface {
 				case ModelValue::Type::Union:
 				{
 					auto &u = v->template get<ModelUnion>();
-					if constexpr(Handler::opType() == OpType::Read) {
+					if constexpr(opType_v == OpType::Read) {
 						u.setActiveField(m_handler->whichFieldPresent(name, u));
 						return m_handler->field(name, UnionView<ModelUnion, true>(&u, u.unionIdx()));
 					} else {
@@ -169,13 +196,12 @@ class ModelHandlerInterface {
 		constexpr auto handler() noexcept {
 			return m_handler;
 		}
-
 };
 
-template<typename Handler>
+template<typename Handler, ox::OpType opType_v = Handler::opType()>
 class ModelHandlerBase {
 	private:
-		ModelHandlerInterface<Handler> m_interface;
+		ModelHandlerInterface<Handler, opType_v> m_interface;
 	public:
 		constexpr ModelHandlerBase() noexcept: m_interface(static_cast<Handler*>(this)) {}
 		constexpr ModelHandlerBase(const ModelHandlerBase&) noexcept: m_interface(static_cast<Handler*>(this)) {}
@@ -184,6 +210,20 @@ class ModelHandlerBase {
 		constexpr auto interface() noexcept {
 			return &m_interface;
 		}
+		[[nodiscard]]
+		static constexpr ox::OpType opType() noexcept {
+			return opType_v;
+		}
 };
 
+
+constexpr ox::Error resizeVector(auto &vec, size_t sz) {
+	if constexpr(ox::is_same_v<decltype(vec.resize(0)), ox::Error>) {
+		return vec.resize(sz);
+	} else {
+		vec.resize(sz);
+		return {};
+	}
+}
+
 }

deps/ox/src/ox/model/modelvalue.hpp

@@ -144,8 +144,6 @@ class ModelValue {
 
 		constexpr ModelValue(const ModelValue &other) noexcept;
 
-		constexpr ModelValue(ModelValue &other) noexcept;
-
 		constexpr ModelValue(ModelValue &&other) noexcept;
 
 		template<typename T>
@@ -204,7 +202,8 @@ class ModelValue {
 class ModelValueVector {
 	private:
 		Vector<ModelValue> m_vec;
-		ModelValue m_templateValue;
+		const DescriptorType *m_type = nullptr;
+		int m_typeSubscriptLevels = 0;
 		String m_typeName;
 		int m_typeVersion = 0;
 
@@ -229,14 +228,15 @@ class ModelValueVector {
 			return m_vec.data();
 		}
 
-		constexpr void resize(std::size_t sz) noexcept {
+		constexpr ox::Error resize(std::size_t sz) noexcept {
 			const auto oldSz = m_vec.size();
 			m_vec.resize(sz);
 			if (sz > oldSz) {
 				for (auto i = oldSz; i < sz; ++i) {
-					m_vec[i] = m_templateValue;
+					oxReturnError(m_vec[i].setType(m_type, m_typeSubscriptLevels));
 				}
 			}
+			return {};
 		}
 
 		[[nodiscard]]
@@ -250,7 +250,9 @@ class ModelValueVector {
 		}
 
 		constexpr Error setType(const DescriptorType *type, int subscriptLevels) noexcept {
-			return m_templateValue.setType(type, subscriptLevels);
+			m_type = type;
+			m_typeSubscriptLevels = subscriptLevels;
+			return {};
 		}
 
 		[[nodiscard]]
@@ -350,7 +352,7 @@ class ModelObject {
 
 		constexpr ModelObject(const ModelObject &other) noexcept {
 			for (const auto &f : other.m_fieldsOrder) {
-				auto &field = m_fieldsOrder.emplace_back(new Field{f->name, f->value});
+				auto &field = m_fieldsOrder.emplace_back(new Field{ox::String(f->name), f->value});
 				m_fields[field->name] = &field->value;
 			}
 			m_type = other.m_type;
@@ -427,7 +429,7 @@ class ModelObject {
 				return *this;
 			}
 			for (const auto &f : other.m_fieldsOrder) {
-				auto &field = m_fieldsOrder.emplace_back(new Field{f->name, f->value});
+				auto &field = m_fieldsOrder.emplace_back(new Field{ox::String(f->name), f->value});
 				m_fields[field->name] = &field->value;
 			}
 			m_type = other.m_type;
@@ -450,7 +452,7 @@ class ModelObject {
 			f = val;
 		}
 
-		constexpr Result<const ModelValue*> get(const String &k) const noexcept {
+		constexpr Result<const ModelValue*> get(StringView const&k) const noexcept {
 			if (m_fields.contains(k)) {
 				return *m_fields.at(k).value;
 			}
@@ -464,7 +466,7 @@ class ModelObject {
 			return {};
 		}
 
-		constexpr auto &operator[](const String &k) noexcept {
+		constexpr auto &operator[](StringView const&k) noexcept {
 			auto [v, err] = m_fields.at(k);
 			if (err) [[unlikely]] {
 				oxPanic(err, ox::sfmt("field {} does not exist in type {}", k, buildTypeId(*m_type)).c_str());
@@ -528,7 +530,7 @@ class ModelUnion {
 	public:
 		constexpr ModelUnion(const ModelUnion &other) noexcept {
 			for (auto i = 0; const auto &f : other.m_fieldsOrder) {
-				auto &field = m_fieldsOrder.emplace_back(new Field{i, f->name, f->value});
+				auto &field = m_fieldsOrder.emplace_back(new Field{i, ox::String(f->name), f->value});
 				m_fields[field->name] = field.get();
 				++i;
 			}
@@ -553,7 +555,7 @@ class ModelUnion {
 			return UniquePtr<ModelUnion>(new ModelUnion(other));
 		}
 
-		constexpr auto &operator[](const String &k) noexcept {
+		constexpr auto &operator[](StringView const&k) noexcept {
 			const auto [v, err] = m_fields.at(k);
 			if (err) [[unlikely]] {
 				oxPanic(err, ox::sfmt("field {} does not exist in type {}", k, buildTypeId(*m_type)).c_str());
@@ -588,7 +590,7 @@ class ModelUnion {
 		}
 
 		[[nodiscard]]
-		constexpr Result<const ModelValue*> get(const String &k) const noexcept {
+		constexpr Result<const ModelValue*> get(StringView const&k) const noexcept {
 			oxRequire(t, m_fields.at(k));
 			return &(*t)->value;
 		}
@@ -814,9 +816,6 @@ constexpr ModelValue::ModelValue(const ModelValue &other) noexcept {
 	}
 }
 
-constexpr ModelValue::ModelValue(ModelValue &other) noexcept: ModelValue(const_cast<const ModelValue&>(other)) {
-}
-
 constexpr ModelValue::ModelValue(ModelValue &&other) noexcept {
 	m_type = other.m_type;
 	switch (m_type) {
@@ -1094,14 +1093,12 @@ constexpr ModelValueVector::ModelValueVector(const ModelValueVector &other) noex
 	for (auto &v : other.m_vec) {
 		m_vec.emplace_back(v);
 	}
-	m_templateValue = other.m_templateValue;
 	m_typeName = other.m_typeName;
 	m_typeVersion = other.m_typeVersion;
 }
 
 constexpr ModelValueVector::ModelValueVector(ModelValueVector &&other) noexcept {
 	m_vec = std::move(other.m_vec);
-	m_templateValue = std::move(other.m_templateValue);
 	m_typeName = std::move(other.m_typeName);
 	m_typeVersion = other.m_typeVersion;
 }
@@ -1113,7 +1110,6 @@ constexpr ModelValueVector &ModelValueVector::operator=(const ModelValueVector &
 	for (auto &v : other.m_vec) {
 		m_vec.emplace_back(v);
 	}
-	m_templateValue = other.m_templateValue;
 	m_typeName = other.m_typeName;
 	m_typeVersion = other.m_typeVersion;
 	return *this;
@@ -1124,7 +1120,6 @@ constexpr ModelValueVector &ModelValueVector::operator=(ModelValueVector &&other
 		return *this;
 	}
 	m_vec = std::move(other.m_vec);
-	m_templateValue = std::move(other.m_templateValue);
 	m_typeName = std::move(other.m_typeName);
 	m_typeVersion = other.m_typeVersion;
 	return *this;

deps/ox/src/ox/model/test/CMakeLists.txt

@@ -8,6 +8,6 @@ target_link_libraries(
 		OxModel
 )
 
-add_test("[ox/model] ModelTest ModelValue" ModelTest ModelValue)
-add_test("[ox/model] ModelTest getModelTypeName" ModelTest getModelTypeName)
-add_test("[ox/model] ModelTest getModelTypeVersion" ModelTest getModelTypeVersion)
+add_test("[ox/model] ModelValue" ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/ModelTest ModelValue)
+add_test("[ox/model] getModelTypeName" ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/ModelTest getModelTypeName)
+add_test("[ox/model] getModelTypeVersion" ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/ModelTest getModelTypeVersion)

deps/ox/src/ox/model/test/tests.cpp

@@ -32,7 +32,7 @@ constexpr auto getModelTypeVersion(TestType2*) noexcept {
 	return 2;
 }
 
-std::map<ox::String, ox::Error(*)()> tests = {
+std::map<ox::StringView, ox::Error(*)()> tests = {
 	{
 		{
 			"ModelValue",
@@ -47,6 +47,7 @@ std::map<ox::String, ox::Error(*)()> tests = {
 				return ox::Error{};
 			}
 		},
+
 		{
 			"getModelTypeName",
 			[] {
@@ -55,6 +56,7 @@ std::map<ox::String, ox::Error(*)()> tests = {
 				return ox::Error{};
 			}
 		},
+
 		{
 			"getModelTypeVersion",
 			[] {
@@ -67,11 +69,14 @@ std::map<ox::String, ox::Error(*)()> tests = {
 };
 
 int main(int argc, const char **args) {
-	if (argc > 0) {
-		auto testName = args[1];
-		if (tests.find(testName) != tests.end()) {
-			oxAssert(tests[testName](), "Test failed...");
-		}
+	if (argc < 2) {
+		oxError("Must specify test to run");
 	}
-	return 0;
+	auto const testName = args[1];
+	auto const func = tests.find(testName);
+	if (func != tests.end()) {
+		oxAssert(func->second(), "Test returned Error");
+		return 0;
+	}
+	return -1;
 }

deps/ox/src/ox/model/types.hpp

@@ -79,9 +79,6 @@ static_assert(isBasicString_v<ox::BasicString<0ul>>);
 static_assert(isBasicString_v<ox::BasicString<8ul>>);
 static_assert(isBasicString_v<ox::String>);
 
-template<typename T>
-constexpr bool isOxString_v = isBString_v<T> || isBasicString_v<T>;
-
 template<typename T>
 consteval bool isOxVector(const T*) noexcept {
 	return false;

deps/ox/src/ox/model/typestore.hpp

@@ -44,11 +44,11 @@ class TypeStore {
 			return out->get();
 		}
 
-		constexpr DescriptorType *getInit(const auto &typeName, int typeVersion, PrimitiveType pt,
+		constexpr DescriptorType *getInit(CRStringView typeName, int typeVersion, PrimitiveType pt,
 		                                  const TypeParamPack &typeParams) noexcept {
 			const auto typeId = buildTypeId(typeName, typeVersion, typeParams);
 			auto &out = m_cache[typeId];
-			out = ox::make_unique<DescriptorType>(typeName, typeVersion, pt, typeParams);
+			out = ox::make_unique<DescriptorType>(String(typeName), typeVersion, pt, typeParams);
 			return out.get();
 		}
 
@@ -58,7 +58,7 @@ class TypeStore {
 				if (!std::is_constant_evaluated()) {
 					oxRequireM(dt, loadDescriptor(typeId));
 					for (auto &f : dt->fieldList) {
-						oxReturnError(this->getLoad(f.typeId).moveTo(&f.type));
+						oxReturnError(this->getLoad(f.typeId).moveTo(f.type));
 					}
 					auto &out = m_cache[typeId];
 					out = std::move(dt);

deps/ox/src/ox/model/walk.hpp

@@ -144,6 +144,13 @@ constexpr Error model(Reader *rdr, DataWalker<Reader, FH> *walker) noexcept {
 	return OxError(0);
 }
 
+template<typename Reader, typename Handler>
+constexpr Error walkModel(DescriptorType *type, Reader_c auto &reader, Handler handler) noexcept {
+	DataWalker<Reader, Handler> walker(type, handler);
+	Reader rdr(reader);
+	return model(&rdr, &walker);
+}
+
 template<typename Reader, typename Handler>
 constexpr Error walkModel(DescriptorType *type, const char *data, std::size_t dataLen, Handler handler) noexcept {
 	DataWalker<Reader, Handler> walker(type, handler);

deps/ox/src/ox/oc/read.cpp

@@ -265,7 +265,7 @@ Error OrganicClawReader::fieldCString(const char *key, char **val, std::size_t b
 Error OrganicClawReader::field(const char *key, UUID *val) noexcept {
 	UUIDStr str;
 	oxReturnError(field(key, &str));
-	return UUID::fromString(str).moveTo(val);
+	return UUID::fromString(str).moveTo(*val);
 }
 
 Result<std::size_t> OrganicClawReader::arrayLength(const char *key, bool) noexcept {

deps/ox/src/ox/oc/read.hpp

@@ -147,7 +147,7 @@ Error OrganicClawReader::field(const char *key, T *val) noexcept {
 	if constexpr(isVector_v<T>) {
 		const auto &srcVal = value(key);
 		const auto srcSize = srcVal.size();
-		val->resize(srcSize);
+		oxReturnError(ox::resizeVector(*val, srcSize));
 		err = field(key, val->data(), val->size());
 	} else if constexpr(isArray_v<T>) {
 		const auto &srcVal = value(key);
@@ -194,7 +194,7 @@ Error OrganicClawReader::field(const char *key, BasicString<L> *val) noexcept {
 	if (targetValid()) {
 		const auto &jv = value(key);
 		if (jv.empty()) {
-			*val = 0;
+			*val = BasicString<L>{};
 		} else if (jv.isString()) {
 			*val = jv.asString().c_str();
 		} else {

deps/ox/src/ox/oc/test/CMakeLists.txt

@@ -8,7 +8,7 @@ target_link_libraries(
 		OxOrganicClaw
 )
 
-add_test("[ox/oc] OcTest Writer" OcTest OrganicClawWriter)
-add_test("[ox/oc] OcTest Reader" OcTest OrganicClawReader)
-add_test("[ox/oc] OcTest OrganicClawModelValue" OcTest OrganicClawModelValue)
-add_test("[ox/oc] OcTest OrganicClawDef" OcTest OrganicClawDef)
+add_test("[ox/oc] Writer" ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/OcTest OrganicClawWriter)
+add_test("[ox/oc] Reader" ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/OcTest OrganicClawReader)
+add_test("[ox/oc] OrganicClawModelValue" ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/OcTest OrganicClawModelValue)
+add_test("[ox/oc] OrganicClawDef" ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/OcTest OrganicClawDef)

deps/ox/src/ox/oc/test/tests.cpp

@@ -53,7 +53,7 @@ struct TestStruct {
 	int32_t Int8 = 0;
 	int unionIdx = 1;
 	TestUnion Union;
-	ox::String String = "";
+	ox::String String{""};
 	uint32_t List[4] = {0, 0, 0, 0};
 	ox::HashMap<ox::String, int> Map;
 	TestStructNest EmptyStruct;
@@ -124,7 +124,7 @@ constexpr TestStruct &TestStruct::operator=(TestStruct &&other) noexcept {
 	return *this;
 }
 
-const std::map<std::string_view, ox::Error(*)()> tests = {
+const std::map<ox::StringView, ox::Error(*)()> tests = {
 	{
 		{
 			"OrganicClawWriter",
@@ -189,53 +189,53 @@ const std::map<std::string_view, ox::Error(*)()> tests = {
 		},
 
 		{
-				"OrganicClawModelValue",
-				[] {
-					ox::Buffer dataBuff;
-					TestStruct testIn;
-					testIn.Bool = true;
-					testIn.Int = 42;
-					testIn.String = "Test String 1";
-					testIn.List[0] = 1;
-					testIn.List[1] = 2;
-					testIn.List[2] = 3;
-					testIn.List[3] = 4;
-					testIn.Struct.Bool = false;
-					testIn.Struct.Int = 300;
-					testIn.Struct.String = "Test String 2";
-					testIn.unionIdx = 1;
-					testIn.Union.Int = 93;
-					oxAssert(ox::writeOC(testIn).moveTo(&dataBuff), "Data generation failed");
-					ox::TypeStore typeStore;
-					auto type = ox::buildTypeDef(&typeStore, &testIn);
-					oxAssert(type.error, "Descriptor write failed");
-					ox::ModelObject testOut;
-					oxReturnError(testOut.setType(type.value));
-					oxAssert(ox::readOC(dataBuff.data(), dataBuff.size(), &testOut), "Data read failed");
-					oxAssert(testOut.get("Int").unwrap()->get<int>() == testIn.Int, "testOut.Int failed");
-					oxAssert(testOut.get("Bool").unwrap()->get<bool>() == testIn.Bool, "testOut.Bool failed");
-					oxAssert(testOut.get("String").unwrap()->get<ox::String>() == testIn.String, "testOut.String failed");
-					auto &testOutStruct = testOut.get("Struct").unwrap()->get<ox::ModelObject>();
-					auto &testOutUnion = testOut.get("Union").unwrap()->get<ox::ModelUnion>();
-					auto &testOutList = testOut.get("List").unwrap()->get<ox::ModelValueVector>();
-					auto testOutStructCopy = testOut.get("Struct").unwrap()->get<ox::ModelObject>();
-					auto testOutUnionCopy = testOut.get("Union").unwrap()->get<ox::ModelUnion>();
-					auto testOutListCopy = testOut.get("List").unwrap()->get<ox::ModelValueVector>();
-					oxAssert(testOutStruct.typeName() == TestStructNest::TypeName, "ModelObject TypeName failed");
-					oxAssert(testOutStruct.typeVersion() == TestStructNest::TypeVersion, "ModelObject TypeVersion failed");
-					oxAssert(testOutStruct.get("Bool").unwrap()->get<bool>() == testIn.Struct.Bool, "testOut.Struct.Bool failed");
-					oxAssert(testOutStruct.get("String").unwrap()->get<ox::String>() == testIn.Struct.String.c_str(), "testOut.Struct.String failed");
-					oxAssert(testOut.get("unionIdx").unwrap()->get<int>() == testIn.unionIdx, "testOut.unionIdx failed");
-					oxAssert(testOutUnion.unionIdx() == testIn.unionIdx, "testOut.Union idx wrong");
-					oxAssert(testOutUnion.get("Int").unwrap()->get<uint32_t>() == testIn.Union.Int, "testOut.Union.Int failed");
-					oxAssert(testOutList[0].get<uint32_t>() == testIn.List[0], "testOut.List[0] failed");
-					oxAssert(testOutList[1].get<uint32_t>() == testIn.List[1], "testOut.Struct.List[1] failed");
-					oxAssert(testOutStructCopy.get("Bool").unwrap()->get<bool>() == testIn.Struct.Bool, "testOut.Struct.Bool (copy) failed");
-					oxAssert(testOutStructCopy.get("String").unwrap()->get<ox::String>() == testIn.Struct.String.c_str(), "testOut.Struct.String (copy) failed");
-					oxAssert(testOutListCopy[0].get<uint32_t>() == testIn.List[0], "testOut.Struct.List[0] (copy) failed");
-					oxAssert(testOutListCopy[1].get<uint32_t>() == testIn.List[1], "testOut.Struct.List[1] (copy) failed");
-					return OxError(0);
-				}
+			"OrganicClawModelValue",
+			[] {
+		   ox::Buffer dataBuff;
+		   TestStruct testIn;
+		   testIn.Bool = true;
+		   testIn.Int = 42;
+		   testIn.String = "Test String 1";
+		   testIn.List[0] = 1;
+		   testIn.List[1] = 2;
+		   testIn.List[2] = 3;
+		   testIn.List[3] = 4;
+		   testIn.Struct.Bool = false;
+		   testIn.Struct.Int = 300;
+		   testIn.Struct.String = "Test String 2";
+		   testIn.unionIdx = 1;
+		   testIn.Union.Int = 93;
+		   oxAssert(ox::writeOC(testIn).moveTo(dataBuff), "Data generation failed");
+		   ox::TypeStore typeStore;
+		   auto type = ox::buildTypeDef(&typeStore, &testIn);
+		   oxAssert(type.error, "Descriptor write failed");
+		   ox::ModelObject testOut;
+		   oxReturnError(testOut.setType(type.value));
+		   oxAssert(ox::readOC(dataBuff.data(), dataBuff.size(), &testOut), "Data read failed");
+		   oxAssert(testOut.get("Int").unwrap()->get<int>() == testIn.Int, "testOut.Int failed");
+		   oxAssert(testOut.get("Bool").unwrap()->get<bool>() == testIn.Bool, "testOut.Bool failed");
+		   oxAssert(testOut.get("String").unwrap()->get<ox::String>() == testIn.String, "testOut.String failed");
+		   auto &testOutStruct = testOut.get("Struct").unwrap()->get<ox::ModelObject>();
+		   auto &testOutUnion = testOut.get("Union").unwrap()->get<ox::ModelUnion>();
+		   auto &testOutList = testOut.get("List").unwrap()->get<ox::ModelValueVector>();
+		   auto testOutStructCopy = testOut.get("Struct").unwrap()->get<ox::ModelObject>();
+		   auto testOutUnionCopy = testOut.get("Union").unwrap()->get<ox::ModelUnion>();
+		   auto testOutListCopy = testOut.get("List").unwrap()->get<ox::ModelValueVector>();
+		   oxAssert(testOutStruct.typeName() == TestStructNest::TypeName, "ModelObject TypeName failed");
+		   oxAssert(testOutStruct.typeVersion() == TestStructNest::TypeVersion, "ModelObject TypeVersion failed");
+		   oxAssert(testOutStruct.get("Bool").unwrap()->get<bool>() == testIn.Struct.Bool, "testOut.Struct.Bool failed");
+		   oxAssert(testOutStruct.get("String").unwrap()->get<ox::String>() == testIn.Struct.String.c_str(), "testOut.Struct.String failed");
+		   oxAssert(testOut.get("unionIdx").unwrap()->get<int>() == testIn.unionIdx, "testOut.unionIdx failed");
+		   oxAssert(testOutUnion.unionIdx() == testIn.unionIdx, "testOut.Union idx wrong");
+		   oxAssert(testOutUnion.get("Int").unwrap()->get<uint32_t>() == testIn.Union.Int, "testOut.Union.Int failed");
+		   oxAssert(testOutList[0].get<uint32_t>() == testIn.List[0], "testOut.List[0] failed");
+		   oxAssert(testOutList[1].get<uint32_t>() == testIn.List[1], "testOut.Struct.List[1] failed");
+		   oxAssert(testOutStructCopy.get("Bool").unwrap()->get<bool>() == testIn.Struct.Bool, "testOut.Struct.Bool (copy) failed");
+		   oxAssert(testOutStructCopy.get("String").unwrap()->get<ox::String>() == testIn.Struct.String.c_str(), "testOut.Struct.String (copy) failed");
+		   oxAssert(testOutListCopy[0].get<uint32_t>() == testIn.List[0], "testOut.Struct.List[0] (copy) failed");
+		   oxAssert(testOutListCopy[1].get<uint32_t>() == testIn.List[1], "testOut.Struct.List[1] (copy) failed");
+		   return OxError(0);
+		   }
 		},
 
 		{
@@ -354,13 +354,11 @@ int main(int argc, const char **args) {
 	if (argc < 2) {
 		oxError("Must specify test to run");
 	}
-	const auto testName = args[1];
-	ox::Error(*test)();
-	try {
-		test = tests.at(testName);
-	} catch (const std::out_of_range&) {
-		oxErrorf("Test {} not found", testName);
-		return 1;
+	auto const testName = args[1];
+	auto const func = tests.find(testName);
+	if (func != tests.end()) {
+		oxAssert(func->second(), "Test returned Error");
+		return 0;
 	}
-	return static_cast<int>(test());
+	return -1;
 }

deps/ox/src/ox/oc/write.cpp

@@ -26,16 +26,8 @@ Error OrganicClawWriter::fieldCString(const char *key, const char *const*val, in
 	return OxError(0);
 }
 
-Error OrganicClawWriter::fieldCString(const char *key, char **val, int len) noexcept {
-	return fieldCString(key, const_cast<const char**>(val), len);
-}
-
 Error OrganicClawWriter::fieldCString(const char *key, const char *const*val) noexcept {
-	return fieldCString(key, const_cast<const char**>(val), {});
-}
-
-Error OrganicClawWriter::fieldCString(const char *key, char **val) noexcept {
-	return fieldCString(key, const_cast<const char**>(val), {});
+	return fieldCString(key, const_cast<const char**>(val), static_cast<int>(ox_strlen(val)));
 }
 
 Error OrganicClawWriter::field(const char *key, const UUID *uuid) noexcept {

deps/ox/src/ox/oc/write.hpp

@@ -36,32 +36,32 @@ class OrganicClawWriter {
 
 		explicit OrganicClawWriter(Json::Value json, int unionIdx = -1) noexcept;
 
-		Error field(const char *key, CommonPtrWith<int8_t> auto *val) noexcept {
-			if (*val) {
+		Error field(const char *key, const int8_t *val) noexcept {
+			if (targetValid() && (*val || m_json.isArray())) {
 				value(key) = *val;
 			}
 			++m_fieldIt;
 			return OxError(0);
 		}
 
-		Error field(const char *key, CommonPtrWith<int16_t> auto *val) noexcept {
-			if (*val) {
+		Error field(const char *key, const int16_t *val) noexcept {
+			if (targetValid() && (*val || m_json.isArray())) {
 				value(key) = *val;
 			}
 			++m_fieldIt;
 			return OxError(0);
 		}
 
-		Error field(const char *key, CommonPtrWith<int32_t> auto *val) noexcept {
-			if (*val) {
+		Error field(const char *key, const int32_t *val) noexcept {
+			if (targetValid() && (*val || m_json.isArray())) {
 				value(key) = *val;
 			}
 			++m_fieldIt;
 			return OxError(0);
 		}
 
-		Error field(const char *key, CommonPtrWith<int64_t> auto *val) noexcept {
-			if (*val) {
+		Error field(const char *key, const int64_t *val) noexcept {
+			if (targetValid() && (*val || m_json.isArray())) {
 				value(key) = *val;
 			}
 			++m_fieldIt;
@@ -69,58 +69,55 @@ class OrganicClawWriter {
 		}
 
 
-		Error field(const char *key, CommonPtrWith<uint8_t> auto *val) noexcept {
-			if (*val) {
+		Error field(const char *key, const uint8_t *val) noexcept {
+			if (targetValid() && (*val || m_json.isArray())) {
 				value(key) = *val;
 			}
 			++m_fieldIt;
 			return OxError(0);
 		}
 
-		Error field(const char *key, CommonPtrWith<uint16_t> auto *val) noexcept {
-			if (targetValid() && *val) {
+		Error field(const char *key, const uint16_t *val) noexcept {
+			if (targetValid() && (*val || m_json.isArray())) {
 				value(key) = *val;
 			}
 			++m_fieldIt;
 			return OxError(0);
 		}
 
-		Error field(const char *key, CommonPtrWith<uint32_t> auto *val) noexcept {
-			if (targetValid() && *val) {
+		Error field(const char *key, const uint32_t *val) noexcept {
+			if (targetValid() && (*val || m_json.isArray())) {
 				value(key) = *val;
 			}
 			++m_fieldIt;
 			return OxError(0);
 		}
 
-		Error field(const char *key, CommonPtrWith<uint64_t> auto *val) noexcept {
-			if (targetValid() && *val) {
+		Error field(const char *key, const uint64_t *val) noexcept {
+			if (targetValid() && (*val || m_json.isArray())) {
 				value(key) = *val;
 			}
 			++m_fieldIt;
 			return OxError(0);
 		}
 
-		Error field(const char *key, CommonPtrWith<bool> auto *val) noexcept {
-			if (targetValid() && *val) {
+		Error field(char const*key, bool const*val) noexcept {
+			if (targetValid() && (*val || m_json.isArray())) {
 				value(key) = *val;
 			}
 			++m_fieldIt;
 			return {};
 		}
 
-		template<typename T>
-		Error field(const char*, T *val, std::size_t len) noexcept;
-
 		template<typename U, bool force = true>
-		Error field(const char*, UnionView<U, force> val) noexcept;
+		Error field(char const*, UnionView<U, force> val) noexcept;
 
 		template<typename T>
-		Error field(const char *key, const HashMap<String, T> *val) noexcept {
+		Error field(char const*key, HashMap<String, T> const*val) noexcept {
 			if (targetValid()) {
 				const auto &keys = val->keys();
 				OrganicClawWriter w;
-				ModelHandlerInterface handler{&w};
+				ModelHandlerInterface<OrganicClawWriter, OpType::Write> handler{&w};
 				for (std::size_t i = 0; i < keys.size(); ++i) {
 					const auto k = keys[i].c_str();
 					if (k) [[likely]] {
@@ -134,13 +131,8 @@ class OrganicClawWriter {
 			return {};
 		}
 
-		template<typename T>
-		Error field(const char *key, HashMap<String, T> *val) noexcept {
-			return field(key, const_cast<const HashMap<String, T>*>(val));
-		}
-
 		template<std::size_t L>
-		Error field(const char *key, const BString<L> *val) noexcept {
+		Error field(char const*key, BString<L> const*val) noexcept {
 			if (targetValid() && val->len()) {
 				value(key) = val->c_str();
 			}
@@ -149,16 +141,7 @@ class OrganicClawWriter {
 		}
 
 		template<std::size_t L>
-		Error field(const char *key, BString<L> *val) noexcept {
-			if (targetValid() && val->len()) {
-				value(key) = val->c_str();
-			}
-			++m_fieldIt;
-			return {};
-		}
-
-		template<std::size_t L>
-		Error field(const char *key, const BasicString<L> *val) noexcept {
+		Error field(char const*key, BasicString<L> const*val) noexcept {
 			if (targetValid() && val->len()) {
 				value(key) = val->c_str();
 			}
@@ -166,33 +149,35 @@ class OrganicClawWriter {
 			return OxError(0);
 		}
 
-		template<std::size_t L>
-		Error field(const char *key, BasicString<L> *val) noexcept {
-			return field(key, const_cast<const BasicString<L>*>(val));
-		}
-
 		Error fieldCString(const char*, const char *const*val, int len) noexcept;
 
-		Error fieldCString(const char *name, char **val, int len) noexcept;
-
 		Error fieldCString(const char *name, const char *const*val) noexcept;
 
-		Error fieldCString(const char *name, char **val) noexcept;
-
 		Error field(const char *key, const UUID *uuid) noexcept;
 
 		template<typename T>
-		Error field(const char*, T *val) noexcept;
+		Error field(const char*, const T *val, std::size_t len) noexcept;
+
+		template<typename T>
+		Error field(const char*, const T *val) noexcept;
 
 		template<typename T>
 		constexpr ox::Error setTypeInfo(
 				const char* = T::TypeName,
-				int = T::TypeVersion,
-				const Vector<String>& = {},
-				std::size_t = ModelFieldCount_v<T>) noexcept {
+				int = T::TypeVersion) noexcept {
 			return {};
 		}
 
+		template<typename T>
+		constexpr ox::Error setTypeInfo(
+				const char*,
+				int,
+				const Vector<String>&,
+				std::size_t) noexcept {
+			return {};
+		}
+
+		[[nodiscard]]
 		static constexpr auto opType() noexcept {
 			return OpType::Write;
 		}
@@ -209,12 +194,12 @@ class OrganicClawWriter {
 };
 
 template<typename T>
-Error OrganicClawWriter::field(const char *key, T *val, std::size_t len) noexcept {
+Error OrganicClawWriter::field(const char *key, const T *val, std::size_t len) noexcept {
 	if (targetValid() && len) {
 		OrganicClawWriter w((Json::Value(Json::arrayValue)));
-		ModelHandlerInterface handler{&w};
+		ModelHandlerInterface<OrganicClawWriter, OpType::Write> handler{&w};
 		for (std::size_t i = 0; i < len; ++i) {
-			oxReturnError(handler.field("", &val[i]));
+			oxReturnError(handler.field({}, &val[i]));
 		}
 		value(key) = w.m_json;
 	}
@@ -223,12 +208,12 @@ Error OrganicClawWriter::field(const char *key, T *val, std::size_t len) noexcep
 }
 
 template<typename T>
-Error OrganicClawWriter::field(const char *key, T *val) noexcept {
+Error OrganicClawWriter::field(const char *key, const T *val) noexcept {
 	if constexpr(isVector_v<T> || isArray_v<T>) {
 		return field(key, val->data(), val->size());
 	} else if (val && targetValid()) {
 		OrganicClawWriter w;
-		ModelHandlerInterface handler{&w};
+		ModelHandlerInterface<OrganicClawWriter, OpType::Write> handler{&w};
 		oxReturnError(model(&handler, val));
 		if (!w.m_json.isNull()) {
 			value(key) = w.m_json;
@@ -242,7 +227,7 @@ template<typename U, bool force>
 Error OrganicClawWriter::field(const char *key, UnionView<U, force> val) noexcept {
 	if (targetValid()) {
 		OrganicClawWriter w(val.idx());
-		ModelHandlerInterface handler{&w};
+		ModelHandlerInterface<OrganicClawWriter, OpType::Write> handler{&w};
 		oxReturnError(model(&handler, val.get()));
 		if (!w.m_json.isNull()) {
 			value(key) = w.m_json;
@@ -254,7 +239,7 @@ Error OrganicClawWriter::field(const char *key, UnionView<U, force> val) noexcep
 
 Result<Buffer> writeOC(const auto &val) noexcept {
 	OrganicClawWriter writer;
-	ModelHandlerInterface handler(&writer);
+	ModelHandlerInterface<OrganicClawWriter, OpType::Write> handler(&writer);
 	oxReturnError(model(&handler, &val));
 	Json::StreamWriterBuilder jsonBuilder;
 	const auto str = Json::writeString(jsonBuilder, writer.m_json);

deps/ox/src/ox/preloader/CMakeLists.txt

@@ -1,6 +1,6 @@
 
 add_library(
-	OxPreloader STATIC
+	OxPreloader
 		preloader.cpp
 )
 

deps/ox/src/ox/preloader/alignmentcatcher.hpp

@@ -22,15 +22,22 @@ template<typename PlatSpec, typename T>
 constexpr std::size_t sizeOf(const T *t) noexcept;
 
 template<typename PlatSpec>
-struct AlignmentCatcher: public ModelHandlerBase<AlignmentCatcher<PlatSpec>> {
+struct AlignmentCatcher: public ModelHandlerBase<AlignmentCatcher<PlatSpec>, OpType::Reflect> {
 	std::size_t biggestAlignment = 1;
 
 	template<typename T>
 	constexpr ox::Error setTypeInfo(
 			const char* = T::TypeName,
-			int = T::TypeVersion,
-			const Vector<String>& = {},
-			std::size_t = ModelFieldCount_v<T>) noexcept {
+			int = T::TypeVersion) noexcept {
+		return {};
+	}
+
+	template<typename T>
+	constexpr ox::Error setTypeInfo(
+			const char*,
+			int,
+			const Vector<String>&,
+			std::size_t) noexcept {
 		return {};
 	}
 
@@ -57,11 +64,6 @@ struct AlignmentCatcher: public ModelHandlerBase<AlignmentCatcher<PlatSpec>> {
 		return {};
 	}
 
-	[[nodiscard]]
-	static constexpr auto opType() noexcept {
-		return ox::OpType::Reflect;
-	}
-
 };
 
 }

deps/ox/src/ox/preloader/platspecs.hpp

@@ -13,6 +13,7 @@
 namespace ox {
 
 struct NativePlatSpec {
+	static constexpr std::size_t RomStart = 1024;
 	using PtrType = uintptr_t;
 	using size_t = std::size_t;
 

deps/ox/src/ox/preloader/preloader.cpp

@@ -6,4 +6,6 @@
 
 namespace ox {
 
+template class Preloader<NativePlatSpec>;
+
 }

deps/ox/src/ox/preloader/preloader.hpp

@@ -15,7 +15,6 @@
 #include <ox/std/units.hpp>
 #include <ox/model/modelhandleradaptor.hpp>
 
-#include "preloader.hpp"
 #include "platspecs.hpp"
 
 namespace ox {
@@ -23,14 +22,8 @@ namespace ox {
 template<typename PlatSpec>
 class Preloader;
 
-template<typename PlatSpec, typename T>
-constexpr ox::Error preload(Preloader<PlatSpec> *pl, ox::CommonPtrWith<T> auto *obj) noexcept;
-
 template<typename PlatSpec>
-class Preloader: public ModelHandlerBase<Preloader<PlatSpec>> {
-	template<typename PS, typename T>
-	friend constexpr ox::Error preload(Preloader<PS> *pl, ox::CommonPtrWith<T> auto *obj) noexcept;
-
+class Preloader: public ModelHandlerBase<Preloader<PlatSpec>, OpType::Reflect> {
 	private:
 		using PtrType = typename PlatSpec::PtrType;
 		static constexpr auto PtrSize = sizeof(PtrType);
@@ -80,9 +73,16 @@ class Preloader: public ModelHandlerBase<Preloader<PlatSpec>> {
 		template<typename T>
 		constexpr ox::Error setTypeInfo(
 				const char* = T::TypeName,
-				int = T::TypeVersion,
-				const Vector<String>& = {},
-				std::size_t = ModelFieldCount_v<T>) noexcept {
+				int = T::TypeVersion) noexcept {
+			return {};
+		}
+
+		template<typename T>
+		constexpr ox::Error setTypeInfo(
+				const char*,
+				int,
+				const Vector<String>&,
+				std::size_t) noexcept {
 			return {};
 		}
 
@@ -114,12 +114,6 @@ class Preloader: public ModelHandlerBase<Preloader<PlatSpec>> {
 			return m_buff;
 		}
 
-		[[nodiscard]]
-		static constexpr auto opType() noexcept {
-			return ox::OpType::Write;
-		}
-
-	protected:
 		template<typename T>
 		constexpr ox::Error pad(const T*) noexcept;
 
@@ -205,7 +199,7 @@ constexpr ox::Error Preloader<PlatSpec>::field(CRStringView, const ox::BasicStri
 	const auto restore = m_writer.tellp();
 	std::size_t a = 0;
 	if (sz && sz >= SmallStringSize) {
-		oxReturnError(ox::allocate(&m_writer, sz).moveTo(&a));
+		oxReturnError(ox::allocate(&m_writer, sz).moveTo(a));
 	} else {
 		a = restore;
 	}
@@ -253,7 +247,7 @@ constexpr ox::Error Preloader<PlatSpec>::field(CRStringView, const T **val, std:
 template<typename PlatSpec>
 constexpr ox::Result<std::size_t> Preloader<PlatSpec>::startAlloc(std::size_t sz) noexcept {
 	oxRequire(a, ox::allocate(&m_writer, sz));
-	m_allocStack.emplace_back(m_writer.tellp());
+	m_allocStack.emplace_back(static_cast<typename PlatSpec::PtrType>(m_writer.tellp()));
 	oxReturnError(m_writer.seekp(a));
 	return a;
 }
@@ -272,7 +266,7 @@ constexpr ox::Error Preloader<PlatSpec>::endAlloc() noexcept {
 		return m_writer.seekp(0, ox::ios_base::end);
 	}
 	const auto &si = *m_allocStack.back().unwrap();
-	oxReturnError(m_writer.seekp(si.restore, si.seekdir));
+	oxReturnError(m_writer.seekp(static_cast<ox::ssize_t>(si.restore), si.seekdir));
 	m_allocStack.pop_back();
 	return {};
 }
@@ -359,10 +353,11 @@ constexpr bool Preloader<PlatSpec>::unionCheckAndIt() noexcept {
 }
 
 template<typename PlatSpec, typename T>
-constexpr ox::Error preload(
-		Preloader<PlatSpec> *pl, ox::CommonPtrWith<T> auto *obj) noexcept {
+constexpr ox::Error preload(Preloader<PlatSpec> *pl, ox::CommonPtrWith<T> auto *obj) noexcept {
 	oxReturnError(model(pl->interface(), obj));
 	return pl->pad(obj);
 }
 
+extern template class Preloader<NativePlatSpec>;
+
 }

deps/ox/src/ox/preloader/sizecatcher.hpp

@@ -24,7 +24,7 @@ template<typename PlatSpec, typename T>
 constexpr std::size_t sizeOf(const T *t) noexcept;
 
 template<typename PlatSpec>
-class SizeCatcher: public ModelHandlerBase<SizeCatcher<PlatSpec>> {
+class SizeCatcher: public ModelHandlerBase<SizeCatcher<PlatSpec>, OpType::Reflect> {
 	private:
 		std::size_t m_size = 0;
 
@@ -34,9 +34,16 @@ class SizeCatcher: public ModelHandlerBase<SizeCatcher<PlatSpec>> {
 		template<typename T>
 		constexpr ox::Error setTypeInfo(
 				const char* = T::TypeName,
-				int = T::TypeVersion,
-				const Vector<String>& = {},
-				std::size_t = ModelFieldCount_v<T>) noexcept {
+				int = T::TypeVersion) noexcept {
+			return {};
+		}
+
+		template<typename T>
+		constexpr ox::Error setTypeInfo(
+				const char*,
+				int,
+				const Vector<String>&,
+				std::size_t) noexcept {
 			return {};
 		}
 
@@ -54,11 +61,6 @@ class SizeCatcher: public ModelHandlerBase<SizeCatcher<PlatSpec>> {
 			return m_size;
 		}
 
-		[[nodiscard]]
-		static constexpr auto opType() noexcept {
-			return ox::OpType::Reflect;
-		}
-
 	private:
 		constexpr void pad(const auto *val) noexcept;
 };
@@ -105,7 +107,7 @@ constexpr std::size_t sizeOf(const T *t) noexcept {
 	if constexpr(ox::is_integral_v<T>) {
 		return sizeof(T);
 	} else if constexpr(ox::is_pointer_v<T>) {
-		return sizeof(PlatSpec::PtrType);
+		return sizeof(typename PlatSpec::PtrType);
 	} else {
 		SizeCatcher<PlatSpec> sc;
 		const auto err = model(sc.interface(), t);

deps/ox/src/ox/preloader/unionsizecatcher.hpp

@@ -14,7 +14,7 @@
 namespace ox {
 
 template<typename PlatSpec>
-class UnionSizeCatcher: public ModelHandlerBase<UnionSizeCatcher<PlatSpec>> {
+class UnionSizeCatcher: public ModelHandlerBase<UnionSizeCatcher<PlatSpec>, OpType::Reflect> {
 	private:
 		std::size_t m_size = 0;
 
@@ -23,9 +23,16 @@ class UnionSizeCatcher: public ModelHandlerBase<UnionSizeCatcher<PlatSpec>> {
 		template<typename T>
 		constexpr ox::Error setTypeInfo(
 				const char* = T::TypeName,
-				int = T::TypeVersion,
-				const Vector<String>& = {},
-				std::size_t = ModelFieldCount_v<T>) noexcept {
+				int = T::TypeVersion) noexcept {
+			return {};
+		}
+
+		template<typename T>
+		constexpr ox::Error setTypeInfo(
+				const char*,
+				int,
+				const Vector<String>&,
+				std::size_t) noexcept {
 			return {};
 		}
 
@@ -48,11 +55,6 @@ class UnionSizeCatcher: public ModelHandlerBase<UnionSizeCatcher<PlatSpec>> {
 			return m_size;
 		}
 
-		[[nodiscard]]
-		static constexpr auto opType() noexcept {
-			return ox::OpType::Reflect;
-		}
-
 	private:
 		template<typename T, std::size_t SmallVecSize>
 		constexpr ox::Error fieldStr(CRStringView, const ox::BasicString<SmallVecSize> *val) noexcept;

deps/ox/src/ox/std/CMakeLists.txt

@@ -30,6 +30,7 @@ add_library(
 		math.cpp
 		memops.cpp
 		random.cpp
+		reader.cpp
 		substitutes.cpp
 		stacktrace.cpp
 		string.cpp
@@ -44,9 +45,14 @@ add_library(
 if(NOT MSVC)
 	target_compile_options(OxStd PRIVATE -Wsign-conversion)
 	target_compile_options(OxStd PRIVATE -Wconversion)
-	if(UNIX AND NOT APPLE)
+	if(${OX_OS_LINUX})
 		target_compile_options(OxStd PUBLIC -export-dynamic)
 		#target_link_options(OxStd PUBLIC -W1,-E)
+	elseif(${OX_OS_FREEBSD})
+		target_link_libraries(
+			OxStd PUBLIC
+				execinfo
+		)
 	endif()
 endif()
 
@@ -112,6 +118,7 @@ install(
 		std.hpp
 		stddef.hpp
 		string.hpp
+		stringliteral.hpp
 		stringview.hpp
 		strongint.hpp
 		strops.hpp

deps/ox/src/ox/std/array.hpp

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015 - 2022 gary@drinkingtea.net
+ * Copyright 2015 - 2023 gary@drinkingtea.net
  *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
@@ -28,109 +28,7 @@ class Array {
 		using size_type = std::size_t;
 
 		template<typename RefType = T&, typename PtrType = T*, bool reverse = false>
-		struct iterator: public Iterator<std::bidirectional_iterator_tag, T> {
-			private:
-				PtrType m_t = nullptr;
-				size_type m_offset = 0;
-				size_type m_max = 0;
-
-			public:
-				constexpr iterator() noexcept = default;
-
-				constexpr iterator(PtrType t, size_type offset, size_type max) noexcept {
-					m_t = t;
-					m_offset = offset;
-					m_max = max;
-				}
-
-				constexpr auto offset() const noexcept {
-					return m_offset;
-				}
-
-				constexpr iterator operator+(size_type s) const noexcept {
-					if constexpr(reverse) {
-						return iterator(m_t, max<size_type>(m_offset - s, 0), m_max);
-					} else {
-						return iterator(m_t, min<size_type>(m_offset + s, m_max), m_max);
-					}
-				}
-
-				constexpr typename Iterator<std::bidirectional_iterator_tag, T>::difference_type
-				operator-(const iterator &other) const noexcept {
-					if constexpr(reverse) {
-						return m_offset + other.m_offset;
-					} else {
-						return m_offset - other.m_offset;
-					}
-				}
-
-				constexpr iterator operator-(size_type s) const noexcept {
-					if constexpr(reverse) {
-						return iterator(m_t, min<size_type>(m_offset + s, m_max), m_max);
-					} else {
-						return iterator(m_t, max<size_type>(m_offset - s, 0), m_max);
-					}
-				}
-
-				constexpr iterator &operator+=(size_type s) noexcept {
-					if constexpr(reverse) {
-						m_offset = max<size_type>(m_offset - s, 0);
-					} else {
-						m_offset = min(m_offset + s, m_max);
-					}
-					return *this;
-				}
-
-				constexpr iterator &operator-=(size_type s) noexcept {
-					if constexpr(reverse) {
-						m_offset = min(m_offset + s, m_max);
-					} else {
-						m_offset = max<size_type>(m_offset - s, 0);
-					}
-					return *this;
-				}
-
-				constexpr iterator &operator++() noexcept {
-					return operator+=(1);
-				}
-
-				constexpr iterator &operator--() noexcept {
-					return operator-=(1);
-				}
-
-				constexpr RefType operator*() const noexcept {
-					return m_t[m_offset];
-				}
-
-				constexpr RefType operator[](size_type s) const noexcept {
-					return m_t[s];
-				}
-
-				constexpr bool operator<(const iterator &other) const noexcept {
-					return m_offset < other.m_offset;
-				}
-
-				constexpr bool operator>(const iterator &other) const noexcept {
-					return m_offset > other.m_offset;
-				}
-
-				constexpr bool operator<=(const iterator &other) const noexcept {
-					return m_offset <= other.m_offset;
-				}
-
-				constexpr bool operator>=(const iterator &other) const noexcept {
-					return m_offset >= other.m_offset;
-				}
-
-				constexpr bool operator==(const iterator &other) const noexcept {
-					return m_t == other.m_t && m_offset == other.m_offset && m_max == other.m_max;
-				}
-
-				constexpr bool operator!=(const iterator &other) const noexcept {
-					return m_t != other.m_t || m_offset != other.m_offset || m_max != other.m_max;
-				}
-
-		};
+		using iterator = SpanIterator<T, RefType, PtrType, reverse>;
 
 	private:
 		T m_items[ArraySize]{};

deps/ox/src/ox/std/assert.hpp

@@ -22,9 +22,9 @@
 
 namespace ox {
 
-void panic(const char *file, int line, const char *panicMsg, const Error &err = OxError(0)) noexcept;
+void panic(CRStringView file, int line, CRStringView panicMsg, const Error &err = OxError(0)) noexcept;
 
-constexpr void constexprPanic(const char *file, int line, const char *panicMsg, const Error &err = OxError(0)) noexcept {
+constexpr void constexprPanic(CRStringView file, int line, CRStringView panicMsg, const Error &err = OxError(0)) noexcept {
 	if (!std::is_constant_evaluated()) {
 		panic(file, line, panicMsg, err);
 	} else {
@@ -32,7 +32,7 @@ constexpr void constexprPanic(const char *file, int line, const char *panicMsg,
 	}
 }
 
-constexpr void assertFunc(const char *file, int line, bool pass, [[maybe_unused]]const char *assertTxt, [[maybe_unused]]const char *msg) noexcept {
+constexpr void assertFunc(CRStringView file, int line, bool pass, [[maybe_unused]]CRStringView assertTxt, [[maybe_unused]]CRStringView msg) noexcept {
 	if (!pass) {
 		if (!std::is_constant_evaluated()) {
 #ifdef OX_USE_STDLIB
@@ -51,7 +51,7 @@ constexpr void assertFunc(const char *file, int line, bool pass, [[maybe_unused]
 	}
 }
 
-constexpr void assertFunc(const char *file, int line, const Error &err, const char*, const char *assertMsg) noexcept {
+constexpr void assertFunc(CRStringView file, int line, const Error &err, CRStringView, CRStringView assertMsg) noexcept {
 	if (err) {
 		if (!std::is_constant_evaluated()) {
 #if defined(OX_USE_STDLIB)
@@ -75,14 +75,14 @@ constexpr void assertFunc(const char *file, int line, const Error &err, const ch
 	}
 }
 
-constexpr void expect(const char *file, int line, const auto &actual, const auto &expected) noexcept {
+constexpr void expect(CRStringView file, int line, const auto &actual, const auto &expected) noexcept {
 	if (actual != expected) {
 		 if (!std::is_constant_evaluated()) {
 #if defined(OX_USE_STDLIB)
 			oxErrf("\n\033[31;1;1mASSERT FAILURE:\033[0m [{}:{}]: {}\n", file, line, "Value incorrect");
 			oxErrf("expected: {}\nactual:   {}\n", detail::toStringView<true>(expected), detail::toStringView<true>(actual));
 			printStackTrace(2);
-			oxTracef("assert::expect", "Failed assert: {} == {} [{}:{}]", detail::toStringView<true>(actual), detail::toStringView<true>(expected), file, line);
+			oxTracef("assert.expect", "Failed assert: {} == {} [{}:{}]", detail::toStringView<true>(actual), detail::toStringView<true>(expected), file, line);
 			std::abort();
 #else
 			constexprPanic(file, line, "Comparison failed");

deps/ox/src/ox/std/basestringview.hpp

@@ -0,0 +1,217 @@
+/*
+ * Copyright 2015 - 2023 gary@drinkingtea.net
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#pragma once
+
+#include "bit.hpp"
+#include "cstrops.hpp"
+#include "iterator.hpp"
+
+namespace ox::detail {
+
+class BaseStringView {
+	public:
+		template<typename RefType = char&, typename PtrType = char*, bool reverse = false>
+		struct iterator: public Iterator<std::bidirectional_iterator_tag, char> {
+			private:
+				PtrType m_t = nullptr;
+				std::size_t m_offset = 0;
+				std::size_t m_max = 0;
+
+			public:
+				constexpr iterator() noexcept = default;
+
+				constexpr iterator(PtrType t, std::size_t offset, std::size_t max) noexcept {
+					m_t = t;
+					m_offset = offset;
+					m_max = max;
+				}
+
+				[[nodiscard]]
+				constexpr auto offset() const noexcept {
+					return m_offset;
+				}
+
+				constexpr iterator operator+(std::size_t s) const noexcept {
+					if constexpr(reverse) {
+						return iterator(m_t, max<std::size_t>(m_offset - s, 0), m_max);
+					} else {
+						return iterator(m_t, min<std::size_t>(m_offset + s, m_max), m_max);
+					}
+				}
+
+				constexpr auto operator-(const iterator &other) const noexcept {
+					if constexpr(reverse) {
+						return m_offset + other.m_offset;
+					} else {
+						return m_offset - other.m_offset;
+					}
+				}
+
+				constexpr iterator operator-(std::size_t s) const noexcept {
+					if constexpr(reverse) {
+						return iterator(m_t, min<std::size_t>(m_offset + s, m_max), m_max);
+					} else {
+						return iterator(m_t, max<std::size_t>(m_offset - s, 0), m_max);
+					}
+				}
+
+				constexpr iterator &operator+=(std::size_t s) noexcept {
+					if constexpr(reverse) {
+						m_offset = max<std::size_t>(m_offset - s, 0);
+					} else {
+						m_offset = min(m_offset + s, m_max);
+					}
+					return *this;
+				}
+
+				constexpr iterator &operator-=(std::size_t s) noexcept {
+					if constexpr(reverse) {
+						m_offset = min(m_offset + s, m_max);
+					} else {
+						m_offset = max<std::size_t>(m_offset - s, 0);
+					}
+					return *this;
+				}
+
+				constexpr iterator &operator++() noexcept {
+					return operator+=(1);
+				}
+
+				constexpr iterator &operator--() noexcept {
+					return operator-=(1);
+				}
+
+				constexpr RefType operator*() const noexcept {
+					return m_t[m_offset];
+				}
+
+				constexpr RefType operator[](std::size_t s) const noexcept {
+					return m_t[s];
+				}
+
+				constexpr bool operator<(const iterator &other) const noexcept {
+					return m_offset < other.m_offset;
+				}
+
+				constexpr bool operator>(const iterator &other) const noexcept {
+					return m_offset > other.m_offset;
+				}
+
+				constexpr bool operator<=(const iterator &other) const noexcept {
+					return m_offset <= other.m_offset;
+				}
+
+				constexpr bool operator>=(const iterator &other) const noexcept {
+					return m_offset >= other.m_offset;
+				}
+
+				constexpr bool operator==(const iterator &other) const noexcept {
+					return m_t == other.m_t && m_offset == other.m_offset && m_max == other.m_max;
+				}
+
+				constexpr bool operator!=(const iterator &other) const noexcept {
+					return m_t != other.m_t || m_offset != other.m_offset || m_max != other.m_max;
+				}
+
+		};
+
+	private:
+		const char *m_str = nullptr;
+		std::size_t m_len = 0;
+	protected:
+		constexpr BaseStringView() noexcept = default;
+
+		constexpr BaseStringView(BaseStringView const&sv) noexcept = default;
+
+		constexpr explicit BaseStringView(std::nullptr_t) noexcept {}
+
+		constexpr explicit BaseStringView(const char *str) noexcept: m_str(str), m_len(str ? ox_strlen(str) : 0) {}
+
+		constexpr explicit BaseStringView(const char *str, std::size_t len) noexcept: m_str(str), m_len(len) {}
+
+	public:
+		[[nodiscard]]
+		constexpr iterator<const char&, const char*> begin() const noexcept {
+			return {m_str, 0, m_len};
+		}
+
+		[[nodiscard]]
+		constexpr iterator<const char&, const char*> end() const noexcept {
+			return {m_str, m_len, m_len};
+		}
+
+		[[nodiscard]]
+		constexpr iterator<const char&, const char*> cbegin() const noexcept {
+			return {m_str, 0, m_len};
+		}
+
+		[[nodiscard]]
+		constexpr iterator<const char&, const char*> cend() const noexcept {
+			return {m_str, m_len, m_len};
+		}
+
+		[[nodiscard]]
+		constexpr iterator<const char&, const char*, true> crbegin() const noexcept {
+			return {m_str, m_len - 1, m_len};
+		}
+
+		[[nodiscard]]
+		constexpr iterator<const char&, const char*, true> crend() const noexcept {
+			return {m_str, MaxValue<std::size_t>, m_len};
+		}
+
+		[[nodiscard]]
+		constexpr iterator<const char&, const char*, true> rbegin() const noexcept {
+			return {m_str, m_len - 1, m_len};
+		}
+
+		[[nodiscard]]
+		constexpr iterator<const char&, const char*, true> rend() const noexcept {
+			return {m_str, MaxValue<std::size_t>, m_len};
+		}
+
+		[[nodiscard]]
+		constexpr auto bytes() const noexcept {
+			return m_len;
+		}
+
+		[[nodiscard]]
+		constexpr auto len() const noexcept {
+			return m_len;
+		}
+
+		[[nodiscard]]
+		constexpr auto *data() const noexcept {
+			return &m_str[0];
+		}
+
+		[[nodiscard]]
+		constexpr auto &front() const noexcept {
+			return m_str[0];
+		}
+
+		[[nodiscard]]
+		constexpr auto &back() const noexcept {
+			return m_str[m_len - 1];
+		}
+
+		[[nodiscard]]
+		constexpr auto operator[](std::size_t i) const noexcept {
+			return m_str[i];
+		}
+
+	protected:
+		constexpr void set(const char *str, std::size_t len) noexcept {
+			m_str = str;
+			m_len = len;
+		}
+
+};
+
+}

deps/ox/src/ox/std/buffer.cpp

@@ -13,6 +13,7 @@ namespace ox {
 
 template class Vector<char>;
 
+template class ReaderT<BufferReader>;
 template class WriterT<BufferWriter>;
 template class WriterT<CharBuffWriter>;
 

deps/ox/src/ox/std/buffer.hpp

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015 - 2022 gary@drinkingtea.net
+ * Copyright 2015 - 2023 gary@drinkingtea.net
  *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
@@ -9,6 +9,7 @@
 #pragma once
 
 #include "error.hpp"
+#include "reader.hpp"
 #include "vector.hpp"
 #include "writer.hpp"
 
@@ -166,6 +167,73 @@ class CharBuffWriter {
 		}
 };
 
+class BufferReader {
+	private:
+		std::size_t m_it = 0;
+		std::size_t m_size = 0;
+		char const* m_buff = nullptr;
+
+	public:
+		constexpr explicit BufferReader(char const*buff, std::size_t sz) noexcept:
+			m_size(sz), m_buff(buff) {}
+
+		constexpr explicit BufferReader(ox::Buffer const&buffer) noexcept:
+			m_size(buffer.size()), m_buff(buffer.data()) {}
+
+		constexpr ox::Result<char> peek() const noexcept {
+			if (m_it >= m_size) [[unlikely]] {
+				return OxError(1, "Peek failed: buffer overrun");
+			}
+			return m_buff[m_it];
+		}
+
+		constexpr ox::Result<std::size_t> read(void *v, std::size_t sz) noexcept {
+			sz = ox::min(sz, m_size - m_it);
+			if (m_it + sz > m_size) [[unlikely]] {
+				return OxError(1, "Read failed: Buffer overrun");
+			}
+			ox_memcpy(v, &m_buff[m_it], sz);
+			m_it += sz;
+			return sz;
+		}
+
+		constexpr ox::Error seekg(std::size_t p) noexcept {
+			if (p > m_size) [[unlikely]] {
+				return OxError(1, "Seek failed: Buffer overrun");
+			}
+			m_it = p;
+			return {};
+		}
+
+		constexpr ox::Error seekg(int64_t off, ios_base::seekdir dir) noexcept {
+			ox::Signed<std::size_t> base = 0;
+			switch (dir) {
+				case ox::ios_base::beg:
+					base = 0;
+					break;
+				case ox::ios_base::end:
+					base = static_cast<ox::Signed<std::size_t>>(m_size);
+					break;
+				case ox::ios_base::cur:
+					base = static_cast<ox::Signed<std::size_t>>(m_it);
+					break;
+				default:
+					return OxError(1, "Invalid seekdir");
+			}
+			auto const newIt = static_cast<std::size_t>(base + off);
+			if (newIt > m_size) [[unlikely]] {
+				return OxError(1, "Seek failed: Buffer overrun");
+			}
+			m_it = newIt;
+			return {};
+		}
+
+		constexpr ox::Result<std::size_t> tellg() const noexcept {
+			return m_it;
+		}
+};
+
+extern template class ReaderT<BufferReader>;
 extern template class WriterT<BufferWriter>;
 extern template class WriterT<CharBuffWriter>;
 

deps/ox/src/ox/std/concepts.hpp

@@ -23,35 +23,10 @@ concept CommonRefWith = ox::is_same_v<typename ox::remove_reference_t<const T&>,
 template<typename T, typename U>
 concept same_as = ox::is_same_v<T, T>;
 
-template<std::size_t SmallStringSize>
-class BasicString;
-template<std::size_t sz>
-class BString;
-class StringView;
-
-namespace detail {
-
-constexpr auto isOxString(const auto*) noexcept {
-	return false;
-}
-
-template<std::size_t sz>
-constexpr auto isOxString(const BasicString<sz>*) noexcept {
-	return true;
-}
-
-template<std::size_t sz>
-constexpr auto isOxString(const BString<sz>*) noexcept {
-	return true;
-}
-
-constexpr auto isOxString(const StringView*) noexcept {
-	return true;
-}
-
-}
+template<typename T>
+concept OxString_c = isOxString_v<T>;
 
 template<typename T>
-concept OxString_c = detail::isOxString(static_cast<T*>(nullptr));
+concept Integral_c = ox::is_integral_v<T>;
 
 }

deps/ox/src/ox/std/cstringview.hpp

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2015 - 2023 gary@drinkingtea.net
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#pragma once
+
+#include "basestringview.hpp"
+#include "bstring.hpp"
+#include "string.hpp"
+#include "stringliteral.hpp"
+
+namespace ox {
+
+class CStringView: public detail::BaseStringView {
+	public:
+		constexpr CStringView() noexcept = default;
+
+		constexpr CStringView(CStringView const&sv) noexcept = default;
+
+		constexpr CStringView(StringLiteral const&str) noexcept: BaseStringView(str.data(), str.len()) {}
+
+		template<std::size_t SmallStrSz>
+		constexpr CStringView(BasicString<SmallStrSz> const&str) noexcept: BaseStringView(str.data(), str.len()) {}
+
+		template<std::size_t SmallStrSz>
+		constexpr CStringView(BString<SmallStrSz> const&str) noexcept: BaseStringView(str.data(), str.len()) {}
+
+		constexpr CStringView(std::nullptr_t) noexcept {}
+
+		constexpr CStringView(const char *str) noexcept: BaseStringView(str) {}
+
+		constexpr CStringView(const char *str, std::size_t len) noexcept: BaseStringView(str, len) {}
+
+		constexpr auto &operator=(CStringView const&other) noexcept {
+			if (&other != this) {
+				set(other.data(), other.len());
+			}
+			return *this;
+		}
+
+		[[nodiscard]]
+		constexpr const char *c_str() const noexcept {
+			return data();
+		}
+
+};
+
+}
+

deps/ox/src/ox/std/cstrops.hpp

@@ -0,0 +1,145 @@
+/*
+ * Copyright 2015 - 2023 gary@drinkingtea.net
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#pragma once
+
+#include "types.hpp"
+#include "typetraits.hpp"
+
+template<typename T1, typename T2>
+constexpr T1 ox_strncpy(T1 dest, T2 src, std::size_t maxLen) noexcept {
+	using T1Type = typename ox::remove_reference<decltype(dest[0])>::type;
+	std::size_t i = 0;
+	while (i < maxLen && src[i]) {
+		dest[i] = static_cast<T1Type>(src[i]);
+		++i;
+	}
+	// set null terminator
+	dest[i] = 0;
+	return dest;
+}
+
+[[nodiscard]]
+constexpr auto ox_strnlen(const char *str1, std::size_t maxLen) noexcept {
+	std::size_t len = 0;
+	for (; len < maxLen && str1[len]; len++);
+	return len;
+}
+
+template<typename T>
+[[nodiscard]]
+constexpr auto ox_strlen(T const&str1) noexcept {
+	std::size_t len = 0;
+	for (; str1[len]; len++);
+	return len;
+}
+
+template<typename T1, typename T2>
+[[nodiscard]]
+constexpr int ox_strcmp(const T1 &str1, const T2 &str2) noexcept {
+	auto retval = 0;
+	auto i = 0u;
+	while (str1[i] || str2[i]) {
+		if (str1[i] < str2[i]) {
+			retval = -1;
+			break;
+		} else if (str1[i] > str2[i]) {
+			retval = 1;
+			break;
+		}
+		i++;
+	}
+	return retval;
+}
+
+template<typename T1, typename T2>
+[[nodiscard]]
+constexpr int ox_strncmp(T1 const&str1, T2 const&str2, const std::size_t maxLen) noexcept {
+	auto retval = 0;
+	std::size_t i = 0;
+	while (i < maxLen && (str1[i] || str2[i])) {
+		if (str1[i] < str2[i]) {
+			retval = -1;
+			break;
+		} else if (str1[i] > str2[i]) {
+			retval = 1;
+			break;
+		}
+		i++;
+	}
+	return retval;
+}
+
+[[nodiscard]]
+constexpr const char *ox_strchr(const char *str, int character, std::size_t maxLen = 0xFFFFFFFF) noexcept {
+	for (std::size_t i = 0; i <= maxLen; i++) {
+		if (str[i] == character) {
+			return &str[i];
+		} else if (str[i] == 0) {
+			return nullptr;
+		}
+	}
+	return nullptr;
+}
+
+[[nodiscard]]
+constexpr char *ox_strchr(char *str, int character, std::size_t maxLen = 0xFFFFFFFF) noexcept {
+	for (std::size_t i = 0; i < maxLen; i++) {
+		if (str[i] == character) {
+			return &str[i];
+		} else if (str[i] == 0) {
+			return nullptr;
+		}
+	}
+	return nullptr;
+}
+
+[[nodiscard]]
+constexpr int ox_lastIndexOf(const auto &str, int character, std::size_t maxLen = 0xFFFFFFFF) noexcept {
+	int retval = -1;
+	for (std::size_t i = 0; i < maxLen && str[i]; i++) {
+		if (str[i] == character) {
+			retval = static_cast<int>(i);
+		}
+	}
+	return retval;
+}
+
+template<typename Integer, typename T>
+constexpr T ox_itoa(Integer v, T str) noexcept {
+	if (v) {
+		ox::ResizedInt_t<Integer, 64> mod = 1000000000000000000;
+		ox::ResizedInt_t<Integer, 64> val = v;
+		constexpr auto base = 10;
+		auto it = 0;
+		if (val < 0) {
+			str[static_cast<std::size_t>(it)] = '-';
+			it++;
+		}
+		while (mod) {
+			auto digit = val / mod;
+			val %= mod;
+			mod /= base;
+			if (it || digit) {
+				ox::ResizedInt_t<Integer, 64> start = '0';
+				if (digit >= 10) {
+					start = 'a';
+					digit -= 10;
+				}
+				str[static_cast<std::size_t>(it)] = static_cast<typename ox::remove_reference<decltype(str[0])>::type>(start + digit);
+				it++;
+			}
+		}
+		str[static_cast<std::size_t>(it)] = 0;
+	} else {
+		// 0 is a special case
+		str[0] = '0';
+		str[1] = 0;
+	}
+	return str;
+}

deps/ox/src/ox/std/def.hpp

@@ -17,16 +17,9 @@
 #define oxOut(...) ox::trace::OutStream(__FILE__, __LINE__, "stdout", __VA_ARGS__)
 #define oxErr(...) ox::trace::OutStream(__FILE__, __LINE__, "stderr", __VA_ARGS__)
 
-#ifdef OX_USE_STDLIB
-// Non-GCC compilers don't like ##__VA_ARGS__, so use initializer list, which relies on std lib
-#define oxTracef(ch, fmt, ...) ox::trace::TraceStream(__FILE__, __LINE__, ch, ox::detail::fmtSegments<ox::detail::argCount(fmt)+1>(fmt), {__VA_ARGS__})
-#define oxOutf(fmt, ...) ox::trace::OutStream(__FILE__, __LINE__, "stdout", ox::detail::fmtSegments<ox::detail::argCount(fmt)+1>(fmt), {__VA_ARGS__})
-#define oxErrf(fmt, ...) ox::trace::OutStream(__FILE__, __LINE__, "stderr", ox::detail::fmtSegments<ox::detail::argCount(fmt)+1>(fmt), {__VA_ARGS__})
-#else
-#define oxTracef(ch, fmt, ...) ox::trace::TraceStream(__FILE__, __LINE__, ch, ox::detail::fmtSegments<ox::detail::argCount(fmt)+1>(fmt), ##__VA_ARGS__)
-#define oxOutf(fmt, ...) ox::trace::OutStream(__FILE__, __LINE__, "stdout", ox::detail::fmtSegments<ox::detail::argCount(fmt)+1>(fmt), ##__VA_ARGS__)
-#define oxErrf(fmt, ...) ox::trace::OutStream(__FILE__, __LINE__, "stderr", ox::detail::fmtSegments<ox::detail::argCount(fmt)+1>(fmt), ##__VA_ARGS__)
-#endif
+#define oxTracef(ch, fmt, ...) ox::trace::TraceStream(__FILE__, __LINE__, ch, ox::detail::fmtSegments<ox::detail::argCount(fmt)+1>(fmt), __VA_ARGS__)
+#define oxOutf(fmt, ...) ox::trace::OutStream(__FILE__, __LINE__, "stdout", ox::detail::fmtSegments<ox::detail::argCount(fmt)+1>(fmt), __VA_ARGS__)
+#define oxErrf(fmt, ...) ox::trace::OutStream(__FILE__, __LINE__, "stderr", ox::detail::fmtSegments<ox::detail::argCount(fmt)+1>(fmt), __VA_ARGS__)
 
 #define oxInfo(...) oxTrace("info", __VA_ARGS__)
 #define oxInfof(...) oxTracef("info", __VA_ARGS__)
@@ -35,12 +28,7 @@
 
 #ifndef OX_NODEBUG
 #define oxDebug(...) ox::trace::OutStream(__FILE__, __LINE__, "debug", __VA_ARGS__)
-#ifdef OX_USE_STDLIB
-// Non-GCC compilers don't like ##__VA_ARGS__, so use initializer list, which relies on std lib
-#define oxDebugf(fmt, ...) ox::trace::OutStream(__FILE__, __LINE__, "debug", ox::detail::fmtSegments<ox::detail::argCount(fmt)+1>(fmt), {__VA_ARGS__})
-#else
-#define oxDebugf(fmt, ...) ox::trace::OutStream(__FILE__, __LINE__, "debug", ox::detail::fmtSegments<ox::detail::argCount(fmt)+1>(fmt), ##__VA_ARGS__)
-#endif
+#define oxDebugf(fmt, ...) ox::trace::OutStream(__FILE__, __LINE__, "debug", ox::detail::fmtSegments<ox::detail::argCount(fmt)+1>(fmt), __VA_ARGS__)
 #else
 #define oxDebug(...) static_assert(false, "Debug prints were checked in.");
 #define oxDebugf(...) static_assert(false, "Debug prints were checked in.");

deps/ox/src/ox/std/error.hpp

@@ -25,8 +25,6 @@ class exception {
 #endif
 
 #include "def.hpp"
-#include "defines.hpp"
-#include "strongint.hpp"
 #include "typetraits.hpp"
 #include "utility.hpp"
 
@@ -132,7 +130,7 @@ struct [[nodiscard]] Result {
 	T value;
 	Error error;
 
-	constexpr Result() noexcept: error(0) {
+	constexpr Result() noexcept: value(), error(0) {
 	}
 
 	template<typename U>
@@ -140,16 +138,16 @@ struct [[nodiscard]] Result {
 	}
 
 	template<typename U>
-	constexpr Result(const Result<U> &&other) noexcept: value(std::move(other.value)), error(std::move(other.error)) {
+	constexpr Result(Result<U> &&other) noexcept: value(std::move(other.value)), error(std::move(other.error)) {
 	}
 
-	constexpr Result(const Error &error) noexcept: error(error) {
+	constexpr Result(const Error &error) noexcept: value(), error(error) {
 	}
 
-	constexpr Result(const type &value, const Error &error = OxError(0)) noexcept: value(const_cast<type&>(value)), error(error) {
+	constexpr Result(const type &value, const Error &error = OxError(0)) noexcept: value(value), error(error) {
 	}
 
-	constexpr Result(type &&value, const Error &error = OxError(0)) noexcept: value(ox::forward<type>(value)), error(error) {
+	constexpr Result(type &&value, const Error &error = OxError(0)) noexcept: value(std::move(value)), error(error) {
 	}
 
 	constexpr ~Result() noexcept = default;
@@ -167,44 +165,139 @@ struct [[nodiscard]] Result {
 		return error == 0;
 	}
 
-	constexpr Error get(type *val) const noexcept {
-		*val = value;
-		return error;
-	}
-
-	constexpr Error get(type *val) noexcept {
-		*val = value;
-		return error;
-	}
-
-	constexpr Error moveTo(type *val) noexcept {
+	constexpr Error copyTo(type &val) const& noexcept {
 		if (!error) [[likely]] {
-			*val = std::move(value);
+			val = value;
 		}
 		return error;
 	}
 
-	constexpr auto &unwrap() noexcept {
+	constexpr Error copyTo(type &val) && noexcept {
+		if (!error) [[likely]] {
+			val = std::move(value);
+		}
+		return error;
+	}
+
+	constexpr Error moveTo(type &val) noexcept {
+		if (!error) [[likely]] {
+			val = std::move(value);
+		}
+		return error;
+	}
+
+	[[nodiscard]]
+	constexpr T &unwrap() & noexcept {
 		if (error) {
 			oxPanic(error, "Failed unwrap");
 		}
 		return value;
 	}
 
-	constexpr const auto &unwrap() const noexcept {
+	[[nodiscard]]
+	constexpr T &&unwrap() && noexcept {
+		if (error) {
+			oxPanic(error, "Failed unwrap");
+		}
+		return std::move(value);
+	}
+
+	[[nodiscard]]
+	constexpr T const&unwrap() const & noexcept {
 		if (error) [[unlikely]] {
 			oxPanic(error, "Failed unwrap");
 		}
 		return value;
 	}
 
-	constexpr ox::Result<T> to(const auto &f) noexcept {
+	[[nodiscard]]
+	constexpr T &unwrapThrow() & {
+		if (error) {
+			throw ox::Exception(error);
+		}
+		return value;
+	}
+
+	[[nodiscard]]
+	constexpr T &&unwrapThrow() && {
+		if (error) {
+			throw ox::Exception(error);
+		}
+		return std::move(value);
+	}
+
+	[[nodiscard]]
+	constexpr T const&unwrapThrow() const & {
+		if (error) {
+			throw ox::Exception(error);
+		}
+		return value;
+	}
+
+	template<typename U = T>
+	constexpr ox::Result<U> to(auto const&f) & noexcept {
 		if (error) [[unlikely]] {
-			return OxError(1);
+			return error;
 		}
 		return f(value);
 	}
 
+	template<typename U = T>
+	constexpr ox::Result<U> to(auto const&f) && noexcept {
+		if (error) [[unlikely]] {
+			return error;
+		}
+		return f(std::move(value));
+	}
+
+	/**
+	 * Returns parameter alt if Result contains an error.
+	 * @param alt
+	 * @return value of Result or alt
+	 */
+	constexpr T or_value(T &&alt) const& noexcept {
+		if (error) {
+			return std::move(alt);
+		}
+		return value;
+	}
+
+	/**
+	 * Returns parameter alt if Result contains an error.
+	 * @param alt
+	 * @return value of Result or alt
+	 */
+	constexpr T or_value(T &&alt) && noexcept {
+		if (error) {
+			return std::move(alt);
+		}
+		return std::move(value);
+	}
+
+	/**
+	 * Returns parameter alt if Result contains an error.
+	 * @param alt
+	 * @return value of Result or alt
+	 */
+	constexpr T or_value(T const&alt) const& noexcept {
+		if (error) {
+			return alt;
+		}
+		return value;
+	}
+
+	/**
+	 * Returns parameter alt if Result contains an error.
+	 * @param alt
+	 * @return value of Result or alt
+	 */
+	constexpr T or_value(T const&alt) && noexcept {
+		if (error) {
+			return alt;
+		}
+		return std::move(value);
+	}
+
 };
 
 namespace detail {

deps/ox/src/ox/std/fmt.hpp

@@ -186,14 +186,14 @@ constexpr Fmt<segementCnt> fmtSegments(StringView fmt) noexcept {
 
 template<typename StringType = String, typename ...Args>
 [[nodiscard]]
-constexpr StringType sfmt(StringView fmt, Args... args) noexcept {
+constexpr StringType sfmt(StringView fmt, Args&&... args) noexcept {
 	assert(ox::detail::argCount(fmt) == sizeof...(args));
 	StringType out;
 	const auto fmtSegments = ox::detail::fmtSegments<sizeof...(args)+1>(fmt);
 	const auto &firstSegment = fmtSegments.segments[0];
 	oxIgnoreError(out.append(firstSegment.str, firstSegment.length));
 	const detail::FmtArg elements[sizeof...(args)] = {args...};
-	for (auto i = 0u; i < fmtSegments.size - 1; ++i) {
+	for (size_t i = 0; i < fmtSegments.size - 1; ++i) {
 		out += elements[i].out;
 		const auto &s = fmtSegments.segments[i + 1];
 		oxIgnoreError(out.append(s.str, s.length));

deps/ox/src/ox/std/hashmap.hpp

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "algorithm.hpp"
+#include "stringview.hpp"
 #include "strops.hpp"
 #include "vector.hpp"
 
@@ -17,8 +18,9 @@ namespace ox {
 template<typename K, typename T>
 class HashMap {
 
-	using key_t = K;
-	using value_t = T;
+	public:
+		using key_t = K;
+		using value_t = T;
 
 	private:
 		struct Pair {
@@ -31,62 +33,49 @@ class HashMap {
 	public:
 		explicit constexpr HashMap(std::size_t size = 100);
 
-		constexpr HashMap(const HashMap &other);
+		constexpr HashMap(HashMap const&other);
 
 		constexpr HashMap(HashMap &&other) noexcept;
 
 		constexpr ~HashMap();
 
-		constexpr bool operator==(const HashMap &other) const;
+		constexpr bool operator==(HashMap const&other) const;
 
-		constexpr HashMap &operator=(const HashMap &other);
+		constexpr HashMap &operator=(HashMap const&other);
 
-		constexpr HashMap &operator=(HashMap &&other);
+		constexpr HashMap &operator=(HashMap &&other) noexcept;
 
-		/**
-		 * K is assumed to be a null terminated string.
-		 */
-		constexpr T &operator[](const K &key);
+		constexpr T &operator[](MaybeSV_t<K> const&key);
 
-		/**
-		 * K is assumed to be a null terminated string.
-		 */
-		constexpr Result<T*> at(const K &key) noexcept;
+		constexpr Result<T*> at(MaybeSV_t<K> const&key) noexcept;
 
-		/**
-		 * K is assumed to be a null terminated string.
-		 */
-		constexpr Result<const T*> at(const K &key) const noexcept;
+		constexpr Result<const T*> at(MaybeSV_t<K> const&key) const noexcept;
 
-		constexpr void erase(const K &key);
+		constexpr void erase(MaybeSV_t<K> const&key);
 
-		constexpr bool contains(const K &key) const noexcept;
+		[[nodiscard]]
+		constexpr bool contains(MaybeSV_t<K> const&key) const noexcept;
 
 		[[nodiscard]]
 		constexpr std::size_t size() const noexcept;
 
 		[[nodiscard]]
-		constexpr const Vector<K> &keys() const noexcept;
+		constexpr Vector<K> const&keys() const noexcept;
 
 		constexpr void clear();
 
 	private:
 		constexpr void expand();
 
-		/**
-		 * K is assumed to be a null terminated string.
-		 */
-		constexpr static uint64_t hash(auto) noexcept;
+		constexpr static uint64_t hash(Integral_c auto) noexcept;
 
-		/**
-		 * K is assumed to be a null terminated string.
-		 */
-		constexpr Pair *const&access(const Vector<Pair*> &pairs, const K &key) const;
+		constexpr static uint64_t hash(StringView const&) noexcept;
 
-		/**
-		 * K is assumed to be a null terminated string.
-		 */
-		constexpr Pair *&access(Vector<Pair*> &pairs, const K &key);
+		template<typename KK>
+		constexpr Pair *const&access(Vector<Pair*> const&pairs, KK const&key) const;
+
+		template<typename KK>
+		constexpr Pair *&access(Vector<Pair*> &pairs, KK const&key);
 
 };
 
@@ -95,7 +84,7 @@ constexpr HashMap<K, T>::HashMap(std::size_t size): m_pairs(size) {
 }
 
 template<typename K, typename T>
-constexpr HashMap<K, T>::HashMap(const HashMap<K, T> &other) {
+constexpr HashMap<K, T>::HashMap(HashMap<K, T> const&other) {
 	m_pairs = other.m_pairs;
 }
 
@@ -111,11 +100,11 @@ constexpr HashMap<K, T>::~HashMap() {
 }
 
 template<typename K, typename T>
-constexpr bool HashMap<K, T>::operator==(const HashMap &other) const {
+constexpr bool HashMap<K, T>::operator==(HashMap const&other) const {
 	if (m_keys != other.m_keys) {
 		return false;
 	}
-	for (int i = 0; i < m_keys.size(); i++) {
+	for (int i = 0; i < m_keys.size(); ++i) {
 		auto &k = m_keys[i];
 		if (at(k) != other.at(k)) {
 			return false;
@@ -125,7 +114,7 @@ constexpr bool HashMap<K, T>::operator==(const HashMap &other) const {
 }
 
 template<typename K, typename T>
-constexpr HashMap<K, T> &HashMap<K, T>::operator=(const HashMap<K, T> &other) {
+constexpr HashMap<K, T> &HashMap<K, T>::operator=(HashMap<K, T> const&other) {
 	if (this != &other) {
 		clear();
 		m_keys = other.m_keys;
@@ -135,7 +124,7 @@ constexpr HashMap<K, T> &HashMap<K, T>::operator=(const HashMap<K, T> &other) {
 }
 
 template<typename K, typename T>
-constexpr HashMap<K, T> &HashMap<K, T>::operator=(HashMap<K, T> &&other) {
+constexpr HashMap<K, T> &HashMap<K, T>::operator=(HashMap<K, T> &&other) noexcept {
 	if (this != &other) {
 		clear();
 		m_keys = std::move(other.m_keys);
@@ -145,7 +134,7 @@ constexpr HashMap<K, T> &HashMap<K, T>::operator=(HashMap<K, T> &&other) {
 }
 
 template<typename K, typename T>
-constexpr T &HashMap<K, T>::operator[](const K &k) {
+constexpr T &HashMap<K, T>::operator[](MaybeSV_t<K> const&k) {
 	auto &p = access(m_pairs, k);
 	if (p == nullptr) {
 		if (static_cast<double>(m_pairs.size()) * 0.7 <
@@ -154,13 +143,13 @@ constexpr T &HashMap<K, T>::operator[](const K &k) {
 		}
 		p = new Pair;
 		p->key = k;
-		m_keys.push_back(k);
+		m_keys.emplace_back(k);
 	}
 	return p->value;
 }
 
 template<typename K, typename T>
-constexpr Result<T*> HashMap<K, T>::at(const K &k) noexcept {
+constexpr Result<T*> HashMap<K, T>::at(MaybeSV_t<K> const&k) noexcept {
 	auto p = access(m_pairs, k);
 	if (!p) {
 		return {nullptr, OxError(1, "value not found for given key")};
@@ -169,7 +158,7 @@ constexpr Result<T*> HashMap<K, T>::at(const K &k) noexcept {
 }
 
 template<typename K, typename T>
-constexpr Result<const T*> HashMap<K, T>::at(const K &k) const noexcept {
+constexpr Result<const T*> HashMap<K, T>::at(MaybeSV_t<K> const&k) const noexcept {
 	auto p = access(m_pairs, k);
 	if (!p) {
 		return {nullptr, OxError(1, "value not found for given key")};
@@ -178,14 +167,14 @@ constexpr Result<const T*> HashMap<K, T>::at(const K &k) const noexcept {
 }
 
 template<typename K, typename T>
-constexpr void HashMap<K, T>::erase(const K &k) {
+constexpr void HashMap<K, T>::erase(MaybeSV_t<K> const&k) {
 	if (!contains(k)) {
 		return;
 	}
 	auto h = hash(k) % m_pairs.size();
 	while (true) {
 		const auto &p = m_pairs[h];
-		if (p == nullptr || ox_strcmp(p->key, k) == 0) {
+		if (p == nullptr || p->key == k) {
 			oxIgnoreError(m_pairs.erase(h));
 			break;
 		} else {
@@ -196,7 +185,7 @@ constexpr void HashMap<K, T>::erase(const K &k) {
 }
 
 template<typename K, typename T>
-constexpr bool HashMap<K, T>::contains(const K &k) const noexcept {
+constexpr bool HashMap<K, T>::contains(MaybeSV_t<K> const&k) const noexcept {
 	return access(m_pairs, k) != nullptr;
 }
 
@@ -206,7 +195,7 @@ constexpr std::size_t HashMap<K, T>::size() const noexcept {
 }
 
 template<typename K, typename T>
-constexpr const Vector<K> &HashMap<K, T>::keys() const noexcept {
+constexpr Vector<K> const&HashMap<K, T>::keys() const noexcept {
 	return m_keys;
 }
 
@@ -223,35 +212,39 @@ template<typename K, typename T>
 constexpr void HashMap<K, T>::expand() {
 	Vector<Pair*> r;
 	for (std::size_t i = 0; i < m_keys.size(); ++i) {
-		auto k = m_keys[i];
+		K k{m_keys[i]};
 		access(r, k) = std::move(access(m_pairs, k));
 	}
 	m_pairs = std::move(r);
 }
 
 template<typename K, typename T>
-constexpr uint64_t HashMap<K, T>::hash(auto k) noexcept {
+constexpr uint64_t HashMap<K, T>::hash(Integral_c auto k) noexcept {
 	uint64_t sum = 1;
-	if constexpr(is_integral_v<decltype(k)>) {
-		for (auto i = 0u; i < sizeof(K); ++i) {
-			const auto shift = i * 8;
-			const auto v = static_cast<uint64_t>(k >> shift & 0xff);
-			sum += (sum + v) * 7 * sum;
-		}
-	} else {
-		for (auto i = 0u; k[i]; ++i) {
-			sum += ((sum + static_cast<uint64_t>(k[i])) * 7) * sum;
-		}
+	for (auto i = 0u; i < sizeof(K); ++i) {
+		const auto shift = i * 8;
+		const auto v = static_cast<uint64_t>(k >> shift & 0xff);
+		sum += (sum + v) * 7 * sum;
 	}
 	return sum;
 }
 
 template<typename K, typename T>
-constexpr typename HashMap<K, T>::Pair *const&HashMap<K, T>::access(const Vector<Pair*> &pairs, const K &k) const {
+constexpr uint64_t HashMap<K, T>::hash(StringView const&k) noexcept {
+	uint64_t sum = 1;
+	for (auto i = 0u; i < k.len(); ++i) {
+		sum += ((sum + static_cast<uint64_t>(k[i])) * 7) * sum;
+	}
+	return sum;
+}
+
+template<typename K, typename T>
+template<typename KK>
+constexpr typename HashMap<K, T>::Pair *const&HashMap<K, T>::access(Vector<Pair*> const&pairs, KK const&k) const {
 	auto h = static_cast<std::size_t>(hash(k) % pairs.size());
 	while (true) {
 		const auto &p = pairs[h];
-		if (p == nullptr || ox_strcmp(p->key, k) == 0) {
+		if (p == nullptr || p->key == k) {
 			return p;
 		} else {
 			h = (h + 1) % pairs.size();
@@ -260,18 +253,12 @@ constexpr typename HashMap<K, T>::Pair *const&HashMap<K, T>::access(const Vector
 }
 
 template<typename K, typename T>
-constexpr typename HashMap<K, T>::Pair *&HashMap<K, T>::access(Vector<Pair*> &pairs, const K &k) {
+template<typename KK>
+constexpr typename HashMap<K, T>::Pair *&HashMap<K, T>::access(Vector<Pair*> &pairs, KK const&k) {
 	auto h = static_cast<std::size_t>(hash(k) % pairs.size());
 	while (true) {
 		auto &p = pairs[h];
-		bool matches = [&] {
-			if constexpr (is_integral_v<K>) {
-				return p == nullptr || k == p->key;
-			} else {
-				return p == nullptr || ox_strcmp(p->key, k) == 0;
-			}
-		}();
-		if (matches) {
+		if (p == nullptr || p->key == k) {
 			return p;
 		} else {
 			h = (h + 1) % pairs.size();

deps/ox/src/ox/std/iterator.hpp

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015 - 2022 gary@drinkingtea.net
+ * Copyright 2015 - 2023 gary@drinkingtea.net
  *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
@@ -8,6 +8,8 @@
 
 #pragma once
 
+#include "math.hpp"
+
 #if !__has_include(<iterator>)
 #include "stddef.hpp"
 
@@ -48,4 +50,116 @@ struct Iterator {
 	using difference_type = DiffType;
 };
 
+
+template<typename T, typename RefType, typename PtrType, bool reverse = false>
+struct SpanIterator {
+	public:
+		using iterator_category = std::bidirectional_iterator_tag;
+		using value_type = T;
+		using pointer = T*;
+		using reference = T&;
+		using difference_type = std::ptrdiff_t;
+
+	private:
+		PtrType m_t = nullptr;
+		std::size_t m_offset = 0;
+		std::size_t m_max = 0;
+
+	public:
+		constexpr SpanIterator() noexcept = default;
+
+		constexpr SpanIterator(PtrType t, std::size_t offset, std::size_t max) noexcept:
+			m_t(t),
+			m_offset(offset),
+			m_max(max) {
+		}
+
+		constexpr auto offset() const noexcept {
+			return m_offset;
+		}
+
+		constexpr SpanIterator operator+(std::size_t s) const noexcept {
+			if constexpr(reverse) {
+				return SpanIterator(m_t, max<std::size_t>(m_offset - s, 0), m_max);
+			} else {
+				return SpanIterator(m_t, min<std::size_t>(m_offset + s, m_max), m_max);
+			}
+		}
+
+		constexpr auto operator-(const SpanIterator &other) const noexcept {
+			if constexpr(reverse) {
+				return m_offset + other.m_offset;
+			} else {
+				return m_offset - other.m_offset;
+			}
+		}
+
+		constexpr SpanIterator operator-(std::size_t s) const noexcept {
+			if constexpr(reverse) {
+				return SpanIterator(m_t, min<std::size_t>(m_offset + s, m_max), m_max);
+			} else {
+				return SpanIterator(m_t, max<std::size_t>(m_offset - s, 0), m_max);
+			}
+		}
+
+		constexpr SpanIterator &operator+=(std::size_t s) noexcept {
+			if constexpr(reverse) {
+				m_offset = max<std::size_t>(m_offset - s, 0);
+			} else {
+				m_offset = min(m_offset + s, m_max);
+			}
+			return *this;
+		}
+
+		constexpr SpanIterator &operator-=(std::size_t s) noexcept {
+			if constexpr(reverse) {
+				m_offset = min(m_offset + s, m_max);
+			} else {
+				m_offset = max<std::size_t>(m_offset - s, 0);
+			}
+			return *this;
+		}
+
+		constexpr SpanIterator &operator++() noexcept {
+			return operator+=(1);
+		}
+
+		constexpr SpanIterator &operator--() noexcept {
+			return operator-=(1);
+		}
+
+		constexpr RefType operator*() const noexcept {
+			return m_t[m_offset];
+		}
+
+		constexpr RefType operator[](std::size_t s) const noexcept {
+			return m_t[s];
+		}
+
+		constexpr bool operator<(const SpanIterator &other) const noexcept {
+			return m_offset < other.m_offset;
+		}
+
+		constexpr bool operator>(const SpanIterator &other) const noexcept {
+			return m_offset > other.m_offset;
+		}
+
+		constexpr bool operator<=(const SpanIterator &other) const noexcept {
+			return m_offset <= other.m_offset;
+		}
+
+		constexpr bool operator>=(const SpanIterator &other) const noexcept {
+			return m_offset >= other.m_offset;
+		}
+
+		constexpr bool operator==(const SpanIterator &other) const noexcept {
+			return m_t == other.m_t && m_offset == other.m_offset && m_max == other.m_max;
+		}
+
+		constexpr bool operator!=(const SpanIterator &other) const noexcept {
+			return m_t != other.m_t || m_offset != other.m_offset || m_max != other.m_max;
+		}
+
+};
+
 }

deps/ox/src/ox/std/memory.hpp

@@ -39,6 +39,7 @@ constexpr T *construct_at(T *p, Args &&...args ) {
 
 #endif
 
+#include "error.hpp"
 #include "utility.hpp"
 
 
@@ -74,6 +75,7 @@ class SharedPtr {
 		int *m_refCnt = nullptr;
 
 	public:
+		using value_type = T;
 		explicit constexpr SharedPtr(T *t = nullptr) noexcept: m_t(t), m_refCnt(new int) {
 		}
 
@@ -180,9 +182,10 @@ template<typename T, typename Deleter = DefaultDelete>
 class UniquePtr {
 
 	private:
-		T *m_t;
+		T *m_t = nullptr;
 
 	public:
+		using value_type = T;
 		explicit constexpr UniquePtr(T *t = nullptr) noexcept: m_t(t) {
 		}
 
@@ -190,8 +193,8 @@ class UniquePtr {
 
 		constexpr UniquePtr(const UniquePtr&) = delete;
 
-		template<typename U>
-		constexpr UniquePtr(UniquePtr<U> &&other) noexcept {
+		template<typename U, typename UDeleter>
+		constexpr UniquePtr(UniquePtr<U, UDeleter> &&other) noexcept {
 			m_t = other.release();
 		}
 
@@ -210,25 +213,25 @@ class UniquePtr {
 			return m_t;
 		}
 
-		template<typename U>
-		constexpr void reset(UniquePtr<U> &&other = UniquePtr()) {
+		template<typename U, typename UDeleter>
+		constexpr void reset(UniquePtr<U, UDeleter> &&other = UniquePtr()) {
 			auto t = m_t;
 			m_t = other.release();
 			Deleter()(t);
 		}
 
-		constexpr UniquePtr &operator=(const UniquePtr<T> &other) = delete;
+		constexpr UniquePtr &operator=(UniquePtr const&other) = delete;
 
-		template<typename U>
-		constexpr UniquePtr &operator=(const UniquePtr<U> &other) = delete;
+		template<typename U, typename UDeleter>
+		constexpr UniquePtr &operator=(UniquePtr<U, UDeleter> const&other) = delete;
 
-		constexpr UniquePtr &operator=(UniquePtr<T> &&other) {
+		constexpr UniquePtr &operator=(UniquePtr<T> &&other) noexcept {
 			reset(std::move(other));
 			return *this;
 		}
 
-		template<typename U>
-		constexpr UniquePtr &operator=(UniquePtr<U> &&other) {
+		template<typename U, typename UDeleter>
+		constexpr UniquePtr &operator=(UniquePtr<U, UDeleter> &&other) noexcept {
 			reset(std::move(other));
 			return *this;
 		}
@@ -247,8 +250,8 @@ class UniquePtr {
 
 };
 
-template<typename T>
-using UPtr = UniquePtr<T>;
+template<typename T, typename Deleter = DefaultDelete>
+using UPtr = UniquePtr<T, Deleter>;
 
 template<typename T>
 constexpr bool operator==(const UniquePtr<T> &p1, const UniquePtr<T> &p2) noexcept {
@@ -282,10 +285,20 @@ constexpr bool operator!=(std::nullptr_t, const UniquePtr<T> &p2) noexcept {
 }
 
 
-template<typename T, typename ...Args>
+template<typename T, typename U = T, typename ...Args>
 [[nodiscard]]
 constexpr auto make_unique(Args&&... args) {
-	return UniquePtr(new T(ox::forward<Args>(args)...));
+	return UniquePtr<U>(new T(ox::forward<Args>(args)...));
+}
+
+template<typename T, typename U = T, typename ...Args>
+[[nodiscard]]
+constexpr Result<UniquePtr<U>> make_unique_catch(Args&&... args) noexcept {
+	try {
+		return UniquePtr<U>(new T(ox::forward<Args>(args)...));
+	} catch (ox::Exception const&ex) {
+		return ex.toError();
+	}
 }
 
 }

deps/ox/src/ox/std/new.hpp

@@ -35,14 +35,17 @@ constexpr void *operator new[](std::size_t, void *addr) noexcept {
 
 namespace ox {
 
-template<typename T, typename ...Args>
+template<typename T, typename U = T, typename ...Args>
 [[nodiscard]]
-constexpr T *make(Args &&...args) noexcept {
+constexpr U *make(Args &&...args) noexcept {
 #ifdef __cpp_exceptions
 	try {
 		return new T(ox::forward<Args>(args)...);
+	} catch (std::exception const&ex) {
+		oxPanic(OxError(1, ex.what()), ex.what());
+		return nullptr;
 	} catch (...) {
-		oxPanic(OxError(1, "Allocation or constructor failed"),  "Allocation or constructor failed");
+		oxPanic(OxError(2, "Allocation or constructor failed"),  "Allocation or constructor failed");
 		return nullptr;
 	}
 #else
@@ -112,11 +115,11 @@ class MallocaPtr {
 			return reinterpret_cast<T*>(m_val);
 		}
 
-		constexpr const T &operator=(MallocaPtr &other) = delete;
+		constexpr MallocaPtr &operator=(MallocaPtr &other) = delete;
 
-		constexpr const T &operator=(const MallocaPtr &other) = delete;
+		constexpr MallocaPtr &operator=(const MallocaPtr &other) = delete;
 
-		constexpr const T &operator=(MallocaPtr &&other) noexcept {
+		constexpr MallocaPtr &operator=(MallocaPtr &&other) noexcept {
 			if (m_onHeap && m_val) {
 				delete[] reinterpret_cast<uint8_t*>(m_val);
 			}
@@ -124,6 +127,7 @@ class MallocaPtr {
 			m_val = other.m_val;
 			other.m_onHeap = false;
 			other.m_val = nullptr;
+			return *this;
 		}
 
 		constexpr const T *operator->() const noexcept {
@@ -134,11 +138,11 @@ class MallocaPtr {
 			return reinterpret_cast<T*>(m_val);
 		}
 
-		constexpr operator const T*() const noexcept {
+		constexpr explicit operator const T*() const noexcept {
 			return reinterpret_cast<T*>(m_val);
 		}
 
-		constexpr operator T*() noexcept {
+		constexpr explicit operator T*() noexcept {
 			return reinterpret_cast<T*>(m_val);
 		}
 
@@ -150,6 +154,10 @@ class MallocaPtr {
 			return *reinterpret_cast<T*>(m_val);
 		}
 
+		constexpr bool operator==(std::nullptr_t) const noexcept {
+			return m_val == nullptr;
+		}
+
 		constexpr bool operator==(const MallocaPtr<T> &other) const noexcept {
 			return m_val == other.m_val && m_onHeap == other.m_onHeap;
 		}

deps/ox/src/ox/std/optional.hpp

@@ -28,7 +28,7 @@ class Optional {
 		constexpr Optional() noexcept = default;
 
 		template<typename ...Args>
-		explicit constexpr Optional(Args &&... args);
+		explicit constexpr Optional(ox::in_place_t, Args &&... args);
 
 		constexpr Optional(const Optional &other) {
 			if (other.m_ptr) {
@@ -64,20 +64,68 @@ class Optional {
 			return *m_ptr;
 		}
 
+		/**
+		 * Returns parameter alt if Result contains an error.
+		 * @param alt
+		 * @return value of Result or alt
+		 */
+		constexpr T or_value(T &&alt) const& noexcept {
+			if (!m_ptr) {
+				return std::move(alt);
+			}
+			return *m_ptr;
+		}
+
+		/**
+		 * Returns parameter alt if Result contains an error.
+		 * @param alt
+		 * @return value of Result or alt
+		 */
+		constexpr T or_value(T &&alt) && noexcept {
+			if (!m_ptr) {
+				return std::move(alt);
+			}
+			return std::move(*m_ptr);
+		}
+
+		/**
+		 * Returns parameter alt if Result contains an error.
+		 * @param alt
+		 * @return value of Result or alt
+		 */
+		constexpr T or_value(T const&alt) const& noexcept {
+			if (!m_ptr) {
+				return alt;
+			}
+			return *m_ptr;
+		}
+
+		/**
+		 * Returns parameter alt if Result contains an error.
+		 * @param alt
+		 * @return value of Result or alt
+		 */
+		constexpr T or_value(T const&alt) && noexcept {
+			if (!m_ptr) {
+				return alt;
+			}
+			return std::move(*m_ptr);
+		}
+
 		constexpr T &operator*() & noexcept {
-			return m_ptr;
+			return *m_ptr;
 		}
 
 		constexpr const T &operator*() const & noexcept {
-			return m_ptr;
+			return *m_ptr;
 		}
 
 		constexpr T &&operator*() && noexcept {
-			return m_ptr;
+			return *m_ptr;
 		}
 
 		constexpr const T &&operator*() const && noexcept {
-			return m_ptr;
+			return *m_ptr;
 		}
 
 		constexpr T *operator->() noexcept {
@@ -163,7 +211,7 @@ class Optional {
 
 template<typename T, std::size_t buffSize>
 template<typename... Args>
-constexpr Optional<T, buffSize>::Optional(Args &&... args) {
+constexpr Optional<T, buffSize>::Optional(ox::in_place_t, Args &&... args) {
 	emplace(ox::forward<Args>(args)...);
 }
 

deps/ox/src/ox/std/reader.cpp

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2015 - 2023 gary@drinkingtea.net
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+
+#ifdef OX_USE_STDLIB
+#include <cstdio>
+
+#include "array.hpp"
+#include "reader.hpp"
+
+namespace ox {
+
+[[nodiscard]]
+constexpr int sdMap(ox::ios_base::seekdir in) noexcept {
+	switch (in) {
+		case ox::ios_base::beg:
+			return SEEK_SET;
+		case ox::ios_base::end:
+			return SEEK_END;
+		case ox::ios_base::cur:
+			return SEEK_CUR;
+	}
+	return -1;
+}
+
+ox::Result<char> FileReader::peek() const noexcept {
+	auto const c = fgetc(m_file);
+	auto const ok = c != EOF;
+	if (ok && ungetc(c, m_file)) [[unlikely]] {
+		return OxError(1, "Unable to unget character");
+	}
+	return {static_cast<char>(c), OxError(!ok, "File peek failed")};
+}
+
+ox::Result<std::size_t> FileReader::read(char *v, std::size_t cnt) noexcept {
+	return fread(v, 1, cnt, m_file);
+}
+
+ox::Error FileReader::seekg(std::size_t p) noexcept {
+	return OxError(fseek(m_file, static_cast<int64_t>(p), SEEK_CUR) != 0);
+}
+
+ox::Error FileReader::seekg(int64_t p, ios_base::seekdir sd) noexcept {
+	return OxError(fseek(m_file, p, sdMap(sd)) != 0);
+}
+
+ox::Result<std::size_t> FileReader::tellg() noexcept {
+	const auto sz = ftell(m_file);
+	return {static_cast<std::size_t>(sz), OxError(sz == -1)};
+}
+
+}
+
+#endif

deps/ox/src/ox/std/reader.hpp

@@ -0,0 +1,96 @@
+/*
+ * Copyright 2015 - 2023 gary@drinkingtea.net
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#pragma once
+
+#ifdef OX_USE_STDLIB
+#include <cstdio>
+#endif
+
+#include "concepts.hpp"
+#include "error.hpp"
+#include "types.hpp"
+#include "writer.hpp"
+
+namespace ox {
+
+template<typename T>
+concept Reader_c = requires(T v) {
+	{v.peek()} -> ox::same_as<ox::Result<char>>;
+	{v.read(static_cast<char*>(nullptr), static_cast<std::size_t>(0))} -> ox::same_as<ox::Result<std::size_t>>;
+	{v.seekg(static_cast<int64_t>(0))} -> ox::same_as<ox::Error>;
+	{v.seekg(static_cast<std::size_t>(0), ios_base::beg)} -> ox::same_as<ox::Error>;
+	{v.tellg()} -> ox::same_as<ox::Result<std::size_t>>;
+};
+
+class Reader_v {
+	public:
+		virtual constexpr ~Reader_v() noexcept = default;
+		[[nodiscard]]
+		virtual constexpr ox::Result<char> peek() const noexcept = 0;
+		virtual constexpr ox::Result<std::size_t> read(char*, std::size_t) noexcept = 0;
+		virtual constexpr ox::Result<std::size_t> tellg() noexcept = 0;
+		virtual constexpr ox::Error seekg(std::size_t) noexcept = 0;
+		virtual constexpr ox::Error seekg(int64_t, ios_base::seekdir) = 0;
+};
+
+template<Reader_c T>
+class ReaderT: public Reader_v {
+	private:
+		T m_reader{};
+	public:
+		template<typename ...Args>
+		constexpr explicit ReaderT(Args&&... args) noexcept: m_reader(args...) {
+		}
+		constexpr ox::Result<char> peek() const noexcept override {
+			return m_reader.peek();
+		}
+		constexpr ox::Result<std::size_t> read(char *v, std::size_t cnt) noexcept override {
+			return m_reader.read(v, cnt);
+		}
+		constexpr ox::Error seekg(std::size_t p) noexcept override {
+			return m_reader.seekg(p);
+		}
+		constexpr ox::Error seekg(int64_t p, ios_base::seekdir sd) noexcept override {
+			return m_reader.seekg(p, sd);
+		}
+		constexpr ox::Result<std::size_t> tellg() noexcept override {
+			return m_reader.tellg();
+		}
+};
+
+#ifdef OX_USE_STDLIB
+class FileReader: public Reader_v {
+	private:
+		FILE *m_file = nullptr;
+	public:
+		constexpr explicit FileReader(FILE *file) noexcept: m_file(file) {}
+		ox::Result<char> peek() const noexcept override;
+		ox::Result<std::size_t> read(char *v, std::size_t cnt) noexcept override;
+		ox::Error seekg(std::size_t p) noexcept override;
+		ox::Error seekg(int64_t p, ios_base::seekdir sd) noexcept override;
+		ox::Result<std::size_t> tellg() noexcept override;
+};
+#endif
+
+/**
+ * Allocates the specified amount of data at the end of the current read stream.
+ * @param reader
+ * @param sz
+ * @return
+ */
+constexpr ox::Result<std::size_t> allocate(Reader_c auto *reader, std::size_t sz) noexcept {
+	const auto p = reader->tellg();
+	oxReturnError(reader->seekg(0, ios_base::end));
+	const auto out = reader->tellg();
+	oxReturnError(reader->read(nullptr, sz));
+	oxReturnError(reader->seekg(p));
+	return out;
+}
+
+}