[FIX]: Window Build Fix

.clang-format

@@ -1,10 +1,9 @@
----
 Language: Cpp
 Standard: c++20
 BasedOnStyle: Microsoft
 
-IndentWidth: 4
-TabWidth: 4
+IndentWidth: 2
+TabWidth: 2
 UseTab: Never
 AccessModifierOffset: -4
 
@@ -28,5 +27,4 @@ SpaceInEmptyParentheses: false
 SpacesInAngles: false
 
 SeparateDefinitionBlocks: Always
-SortIncludes: false
----
+SortIncludes: Never

.github/workflows/ci.yaml

@@ -18,6 +18,7 @@ jobs:
       fail-fast: false
       matrix:
         target: [x64-linux]
+        
     steps:
       - uses: actions/checkout@v4
 
@@ -29,3 +30,23 @@ jobs:
 
       - name: Build
         run: cmake --build --preset ${{ matrix.target }} --config Release
+
+  build-windows:
+    runs-on: windows-latest
+    permissions:
+      contents: read
+    strategy:
+      fail-fast: false
+      matrix:
+        target: [x64-windows]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: ilammy/msvc-dev-cmd@v1
+
+      - name: Configure
+        run: cmake --preset ${{ matrix.target }}
+
+      - name: Build
+        run: cmake --build --preset ${{ matrix.target }} --config Release

CMake/FindDeps.cmake

@@ -92,6 +92,8 @@ FetchContent_Declare(
     EXCLUDE_FROM_ALL
 )
 
+set(PUGIXML_NO_EXCEPTIONS ON)
+
 FetchContent_Declare(
   pugixml
   GIT_REPOSITORY https://github.com/zeux/pugixml.git

CMake/IAProjectConfig.cmake

@@ -18,6 +18,8 @@ macro(iacore_setup_project)
         add_compile_options(-Wall -Wextra -Wpedantic -Wno-language-extension-token)
     endif()
 
+    add_compile_options(-Wno-missing-field-initializers -Wno-missing-designated-field-initializers)
+
     if(CMAKE_SYSTEM_PROCESSOR MATCHES "amd64|x86_64|AMD64")
         set(IACORE_ARCH_X64 TRUE CACHE INTERNAL "")
     elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|arm64|ARM64")

CMake/Toolchains/x64-windows-clang.cmake

@@ -4,6 +4,8 @@ set(CMAKE_C_COMPILER clang-cl)
 set(CMAKE_CXX_COMPILER clang-cl)
 set(CMAKE_RC_COMPILER llvm-rc)
 
+set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded")
+
 set(triple x86_64-pc-windows-msvc)
 set(CMAKE_C_COMPILER_TARGET ${triple})
 set(CMAKE_CXX_COMPILER_TARGET ${triple})

CMake/Toolchains/x64-windows-cross-clang.cmake

@@ -0,0 +1,48 @@
+set(CMAKE_SYSTEM_NAME Windows)
+set(CMAKE_SYSTEM_PROCESSOR AMD64)
+set(CMAKE_C_COMPILER clang-cl)
+set(CMAKE_CXX_COMPILER clang-cl)
+set(CMAKE_RC_COMPILER llvm-rc)
+
+set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded")
+
+set(triple x86_64-pc-windows-msvc)
+set(CMAKE_C_COMPILER_TARGET ${triple})
+set(CMAKE_CXX_COMPILER_TARGET ${triple})
+
+set(CMAKE_LINKER lld-link)
+
+string(APPEND CMAKE_C_FLAGS   " /arch:AVX2 /clang:-mfma")
+string(APPEND CMAKE_CXX_FLAGS " /arch:AVX2 /clang:-mfma")
+
+# ---------------------------------------------------------------------
+# WinSDK directory can be splatted on linux using 'xwin' cargo package
+# Please also ensure to place OpenSSL windows binaries in WINSDK_PATH/openssl/x64
+# OpenSSL minimum required version is 3.0.0
+
+if(NOT DEFINED ENV{WINSDK_PATH} OR "$ENV{WINSDK_PATH}" STREQUAL "")
+    message(FATAL_ERROR "Environment variable WINSDK_PATH is not set. Please set it before running the cross toolchain.")
+endif()
+
+message(STATUS "Using Windows SDK at : $ENV{WINSDK_PATH}")
+
+set(OPENSSL_ROOT_DIR "$ENV{WINSDK_PATH}/openssl/x64")
+set(OPENSSL_USE_STATIC_LIBS TRUE)
+
+if(NOT EXISTS "${OPENSSL_ROOT_DIR}")
+    message(FATAL_ERROR "OpenSSL directory not found: ${OPENSSL_ROOT_DIR}")
+elseif(NOT IS_DIRECTORY "${OPENSSL_ROOT_DIR}")
+    message(FATAL_ERROR "OpenSSL path exists but is not a directory: ${OPENSSL_ROOT_DIR}")
+endif()
+
+string(APPEND CMAKE_C_FLAGS   " /imsvc $ENV{WINSDK_PATH}/crt/include /imsvc $ENV{WINSDK_PATH}/sdk/include/ucrt /imsvc $ENV{WINSDK_PATH}/sdk/include/um /imsvc $ENV{WINSDK_PATH}/sdk/include/shared")
+string(APPEND CMAKE_CXX_FLAGS " /imsvc $ENV{WINSDK_PATH}/crt/include /imsvc $ENV{WINSDK_PATH}/sdk/include/ucrt /imsvc $ENV{WINSDK_PATH}/sdk/include/um /imsvc $ENV{WINSDK_PATH}/sdk/include/shared")
+
+set(CRT_LIB_PATH "$ENV{WINSDK_PATH}/crt/lib/x86_64")
+set(SDK_LIB_PATH "$ENV{WINSDK_PATH}/sdk/lib")
+
+set(CMAKE_EXE_LINKER_FLAGS 
+    "${CMAKE_EXE_LINKER_FLAGS} /libpath:\"${CRT_LIB_PATH}\" /libpath:\"${SDK_LIB_PATH}/ucrt/x86_64\" /libpath:\"${SDK_LIB_PATH}/um/x86_64\""
+)
+
+# ---------------------------------------------------------------------

CMakePresets.json

@@ -47,10 +47,19 @@
       }
     },
     {
-      "name": "wasm",
+      "name": "wasm32-emscripten",
       "displayName": "IACore WebAssembly (Clang)",
       "inherits": "iacore-base",
       "cacheVariables": {}
+    },
+    {
+      "name": "x64-windows-cross",
+      "displayName": "IACore Windows x64 Cross (Linux Host) (Clang)",
+      "inherits": "iacore-base",
+      "cacheVariables": {
+        "CMAKE_C_COMPILER": "clang-cl",
+        "CMAKE_CXX_COMPILER": "clang-cl"
+      }
     }
   ],
   "buildPresets": [
@@ -71,8 +80,12 @@
       "configurePreset": "arm64-windows"
     },
     {
-      "name": "wasm",
-      "configurePreset": "wasm"
+      "name": "wasm32-emscripten",
+      "configurePreset": "wasm32-emscripten"
+    },
+    {
+      "name": "x64-windows-cross",
+      "configurePreset": "x64-windows-cross"
     }
   ]
 }

Src/IACore/CMakeLists.txt

@@ -57,7 +57,11 @@ endif()
 
 target_precompile_headers(IACore PUBLIC inc/IACore/PCH.hpp)
 
-set(NO_EXCEPT_FLAG "$<IF:$<CXX_COMPILER_ID:MSVC>,/EHs-c-,-fno-exceptions>")
+if(MSVC)
+    set(NO_EXCEPT_FLAG "/EHs-c-")
+else()
+    set(NO_EXCEPT_FLAG "-fno-exceptions")
+endif()
 target_compile_options(IACore PRIVATE ${NO_EXCEPT_FLAG})
 target_compile_options(IACore INTERFACE
     $<$<NOT:$<BOOL:$<TARGET_PROPERTY:USE_EXCEPTIONS>>>:${NO_EXCEPT_FLAG}>
@@ -71,6 +75,7 @@ define_property(TARGET PROPERTY USE_EXCEPTIONS
 target_compile_definitions(IACore PRIVATE 
     CPPHTTPLIB_OPENSSL_SUPPORT 
     CPPHTTPLIB_ZLIB_SUPPORT
+    _CRT_SECURE_NO_WARNINGS
     NOMINMAX
 )
 

Src/IACore/imp/cpp/AsyncOps.cpp

@@ -15,89 +15,104 @@
 
 #include <IACore/AsyncOps.hpp>
 
-namespace IACore {
-Mut<std::mutex> AsyncOps::s_queue_mutex;
-Mut<std::condition_variable> AsyncOps::s_wake_condition;
-Mut<Vec<std::jthread>> AsyncOps::s_schedule_workers;
-Mut<std::deque<AsyncOps::ScheduledTask>> AsyncOps::s_high_priority_queue;
-Mut<std::deque<AsyncOps::ScheduledTask>> AsyncOps::s_normal_priority_queue;
+namespace IACore
+{
+  Mut<std::mutex> AsyncOps::s_queue_mutex;
+  Mut<std::condition_variable> AsyncOps::s_wake_condition;
+  Mut<Vec<std::jthread>> AsyncOps::s_schedule_workers;
+  Mut<std::deque<AsyncOps::ScheduledTask>> AsyncOps::s_high_priority_queue;
+  Mut<std::deque<AsyncOps::ScheduledTask>> AsyncOps::s_normal_priority_queue;
 
-auto AsyncOps::run_task(Mut<std::function<void()>> task) -> void {
+  auto AsyncOps::run_task(Mut<std::function<void()>> task) -> void
+  {
     std::jthread(std::move(task)).detach();
-}
+  }
 
-auto AsyncOps::initialize_scheduler(Mut<u8> worker_count) -> Result<void> {
-  if (worker_count == 0) {
-    Const<u32> hw_concurrency = std::thread::hardware_concurrency();
+  auto AsyncOps::initialize_scheduler(Mut<u8> worker_count) -> Result<void>
+  {
+    if (worker_count == 0)
+    {
+      const u32 hw_concurrency = std::thread::hardware_concurrency();
       Mut<u32> threads = 2;
-    if (hw_concurrency > 2) {
+      if (hw_concurrency > 2)
+      {
         threads = hw_concurrency - 2;
       }
 
-    if (threads > 255) {
+      if (threads > 255)
+      {
         threads = 255;
       }
       worker_count = static_cast<u8>(threads);
     }
 
-  for (Mut<u32> i = 0; i < worker_count; ++i) {
-    s_schedule_workers.emplace_back(schedule_worker_loop,
-                                    static_cast<WorkerId>(i + 1));
+    for (Mut<u32> i = 0; i < worker_count; ++i)
+    {
+      s_schedule_workers.emplace_back(schedule_worker_loop, static_cast<WorkerId>(i + 1));
     }
 
     return {};
-}
+  }
 
-auto AsyncOps::terminate_scheduler() -> void {
-  for (MutRef<std::jthread> worker : s_schedule_workers) {
+  auto AsyncOps::terminate_scheduler() -> void
+  {
+    for (MutRef<std::jthread> worker : s_schedule_workers)
+    {
       worker.request_stop();
     }
 
     s_wake_condition.notify_all();
 
-  for (MutRef<std::jthread> worker : s_schedule_workers) {
-    if (worker.joinable()) {
+    for (MutRef<std::jthread> worker : s_schedule_workers)
+    {
+      if (worker.joinable())
+      {
         worker.join();
       }
     }
 
     s_schedule_workers.clear();
-}
+  }
 
-auto AsyncOps::schedule_task(Mut<std::function<void(WorkerId worker_id)>> task,
-                             Const<TaskTag> tag, Const<Schedule *> schedule,
-                             Const<Priority> priority) -> void {
-  ensure(!s_schedule_workers.empty(),
-         "Scheduler must be initialized before calling schedule_task");
+  auto AsyncOps::schedule_task(Mut<std::function<void(WorkerId worker_id)>> task, const TaskTag tag, Schedule *schedule,
+                               const Priority priority) -> void
+  {
+    ensure(!s_schedule_workers.empty(), "Scheduler must be initialized before calling schedule_task");
 
     schedule->counter.fetch_add(1);
     {
-    Const<std::lock_guard<std::mutex>> lock(s_queue_mutex);
-    if (priority == Priority::High) {
-      s_high_priority_queue.emplace_back(
-          ScheduledTask{tag, schedule, std::move(task)});
-    } else {
-      s_normal_priority_queue.emplace_back(
-          ScheduledTask{tag, schedule, std::move(task)});
+      const std::lock_guard<std::mutex> lock(s_queue_mutex);
+      if (priority == Priority::High)
+      {
+        s_high_priority_queue.emplace_back(ScheduledTask{tag, schedule, std::move(task)});
+      }
+      else
+      {
+        s_normal_priority_queue.emplace_back(ScheduledTask{tag, schedule, std::move(task)});
       }
     }
     s_wake_condition.notify_one();
-}
+  }
 
-auto AsyncOps::cancel_tasks_of_tag(Const<TaskTag> tag) -> void {
-  Const<std::lock_guard<std::mutex>> lock(s_queue_mutex);
+  auto AsyncOps::cancel_tasks_of_tag(const TaskTag tag) -> void
+  {
+    const std::lock_guard<std::mutex> lock(s_queue_mutex);
 
     {
       MutRef<std::deque<ScheduledTask>> queue = s_high_priority_queue;
-    for (Mut<std::deque<ScheduledTask>::iterator> it = queue.begin();
-         it != queue.end();
-         /* no incr */) {
-      if (it->tag == tag) {
-        if (it->schedule_handle->counter.fetch_sub(1) == 1) {
+      for (Mut<std::deque<ScheduledTask>::iterator> it = queue.begin(); it != queue.end();
+           /* no incr */)
+      {
+        if (it->tag == tag)
+        {
+          if (it->schedule_handle->counter.fetch_sub(1) == 1)
+          {
             it->schedule_handle->counter.notify_all();
           }
           it = queue.erase(it);
-      } else {
+        }
+        else
+        {
           ++it;
         }
       }
@@ -105,96 +120,115 @@ auto AsyncOps::cancel_tasks_of_tag(Const<TaskTag> tag) -> void {
 
     {
       MutRef<std::deque<ScheduledTask>> queue = s_normal_priority_queue;
-    for (Mut<std::deque<ScheduledTask>::iterator> it = queue.begin();
-         it != queue.end();
-         /* no incr */) {
-      if (it->tag == tag) {
-        if (it->schedule_handle->counter.fetch_sub(1) == 1) {
+      for (Mut<std::deque<ScheduledTask>::iterator> it = queue.begin(); it != queue.end();
+           /* no incr */)
+      {
+        if (it->tag == tag)
+        {
+          if (it->schedule_handle->counter.fetch_sub(1) == 1)
+          {
             it->schedule_handle->counter.notify_all();
           }
           it = queue.erase(it);
-      } else {
+        }
+        else
+        {
           ++it;
         }
       }
     }
-}
+  }
 
-auto AsyncOps::wait_for_schedule_completion(Const<Schedule *> schedule)
-    -> void {
+  auto AsyncOps::wait_for_schedule_completion(Schedule *schedule) -> void
+  {
     ensure(!s_schedule_workers.empty(), "Scheduler must be initialized before "
                                         "calling wait_for_schedule_completion");
 
-  while (schedule->counter.load() > 0) {
+    while (schedule->counter.load() > 0)
+    {
       Mut<ScheduledTask> task;
       Mut<bool> found_task = false;
       {
         Mut<std::unique_lock<std::mutex>> lock(s_queue_mutex);
-      if (!s_high_priority_queue.empty()) {
+        if (!s_high_priority_queue.empty())
+        {
           task = std::move(s_high_priority_queue.front());
           s_high_priority_queue.pop_front();
           found_task = true;
-      } else if (!s_normal_priority_queue.empty()) {
+        }
+        else if (!s_normal_priority_queue.empty())
+        {
           task = std::move(s_normal_priority_queue.front());
           s_normal_priority_queue.pop_front();
           found_task = true;
         }
       }
 
-    if (found_task) {
+      if (found_task)
+      {
         task.task(MAIN_THREAD_WORKER_ID);
-      if (task.schedule_handle->counter.fetch_sub(1) == 1) {
+        if (task.schedule_handle->counter.fetch_sub(1) == 1)
+        {
           task.schedule_handle->counter.notify_all();
         }
-    } else {
-      Const<u32> current_val = schedule->counter.load();
-      if (current_val > 0) {
+      }
+      else
+      {
+        const u32 current_val = schedule->counter.load();
+        if (current_val > 0)
+        {
           schedule->counter.wait(current_val);
         }
       }
     }
-}
+  }
 
-auto AsyncOps::get_worker_count() -> WorkerId {
+  auto AsyncOps::get_worker_count() -> WorkerId
+  {
     return static_cast<WorkerId>(s_schedule_workers.size());
-}
+  }
 
-auto AsyncOps::schedule_worker_loop(Const<std::stop_token> stop_token,
-                                    Const<WorkerId> worker_id) -> void {
-  while (!stop_token.stop_requested()) {
+  auto AsyncOps::schedule_worker_loop(const std::stop_token stop_token, const WorkerId worker_id) -> void
+  {
+    while (!stop_token.stop_requested())
+    {
       Mut<ScheduledTask> task;
       Mut<bool> found_task = false;
       {
         Mut<std::unique_lock<std::mutex>> lock(s_queue_mutex);
 
         s_wake_condition.wait(lock, [&stop_token] {
-        return !s_high_priority_queue.empty() ||
-               !s_normal_priority_queue.empty() || stop_token.stop_requested();
+          return !s_high_priority_queue.empty() || !s_normal_priority_queue.empty() || stop_token.stop_requested();
         });
 
-      if (stop_token.stop_requested() && s_high_priority_queue.empty() &&
-          s_normal_priority_queue.empty()) {
+        if (stop_token.stop_requested() && s_high_priority_queue.empty() && s_normal_priority_queue.empty())
+        {
           return;
         }
 
-      if (!s_high_priority_queue.empty()) {
+        if (!s_high_priority_queue.empty())
+        {
           task = std::move(s_high_priority_queue.front());
           s_high_priority_queue.pop_front();
           found_task = true;
-      } else if (!s_normal_priority_queue.empty()) {
+        }
+        else if (!s_normal_priority_queue.empty())
+        {
           task = std::move(s_normal_priority_queue.front());
           s_normal_priority_queue.pop_front();
           found_task = true;
         }
       }
 
-    if (found_task) {
+      if (found_task)
+      {
         task.task(worker_id);
-      if (task.schedule_handle->counter.fetch_sub(1) == 1) {
+        if (task.schedule_handle->counter.fetch_sub(1) == 1)
+        {
           task.schedule_handle->counter.notify_all();
         }
       }
     }
-}
+  }
 
 } // namespace IACore

Src/IACore/imp/cpp/CLI.cpp

@@ -15,13 +15,16 @@
 
 #include <IACore/CLI.hpp>
 
-namespace IACore {
-CLIParser::CLIParser(Const<Span<Const<String>>> args) : m_arg_list(args) {
+namespace IACore
+{
+  CLIParser::CLIParser(const Span<const String> args) : m_arg_list(args)
+  {
     m_current_arg = m_arg_list.begin();
 
     // Skip executable path
-  if (m_current_arg != m_arg_list.end()) {
+    if (m_current_arg != m_arg_list.end())
+    {
       m_current_arg++;
     }
-}
+  }
 } // namespace IACore

Src/IACore/imp/cpp/DataOps.cpp

@@ -22,166 +22,181 @@
 #include <zstd.h>
 
 #if IA_ARCH_X64
-#include <immintrin.h>
+#  include <immintrin.h>
 #endif
 
 #if IA_ARCH_ARM64
-#include <arm_acle.h>
+#  include <arm_acle.h>
 #endif
 
-namespace IACore {
-template <typename T>
-[[nodiscard]] inline auto read_unaligned(Const<Const<u8> *> ptr) -> T {
+namespace IACore
+{
+  template<typename T> [[nodiscard]] inline auto read_unaligned(const u8 *ptr) -> T
+  {
     Mut<T> v;
     std::memcpy(&v, ptr, sizeof(T));
     return v;
-}
+  }
 
-struct Crc32Tables {
+  struct Crc32Tables
+  {
     Mut<u32> table[8][256] = {};
 
-  consteval Crc32Tables() {
-    constexpr Const<u32> T = 0x82F63B78;
+    consteval Crc32Tables()
+    {
+      constexpr const u32 T = 0x82F63B78;
 
-    for (Mut<u32> i = 0; i < 256; i++) {
+      for (Mut<u32> i = 0; i < 256; i++)
+      {
         Mut<u32> crc = i;
-      for (Mut<i32> j = 0; j < 8; j++) {
+        for (Mut<i32> j = 0; j < 8; j++)
+        {
           crc = (crc >> 1) ^ ((crc & 1) ? T : 0);
         }
         table[0][i] = crc;
       }
 
-    for (Mut<i32> i = 0; i < 256; i++) {
-      for (Mut<i32> slice = 1; slice < 8; slice++) {
-        Const<u32> prev = table[slice - 1][i];
+      for (Mut<i32> i = 0; i < 256; i++)
+      {
+        for (Mut<i32> slice = 1; slice < 8; slice++)
+        {
+          const u32 prev = table[slice - 1][i];
           table[slice][i] = (prev >> 8) ^ table[0][prev & 0xFF];
         }
       }
     }
-};
+  };
 
-static constexpr Const<Crc32Tables> CRC32_TABLES{};
+  static constexpr const Crc32Tables CRC32_TABLES{};
 
 #if IA_ARCH_X64
-inline auto crc32_x64_hw(Ref<Span<Const<u8>>> data) -> u32 {
+  inline auto crc32_x64_hw(Ref<Span<const u8>> data) -> u32
+  {
     Mut<const u8 *> p = data.data();
 
     Mut<u32> crc = 0xFFFFFFFF;
     Mut<usize> len = data.size();
 
-  while (len >= 8) {
-    Const<u64> chunk = read_unaligned<u64>(p);
+    while (len >= 8)
+    {
+      const u64 chunk = read_unaligned<u64>(p);
       crc = static_cast<u32>(_mm_crc32_u64(static_cast<u64>(crc), chunk));
       p += 8;
       len -= 8;
     }
 
-  while (len--) {
+    while (len--)
+    {
       crc = _mm_crc32_u8(crc, *p++);
     }
 
     return ~crc;
-}
+  }
 #endif
 
 #if IA_ARCH_ARM64
-__attribute__((target("+crc"))) inline auto
-crc32_arm64_hw(Ref<Span<Const<u8>>> data) -> u32 {
+  __attribute__((target("+crc"))) inline auto crc32_arm64_hw(Ref<Span<const u8>> data) -> u32
+  {
     Mut<const u8 *> p = data.data();
 
     Mut<u32> crc = 0xFFFFFFFF;
     Mut<usize> len = data.size();
 
-  while (len >= 8) {
-    Const<u64> chunk = read_unaligned<u64>(p);
+    while (len >= 8)
+    {
+      const u64 chunk = read_unaligned<u64>(p);
       crc = __crc32cd(crc, chunk);
       p += 8;
       len -= 8;
     }
 
-  while (len--) {
+    while (len--)
+    {
       crc = __crc32cb(crc, *p++);
     }
 
     return ~crc;
-}
+  }
 #endif
 
-inline auto crc32_software_slice8(Ref<Span<Const<u8>>> data) -> u32 {
+  inline auto crc32_software_slice8(Ref<Span<const u8>> data) -> u32
+  {
     Mut<const u8 *> p = data.data();
     Mut<u32> crc = 0xFFFFFFFF;
     Mut<usize> len = data.size();
 
-  while (len >= 8) {
-    Const<u32> term1 = crc ^ read_unaligned<u32>(p);
-    Const<u32> term2 = read_unaligned<u32>(p + 4);
+    while (len >= 8)
+    {
+      const u32 term1 = crc ^ read_unaligned<u32>(p);
+      const u32 term2 = read_unaligned<u32>(p + 4);
 
-    crc = CRC32_TABLES.table[7][term1 & 0xFF] ^
-          CRC32_TABLES.table[6][(term1 >> 8) & 0xFF] ^
-          CRC32_TABLES.table[5][(term1 >> 16) & 0xFF] ^
-          CRC32_TABLES.table[4][(term1 >> 24)] ^
-          CRC32_TABLES.table[3][term2 & 0xFF] ^
-          CRC32_TABLES.table[2][(term2 >> 8) & 0xFF] ^
-          CRC32_TABLES.table[1][(term2 >> 16) & 0xFF] ^
-          CRC32_TABLES.table[0][(term2 >> 24)];
+      crc = CRC32_TABLES.table[7][term1 & 0xFF] ^ CRC32_TABLES.table[6][(term1 >> 8) & 0xFF] ^
+            CRC32_TABLES.table[5][(term1 >> 16) & 0xFF] ^ CRC32_TABLES.table[4][(term1 >> 24)] ^
+            CRC32_TABLES.table[3][term2 & 0xFF] ^ CRC32_TABLES.table[2][(term2 >> 8) & 0xFF] ^
+            CRC32_TABLES.table[1][(term2 >> 16) & 0xFF] ^ CRC32_TABLES.table[0][(term2 >> 24)];
 
       p += 8;
       len -= 8;
     }
 
-  while (len--) {
+    while (len--)
+    {
       crc = (crc >> 8) ^ CRC32_TABLES.table[0][(crc ^ *p++) & 0xFF];
     }
 
     return ~crc;
-}
+  }
 
-auto DataOps::crc32(Ref<Span<Const<u8>>> data) -> u32 {
+  auto DataOps::crc32(Ref<Span<const u8>> data) -> u32
+  {
 #if IA_ARCH_X64
     // IACore mandates AVX2 so no need to check
     return crc32_x64_hw(data);
 #elif IA_ARCH_ARM64
-  if (Platform::GetCapabilities().HardwareCRC32) {
+    if (Platform::GetCapabilities().HardwareCRC32)
+    {
       return crc32_arm64_hw(data);
     }
 #endif
     return crc32_software_slice8(data);
-}
+  }
 
-constexpr Const<u32> XXH_PRIME32_1 = 0x9E3779B1U;
-constexpr Const<u32> XXH_PRIME32_2 = 0x85EBCA77U;
-constexpr Const<u32> XXH_PRIME32_3 = 0xC2B2AE3DU;
-constexpr Const<u32> XXH_PRIME32_4 = 0x27D4EB2FU;
-constexpr Const<u32> XXH_PRIME32_5 = 0x165667B1U;
+  constexpr const u32 XXH_PRIME32_1 = 0x9E3779B1U;
+  constexpr const u32 XXH_PRIME32_2 = 0x85EBCA77U;
+  constexpr const u32 XXH_PRIME32_3 = 0xC2B2AE3DU;
+  constexpr const u32 XXH_PRIME32_4 = 0x27D4EB2FU;
+  constexpr const u32 XXH_PRIME32_5 = 0x165667B1U;
 
-inline auto xxh32_round(Mut<u32> seed, Const<u32> input) -> u32 {
+  inline auto xxh32_round(Mut<u32> seed, const u32 input) -> u32
+  {
     seed += input * XXH_PRIME32_2;
     seed = std::rotl(seed, 13);
     seed *= XXH_PRIME32_1;
     return seed;
-}
+  }
 
-auto DataOps::hash_xxhash(Ref<String> string, Const<u32> seed) -> u32 {
-  return hash_xxhash(
-      Span<Const<u8>>(reinterpret_cast<const u8 *>(string.data()),
-                      string.length()),
-      seed);
-}
+  auto DataOps::hash_xxhash(Ref<String> string, const u32 seed) -> u32
+  {
+    return hash_xxhash(Span<const u8>(reinterpret_cast<const u8 *>(string.data()), string.length()), seed);
+  }
 
-auto DataOps::hash_xxhash(Ref<Span<Const<u8>>> data, Const<u32> seed) -> u32 {
+  auto DataOps::hash_xxhash(Ref<Span<const u8>> data, const u32 seed) -> u32
+  {
     Mut<const u8 *> p = data.data();
-  Const<const u8 *> b_end = p + data.size();
+    const u8 *b_end = p + data.size();
     Mut<u32> h32{};
 
-  if (data.size() >= 16) {
-    Const<const u8 *> limit = b_end - 16;
+    if (data.size() >= 16)
+    {
+      const u8 *limit = b_end - 16;
 
       Mut<u32> v1 = seed + XXH_PRIME32_1 + XXH_PRIME32_2;
       Mut<u32> v2 = seed + XXH_PRIME32_2;
       Mut<u32> v3 = seed + 0;
       Mut<u32> v4 = seed - XXH_PRIME32_1;
 
-    do {
+      do
+      {
         v1 = xxh32_round(v1, read_unaligned<u32>(p));
         p += 4;
         v2 = xxh32_round(v2, read_unaligned<u32>(p));
@@ -192,22 +207,25 @@ auto DataOps::hash_xxhash(Ref<Span<Const<u8>>> data, Const<u32> seed) -> u32 {
         p += 4;
       } while (p <= limit);
 
-    h32 = std::rotl(v1, 1) + std::rotl(v2, 7) + std::rotl(v3, 12) +
-          std::rotl(v4, 18);
-  } else {
+      h32 = std::rotl(v1, 1) + std::rotl(v2, 7) + std::rotl(v3, 12) + std::rotl(v4, 18);
+    }
+    else
+    {
       h32 = seed + XXH_PRIME32_5;
     }
 
     h32 += static_cast<u32>(data.size());
 
-  while (p + 4 <= b_end) {
-    Const<u32> t = read_unaligned<u32>(p) * XXH_PRIME32_3;
+    while (p + 4 <= b_end)
+    {
+      const u32 t = read_unaligned<u32>(p) * XXH_PRIME32_3;
       h32 += t;
       h32 = std::rotl(h32, 17) * XXH_PRIME32_4;
       p += 4;
     }
 
-  while (p < b_end) {
+    while (p < b_end)
+    {
       h32 += (*p++) * XXH_PRIME32_5;
       h32 = std::rotl(h32, 11) * XXH_PRIME32_1;
     }
@@ -219,56 +237,64 @@ auto DataOps::hash_xxhash(Ref<Span<Const<u8>>> data, Const<u32> seed) -> u32 {
     h32 ^= h32 >> 16;
 
     return h32;
-}
+  }
 
-constexpr Const<u32> FNV1A_32_PRIME = 0x01000193;
-constexpr Const<u32> FNV1A_32_OFFSET = 0x811c9dc5;
+  constexpr const u32 FNV1A_32_PRIME = 0x01000193;
+  constexpr const u32 FNV1A_32_OFFSET = 0x811c9dc5;
 
-auto DataOps::hash_fnv1a(Ref<String> string) -> u32 {
+  auto DataOps::hash_fnv1a(Ref<String> string) -> u32
+  {
     Mut<u32> hash = FNV1A_32_OFFSET;
-  for (Const<char> c : string) {
+    for (const char c : string)
+    {
       hash ^= static_cast<u8>(c);
       hash *= FNV1A_32_PRIME;
     }
     return hash;
-}
+  }
 
-auto DataOps::hash_fnv1a(Ref<Span<Const<u8>>> data) -> u32 {
+  auto DataOps::hash_fnv1a(Ref<Span<const u8>> data) -> u32
+  {
     Mut<u32> hash = FNV1A_32_OFFSET;
-  Const<const u8 *> ptr = data.data();
+    const u8 *ptr = data.data();
 
-  for (Mut<usize> i = 0; i < data.size(); ++i) {
+    for (Mut<usize> i = 0; i < data.size(); ++i)
+    {
       hash ^= ptr[i];
       hash *= FNV1A_32_PRIME;
     }
     return hash;
-}
+  }
 
-auto DataOps::detect_compression(Const<Span<Const<u8>>> data)
-    -> CompressionType {
-  if (data.size() < 2) {
+  auto DataOps::detect_compression(const Span<const u8> data) -> CompressionType
+  {
+    if (data.size() < 2)
+    {
       return CompressionType::None;
     }
 
-  if (data[0] == 0x1F && data[1] == 0x8B) {
+    if (data[0] == 0x1F && data[1] == 0x8B)
+    {
       return CompressionType::Gzip;
     }
 
-  if (data[0] == 0x78 &&
-      (data[1] == 0x01 || data[1] == 0x9C || data[1] == 0xDA)) {
+    if (data[0] == 0x78 && (data[1] == 0x01 || data[1] == 0x9C || data[1] == 0xDA))
+    {
       return CompressionType::Zlib;
     }
 
     return CompressionType::None;
-}
+  }
 
-auto DataOps::zlib_inflate(Ref<Span<Const<u8>>> data) -> Result<Vec<u8>> {
+  auto DataOps::zlib_inflate(Ref<Span<const u8>> data) -> Result<Vec<u8>>
+  {
     Mut<z_stream> zs{};
     zs.zalloc = Z_NULL;
     zs.zfree = Z_NULL;
     zs.opaque = Z_NULL;
 
-  if (inflateInit2(&zs, 15 + 32) != Z_OK) {
+    if (inflateInit2(&zs, 15 + 32) != Z_OK)
+    {
       return fail("Failed to initialize zlib inflate");
     }
 
@@ -276,18 +302,19 @@ auto DataOps::zlib_inflate(Ref<Span<Const<u8>>> data) -> Result<Vec<u8>> {
     zs.avail_in = static_cast<uInt>(data.size());
 
     Mut<Vec<u8>> out_buffer;
-  Const<usize> guess_size =
-      data.size() < 1024 ? data.size() * 4 : data.size() * 2;
+    const usize guess_size = data.size() < 1024 ? data.size() * 4 : data.size() * 2;
     out_buffer.resize(guess_size);
 
     zs.next_out = reinterpret_cast<Bytef *>(out_buffer.data());
     zs.avail_out = static_cast<uInt>(out_buffer.size());
 
     Mut<int> ret;
-  do {
-    if (zs.avail_out == 0) {
-      Const<usize> current_pos = zs.total_out;
-      Const<usize> new_size = out_buffer.size() * 2;
+    do
+    {
+      if (zs.avail_out == 0)
+      {
+        const usize current_pos = zs.total_out;
+        const usize new_size = out_buffer.size() * 2;
         out_buffer.resize(new_size);
 
         zs.next_out = reinterpret_cast<Bytef *>(out_buffer.data() + current_pos);
@@ -300,22 +327,25 @@ auto DataOps::zlib_inflate(Ref<Span<Const<u8>>> data) -> Result<Vec<u8>> {
 
     inflateEnd(&zs);
 
-  if (ret != Z_STREAM_END) {
+    if (ret != Z_STREAM_END)
+    {
       return fail("Failed to inflate: corrupt data or stream error");
     }
 
     out_buffer.resize(zs.total_out);
 
     return out_buffer;
-}
+  }
 
-auto DataOps::zlib_deflate(Ref<Span<Const<u8>>> data) -> Result<Vec<u8>> {
+  auto DataOps::zlib_deflate(Ref<Span<const u8>> data) -> Result<Vec<u8>>
+  {
     Mut<z_stream> zs{};
     zs.zalloc = Z_NULL;
     zs.zfree = Z_NULL;
     zs.opaque = Z_NULL;
 
-  if (deflateInit(&zs, Z_DEFAULT_COMPRESSION) != Z_OK) {
+    if (deflateInit(&zs, Z_DEFAULT_COMPRESSION) != Z_OK)
+    {
       return fail("Failed to initialize zlib deflate");
     }
 
@@ -328,9 +358,10 @@ auto DataOps::zlib_deflate(Ref<Span<Const<u8>>> data) -> Result<Vec<u8>> {
     zs.next_out = reinterpret_cast<Bytef *>(out_buffer.data());
     zs.avail_out = static_cast<uInt>(out_buffer.size());
 
-  Const<int> ret = deflate(&zs, Z_FINISH);
+    const int ret = deflate(&zs, Z_FINISH);
 
-  if (ret != Z_STREAM_END) {
+    if (ret != Z_STREAM_END)
+    {
       deflateEnd(&zs);
       return fail("Failed to deflate, ran out of buffer memory");
     }
@@ -339,24 +370,26 @@ auto DataOps::zlib_deflate(Ref<Span<Const<u8>>> data) -> Result<Vec<u8>> {
 
     deflateEnd(&zs);
     return out_buffer;
-}
+  }
 
-auto DataOps::zstd_inflate(Ref<Span<Const<u8>>> data) -> Result<Vec<u8>> {
-  Const<unsigned long long> content_size =
-      ZSTD_getFrameContentSize(data.data(), data.size());
+  auto DataOps::zstd_inflate(Ref<Span<const u8>> data) -> Result<Vec<u8>>
+  {
+    const unsigned long long content_size = ZSTD_getFrameContentSize(data.data(), data.size());
 
-  if (content_size == ZSTD_CONTENTSIZE_ERROR) {
+    if (content_size == ZSTD_CONTENTSIZE_ERROR)
+    {
       return fail("Failed to inflate: Not valid ZSTD compressed data");
     }
 
-  if (content_size != ZSTD_CONTENTSIZE_UNKNOWN) {
+    if (content_size != ZSTD_CONTENTSIZE_UNKNOWN)
+    {
       Mut<Vec<u8>> out_buffer;
       out_buffer.resize(static_cast<usize>(content_size));
 
-    Const<usize> d_size = ZSTD_decompress(out_buffer.data(), out_buffer.size(),
-                                          data.data(), data.size());
+      const usize d_size = ZSTD_decompress(out_buffer.data(), out_buffer.size(), data.data(), data.size());
 
-    if (ZSTD_isError(d_size)) {
+      if (ZSTD_isError(d_size))
+      {
         return fail("Failed to inflate: {}", ZSTD_getErrorName(d_size));
       }
 
@@ -371,16 +404,19 @@ auto DataOps::zstd_inflate(Ref<Span<Const<u8>>> data) -> Result<Vec<u8>> {
     Mut<ZSTD_outBuffer> output = {out_buffer.data(), out_buffer.size(), 0};
 
     Mut<usize> ret;
-  do {
+    do
+    {
       ret = ZSTD_decompressStream(dctx, &output, &input);
 
-    if (ZSTD_isError(ret)) {
+      if (ZSTD_isError(ret))
+      {
         ZSTD_freeDCtx(dctx);
         return fail("Failed to inflate: {}", ZSTD_getErrorName(ret));
       }
 
-    if (output.pos == output.size) {
-      Const<usize> new_size = out_buffer.size() * 2;
+      if (output.pos == output.size)
+      {
+        const usize new_size = out_buffer.size() * 2;
         out_buffer.resize(new_size);
         output.dst = out_buffer.data();
         output.size = new_size;
@@ -392,33 +428,35 @@ auto DataOps::zstd_inflate(Ref<Span<Const<u8>>> data) -> Result<Vec<u8>> {
     ZSTD_freeDCtx(dctx);
 
     return out_buffer;
-}
+  }
 
-auto DataOps::zstd_deflate(Ref<Span<Const<u8>>> data) -> Result<Vec<u8>> {
-  Const<usize> max_dst_size = ZSTD_compressBound(data.size());
+  auto DataOps::zstd_deflate(Ref<Span<const u8>> data) -> Result<Vec<u8>>
+  {
+    const usize max_dst_size = ZSTD_compressBound(data.size());
 
     Mut<Vec<u8>> out_buffer;
     out_buffer.resize(max_dst_size);
 
-  Const<usize> compressed_size = ZSTD_compress(out_buffer.data(), max_dst_size,
-                                               data.data(), data.size(), 3);
+    const usize compressed_size = ZSTD_compress(out_buffer.data(), max_dst_size, data.data(), data.size(), 3);
 
-  if (ZSTD_isError(compressed_size)) {
+    if (ZSTD_isError(compressed_size))
+    {
       return fail("Failed to deflate: {}", ZSTD_getErrorName(compressed_size));
     }
 
     out_buffer.resize(compressed_size);
     return out_buffer;
-}
+  }
 
-auto DataOps::gzip_deflate(Ref<Span<Const<u8>>> data) -> Result<Vec<u8>> {
+  auto DataOps::gzip_deflate(Ref<Span<const u8>> data) -> Result<Vec<u8>>
+  {
     Mut<z_stream> zs{};
     zs.zalloc = Z_NULL;
     zs.zfree = Z_NULL;
     zs.opaque = Z_NULL;
 
-  if (deflateInit2(&zs, Z_DEFAULT_COMPRESSION, Z_DEFLATED, 15 + 16, 8,
-                   Z_DEFAULT_STRATEGY) != Z_OK) {
+    if (deflateInit2(&zs, Z_DEFAULT_COMPRESSION, Z_DEFLATED, 15 + 16, 8, Z_DEFAULT_STRATEGY) != Z_OK)
+    {
       return fail("Failed to initialize gzip deflate");
     }
 
@@ -432,9 +470,10 @@ auto DataOps::gzip_deflate(Ref<Span<Const<u8>>> data) -> Result<Vec<u8>> {
     zs.next_out = reinterpret_cast<Bytef *>(out_buffer.data());
     zs.avail_out = static_cast<uInt>(out_buffer.size());
 
-  Const<int> ret = deflate(&zs, Z_FINISH);
+    const int ret = deflate(&zs, Z_FINISH);
 
-  if (ret != Z_STREAM_END) {
+    if (ret != Z_STREAM_END)
+    {
       deflateEnd(&zs);
       return fail("Failed to deflate");
     }
@@ -443,10 +482,11 @@ auto DataOps::gzip_deflate(Ref<Span<Const<u8>>> data) -> Result<Vec<u8>> {
 
     deflateEnd(&zs);
     return out_buffer;
-}
+  }
 
-auto DataOps::gzip_inflate(Ref<Span<Const<u8>>> data) -> Result<Vec<u8>> {
+  auto DataOps::gzip_inflate(Ref<Span<const u8>> data) -> Result<Vec<u8>>
+  {
     return zlib_inflate(data);
-}
+  }
 
 } // namespace IACore

Src/IACore/imp/cpp/FileOps.cpp

@@ -18,299 +18,335 @@
 #include <cstdio>
 
 #if IA_PLATFORM_UNIX
-#include <fcntl.h>
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <unistd.h>
+#  include <fcntl.h>
+#  include <sys/mman.h>
+#  include <sys/stat.h>
+#  include <unistd.h>
 #endif
 
-namespace IACore {
+namespace IACore
+{
 
-Mut<HashMap<const u8 *, std::tuple<void *, void *, void *>>>
-    FileOps::s_mapped_files;
+  Mut<HashMap<const u8 *, std::tuple<void *, void *, void *>>> FileOps::s_mapped_files;
 
-auto FileOps::unmap_file(Const<Const<u8> *> mapped_ptr) -> void {
-  if (!s_mapped_files.contains(mapped_ptr)) {
+  auto FileOps::unmap_file(const u8 *mapped_ptr) -> void
+  {
+    if (!s_mapped_files.contains(mapped_ptr))
+    {
       return;
     }
 
     Mut<decltype(s_mapped_files)::iterator> it = s_mapped_files.find(mapped_ptr);
-  Const<std::tuple<void *, void *, void *>> handles = it->second;
+    const std::tuple<void *, void *, void *> handles = it->second;
     s_mapped_files.erase(it);
 
 #if IA_PLATFORM_WINDOWS
     ::UnmapViewOfFile(std::get<1>(handles));
     ::CloseHandle(static_cast<HANDLE>(std::get<2>(handles)));
 
-  Const<HANDLE> handle = static_cast<HANDLE>(std::get<0>(handles));
-  if (handle != INVALID_HANDLE_VALUE) {
+    const HANDLE handle = static_cast<HANDLE>(std::get<0>(handles));
+    if (handle != INVALID_HANDLE_VALUE)
+    {
       ::CloseHandle(handle);
     }
 #elif IA_PLATFORM_UNIX
-  ::munmap(std::get<1>(handles), (usize)std::get<2>(handles));
-  Const<i32> fd = (i32)((u64)std::get<0>(handles));
-  if (fd != -1) {
+    ::munmap(std::get<1>(handles), (usize) std::get<2>(handles));
+    const i32 fd = (i32) ((u64) std::get<0>(handles));
+    if (fd != -1)
+    {
       ::close(fd);
     }
 #endif
-}
+  }
 
-auto FileOps::map_shared_memory(Ref<String> name, Const<usize> size,
-                                Const<bool> is_owner) -> Result<u8 *> {
+  auto FileOps::map_shared_memory(Ref<String> name, const usize size, const bool is_owner) -> Result<u8 *>
+  {
 #if IA_PLATFORM_WINDOWS
-  Const<int> wchars_num =
-      MultiByteToWideChar(CP_UTF8, 0, name.c_str(), -1, NULL, 0);
+    const int wchars_num = MultiByteToWideChar(CP_UTF8, 0, name.c_str(), -1, NULL, 0);
     Mut<std::wstring> w_name(wchars_num, 0);
     MultiByteToWideChar(CP_UTF8, 0, name.c_str(), -1, &w_name[0], wchars_num);
 
     Mut<HANDLE> h_map = NULL;
-  if (is_owner) {
-    h_map = CreateFileMappingW(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE,
-                               (DWORD)(size >> 32), (DWORD)(size & 0xFFFFFFFF),
-                               w_name.c_str());
-  } else {
+    if (is_owner)
+    {
+      h_map = CreateFileMappingW(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, (DWORD) (size >> 32),
+                                 (DWORD) (size & 0xFFFFFFFF), w_name.c_str());
+    }
+    else
+    {
       h_map = OpenFileMappingW(FILE_MAP_ALL_ACCESS, false, w_name.c_str());
     }
 
-  if (h_map == NULL) {
-    return fail("Failed to {} shared memory '{}'",
-                is_owner ? "owner" : "consumer", name);
+    if (h_map == NULL)
+    {
+      return fail("Failed to {} shared memory '{}'", is_owner ? "owner" : "consumer", name);
     }
 
-  Mut<u8 *> result =
-      static_cast<u8 *>(MapViewOfFile(h_map, FILE_MAP_ALL_ACCESS, 0, 0, size));
-  if (result == NULL) {
+    Mut<u8 *> result = static_cast<u8 *>(MapViewOfFile(h_map, FILE_MAP_ALL_ACCESS, 0, 0, size));
+    if (result == NULL)
+    {
       CloseHandle(h_map);
       return fail("Failed to map view of shared memory '{}'", name);
     }
 
-  s_mapped_files[result] = std::make_tuple((void *)INVALID_HANDLE_VALUE,
-                                           (void *)result, (void *)h_map);
+    s_mapped_files[result] = std::make_tuple((void *) INVALID_HANDLE_VALUE, (void *) result, (void *) h_map);
     return result;
 
 #elif IA_PLATFORM_UNIX
     Mut<int> fd = -1;
-  if (is_owner) {
+    if (is_owner)
+    {
       fd = shm_open(name.c_str(), O_RDWR | O_CREAT | O_TRUNC, 0666);
-    if (fd != -1) {
-      if (ftruncate(fd, size) == -1) {
+      if (fd != -1)
+      {
+        if (ftruncate(fd, size) == -1)
+        {
           close(fd);
           shm_unlink(name.c_str());
           return fail("Failed to truncate shared memory '{}'", name);
         }
       }
-  } else {
+    }
+    else
+    {
       fd = shm_open(name.c_str(), O_RDWR, 0666);
     }
 
-  if (fd == -1) {
-    return fail("Failed to {} shared memory '{}'",
-                is_owner ? "owner" : "consumer", name);
+    if (fd == -1)
+    {
+      return fail("Failed to {} shared memory '{}'", is_owner ? "owner" : "consumer", name);
     }
 
-  Mut<void *> addr =
-      mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
-  if (addr == MAP_FAILED) {
+    Mut<void *> addr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+    if (addr == MAP_FAILED)
+    {
       close(fd);
       return fail("Failed to mmap shared memory '{}'", name);
     }
 
     Mut<u8 *> result = static_cast<u8 *>(addr);
 
-  s_mapped_files[result] =
-      std::make_tuple((void *)((u64)fd), (void *)addr, (void *)size);
+    s_mapped_files[result] = std::make_tuple((void *) ((u64) fd), (void *) addr, (void *) size);
     return result;
 #endif
-}
+  }
 
-auto FileOps::unlink_shared_memory(Ref<String> name) -> void {
-  if (name.empty()) {
+  auto FileOps::unlink_shared_memory(Ref<String> name) -> void
+  {
+    if (name.empty())
+    {
       return;
     }
 #if IA_PLATFORM_UNIX
     shm_unlink(name.c_str());
 #endif
-}
+  }
 
-auto FileOps::map_file(Ref<Path> path, MutRef<usize> size)
-    -> Result<const u8 *> {
+  auto FileOps::map_file(Ref<Path> path, MutRef<usize> size) -> Result<const u8 *>
+  {
 #if IA_PLATFORM_WINDOWS
-  Const<HANDLE> handle = CreateFileA(
-      path.string().c_str(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,
+    const HANDLE handle = CreateFileA(path.string().c_str(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,
                                       FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, NULL);
 
-  if (handle == INVALID_HANDLE_VALUE) {
+    if (handle == INVALID_HANDLE_VALUE)
+    {
       return fail("Failed to open {} for memory mapping", path.string());
     }
 
     Mut<LARGE_INTEGER> file_size;
-  if (!GetFileSizeEx(handle, &file_size)) {
+    if (!GetFileSizeEx(handle, &file_size))
+    {
       CloseHandle(handle);
       return fail("Failed to get size of {} for memory mapping", path.string());
     }
     size = static_cast<usize>(file_size.QuadPart);
-  if (size == 0) {
+    if (size == 0)
+    {
       CloseHandle(handle);
       return fail("Failed to get size of {} for memory mapping", path.string());
     }
 
-  Mut<HANDLE> h_map =
-      CreateFileMappingW(handle, NULL, PAGE_READONLY, 0, 0, NULL);
-  if (h_map == NULL) {
+    Mut<HANDLE> h_map = CreateFileMappingW(handle, NULL, PAGE_READONLY, 0, 0, NULL);
+    if (h_map == NULL)
+    {
       CloseHandle(handle);
       return fail("Failed to memory map {}", path.string());
     }
 
-  Const<u8> *result =
-      static_cast<const u8 *>(MapViewOfFile(h_map, FILE_MAP_READ, 0, 0, 0));
-  if (result == NULL) {
+    const u8 *result = static_cast<const u8 *>(MapViewOfFile(h_map, FILE_MAP_READ, 0, 0, 0));
+    if (result == NULL)
+    {
       CloseHandle(handle);
       CloseHandle(h_map);
       return fail("Failed to memory map {}", path.string());
     }
-  s_mapped_files[result] = std::make_tuple(
-      (void *)handle, (void *)const_cast<u8 *>(result), (void *)h_map);
+    s_mapped_files[result] = std::make_tuple((void *) handle, (void *) const_cast<u8 *>(result), (void *) h_map);
     return result;
 
 #elif IA_PLATFORM_UNIX
-  Const<int> handle = open(path.string().c_str(), O_RDONLY);
-  if (handle == -1) {
+    const int handle = open(path.string().c_str(), O_RDONLY);
+    if (handle == -1)
+    {
       return fail("Failed to open {} for memory mapping", path.string());
     }
     Mut<struct stat> sb;
-  if (fstat(handle, &sb) == -1) {
+    if (fstat(handle, &sb) == -1)
+    {
       close(handle);
       return fail("Failed to get stats of {} for memory mapping", path.string());
     }
     size = static_cast<usize>(sb.st_size);
-  if (size == 0) {
+    if (size == 0)
+    {
       close(handle);
       return fail("Failed to get size of {} for memory mapping", path.string());
     }
     Mut<void *> addr = mmap(nullptr, size, PROT_READ, MAP_PRIVATE, handle, 0);
-  if (addr == MAP_FAILED) {
+    if (addr == MAP_FAILED)
+    {
       close(handle);
       return fail("Failed to memory map {}", path.string());
     }
-  Const<Const<u8> *> result = static_cast<const u8 *>(addr);
+    const u8 *result = static_cast<const u8 *>(addr);
     madvise(addr, size, MADV_SEQUENTIAL);
-  s_mapped_files[result] =
-      std::make_tuple((void *)((u64)handle), (void *)addr, (void *)size);
+    s_mapped_files[result] = std::make_tuple((void *) ((u64) handle), (void *) addr, (void *) size);
     return result;
 #endif
-}
+  }
 
-auto FileOps::stream_to_file(Ref<Path> path, Const<bool> overwrite)
-    -> Result<StreamWriter> {
-  if (!overwrite && std::filesystem::exists(path)) {
+  auto FileOps::stream_to_file(Ref<Path> path, const bool overwrite) -> Result<StreamWriter>
+  {
+    if (!overwrite && std::filesystem::exists(path))
+    {
       return fail("File already exists: {}", path.string());
     }
     return StreamWriter::create_from_file(path);
-}
+  }
 
-auto FileOps::stream_from_file(Ref<Path> path) -> Result<StreamReader> {
-  if (!std::filesystem::exists(path)) {
+  auto FileOps::stream_from_file(Ref<Path> path) -> Result<StreamReader>
+  {
+    if (!std::filesystem::exists(path))
+    {
       return fail("File does not exist: {}", path.string());
     }
     return StreamReader::create_from_file(path);
-}
+  }
 
-auto FileOps::read_text_file(Ref<Path> path) -> Result<String> {
+  auto FileOps::read_text_file(Ref<Path> path) -> Result<String>
+  {
     Mut<FILE *> f = fopen(path.string().c_str(), "r");
-  if (!f) {
+    if (!f)
+    {
       return fail("Failed to open file: {}", path.string());
     }
     Mut<String> result;
     fseek(f, 0, SEEK_END);
-  Const<long> len = ftell(f);
-  if (len > 0) {
+    const long len = ftell(f);
+    if (len > 0)
+    {
       result.resize(static_cast<usize>(len));
       fseek(f, 0, SEEK_SET);
-    fread(result.data(), 1, result.size(), f);
+      const usize read_length = fread(result.data(), 1, result.size(), f);
+      result.resize(read_length);
     }
     fclose(f);
     return result;
-}
+  }
 
-auto FileOps::read_binary_file(Ref<Path> path) -> Result<Vec<u8>> {
+  auto FileOps::read_binary_file(Ref<Path> path) -> Result<Vec<u8>>
+  {
     Mut<FILE *> f = fopen(path.string().c_str(), "rb");
-  if (!f) {
+    if (!f)
+    {
       return fail("Failed to open file: {}", path.string());
     }
     Mut<Vec<u8>> result;
     fseek(f, 0, SEEK_END);
-  Const<long> len = ftell(f);
-  if (len > 0) {
+    const long len = ftell(f);
+    if (len > 0)
+    {
       result.resize(static_cast<usize>(len));
       fseek(f, 0, SEEK_SET);
       fread(result.data(), 1, result.size(), f);
     }
     fclose(f);
     return result;
-}
+  }
 
-auto FileOps::write_text_file(Ref<Path> path, Ref<String> contents,
-                              Const<bool> overwrite) -> Result<usize> {
-  Const<Const<char> *> mode = overwrite ? "w" : "wx";
+  auto FileOps::write_text_file(Ref<Path> path, Ref<String> contents, const bool overwrite) -> Result<usize>
+  {
+    const char *mode = overwrite ? "w" : "wx";
     Mut<FILE *> f = fopen(path.string().c_str(), mode);
-  if (!f) {
-    if (!overwrite && errno == EEXIST) {
+    if (!f)
+    {
+      if (!overwrite && errno == EEXIST)
+      {
         return fail("File already exists: {}", path.string());
       }
       return fail("Failed to write to file: {}", path.string());
     }
-  Const<usize> result = fwrite(contents.data(), 1, contents.size(), f);
+    const usize result = fwrite(contents.data(), 1, contents.size(), f);
     fclose(f);
     return result;
-}
+  }
 
-auto FileOps::write_binary_file(Ref<Path> path, Const<Span<Const<u8>>> contents,
-                                Const<bool> overwrite) -> Result<usize> {
-  Const<Const<char> *> mode = overwrite ? "w" : "wx";
+  auto FileOps::write_binary_file(Ref<Path> path, const Span<const u8> contents, const bool overwrite) -> Result<usize>
+  {
+    const char *mode = overwrite ? "w" : "wx";
     Mut<FILE *> f = fopen(path.string().c_str(), mode);
-  if (!f) {
-    if (!overwrite && errno == EEXIST) {
+    if (!f)
+    {
+      if (!overwrite && errno == EEXIST)
+      {
         return fail("File already exists: {}", path.string());
       }
       return fail("Failed to write to file: {}", path.string());
     }
-  Const<usize> result = fwrite(contents.data(), 1, contents.size(), f);
+    const usize result = fwrite(contents.data(), 1, contents.size(), f);
     fclose(f);
     return result;
-}
+  }
 
-auto FileOps::normalize_executable_path(Ref<Path> path) -> Path {
+  auto FileOps::normalize_executable_path(Ref<Path> path) -> Path
+  {
     Mut<Path> result = path;
 
 #if IA_PLATFORM_WINDOWS
-  if (!result.has_extension()) {
+    if (!result.has_extension())
+    {
       result.replace_extension(".exe");
     }
 #elif IA_PLATFORM_UNIX
-  if (result.extension() == ".exe") {
+    if (result.extension() == ".exe")
+    {
       result.replace_extension("");
     }
 
-  if (result.is_relative()) {
+    if (result.is_relative())
+    {
       Mut<String> path_str = result.string();
-    if (!path_str.starts_with("./") && !path_str.starts_with("../")) {
+      if (!path_str.starts_with("./") && !path_str.starts_with("../"))
+      {
         result = "./" + path_str;
       }
     }
 #endif
     return result;
-}
+  }
 
-auto FileOps::native_open_file(Ref<Path> path, Const<FileAccess> access,
-                               Const<FileMode> mode, Const<u32> permissions)
-    -> Result<NativeFileHandle> {
+  auto FileOps::native_open_file(Ref<Path> path, const FileAccess access, const FileMode mode, const u32 permissions)
+      -> Result<NativeFileHandle>
+  {
 #if IA_PLATFORM_WINDOWS
+    AU_UNUSED(permissions);
+
     Mut<DWORD> dw_access = 0;
     Mut<DWORD> dw_share = FILE_SHARE_READ;
     Mut<DWORD> dw_disposition = 0;
     Mut<DWORD> dw_flags_and_attributes = FILE_ATTRIBUTE_NORMAL;
 
-  switch (access) {
+    switch (access)
+    {
     case FileAccess::Read:
       dw_access = GENERIC_READ;
       break;
@@ -322,7 +358,8 @@ auto FileOps::native_open_file(Ref<Path> path, Const<FileAccess> access,
       break;
     }
 
-  switch (mode) {
+    switch (mode)
+    {
     case FileMode::OpenExisting:
       dw_disposition = OPEN_EXISTING;
       break;
@@ -341,10 +378,10 @@ auto FileOps::native_open_file(Ref<Path> path, Const<FileAccess> access,
     }
 
     Mut<HANDLE> h_file =
-      CreateFileA(path.string().c_str(), dw_access, dw_share, NULL,
-                  dw_disposition, dw_flags_and_attributes, NULL);
+        CreateFileA(path.string().c_str(), dw_access, dw_share, NULL, dw_disposition, dw_flags_and_attributes, NULL);
 
-  if (h_file == INVALID_HANDLE_VALUE) {
+    if (h_file == INVALID_HANDLE_VALUE)
+    {
       return fail("Failed to open file '{}': {}", path.string(), GetLastError());
     }
 
@@ -353,7 +390,8 @@ auto FileOps::native_open_file(Ref<Path> path, Const<FileAccess> access,
 #elif IA_PLATFORM_UNIX
     Mut<int> flags = 0;
 
-  switch (access) {
+    switch (access)
+    {
     case FileAccess::Read:
       flags = O_RDONLY;
       break;
@@ -365,7 +403,8 @@ auto FileOps::native_open_file(Ref<Path> path, Const<FileAccess> access,
       break;
     }
 
-  switch (mode) {
+    switch (mode)
+    {
     case FileMode::OpenExisting:
       break;
     case FileMode::OpenAlways:
@@ -384,16 +423,19 @@ auto FileOps::native_open_file(Ref<Path> path, Const<FileAccess> access,
 
     Mut<int> fd = open(path.string().c_str(), flags, permissions);
 
-  if (fd == -1) {
+    if (fd == -1)
+    {
       return fail("Failed to open file '{}': {}", path.string(), errno);
     }
 
     return fd;
 #endif
-}
+  }
 
-auto FileOps::native_close_file(Const<NativeFileHandle> handle) -> void {
-  if (handle == INVALID_FILE_HANDLE) {
+  auto FileOps::native_close_file(const NativeFileHandle handle) -> void
+  {
+    if (handle == INVALID_FILE_HANDLE)
+    {
       return;
     }
 
@@ -402,19 +444,23 @@ auto FileOps::native_close_file(Const<NativeFileHandle> handle) -> void {
 #elif IA_PLATFORM_UNIX
     close(handle);
 #endif
-}
+  }
 
-FileOps::MemoryMappedRegion::~MemoryMappedRegion() { unmap(); }
+  FileOps::MemoryMappedRegion::~MemoryMappedRegion()
+  {
+    unmap();
+  }
 
-FileOps::MemoryMappedRegion::MemoryMappedRegion(
-    ForwardRef<MemoryMappedRegion> other) noexcept {
+  FileOps::MemoryMappedRegion::MemoryMappedRegion(ForwardRef<MemoryMappedRegion> other) noexcept
+  {
     *this = std::move(other);
-}
+  }
 
-auto FileOps::MemoryMappedRegion::operator=(
-    ForwardRef<MemoryMappedRegion> other) noexcept
-    -> MutRef<MemoryMappedRegion> {
-  if (this != &other) {
+  auto FileOps::MemoryMappedRegion::operator=(ForwardRef<MemoryMappedRegion> other) noexcept
+      -> MutRef<MemoryMappedRegion>
+  {
+    if (this != &other)
+    {
       unmap();
       m_ptr = other.m_ptr;
       m_size = other.m_size;
@@ -426,74 +472,83 @@ auto FileOps::MemoryMappedRegion::operator=(
       other.m_size = 0;
     }
     return *this;
-}
+  }
 
-auto FileOps::MemoryMappedRegion::map(Const<NativeFileHandle> handle,
-                                      Const<u64> offset, Const<usize> size)
-    -> Result<void> {
+  auto FileOps::MemoryMappedRegion::map(const NativeFileHandle handle, const u64 offset, const usize size)
+      -> Result<void>
+  {
     unmap();
 
-  if (handle == INVALID_FILE_HANDLE) {
+    if (handle == INVALID_FILE_HANDLE)
+    {
       return fail("Invalid file handle provided to Map");
     }
 
-  if (size == 0) {
+    if (size == 0)
+    {
       return fail("Cannot map region of size 0");
     }
 
 #if IA_PLATFORM_WINDOWS
     Mut<LARGE_INTEGER> file_size;
-  if (!GetFileSizeEx(handle, &file_size)) {
+    if (!GetFileSizeEx(handle, &file_size))
+    {
       return fail("Failed to get file size");
     }
 
-  Const<u64> end_offset = offset + size;
-  if (static_cast<u64>(file_size.QuadPart) < end_offset) {
+    const u64 end_offset = offset + size;
+    if (static_cast<u64>(file_size.QuadPart) < end_offset)
+    {
       Mut<LARGE_INTEGER> new_size;
       new_size.QuadPart = static_cast<LONGLONG>(end_offset);
-    if (!SetFilePointerEx(handle, new_size, NULL, FILE_BEGIN)) {
+      if (!SetFilePointerEx(handle, new_size, NULL, FILE_BEGIN))
+      {
         return fail("Failed to seek to new end of file");
       }
 
-    if (!SetEndOfFile(handle)) {
+      if (!SetEndOfFile(handle))
+      {
         return fail("Failed to extend file for mapping");
       }
     }
 
     m_map_handle = CreateFileMappingW(handle, NULL, PAGE_READWRITE, 0, 0, NULL);
-  if (m_map_handle == NULL) {
+    if (m_map_handle == NULL)
+    {
       return fail("CreateFileMapping failed: {}", GetLastError());
     }
 
-  Const<DWORD> offset_high = static_cast<DWORD>(offset >> 32);
-  Const<DWORD> offset_low = static_cast<DWORD>(offset & 0xFFFFFFFF);
+    const DWORD offset_high = static_cast<DWORD>(offset >> 32);
+    const DWORD offset_low = static_cast<DWORD>(offset & 0xFFFFFFFF);
 
-  m_ptr = static_cast<u8 *>(MapViewOfFile(m_map_handle, FILE_MAP_WRITE,
-                                          offset_high, offset_low, size));
-  if (m_ptr == NULL) {
+    m_ptr = static_cast<u8 *>(MapViewOfFile(m_map_handle, FILE_MAP_WRITE, offset_high, offset_low, size));
+    if (m_ptr == NULL)
+    {
       CloseHandle(m_map_handle);
       m_map_handle = NULL;
-    return fail("MapViewOfFile failed (Offset: {}, Size: {}): {}", offset, size,
-                GetLastError());
+      return fail("MapViewOfFile failed (Offset: {}, Size: {}): {}", offset, size, GetLastError());
     }
     m_size = size;
 
 #elif IA_PLATFORM_UNIX
     Mut<struct stat> sb;
-  if (fstat(handle, &sb) == -1) {
+    if (fstat(handle, &sb) == -1)
+    {
       return fail("Failed to fstat file");
     }
 
-  Const<u64> end_offset = offset + size;
-  if (static_cast<u64>(sb.st_size) < end_offset) {
-    if (ftruncate(handle, static_cast<off_t>(end_offset)) == -1) {
+    const u64 end_offset = offset + size;
+    if (static_cast<u64>(sb.st_size) < end_offset)
+    {
+      if (ftruncate(handle, static_cast<off_t>(end_offset)) == -1)
+      {
         return fail("Failed to ftruncate (extend) file");
       }
     }
 
-  Mut<void *> ptr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED,
-                         handle, static_cast<off_t>(offset));
-  if (ptr == MAP_FAILED) {
+    Mut<void *> ptr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, handle, static_cast<off_t>(offset));
+    if (ptr == MAP_FAILED)
+    {
       return fail("mmap failed: {}", errno);
     }
 
@@ -504,16 +559,19 @@ auto FileOps::MemoryMappedRegion::map(Const<NativeFileHandle> handle,
 #endif
 
     return {};
-}
+  }
 
-auto FileOps::MemoryMappedRegion::unmap() -> void {
-  if (!m_ptr) {
+  auto FileOps::MemoryMappedRegion::unmap() -> void
+  {
+    if (!m_ptr)
+    {
       return;
     }
 
 #if IA_PLATFORM_WINDOWS
     UnmapViewOfFile(m_ptr);
-  if (m_map_handle) {
+    if (m_map_handle)
+    {
       CloseHandle(m_map_handle);
       m_map_handle = NULL;
     }
@@ -522,10 +580,12 @@ auto FileOps::MemoryMappedRegion::unmap() -> void {
 #endif
     m_ptr = nullptr;
     m_size = 0;
-}
+  }
 
-auto FileOps::MemoryMappedRegion::flush() -> void {
-  if (!m_ptr) {
+  auto FileOps::MemoryMappedRegion::flush() -> void
+  {
+    if (!m_ptr)
+    {
       return;
     }
 
@@ -534,6 +594,6 @@ auto FileOps::MemoryMappedRegion::flush() -> void {
 #elif IA_PLATFORM_UNIX
     msync(m_ptr, m_size, MS_SYNC);
 #endif
-}
+  }
 
 } // namespace IACore

Src/IACore/imp/cpp/Http/Client.cpp

@@ -16,69 +16,77 @@
 #include <IACore/DataOps.hpp>
 #include <IACore/Http/Client.hpp>
 
-namespace IACore {
-auto HttpClient::create(Ref<String> host) -> Result<Box<HttpClient>> {
+namespace IACore
+{
+  auto HttpClient::create(Ref<String> host) -> Result<Box<HttpClient>>
+  {
     return make_box_protected<HttpClient>(httplib::Client(host));
-}
+  }
 
-static auto build_headers(Span<Const<HttpClient::Header>> headers,
-                          Const<Const<char> *> default_content_type)
-    -> httplib::Headers {
+  static auto build_headers(Span<const HttpClient::Header> headers, const char *default_content_type)
+      -> httplib::Headers
+  {
     Mut<httplib::Headers> out;
     Mut<bool> has_content_type = false;
 
-  for (Ref<HttpClient::Header> h : headers) {
+    for (Ref<HttpClient::Header> h : headers)
+    {
       out.emplace(h.first, h.second);
 
-    if (h.first == HttpClient::header_type_to_string(
-                       HttpClient::EHeaderType::CONTENT_TYPE)) {
+      if (h.first == HttpClient::header_type_to_string(HttpClient::EHeaderType::CONTENT_TYPE))
+      {
         has_content_type = true;
       }
     }
 
-  if (!has_content_type && default_content_type) {
+    if (!has_content_type && default_content_type)
+    {
       out.emplace("Content-Type", default_content_type);
     }
     return out;
-}
+  }
 
-HttpClient::HttpClient(ForwardRef<httplib::Client> client)
-    : m_client(std::move(client)),
-      m_last_response_code(EResponseCode::INTERNAL_SERVER_ERROR) {
+  HttpClient::HttpClient(ForwardRef<httplib::Client> client)
+      : m_client(std::move(client)), m_last_response_code(EResponseCode::INTERNAL_SERVER_ERROR)
+  {
     m_client.enable_server_certificate_verification(true);
-}
+  }
 
-HttpClient::~HttpClient() = default;
+  HttpClient::~HttpClient() = default;
 
-auto HttpClient::enable_certificate_verification() -> void {
+  auto HttpClient::enable_certificate_verification() -> void
+  {
     m_client.enable_server_certificate_verification(true);
-}
+  }
 
-auto HttpClient::disable_certificate_verification() -> void {
+  auto HttpClient::disable_certificate_verification() -> void
+  {
     m_client.enable_server_certificate_verification(false);
-}
+  }
 
-auto HttpClient::preprocess_response(Ref<String> response) -> String {
-  Const<Span<Const<u8>>> response_bytes = {
-      reinterpret_cast<Const<u8> *>(response.data()), response.size()};
-  Const<DataOps::CompressionType> compression =
-      DataOps::detect_compression(response_bytes);
+  auto HttpClient::preprocess_response(Ref<String> response) -> String
+  {
+    const Span<const u8> response_bytes = {reinterpret_cast<const u8 *>(response.data()), response.size()};
+    const DataOps::CompressionType compression = DataOps::detect_compression(response_bytes);
 
-  switch (compression) {
+    switch (compression)
+    {
     case DataOps::CompressionType::Gzip: {
-    Const<Result<Vec<u8>>> data = DataOps::gzip_inflate(response_bytes);
-    if (!data) {
+      const Result<Vec<u8>> data = DataOps::gzip_inflate(response_bytes);
+      if (!data)
+      {
         return response;
       }
-    return String(reinterpret_cast<Const<char> *>(data->data()), data->size());
+      return String(reinterpret_cast<const char *>(data->data()), data->size());
     }
 
     case DataOps::CompressionType::Zlib: {
-    Const<Result<Vec<u8>>> data = DataOps::zlib_inflate(response_bytes);
-    if (!data) {
+      const Result<Vec<u8>> data = DataOps::zlib_inflate(response_bytes);
+      if (!data)
+      {
         return response;
       }
-    return String(reinterpret_cast<Const<char> *>(data->data()), data->size());
+      return String(reinterpret_cast<const char *>(data->data()), data->size());
     }
 
     case DataOps::CompressionType::None:
@@ -86,43 +94,43 @@ auto HttpClient::preprocess_response(Ref<String> response) -> String {
       break;
     }
     return response;
-}
+  }
 
-auto HttpClient::raw_get(Ref<String> path, Span<Const<Header>> headers,
-                         Const<Const<char> *> default_content_type)
-    -> Result<String> {
-  Const<httplib::Headers> http_headers =
-      build_headers(headers, default_content_type);
+  auto HttpClient::raw_get(Ref<String> path, Span<const Header> headers, const char *default_content_type)
+      -> Result<String>
+  {
+    const httplib::Headers http_headers = build_headers(headers, default_content_type);
 
     Mut<String> adjusted_path = path;
-  if (!path.empty() && path[0] != '/') {
+    if (!path.empty() && path[0] != '/')
+    {
       adjusted_path = "/" + path;
     }
 
-  Const<httplib::Result> res =
-      m_client.Get(adjusted_path.c_str(), http_headers);
+    const httplib::Result res = m_client.Get(adjusted_path.c_str(), http_headers);
 
-  if (res) {
+    if (res)
+    {
       m_last_response_code = static_cast<EResponseCode>(res->status);
-    if (res->status >= 200 && res->status < 300) {
+      if (res->status >= 200 && res->status < 300)
+      {
         return preprocess_response(res->body);
       }
       return fail("HTTP Error {} : {}", res->status, res->body);
     }
 
     return fail("Network Error: {}", httplib::to_string(res.error()));
-}
+  }
 
-auto HttpClient::raw_post(Ref<String> path, Span<Const<Header>> headers,
-                          Ref<String> body,
-                          Const<Const<char> *> default_content_type)
-    -> Result<String> {
-  Mut<httplib::Headers> http_headers =
-      build_headers(headers, default_content_type);
+  auto HttpClient::raw_post(Ref<String> path, Span<const Header> headers, Ref<String> body,
+                            const char *default_content_type) -> Result<String>
+  {
+    Mut<httplib::Headers> http_headers = build_headers(headers, default_content_type);
 
     Mut<String> content_type = default_content_type;
-  if (http_headers.count("Content-Type")) {
-    Const<httplib::Headers::iterator> t = http_headers.find("Content-Type");
+    if (http_headers.count("Content-Type"))
+    {
+      const httplib::Headers::iterator t = http_headers.find("Content-Type");
       content_type = t->second;
       http_headers.erase(t);
     }
@@ -130,21 +138,23 @@ auto HttpClient::raw_post(Ref<String> path, Span<Const<Header>> headers,
     m_client.set_keep_alive(true);
 
     Mut<String> adjusted_path = path;
-  if (!path.empty() && path[0] != '/') {
+    if (!path.empty() && path[0] != '/')
+    {
       adjusted_path = "/" + path;
     }
 
-  Const<httplib::Result> res = m_client.Post(
-      adjusted_path.c_str(), http_headers, body, content_type.c_str());
+    const httplib::Result res = m_client.Post(adjusted_path.c_str(), http_headers, body, content_type.c_str());
 
-  if (res) {
+    if (res)
+    {
       m_last_response_code = static_cast<EResponseCode>(res->status);
-    if (res->status >= 200 && res->status < 300) {
+      if (res->status >= 200 && res->status < 300)
+      {
         return preprocess_response(res->body);
       }
       return fail("HTTP Error {} : {}", res->status, res->body);
     }
 
     return fail("Network Error: {}", httplib::to_string(res.error()));
-}
+  }
 } // namespace IACore

Src/IACore/imp/cpp/Http/Common.cpp

@@ -15,46 +15,52 @@
 
 #include <IACore/Http/Common.hpp>
 
-namespace IACore {
-auto HttpCommon::url_encode(Ref<String> value) -> String {
+namespace IACore
+{
+  auto HttpCommon::url_encode(Ref<String> value) -> String
+  {
     Mut<std::stringstream> escaped;
     escaped.fill('0');
     escaped << std::hex << std::uppercase;
 
-  for (Const<char> c : value) {
-    if (std::isalnum(static_cast<unsigned char>(c)) || c == '-' || c == '_' ||
-        c == '.' || c == '~')
+    for (const char c : value)
+    {
+      if (std::isalnum(static_cast<unsigned char>(c)) || c == '-' || c == '_' || c == '.' || c == '~')
         escaped << c;
       else
-      escaped << '%' << std::setw(2)
-              << static_cast<int>(static_cast<unsigned char>(c));
+        escaped << '%' << std::setw(2) << static_cast<int>(static_cast<unsigned char>(c));
     }
 
     return escaped.str();
-}
+  }
 
-auto HttpCommon::url_decode(Ref<String> value) -> String {
+  auto HttpCommon::url_decode(Ref<String> value) -> String
+  {
     Mut<String> result;
     result.reserve(value.length());
 
-  for (Mut<size_t> i = 0; i < value.length(); ++i) {
-    if (value[i] == '%' && i + 2 < value.length()) {
-      Const<std::string> hex_str = value.substr(i + 1, 2);
-      Const<char> decoded_char =
-          static_cast<char>(std::strtol(hex_str.c_str(), nullptr, 16));
+    for (Mut<size_t> i = 0; i < value.length(); ++i)
+    {
+      if (value[i] == '%' && i + 2 < value.length())
+      {
+        const std::string hex_str = value.substr(i + 1, 2);
+        const char decoded_char = static_cast<char>(std::strtol(hex_str.c_str(), nullptr, 16));
         result += decoded_char;
         i += 2;
-    } else if (value[i] == '+')
+      }
+      else if (value[i] == '+')
         result += ' ';
       else
         result += value[i];
     }
 
     return result;
-}
+  }
 
-auto HttpCommon::header_type_to_string(Const<EHeaderType> type) -> String {
-  switch (type) {
+  auto HttpCommon::header_type_to_string(const EHeaderType type) -> String
+  {
+    switch (type)
+    {
     case EHeaderType::ACCEPT:
       return "Accept";
     case EHeaderType::ACCEPT_CHARSET:
@@ -109,9 +115,10 @@ auto HttpCommon::header_type_to_string(Const<EHeaderType> type) -> String {
       return "Warning";
     }
     return "<Unknown>";
-}
+  }
 
-auto HttpCommon::is_success_response_code(Const<EResponseCode> code) -> bool {
-  return (i32)code >= 200 && (i32)code < 300;
-}
+  auto HttpCommon::is_success_response_code(const EResponseCode code) -> bool
+  {
+    return (i32) code >= 200 && (i32) code < 300;
+  }
 } // namespace IACore

Src/IACore/imp/cpp/Http/Server.cpp

@@ -15,102 +15,126 @@
 
 #include <IACore/Http/Server.hpp>
 
-namespace IACore {
+namespace IACore
+{
 
-auto HttpServer::Request::get_header(Ref<String> key) const -> String {
-  if (Const<HashMap<String, String>::const_iterator> it = headers.find(key);
-      it != headers.end()) {
+  auto HttpServer::Request::get_header(Ref<String> key) const -> String
+  {
+    if (auto it = headers.find(key); it != headers.end())
+    {
       return it->second;
     }
     return "";
-}
+  }
 
-auto HttpServer::Request::get_param(Ref<String> key) const -> String {
-  if (Const<HashMap<String, String>::const_iterator> it = params.find(key);
-      it != params.end()) {
+  auto HttpServer::Request::get_param(Ref<String> key) const -> String
+  {
+    if (auto it = params.find(key); it != params.end())
+    {
       return it->second;
     }
     return "";
-}
+  }
 
-auto HttpServer::Request::get_path_param(Ref<String> key) const -> String {
-  if (Const<HashMap<String, String>::const_iterator> it = path_params.find(key);
-      it != path_params.end()) {
+  auto HttpServer::Request::get_path_param(Ref<String> key) const -> String
+  {
+    if (auto it = path_params.find(key); it != path_params.end())
+    {
       return it->second;
     }
     return "";
-}
+  }
 
-auto HttpServer::Request::has_header(Ref<String> key) const -> bool {
+  auto HttpServer::Request::has_header(Ref<String> key) const -> bool
+  {
     return headers.contains(key);
-}
+  }
 
-auto HttpServer::Request::has_param(Ref<String> key) const -> bool {
+  auto HttpServer::Request::has_param(Ref<String> key) const -> bool
+  {
     return params.contains(key);
-}
+  }
 
-auto HttpServer::Request::has_path_param(Ref<String> key) const -> bool {
+  auto HttpServer::Request::has_path_param(Ref<String> key) const -> bool
+  {
     return path_params.contains(key);
-}
+  }
 
-void HttpServer::Response::set_content(Ref<String> content, Ref<String> type) {
+  void HttpServer::Response::set_content(Ref<String> content, Ref<String> type)
+  {
     body = content;
     content_type = type;
-}
+  }
 
-void HttpServer::Response::set_status(Const<EResponseCode> status_code) {
+  void HttpServer::Response::set_status(const EResponseCode status_code)
+  {
     code = status_code;
-}
+  }
 
-void HttpServer::Response::add_header(Ref<String> key, Ref<String> value) {
+  void HttpServer::Response::add_header(Ref<String> key, Ref<String> value)
+  {
     headers[key] = value;
-}
+  }
 
-struct PublicHttpServer : public HttpServer {
+  struct PublicHttpServer : public HttpServer
+  {
     PublicHttpServer() = default;
-};
+  };
 
-HttpServer::HttpServer() = default;
+  HttpServer::HttpServer() = default;
 
-HttpServer::~HttpServer() { stop(); }
+  HttpServer::~HttpServer()
+  {
+    stop();
+  }
 
-auto HttpServer::create() -> Result<Box<HttpServer>> {
+  auto HttpServer::create() -> Result<Box<HttpServer>>
+  {
     return make_box<PublicHttpServer>();
-}
+  }
 
-auto HttpServer::listen(Ref<String> host, Const<u32> port) -> Result<void> {
-  if (!m_server.listen(host.c_str(), static_cast<int>(port))) {
+  auto HttpServer::listen(Ref<String> host, const u32 port) -> Result<void>
+  {
+    if (!m_server.listen(host.c_str(), static_cast<int>(port)))
+    {
       return fail("Failed to start HTTP server on {}:{}", host, port);
     }
     return {};
-}
+  }
 
-void HttpServer::stop() {
-  if (m_server.is_running()) {
+  void HttpServer::stop()
+  {
+    if (m_server.is_running())
+    {
       m_server.stop();
     }
-}
+  }
 
-auto HttpServer::is_running() const -> bool { return m_server.is_running(); }
+  auto HttpServer::is_running() const -> bool
+  {
+    return m_server.is_running();
+  }
 
-void HttpServer::register_handler(Ref<String> method, Ref<String> pattern,
-                                  Const<Handler> handler) {
-  Const<httplib::Server::Handler> wrapper =
-      [handler](Ref<httplib::Request> req, MutRef<httplib::Response> res) {
+  void HttpServer::register_handler(Ref<String> method, Ref<String> pattern, const Handler handler)
+  {
+    const httplib::Server::Handler wrapper = [handler](Ref<httplib::Request> req, MutRef<httplib::Response> res) {
       Mut<Request> ia_req;
       ia_req.path = req.path;
       ia_req.method = req.method;
       ia_req.body = req.body;
 
-        for (Ref<Pair<const String, String>> item : req.headers) {
+      for (Ref<Pair<const String, String>> item : req.headers)
+      {
         ia_req.headers[item.first] = item.second;
       }
 
-        for (Ref<Pair<const String, String>> item : req.params) {
+      for (Ref<Pair<const String, String>> item : req.params)
+      {
         ia_req.params[item.first] = item.second;
       }
 
-        for (Ref<Pair<const String, String>> item : req.path_params) {
+      for (Ref<Pair<const String, String>> item : req.path_params)
+      {
         ia_req.path_params[item.first] = item.second;
       }
 
@@ -120,42 +144,57 @@ void HttpServer::register_handler(Ref<String> method, Ref<String> pattern,
       res.status = static_cast<int>(ia_res.code);
       res.set_content(ia_res.body, ia_res.content_type.c_str());
 
-        for (Ref<Pair<String, String>> item : ia_res.headers) {
+      for (Ref<Pair<String, String>> item : ia_res.headers)
+      {
         res.set_header(item.first.c_str(), item.second.c_str());
       }
     };
 
-  if (method == "GET") {
+    if (method == "GET")
+    {
       m_server.Get(pattern.c_str(), wrapper);
-  } else if (method == "POST") {
+    }
+    else if (method == "POST")
+    {
       m_server.Post(pattern.c_str(), wrapper);
-  } else if (method == "PUT") {
+    }
+    else if (method == "PUT")
+    {
       m_server.Put(pattern.c_str(), wrapper);
-  } else if (method == "DELETE") {
+    }
+    else if (method == "DELETE")
+    {
       m_server.Delete(pattern.c_str(), wrapper);
-  } else if (method == "OPTIONS") {
+    }
+    else if (method == "OPTIONS")
+    {
       m_server.Options(pattern.c_str(), wrapper);
     }
-}
+  }
 
-void HttpServer::get(Ref<String> pattern, Const<Handler> handler) {
+  void HttpServer::get(Ref<String> pattern, const Handler handler)
+  {
     register_handler("GET", pattern, handler);
-}
+  }
 
-void HttpServer::post(Ref<String> pattern, Const<Handler> handler) {
+  void HttpServer::post(Ref<String> pattern, const Handler handler)
+  {
     register_handler("POST", pattern, handler);
-}
+  }
 
-void HttpServer::put(Ref<String> pattern, Const<Handler> handler) {
+  void HttpServer::put(Ref<String> pattern, const Handler handler)
+  {
     register_handler("PUT", pattern, handler);
-}
+  }
 
-void HttpServer::del(Ref<String> pattern, Const<Handler> handler) {
+  void HttpServer::del(Ref<String> pattern, const Handler handler)
+  {
     register_handler("DELETE", pattern, handler);
-}
+  }
 
-void HttpServer::options(Ref<String> pattern, Const<Handler> handler) {
+  void HttpServer::options(Ref<String> pattern, const Handler handler)
+  {
     register_handler("OPTIONS", pattern, handler);
-}
+  }
 
 } // namespace IACore

Src/IACore/imp/cpp/IACore.cpp

@@ -19,15 +19,18 @@
 #include <chrono>
 #include <mimalloc.h>
 
-namespace IACore {
-Mut<std::chrono::high_resolution_clock::time_point> g_start_time = {};
+namespace IACore
+{
+  Mut<std::chrono::high_resolution_clock::time_point> g_start_time = {};
 
-static Mut<std::thread::id> g_main_thread_id = {};
-static Mut<i32> g_core_init_count = 0;
+  static Mut<std::thread::id> g_main_thread_id = {};
+  static Mut<i32> g_core_init_count = 0;
 
-auto initialize() -> void {
+  auto initialize() -> void
+  {
     g_core_init_count++;
-  if (g_core_init_count > 1) {
+    if (g_core_init_count > 1)
+    {
       return;
     }
 
@@ -37,20 +40,26 @@ auto initialize() -> void {
     Logger::initialize();
 
     mi_option_set(mi_option_verbose, 0);
-}
+  }
 
-auto terminate() -> void {
+  auto terminate() -> void
+  {
     g_core_init_count--;
-  if (g_core_init_count > 0) {
+    if (g_core_init_count > 0)
+    {
       return;
     }
 
     Logger::terminate();
-}
+  }
 
-auto is_initialized() -> bool { return g_core_init_count > 0; }
+  auto is_initialized() -> bool
+  {
+    return g_core_init_count > 0;
+  }
 
-auto is_main_thread() -> bool {
+  auto is_main_thread() -> bool
+  {
     return std::this_thread::get_id() == g_main_thread_id;
-}
+  }
 } // namespace IACore

Src/IACore/imp/cpp/IPC.cpp

@@ -20,31 +20,41 @@
 #include <charconv>
 #include <fcntl.h>
 
-namespace IACore {
-struct IpcConnectionDescriptor {
+namespace IACore
+{
+  struct IpcConnectionDescriptor
+  {
     Mut<String> socket_path;
     Mut<String> shared_mem_path;
     Mut<u32> shared_mem_size;
 
-  [[nodiscard]] auto serialize() const -> String {
-    return std::format("{}|{}|{}|", socket_path, shared_mem_path,
-                       shared_mem_size);
+    [[nodiscard]] auto serialize() const -> String
+    {
+      return std::format("{}|{}|{}|", socket_path, shared_mem_path, shared_mem_size);
     }
 
-  static auto deserialize(Const<StringView> data)
-      -> Option<IpcConnectionDescriptor> {
-    enum class ParseState { SocketPath, SharedMemPath, SharedMemSize };
+    static auto deserialize(const StringView data) -> Option<IpcConnectionDescriptor>
+    {
+      enum class ParseState
+      {
+        SocketPath,
+        SharedMemPath,
+        SharedMemSize
+      };
 
       Mut<IpcConnectionDescriptor> result{};
       Mut<usize> t = 0;
       Mut<ParseState> state = ParseState::SocketPath;
 
-    for (Mut<usize> i = 0; i < data.size(); ++i) {
-      if (data[i] != '|') {
+      for (Mut<usize> i = 0; i < data.size(); ++i)
+      {
+        if (data[i] != '|')
+        {
           continue;
         }
 
-      switch (state) {
+        switch (state)
+        {
         case ParseState::SocketPath:
           result.socket_path = String(data.substr(t, i - t));
           state = ParseState::SharedMemPath;
@@ -56,10 +66,10 @@ struct IpcConnectionDescriptor {
           break;
 
         case ParseState::SharedMemSize: {
-        Const<const char *> start = data.data() + t;
-        Const<const char *> end = data.data() + i;
-        if (std::from_chars(start, end, result.shared_mem_size).ec !=
-            std::errc{}) {
+          const char *start = data.data() + t;
+          const char *end = data.data() + i;
+          if (std::from_chars(start, end, result.shared_mem_size).ec != std::errc{})
+          {
             return std::nullopt;
           }
           return result;
@@ -69,51 +79,51 @@ struct IpcConnectionDescriptor {
       }
       return std::nullopt;
     }
-};
+  };
 
-IpcNode::~IpcNode() {
-  if (m_socket != INVALID_SOCKET) {
+  IpcNode::~IpcNode()
+  {
+    if (m_socket != INVALID_SOCKET)
+    {
       SocketOps::close(m_socket);
     }
-}
+  }
 
-auto IpcNode::connect(Const<const char *> connection_string) -> Result<void> {
-  Const<Option<IpcConnectionDescriptor>> desc_opt =
-      IpcConnectionDescriptor::deserialize(connection_string);
-  if (!desc_opt) {
+  auto IpcNode::connect(const char *connection_string) -> Result<void>
+  {
+    const Option<IpcConnectionDescriptor> desc_opt = IpcConnectionDescriptor::deserialize(connection_string);
+    if (!desc_opt)
+    {
       return fail("Failed to parse connection string");
     }
     Ref<IpcConnectionDescriptor> desc = *desc_opt;
     m_shm_name = desc.shared_mem_path;
 
     m_socket = AU_TRY(SocketOps::create_unix_socket());
-  AU_TRY_PURE(
-      SocketOps::connect_unix_socket(m_socket, desc.socket_path.c_str()));
+    AU_TRY_PURE(SocketOps::connect_unix_socket(m_socket, desc.socket_path.c_str()));
 
-  Mut<u8 *> mapped_ptr = AU_TRY(FileOps::map_shared_memory(
-      desc.shared_mem_path, desc.shared_mem_size, false));
+    Mut<u8 *> mapped_ptr = AU_TRY(FileOps::map_shared_memory(desc.shared_mem_path, desc.shared_mem_size, false));
     m_shared_memory = mapped_ptr;
 
-  Mut<IpcSharedMemoryLayout *> layout =
-      reinterpret_cast<IpcSharedMemoryLayout *>(m_shared_memory);
+    Mut<IpcSharedMemoryLayout *> layout = reinterpret_cast<IpcSharedMemoryLayout *>(m_shared_memory);
 
-  if (layout->meta.magic != 0x49414950) {
+    if (layout->meta.magic != 0x49414950)
+    {
       return fail("Invalid shared memory header signature");
     }
 
-  if (layout->meta.version != 1) {
+    if (layout->meta.version != 1)
+    {
       return fail("IPC version mismatch");
     }
 
     Mut<u8 *> moni_ptr = m_shared_memory + layout->moni_data_offset;
     Mut<u8 *> mino_ptr = m_shared_memory + layout->mino_data_offset;
 
-  m_moni = AU_TRY(RingBufferView::create(
-      &layout->moni_control,
+    m_moni = AU_TRY(RingBufferView::create(&layout->moni_control,
                                            Span<u8>(moni_ptr, static_cast<usize>(layout->moni_data_size)), false));
 
-  m_mino = AU_TRY(RingBufferView::create(
-      &layout->mino_control,
+    m_mino = AU_TRY(RingBufferView::create(&layout->mino_control,
                                            Span<u8>(mino_ptr, static_cast<usize>(layout->mino_data_size)), false));
 
 #if IA_PLATFORM_WINDOWS
@@ -126,70 +136,79 @@ auto IpcNode::connect(Const<const char *> connection_string) -> Result<void> {
     m_receive_buffer.resize(UINT16_MAX + 1);
 
     return {};
-}
+  }
 
-void IpcNode::update() {
-  if (!m_moni.is_valid()) {
+  void IpcNode::update()
+  {
+    if (!m_moni.is_valid())
+    {
       return;
     }
 
     Mut<IpcPacketHeader> header;
 
-  while (m_moni.pop(
-      header, Span<u8>(m_receive_buffer.data(), m_receive_buffer.size()))) {
+    while (m_moni.pop(header, Span<u8>(m_receive_buffer.data(), m_receive_buffer.size())))
+    {
       on_packet(header.id, {m_receive_buffer.data(), header.payload_size});
     }
 
     Mut<u8> signal = 0;
-  Const<isize> res = recv(m_socket, reinterpret_cast<char *>(&signal), 1, 0);
-  if (res == 1) {
+    const isize res = recv(m_socket, reinterpret_cast<char *>(&signal), 1, 0);
+    if (res == 1)
+    {
       on_signal(signal);
-  } else if (res == 0 || (res < 0 && !SocketOps::is_would_block())) {
+    }
+    else if (res == 0 || (res < 0 && !SocketOps::is_would_block()))
+    {
       SocketOps::close(m_socket);
       FileOps::unlink_shared_memory(m_shm_name);
 
       std::exit(-1);
     }
-}
+  }
 
-void IpcNode::send_signal(Const<u8> signal) {
-  if (m_socket != INVALID_SOCKET) {
+  void IpcNode::send_signal(const u8 signal)
+  {
+    if (m_socket != INVALID_SOCKET)
+    {
       send(m_socket, reinterpret_cast<const char *>(&signal), sizeof(signal), 0);
     }
-}
+  }
 
-auto IpcNode::send_packet(Const<u16> packet_id, Const<Span<Const<u8>>> payload)
-    -> Result<void> {
+  auto IpcNode::send_packet(const u16 packet_id, const Span<const u8> payload) -> Result<void>
+  {
     if (!m_mino.is_valid())
       return fail("invalid MINO");
     return m_mino.push(packet_id, payload);
-}
-
-void IpcManager::NodeSession::send_signal(Const<u8> signal) {
-  if (data_socket != INVALID_SOCKET) {
-    send(data_socket, reinterpret_cast<const char *>(&signal), sizeof(signal),
-         0);
   }
-}
 
-auto IpcManager::NodeSession::send_packet(Const<u16> packet_id,
-                                          Const<Span<Const<u8>>> payload)
-    -> Result<void> {
-  Const<std::scoped_lock<std::mutex>> lock(send_mutex);
+  void IpcManager::NodeSession::send_signal(const u8 signal)
+  {
+    if (data_socket != INVALID_SOCKET)
+    {
+      send(data_socket, reinterpret_cast<const char *>(&signal), sizeof(signal), 0);
+    }
+  }
+
+  auto IpcManager::NodeSession::send_packet(const u16 packet_id, const Span<const u8> payload) -> Result<void>
+  {
+    const std::scoped_lock<std::mutex> lock(send_mutex);
     if (!moni.is_valid())
       return fail("invalid MONI");
     return moni.push(packet_id, payload);
-}
+  }
 
-IpcManager::IpcManager() {
-  ensure(SocketOps::is_initialized(),
-         "SocketOps must be initialized before using IpcManager");
+  IpcManager::IpcManager()
+  {
+    ensure(SocketOps::is_initialized(), "SocketOps must be initialized before using IpcManager");
 
     m_receive_buffer.resize(UINT16_MAX + 1);
-}
+  }
 
-IpcManager::~IpcManager() {
-  for (MutRef<Box<NodeSession>> session : m_active_sessions) {
+  IpcManager::~IpcManager()
+  {
+    for (MutRef<Box<NodeSession>> session : m_active_sessions)
+    {
       ProcessOps::terminate_process(session->node_process);
       FileOps::unmap_file(session->mapped_ptr);
       FileOps::unlink_shared_memory(session->shared_mem_name);
@@ -197,25 +216,26 @@ IpcManager::~IpcManager() {
     }
     m_active_sessions.clear();
 
-  for (MutRef<Box<NodeSession>> session : m_pending_sessions) {
+    for (MutRef<Box<NodeSession>> session : m_pending_sessions)
+    {
       ProcessOps::terminate_process(session->node_process);
       FileOps::unmap_file(session->mapped_ptr);
       FileOps::unlink_shared_memory(session->shared_mem_name);
       SocketOps::close(session->listener_socket);
     }
     m_pending_sessions.clear();
-}
+  }
 
-void IpcManager::update() {
-  Const<std::chrono::system_clock::time_point> now =
-      std::chrono::system_clock::now();
+  void IpcManager::update()
+  {
+    const std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
 
-  for (Mut<isize> i = static_cast<isize>(m_pending_sessions.size()) - 1; i >= 0;
-       --i) {
-    MutRef<Box<NodeSession>> session =
-        m_pending_sessions[static_cast<usize>(i)];
+    for (Mut<isize> i = static_cast<isize>(m_pending_sessions.size()) - 1; i >= 0; --i)
+    {
+      MutRef<Box<NodeSession>> session = m_pending_sessions[static_cast<usize>(i)];
 
-    if (now - session->creation_time > std::chrono::seconds(5)) {
+      if (now - session->creation_time > std::chrono::seconds(5))
+      {
         ProcessOps::terminate_process(session->node_process);
 
         FileOps::unmap_file(session->mapped_ptr);
@@ -232,7 +252,8 @@ void IpcManager::update() {
       Mut<i32> new_sock = accept(session->listener_socket, nullptr, nullptr);
 #endif
 
-    if (new_sock != INVALID_SOCKET) {
+      if (new_sock != INVALID_SOCKET)
+      {
         session->data_socket = new_sock;
         session->is_ready = true;
 
@@ -246,7 +267,7 @@ void IpcManager::update() {
         SocketOps::close(session->listener_socket);
         session->listener_socket = INVALID_SOCKET;
 
-      Const<NativeProcessID> session_id = session->node_process->id.load();
+        const NativeProcessID session_id = session->node_process->id.load();
         Mut<NodeSession *> session_ptr = session.get();
         m_active_sessions.push_back(std::move(session));
         m_pending_sessions.erase(m_pending_sessions.begin() + i);
@@ -254,27 +275,28 @@ void IpcManager::update() {
       }
     }
 
-  for (Mut<isize> i = static_cast<isize>(m_active_sessions.size()) - 1; i >= 0;
-       --i) {
+    for (Mut<isize> i = static_cast<isize>(m_active_sessions.size()) - 1; i >= 0; --i)
+    {
       MutRef<Box<NodeSession>> node = m_active_sessions[static_cast<usize>(i)];
 
       Mut<NativeProcessID> node_id = node->node_process->id.load();
 
       Mut<IpcPacketHeader> header;
 
-    while (node->mino.pop(
-        header, Span<u8>(m_receive_buffer.data(), m_receive_buffer.size()))) {
-      on_packet(node_id, header.id,
-                {m_receive_buffer.data(), header.payload_size});
+      while (node->mino.pop(header, Span<u8>(m_receive_buffer.data(), m_receive_buffer.size())))
+      {
+        on_packet(node_id, header.id, {m_receive_buffer.data(), header.payload_size});
       }
 
       Mut<u8> signal = 0;
-    Const<isize> res =
-        recv(node->data_socket, reinterpret_cast<char *>(&signal), 1, 0);
+      const isize res = recv(node->data_socket, reinterpret_cast<char *>(&signal), 1, 0);
 
-    if (res == 1) {
+      if (res == 1)
+      {
         on_signal(node_id, signal);
-    } else if (res == 0 || (res < 0 && !SocketOps::is_would_block())) {
+      }
+      else if (res == 0 || (res < 0 && !SocketOps::is_would_block()))
+      {
         ProcessOps::terminate_process(node->node_process);
 
         FileOps::unmap_file(node->mapped_ptr);
@@ -285,15 +307,14 @@ void IpcManager::update() {
         m_active_session_map.erase(node_id);
       }
     }
-}
+  }
 
-auto IpcManager::spawn_node(Ref<Path> executable_path,
-                            Const<u32> shared_memory_size)
-    -> Result<NativeProcessID> {
+  auto IpcManager::spawn_node(Ref<Path> executable_path, const u32 shared_memory_size) -> Result<NativeProcessID>
+  {
     Mut<Box<NodeSession>> session = make_box<NodeSession>();
 
     static Mut<std::atomic<u32>> s_id_gen{0};
-  Const<u32> sid = ++s_id_gen;
+    const u32 sid = ++s_id_gen;
 
     Mut<String> sock_path;
 #if IA_PLATFORM_WINDOWS
@@ -305,8 +326,7 @@ auto IpcManager::spawn_node(Ref<Path> executable_path,
 #endif
 
     session->listener_socket = AU_TRY(SocketOps::create_unix_socket());
-  AU_TRY_PURE(
-      SocketOps::bind_unix_socket(session->listener_socket, sock_path.c_str()));
+    AU_TRY_PURE(SocketOps::bind_unix_socket(session->listener_socket, sock_path.c_str()));
     AU_TRY_PURE(SocketOps::listen(session->listener_socket, 1));
 
 #if IA_PLATFORM_WINDOWS
@@ -316,19 +336,17 @@ auto IpcManager::spawn_node(Ref<Path> executable_path,
     fcntl(session->listener_socket, F_SETFL, O_NONBLOCK);
 #endif
 
-  Const<String> shm_name = std::format("ia_shm_{}", sid);
-  session->mapped_ptr =
-      AU_TRY(FileOps::map_shared_memory(shm_name, shared_memory_size, true));
+    const String shm_name = std::format("ia_shm_{}", sid);
+    session->mapped_ptr = AU_TRY(FileOps::map_shared_memory(shm_name, shared_memory_size, true));
 
-  Mut<IpcSharedMemoryLayout *> layout =
-      reinterpret_cast<IpcSharedMemoryLayout *>(session->mapped_ptr);
+    Mut<IpcSharedMemoryLayout *> layout = reinterpret_cast<IpcSharedMemoryLayout *>(session->mapped_ptr);
 
     layout->meta.magic = 0x49414950;
     layout->meta.version = 1;
     layout->meta.total_size = shared_memory_size;
 
-  Const<u64> header_size = IpcSharedMemoryLayout::get_header_size();
-  Const<u64> usable_bytes = shared_memory_size - header_size;
+    const u64 header_size = IpcSharedMemoryLayout::get_header_size();
+    const u64 usable_bytes = shared_memory_size - header_size;
 
     Mut<u64> half_size = (usable_bytes / 2);
     half_size -= (half_size % 64);
@@ -341,67 +359,68 @@ auto IpcManager::spawn_node(Ref<Path> executable_path,
 
     session->moni = AU_TRY(RingBufferView::create(
         &layout->moni_control,
-      Span<u8>(session->mapped_ptr + layout->moni_data_offset,
-               static_cast<usize>(layout->moni_data_size)),
-      true));
+        Span<u8>(session->mapped_ptr + layout->moni_data_offset, static_cast<usize>(layout->moni_data_size)), true));
 
     session->mino = AU_TRY(RingBufferView::create(
         &layout->mino_control,
-      Span<u8>(session->mapped_ptr + layout->mino_data_offset,
-               static_cast<usize>(layout->mino_data_size)),
-      true));
+        Span<u8>(session->mapped_ptr + layout->mino_data_offset, static_cast<usize>(layout->mino_data_size)), true));
 
     Mut<IpcConnectionDescriptor> desc;
     desc.socket_path = sock_path;
     desc.shared_mem_path = shm_name;
     desc.shared_mem_size = shared_memory_size;
 
-  Const<String> args = std::format("\"{}\"", desc.serialize());
+    const String args = std::format("\"{}\"", desc.serialize());
 
     session->node_process = AU_TRY(ProcessOps::spawn_process_async(
         FileOps::normalize_executable_path(executable_path).string(), args,
-      [sid](Const<StringView> line) {
-        if (Env::IS_DEBUG) {
-          std::cout << std::format("{}[Node:{}:STDOUT|STDERR]: {}{}\n",
-                                   console::MAGENTA, sid, line, console::RESET);
+        [sid](StringView line) {
+          if (Env::IS_DEBUG)
+          {
+            std::cout << std::format("{}[Node:{}:STDOUT|STDERR]: {}{}\n", console::MAGENTA, sid, line, console::RESET);
           }
         },
-      [sid](Const<Result<i32>> result) {
-        if (Env::IS_DEBUG) {
-          if (!result) {
-            std::cout << std::format(
-                "{}[Node: {}]: Failed to spawn with error '{}'{}\n",
-                console::RED, sid, result.error(), console::RESET);
-          } else {
-            std::cout << std::format("{}[Node: {}]: Exited with code {}{}\n",
-                                     console::RED, sid, *result,
+        [sid](Result<i32> result) {
+          if (Env::IS_DEBUG)
+          {
+            if (!result)
+            {
+              std::cout << std::format("{}[Node: {}]: Failed to spawn with error '{}'{}\n", console::RED, sid,
+                                       result.error(), console::RESET);
+            }
+            else
+            {
+              std::cout << std::format("{}[Node: {}]: Exited with code {}{}\n", console::RED, sid, *result,
                                        console::RESET);
             }
           }
         }));
 
     std::this_thread::sleep_for(std::chrono::seconds(1));
-  if (!session->node_process->is_active()) {
-    return fail("Failed to spawn the child process \"{}\"",
-                executable_path.string());
+    if (!session->node_process->is_active())
+    {
+      return fail("Failed to spawn the child process \"{}\"", executable_path.string());
     }
 
-  Const<NativeProcessID> process_id = session->node_process->id.load();
+    const NativeProcessID process_id = session->node_process->id.load();
 
     session->shared_mem_name = shm_name;
     session->creation_time = std::chrono::system_clock::now();
     m_pending_sessions.push_back(std::move(session));
 
     return process_id;
-}
+  }
 
-auto IpcManager::wait_till_node_is_online(Const<NativeProcessID> node_id)
-    -> bool {
+  auto IpcManager::wait_till_node_is_online(const NativeProcessID node_id) -> bool
+  {
     Mut<bool> is_pending = true;
-  while (is_pending) {
+    while (is_pending)
+    {
       is_pending = false;
-    for (Const<Box<NodeSession>> &session : m_pending_sessions) {
-      if (session->node_process->id.load() == node_id) {
+      for (const Box<NodeSession> &session : m_pending_sessions)
+      {
+        if (session->node_process->id.load() == node_id)
+        {
           is_pending = true;
           break;
         }
@@ -410,12 +429,13 @@ auto IpcManager::wait_till_node_is_online(Const<NativeProcessID> node_id)
       std::this_thread::sleep_for(std::chrono::milliseconds(10));
     }
     return m_active_session_map.contains(node_id);
-}
+  }
 
-void IpcManager::shutdown_node(Const<NativeProcessID> node_id) {
-  Const<HashMap<NativeProcessID, NodeSession *>::iterator> it_node =
-      m_active_session_map.find(node_id);
-  if (it_node == m_active_session_map.end()) {
+  void IpcManager::shutdown_node(const NativeProcessID node_id)
+  {
+    const HashMap<NativeProcessID, NodeSession *>::iterator it_node = m_active_session_map.find(node_id);
+    if (it_node == m_active_session_map.end())
+    {
       return;
     }
 
@@ -426,26 +446,26 @@ void IpcManager::shutdown_node(Const<NativeProcessID> node_id) {
     FileOps::unlink_shared_memory(node->shared_mem_name);
     SocketOps::close(node->data_socket);
 
-  std::erase_if(m_active_sessions,
-                [&](Ref<Box<NodeSession>> s) { return s.get() == node; });
+    std::erase_if(m_active_sessions, [&](Ref<Box<NodeSession>> s) { return s.get() == node; });
     m_active_session_map.erase(it_node);
-}
+  }
 
-void IpcManager::send_signal(Const<NativeProcessID> node, Const<u8> signal) {
-  Const<HashMap<NativeProcessID, NodeSession *>::iterator> it_node =
-      m_active_session_map.find(node);
-  if (it_node == m_active_session_map.end()) {
+  void IpcManager::send_signal(const NativeProcessID node, const u8 signal)
+  {
+    const HashMap<NativeProcessID, NodeSession *>::iterator it_node = m_active_session_map.find(node);
+    if (it_node == m_active_session_map.end())
+    {
       return;
     }
     it_node->second->send_signal(signal);
-}
+  }
 
-auto IpcManager::send_packet(Const<NativeProcessID> node, Const<u16> packet_id,
-                             Const<Span<Const<u8>>> payload) -> Result<void> {
-  Const<HashMap<NativeProcessID, NodeSession *>::iterator> it_node =
-      m_active_session_map.find(node);
+  auto IpcManager::send_packet(const NativeProcessID node, const u16 packet_id, const Span<const u8> payload)
+      -> Result<void>
+  {
+    const HashMap<NativeProcessID, NodeSession *>::iterator it_node = m_active_session_map.find(node);
     if (it_node == m_active_session_map.end())
       return fail("no such node");
     return it_node->second->send_packet(packet_id, payload);
-}
+  }
 } // namespace IACore

Src/IACore/imp/cpp/JSON.cpp

@@ -15,4 +15,6 @@
 
 #include <IACore/JSON.hpp>
 
-namespace IACore {} // namespace IACore
+namespace IACore
+{
+} // namespace IACore

Src/IACore/imp/cpp/Logger.cpp

@@ -19,68 +19,76 @@
 #include <fstream>
 #include <iostream>
 
-namespace IACore {
-Mut<Logger::LogLevel> Logger::m_log_level = Logger::LogLevel::Info;
-Mut<std::ofstream> Logger::m_log_file;
+namespace IACore
+{
+  Mut<Logger::LogLevel> Logger::m_log_level = Logger::LogLevel::Info;
+  Mut<std::ofstream> Logger::m_log_file;
 
-static auto get_seconds_count() -> f64 {
-  static Const<std::chrono::time_point<std::chrono::steady_clock>> start_time =
-      std::chrono::steady_clock::now();
-  Const<std::chrono::time_point<std::chrono::steady_clock>> now =
-      std::chrono::steady_clock::now();
-  Const<std::chrono::duration<f64>> duration = now - start_time;
+  static auto get_seconds_count() -> f64
+  {
+    static const std::chrono::time_point<std::chrono::steady_clock> start_time = std::chrono::steady_clock::now();
+    const std::chrono::time_point<std::chrono::steady_clock> now = std::chrono::steady_clock::now();
+    const std::chrono::duration<f64> duration = now - start_time;
     return duration.count();
-}
+  }
 
-auto Logger::initialize() -> void {}
+  auto Logger::initialize() -> void
+  {
+  }
 
-auto Logger::terminate() -> void {
-  if (m_log_file.is_open()) {
+  auto Logger::terminate() -> void
+  {
+    if (m_log_file.is_open())
+    {
       m_log_file.flush();
       m_log_file.close();
     }
-}
+  }
 
-auto Logger::enable_logging_to_disk(Const<Const<char> *> file_path)
-    -> Result<void> {
-  if (m_log_file.is_open()) {
+  auto Logger::enable_logging_to_disk(const char *file_path) -> Result<void>
+  {
+    if (m_log_file.is_open())
+    {
       m_log_file.flush();
       m_log_file.close();
     }
 
     m_log_file.open(file_path);
 
-  if (!m_log_file.is_open()) {
+    if (!m_log_file.is_open())
+    {
       return fail("Failed to open log file: {}", file_path);
     }
 
     return {};
-}
+  }
 
-auto Logger::set_log_level(Const<LogLevel> log_level) -> void {
+  auto Logger::set_log_level(const LogLevel log_level) -> void
+  {
     m_log_level = log_level;
-}
+  }
 
-auto Logger::flush_logs() -> void {
+  auto Logger::flush_logs() -> void
+  {
     std::cout.flush();
-  if (m_log_file.is_open()) {
+    if (m_log_file.is_open())
+    {
       m_log_file.flush();
     }
-}
+  }
 
-auto Logger::log_internal(Const<Const<char> *> prefix, Const<Const<char> *> tag,
-                          ForwardRef<String> msg) -> void {
-  Const<f64> seconds = get_seconds_count();
-  Const<String> out_line =
-      std::format("[{:>8.3f}]: [{}]: {}", seconds, tag, msg);
+  auto Logger::log_internal(const char *prefix, const char *tag, ForwardRef<String> msg) -> void
+  {
+    const f64 seconds = get_seconds_count();
+    const String out_line = std::format("[{:>8.3f}]: [{}]: {}", seconds, tag, msg);
 
     std::cout << prefix << out_line << console::RESET << '\n';
 
-  if (m_log_file.is_open()) {
-    m_log_file.write(out_line.data(),
-                     static_cast<std::streamsize>(out_line.size()));
+    if (m_log_file.is_open())
+    {
+      m_log_file.write(out_line.data(), static_cast<std::streamsize>(out_line.size()));
       m_log_file.put('\n');
       m_log_file.flush();
     }
-}
+  }
 } // namespace IACore

Src/IACore/imp/cpp/Platform.cpp

@@ -16,26 +16,26 @@
 #include <IACore/Platform.hpp>
 
 #if defined(IA_ARCH_X64)
-#ifndef _MSC_VER
-#include <cpuid.h>
-#endif
+#  ifndef _MSC_VER
+#    include <cpuid.h>
+#  endif
 #elif defined(IA_ARCH_ARM64)
-#if defined(__linux__) || defined(__ANDROID__)
-#include <asm/hwcap.h>
-#include <sys/auxv.h>
-#endif
+#  if defined(__linux__) || defined(__ANDROID__)
+#    include <asm/hwcap.h>
+#    include <sys/auxv.h>
+#  endif
 #endif
 
-namespace IACore {
-Mut<Platform::Capabilities> Platform::s_capabilities{};
+namespace IACore
+{
+  Mut<Platform::Capabilities> Platform::s_capabilities{};
 
 #if defined(IA_ARCH_X64)
-auto Platform::cpuid(Const<i32> function, Const<i32> sub_function,
-                     Mut<i32> out[4]) -> void {
-#ifdef _MSC_VER
-  __cpuidex(reinterpret_cast<i32 *>(out), static_cast<i32>(function),
-            static_cast<i32>(sub_function));
-#else
+  auto Platform::cpuid(const i32 function, const i32 sub_function, Mut<i32> out[4]) -> void
+  {
+#  ifdef _MSC_VER
+    __cpuidex(reinterpret_cast<i32 *>(out), static_cast<i32>(function), static_cast<i32>(sub_function));
+#  else
     Mut<u32> a = 0;
     Mut<u32> b = 0;
     Mut<u32> c = 0;
@@ -45,62 +45,68 @@ auto Platform::cpuid(Const<i32> function, Const<i32> sub_function,
     out[1] = static_cast<i32>(b);
     out[2] = static_cast<i32>(c);
     out[3] = static_cast<i32>(d);
-#endif
-}
+#  endif
+  }
 #endif
 
-auto Platform::check_cpu() -> bool {
+  auto Platform::check_cpu() -> bool
+  {
 #if defined(IA_ARCH_X64)
     Mut<i32> cpu_info[4];
 
     cpuid(0, 0, cpu_info);
-  if (cpu_info[0] < 7) {
+    if (cpu_info[0] < 7)
+    {
       return false;
     }
 
     cpuid(1, 0, cpu_info);
-  Const<bool> osxsave = (cpu_info[2] & (1 << 27)) != 0;
-  Const<bool> avx = (cpu_info[2] & (1 << 28)) != 0;
-  Const<bool> fma = (cpu_info[2] & (1 << 12)) != 0;
+    const bool osxsave = (cpu_info[2] & (1 << 27)) != 0;
+    const bool avx = (cpu_info[2] & (1 << 28)) != 0;
+    const bool fma = (cpu_info[2] & (1 << 12)) != 0;
 
-  if (!osxsave || !avx || !fma) {
+    if (!osxsave || !avx || !fma)
+    {
       return false;
     }
 
-  Const<u64> xcr_feature_mask = _xgetbv(0);
-  if ((xcr_feature_mask & 0x6) != 0x6) {
+    const u64 xcr_feature_mask = _xgetbv(0);
+    if ((xcr_feature_mask & 0x6) != 0x6)
+    {
       return false;
     }
 
     cpuid(7, 0, cpu_info);
-  Const<bool> avx2 = (cpu_info[1] & (1 << 5)) != 0;
-  if (!avx2) {
+    const bool avx2 = (cpu_info[1] & (1 << 5)) != 0;
+    if (!avx2)
+    {
       return false;
     }
 
     s_capabilities.hardware_crc32 = true;
 
 #elif defined(IA_ARCH_ARM64)
-#if defined(__linux__) || defined(__ANDROID__)
-  Const<usize> hw_caps = getauxval(AT_HWCAP);
+#  if defined(__linux__) || defined(__ANDROID__)
+    const usize hw_caps = getauxval(AT_HWCAP);
 
-#ifndef HWCAP_CRC32
-#define HWCAP_CRC32 (1 << 7)
-#endif
+#    ifndef HWCAP_CRC32
+#      define HWCAP_CRC32 (1 << 7)
+#    endif
 
     s_capabilities.hardware_crc32 = (hw_caps & HWCAP_CRC32) != 0;
-#elif defined(IA_PLATFORM_APPLE)
+#  elif defined(IA_PLATFORM_APPLE)
     s_capabilities.hardware_crc32 = true;
-#else
+#  else
     s_capabilities.hardware_crc32 = false;
-#endif
+#  endif
 #else
     s_capabilities.hardware_crc32 = false;
 #endif
     return true;
-}
+  }
 
-auto Platform::get_architecture_name() -> const char * {
+  auto Platform::get_architecture_name() -> const char *
+  {
 #if defined(IA_ARCH_X64)
     return "x86_64";
 #elif defined(IA_ARCH_ARM64)
@@ -110,17 +116,18 @@ auto Platform::get_architecture_name() -> const char * {
 #else
     return "unknown";
 #endif
-}
+  }
 
-auto Platform::get_operating_system_name() -> const char * {
+  auto Platform::get_operating_system_name() -> const char *
+  {
 #if IA_PLATFORM_WINDOWS
     return "Windows";
 #elif defined(IA_PLATFORM_APPLE)
-#if defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
+#  if defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
     return "iOS";
-#else
+#  else
     return "macOS";
-#endif
+#  endif
 #elif defined(__ANDROID__)
     return "Android";
 #elif IA_PLATFORM_LINUX
@@ -130,5 +137,5 @@ auto Platform::get_operating_system_name() -> const char * {
 #else
     return "Unknown";
 #endif
-}
+  }
 } // namespace IACore

Src/IACore/imp/cpp/ProcessOps.cpp

@@ -15,117 +15,144 @@
 
 #include <IACore/ProcessOps.hpp>
 
-namespace IACore {
-struct LineBuffer {
+namespace IACore
+{
+  struct LineBuffer
+  {
     Mut<String> m_accumulator;
-  Const<std::function<void(Const<StringView>)>> m_callback;
+    const std::function<void(StringView)> m_callback;
 
-  auto append(Const<char *> data, Const<usize> size) -> void;
+    auto append(const char *data, const usize size) -> void;
     auto flush() -> void;
-};
+  };
 
-auto LineBuffer::append(Const<char *> data, Const<usize> size) -> void {
+  auto LineBuffer::append(const char *data, const usize size) -> void
+  {
     Mut<usize> start = 0;
-  for (Mut<usize> i = 0; i < size; ++i) {
-    if (data[i] == '\n' || data[i] == '\r') {
-      if (!m_accumulator.empty()) {
+    for (Mut<usize> i = 0; i < size; ++i)
+    {
+      if (data[i] == '\n' || data[i] == '\r')
+      {
+        if (!m_accumulator.empty())
+        {
           m_accumulator.append(data + start, i - start);
-        if (!m_accumulator.empty()) {
+          if (!m_accumulator.empty())
+          {
             m_callback(m_accumulator);
           }
           m_accumulator.clear();
-      } else {
-        if (i > start) {
+        }
+        else
+        {
+          if (i > start)
+          {
             m_callback(StringView(data + start, i - start));
           }
         }
 
-      if (data[i] == '\r' && i + 1 < size && data[i + 1] == '\n') {
+        if (data[i] == '\r' && i + 1 < size && data[i + 1] == '\n')
+        {
           i++;
         }
         start = i + 1;
       }
     }
-  if (start < size) {
+    if (start < size)
+    {
       m_accumulator.append(data + start, size - start);
     }
-}
+  }
 
-auto LineBuffer::flush() -> void {
-  if (!m_accumulator.empty()) {
+  auto LineBuffer::flush() -> void
+  {
+    if (!m_accumulator.empty())
+    {
       m_callback(m_accumulator);
       m_accumulator.clear();
     }
-}
+  }
 
-auto ProcessOps::get_current_process_id() -> NativeProcessID {
+  auto ProcessOps::get_current_process_id() -> NativeProcessID
+  {
 #if IA_PLATFORM_WINDOWS
     return ::GetCurrentProcessId();
 #else
     return getpid();
 #endif
-}
+  }
 
-auto ProcessOps::spawn_process_sync(
-    Ref<String> command, Ref<String> args,
-    Const<std::function<void(Const<StringView>)>> on_output_line_callback)
-    -> Result<i32> {
+  auto ProcessOps::spawn_process_sync(Ref<String> command, Ref<String> args,
+                                      const std::function<void(StringView)> on_output_line_callback) -> Result<i32>
+  {
     Mut<std::atomic<NativeProcessID>> id = 0;
-  if constexpr (Env::IS_WINDOWS) {
+    if constexpr (Env::IS_WINDOWS)
+    {
       return spawn_process_windows(command, args, on_output_line_callback, id);
-  } else {
+    }
+    else
+    {
       return spawn_process_posix(command, args, on_output_line_callback, id);
     }
-}
+  }
 
-auto ProcessOps::spawn_process_async(
-    Ref<String> command, Ref<String> args,
-    Const<std::function<void(Const<StringView>)>> on_output_line_callback,
-    Const<std::function<void(Const<Result<i32>>)>> on_finish_callback)
-    -> Result<Box<ProcessHandle>> {
+  auto ProcessOps::spawn_process_async(Ref<String> command, Ref<String> args,
+                                       const std::function<void(StringView)> on_output_line_callback,
+                                       const std::function<void(Result<i32>)> on_finish_callback)
+      -> Result<Box<ProcessHandle>>
+  {
     Mut<Box<ProcessHandle>> handle = make_box<ProcessHandle>();
     handle->is_running = true;
 
     Mut<ProcessHandle *> h_ptr = handle.get();
 
-  handle->m_thread_handle = std::jthread([h_ptr, cmd = command, arg = args,
-                                          cb = on_output_line_callback,
-                                          fin = on_finish_callback]() mutable {
+    handle->m_thread_handle = std::jthread(
+        [h_ptr, cmd = command, arg = args, cb = on_output_line_callback, fin = on_finish_callback]() mutable {
           Mut<Result<i32>> result = fail("Platform not supported");
 
-    if constexpr (Env::IS_WINDOWS) {
+          if constexpr (Env::IS_WINDOWS)
+          {
             result = spawn_process_windows(cmd, arg, cb, h_ptr->id);
-    } else {
+          }
+          else
+          {
             result = spawn_process_posix(cmd, arg, cb, h_ptr->id);
           }
 
           h_ptr->is_running = false;
 
-    if (fin) {
-      if (!result) {
+          if (fin)
+          {
+            if (!result)
+            {
               fin(fail(std::move(result.error())));
-      } else {
+            }
+            else
+            {
               fin(*result);
             }
           }
         });
 
     return handle;
-}
+  }
 
-auto ProcessOps::terminate_process(Ref<Box<ProcessHandle>> handle) -> void {
-  if (!handle || !handle->is_active()) {
+  auto ProcessOps::terminate_process(Ref<Box<ProcessHandle>> handle) -> void
+  {
+    if (!handle || !handle->is_active())
+    {
       return;
     }
 
-  Const<NativeProcessID> pid = handle->id.load();
-  if (pid == 0) {
+    const NativeProcessID pid = handle->id.load();
+    if (pid == 0)
+    {
       return;
     }
 
 #if IA_PLATFORM_WINDOWS
     Mut<HANDLE> h_process = OpenProcess(PROCESS_TERMINATE, false, pid);
-  if (h_process != NULL) {
+    if (h_process != NULL)
+    {
       ::TerminateProcess(h_process, 9);
       CloseHandle(h_process);
     }
@@ -133,22 +160,24 @@ auto ProcessOps::terminate_process(Ref<Box<ProcessHandle>> handle) -> void {
 #if IA_PLATFORM_UNIX
     kill(pid, SIGKILL);
 #endif
-}
+  }
 
-auto ProcessOps::spawn_process_windows(
-    Ref<String> command, Ref<String> args,
-    Const<std::function<void(Const<StringView>)>> on_output_line_callback,
-    MutRef<std::atomic<NativeProcessID>> id) -> Result<i32> {
+  auto ProcessOps::spawn_process_windows(Ref<String> command, Ref<String> args,
+                                         const std::function<void(StringView)> on_output_line_callback,
+                                         MutRef<std::atomic<NativeProcessID>> id) -> Result<i32>
+  {
 #if IA_PLATFORM_WINDOWS
     Mut<SECURITY_ATTRIBUTES> sa_attr = {sizeof(SECURITY_ATTRIBUTES), NULL, true};
     Mut<HANDLE> h_read = NULL;
     Mut<HANDLE> h_write = NULL;
 
-  if (!CreatePipe(&h_read, &h_write, &sa_attr, 0)) {
+    if (!CreatePipe(&h_read, &h_write, &sa_attr, 0))
+    {
       return fail("Failed to create pipe");
     }
 
-  if (!SetHandleInformation(h_read, HANDLE_FLAG_INHERIT, 0)) {
+    if (!SetHandleInformation(h_read, HANDLE_FLAG_INHERIT, 0))
+    {
       return fail("Failed to secure pipe handles");
     }
 
@@ -162,12 +191,12 @@ auto ProcessOps::spawn_process_windows(
 
     Mut<String> command_line = std::format("\"{}\" {}", command, args);
 
-  Const<BOOL> success = CreateProcessA(NULL, command_line.data(), NULL, NULL,
-                                       true, 0, NULL, NULL, &si, &pi);
+    const BOOL success = CreateProcessA(NULL, command_line.data(), NULL, NULL, true, 0, NULL, NULL, &si, &pi);
 
     CloseHandle(h_write);
 
-  if (!success) {
+    if (!success)
+    {
       CloseHandle(h_read);
       return fail("CreateProcess failed: {}", GetLastError());
     }
@@ -178,9 +207,8 @@ auto ProcessOps::spawn_process_windows(
     Mut<DWORD> bytes_read = 0;
     Mut<Array<char, 4096>> buffer;
 
-  while (ReadFile(h_read, buffer.data(), static_cast<DWORD>(buffer.size()),
-                  &bytes_read, NULL) &&
-         bytes_read != 0) {
+    while (ReadFile(h_read, buffer.data(), static_cast<DWORD>(buffer.size()), &bytes_read, NULL) && bytes_read != 0)
+    {
       line_buf.append(buffer.data(), bytes_read);
     }
     line_buf.flush();
@@ -202,23 +230,27 @@ auto ProcessOps::spawn_process_windows(
     AU_UNUSED(id);
     return fail("Windows implementation not available.");
 #endif
-}
+  }
 
-auto ProcessOps::spawn_process_posix(
-    Ref<String> command, Ref<String> args,
-    Const<std::function<void(Const<StringView>)>> on_output_line_callback,
-    MutRef<std::atomic<NativeProcessID>> id) -> Result<i32> {
+  auto ProcessOps::spawn_process_posix(Ref<String> command, Ref<String> args,
+                                       const std::function<void(StringView)> on_output_line_callback,
+                                       MutRef<std::atomic<NativeProcessID>> id) -> Result<i32>
+  {
 #if IA_PLATFORM_UNIX
     Mut<Array<i32, 2>> pipefd;
-  if (pipe(pipefd.data()) == -1) {
+    if (pipe(pipefd.data()) == -1)
+    {
       return fail("Failed to create pipe");
     }
 
-  Const<pid_t> pid = fork();
+    const pid_t pid = fork();
 
-  if (pid == -1) {
+    if (pid == -1)
+    {
       return fail("Failed to fork process");
-  } else if (pid == 0) {
+    }
+    else if (pid == 0)
+    {
       close(pipefd[0]);
 
       dup2(pipefd[1], STDOUT_FILENO);
@@ -235,45 +267,57 @@ auto ProcessOps::spawn_process_posix(
       Mut<bool> in_quotes = false;
       Mut<bool> is_escaped = false;
 
-    for (Const<char> c : args) {
-      if (is_escaped) {
+      for (const char c : args)
+      {
+        if (is_escaped)
+        {
           current_token += c;
           is_escaped = false;
           continue;
         }
 
-      if (c == '\\') {
+        if (c == '\\')
+        {
           is_escaped = true;
           continue;
         }
 
-      if (c == '\"') {
+        if (c == '\"')
+        {
           in_quotes = !in_quotes;
           continue;
         }
 
-      if (c == ' ' && !in_quotes) {
-        if (!current_token.empty()) {
+        if (c == ' ' && !in_quotes)
+        {
+          if (!current_token.empty())
+          {
             arg_storage.push_back(current_token);
             current_token.clear();
           }
-      } else {
+        }
+        else
+        {
           current_token += c;
         }
       }
 
-    if (!current_token.empty()) {
+      if (!current_token.empty())
+      {
         arg_storage.push_back(current_token);
       }
 
-    for (MutRef<String> s : arg_storage) {
+      for (MutRef<String> s : arg_storage)
+      {
         argv.push_back(s.data());
       }
       argv.push_back(nullptr);
 
       execvp(argv[0], argv.data());
       _exit(127);
-  } else {
+    }
+    else
+    {
       id.store(pid);
 
       close(pipefd[1]);
@@ -282,7 +326,8 @@ auto ProcessOps::spawn_process_posix(
       Mut<Array<char, 4096>> buffer;
       Mut<isize> count;
 
-    while ((count = read(pipefd[0], buffer.data(), buffer.size())) > 0) {
+      while ((count = read(pipefd[0], buffer.data(), buffer.size())) > 0)
+      {
         line_buf.append(buffer.data(), static_cast<usize>(count));
       }
       line_buf.flush();
@@ -292,7 +337,8 @@ auto ProcessOps::spawn_process_posix(
       waitpid(pid, &status, 0);
 
       id.store(0);
-    if (WIFEXITED(status)) {
+      if (WIFEXITED(status))
+      {
         return WEXITSTATUS(status);
       }
       return -1;
@@ -304,6 +350,6 @@ auto ProcessOps::spawn_process_posix(
     AU_UNUSED(id);
     return fail("Posix implementation not available.");
 #endif
-}
+  }
 
 } // namespace IACore

Src/IACore/imp/cpp/SIMD.cpp

@@ -15,4 +15,6 @@
 
 #include <IACore/SIMD.hpp>
 
-namespace IACore {} // namespace IACore
+namespace IACore
+{
+} // namespace IACore

Src/IACore/imp/cpp/SocketOps.cpp

@@ -14,13 +14,15 @@
 // limitations under the License.
 
 #include <IACore/SocketOps.hpp>
-#include <cstring>
 
-namespace IACore {
-Mut<i32> SocketOps::s_init_count = 0;
+namespace IACore
+{
+  Mut<i32> SocketOps::s_init_count = 0;
 
-auto SocketOps::close(Const<SocketHandle> sock) -> void {
-  if (sock == INVALID_SOCKET) {
+  auto SocketOps::close(const SocketHandle sock) -> void
+  {
+    if (sock == INVALID_SOCKET)
+    {
       return;
     }
 #if IA_PLATFORM_WINDOWS
@@ -28,11 +30,12 @@ auto SocketOps::close(Const<SocketHandle> sock) -> void {
 #else
     ::close(sock);
 #endif
-}
+  }
 
-auto SocketOps::listen(Const<SocketHandle> sock, Const<i32> queue_size)
-    -> Result<void> {
-  if (::listen(sock, queue_size) == 0) {
+  auto SocketOps::listen(const SocketHandle sock, const i32 queue_size) -> Result<void>
+  {
+    if (::listen(sock, queue_size) == 0)
+    {
       return {};
     }
 
@@ -41,11 +44,13 @@ auto SocketOps::listen(Const<SocketHandle> sock, Const<i32> queue_size)
 #else
     return fail("listen failed: {}", errno);
 #endif
-}
+  }
 
-auto SocketOps::create_unix_socket() -> Result<SocketHandle> {
-  Const<SocketHandle> sock = socket(AF_UNIX, SOCK_STREAM, 0);
-  if (sock == INVALID_SOCKET) {
+  auto SocketOps::create_unix_socket() -> Result<SocketHandle>
+  {
+    const SocketHandle sock = socket(AF_UNIX, SOCK_STREAM, 0);
+    if (sock == INVALID_SOCKET)
+    {
 #if IA_PLATFORM_WINDOWS
       return fail("socket(AF_UNIX) failed: {}", WSAGetLastError());
 #else
@@ -53,11 +58,12 @@ auto SocketOps::create_unix_socket() -> Result<SocketHandle> {
 #endif
     }
     return sock;
-}
+  }
 
-auto SocketOps::bind_unix_socket(Const<SocketHandle> sock,
-                                 Const<const char *> path) -> Result<void> {
-  if (sock == INVALID_SOCKET) {
+  auto SocketOps::bind_unix_socket(const SocketHandle sock, const char *path) -> Result<void>
+  {
+    if (sock == INVALID_SOCKET)
+    {
       return fail("Invalid socket handle");
     }
 
@@ -66,15 +72,15 @@ auto SocketOps::bind_unix_socket(Const<SocketHandle> sock,
     Mut<sockaddr_un> addr{};
     addr.sun_family = AF_UNIX;
 
-  Const<usize> max_len = sizeof(addr.sun_path) - 1;
+    const usize max_len = sizeof(addr.sun_path) - 1;
 #if IA_PLATFORM_WINDOWS
     strncpy_s(addr.sun_path, sizeof(addr.sun_path), path, max_len);
 #else
     std::strncpy(addr.sun_path, path, max_len);
 #endif
 
-  if (::bind(sock, reinterpret_cast<struct sockaddr *>(&addr), sizeof(addr)) ==
-      -1) {
+    if (::bind(sock, reinterpret_cast<struct sockaddr *>(&addr), sizeof(addr)) == -1)
+    {
 #if IA_PLATFORM_WINDOWS
       return fail("bind failed: {}", WSAGetLastError());
 #else
@@ -83,26 +89,27 @@ auto SocketOps::bind_unix_socket(Const<SocketHandle> sock,
     }
 
     return {};
-}
+  }
 
-auto SocketOps::connect_unix_socket(Const<SocketHandle> sock,
-                                    Const<const char *> path) -> Result<void> {
-  if (sock == INVALID_SOCKET) {
+  auto SocketOps::connect_unix_socket(const SocketHandle sock, const char *path) -> Result<void>
+  {
+    if (sock == INVALID_SOCKET)
+    {
       return fail("Invalid socket handle");
     }
 
     Mut<sockaddr_un> addr{};
     addr.sun_family = AF_UNIX;
 
-  Const<usize> max_len = sizeof(addr.sun_path) - 1;
+    const usize max_len = sizeof(addr.sun_path) - 1;
 #if IA_PLATFORM_WINDOWS
     strncpy_s(addr.sun_path, sizeof(addr.sun_path), path, max_len);
 #else
     std::strncpy(addr.sun_path, path, max_len);
 #endif
 
-  if (::connect(sock, reinterpret_cast<struct sockaddr *>(&addr),
-                sizeof(addr)) == -1) {
+    if (::connect(sock, reinterpret_cast<struct sockaddr *>(&addr), sizeof(addr)) == -1)
+    {
 #if IA_PLATFORM_WINDOWS
       return fail("connect failed: {}", WSAGetLastError());
 #else
@@ -111,11 +118,13 @@ auto SocketOps::connect_unix_socket(Const<SocketHandle> sock,
     }
 
     return {};
-}
+  }
 
-auto SocketOps::is_port_available(Const<u16> port, Const<i32> type) -> bool {
-  Const<SocketHandle> sock = socket(AF_INET, type, 0);
-  if (sock == INVALID_SOCKET) {
+  auto SocketOps::is_port_available(const u16 port, const i32 type) -> bool
+  {
+    const SocketHandle sock = socket(AF_INET, type, 0);
+    if (sock == INVALID_SOCKET)
+    {
       return false;
     }
 
@@ -125,22 +134,23 @@ auto SocketOps::is_port_available(Const<u16> port, Const<i32> type) -> bool {
     addr.sin_addr.s_addr = htonl(INADDR_ANY);
 
     Mut<bool> is_free = false;
-  if (::bind(sock, reinterpret_cast<struct sockaddr *>(&addr), sizeof(addr)) ==
-      0) {
+    if (::bind(sock, reinterpret_cast<struct sockaddr *>(&addr), sizeof(addr)) == 0)
+    {
       is_free = true;
     }
 
     close(sock);
 
     return is_free;
-}
+  }
 
-auto SocketOps::is_would_block() -> bool {
+  auto SocketOps::is_would_block() -> bool
+  {
 #if IA_PLATFORM_WINDOWS
     return WSAGetLastError() == WSAEWOULDBLOCK;
 #else
     return errno == EWOULDBLOCK || errno == EAGAIN;
 #endif
-}
+  }
 
 } // namespace IACore

Src/IACore/imp/cpp/StreamReader.cpp

@@ -16,47 +16,52 @@
 #include <IACore/FileOps.hpp>
 #include <IACore/StreamReader.hpp>
 
-namespace IACore {
-auto StreamReader::create_from_file(Ref<Path> path) -> Result<StreamReader> {
+namespace IACore
+{
+  auto StreamReader::create_from_file(Ref<Path> path) -> Result<StreamReader>
+  {
     Mut<usize> size = 0;
 
-  Const<const u8 *> ptr = AU_TRY(FileOps::map_file(path, size));
+    const u8 *ptr = AU_TRY(FileOps::map_file(path, size));
 
     Mut<StreamReader> reader(Span<const u8>(ptr, size));
     reader.m_storage_type = StorageType::OwningMmap;
 
     return reader;
-}
+  }
 
-StreamReader::StreamReader(ForwardRef<Vec<u8>> data)
-    : m_owning_vector(std::move(data)),
-      m_storage_type(StorageType::OwningVector) {
+  StreamReader::StreamReader(ForwardRef<Vec<u8>> data)
+      : m_owning_vector(std::move(data)), m_storage_type(StorageType::OwningVector)
+  {
     m_data = m_owning_vector.data();
     m_data_size = m_owning_vector.size();
-}
+  }
 
-StreamReader::StreamReader(Const<Span<const u8>> data)
-    : m_data(data.data()), m_data_size(data.size()),
-      m_storage_type(StorageType::NonOwning) {}
+  StreamReader::StreamReader(const Span<const u8> data)
+      : m_data(data.data()), m_data_size(data.size()), m_storage_type(StorageType::NonOwning)
+  {
+  }
 
-StreamReader::StreamReader(ForwardRef<StreamReader> other)
-    : m_data(other.m_data), m_cursor(other.m_cursor),
-      m_data_size(other.m_data_size),
-      m_owning_vector(std::move(other.m_owning_vector)),
-      m_storage_type(other.m_storage_type) {
+  StreamReader::StreamReader(ForwardRef<StreamReader> other)
+      : m_data(other.m_data), m_cursor(other.m_cursor), m_data_size(other.m_data_size),
+        m_owning_vector(std::move(other.m_owning_vector)), m_storage_type(other.m_storage_type)
+  {
     other.m_storage_type = StorageType::NonOwning;
     other.m_data = {};
     other.m_data_size = 0;
 
-  if (m_storage_type == StorageType::OwningVector) {
+    if (m_storage_type == StorageType::OwningVector)
+    {
       m_data = m_owning_vector.data();
     }
-}
+  }
 
-auto StreamReader::operator=(ForwardRef<StreamReader> other)
-    -> MutRef<StreamReader> {
-  if (this != &other) {
-    if (m_storage_type == StorageType::OwningMmap) {
+  auto StreamReader::operator=(ForwardRef<StreamReader> other) -> MutRef<StreamReader>
+  {
+    if (this != &other)
+    {
+      if (m_storage_type == StorageType::OwningMmap)
+      {
         FileOps::unmap_file(m_data);
       }
 
@@ -66,7 +71,8 @@ auto StreamReader::operator=(ForwardRef<StreamReader> other)
       m_owning_vector = std::move(other.m_owning_vector);
       m_storage_type = other.m_storage_type;
 
-    if (m_storage_type == StorageType::OwningVector) {
+      if (m_storage_type == StorageType::OwningVector)
+      {
         m_data = m_owning_vector.data();
       }
 
@@ -75,11 +81,13 @@ auto StreamReader::operator=(ForwardRef<StreamReader> other)
       other.m_data_size = 0;
     }
     return *this;
-}
+  }
 
-StreamReader::~StreamReader() {
-  if (m_storage_type == StorageType::OwningMmap) {
+  StreamReader::~StreamReader()
+  {
+    if (m_storage_type == StorageType::OwningMmap)
+    {
       FileOps::unmap_file(m_data);
     }
-}
+  }
 } // namespace IACore

Src/IACore/imp/cpp/StreamWriter.cpp

@@ -15,11 +15,14 @@
 
 #include <IACore/StreamWriter.hpp>
 
-namespace IACore {
+namespace IACore
+{
 
-auto StreamWriter::create_from_file(Ref<Path> path) -> Result<StreamWriter> {
+  auto StreamWriter::create_from_file(Ref<Path> path) -> Result<StreamWriter>
+  {
     Mut<FILE *> f = std::fopen(path.string().c_str(), "wb");
-  if (!f) {
+    if (!f)
+    {
       return fail("Failed to open file for writing: {}", path.string());
     }
     std::fclose(f);
@@ -29,38 +32,42 @@ auto StreamWriter::create_from_file(Ref<Path> path) -> Result<StreamWriter> {
     writer.m_storage_type = StorageType::OwningFile;
 
     return writer;
-}
+  }
 
-StreamWriter::StreamWriter() : m_storage_type(StorageType::OwningVector) {
+  StreamWriter::StreamWriter() : m_storage_type(StorageType::OwningVector)
+  {
     m_capacity = 256;
     m_owning_vector.resize(m_capacity);
     m_buffer = m_owning_vector.data();
-}
+  }
 
-StreamWriter::StreamWriter(Const<Span<u8>> data)
-    : m_buffer(data.data()), m_cursor(0), m_capacity(data.size()),
-      m_storage_type(StorageType::NonOwning) {}
+  StreamWriter::StreamWriter(const Span<u8> data)
+      : m_buffer(data.data()), m_cursor(0), m_capacity(data.size()), m_storage_type(StorageType::NonOwning)
+  {
+  }
 
-StreamWriter::StreamWriter(ForwardRef<StreamWriter> other)
-    : m_buffer(other.m_buffer), m_cursor(other.m_cursor),
-      m_capacity(other.m_capacity), m_file_path(other.m_file_path),
-      m_owning_vector(std::move(other.m_owning_vector)),
-      m_storage_type(other.m_storage_type) {
+  StreamWriter::StreamWriter(ForwardRef<StreamWriter> other)
+      : m_buffer(other.m_buffer), m_cursor(other.m_cursor), m_capacity(other.m_capacity),
+        m_file_path(other.m_file_path), m_owning_vector(std::move(other.m_owning_vector)),
+        m_storage_type(other.m_storage_type)
+  {
     other.m_capacity = {};
     other.m_buffer = {};
     other.m_storage_type = StorageType::NonOwning;
 
     if (m_storage_type == StorageType::OwningVector)
       m_buffer = m_owning_vector.data();
-}
+  }
 
-auto StreamWriter::operator=(ForwardRef<StreamWriter> other)
-    -> MutRef<StreamWriter> {
-  if (this != &other) {
-    if (m_storage_type == StorageType::OwningFile) {
-      if (Const<Result<void>> res = flush_to_disk(); !res) {
-        std::fprintf(stderr, "[IACore] Data loss in StreamWriter move: %s\n",
-                     res.error().c_str());
+  auto StreamWriter::operator=(ForwardRef<StreamWriter> other) -> MutRef<StreamWriter>
+  {
+    if (this != &other)
+    {
+      if (m_storage_type == StorageType::OwningFile)
+      {
+        if (const Result<void> res = flush_to_disk(); !res)
+        {
+          std::fprintf(stderr, "[IACore] Data loss in StreamWriter move: %s\n", res.error().c_str());
         }
       }
 
@@ -80,53 +87,64 @@ auto StreamWriter::operator=(ForwardRef<StreamWriter> other)
       other.m_storage_type = StorageType::NonOwning;
     }
     return *this;
-}
+  }
 
-StreamWriter::~StreamWriter() {
-  if (m_storage_type == StorageType::OwningFile) {
-    if (Const<Result<void>> res = flush_to_disk(); !res) {
-      std::fprintf(stderr, "[IACore] LOST DATA in ~StreamWriter: %s\n",
-                   res.error().c_str());
+  StreamWriter::~StreamWriter()
+  {
+    if (m_storage_type == StorageType::OwningFile)
+    {
+      if (const Result<void> res = flush_to_disk(); !res)
+      {
+        std::fprintf(stderr, "[IACore] LOST DATA in ~StreamWriter: %s\n", res.error().c_str());
+      }
     }
   }
-}
 
-auto StreamWriter::flush() -> Result<void> {
+  auto StreamWriter::flush() -> Result<void>
+  {
     Mut<Result<void>> res = flush_to_disk();
-  if (res.has_value()) {
+    if (res.has_value())
+    {
       m_storage_type = StorageType::OwningVector;
     }
     return res;
-}
+  }
 
-auto StreamWriter::flush_to_disk() -> Result<void> {
-  if (m_storage_type != StorageType::OwningFile || m_file_path.empty()) {
+  auto StreamWriter::flush_to_disk() -> Result<void>
+  {
+    if (m_storage_type != StorageType::OwningFile || m_file_path.empty())
+    {
       return {};
     }
 
     Mut<FILE *> f = std::fopen(m_file_path.string().c_str(), "wb");
-  if (!f) {
+    if (!f)
+    {
       return fail("Failed to open file for writing: {}", m_file_path.string());
     }
 
-  Const<usize> written = std::fwrite(m_buffer, 1, m_cursor, f);
+    const usize written = std::fwrite(m_buffer, 1, m_cursor, f);
     std::fclose(f);
 
-  if (written != m_cursor) {
+    if (written != m_cursor)
+    {
       return fail("Incomplete write: {} of {} bytes written", written, m_cursor);
     }
     return {};
-}
+  }
 
-auto StreamWriter::write(Const<u8> byte, Const<usize> count) -> Result<void> {
-  if (m_cursor + count > m_capacity) {
-    if (m_storage_type == StorageType::NonOwning) {
+  auto StreamWriter::write(const u8 byte, const usize count) -> Result<void>
+  {
+    if (m_cursor + count > m_capacity)
+    {
+      if (m_storage_type == StorageType::NonOwning)
+      {
         return fail("StreamWriter buffer overflow (NonOwning)");
       }
 
-    Const<usize> required = m_cursor + count;
-    Const<usize> double_cap = m_capacity * 2;
-    Const<usize> new_capacity = (double_cap > required) ? double_cap : required;
+      const usize required = m_cursor + count;
+      const usize double_cap = m_capacity * 2;
+      const usize new_capacity = (double_cap > required) ? double_cap : required;
 
       m_owning_vector.resize(new_capacity);
       m_capacity = m_owning_vector.size();
@@ -136,18 +154,20 @@ auto StreamWriter::write(Const<u8> byte, Const<usize> count) -> Result<void> {
     std::memset(m_buffer + m_cursor, byte, count);
     m_cursor += count;
     return {};
-}
+  }
 
-auto StreamWriter::write(Const<const void *> buffer, Const<usize> size)
-    -> Result<void> {
-  if (m_cursor + size > m_capacity) {
-    if (m_storage_type == StorageType::NonOwning) {
+  auto StreamWriter::write(const void *buffer, const usize size) -> Result<void>
+  {
+    if (m_cursor + size > m_capacity)
+    {
+      if (m_storage_type == StorageType::NonOwning)
+      {
         return fail("StreamWriter buffer overflow (NonOwning)");
       }
 
-    Const<usize> required = m_cursor + size;
-    Const<usize> double_cap = m_capacity * 2;
-    Const<usize> new_capacity = (double_cap > required) ? double_cap : required;
+      const usize required = m_cursor + size;
+      const usize double_cap = m_capacity * 2;
+      const usize new_capacity = (double_cap > required) ? double_cap : required;
 
       m_owning_vector.resize(new_capacity);
       m_capacity = m_owning_vector.size();
@@ -157,6 +177,6 @@ auto StreamWriter::write(Const<const void *> buffer, Const<usize> size)
     std::memcpy(m_buffer + m_cursor, buffer, size);
     m_cursor += size;
     return {};
-}
+  }
 
 } // namespace IACore

Src/IACore/imp/cpp/StringOps.cpp

@@ -15,17 +15,18 @@
 
 #include <IACore/StringOps.hpp>
 
-namespace IACore {
+namespace IACore
+{
 
-static Const<String> BASE64_CHAR_TABLE =
-    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  static const String BASE64_CHAR_TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
-static auto is_base64(Const<u8> c) -> bool {
-  return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') ||
-         (c >= '0' && c <= '9') || (c == '+') || (c == '/');
-}
+  static auto is_base64(const u8 c) -> bool
+  {
+    return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || (c == '+') || (c == '/');
+  }
 
-static auto get_base64_index(Const<u8> c) -> u8 {
+  static auto get_base64_index(const u8 c) -> u8
+  {
     if (c >= 'A' && c <= 'Z')
       return c - 'A';
     if (c >= 'a' && c <= 'z')
@@ -37,59 +38,72 @@ static auto get_base64_index(Const<u8> c) -> u8 {
     if (c == '/')
       return 63;
     return 0;
-}
+  }
 
-auto StringOps::encode_base64(Const<Span<Const<u8>>> data) -> String {
+  auto StringOps::encode_base64(const Span<const u8> data) -> String
+  {
     Mut<String> result;
     result.reserve(((data.size() + 2) / 3) * 4);
 
-  for (Mut<usize> i = 0; i < data.size(); i += 3) {
-    Const<u32> b0 = data[i];
-    Const<u32> b1 = (i + 1 < data.size()) ? data[i + 1] : 0;
-    Const<u32> b2 = (i + 2 < data.size()) ? data[i + 2] : 0;
+    for (Mut<usize> i = 0; i < data.size(); i += 3)
+    {
+      const u32 b0 = data[i];
+      const u32 b1 = (i + 1 < data.size()) ? data[i + 1] : 0;
+      const u32 b2 = (i + 2 < data.size()) ? data[i + 2] : 0;
 
-    Const<u32> triple = (b0 << 16) | (b1 << 8) | b2;
+      const u32 triple = (b0 << 16) | (b1 << 8) | b2;
 
       result += BASE64_CHAR_TABLE[(triple >> 18) & 0x3F];
       result += BASE64_CHAR_TABLE[(triple >> 12) & 0x3F];
 
-    if (i + 1 < data.size()) {
+      if (i + 1 < data.size())
+      {
         result += BASE64_CHAR_TABLE[(triple >> 6) & 0x3F];
-    } else {
+      }
+      else
+      {
         result += '=';
       }
 
-    if (i + 2 < data.size()) {
+      if (i + 2 < data.size())
+      {
         result += BASE64_CHAR_TABLE[triple & 0x3F];
-    } else {
+      }
+      else
+      {
         result += '=';
       }
     }
     return result;
-}
+  }
 
-auto StringOps::decode_base64(Ref<String> data) -> Vec<u8> {
+  auto StringOps::decode_base64(Ref<String> data) -> Vec<u8>
+  {
     Mut<Vec<u8>> result;
     result.reserve(data.size() * 3 / 4);
 
     Mut<i32> i = 0;
     Mut<Array<u8, 4>> tmp_buf = {};
 
-  for (Const<char> c_char : data) {
-    Const<u8> c = static_cast<u8>(c_char);
-    if (c == '=') {
+    for (const char c_char : data)
+    {
+      const u8 c = static_cast<u8>(c_char);
+      if (c == '=')
+      {
         break;
       }
-    if (!is_base64(c)) {
+      if (!is_base64(c))
+      {
         break;
       }
 
       tmp_buf[i++] = c;
-    if (i == 4) {
-      Const<u8> n0 = get_base64_index(tmp_buf[0]);
-      Const<u8> n1 = get_base64_index(tmp_buf[1]);
-      Const<u8> n2 = get_base64_index(tmp_buf[2]);
-      Const<u8> n3 = get_base64_index(tmp_buf[3]);
+      if (i == 4)
+      {
+        const u8 n0 = get_base64_index(tmp_buf[0]);
+        const u8 n1 = get_base64_index(tmp_buf[1]);
+        const u8 n2 = get_base64_index(tmp_buf[2]);
+        const u8 n3 = get_base64_index(tmp_buf[3]);
 
         result.push_back((n0 << 2) | ((n1 & 0x30) >> 4));
         result.push_back(((n1 & 0x0F) << 4) | ((n2 & 0x3C) >> 2));
@@ -99,24 +113,28 @@ auto StringOps::decode_base64(Ref<String> data) -> Vec<u8> {
       }
     }
 
-  if (i > 0) {
-    for (Mut<i32> j = i; j < 4; ++j) {
+    if (i > 0)
+    {
+      for (Mut<i32> j = i; j < 4; ++j)
+      {
         tmp_buf[j] = 'A';
       }
 
-    Const<u8> n0 = get_base64_index(tmp_buf[0]);
-    Const<u8> n1 = get_base64_index(tmp_buf[1]);
-    Const<u8> n2 = get_base64_index(tmp_buf[2]);
+      const u8 n0 = get_base64_index(tmp_buf[0]);
+      const u8 n1 = get_base64_index(tmp_buf[1]);
+      const u8 n2 = get_base64_index(tmp_buf[2]);
 
-    if (i > 1) {
+      if (i > 1)
+      {
         result.push_back((n0 << 2) | ((n1 & 0x30) >> 4));
       }
-    if (i > 2) {
+      if (i > 2)
+      {
         result.push_back(((n1 & 0x0F) << 4) | ((n2 & 0x3C) >> 2));
       }
     }
 
     return result;
-}
+  }
 
 } // namespace IACore

Src/IACore/imp/cpp/Utils.cpp

@@ -17,90 +17,104 @@
 #include <chrono>
 #include <cstdlib>
 
-namespace IACore {
-namespace {
-auto from_hex_char(Const<char> c) -> i32 {
-  if (c >= '0' && c <= '9') {
+namespace IACore
+{
+  namespace
+  {
+    auto from_hex_char(const char c) -> i32
+    {
+      if (c >= '0' && c <= '9')
+      {
         return c - '0';
       }
-  if (c >= 'A' && c <= 'F') {
+      if (c >= 'A' && c <= 'F')
+      {
         return c - 'A' + 10;
       }
-  if (c >= 'a' && c <= 'f') {
+      if (c >= 'a' && c <= 'f')
+      {
         return c - 'a' + 10;
       }
       return -1;
-}
-} // namespace
+    }
+  } // namespace
 
-extern Mut<std::chrono::high_resolution_clock::time_point> g_start_time;
+  extern Mut<std::chrono::high_resolution_clock::time_point> g_start_time;
 
-auto Utils::get_unix_time() -> u64 {
-  Const<std::chrono::system_clock::time_point> now =
-      std::chrono::system_clock::now();
-  return std::chrono::duration_cast<std::chrono::seconds>(
-             now.time_since_epoch())
-      .count();
-}
+  auto Utils::get_unix_time() -> u64
+  {
+    const std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
+    return std::chrono::duration_cast<std::chrono::seconds>(now.time_since_epoch()).count();
+  }
 
-auto Utils::get_ticks_count() -> u64 {
-  Const<std::chrono::high_resolution_clock::duration> duration =
+  auto Utils::get_ticks_count() -> u64
+  {
+    const std::chrono::high_resolution_clock::duration duration =
         std::chrono::high_resolution_clock::now() - g_start_time;
-  return std::chrono::duration_cast<std::chrono::milliseconds>(duration)
-      .count();
-}
+    return std::chrono::duration_cast<std::chrono::milliseconds>(duration).count();
+  }
 
-auto Utils::get_seconds_count() -> f64 {
-  Const<std::chrono::high_resolution_clock::duration> duration =
+  auto Utils::get_seconds_count() -> f64
+  {
+    const std::chrono::high_resolution_clock::duration duration =
         std::chrono::high_resolution_clock::now() - g_start_time;
-  return static_cast<f64>(
-      std::chrono::duration_cast<std::chrono::seconds>(duration).count());
-}
+    return static_cast<f64>(std::chrono::duration_cast<std::chrono::seconds>(duration).count());
+  }
 
-auto Utils::get_random() -> f32 {
+  auto Utils::get_random() -> f32
+  {
     return static_cast<f32>(std::rand()) / static_cast<f32>(RAND_MAX);
-}
+  }
 
-auto Utils::get_random(Const<u64> max) -> u64 {
+  auto Utils::get_random(const u64 max) -> u64
+  {
     return static_cast<u64>(static_cast<f32>(max) * get_random());
-}
+  }
 
-auto Utils::get_random(Const<i64> min, Const<i64> max) -> i64 {
+  auto Utils::get_random(const i64 min, const i64 max) -> i64
+  {
     return min + static_cast<i64>(static_cast<f32>(max - min) * get_random());
-}
+  }
 
-auto Utils::sleep(Const<u64> milliseconds) -> void {
+  auto Utils::sleep(const u64 milliseconds) -> void
+  {
     std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds));
-}
+  }
 
-auto Utils::binary_to_hex_string(Const<Span<Const<u8>>> data) -> String {
-  static constexpr Const<char[17]> lut = "0123456789ABCDEF";
+  auto Utils::binary_to_hex_string(const Span<const u8> data) -> String
+  {
+    static constexpr const char LUT[17] = "0123456789ABCDEF";
     Mut<String> res = String();
     res.reserve(data.size() * 2);
 
-  for (Const<u8> b : data) {
-    res.push_back(lut[(b >> 4) & 0x0F]);
-    res.push_back(lut[b & 0x0F]);
+    for (u8 b : data)
+    {
+      res.push_back(LUT[(b >> 4) & 0x0F]);
+      res.push_back(LUT[b & 0x0F]);
     }
     return res;
-}
+  }
 
-auto Utils::hex_string_to_binary(Const<StringView> hex) -> Result<Vec<u8>> {
-  if (hex.size() % 2 != 0) {
+  auto Utils::hex_string_to_binary(const StringView hex) -> Result<Vec<u8>>
+  {
+    if (hex.size() % 2 != 0)
+    {
       return fail("Hex string must have even length");
     }
 
     Mut<Vec<u8>> out = Vec<u8>();
     out.reserve(hex.size() / 2);
 
-  for (Mut<usize> i = 0; i < hex.size(); i += 2) {
-    Const<char> high = hex[i];
-    Const<char> low = hex[i + 1];
+    for (Mut<usize> i = 0; i < hex.size(); i += 2)
+    {
+      const char high = hex[i];
+      const char low = hex[i + 1];
 
-    Const<i32> h = from_hex_char(high);
-    Const<i32> l = from_hex_char(low);
+      const i32 h = from_hex_char(high);
+      const i32 l = from_hex_char(low);
 
-    if (h == -1 || l == -1) {
+      if (h == -1 || l == -1)
+      {
         return fail("Invalid hex character found");
       }
 
@@ -108,5 +122,5 @@ auto Utils::hex_string_to_binary(Const<StringView> hex) -> Result<Vec<u8>> {
     }
 
     return out;
-}
+  }
 } // namespace IACore

Src/IACore/imp/cpp/XML.cpp

@@ -16,45 +16,54 @@
 #include <IACore/XML.hpp>
 #include <sstream>
 
-namespace IACore {
+namespace IACore
+{
 
-auto XML::parse_from_string(Ref<String> data) -> Result<Document> {
+  auto XML::parse_from_string(Ref<String> data) -> Result<Document>
+  {
     Mut<Document> doc;
-  Const<pugi::xml_parse_result> parse_result = doc.load_string(data.c_str());
-  if (!parse_result) {
+    const pugi::xml_parse_result parse_result = doc.load_string(data.c_str());
+    if (!parse_result)
+    {
       return fail("Failed to parse XML {}", parse_result.description());
     }
     return std::move(doc);
-}
+  }
 
-auto XML::parse_from_file(Ref<Path> path) -> Result<Document> {
+  auto XML::parse_from_file(Ref<Path> path) -> Result<Document>
+  {
     Mut<Document> doc;
-  Const<pugi::xml_parse_result> parse_result =
-      doc.load_file(path.string().c_str());
-  if (!parse_result) {
+    const pugi::xml_parse_result parse_result = doc.load_file(path.string().c_str());
+    if (!parse_result)
+    {
       return fail("Failed to parse XML {}", parse_result.description());
     }
     return std::move(doc);
-}
+  }
 
-auto XML::serialize_to_string(Ref<Node> node, Const<bool> escape) -> String {
+  auto XML::serialize_to_string(Ref<Node> node, const bool escape) -> String
+  {
     Mut<std::ostringstream> oss;
     node.print(oss);
     return escape ? escape_xml_string(oss.str()) : oss.str();
-}
+  }
 
-auto XML::serialize_to_string(Ref<Document> doc, Const<bool> escape) -> String {
+  auto XML::serialize_to_string(Ref<Document> doc, const bool escape) -> String
+  {
     Mut<std::ostringstream> oss;
     doc.save(oss);
     return escape ? escape_xml_string(oss.str()) : oss.str();
-}
+  }
 
-auto XML::escape_xml_string(Ref<String> xml) -> String {
+  auto XML::escape_xml_string(Ref<String> xml) -> String
+  {
     Mut<String> buffer;
     buffer.reserve(xml.size() + (xml.size() / 10));
 
-  for (Const<char> c : xml) {
-    switch (c) {
+    for (const char c : xml)
+    {
+      switch (c)
+      {
       case '&':
         buffer.append("&amp;");
         break;
@@ -77,6 +86,6 @@ auto XML::escape_xml_string(Ref<String> xml) -> String {
     }
 
     return buffer;
-}
+  }
 
 } // namespace IACore

Src/IACore/inc/IACore/ADT/RingBuffer.hpp

@@ -17,32 +17,42 @@
 
 #include <IACore/PCH.hpp>
 
-namespace IACore {
-class RingBufferView {
+namespace IACore
+{
+  class RingBufferView
+  {
 public:
-  static constexpr Const<u16> PACKET_ID_SKIP = 0;
+    static constexpr const u16 PACKET_ID_SKIP = 0;
 
-  struct ControlBlock {
-    struct alignas(64) {
+    struct ControlBlock
+    {
+      struct alignas(64)
+      {
         Mut<std::atomic<u32>> write_offset{0};
       } producer;
 
-    struct alignas(64) {
+      struct alignas(64)
+      {
         Mut<std::atomic<u32>> read_offset{0};
         Mut<u32> capacity{0};
       } consumer;
     };
 
-  static_assert(offsetof(ControlBlock, consumer) == 64,
-                "False sharing detected in ControlBlock");
+    static_assert(offsetof(ControlBlock, consumer) == 64, "False sharing detected in ControlBlock");
 
-  struct PacketHeader {
-    PacketHeader() : id(0), payload_size(0) {}
+    struct PacketHeader
+    {
+      PacketHeader() : id(0), payload_size(0)
+      {
+      }
 
-    PacketHeader(Const<u16> id) : id(id), payload_size(0) {}
+      PacketHeader(const u16 id) : id(id), payload_size(0)
+      {
+      }
 
-    PacketHeader(Const<u16> id, Const<u16> payload_size)
-        : id(id), payload_size(payload_size) {}
+      PacketHeader(const u16 id, const u16 payload_size) : id(id), payload_size(payload_size)
+      {
+      }
 
       Mut<u16> id{};
       Mut<u16> payload_size{};
@@ -51,28 +61,25 @@ public:
 public:
     static auto default_instance() -> RingBufferView;
 
-  static auto create(Ref<Span<u8>> buffer, Const<bool> is_owner)
+    static auto create(Ref<Span<u8>> buffer, const bool is_owner) -> Result<RingBufferView>;
+    static auto create(ControlBlock *control_block, Ref<Span<u8>> buffer, const bool is_owner)
         -> Result<RingBufferView>;
-  static auto create(Const<ControlBlock *> control_block, Ref<Span<u8>> buffer,
-                     Const<bool> is_owner) -> Result<RingBufferView>;
 
     // Returns:
     // - nullopt if empty
     // - bytes_read if success
     // - Error if buffer too small
-  auto pop(MutRef<PacketHeader> out_header, Ref<Span<u8>> out_buffer)
-      -> Result<Option<usize>>;
+    auto pop(MutRef<PacketHeader> out_header, Ref<Span<u8>> out_buffer) -> Result<Option<usize>>;
 
-  auto push(Const<u16> packet_id, Ref<Span<const u8>> data) -> Result<void>;
+    auto push(const u16 packet_id, Ref<Span<const u8>> data) -> Result<void>;
 
     auto get_control_block() -> ControlBlock *;
 
     [[nodiscard]] auto is_valid() const -> bool;
 
 protected:
-  RingBufferView(Ref<Span<u8>> buffer, Const<bool> is_owner);
-  RingBufferView(Const<ControlBlock *> control_block, Ref<Span<u8>> buffer,
-                 Const<bool> is_owner);
+    RingBufferView(Ref<Span<u8>> buffer, const bool is_owner);
+    RingBufferView(ControlBlock *control_block, Ref<Span<u8>> buffer, const bool is_owner);
 
 private:
     Mut<u8 *> m_data_ptr{};
@@ -80,185 +87,190 @@ private:
     Mut<ControlBlock *> m_control_block{};
 
 private:
-  auto write_wrapped(Const<u32> offset, Const<const void *> data,
-                     Const<u32> size) -> void;
-  auto read_wrapped(Const<u32> offset, Const<void *> out_data, Const<u32> size)
-      -> void;
-};
+    auto write_wrapped(const u32 offset, const void *data, const u32 size) -> void;
+    auto read_wrapped(const u32 offset, void *out_data, const u32 size) -> void;
+  };
 
-inline auto RingBufferView::default_instance() -> RingBufferView {
+  inline auto RingBufferView::default_instance() -> RingBufferView
+  {
     return RingBufferView(nullptr, {}, false);
-}
+  }
 
-inline auto RingBufferView::create(Ref<Span<u8>> buffer, Const<bool> is_owner)
-    -> Result<RingBufferView> {
-  if (buffer.size() <= sizeof(ControlBlock)) {
+  inline auto RingBufferView::create(Ref<Span<u8>> buffer, const bool is_owner) -> Result<RingBufferView>
+  {
+    if (buffer.size() <= sizeof(ControlBlock))
+    {
       return fail("Buffer too small for ControlBlock");
     }
 
-  if (!is_owner) {
-    Const<ControlBlock *> cb = reinterpret_cast<ControlBlock *>(buffer.data());
-    Const<u32> capacity =
-        static_cast<u32>(buffer.size()) - sizeof(ControlBlock);
-    if (cb->consumer.capacity != capacity) {
+    if (!is_owner)
+    {
+      const ControlBlock *cb = reinterpret_cast<ControlBlock *>(buffer.data());
+      const u32 capacity = static_cast<u32>(buffer.size()) - sizeof(ControlBlock);
+      if (cb->consumer.capacity != capacity)
+      {
         return fail("Capacity mismatch");
       }
     }
 
     return RingBufferView(buffer, is_owner);
-}
+  }
 
-inline auto RingBufferView::create(Const<ControlBlock *> control_block,
-                                   Ref<Span<u8>> buffer, Const<bool> is_owner)
-    -> Result<RingBufferView> {
-  if (control_block == nullptr) {
+  inline auto RingBufferView::create(ControlBlock *control_block, Ref<Span<u8>> buffer, const bool is_owner)
+      -> Result<RingBufferView>
+  {
+    if (control_block == nullptr)
+    {
       return fail("ControlBlock is null");
     }
-  if (buffer.empty()) {
+    if (buffer.empty())
+    {
       return fail("Buffer is empty");
     }
 
     return RingBufferView(control_block, buffer, is_owner);
-}
+  }
 
-inline RingBufferView::RingBufferView(Ref<Span<u8>> buffer,
-                                      Const<bool> is_owner) {
+  inline RingBufferView::RingBufferView(Ref<Span<u8>> buffer, const bool is_owner)
+  {
     m_control_block = reinterpret_cast<ControlBlock *>(buffer.data());
     m_data_ptr = buffer.data() + sizeof(ControlBlock);
 
     m_capacity = static_cast<u32>(buffer.size()) - sizeof(ControlBlock);
 
-  if (is_owner) {
+    if (is_owner)
+    {
       m_control_block->consumer.capacity = m_capacity;
       m_control_block->producer.write_offset.store(0, std::memory_order_release);
       m_control_block->consumer.read_offset.store(0, std::memory_order_release);
     }
-}
+  }
 
-inline RingBufferView::RingBufferView(Const<ControlBlock *> control_block,
-                                      Ref<Span<u8>> buffer,
-                                      Const<bool> is_owner) {
+  inline RingBufferView::RingBufferView(ControlBlock *control_block, Ref<Span<u8>> buffer, const bool is_owner)
+  {
     m_control_block = control_block;
     m_data_ptr = buffer.data();
     m_capacity = static_cast<u32>(buffer.size());
 
-  if (is_owner) {
+    if (is_owner)
+    {
       m_control_block->consumer.capacity = m_capacity;
       m_control_block->producer.write_offset.store(0, std::memory_order_release);
       m_control_block->consumer.read_offset.store(0, std::memory_order_release);
     }
-}
+  }
 
-inline auto RingBufferView::pop(MutRef<PacketHeader> out_header,
-                                Ref<Span<u8>> out_buffer)
-    -> Result<Option<usize>> {
-  Const<u32> write =
-      m_control_block->producer.write_offset.load(std::memory_order_acquire);
-  Const<u32> read =
-      m_control_block->consumer.read_offset.load(std::memory_order_relaxed);
-  Const<u32> cap = m_capacity;
+  inline auto RingBufferView::pop(MutRef<PacketHeader> out_header, Ref<Span<u8>> out_buffer) -> Result<Option<usize>>
+  {
+    const u32 write = m_control_block->producer.write_offset.load(std::memory_order_acquire);
+    const u32 read = m_control_block->consumer.read_offset.load(std::memory_order_relaxed);
+    const u32 cap = m_capacity;
 
-  if (read == write) {
+    if (read == write)
+    {
       return std::nullopt;
     }
 
     read_wrapped(read, &out_header, sizeof(PacketHeader));
 
-  if (out_header.payload_size > out_buffer.size()) {
-    return fail("Buffer too small: needed {}, provided {}",
-                out_header.payload_size, out_buffer.size());
+    if (out_header.payload_size > out_buffer.size())
+    {
+      return fail("Buffer too small: needed {}, provided {}", out_header.payload_size, out_buffer.size());
     }
 
-  if (out_header.payload_size > 0) {
-    Const<u32> data_read_offset = (read + sizeof(PacketHeader)) % cap;
+    if (out_header.payload_size > 0)
+    {
+      const u32 data_read_offset = (read + sizeof(PacketHeader)) % cap;
       read_wrapped(data_read_offset, out_buffer.data(), out_header.payload_size);
     }
 
-  Const<u32> new_read_offset =
-      (read + sizeof(PacketHeader) + out_header.payload_size) % cap;
-  m_control_block->consumer.read_offset.store(new_read_offset,
-                                              std::memory_order_release);
+    const u32 new_read_offset = (read + sizeof(PacketHeader) + out_header.payload_size) % cap;
+    m_control_block->consumer.read_offset.store(new_read_offset, std::memory_order_release);
 
     return std::make_optional(static_cast<usize>(out_header.payload_size));
-}
+  }
 
-inline auto RingBufferView::push(Const<u16> packet_id, Ref<Span<const u8>> data)
-    -> Result<void> {
-  if (data.size() > std::numeric_limits<u16>::max()) {
+  inline auto RingBufferView::push(const u16 packet_id, Ref<Span<const u8>> data) -> Result<void>
+  {
+    if (data.size() > std::numeric_limits<u16>::max())
+    {
       return fail("Data size exceeds u16 limit");
     }
 
-  Const<u32> total_size = sizeof(PacketHeader) + static_cast<u32>(data.size());
+    const u32 total_size = sizeof(PacketHeader) + static_cast<u32>(data.size());
 
-  Const<u32> read =
-      m_control_block->consumer.read_offset.load(std::memory_order_acquire);
-  Const<u32> write =
-      m_control_block->producer.write_offset.load(std::memory_order_relaxed);
-  Const<u32> cap = m_capacity;
+    const u32 read = m_control_block->consumer.read_offset.load(std::memory_order_acquire);
+    const u32 write = m_control_block->producer.write_offset.load(std::memory_order_relaxed);
+    const u32 cap = m_capacity;
 
-  Const<u32> free_space =
-      (read <= write) ? (m_capacity - write) + read : (read - write);
+    const u32 free_space = (read <= write) ? (m_capacity - write) + read : (read - write);
 
     // Leave 1 byte empty (prevent ambiguities)
-  if (free_space <= total_size) {
+    if (free_space <= total_size)
+    {
       return fail("RingBuffer full");
     }
 
-  Const<PacketHeader> header{packet_id, static_cast<u16>(data.size())};
+    const PacketHeader header{packet_id, static_cast<u16>(data.size())};
     write_wrapped(write, &header, sizeof(PacketHeader));
 
-  Const<u32> data_write_offset = (write + sizeof(PacketHeader)) % cap;
+    const u32 data_write_offset = (write + sizeof(PacketHeader)) % cap;
 
-  if (!data.empty()) {
-    write_wrapped(data_write_offset, data.data(),
-                  static_cast<u32>(data.size()));
+    if (!data.empty())
+    {
+      write_wrapped(data_write_offset, data.data(), static_cast<u32>(data.size()));
     }
 
-  Const<u32> new_write_offset = (data_write_offset + data.size()) % cap;
-  m_control_block->producer.write_offset.store(new_write_offset,
-                                               std::memory_order_release);
+    const u32 new_write_offset = (data_write_offset + data.size()) % cap;
+    m_control_block->producer.write_offset.store(new_write_offset, std::memory_order_release);
 
     return {};
-}
+  }
 
-inline auto RingBufferView::get_control_block() -> ControlBlock * {
+  inline auto RingBufferView::get_control_block() -> ControlBlock *
+  {
     return m_control_block;
-}
+  }
 
-inline auto RingBufferView::write_wrapped(Const<u32> offset,
-                                          Const<const void *> data,
-                                          Const<u32> size) -> void {
-  if (offset + size <= m_capacity) {
+  inline auto RingBufferView::write_wrapped(const u32 offset, const void *data, const u32 size) -> void
+  {
+    if (offset + size <= m_capacity)
+    {
       std::memcpy(m_data_ptr + offset, data, size);
-  } else {
-    Const<u32> first_chunk = m_capacity - offset;
-    Const<u32> second_chunk = size - first_chunk;
+    }
+    else
+    {
+      const u32 first_chunk = m_capacity - offset;
+      const u32 second_chunk = size - first_chunk;
 
-    Const<const u8 *> src = static_cast<const u8 *>(data);
+      const u8 *src = static_cast<const u8 *>(data);
 
       std::memcpy(m_data_ptr + offset, src, first_chunk);
       std::memcpy(m_data_ptr, src + first_chunk, second_chunk);
     }
-}
+  }
 
-inline auto RingBufferView::read_wrapped(Const<u32> offset,
-                                         Const<void *> out_data,
-                                         Const<u32> size) -> void {
-  if (offset + size <= m_capacity) {
+  inline auto RingBufferView::read_wrapped(const u32 offset, void *out_data, const u32 size) -> void
+  {
+    if (offset + size <= m_capacity)
+    {
       std::memcpy(out_data, m_data_ptr + offset, size);
-  } else {
-    Const<u32> first_chunk = m_capacity - offset;
-    Const<u32> second_chunk = size - first_chunk;
+    }
+    else
+    {
+      const u32 first_chunk = m_capacity - offset;
+      const u32 second_chunk = size - first_chunk;
 
-    Const<u8 *> dst = static_cast<u8 *>(out_data);
+      u8 *dst = static_cast<u8 *>(out_data);
 
       std::memcpy(dst, m_data_ptr + offset, first_chunk);
       std::memcpy(dst + first_chunk, m_data_ptr, second_chunk);
     }
-}
+  }
 
-[[nodiscard]] inline auto RingBufferView::is_valid() const -> bool {
+  [[nodiscard]] inline auto RingBufferView::is_valid() const -> bool
+  {
     return m_control_block && m_data_ptr && m_capacity;
-}
+  }
 
 } // namespace IACore

Src/IACore/inc/IACore/AsyncOps.hpp

@@ -20,30 +20,35 @@
 #include <functional>
 #include <stop_token>
 
-namespace IACore {
-class AsyncOps {
+namespace IACore
+{
+  class AsyncOps
+  {
 public:
     using TaskTag = u64;
     using WorkerId = u16;
 
-  static constexpr Const<WorkerId> MAIN_THREAD_WORKER_ID = 0;
+    static constexpr const WorkerId MAIN_THREAD_WORKER_ID = 0;
 
-  enum class Priority : u8 { High, Normal };
+    enum class Priority : u8
+    {
+      High,
+      Normal
+    };
 
-  struct Schedule {
+    struct Schedule
+    {
       Mut<std::atomic<i32>> counter{0};
     };
 
 public:
-  static auto initialize_scheduler(Const<u8> worker_count = 0) -> Result<void>;
+    static auto initialize_scheduler(const u8 worker_count = 0) -> Result<void>;
     static auto terminate_scheduler() -> void;
 
-  static auto schedule_task(Mut<std::function<void(Const<WorkerId>)>> task,
-                            Const<TaskTag> tag, Mut<Schedule *> schedule,
-                            Const<Priority> priority = Priority::Normal)
-      -> void;
+    static auto schedule_task(Mut<std::function<void(const WorkerId)>> task, const TaskTag tag,
+                              Mut<Schedule *> schedule, const Priority priority = Priority::Normal) -> void;
 
-  static auto cancel_tasks_of_tag(Const<TaskTag> tag) -> void;
+    static auto cancel_tasks_of_tag(const TaskTag tag) -> void;
 
     static auto wait_for_schedule_completion(Mut<Schedule *> schedule) -> void;
 
@@ -52,14 +57,14 @@ public:
     IA_NODISCARD static auto get_worker_count() -> WorkerId;
 
 private:
-  struct ScheduledTask {
+    struct ScheduledTask
+    {
       Mut<TaskTag> tag{};
       Mut<Schedule *> schedule_handle{};
-    Mut<std::function<void(Const<WorkerId>)>> task{};
+      Mut<std::function<void(const WorkerId)>> task{};
     };
 
-  static auto schedule_worker_loop(Mut<std::stop_token> stop_token,
-                                   Const<WorkerId> worker_id) -> void;
+    static auto schedule_worker_loop(Mut<std::stop_token> stop_token, const WorkerId worker_id) -> void;
 
 private:
     static Mut<std::mutex> s_queue_mutex;
@@ -67,5 +72,5 @@ private:
     static Mut<Vec<std::jthread>> s_schedule_workers;
     static Mut<std::deque<ScheduledTask>> s_high_priority_queue;
     static Mut<std::deque<ScheduledTask>> s_normal_priority_queue;
-};
+  };
 } // namespace IACore

Src/IACore/inc/IACore/CLI.hpp

@@ -17,8 +17,10 @@
 
 #include <IACore/PCH.hpp>
 
-namespace IACore {
-class CLIParser {
+namespace IACore
+{
+  class CLIParser
+  {
     /*
      * PLEASE READ
      *
@@ -28,28 +30,33 @@ class CLIParser {
      */
 
 public:
-  CLIParser(Const<Span<Const<String>>> args);
+    CLIParser(const Span<const String> args);
     ~CLIParser() = default;
 
 public:
-  IA_NODISCARD auto remaining() const -> bool {
+    IA_NODISCARD auto remaining() const -> bool
+    {
       return m_current_arg < m_arg_list.end();
     }
 
-  IA_NODISCARD auto peek() const -> StringView {
+    IA_NODISCARD auto peek() const -> StringView
+    {
       if (!remaining())
         return "";
       return *m_current_arg;
     }
 
-  auto next() -> StringView {
+    auto next() -> StringView
+    {
       if (!remaining())
         return "";
       return *m_current_arg++;
     }
 
-  auto consume(Ref<StringView> expected) -> bool {
-    if (peek() == expected) {
+    auto consume(Ref<StringView> expected) -> bool
+    {
+      if (peek() == expected)
+      {
         next();
         return true;
       }
@@ -57,7 +64,7 @@ public:
     }
 
 private:
-  Const<Span<Const<String>>> m_arg_list;
-  Mut<Span<Const<String>>::const_iterator> m_current_arg;
-};
+    const Span<const String> m_arg_list;
+    Mut<Span<const String>::const_iterator> m_current_arg;
+  };
 } // namespace IACore

Src/IACore/inc/IACore/DataOps.hpp

@@ -17,31 +17,36 @@
 
 #include <IACore/PCH.hpp>
 
-namespace IACore {
-class DataOps {
+namespace IACore
+{
+  class DataOps
+  {
 public:
-  enum class CompressionType { None, Gzip, Zlib };
+    enum class CompressionType
+    {
+      None,
+      Gzip,
+      Zlib
+    };
 
 public:
     static auto hash_fnv1a(Ref<String> string) -> u32;
-  static auto hash_fnv1a(Ref<Span<Const<u8>>> data) -> u32;
+    static auto hash_fnv1a(Ref<Span<const u8>> data) -> u32;
 
-  static auto hash_xxhash(Ref<String> string, Const<u32> seed = 0) -> u32;
-  static auto hash_xxhash(Ref<Span<Const<u8>>> data, Const<u32> seed = 0)
-      -> u32;
+    static auto hash_xxhash(Ref<String> string, const u32 seed = 0) -> u32;
+    static auto hash_xxhash(Ref<Span<const u8>> data, const u32 seed = 0) -> u32;
 
-  static auto crc32(Ref<Span<Const<u8>>> data) -> u32;
+    static auto crc32(Ref<Span<const u8>> data) -> u32;
 
-  static auto detect_compression(Const<Span<Const<u8>>> data)
-      -> CompressionType;
+    static auto detect_compression(const Span<const u8> data) -> CompressionType;
 
-  static auto gzip_inflate(Ref<Span<Const<u8>>> data) -> Result<Vec<u8>>;
-  static auto gzip_deflate(Ref<Span<Const<u8>>> data) -> Result<Vec<u8>>;
+    static auto gzip_inflate(Ref<Span<const u8>> data) -> Result<Vec<u8>>;
+    static auto gzip_deflate(Ref<Span<const u8>> data) -> Result<Vec<u8>>;
 
-  static auto zlib_inflate(Ref<Span<Const<u8>>> data) -> Result<Vec<u8>>;
-  static auto zlib_deflate(Ref<Span<Const<u8>>> data) -> Result<Vec<u8>>;
+    static auto zlib_inflate(Ref<Span<const u8>> data) -> Result<Vec<u8>>;
+    static auto zlib_deflate(Ref<Span<const u8>> data) -> Result<Vec<u8>>;
 
-  static auto zstd_inflate(Ref<Span<Const<u8>>> data) -> Result<Vec<u8>>;
-  static auto zstd_deflate(Ref<Span<Const<u8>>> data) -> Result<Vec<u8>>;
-};
+    static auto zstd_inflate(Ref<Span<const u8>> data) -> Result<Vec<u8>>;
+    static auto zstd_deflate(Ref<Span<const u8>> data) -> Result<Vec<u8>>;
+  };
 } // namespace IACore

Src/IACore/inc/IACore/DynamicLib.hpp

@@ -18,19 +18,22 @@
 #include <IACore/PCH.hpp>
 
 #if !IA_PLATFORM_WINDOWS
-#include <dlfcn.h>
+#  include <dlfcn.h>
 #endif
 
-namespace IACore {
+namespace IACore
+{
 
-class DynamicLib {
+  class DynamicLib
+  {
 public:
-  IA_NODISCARD static auto load(Ref<String> search_path, Ref<String> name)
-      -> Result<DynamicLib> {
+    IA_NODISCARD static auto load(Ref<String> search_path, Ref<String> name) -> Result<DynamicLib>
+    {
       namespace fs = std::filesystem;
       Mut<Path> full_path = fs::path(search_path) / name;
 
-    if (!full_path.has_extension()) {
+      if (!full_path.has_extension())
+      {
 #if IA_PLATFORM_WINDOWS
         full_path += ".dll";
 #elif IA_PLATFORM_APPLE
@@ -43,15 +46,17 @@ public:
       Mut<DynamicLib> lib;
 
 #if IA_PLATFORM_WINDOWS
-    Const<HMODULE> h = LoadLibraryA(full_path.string().c_str());
-    if (!h) {
+      const HMODULE h = LoadLibraryA(full_path.string().c_str());
+      if (!h)
+      {
         return fail(get_windows_error());
       }
       lib.m_handle = static_cast<void *>(h);
 #else
       Mut<void *> h = dlopen(full_path.c_str(), RTLD_LAZY | RTLD_LOCAL);
-    if (!h) {
-      Const<char *> err = dlerror();
+      if (!h)
+      {
+        const char *err = dlerror();
         return fail(err ? err : "Unknown dlopen error");
       }
       lib.m_handle = h;
@@ -62,12 +67,15 @@ public:
 
     DynamicLib() = default;
 
-  DynamicLib(ForwardRef<DynamicLib> other) noexcept : m_handle(other.m_handle) {
+    DynamicLib(ForwardRef<DynamicLib> other) noexcept : m_handle(other.m_handle)
+    {
       other.m_handle = nullptr;
     }
 
-  auto operator=(ForwardRef<DynamicLib> other) noexcept -> MutRef<DynamicLib> {
-    if (this != &other) {
+    auto operator=(ForwardRef<DynamicLib> other) noexcept -> MutRef<DynamicLib>
+    {
+      if (this != &other)
+      {
         unload();
         m_handle = other.m_handle;
         other.m_handle = nullptr;
@@ -78,25 +86,31 @@ public:
     DynamicLib(Ref<DynamicLib>) = delete;
     auto operator=(Ref<DynamicLib>) -> MutRef<DynamicLib> = delete;
 
-  ~DynamicLib() { unload(); }
+    ~DynamicLib()
+    {
+      unload();
+    }
 
-  IA_NODISCARD auto get_symbol(Ref<String> name) const -> Result<void *> {
-    if (!m_handle) {
+    IA_NODISCARD auto get_symbol(Ref<String> name) const -> Result<void *>
+    {
+      if (!m_handle)
+      {
         return fail("Library not loaded");
       }
 
       Mut<void *> sym = nullptr;
 
 #if IA_PLATFORM_WINDOWS
-    sym = static_cast<void *>(
-        GetProcAddress(static_cast<HMODULE>(m_handle), name.c_str()));
-    if (!sym) {
+      sym = static_cast<void *>(GetProcAddress(static_cast<HMODULE>(m_handle), name.c_str()));
+      if (!sym)
+      {
         return fail(get_windows_error());
       }
 #else
       dlerror(); // Clear prev errors
       sym = dlsym(m_handle, name.c_str());
-    if (Const<char *> err = dlerror()) {
+      if (const char *err = dlerror())
+      {
         return fail(err);
       }
 #endif
@@ -104,15 +118,17 @@ public:
       return sym;
     }
 
-  template <typename FuncT>
-  IA_NODISCARD auto get_function(Ref<String> name) const -> Result<FuncT> {
+    template<typename FuncT> IA_NODISCARD auto get_function(Ref<String> name) const -> Result<FuncT>
+    {
       Mut<void *> sym = nullptr;
       sym = AU_TRY(get_symbol(name));
       return reinterpret_cast<FuncT>(sym);
     }
 
-  void unload() {
-    if (m_handle) {
+    void unload()
+    {
+      if (m_handle)
+      {
 #if IA_PLATFORM_WINDOWS
         FreeLibrary(static_cast<HMODULE>(m_handle));
 #else
@@ -122,30 +138,33 @@ public:
       }
     }
 
-  IA_NODISCARD auto is_loaded() const -> bool { return m_handle != nullptr; }
+    IA_NODISCARD auto is_loaded() const -> bool
+    {
+      return m_handle != nullptr;
+    }
 
 private:
     Mut<void *> m_handle = nullptr;
 
 #if IA_PLATFORM_WINDOWS
-  static auto get_windows_error() -> String {
-    Const<DWORD> error_id = ::GetLastError();
-    if (error_id == 0) {
+    static auto get_windows_error() -> String
+    {
+      const DWORD error_id = ::GetLastError();
+      if (error_id == 0)
+      {
         return String();
       }
 
       Mut<LPSTR> message_buffer = nullptr;
-    Const<usize> size = FormatMessageA(
-        FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
-            FORMAT_MESSAGE_IGNORE_INSERTS,
-        nullptr, error_id, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-        reinterpret_cast<LPSTR>(&message_buffer), 0, nullptr);
+      const usize size = FormatMessageA(
+          FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, nullptr,
+          error_id, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), reinterpret_cast<LPSTR>(&message_buffer), 0, nullptr);
 
-    Const<String> message(message_buffer, size);
+      const String message(message_buffer, size);
       LocalFree(message_buffer);
       return "Win32 Error: " + message;
     }
 #endif
-};
+  };
 
 } // namespace IACore

Src/IACore/inc/IACore/Environment.hpp

@@ -18,26 +18,29 @@
 #include <IACore/PCH.hpp>
 #include <cstdlib>
 
-namespace IACore {
+namespace IACore
+{
 
-class Environment {
+  class Environment
+  {
 public:
-  static auto find(Ref<String> name) -> Option<String> {
+    static auto find(Ref<String> name) -> Option<String>
+    {
 #if IA_PLATFORM_WINDOWS
-    Const<u32> buffer_size =
-        static_cast<u32>(GetEnvironmentVariableA(name.c_str(), nullptr, 0));
+      const u32 buffer_size = static_cast<u32>(GetEnvironmentVariableA(name.c_str(), nullptr, 0));
 
-    if (buffer_size == 0) {
+      if (buffer_size == 0)
+      {
         return std::nullopt;
       }
 
       Mut<String> result;
       result.resize(buffer_size);
 
-    Const<u32> actual_size = static_cast<u32>(
-        GetEnvironmentVariableA(name.c_str(), result.data(), buffer_size));
+      const u32 actual_size = static_cast<u32>(GetEnvironmentVariableA(name.c_str(), result.data(), buffer_size));
 
-    if (actual_size == 0 || actual_size > buffer_size) {
+      if (actual_size == 0 || actual_size > buffer_size)
+      {
         return std::nullopt;
       }
 
@@ -45,55 +48,66 @@ public:
       return result;
 
 #else
-    Const<char *> val = std::getenv(name.c_str());
-    if (val == nullptr) {
+      const char *val = std::getenv(name.c_str());
+      if (val == nullptr)
+      {
         return std::nullopt;
       }
       return String(val);
 #endif
     }
 
-  static auto get(Ref<String> name, Ref<String> default_value = "") -> String {
+    static auto get(Ref<String> name, Ref<String> default_value = "") -> String
+    {
       return find(name).value_or(default_value);
     }
 
-  static auto set(Ref<String> name, Ref<String> value) -> Result<void> {
-    if (name.empty()) {
+    static auto set(Ref<String> name, Ref<String> value) -> Result<void>
+    {
+      if (name.empty())
+      {
         return fail("Environment variable name cannot be empty");
       }
 
 #if IA_PLATFORM_WINDOWS
-    if (SetEnvironmentVariableA(name.c_str(), value.c_str()) == 0) {
+      if (SetEnvironmentVariableA(name.c_str(), value.c_str()) == 0)
+      {
         return fail("Failed to set environment variable: {}", name);
       }
 #else
-    if (setenv(name.c_str(), value.c_str(), 1) != 0) {
+      if (setenv(name.c_str(), value.c_str(), 1) != 0)
+      {
         return fail("Failed to set environment variable: {}", name);
       }
 #endif
       return {};
     }
 
-  static auto unset(Ref<String> name) -> Result<void> {
-    if (name.empty()) {
+    static auto unset(Ref<String> name) -> Result<void>
+    {
+      if (name.empty())
+      {
         return fail("Environment variable name cannot be empty");
       }
 
 #if IA_PLATFORM_WINDOWS
-    if (SetEnvironmentVariableA(name.c_str(), nullptr) == 0) {
+      if (SetEnvironmentVariableA(name.c_str(), nullptr) == 0)
+      {
         return fail("Failed to unset environment variable: {}", name);
       }
 #else
-    if (unsetenv(name.c_str()) != 0) {
+      if (unsetenv(name.c_str()) != 0)
+      {
         return fail("Failed to unset environment variable: {}", name);
       }
 #endif
       return {};
     }
 
-  static auto exists(Ref<String> name) -> bool {
+    static auto exists(Ref<String> name) -> bool
+    {
       return find(name).has_value();
     }
-};
+  };
 
 } // namespace IACore

Src/IACore/inc/IACore/FileOps.hpp

@@ -22,26 +22,29 @@
 
 #if IA_PLATFORM_WINDOWS
 using NativeFileHandle = HANDLE;
-static constexpr au::Const<NativeFileHandle> INVALID_FILE_HANDLE =
-    INVALID_HANDLE_VALUE;
+static const NativeFileHandle INVALID_FILE_HANDLE = INVALID_HANDLE_VALUE;
 #else
 using NativeFileHandle = int;
-static constexpr au::Const<NativeFileHandle> INVALID_FILE_HANDLE = -1;
+static const NativeFileHandle INVALID_FILE_HANDLE = -1;
 #endif
 
-namespace IACore {
+namespace IACore
+{
 
-class FileOps {
+  class FileOps
+  {
 public:
     class MemoryMappedRegion;
 
-  enum class FileAccess : u8 {
+    enum class FileAccess : u8
+    {
       Read,     // Read-only
       Write,    // Write-only
       ReadWrite // Read and Write
     };
 
-  enum class FileMode : u8 {
+    enum class FileMode : u8
+    {
       OpenExisting,    // Fails if file doesn't exist
       OpenAlways,      // Opens if exists, creates if not
       CreateNew,       // Fails if file exists
@@ -49,49 +52,43 @@ public:
       TruncateExisting // Opens existing and clears it
     };
 
-  static auto native_open_file(Ref<Path> path, Const<FileAccess> access,
-                               Const<FileMode> mode,
-                               Const<u32> permissions = 0644)
-      -> Result<NativeFileHandle>;
+    static auto native_open_file(Ref<Path> path, const FileAccess access, const FileMode mode,
+                                 const u32 permissions = 0644) -> Result<NativeFileHandle>;
 
-  static auto native_close_file(Const<NativeFileHandle> handle) -> void;
+    static auto native_close_file(const NativeFileHandle handle) -> void;
 
 public:
     static auto normalize_executable_path(Ref<Path> path) -> Path;
 
 public:
-  static auto unmap_file(Const<const u8 *> mapped_ptr) -> void;
+    static auto unmap_file(const u8 *mapped_ptr) -> void;
 
-  static auto map_file(Ref<Path> path, MutRef<usize> size)
-      -> Result<const u8 *>;
+    static auto map_file(Ref<Path> path, MutRef<usize> size) -> Result<const u8 *>;
 
     // @param `is_owner` true to allocate/truncate. false to just open.
-  static auto map_shared_memory(Ref<String> name, Const<usize> size,
-                                Const<bool> is_owner) -> Result<u8 *>;
+    static auto map_shared_memory(Ref<String> name, const usize size, const bool is_owner) -> Result<u8 *>;
 
     static auto unlink_shared_memory(Ref<String> name) -> void;
 
     static auto stream_from_file(Ref<Path> path) -> Result<StreamReader>;
 
-  static auto stream_to_file(Ref<Path> path, Const<bool> overwrite = false)
-      -> Result<StreamWriter>;
+    static auto stream_to_file(Ref<Path> path, const bool overwrite = false) -> Result<StreamWriter>;
 
     static auto read_text_file(Ref<Path> path) -> Result<String>;
 
     static auto read_binary_file(Ref<Path> path) -> Result<Vec<u8>>;
 
-  static auto write_text_file(Ref<Path> path, Ref<String> contents,
-                              Const<bool> overwrite = false) -> Result<usize>;
+    static auto write_text_file(Ref<Path> path, Ref<String> contents, const bool overwrite = false) -> Result<usize>;
 
-  static auto write_binary_file(Ref<Path> path, Const<Span<const u8>> contents,
-                                Const<bool> overwrite = false) -> Result<usize>;
+    static auto write_binary_file(Ref<Path> path, const Span<const u8> contents, const bool overwrite = false)
+        -> Result<usize>;
 
 private:
-  static Mut<HashMap<const u8 *, std::tuple<void *, void *, void *>>>
-      s_mapped_files;
-};
+    static Mut<HashMap<const u8 *, std::tuple<void *, void *, void *>>> s_mapped_files;
+  };
 
-class FileOps::MemoryMappedRegion {
+  class FileOps::MemoryMappedRegion
+  {
 public:
     MemoryMappedRegion() = default;
     ~MemoryMappedRegion();
@@ -100,20 +97,27 @@ public:
     auto operator=(Ref<MemoryMappedRegion>) -> MemoryMappedRegion & = delete;
 
     MemoryMappedRegion(ForwardRef<MemoryMappedRegion> other) noexcept;
-  auto operator=(ForwardRef<MemoryMappedRegion> other) noexcept
-      -> MemoryMappedRegion &;
+    auto operator=(ForwardRef<MemoryMappedRegion> other) noexcept -> MemoryMappedRegion &;
 
-  auto map(Const<NativeFileHandle> handle, Const<u64> offset, Const<usize> size)
-      -> Result<void>;
+    auto map(const NativeFileHandle handle, const u64 offset, const usize size) -> Result<void>;
 
     auto unmap() -> void;
     auto flush() -> void;
 
-  [[nodiscard]] auto get_ptr() const -> u8 * { return m_ptr; }
+    [[nodiscard]] auto get_ptr() const -> u8 *
+    {
+      return m_ptr;
+    }
 
-  [[nodiscard]] auto get_size() const -> usize { return m_size; }
+    [[nodiscard]] auto get_size() const -> usize
+    {
+      return m_size;
+    }
 
-  [[nodiscard]] auto is_valid() const -> bool { return m_ptr != nullptr; }
+    [[nodiscard]] auto is_valid() const -> bool
+    {
+      return m_ptr != nullptr;
+    }
 
 private:
     Mut<u8 *> m_ptr = nullptr;
@@ -122,6 +126,6 @@ private:
 #if IA_PLATFORM_WINDOWS
     Mut<HANDLE> m_map_handle = NULL;
 #endif
-};
+  };
 
 } // namespace IACore

Src/IACore/inc/IACore/Http/Client.hpp

@@ -18,8 +18,10 @@
 #include <IACore/Http/Common.hpp>
 #include <IACore/JSON.hpp>
 
-namespace IACore {
-class HttpClient : public HttpCommon {
+namespace IACore
+{
+  class HttpClient : public HttpCommon
+  {
 public:
     static auto create(Ref<String> host) -> Result<Box<HttpClient>>;
 
@@ -31,28 +33,26 @@ public:
     auto operator=(Ref<HttpClient>) -> MutRef<HttpClient> = delete;
 
 public:
-  auto raw_get(Ref<String> path, Span<Const<Header>> headers,
-               Const<char> *default_content_type =
-                   "application/x-www-form-urlencoded") -> Result<String>;
+    auto raw_get(Ref<String> path, Span<const Header> headers,
+                 const char *default_content_type = "application/x-www-form-urlencoded") -> Result<String>;
 
-  auto raw_post(Ref<String> path, Span<Const<Header>> headers, Ref<String> body,
-                Const<char> *default_content_type =
-                    "application/x-www-form-urlencoded") -> Result<String>;
+    auto raw_post(Ref<String> path, Span<const Header> headers, Ref<String> body,
+                  const char *default_content_type = "application/x-www-form-urlencoded") -> Result<String>;
 
-  template <typename ResponseType>
-  auto json_get(Ref<String> path, Span<Const<Header>> headers)
-      -> Result<ResponseType>;
+    template<typename ResponseType> auto json_get(Ref<String> path, Span<const Header> headers) -> Result<ResponseType>;
 
-  template <typename PayloadType, typename ResponseType>
-  auto json_post(Ref<String> path, Span<Const<Header>> headers,
-                 Ref<PayloadType> body) -> Result<ResponseType>;
+    template<typename PayloadType, typename ResponseType>
+    auto json_post(Ref<String> path, Span<const Header> headers, Ref<PayloadType> body) -> Result<ResponseType>;
 
     // Certificate verification is enabled by default
     auto enable_certificate_verification() -> void;
     auto disable_certificate_verification() -> void;
 
 public:
-  auto last_response_code() -> EResponseCode { return m_last_response_code; }
+    auto last_response_code() -> EResponseCode
+    {
+      return m_last_response_code;
+    }
 
 private:
     Mut<httplib::Client> m_client;
@@ -63,33 +63,32 @@ private:
 
 protected:
     explicit HttpClient(ForwardRef<httplib::Client> client);
-};
+  };
 
-template <typename ResponseType>
-auto HttpClient::json_get(Ref<String> path, Span<Const<Header>> headers)
-    -> Result<ResponseType> {
-  Const<String> raw_response =
-      AU_TRY(raw_get(path, headers, "application/json"));
+  template<typename ResponseType>
+  auto HttpClient::json_get(Ref<String> path, Span<const Header> headers) -> Result<ResponseType>
+  {
+    const String raw_response = AU_TRY(raw_get(path, headers, "application/json"));
 
-  if (last_response_code() != EResponseCode::OK) {
-    return fail("Server responded with code {}",
-                static_cast<i32>(last_response_code()));
+    if (last_response_code() != EResponseCode::OK)
+    {
+      return fail("Server responded with code {}", static_cast<i32>(last_response_code()));
     }
     return Json::parse_to_struct<ResponseType>(raw_response);
-}
+  }
 
-template <typename PayloadType, typename ResponseType>
-auto HttpClient::json_post(Ref<String> path, Span<Const<Header>> headers,
-                           Ref<PayloadType> body) -> Result<ResponseType> {
-  Const<String> encoded_body = AU_TRY(Json::encode_struct(body));
+  template<typename PayloadType, typename ResponseType>
+  auto HttpClient::json_post(Ref<String> path, Span<const Header> headers, Ref<PayloadType> body)
+      -> Result<ResponseType>
+  {
+    const String encoded_body = AU_TRY(Json::encode_struct(body));
 
-  Const<String> raw_response =
-      AU_TRY(raw_post(path, headers, encoded_body, "application/json"));
+    const String raw_response = AU_TRY(raw_post(path, headers, encoded_body, "application/json"));
 
-  if (last_response_code() != EResponseCode::OK) {
-    return fail("Server responded with code {}",
-                static_cast<i32>(last_response_code()));
+    if (last_response_code() != EResponseCode::OK)
+    {
+      return fail("Server responded with code {}", static_cast<i32>(last_response_code()));
     }
     return Json::parse_to_struct<ResponseType>(raw_response);
-}
+  }
 } // namespace IACore

Src/IACore/inc/IACore/Http/Common.hpp

@@ -19,10 +19,13 @@
 
 #include <httplib.h>
 
-namespace IACore {
-class HttpCommon {
+namespace IACore
+{
+  class HttpCommon
+  {
 public:
-  enum class EHeaderType {
+    enum class EHeaderType
+    {
       ACCEPT,
       ACCEPT_CHARSET,
       ACCEPT_ENCODING,
@@ -51,7 +54,8 @@ public:
       WARNING
     };
 
-  enum class EResponseCode : i32 {
+    enum class EResponseCode : i32
+    {
       // 1xx Informational
       CONTINUE = 100,
       SWITCHING_PROTOCOLS = 101,
@@ -130,26 +134,24 @@ public:
     static auto url_encode(Ref<String> value) -> String;
     static auto url_decode(Ref<String> value) -> String;
 
-  static auto header_type_to_string(Const<EHeaderType> type) -> String;
+    static auto header_type_to_string(const EHeaderType type) -> String;
 
-  static inline auto create_header(Const<EHeaderType> key, Ref<String> value)
-      -> Header;
-  static inline auto create_header(Ref<String> key, Ref<String> value)
-      -> Header;
+    static inline auto create_header(const EHeaderType key, Ref<String> value) -> Header;
+    static inline auto create_header(Ref<String> key, Ref<String> value) -> Header;
 
-  static auto is_success_response_code(Const<EResponseCode> code) -> bool;
+    static auto is_success_response_code(const EResponseCode code) -> bool;
 
 protected:
     HttpCommon() = default;
-};
+  };
 
-auto HttpCommon::create_header(Const<EHeaderType> key, Ref<String> value)
-    -> HttpCommon::Header {
+  auto HttpCommon::create_header(const EHeaderType key, Ref<String> value) -> HttpCommon::Header
+  {
     return Header{header_type_to_string(key), value};
-}
+  }
 
-auto HttpCommon::create_header(Ref<String> key, Ref<String> value)
-    -> HttpCommon::Header {
+  auto HttpCommon::create_header(Ref<String> key, Ref<String> value) -> HttpCommon::Header
+  {
     return Header{key, value};
-}
+  }
 } // namespace IACore

Src/IACore/inc/IACore/Http/Server.hpp

@@ -19,10 +19,13 @@
 #include <IACore/JSON.hpp>
 #include <functional>
 
-namespace IACore {
-class HttpServer : public HttpCommon {
+namespace IACore
+{
+  class HttpServer : public HttpCommon
+  {
 public:
-  struct Request {
+    struct Request
+    {
       Mut<String> path;
       Mut<String> method;
       Mut<String> body;
@@ -39,14 +42,15 @@ public:
       [[nodiscard]] auto has_path_param(Ref<String> key) const -> bool;
     };
 
-  struct Response {
+    struct Response
+    {
       Mut<EResponseCode> code = EResponseCode::OK;
       Mut<String> body;
       Mut<HashMap<String, String>> headers;
       Mut<String> content_type = "text/plain";
 
       void set_content(Ref<String> content, Ref<String> type);
-    void set_status(Const<EResponseCode> status_code);
+      void set_status(const EResponseCode status_code);
       void add_header(Ref<String> key, Ref<String> value);
     };
 
@@ -62,25 +66,21 @@ public:
     auto operator=(HttpServer &&) -> HttpServer & = delete;
     auto operator=(const HttpServer &) -> HttpServer & = delete;
 
-  auto listen(Ref<String> host, Const<u32> port) -> Result<void>;
+    auto listen(Ref<String> host, const u32 port) -> Result<void>;
     void stop();
     auto is_running() const -> bool;
 
-  void get(Ref<String> pattern, Const<Handler> handler);
-  void post(Ref<String> pattern, Const<Handler> handler);
-  void put(Ref<String> pattern, Const<Handler> handler);
-  void del(Ref<String> pattern, Const<Handler> handler);
-  void options(Ref<String> pattern, Const<Handler> handler);
+    void get(Ref<String> pattern, const Handler handler);
+    void post(Ref<String> pattern, const Handler handler);
+    void put(Ref<String> pattern, const Handler handler);
+    void del(Ref<String> pattern, const Handler handler);
+    void options(Ref<String> pattern, const Handler handler);
 
-  template <typename ResponseType>
-  void
-  json_get(Ref<String> pattern,
-           Const<std::function<Result<ResponseType>(Ref<Request>)>> handler);
+    template<typename ResponseType>
+    void json_get(Ref<String> pattern, const std::function<Result<ResponseType(Ref<Request>)>> handler);
 
-  template <typename PayloadType, typename ResponseType>
-  void json_post(
-      Ref<String> pattern,
-      Const<std::function<Result<ResponseType>(Ref<PayloadType>)>> handler);
+    template<typename PayloadType, typename ResponseType>
+    void json_post(Ref<String> pattern, const std::function<Result<ResponseType(Ref<PayloadType>)>> handler);
 
 protected:
     HttpServer();
@@ -88,24 +88,24 @@ protected:
 private:
     Mut<httplib::Server> m_server;
 
-  void register_handler(Ref<String> method, Ref<String> pattern,
-                        Const<Handler> handler);
-};
+    void register_handler(Ref<String> method, Ref<String> pattern, const Handler handler);
+  };
 
-template <typename ResponseType>
-void HttpServer::json_get(
-    Ref<String> pattern,
-    Const<std::function<Result<ResponseType>(Ref<Request>)>> handler) {
+  template<typename ResponseType>
+  void HttpServer::json_get(Ref<String> pattern, const std::function<Result<ResponseType(Ref<Request>)>> handler)
+  {
     get(pattern, [handler](Ref<Request> req, MutRef<Response> res) {
-    Const<Result<ResponseType>> result = handler(req);
-    if (!result) {
+      const Result<ResponseType> result = handler(req);
+      if (!result)
+      {
         res.set_status(EResponseCode::INTERNAL_SERVER_ERROR);
         res.set_content(result.error(), "text/plain");
         return;
       }
 
-    Const<Result<String>> json_res = Json::encode_struct(*result);
-    if (!json_res) {
+      const Result<String> json_res = Json::encode_struct(*result);
+      if (!json_res)
+      {
         res.set_status(EResponseCode::INTERNAL_SERVER_ERROR);
         res.set_content("Failed to encode JSON response", "text/plain");
         return;
@@ -114,30 +114,31 @@ void HttpServer::json_get(
       res.set_status(EResponseCode::OK);
       res.set_content(*json_res, "application/json");
     });
-}
+  }
 
-template <typename PayloadType, typename ResponseType>
-void HttpServer::json_post(
-    Ref<String> pattern,
-    Const<std::function<Result<ResponseType>(Ref<PayloadType>)>> handler) {
+  template<typename PayloadType, typename ResponseType>
+  void HttpServer::json_post(Ref<String> pattern, const std::function<Result<ResponseType(Ref<PayloadType>)>> handler)
+  {
     post(pattern, [handler](Ref<Request> req, MutRef<Response> res) {
-    Const<Result<PayloadType>> payload =
-        Json::parse_to_struct<PayloadType>(req.body);
-    if (!payload) {
+      const Result<PayloadType> payload = Json::parse_to_struct<PayloadType>(req.body);
+      if (!payload)
+      {
         res.set_status(EResponseCode::BAD_REQUEST);
         res.set_content("Invalid JSON Payload", "text/plain");
         return;
       }
 
-    Const<Result<ResponseType>> result = handler(*payload);
-    if (!result) {
+      const Result<ResponseType> result = handler(*payload);
+      if (!result)
+      {
         res.set_status(EResponseCode::INTERNAL_SERVER_ERROR);
         res.set_content(result.error(), "text/plain");
         return;
       }
 
-    Const<Result<String>> json_res = Json::encode_struct(*result);
-    if (!json_res) {
+      const Result<String> json_res = Json::encode_struct(*result);
+      if (!json_res)
+      {
         res.set_status(EResponseCode::INTERNAL_SERVER_ERROR);
         res.set_content("Failed to encode JSON response", "text/plain");
         return;
@@ -146,6 +147,6 @@ void HttpServer::json_post(
       res.set_status(EResponseCode::OK);
       res.set_content(*json_res, "application/json");
     });
-}
+  }
 
 } // namespace IACore

Src/IACore/inc/IACore/IACore.hpp

@@ -19,48 +19,53 @@
 #include <IACore/PCH.hpp>
 
 #define IACORE_MAIN()                                                                                                  \
-  auto _app_entry(IACore::Ref<IACore::Vec<IACore::String>> args)               \
-      -> IACore::Result<IACore::i32>;                                          \
-  auto main(Const<int> argc, Mut<char *> argv[]) -> int {                      \
+  auto _app_entry(IACore::Ref<IACore::Vec<IACore::String>> args) -> IACore::Result<IACore::i32>;                       \
+  auto main(int argc, Mut<char *> argv[]) -> int                                                                       \
+  {                                                                                                                    \
     IACore::Mut<IACore::i32> exit_code = 0;                                                                            \
     IACore::initialize();                                                                                              \
     IACore::Mut<IACore::Vec<IACore::String>> args;                                                                     \
     args.reserve(static_cast<IACore::usize>(argc));                                                                    \
-    for (IACore::Mut<IACore::i32> i = 0; i < argc; ++i) {                      \
+    for (IACore::Mut<IACore::i32> i = 0; i < argc; ++i)                                                                \
+    {                                                                                                                  \
       args.push_back(argv[i]);                                                                                         \
     }                                                                                                                  \
-    IACore::Const<IACore::Result<IACore::i32>> result = _app_entry(args);      \
-    if (!result) {                                                             \
-      IACore::Logger::error("Application exited with an error: '{}'.",         \
-                            result.error());                                   \
+    IACore::Result<IACore::i32> result = _app_entry(args);                                                             \
+    if (!result)                                                                                                       \
+    {                                                                                                                  \
+      IACore::Logger::error("Application exited with an error: '{}'.", result.error());                                \
       exit_code = -20;                                                                                                 \
-    } else {                                                                   \
+    }                                                                                                                  \
+    else                                                                                                               \
+    {                                                                                                                  \
       exit_code = *result;                                                                                             \
-      if (exit_code == 0) {                                                    \
+      if (exit_code == 0)                                                                                              \
+      {                                                                                                                \
         IACore::Logger::info("Application exited successfully.");                                                      \
-      } else {                                                                 \
-        IACore::Logger::error("Application exited with error code: {}.",       \
-                              exit_code);                                      \
+      }                                                                                                                \
+      else                                                                                                             \
+      {                                                                                                                \
+        IACore::Logger::error("Application exited with error code: {}.", exit_code);                                   \
       }                                                                                                                \
     }                                                                                                                  \
     IACore::terminate();                                                                                               \
     return exit_code;                                                                                                  \
   }                                                                                                                    \
-  auto _app_entry(IACore::Ref<IACore::Vec<IACore::String>> args)               \
-      -> IACore::Result<IACore::i32>
+  auto _app_entry(IACore::Ref<IACore::Vec<IACore::String>> args) -> IACore::Result<IACore::i32>
 
-namespace IACore {
-// Must be called from main thread
-// Safe to call multiple times but, given every initialize call is paired with a
-// corresponding terminate call
-auto initialize() -> void;
+namespace IACore
+{
+  // Must be called from main thread
+  // Safe to call multiple times but, given every initialize call is paired with a
+  // corresponding terminate call
+  auto initialize() -> void;
 
-// Must be called from same thread as initialize
-// Safe to call multiple times but, given every initialize call is paired with a
-// corresponding terminate call
-auto terminate() -> void;
+  // Must be called from same thread as initialize
+  // Safe to call multiple times but, given every initialize call is paired with a
+  // corresponding terminate call
+  auto terminate() -> void;
 
-auto is_initialized() -> bool;
+  auto is_initialized() -> bool;
 
-auto is_main_thread() -> bool;
+  auto is_main_thread() -> bool;
 } // namespace IACore

Src/IACore/inc/IACore/IATest.hpp

@@ -27,13 +27,10 @@
 
 #define IAT_CHECK(v) __iat_micro_test(_test((v), #v))
 #define IAT_CHECK_NOT(v) __iat_micro_test(_test_not((v), "NOT " #v))
-#define IAT_CHECK_EQ(lhs, rhs)                                                 \
-  __iat_micro_test(_test_eq((lhs), (rhs), #lhs " == " #rhs))
-#define IAT_CHECK_NEQ(lhs, rhs)                                                \
-  __iat_micro_test(_test_neq((lhs), (rhs), #lhs " != " #rhs))
+#define IAT_CHECK_EQ(lhs, rhs) __iat_micro_test(_test_eq((lhs), (rhs), #lhs " == " #rhs))
+#define IAT_CHECK_NEQ(lhs, rhs) __iat_micro_test(_test_neq((lhs), (rhs), #lhs " != " #rhs))
 
-#define IAT_CHECK_APPROX(lhs, rhs)                                             \
-  __iat_micro_test(_test_approx((lhs), (rhs), #lhs " ~= " #rhs))
+#define IAT_CHECK_APPROX(lhs, rhs) __iat_micro_test(_test_approx((lhs), (rhs), #lhs " ~= " #rhs))
 
 #define IAT_UNIT(func) _test_unit([this]() { return this->func(); }, #func)
 #define IAT_NAMED_UNIT(n, func) _test_unit([this]() { return this->func(); }, n)
@@ -41,151 +38,171 @@
 #define IAT_BLOCK(name) class name : public IACore::Test::Block
 
 #define IAT_BEGIN_BLOCK(_group, _name)                                                                                 \
-  class _group##_##_name : public IACore::Test::Block {                        \
-  public:                                                                      \
-    [[nodiscard]] auto get_name() const -> const char * override {             \
+  class _group##_##_name : public IACore::Test::Block                                                                  \
+  {                                                                                                                    \
+public:                                                                                                                \
+    [[nodiscard]] auto get_name() const -> const char * override                                                       \
+    {                                                                                                                  \
       return #_group "::" #_name;                                                                                      \
     }                                                                                                                  \
                                                                                                                        \
-  private:
+private:
 
 #define IAT_END_BLOCK()                                                                                                \
   }                                                                                                                    \
   ;
 
 #define IAT_BEGIN_TEST_LIST()                                                                                          \
-public:                                                                        \
-  auto declare_tests() -> void override {
+  public:                                                                                                              \
+  auto declare_tests() -> void override                                                                                \
+  {
 #define IAT_ADD_TEST(name) IAT_UNIT(name)
 #define IAT_END_TEST_LIST()                                                                                            \
   }                                                                                                                    \
                                                                                                                        \
-private:
+  private:
 
-namespace IACore::Test {
-// -------------------------------------------------------------------------
-// String Conversion Helpers
-// -------------------------------------------------------------------------
-template <typename T> auto to_string(Ref<T> value) -> String {
-  if constexpr (std::is_arithmetic_v<T>) {
+namespace IACore::Test
+{
+  // -------------------------------------------------------------------------
+  // String Conversion Helpers
+  // -------------------------------------------------------------------------
+  template<typename T> auto to_string(Ref<T> value) -> String
+  {
+    if constexpr (std::is_arithmetic_v<T>)
+    {
       return std::to_string(value);
-  } else if constexpr (std::is_same_v<T, String> ||
-                       std::is_same_v<T, const char *> ||
-                       std::is_same_v<T, char *>) {
+    }
+    else if constexpr (std::is_same_v<T, String> || std::is_same_v<T, const char *> || std::is_same_v<T, char *>)
+    {
       return String("\"") + String(value) + "\"";
-  } else {
+    }
+    else
+    {
       return "{Object}";
     }
-}
+  }
 
-template <typename T> auto to_string(T *value) -> String {
-  if (value == nullptr) {
+  template<typename T> auto to_string(T *value) -> String
+  {
+    if (value == nullptr)
+    {
       return "nullptr";
     }
     return std::format("ptr({})", static_cast<const void *>(value));
-}
+  }
 
-// -------------------------------------------------------------------------
-// Types
-// -------------------------------------------------------------------------
-using TestFunctor = std::function<bool()>;
+  // -------------------------------------------------------------------------
+  // Types
+  // -------------------------------------------------------------------------
+  using TestFunctor = std::function<bool()>;
 
-struct TestUnit {
+  struct TestUnit
+  {
     Mut<String> name;
     Mut<TestFunctor> functor;
-};
+  };
 
-class Block {
+  class Block
+  {
 public:
     virtual ~Block() = default;
     [[nodiscard]] virtual auto get_name() const -> const char * = 0;
     virtual auto declare_tests() -> void = 0;
 
-  auto units() -> MutRef<Vec<TestUnit>> { return m_units; }
+    auto units() -> MutRef<Vec<TestUnit>>
+    {
+      return m_units;
+    }
 
 protected:
-  template <typename T1, typename T2>
-  auto _test_eq(Ref<T1> lhs, Ref<T2> rhs, Const<const char *> description)
-      -> bool {
-    if (lhs != rhs) {
+    template<typename T1, typename T2> auto _test_eq(Ref<T1> lhs, Ref<T2> rhs, const char *description) -> bool
+    {
+      if (lhs != rhs)
+      {
         print_fail(description, to_string(lhs), to_string(rhs));
         return false;
       }
       return true;
     }
 
-  template <typename T1, typename T2>
-  auto _test_neq(Ref<T1> lhs, Ref<T2> rhs, Const<const char *> description)
-      -> bool {
-    if (lhs == rhs) {
+    template<typename T1, typename T2> auto _test_neq(Ref<T1> lhs, Ref<T2> rhs, const char *description) -> bool
+    {
+      if (lhs == rhs)
+      {
         print_fail(description, to_string(lhs), "NOT " + to_string(rhs));
         return false;
       }
       return true;
     }
 
-  template <typename T>
-  auto _test_approx(Const<T> lhs, Const<T> rhs, Const<const char *> description)
-      -> bool {
-    static_assert(std::is_floating_point_v<T>,
-                  "Approx only works for floats/doubles");
-    Const<T> diff = std::abs(lhs - rhs);
-    if (diff > static_cast<T>(0.0001)) {
+    template<typename T> auto _test_approx(const T lhs, const T rhs, const char *description) -> bool
+    {
+      static_assert(std::is_floating_point_v<T>, "Approx only works for floats/doubles");
+      const T diff = std::abs(lhs - rhs);
+      if (diff > static_cast<T>(0.0001))
+      {
         print_fail(description, to_string(lhs), to_string(rhs));
         return false;
       }
       return true;
     }
 
-  auto _test(Const<bool> value, Const<const char *> description) -> bool {
-    if (!value) {
-      std::cout << console::BLUE << "    " << description << "... "
-                << console::RED << "FAILED" << console::RESET << "\n";
+    auto _test(const bool value, const char *description) -> bool
+    {
+      if (!value)
+      {
+        std::cout << console::BLUE << "    " << description << "... " << console::RED << "FAILED" << console::RESET
+                  << "\n";
         return false;
       }
       return true;
     }
 
-  auto _test_not(Const<bool> value, Const<const char *> description) -> bool {
-    if (value) {
-      std::cout << console::BLUE << "    " << description << "... "
-                << console::RED << "FAILED" << console::RESET << "\n";
+    auto _test_not(const bool value, const char *description) -> bool
+    {
+      if (value)
+      {
+        std::cout << console::BLUE << "    " << description << "... " << console::RED << "FAILED" << console::RESET
+                  << "\n";
         return false;
       }
       return true;
     }
 
-  auto _test_unit(Mut<TestFunctor> functor, Const<const char *> name) -> void {
+    auto _test_unit(Mut<TestFunctor> functor, const char *name) -> void
+    {
       m_units.push_back({name, std::move(functor)});
     }
 
 private:
-  auto print_fail(Const<const char *> desc, Ref<String> v1, Ref<String> v2)
-      -> void {
-    std::cout << console::BLUE << "    " << desc << "... " << console::RED
-              << "FAILED" << console::RESET << "\n";
-    std::cout << console::RED << "      Expected: " << v2 << console::RESET
-              << "\n";
-    std::cout << console::RED << "      Actual:   " << v1 << console::RESET
-              << "\n";
+    auto print_fail(const char *desc, Ref<String> v1, Ref<String> v2) -> void
+    {
+      std::cout << console::BLUE << "    " << desc << "... " << console::RED << "FAILED" << console::RESET << "\n";
+      std::cout << console::RED << "      Expected: " << v2 << console::RESET << "\n";
+      std::cout << console::RED << "      Actual:   " << v1 << console::RESET << "\n";
     }
 
     Mut<Vec<TestUnit>> m_units;
-};
+  };
 
-template <typename T>
-concept ValidBlockClass = std::derived_from<T, Block>;
+  template<typename T>
+  concept ValidBlockClass = std::derived_from<T, Block>;
 
-// -------------------------------------------------------------------------
-// Runner
-// -------------------------------------------------------------------------
-template <bool StopOnFail = false, bool IsVerbose = false> class Runner {
+  // -------------------------------------------------------------------------
+  // Runner
+  // -------------------------------------------------------------------------
+  template<bool StopOnFail = false, bool IsVerbose = false> class Runner
+  {
 public:
     Runner() = default;
 
-  ~Runner() { summarize(); }
+    ~Runner()
+    {
+      summarize();
+    }
 
-  template <typename BlockClass>
+    template<typename BlockClass>
       requires ValidBlockClass<BlockClass>
     auto test_block() -> void;
 
@@ -195,99 +212,101 @@ private:
     Mut<usize> m_test_count{0};
     Mut<usize> m_fail_count{0};
     Mut<usize> m_block_count{0};
-};
+  };
 
-template <bool StopOnFail, bool IsVerbose>
-template <typename BlockClass>
+  template<bool StopOnFail, bool IsVerbose>
+  template<typename BlockClass>
     requires ValidBlockClass<BlockClass>
-auto Runner<StopOnFail, IsVerbose>::test_block() -> void {
+  auto Runner<StopOnFail, IsVerbose>::test_block() -> void
+  {
     m_block_count++;
     Mut<BlockClass> b;
     b.declare_tests();
 
-  std::cout << console::MAGENTA << "Testing [" << b.get_name() << "]..."
-            << console::RESET << "\n";
+    std::cout << console::MAGENTA << "Testing [" << b.get_name() << "]..." << console::RESET << "\n";
 
-  for (MutRef<TestUnit> v : b.units()) {
+    for (MutRef<TestUnit> v : b.units())
+    {
       m_test_count++;
-    if constexpr (IsVerbose) {
-      std::cout << console::YELLOW << "  Testing " << v.name << "...\n"
-                << console::RESET;
+      if constexpr (IsVerbose)
+      {
+        std::cout << console::YELLOW << "  Testing " << v.name << "...\n" << console::RESET;
       }
 
-    Const<bool> result = v.functor();
+      const bool result = v.functor();
 
-    if (!result) {
+      if (!result)
+      {
         m_fail_count++;
-      if constexpr (StopOnFail) {
+        if constexpr (StopOnFail)
+        {
           summarize();
           std::exit(-1);
         }
       }
     }
     std::cout << "\n";
-}
+  }
 
-template <bool StopOnFail, bool IsVerbose>
-auto Runner<StopOnFail, IsVerbose>::summarize() -> void {
+  template<bool StopOnFail, bool IsVerbose> auto Runner<StopOnFail, IsVerbose>::summarize() -> void
+  {
     std::cout << console::GREEN
               << "\n-----------------------------------\n\t      "
                  "SUMMARY\n-----------------------------------\n";
 
-  if (m_fail_count == 0) {
+    if (m_fail_count == 0)
+    {
       std::cout << "\n\tALL TESTS PASSED!\n\n";
-  } else {
-    Const<f64> success_rate =
-        (100.0 * static_cast<f64>(m_test_count - m_fail_count) /
-         static_cast<f64>(m_test_count));
-    std::cout << console::RED << m_fail_count << " OF " << m_test_count
-              << " TESTS FAILED\n"
-              << console::YELLOW
-              << std::format("Success Rate: {:.2f}%\n", success_rate);
+    }
+    else
+    {
+      const f64 success_rate = (100.0 * static_cast<f64>(m_test_count - m_fail_count) / static_cast<f64>(m_test_count));
+      std::cout << console::RED << m_fail_count << " OF " << m_test_count << " TESTS FAILED\n"
+                << console::YELLOW << std::format("Success Rate: {:.2f}%\n", success_rate);
     }
 
-  std::cout << console::MAGENTA << "Ran " << m_test_count << " test(s) across "
-            << m_block_count << " block(s)\n"
-            << console::GREEN << "-----------------------------------"
-            << console::RESET << "\n";
-}
+    std::cout << console::MAGENTA << "Ran " << m_test_count << " test(s) across " << m_block_count << " block(s)\n"
+              << console::GREEN << "-----------------------------------" << console::RESET << "\n";
+  }
 
-using DefaultRunner = Runner<false, true>;
+  using DefaultRunner = Runner<false, true>;
 
-// -------------------------------------------------------------------------
-// Registry
-// -------------------------------------------------------------------------
-class TestRegistry {
+  // -------------------------------------------------------------------------
+  // Registry
+  // -------------------------------------------------------------------------
+  class TestRegistry
+  {
 public:
     using TestEntry = std::function<void(MutRef<DefaultRunner>)>;
 
-  static auto get_entries() -> MutRef<Vec<TestEntry>> {
+    static auto get_entries() -> MutRef<Vec<TestEntry>>
+    {
       static Mut<Vec<TestEntry>> entries;
       return entries;
     }
 
-  static auto run_all() -> i32 {
+    static auto run_all() -> i32
+    {
       Mut<DefaultRunner> r;
       MutRef<Vec<TestEntry>> entries = get_entries();
-    std::cout << console::CYAN << "[IATest] Discovered " << entries.size()
-              << " Test Blocks\n\n"
-              << console::RESET;
+      std::cout << console::CYAN << "[IATest] Discovered " << entries.size() << " Test Blocks\n\n" << console::RESET;
 
-    for (MutRef<TestEntry> entry : entries) {
+      for (MutRef<TestEntry> entry : entries)
+      {
         entry(r);
       }
 
       return 0;
     }
-};
+  };
 
-template <typename BlockType> struct AutoRegister {
-  AutoRegister() {
-    TestRegistry::get_entries().push_back(
-        [](MutRef<DefaultRunner> r) { r.test_block<BlockType>(); });
+  template<typename BlockType> struct AutoRegister
+  {
+    AutoRegister()
+    {
+      TestRegistry::get_entries().push_back([](MutRef<DefaultRunner> r) { r.test_block<BlockType>(); });
     }
-};
+  };
 } // namespace IACore::Test
 
-#define IAT_REGISTER_ENTRY(Group, Name)                                        \
-  static IACore::Test::AutoRegister<Group##_##Name> _iat_reg_##Group##_##Name;
+#define IAT_REGISTER_ENTRY(Group, Name) static IACore::Test::AutoRegister<Group##_##Name> _iat_reg_##Group##_##Name;

Src/IACore/inc/IACore/IPC.hpp

@@ -19,14 +19,17 @@
 #include <IACore/ProcessOps.hpp>
 #include <IACore/SocketOps.hpp>
 
-namespace IACore {
-using IpcPacketHeader = RingBufferView::PacketHeader;
+namespace IACore
+{
+  using IpcPacketHeader = RingBufferView::PacketHeader;
 
-struct alignas(64) IpcSharedMemoryLayout {
+  struct alignas(64) IpcSharedMemoryLayout
+  {
     // =========================================================
     // METADATA & HANDSHAKE
     // =========================================================
-  struct Header {
+    struct Header
+    {
       Mut<u32> magic;      // 0x49414950 ("IAIP")
       Mut<u32> version;    // 1
       Mut<u64> total_size; // Total size of SHM block
@@ -35,7 +38,7 @@ struct alignas(64) IpcSharedMemoryLayout {
     Mut<Header> meta;
 
     // Pad to ensure MONI starts on a fresh cache line (64 bytes)
-  Const<Array<u8, 64 - sizeof(Header)>> _pad0;
+    const Array<u8, 64 - sizeof(Header)> _pad0;
 
     // =========================================================
     // RING BUFFER CONTROL BLOCKS
@@ -56,35 +59,34 @@ struct alignas(64) IpcSharedMemoryLayout {
     Mut<u64> mino_data_size;
 
     // Pad to ensure the actual Data Buffer starts on a fresh cache line
-  Const<Array<u8, 64 - (sizeof(u64) * 4)>> _pad1;
+    const Array<u8, 64 - (sizeof(u64) * 4)> _pad1;
 
-  static constexpr auto get_header_size() -> usize {
+    static constexpr auto get_header_size() -> usize
+    {
       return sizeof(IpcSharedMemoryLayout);
     }
-};
+  };
 
-// Check padding logic is gucci
-static_assert(sizeof(IpcSharedMemoryLayout) % 64 == 0,
-              "IPC Layout is not cache-line aligned!");
+  // Check padding logic is gucci
+  static_assert(sizeof(IpcSharedMemoryLayout) % 64 == 0, "IPC Layout is not cache-line aligned!");
 
-class IpcNode {
+  class IpcNode
+  {
 public:
     virtual ~IpcNode();
 
     // When Manager spawns a node, `connection_string` is passed
     // as the first command line argument
-  auto connect(Const<const char *> connection_string) -> Result<void>;
+    auto connect(const char *connection_string) -> Result<void>;
 
     auto update() -> void;
 
-  auto send_signal(Const<u8> signal) -> void;
-  auto send_packet(Const<u16> packet_id, Const<Span<Const<u8>>> payload)
-      -> Result<void>;
+    auto send_signal(const u8 signal) -> void;
+    auto send_packet(const u16 packet_id, const Span<const u8> payload) -> Result<void>;
 
 protected:
-  virtual auto on_signal(Const<u8> signal) -> void = 0;
-  virtual auto on_packet(Const<u16> packet_id, Const<Span<Const<u8>>> payload)
-      -> void = 0;
+    virtual auto on_signal(const u8 signal) -> void = 0;
+    virtual auto on_packet(const u16 packet_id, const Span<const u8> payload) -> void = 0;
 
 private:
     Mut<String> m_shm_name;
@@ -94,10 +96,12 @@ private:
 
     Mut<RingBufferView> m_moni; // Manager Out, Node In
     Mut<RingBufferView> m_mino; // Manager In, Node Out
-};
+  };
 
-class IpcManager {
-  struct NodeSession {
+  class IpcManager
+  {
+    struct NodeSession
+    {
       Mut<std::chrono::system_clock::time_point> creation_time{};
       Mut<Box<ProcessHandle>> node_process;
 
@@ -109,44 +113,36 @@ class IpcManager {
       Mut<SocketHandle> listener_socket{INVALID_SOCKET};
       Mut<SocketHandle> data_socket{INVALID_SOCKET};
 
-    Mut<RingBufferView> moni =
-        RingBufferView::default_instance(); // Manager Out, Node In
-    Mut<RingBufferView> mino =
-        RingBufferView::default_instance(); // Manager In, Node Out
+      Mut<RingBufferView> moni = RingBufferView::default_instance(); // Manager Out, Node In
+      Mut<RingBufferView> mino = RingBufferView::default_instance(); // Manager In, Node Out
 
       Mut<bool> is_ready{false};
 
-    auto send_signal(Const<u8> signal) -> void;
-    auto send_packet(Const<u16> packet_id, Const<Span<Const<u8>>> payload)
-        -> Result<void>;
+      auto send_signal(const u8 signal) -> void;
+      auto send_packet(const u16 packet_id, const Span<const u8> payload) -> Result<void>;
     };
 
 public:
-  static constexpr Const<u32> DEFAULT_NODE_SHARED_MEMORY_SIZE = 4 * 1024 * 1024;
+    static constexpr const u32 DEFAULT_NODE_SHARED_MEMORY_SIZE = 4 * 1024 * 1024;
 
 public:
     virtual ~IpcManager();
 
     auto update() -> void;
 
-  auto
-  spawn_node(Ref<Path> executable_path,
-             Const<u32> shared_memory_size = DEFAULT_NODE_SHARED_MEMORY_SIZE)
+    auto spawn_node(Ref<Path> executable_path, const u32 shared_memory_size = DEFAULT_NODE_SHARED_MEMORY_SIZE)
         -> Result<NativeProcessID>;
 
-  auto wait_till_node_is_online(Const<NativeProcessID> node) -> bool;
+    auto wait_till_node_is_online(const NativeProcessID node) -> bool;
 
-  auto shutdown_node(Const<NativeProcessID> node) -> void;
+    auto shutdown_node(const NativeProcessID node) -> void;
 
-  auto send_signal(Const<NativeProcessID> node, Const<u8> signal) -> void;
-  auto send_packet(Const<NativeProcessID> node, Const<u16> packet_id,
-                   Const<Span<Const<u8>>> payload) -> Result<void>;
+    auto send_signal(const NativeProcessID node, const u8 signal) -> void;
+    auto send_packet(const NativeProcessID node, const u16 packet_id, const Span<const u8> payload) -> Result<void>;
 
 protected:
-  virtual auto on_signal(Const<NativeProcessID> node, Const<u8> signal)
-      -> void = 0;
-  virtual auto on_packet(Const<NativeProcessID> node, Const<u16> packet_id,
-                         Const<Span<Const<u8>>> payload) -> void = 0;
+    virtual auto on_signal(const NativeProcessID node, const u8 signal) -> void = 0;
+    virtual auto on_packet(const NativeProcessID node, const u16 packet_id, const Span<const u8> payload) -> void = 0;
 
 private:
     Mut<Vec<u8>> m_receive_buffer;
@@ -156,5 +152,5 @@ private:
 
 protected:
     IpcManager();
-};
+  };
 } // namespace IACore

Src/IACore/inc/IACore/JSON.hpp

@@ -21,35 +21,38 @@
 #include <nlohmann/json.hpp>
 #include <simdjson.h>
 
-namespace IACore {
-class JsonDocument {
+namespace IACore
+{
+  class JsonDocument
+  {
 public:
     JsonDocument(ForwardRef<JsonDocument>) noexcept = default;
-  auto operator=(ForwardRef<JsonDocument>) noexcept
-      -> MutRef<JsonDocument> = default;
+    auto operator=(ForwardRef<JsonDocument>) noexcept -> MutRef<JsonDocument> = default;
 
     JsonDocument(Ref<JsonDocument>) = delete;
     auto operator=(Ref<JsonDocument>) -> MutRef<JsonDocument> = delete;
 
     [[nodiscard]]
-  auto root() const noexcept -> simdjson::dom::element {
+    auto root() const noexcept -> simdjson::dom::element
+    {
       return m_root;
     }
 
 private:
     friend class Json;
 
-  JsonDocument(Mut<Box<simdjson::dom::parser>> p, Mut<simdjson::dom::element> r)
-      : m_parser(std::move(p)), m_root(r) {}
+    JsonDocument(Mut<Box<simdjson::dom::parser>> p, Mut<simdjson::dom::element> r) : m_parser(std::move(p)), m_root(r)
+    {
+    }
 
     Mut<Box<simdjson::dom::parser>> m_parser;
     Mut<simdjson::dom::element> m_root;
-};
+  };
 
-class Json {
+  class Json
+  {
 private:
-  static constexpr Const<glz::opts> GLAZE_OPTS =
-      glz::opts{.error_on_unknown_keys = false};
+    static constexpr const glz::opts GLAZE_OPTS = glz::opts{.error_on_unknown_keys = false};
 
 public:
     static auto parse(Ref<String> json_str) -> Result<nlohmann::json>;
@@ -57,63 +60,65 @@ public:
 
     static auto parse_read_only(Ref<String> json_str) -> Result<JsonDocument>;
 
-  template <typename T>
-  static auto parse_to_struct(Ref<String> json_str) -> Result<T>;
+    template<typename T> static auto parse_to_struct(Ref<String> json_str) -> Result<T>;
 
-  template <typename T>
-  static auto encode_struct(Ref<T> data) -> Result<String>;
-};
+    template<typename T> static auto encode_struct(Ref<T> data) -> Result<String>;
+  };
 
-inline auto Json::parse(Ref<String> json_str) -> Result<nlohmann::json> {
-  Const<nlohmann::json> res =
-      nlohmann::json::parse(json_str, nullptr, false, true);
+  inline auto Json::parse(Ref<String> json_str) -> Result<nlohmann::json>
+  {
+    const nlohmann::json res = nlohmann::json::parse(json_str, nullptr, false, true);
 
-  if (res.is_discarded()) {
+    if (res.is_discarded())
+    {
       return fail("Failed to parse JSON (Invalid Syntax)");
     }
     return res;
-}
+  }
 
-inline auto Json::parse_read_only(Ref<String> json_str)
-    -> Result<JsonDocument> {
+  inline auto Json::parse_read_only(Ref<String> json_str) -> Result<JsonDocument>
+  {
     Mut<Box<simdjson::dom::parser>> parser = make_box<simdjson::dom::parser>();
 
     Mut<simdjson::dom::element> root;
 
-  Const<simdjson::error_code> error = parser->parse(json_str).get(root);
+    const simdjson::error_code error = parser->parse(json_str).get(root);
 
-  if (error) {
+    if (error)
+    {
       return fail("JSON Error: {}", simdjson::error_message(error));
     }
 
     return JsonDocument(std::move(parser), root);
-}
+  }
 
-inline auto Json::encode(Ref<nlohmann::json> data) -> String {
+  inline auto Json::encode(Ref<nlohmann::json> data) -> String
+  {
     return data.dump();
-}
+  }
 
-template <typename T>
-inline auto Json::parse_to_struct(Ref<String> json_str) -> Result<T> {
+  template<typename T> inline auto Json::parse_to_struct(Ref<String> json_str) -> Result<T>
+  {
     Mut<T> result{};
 
-  Const<glz::error_ctx> err = glz::read<GLAZE_OPTS>(result, json_str);
+    const glz::error_ctx err = glz::read<GLAZE_OPTS>(result, json_str);
 
-  if (err) {
-    return fail("JSON Struct Parse Error: {}",
-                glz::format_error(err, json_str));
+    if (err)
+    {
+      return fail("JSON Struct Parse Error: {}", glz::format_error(err, json_str));
     }
     return result;
-}
+  }
 
-template <typename T>
-inline auto Json::encode_struct(Ref<T> data) -> Result<String> {
+  template<typename T> inline auto Json::encode_struct(Ref<T> data) -> Result<String>
+  {
     Mut<String> result;
-  Const<glz::error_ctx> err = glz::write_json(data, result);
+    const glz::error_ctx err = glz::write_json(data, result);
 
-  if (err) {
+    if (err)
+    {
       return fail("JSON Struct Encode Error");
     }
     return result;
-}
+  }
 } // namespace IACore

Src/IACore/inc/IACore/Logger.hpp

@@ -18,8 +18,7 @@
 #include <IACore/PCH.hpp>
 
 #define IA_LOG_SET_FILE(path) IACore::Logger::enable_logging_to_disk(path)
-#define IA_LOG_SET_LEVEL(level)                                                \
-  IACore::Logger::set_log_level(IACore::Logger::LogLevel::level)
+#define IA_LOG_SET_LEVEL(level) IACore::Logger::set_log_level(IACore::Logger::LogLevel::level)
 
 #define IA_LOG_TRACE(...) IACore::Logger::trace(__VA_ARGS__)
 #define IA_LOG_DEBUG(...) IACore::Logger::debug(__VA_ARGS__)
@@ -27,43 +26,49 @@
 #define IA_LOG_WARN(...) IACore::Logger::warn(__VA_ARGS__)
 #define IA_LOG_ERROR(...) IACore::Logger::error(__VA_ARGS__)
 
-namespace IACore {
-class Logger {
+namespace IACore
+{
+  class Logger
+  {
 public:
-  enum class LogLevel { Trace, Debug, Info, Warn, Error };
+    enum class LogLevel
+    {
+      Trace,
+      Debug,
+      Info,
+      Warn,
+      Error
+    };
 
 public:
-  static auto enable_logging_to_disk(Const<const char *> file_path)
-      -> Result<void>;
-  static auto set_log_level(Const<LogLevel> log_level) -> void;
+    static auto enable_logging_to_disk(const char *file_path) -> Result<void>;
+    static auto set_log_level(const LogLevel log_level) -> void;
 
-  template <typename... Args>
-  static auto trace(Const<std::format_string<Args...>> fmt,
-                    ForwardRef<Args>... args) -> void {
+    template<typename... Args>
+    static auto trace(const std::format_string<Args...> fmt, ForwardRef<Args>... args) -> void
+    {
       log_trace(std::vformat(fmt.get(), std::make_format_args(args...)));
     }
 
-  template <typename... Args>
-  static auto debug(Const<std::format_string<Args...>> fmt,
-                    ForwardRef<Args>... args) -> void {
+    template<typename... Args>
+    static auto debug(const std::format_string<Args...> fmt, ForwardRef<Args>... args) -> void
+    {
       log_debug(std::vformat(fmt.get(), std::make_format_args(args...)));
     }
 
-  template <typename... Args>
-  static auto info(Const<std::format_string<Args...>> fmt,
-                   ForwardRef<Args>... args) -> void {
+    template<typename... Args> static auto info(const std::format_string<Args...> fmt, ForwardRef<Args>... args) -> void
+    {
       log_info(std::vformat(fmt.get(), std::make_format_args(args...)));
     }
 
-  template <typename... Args>
-  static auto warn(Const<std::format_string<Args...>> fmt,
-                   ForwardRef<Args>... args) -> void {
+    template<typename... Args> static auto warn(const std::format_string<Args...> fmt, ForwardRef<Args>... args) -> void
+    {
       log_warn(std::vformat(fmt.get(), std::make_format_args(args...)));
     }
 
-  template <typename... Args>
-  static auto error(Const<std::format_string<Args...>> fmt,
-                    ForwardRef<Args>... args) -> void {
+    template<typename... Args>
+    static auto error(const std::format_string<Args...> fmt, ForwardRef<Args>... args) -> void
+    {
       log_error(std::vformat(fmt.get(), std::make_format_args(args...)));
     }
 
@@ -71,44 +76,63 @@ public:
 
 private:
 #if IA_DISABLE_LOGGING > 0
-  static auto log_trace(ForwardRef<String> msg) -> void { IA_UNUSED(msg); }
+    static auto log_trace(ForwardRef<String> msg) -> void
+    {
+      IA_UNUSED(msg);
+    }
 
-  static auto log_debug(ForwardRef<String> msg) -> void { IA_UNUSED(msg); }
+    static auto log_debug(ForwardRef<String> msg) -> void
+    {
+      IA_UNUSED(msg);
+    }
 
-  static auto log_info(ForwardRef<String> msg) -> void { IA_UNUSED(msg); }
+    static auto log_info(ForwardRef<String> msg) -> void
+    {
+      IA_UNUSED(msg);
+    }
 
-  static auto log_warn(ForwardRef<String> msg) -> void { IA_UNUSED(msg); }
+    static auto log_warn(ForwardRef<String> msg) -> void
+    {
+      IA_UNUSED(msg);
+    }
 
-  static auto log_error(ForwardRef<String> msg) -> void { IA_UNUSED(msg); }
+    static auto log_error(ForwardRef<String> msg) -> void
+    {
+      IA_UNUSED(msg);
+    }
 #else
-  static auto log_trace(ForwardRef<String> msg) -> void {
+    static auto log_trace(ForwardRef<String> msg) -> void
+    {
       if (m_log_level <= LogLevel::Trace)
         log_internal(console::RESET, "TRACE", std::move(msg));
     }
 
-  static auto log_debug(ForwardRef<String> msg) -> void {
+    static auto log_debug(ForwardRef<String> msg) -> void
+    {
       if (m_log_level <= LogLevel::Debug)
         log_internal(console::CYAN, "DEBUG", std::move(msg));
     }
 
-  static auto log_info(ForwardRef<String> msg) -> void {
+    static auto log_info(ForwardRef<String> msg) -> void
+    {
       if (m_log_level <= LogLevel::Info)
         log_internal(console::GREEN, "INFO", std::move(msg));
     }
 
-  static auto log_warn(ForwardRef<String> msg) -> void {
+    static auto log_warn(ForwardRef<String> msg) -> void
+    {
       if (m_log_level <= LogLevel::Warn)
         log_internal(console::YELLOW, "WARN", std::move(msg));
     }
 
-  static auto log_error(ForwardRef<String> msg) -> void {
+    static auto log_error(ForwardRef<String> msg) -> void
+    {
       if (m_log_level <= LogLevel::Error)
         log_internal(console::RED, "ERROR", std::move(msg));
     }
 #endif
 
-  static auto log_internal(Const<const char *> prefix, Const<const char *> tag,
-                           ForwardRef<String> msg) -> void;
+    static auto log_internal(const char *prefix, const char *tag, ForwardRef<String> msg) -> void;
 
 private:
     static Mut<LogLevel> m_log_level;
@@ -119,5 +143,5 @@ private:
 
     friend void initialize();
     friend void terminate();
-};
+  };
 } // namespace IACore

Src/IACore/inc/IACore/PCH.hpp

@@ -16,42 +16,42 @@
 #pragma once
 
 #if defined(__x86_64__) || defined(_M_X64) || defined(_M_AMD64)
-#define IA_ARCH_X64 1
+#  define IA_ARCH_X64 1
 #elif defined(__aarch64__) || defined(_M_ARM64)
-#define IA_ARCH_ARM64 1
+#  define IA_ARCH_ARM64 1
 #elif defined(__wasm__) || defined(__wasm32__) || defined(__wasm64__)
-#define IA_ARCH_WASM 1
+#  define IA_ARCH_WASM 1
 #else
-#error "IACore: Unsupported Architecture."
+#  error "IACore: Unsupported Architecture."
 #endif
 
 #if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
-#define IA_PLATFORM_WINDOWS 1
+#  define IA_PLATFORM_WINDOWS 1
 #elif __APPLE__
-#include <TargetConditionals.h>
-#define IA_PLATFORM_APPLE 1
-#define IA_PLATFORM_UNIX 1
+#  include <TargetConditionals.h>
+#  define IA_PLATFORM_APPLE 1
+#  define IA_PLATFORM_UNIX 1
 #elif __linux__
-#define IA_PLATFORM_LINUX 1
-#define IA_PLATFORM_UNIX 1
+#  define IA_PLATFORM_LINUX 1
+#  define IA_PLATFORM_UNIX 1
 #elif __wasm__
-#define IA_PLATFORM_WASM 1
+#  define IA_PLATFORM_WASM 1
 #else
-#error "IACore: Unsupported Platform."
+#  error "IACore: Unsupported Platform."
 #endif
 
 #if IA_PLATFORM_WINDOWS
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN
-#endif
-#ifndef NOMINMAX
-#define NOMINMAX
-#endif
-#include <windows.h>
+#  ifndef WIN32_LEAN_AND_MEAN
+#    define WIN32_LEAN_AND_MEAN
+#  endif
+#  ifndef NOMINMAX
+#    define NOMINMAX
+#  endif
+#  include <windows.h>
 #elif IA_PLATFORM_UNIX
-#include <signal.h>
-#include <sys/wait.h>
-#include <unistd.h>
+#  include <signal.h>
+#  include <sys/wait.h>
+#  include <unistd.h>
 #endif
 
 #include <atomic>
@@ -70,66 +70,69 @@
 
 #include <auxid/auxid.hpp>
 
-namespace IACore {
+namespace IACore
+{
 
-using namespace Auxid;
+  using namespace Auxid;
 
-// =============================================================================
-// Build Environment & Constants
-// =============================================================================
-namespace Env {
+  // =============================================================================
+  // Build Environment & Constants
+  // =============================================================================
+  namespace Env
+  {
 
-using namespace Auxid::Env;
+    using namespace Auxid::Env;
 
 #if IA_PLATFORM_WINDOWS
-constexpr Const<bool> IS_WINDOWS = true;
-constexpr Const<bool> IS_UNIX = false;
+    constexpr const bool IS_WINDOWS = true;
+    constexpr const bool IS_UNIX = false;
 #else
-constexpr Const<bool> IS_WINDOWS = false;
-constexpr Const<bool> IS_UNIX = true;
+    constexpr const bool IS_WINDOWS = false;
+    constexpr const bool IS_UNIX = true;
 #endif
 
-constexpr Const<usize> MAX_PATH_LEN = 4096;
+    constexpr const usize MAX_PATH_LEN = 4096;
 
-} // namespace Env
+  } // namespace Env
 
-// =============================================================================
-// Data Structures & Aliases
-// =============================================================================
-template <typename K, typename V>
-using HashMap = ankerl::unordered_dense::map<K, V>;
-template <typename T> using HashSet = ankerl::unordered_dense::set<T>;
+  // =============================================================================
+  // Data Structures & Aliases
+  // =============================================================================
+  template<typename K, typename V> using HashMap = ankerl::unordered_dense::map<K, V>;
+  template<typename T> using HashSet = ankerl::unordered_dense::set<T>;
 
-using Path = std::filesystem::path;
+  using Path = std::filesystem::path;
 
-// =============================================================================
-// Versioning
-// =============================================================================
-struct Version {
+  // =============================================================================
+  // Versioning
+  // =============================================================================
+  struct Version
+  {
     u32 major = 0;
     u32 minor = 0;
     u32 patch = 0;
 
-  [[nodiscard]] constexpr auto to_u64() const -> u64 {
-    return (static_cast<u64>(major) << 40) | (static_cast<u64>(minor) << 16) |
-           (static_cast<u64>(patch));
+    [[nodiscard]] constexpr auto to_u64() const -> u64
+    {
+      return (static_cast<u64>(major) << 40) | (static_cast<u64>(minor) << 16) | (static_cast<u64>(patch));
     }
-};
+  };
 
-// =============================================================================
-// Console Colors
-// =============================================================================
-namespace console {
-constexpr Const<const char *> RESET = "\033[0m";
-constexpr Const<const char *> RED = "\033[31m";
-constexpr Const<const char *> GREEN = "\033[32m";
-constexpr Const<const char *> YELLOW = "\033[33m";
-constexpr Const<const char *> BLUE = "\033[34m";
-constexpr Const<const char *> MAGENTA = "\033[35m";
-constexpr Const<const char *> CYAN = "\033[36m";
-} // namespace console
+  // =============================================================================
+  // Console Colors
+  // =============================================================================
+  namespace console
+  {
+    constexpr const char *RESET = "\033[0m";
+    constexpr const char *RED = "\033[31m";
+    constexpr const char *GREEN = "\033[32m";
+    constexpr const char *YELLOW = "\033[33m";
+    constexpr const char *BLUE = "\033[34m";
+    constexpr const char *MAGENTA = "\033[35m";
+    constexpr const char *CYAN = "\033[36m";
+  } // namespace console
 
 } // namespace IACore
 
 #define IA_NODISCARD [[nodiscard]]
-#define IA_UNUSED(v) (void)(v)
+#define IA_UNUSED(v) (void) (v)

Src/IACore/inc/IACore/Platform.hpp

@@ -18,35 +18,40 @@
 #include <IACore/PCH.hpp>
 
 #if IA_ARCH_X64
-#ifdef _MSC_VER
-#include <intrin.h>
-#else
-#include <immintrin.h>
-#endif
+#  ifdef _MSC_VER
+#    include <intrin.h>
+#  else
+#    include <immintrin.h>
+#  endif
 #elif IA_ARCH_ARM64
-#include <arm_acle.h>
+#  include <arm_acle.h>
 #endif
 
-namespace IACore {
-class Platform {
+namespace IACore
+{
+  class Platform
+  {
 public:
-  struct Capabilities {
+    struct Capabilities
+    {
       Mut<bool> hardware_crc32 = false;
     };
 
     static auto check_cpu() -> bool;
 
 #if IA_ARCH_X64
-  static auto cpuid(Const<i32> function, Const<i32> sub_function,
-                    Mut<i32 *> out) -> void;
+    static auto cpuid(const i32 function, const i32 sub_function, Mut<i32 *> out) -> void;
 #endif
 
     static auto get_architecture_name() -> const char *;
     static auto get_operating_system_name() -> const char *;
 
-  static auto get_capabilities() -> Ref<Capabilities> { return s_capabilities; }
+    static auto get_capabilities() -> Ref<Capabilities>
+    {
+      return s_capabilities;
+    }
 
 private:
     static Mut<Capabilities> s_capabilities;
-};
+  };
 } // namespace IACore

Src/IACore/inc/IACore/ProcessOps.hpp

@@ -22,48 +22,49 @@ using NativeProcessID = DWORD;
 #elif IA_PLATFORM_UNIX
 using NativeProcessID = pid_t;
 #else
-#error "This platform does not support IACore ProcessOps"
+#  error "This platform does not support IACore ProcessOps"
 #endif
 
-namespace IACore {
-struct ProcessHandle {
+namespace IACore
+{
+  struct ProcessHandle
+  {
     Mut<std::atomic<NativeProcessID>> id{0};
     Mut<std::atomic<bool>> is_running{false};
 
-  [[nodiscard]] auto is_active() const -> bool { return is_running && id != 0; }
+    [[nodiscard]] auto is_active() const -> bool
+    {
+      return is_running && id != 0;
+    }
 
 private:
     Mut<std::jthread> m_thread_handle;
 
     friend class ProcessOps;
-};
+  };
 
-class ProcessOps {
+  class ProcessOps
+  {
 public:
     static auto get_current_process_id() -> NativeProcessID;
 
-  static auto spawn_process_sync(
-      Ref<String> command, Ref<String> args,
-      Const<std::function<void(Const<StringView>)>> on_output_line_callback)
-      -> Result<i32>;
+    static auto spawn_process_sync(Ref<String> command, Ref<String> args,
+                                   const std::function<void(StringView)> on_output_line_callback) -> Result<i32>;
 
-  static auto spawn_process_async(
-      Ref<String> command, Ref<String> args,
-      Const<std::function<void(Const<StringView>)>> on_output_line_callback,
-      Const<std::function<void(Const<Result<i32>>)>> on_finish_callback)
+    static auto spawn_process_async(Ref<String> command, Ref<String> args,
+                                    const std::function<void(StringView)> on_output_line_callback,
+                                    const std::function<void(Result<i32>)> on_finish_callback)
         -> Result<Box<ProcessHandle>>;
 
     static auto terminate_process(Ref<Box<ProcessHandle>> handle) -> void;
 
 private:
-  static auto spawn_process_windows(
-      Ref<String> command, Ref<String> args,
-      Const<std::function<void(Const<StringView>)>> on_output_line_callback,
+    static auto spawn_process_windows(Ref<String> command, Ref<String> args,
+                                      const std::function<void(StringView)> on_output_line_callback,
                                       MutRef<std::atomic<NativeProcessID>> id) -> Result<i32>;
 
-  static auto spawn_process_posix(
-      Ref<String> command, Ref<String> args,
-      Const<std::function<void(Const<StringView>)>> on_output_line_callback,
+    static auto spawn_process_posix(Ref<String> command, Ref<String> args,
+                                    const std::function<void(StringView)> on_output_line_callback,
                                     MutRef<std::atomic<NativeProcessID>> id) -> Result<i32>;
-};
+  };
 } // namespace IACore

Src/IACore/inc/IACore/SIMD.hpp

@@ -18,33 +18,33 @@
 #include <IACore/PCH.hpp>
 
 #if defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-#pragma GCC diagnostic ignored "-Wgnu-zero-variadic-macro-arguments"
+#  pragma GCC diagnostic push
+#  pragma GCC diagnostic ignored "-Wunused-parameter"
+#  pragma GCC diagnostic ignored "-Wgnu-zero-variadic-macro-arguments"
 #endif
 
 #include <hwy/highway.h>
 
 #if defined(__clang__)
-#pragma GCC diagnostic pop
+#  pragma GCC diagnostic pop
 #endif
 
-namespace IACore {
-namespace hn = hwy::HWY_NAMESPACE;
+namespace IACore
+{
+  namespace hn = hwy::HWY_NAMESPACE;
 
 #if HWY_TARGET == HWY_SCALAR
-#pragma message(                                                               \
-    "Warning: Configuration mismatch. IACore is being compiled for SCALAR SIMD (Slow)")
+#  pragma message("Warning: Configuration mismatch. IACore is being compiled for SCALAR SIMD (Slow)")
 #endif
 
-class alignas(16) IntVec4 {
+  class alignas(16) IntVec4
+  {
 public:
     IntVec4() = default;
 
-  inline explicit IntVec4(Const<u32> s);
-  inline explicit IntVec4(Const<const u32 *> values);
-  inline explicit IntVec4(Const<u32> a, Const<u32> b, Const<u32> c,
-                          Const<u32> d);
+    inline explicit IntVec4(const u32 s);
+    inline explicit IntVec4(const u32 *values);
+    inline explicit IntVec4(const u32 a, const u32 b, const u32 c, const u32 d);
 
     inline auto operator+(Ref<IntVec4> other) const -> IntVec4;
     inline auto operator-(Ref<IntVec4> other) const -> IntVec4;
@@ -55,45 +55,44 @@ public:
     inline auto operator^(Ref<IntVec4> other) const -> IntVec4;
     inline auto operator~() const -> IntVec4;
 
-  inline auto operator<<(Const<u32> amount) const -> IntVec4;
-  inline auto operator>>(Const<u32> amount) const -> IntVec4;
+    inline auto operator<<(const u32 amount) const -> IntVec4;
+    inline auto operator>>(const u32 amount) const -> IntVec4;
 
     [[nodiscard]] inline auto sat_add(Ref<IntVec4> other) const -> IntVec4;
     [[nodiscard]] inline auto sat_sub(Ref<IntVec4> other) const -> IntVec4;
 
-  [[nodiscard]] inline auto clamp(Const<u32> min, Const<u32> max) const
-      -> IntVec4;
+    [[nodiscard]] inline auto clamp(const u32 min, const u32 max) const -> IntVec4;
 
-  [[nodiscard]] inline auto mult_add(Ref<IntVec4> multiplier,
-                                     Ref<IntVec4> addend) const -> IntVec4;
+    [[nodiscard]] inline auto mult_add(Ref<IntVec4> multiplier, Ref<IntVec4> addend) const -> IntVec4;
 
     inline auto store(Mut<u32 *> values) -> void;
-  static inline auto load(Const<const u32 *> values) -> IntVec4;
+    static inline auto load(const u32 *values) -> IntVec4;
 
 private:
     using Tag = hn::FixedTag<u32, 4>;
 
     Mut<hn::Vec<Tag>> m_data;
 
-  inline explicit IntVec4(Const<hn::Vec<Tag>> v) : m_data(v) {}
-};
+    inline explicit IntVec4(const hn::Vec<Tag> v) : m_data(v)
+    {
+    }
+  };
 
-class alignas(16) FloatVec4 {
+  class alignas(16) FloatVec4
+  {
 public:
     FloatVec4() = default;
 
-  inline explicit FloatVec4(Const<f32> s);
-  inline explicit FloatVec4(Const<const f32 *> values);
-  inline explicit FloatVec4(Const<f32> a, Const<f32> b, Const<f32> c,
-                            Const<f32> d);
+    inline explicit FloatVec4(const f32 s);
+    inline explicit FloatVec4(const f32 *values);
+    inline explicit FloatVec4(const f32 a, const f32 b, const f32 c, const f32 d);
 
     inline auto operator+(Ref<FloatVec4> other) const -> FloatVec4;
     inline auto operator-(Ref<FloatVec4> other) const -> FloatVec4;
     inline auto operator*(Ref<FloatVec4> other) const -> FloatVec4;
     inline auto operator/(Ref<FloatVec4> other) const -> FloatVec4;
 
-  [[nodiscard]] inline auto clamp(Const<f32> min, Const<f32> max) const
-      -> FloatVec4;
+    [[nodiscard]] inline auto clamp(const f32 min, const f32 max) const -> FloatVec4;
 
     [[nodiscard]] inline auto abs() const -> FloatVec4;
     [[nodiscard]] inline auto sqrt() const -> FloatVec4;
@@ -102,179 +101,218 @@ public:
 
     [[nodiscard]] inline auto dot(Ref<FloatVec4> other) const -> f32;
 
-  [[nodiscard]] inline auto mult_add(Ref<FloatVec4> multiplier,
-                                     Ref<FloatVec4> addend) const -> FloatVec4;
+    [[nodiscard]] inline auto mult_add(Ref<FloatVec4> multiplier, Ref<FloatVec4> addend) const -> FloatVec4;
 
     inline auto store(Mut<f32 *> values) -> void;
-  static inline auto load(Const<const f32 *> values) -> FloatVec4;
+    static inline auto load(const f32 *values) -> FloatVec4;
 
 private:
     using Tag = hn::FixedTag<f32, 4>;
 
     Mut<hn::Vec<Tag>> m_data;
 
-  inline explicit FloatVec4(Const<hn::Vec<Tag>> v) : m_data(v) {}
-};
+    inline explicit FloatVec4(const hn::Vec<Tag> v) : m_data(v)
+    {
+    }
+  };
 } // namespace IACore
 
-namespace IACore {
-IntVec4::IntVec4(Const<u32> s) {
-  Const<Tag> d;
+namespace IACore
+{
+  IntVec4::IntVec4(const u32 s)
+  {
+    const Tag d;
     m_data = hn::Set(d, s);
-}
+  }
 
-IntVec4::IntVec4(Const<const u32 *> values) {
-  Const<Tag> data;
+  IntVec4::IntVec4(const u32 *values)
+  {
+    const Tag data;
     m_data = hn::Load(data, values);
-}
+  }
 
-IntVec4::IntVec4(Const<u32> a, Const<u32> b, Const<u32> c, Const<u32> d) {
-  Const<Tag> data;
+  IntVec4::IntVec4(const u32 a, const u32 b, const u32 c, const u32 d)
+  {
+    const Tag data;
     alignas(16) Mut<Array<u32, 4>> values = {a, b, c, d};
     m_data = hn::Load(data, values.data());
-}
+  }
 
-auto IntVec4::operator+(Ref<IntVec4> other) const -> IntVec4 {
+  auto IntVec4::operator+(Ref<IntVec4> other) const -> IntVec4
+  {
     return IntVec4(hn::Add(m_data, other.m_data));
-}
+  }
 
-auto IntVec4::operator-(Ref<IntVec4> other) const -> IntVec4 {
+  auto IntVec4::operator-(Ref<IntVec4> other) const -> IntVec4
+  {
     return IntVec4(hn::Sub(m_data, other.m_data));
-}
+  }
 
-auto IntVec4::operator*(Ref<IntVec4> other) const -> IntVec4 {
+  auto IntVec4::operator*(Ref<IntVec4> other) const -> IntVec4
+  {
     return IntVec4(hn::Mul(m_data, other.m_data));
-}
+  }
 
-auto IntVec4::operator&(Ref<IntVec4> other) const -> IntVec4 {
+  auto IntVec4::operator&(Ref<IntVec4> other) const -> IntVec4
+  {
     return IntVec4(hn::And(m_data, other.m_data));
-}
+  }
 
-auto IntVec4::operator|(Ref<IntVec4> other) const -> IntVec4 {
+  auto IntVec4::operator|(Ref<IntVec4> other) const -> IntVec4
+  {
     return IntVec4(hn::Or(m_data, other.m_data));
-}
+  }
 
-auto IntVec4::operator^(Ref<IntVec4> other) const -> IntVec4 {
+  auto IntVec4::operator^(Ref<IntVec4> other) const -> IntVec4
+  {
     return IntVec4(hn::Xor(m_data, other.m_data));
-}
+  }
 
-auto IntVec4::operator~() const -> IntVec4 { return IntVec4(hn::Not(m_data)); }
+  auto IntVec4::operator~() const -> IntVec4
+  {
+    return IntVec4(hn::Not(m_data));
+  }
 
-auto IntVec4::operator<<(Const<u32> amount) const -> IntVec4 {
+  auto IntVec4::operator<<(const u32 amount) const -> IntVec4
+  {
     return IntVec4(hn::ShiftLeftSame(m_data, amount));
-}
+  }
 
-auto IntVec4::operator>>(Const<u32> amount) const -> IntVec4 {
+  auto IntVec4::operator>>(const u32 amount) const -> IntVec4
+  {
     return IntVec4(hn::ShiftRightSame(m_data, amount));
-}
+  }
 
-auto IntVec4::mult_add(Ref<IntVec4> multiplier, Ref<IntVec4> addend) const
-    -> IntVec4 {
+  auto IntVec4::mult_add(Ref<IntVec4> multiplier, Ref<IntVec4> addend) const -> IntVec4
+  {
     return IntVec4(hn::MulAdd(m_data, multiplier.m_data, addend.m_data));
-}
+  }
 
-auto IntVec4::sat_add(Ref<IntVec4> other) const -> IntVec4 {
+  auto IntVec4::sat_add(Ref<IntVec4> other) const -> IntVec4
+  {
     return IntVec4(hn::SaturatedAdd(m_data, other.m_data));
-}
+  }
 
-auto IntVec4::sat_sub(Ref<IntVec4> other) const -> IntVec4 {
+  auto IntVec4::sat_sub(Ref<IntVec4> other) const -> IntVec4
+  {
     return IntVec4(hn::SaturatedSub(m_data, other.m_data));
-}
+  }
 
-auto IntVec4::clamp(Const<u32> min, Const<u32> max) const -> IntVec4 {
-  Const<Tag> d;
-  Const<hn::Vec<Tag>> v_min = hn::Set(d, min);
-  Const<hn::Vec<Tag>> v_max = hn::Set(d, max);
+  auto IntVec4::clamp(const u32 min, const u32 max) const -> IntVec4
+  {
+    const Tag d;
+    const hn::Vec<Tag> v_min = hn::Set(d, min);
+    const hn::Vec<Tag> v_max = hn::Set(d, max);
     return IntVec4(hn::Min(hn::Max(m_data, v_min), v_max));
-}
+  }
 
-auto IntVec4::store(Mut<u32 *> values) -> void {
-  Const<Tag> d;
+  auto IntVec4::store(Mut<u32 *> values) -> void
+  {
+    const Tag d;
     hn::Store(m_data, d, values);
-}
+  }
 
-auto IntVec4::load(Const<const u32 *> values) -> IntVec4 {
-  Const<Tag> d;
+  auto IntVec4::load(const u32 *values) -> IntVec4
+  {
+    const Tag d;
     return IntVec4(hn::Load(d, values));
-}
+  }
 } // namespace IACore
 
-namespace IACore {
-FloatVec4::FloatVec4(Const<f32> s) {
-  Const<Tag> d;
+namespace IACore
+{
+  FloatVec4::FloatVec4(const f32 s)
+  {
+    const Tag d;
     m_data = hn::Set(d, s);
-}
+  }
 
-FloatVec4::FloatVec4(Const<const f32 *> values) {
-  Const<Tag> d;
+  FloatVec4::FloatVec4(const f32 *values)
+  {
+    const Tag d;
     m_data = hn::Load(d, values);
-}
+  }
 
-FloatVec4::FloatVec4(Const<f32> a, Const<f32> b, Const<f32> c, Const<f32> d) {
-  Const<Tag> data;
+  FloatVec4::FloatVec4(const f32 a, const f32 b, const f32 c, const f32 d)
+  {
+    const Tag data;
     alignas(16) Mut<Array<f32, 4>> temp = {a, b, c, d};
     m_data = hn::Load(data, temp.data());
-}
+  }
 
-auto FloatVec4::operator+(Ref<FloatVec4> other) const -> FloatVec4 {
+  auto FloatVec4::operator+(Ref<FloatVec4> other) const -> FloatVec4
+  {
     return FloatVec4(hn::Add(m_data, other.m_data));
-}
+  }
 
-auto FloatVec4::operator-(Ref<FloatVec4> other) const -> FloatVec4 {
+  auto FloatVec4::operator-(Ref<FloatVec4> other) const -> FloatVec4
+  {
     return FloatVec4(hn::Sub(m_data, other.m_data));
-}
+  }
 
-auto FloatVec4::operator*(Ref<FloatVec4> other) const -> FloatVec4 {
+  auto FloatVec4::operator*(Ref<FloatVec4> other) const -> FloatVec4
+  {
     return FloatVec4(hn::Mul(m_data, other.m_data));
-}
+  }
 
-auto FloatVec4::operator/(Ref<FloatVec4> other) const -> FloatVec4 {
+  auto FloatVec4::operator/(Ref<FloatVec4> other) const -> FloatVec4
+  {
     return FloatVec4(hn::Div(m_data, other.m_data));
-}
+  }
 
-auto FloatVec4::mult_add(Ref<FloatVec4> multiplier, Ref<FloatVec4> addend) const
-    -> FloatVec4 {
+  auto FloatVec4::mult_add(Ref<FloatVec4> multiplier, Ref<FloatVec4> addend) const -> FloatVec4
+  {
     return FloatVec4(hn::MulAdd(m_data, multiplier.m_data, addend.m_data));
-}
+  }
 
-auto FloatVec4::clamp(Const<f32> min, Const<f32> max) const -> FloatVec4 {
-  Const<Tag> d;
-  Const<hn::Vec<Tag>> v_min = hn::Set(d, min);
-  Const<hn::Vec<Tag>> v_max = hn::Set(d, max);
+  auto FloatVec4::clamp(const f32 min, const f32 max) const -> FloatVec4
+  {
+    const Tag d;
+    const hn::Vec<Tag> v_min = hn::Set(d, min);
+    const hn::Vec<Tag> v_max = hn::Set(d, max);
     return FloatVec4(hn::Min(hn::Max(m_data, v_min), v_max));
-}
+  }
 
-auto FloatVec4::sqrt() const -> FloatVec4 {
+  auto FloatVec4::sqrt() const -> FloatVec4
+  {
     return FloatVec4(hn::Sqrt(m_data));
-}
+  }
 
-auto FloatVec4::rsqrt() const -> FloatVec4 {
+  auto FloatVec4::rsqrt() const -> FloatVec4
+  {
     return FloatVec4(hn::ApproximateReciprocalSqrt(m_data));
-}
+  }
 
-auto FloatVec4::abs() const -> FloatVec4 { return FloatVec4(hn::Abs(m_data)); }
+  auto FloatVec4::abs() const -> FloatVec4
+  {
+    return FloatVec4(hn::Abs(m_data));
+  }
 
-auto FloatVec4::dot(Ref<FloatVec4> other) const -> f32 {
-  Const<Tag> d;
-  Const<hn::Vec<Tag>> v_mul = hn::Mul(m_data, other.m_data);
+  auto FloatVec4::dot(Ref<FloatVec4> other) const -> f32
+  {
+    const Tag d;
+    const hn::Vec<Tag> v_mul = hn::Mul(m_data, other.m_data);
     return hn::ReduceSum(d, v_mul);
-}
+  }
 
-auto FloatVec4::normalize() const -> FloatVec4 {
-  Const<Tag> d;
-  Const<hn::Vec<Tag>> v_mul = hn::Mul(m_data, m_data);
-  Const<hn::Vec<Tag>> v_len_sq = hn::SumOfLanes(d, v_mul);
-  Const<hn::Vec<Tag>> v_inv_len = hn::ApproximateReciprocalSqrt(v_len_sq);
+  auto FloatVec4::normalize() const -> FloatVec4
+  {
+    const Tag d;
+    const hn::Vec<Tag> v_mul = hn::Mul(m_data, m_data);
+    const hn::Vec<Tag> v_len_sq = hn::SumOfLanes(d, v_mul);
+    const hn::Vec<Tag> v_inv_len = hn::ApproximateReciprocalSqrt(v_len_sq);
     return FloatVec4(hn::Mul(m_data, v_inv_len));
-}
+  }
 
-auto FloatVec4::store(Mut<f32 *> values) -> void {
-  Const<Tag> d;
+  auto FloatVec4::store(Mut<f32 *> values) -> void
+  {
+    const Tag d;
     hn::Store(m_data, d, values);
-}
+  }
 
-auto FloatVec4::load(Const<const f32 *> values) -> FloatVec4 {
-  Const<Tag> d;
+  auto FloatVec4::load(const f32 *values) -> FloatVec4
+  {
+    const Tag d;
     return FloatVec4(hn::Load(d, values));
-}
+  }
 } // namespace IACore

Src/IACore/inc/IACore/SocketOps.hpp

@@ -18,43 +18,48 @@
 #include <IACore/PCH.hpp>
 
 #if IA_PLATFORM_WINDOWS
-#include <afunix.h>
-#include <winsock2.h>
-#include <ws2tcpip.h>
-#pragma comment(lib, "ws2_32.lib")
+#  include <winsock2.h>
+#  include <ws2tcpip.h>
+#  include <afunix.h>
+#  pragma comment(lib, "ws2_32.lib")
 #elif IA_PLATFORM_UNIX
-#include <netinet/in.h>
-#include <sys/socket.h>
-#include <sys/types.h>
-#include <sys/un.h>
-#ifndef INVALID_SOCKET
-#define INVALID_SOCKET -1
-#endif
+#  include <netinet/in.h>
+#  include <sys/socket.h>
+#  include <sys/types.h>
+#  include <sys/un.h>
+#  ifndef INVALID_SOCKET
+#    define INVALID_SOCKET -1
+#  endif
 #else
-#error "IACore SocketOps is not supported on this platform."
+#  error "IACore SocketOps is not supported on this platform."
 #endif
 
-namespace IACore {
+namespace IACore
+{
 #if IA_PLATFORM_WINDOWS
-using SocketHandle = SOCKET;
+  using SocketHandle = SOCKET;
 #elif IA_PLATFORM_UNIX
-using SocketHandle = i32;
+  using SocketHandle = i32;
 #endif
 
-class SocketOps {
+  class SocketOps
+  {
 public:
     // SocketOps correctly handles multiple calls to initialize and terminate.
     // Make sure every initialize call is paired with a corresponding terminate
     // call.
-  static auto initialize() -> Result<void> {
+    static auto initialize() -> Result<void>
+    {
       s_init_count++;
-    if (s_init_count > 1) {
+      if (s_init_count > 1)
+      {
         return {};
       }
 #if IA_PLATFORM_WINDOWS
       Mut<WSADATA> wsa_data;
-    Const<i32> res = WSAStartup(MAKEWORD(2, 2), &wsa_data);
-    if (res != 0) {
+      const i32 res = WSAStartup(MAKEWORD(2, 2), &wsa_data);
+      if (res != 0)
+      {
         s_init_count--;
         return fail("WSAStartup failed with error: {}", res);
       }
@@ -65,9 +70,11 @@ public:
     // SocketOps correctly handles multiple calls to initialize and terminate.
     // Make sure every initialize call is paired with a corresponding terminate
     // call.
-  static auto terminate() -> void {
+    static auto terminate() -> void
+    {
       s_init_count--;
-    if (s_init_count > 0) {
+      if (s_init_count > 0)
+      {
         return;
       }
 #if IA_PLATFORM_WINDOWS
@@ -75,31 +82,34 @@ public:
 #endif
     }
 
-  static auto is_initialized() -> bool { return s_init_count > 0; }
+    static auto is_initialized() -> bool
+    {
+      return s_init_count > 0;
+    }
 
-  static auto is_port_available_tcp(Const<u16> port) -> bool {
+    static auto is_port_available_tcp(const u16 port) -> bool
+    {
       return is_port_available(port, SOCK_STREAM);
     }
 
-  static auto is_port_available_udp(Const<u16> port) -> bool {
+    static auto is_port_available_udp(const u16 port) -> bool
+    {
       return is_port_available(port, SOCK_DGRAM);
     }
 
     static auto is_would_block() -> bool;
 
-  static auto close(Const<SocketHandle> sock) -> void;
+    static auto close(const SocketHandle sock) -> void;
 
-  static auto listen(Const<SocketHandle> sock, Const<i32> queue_size = 5)
-      -> Result<void>;
+    static auto listen(const SocketHandle sock, const i32 queue_size = 5) -> Result<void>;
 
     static auto create_unix_socket() -> Result<SocketHandle>;
 
-  static auto bind_unix_socket(Const<SocketHandle> sock,
-                               Const<const char *> path) -> Result<void>;
-  static auto connect_unix_socket(Const<SocketHandle> sock,
-                                  Const<const char *> path) -> Result<void>;
+    static auto bind_unix_socket(const SocketHandle sock, const char *path) -> Result<void>;
+    static auto connect_unix_socket(const SocketHandle sock, const char *path) -> Result<void>;
 
-  static auto unlink_file(Const<const char *> path) -> void {
+    static auto unlink_file(const char *path) -> void
+    {
 #if IA_PLATFORM_WINDOWS
       DeleteFileA(path);
 #elif IA_PLATFORM_UNIX
@@ -108,9 +118,9 @@ public:
     }
 
 private:
-  static auto is_port_available(Const<u16> port, Const<i32> type) -> bool;
+    static auto is_port_available(const u16 port, const i32 type) -> bool;
 
 private:
     static Mut<i32> s_init_count;
-};
+  };
 } // namespace IACore

Src/IACore/inc/IACore/StreamReader.hpp

@@ -19,10 +19,13 @@
 #include <algorithm>
 #include <cstring>
 
-namespace IACore {
-class StreamReader {
+namespace IACore
+{
+  class StreamReader
+  {
 public:
-  enum class StorageType {
+    enum class StorageType
+    {
       NonOwning,
       OwningMmap,
       OwningVector,
@@ -31,7 +34,7 @@ public:
     static auto create_from_file(Ref<Path> path) -> Result<StreamReader>;
 
     explicit StreamReader(ForwardRef<Vec<u8>> data);
-  explicit StreamReader(Const<Span<const u8>> data);
+    explicit StreamReader(const Span<const u8> data);
     ~StreamReader();
 
     StreamReader(ForwardRef<StreamReader> other);
@@ -40,29 +43,41 @@ public:
     StreamReader(Ref<StreamReader>) = delete;
     auto operator=(Ref<StreamReader>) -> MutRef<StreamReader> = delete;
 
-  auto read(Mut<void *> buffer, Const<usize> size) -> Result<void>;
+    auto read(Mut<void *> buffer, const usize size) -> Result<void>;
 
-  template <typename T>
+    template<typename T>
     [[nodiscard("Check for EOF")]]
     auto read() -> Result<T>;
 
-  auto skip(Const<usize> amount) -> void {
+    auto skip(const usize amount) -> void
+    {
       m_cursor = std::min(m_cursor + amount, m_data_size);
     }
 
-  auto seek(Const<usize> pos) -> void {
+    auto seek(const usize pos) -> void
+    {
       m_cursor = (pos > m_data_size) ? m_data_size : pos;
     }
 
-  [[nodiscard]] auto cursor() const -> usize { return m_cursor; }
+    [[nodiscard]] auto cursor() const -> usize
+    {
+      return m_cursor;
+    }
 
-  [[nodiscard]] auto size() const -> usize { return m_data_size; }
+    [[nodiscard]] auto size() const -> usize
+    {
+      return m_data_size;
+    }
 
-  [[nodiscard]] auto remaining() const -> usize {
+    [[nodiscard]] auto remaining() const -> usize
+    {
       return m_data_size - m_cursor;
     }
 
-  [[nodiscard]] auto is_eof() const -> bool { return m_cursor >= m_data_size; }
+    [[nodiscard]] auto is_eof() const -> bool
+    {
+      return m_cursor >= m_data_size;
+    }
 
 private:
     Mut<const u8 *> m_data = nullptr;
@@ -70,11 +85,12 @@ private:
     Mut<usize> m_data_size = 0;
     Mut<Vec<u8>> m_owning_vector;
     Mut<StorageType> m_storage_type = StorageType::NonOwning;
-};
+  };
 
-inline auto StreamReader::read(Mut<void *> buffer, Const<usize> size)
-    -> Result<void> {
-  if (m_cursor + size > m_data_size) [[unlikely]] {
+  inline auto StreamReader::read(Mut<void *> buffer, const usize size) -> Result<void>
+  {
+    if (m_cursor + size > m_data_size) [[unlikely]]
+    {
       return fail("Unexpected EOF while reading");
     }
 
@@ -82,17 +98,18 @@ inline auto StreamReader::read(Mut<void *> buffer, Const<usize> size)
     m_cursor += size;
 
     return {};
-}
+  }
 
-template <typename T>
-[[nodiscard("Check for EOF")]]
-inline auto StreamReader::read() -> Result<T> {
-  static_assert(std::is_trivially_copyable_v<T>,
-                "T must be trivially copyable to read via memcpy");
+  template<typename T>
+  [[nodiscard("Check for EOF")]]
+  inline auto StreamReader::read() -> Result<T>
+  {
+    static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable to read via memcpy");
 
-  constexpr Const<usize> SIZE = sizeof(T);
+    constexpr const usize SIZE = sizeof(T);
 
-  if (m_cursor + SIZE > m_data_size) [[unlikely]] {
+    if (m_cursor + SIZE > m_data_size) [[unlikely]]
+    {
       return fail("Unexpected EOF while reading");
     }
 
@@ -101,6 +118,6 @@ inline auto StreamReader::read() -> Result<T> {
     m_cursor += SIZE;
 
     return value;
-}
+  }
 
 } // namespace IACore

Src/IACore/inc/IACore/StreamWriter.hpp

@@ -17,11 +17,14 @@
 
 #include <IACore/PCH.hpp>
 
-namespace IACore {
+namespace IACore
+{
 
-class StreamWriter {
+  class StreamWriter
+  {
 public:
-  enum class StorageType {
+    enum class StorageType
+    {
       NonOwning,
       OwningFile,
       OwningVector,
@@ -30,7 +33,7 @@ public:
     static auto create_from_file(Ref<Path> path) -> Result<StreamWriter>;
 
     StreamWriter();
-  explicit StreamWriter(Const<Span<u8>> data);
+    explicit StreamWriter(const Span<u8> data);
 
     StreamWriter(ForwardRef<StreamWriter> other);
     auto operator=(ForwardRef<StreamWriter> other) -> MutRef<StreamWriter>;
@@ -40,14 +43,20 @@ public:
 
     ~StreamWriter();
 
-  auto write(Const<u8> byte, Const<usize> count) -> Result<void>;
-  auto write(Const<const void *> buffer, Const<usize> size) -> Result<void>;
+    auto write(const u8 byte, const usize count) -> Result<void>;
+    auto write(const void *buffer, const usize size) -> Result<void>;
 
-  template <typename T> auto write(Ref<T> value) -> Result<void>;
+    template<typename T> auto write(Ref<T> value) -> Result<void>;
 
-  [[nodiscard]] auto data() const -> const u8 * { return m_buffer; }
+    [[nodiscard]] auto data() const -> const u8 *
+    {
+      return m_buffer;
+    }
 
-  [[nodiscard]] auto cursor() const -> usize { return m_cursor; }
+    [[nodiscard]] auto cursor() const -> usize
+    {
+      return m_cursor;
+    }
 
     auto flush() -> Result<void>;
 
@@ -61,11 +70,11 @@ private:
 
 private:
     auto flush_to_disk() -> Result<void>;
-};
+  };
 
-template <typename T>
-inline auto StreamWriter::write(Ref<T> value) -> Result<void> {
+  template<typename T> inline auto StreamWriter::write(Ref<T> value) -> Result<void>
+  {
     return write(&value, sizeof(T));
-}
+  }
 
 } // namespace IACore

Src/IACore/inc/IACore/StringOps.hpp

@@ -17,10 +17,12 @@
 
 #include <IACore/PCH.hpp>
 
-namespace IACore {
-class StringOps {
+namespace IACore
+{
+  class StringOps
+  {
 public:
-  static auto encode_base64(Const<Span<Const<u8>>> data) -> String;
+    static auto encode_base64(const Span<const u8> data) -> String;
     static auto decode_base64(Ref<String> data) -> Vec<u8>;
-};
+  };
 } // namespace IACore

Src/IACore/inc/IACore/Utils.hpp

@@ -19,8 +19,10 @@
 
 #include <algorithm>
 
-namespace IACore {
-class Utils {
+namespace IACore
+{
+  class Utils
+  {
 public:
     static auto get_unix_time() -> u64;
 
@@ -29,63 +31,66 @@ public:
     static auto get_seconds_count() -> f64;
 
     static auto get_random() -> f32;
-  static auto get_random(Const<u64> max) -> u64;
-  static auto get_random(Const<i64> min, Const<i64> max) -> i64;
+    static auto get_random(const u64 max) -> u64;
+    static auto get_random(const i64 min, const i64 max) -> i64;
 
-  static auto sleep(Const<u64> milliseconds) -> void;
+    static auto sleep(const u64 milliseconds) -> void;
 
-  static auto binary_to_hex_string(Const<Span<Const<u8>>> data) -> String;
+    static auto binary_to_hex_string(const Span<const u8> data) -> String;
 
-  static auto hex_string_to_binary(Const<StringView> hex) -> Result<Vec<u8>>;
+    static auto hex_string_to_binary(const StringView hex) -> Result<Vec<u8>>;
 
-  template <typename Range>
-  inline static auto sort(ForwardRef<Range> range) -> void {
+    template<typename Range> inline static auto sort(ForwardRef<Range> range) -> void
+    {
       std::ranges::sort(std::forward<Range>(range));
     }
 
-  template <typename Range, typename T>
-  inline static auto binary_search_left(ForwardRef<Range> range, Ref<T> value)
-      -> auto {
+    template<typename Range, typename T>
+    inline static auto binary_search_left(ForwardRef<Range> range, Ref<T> value) -> auto
+    {
       return std::ranges::lower_bound(std::forward<Range>(range), value);
     }
 
-  template <typename Range, typename T>
-  inline static auto binary_search_right(ForwardRef<Range> range, Ref<T> value)
-      -> auto {
+    template<typename Range, typename T>
+    inline static auto binary_search_right(ForwardRef<Range> range, Ref<T> value) -> auto
+    {
       return std::ranges::upper_bound(std::forward<Range>(range), value);
     }
 
-  template <typename T>
-  inline static auto hash_combine(MutRef<u64> seed, Ref<T> v) -> void {
+    template<typename T> inline static auto hash_combine(MutRef<u64> seed, Ref<T> v) -> void
+    {
       Mut<u64> h = 0;
 
-    if constexpr (std::is_constructible_v<StringView, T>) {
-      Const<StringView> sv(v);
-      Const<ankerl::unordered_dense::hash<StringView>> hasher;
+      if constexpr (std::is_constructible_v<StringView, T>)
+      {
+        const StringView sv(v);
+        const ankerl::unordered_dense::hash<StringView> hasher;
         h = hasher(sv);
-    } else {
-      Const<ankerl::unordered_dense::hash<T>> hasher;
+      }
+      else
+      {
+        const ankerl::unordered_dense::hash<T> hasher;
         h = hasher(v);
       }
 
       seed ^= h + 0x9e3779b97f4a7c15 + (seed << 6) + (seed >> 2);
     }
 
-  template <typename... Args>
-  inline static auto compute_hash(Ref<Args>... args) -> u64 {
+    template<typename... Args> inline static auto compute_hash(Ref<Args>... args) -> u64
+    {
       Mut<u64> seed = 0;
       (hash_combine(seed, args), ...);
       return seed;
     }
 
-  template <typename T, typename... MemberPtrs>
-  inline static auto compute_hash_flat(Ref<T> obj, Const<MemberPtrs>... members)
-      -> u64 {
+    template<typename T, typename... MemberPtrs>
+    inline static auto compute_hash_flat(Ref<T> obj, const MemberPtrs... members) -> u64
+    {
       Mut<u64> seed = 0;
       (hash_combine(seed, obj.*members), ...);
       return seed;
     }
-};
+  };
 } // namespace IACore
 
 // -----------------------------------------------------------------------------
@@ -98,10 +103,12 @@ public:
 //   IA_MAKE_HASHABLE(Vector3, &Vector3::x, &Vector3::y, &Vector3::z)
 // -----------------------------------------------------------------------------
 #define IA_MAKE_HASHABLE(Type, ...)                                                                                    \
-  template <> struct ankerl::unordered_dense::hash<Type> {                     \
+  template<> struct ankerl::unordered_dense::hash<Type>                                                                \
+  {                                                                                                                    \
     using is_avalanching = void;                                                                                       \
     IA_NODISCARD                                                                                                       \
-    auto operator()(IACore::Ref<Type> v) const noexcept -> IACore::u64 {       \
+    auto operator()(IACore::Ref<Type> v) const noexcept -> IACore::u64                                                 \
+    {                                                                                                                  \
       return IACore::Utils::compute_hash_flat(v, __VA_ARGS__);                                                         \
     }                                                                                                                  \
   };

Src/IACore/inc/IACore/XML.hpp

@@ -19,8 +19,10 @@
 
 #include <pugixml.hpp>
 
-namespace IACore {
-class XML {
+namespace IACore
+{
+  class XML
+  {
 public:
     using Node = pugi::xml_node;
     using Document = pugi::xml_document;
@@ -29,11 +31,9 @@ public:
     static auto parse_from_string(Ref<String> data) -> Result<Document>;
     static auto parse_from_file(Ref<Path> path) -> Result<Document>;
 
-  static auto serialize_to_string(Ref<Node> node, Const<bool> escape = false)
-      -> String;
-  static auto serialize_to_string(Ref<Document> doc, Const<bool> escape = false)
-      -> String;
+    static auto serialize_to_string(Ref<Node> node, const bool escape = false) -> String;
+    static auto serialize_to_string(Ref<Document> doc, const bool escape = false) -> String;
 
     static auto escape_xml_string(Ref<String> xml) -> String;
-};
+  };
 } // namespace IACore

Tests/Unit/AsyncOps.cpp

@@ -20,18 +20,24 @@
 
 using namespace IACore;
 
-struct SchedulerGuard {
-  SchedulerGuard(u8 worker_count = 2) {
+struct SchedulerGuard
+{
+  SchedulerGuard(u8 worker_count = 2)
+  {
 
-    (void)AsyncOps::initialize_scheduler(worker_count);
+    (void) AsyncOps::initialize_scheduler(worker_count);
   }
 
-  ~SchedulerGuard() { AsyncOps::terminate_scheduler(); }
+  ~SchedulerGuard()
+  {
+    AsyncOps::terminate_scheduler();
+  }
 };
 
 IAT_BEGIN_BLOCK(Core, AsyncOps)
 
-auto test_initialization() -> bool {
+auto test_initialization() -> bool
+{
 
   AsyncOps::terminate_scheduler();
 
@@ -50,14 +56,14 @@ auto test_initialization() -> bool {
   return true;
 }
 
-auto test_basic_execution() -> bool {
+auto test_basic_execution() -> bool
+{
   SchedulerGuard guard(2);
 
   AsyncOps::Schedule schedule;
   std::atomic<i32> run_count{0};
 
-  AsyncOps::schedule_task([&](AsyncOps::WorkerId) { run_count++; }, 0,
-                          &schedule);
+  AsyncOps::schedule_task([&](AsyncOps::WorkerId) { run_count++; }, 0, &schedule);
 
   AsyncOps::wait_for_schedule_completion(&schedule);
 
@@ -66,14 +72,16 @@ auto test_basic_execution() -> bool {
   return true;
 }
 
-auto test_concurrency() -> bool {
+auto test_concurrency() -> bool
+{
   SchedulerGuard guard(4);
 
   AsyncOps::Schedule schedule;
   std::atomic<i32> run_count{0};
   const i32 total_tasks = 100;
 
-  for (i32 i = 0; i < total_tasks; ++i) {
+  for (i32 i = 0; i < total_tasks; ++i)
+  {
     AsyncOps::schedule_task(
         [&](AsyncOps::WorkerId) {
           std::this_thread::sleep_for(std::chrono::microseconds(10));
@@ -89,17 +97,16 @@ auto test_concurrency() -> bool {
   return true;
 }
 
-auto test_priorities() -> bool {
+auto test_priorities() -> bool
+{
   SchedulerGuard guard(2);
   AsyncOps::Schedule schedule;
   std::atomic<i32> high_priority_ran{0};
   std::atomic<i32> normal_priority_ran{0};
 
-  AsyncOps::schedule_task([&](AsyncOps::WorkerId) { high_priority_ran++; }, 0,
-                          &schedule, AsyncOps::Priority::High);
+  AsyncOps::schedule_task([&](AsyncOps::WorkerId) { high_priority_ran++; }, 0, &schedule, AsyncOps::Priority::High);
 
-  AsyncOps::schedule_task([&](AsyncOps::WorkerId) { normal_priority_ran++; }, 0,
-                          &schedule, AsyncOps::Priority::Normal);
+  AsyncOps::schedule_task([&](AsyncOps::WorkerId) { normal_priority_ran++; }, 0, &schedule, AsyncOps::Priority::Normal);
 
   AsyncOps::wait_for_schedule_completion(&schedule);
 
@@ -109,14 +116,16 @@ auto test_priorities() -> bool {
   return true;
 }
 
-auto test_run_task_fire_and_forget() -> bool {
+auto test_run_task_fire_and_forget() -> bool
+{
   SchedulerGuard guard(2);
 
   std::atomic<bool> executed{false};
 
   AsyncOps::run_task([&]() { executed = true; });
 
-  for (int i = 0; i < 100; ++i) {
+  for (int i = 0; i < 100; ++i)
+  {
     if (executed.load())
       break;
     std::this_thread::sleep_for(std::chrono::milliseconds(10));
@@ -127,7 +136,8 @@ auto test_run_task_fire_and_forget() -> bool {
   return true;
 }
 
-auto test_cancellation_safety() -> bool {
+auto test_cancellation_safety() -> bool
+{
   SchedulerGuard guard(2);
 
   AsyncOps::cancel_tasks_of_tag(999);
@@ -135,8 +145,7 @@ auto test_cancellation_safety() -> bool {
   AsyncOps::Schedule schedule;
   std::atomic<i32> counter{0};
 
-  AsyncOps::schedule_task([&](AsyncOps::WorkerId) { counter++; }, 10,
-                          &schedule);
+  AsyncOps::schedule_task([&](AsyncOps::WorkerId) { counter++; }, 10, &schedule);
 
   AsyncOps::wait_for_schedule_completion(&schedule);
   IAT_CHECK_EQ(counter.load(), 1);

Tests/Unit/CLI.cpp

@@ -20,7 +20,8 @@ using namespace IACore;
 
 IAT_BEGIN_BLOCK(Core, CLI)
 
-auto test_basic_traversal() -> bool {
+auto test_basic_traversal() -> bool
+{
   const Vec<String> args = {"ignored", "one", "two", "three"};
   CLIParser parser(args);
 
@@ -41,7 +42,8 @@ auto test_basic_traversal() -> bool {
   return true;
 }
 
-auto test_peek() -> bool {
+auto test_peek() -> bool
+{
   const Vec<String> args = {"ignored", "peek_val", "next_val"};
   CLIParser parser(args);
 
@@ -58,7 +60,8 @@ auto test_peek() -> bool {
   return true;
 }
 
-auto test_consume() -> bool {
+auto test_consume() -> bool
+{
   const Vec<String> args = {"ignored", "-v", "--output", "file.txt"};
   CLIParser parser(args);
 
@@ -79,7 +82,8 @@ auto test_consume() -> bool {
   return true;
 }
 
-auto test_empty() -> bool {
+auto test_empty() -> bool
+{
   const Vec<String> args = {};
   CLIParser parser(args);
 

Tests/Unit/CMakeLists.txt

@@ -24,7 +24,11 @@ set(TEST_SOURCES
 
 add_executable(IACore_Test_Suite ${TEST_SOURCES})
 
-target_compile_options(IACore_Test_Suite PRIVATE -fexceptions)
+if(MSVC)
+    target_compile_options(IACore_Test_Suite PRIVATE "/EHsc")
+else()
+    target_compile_options(IACore_Test_Suite PRIVATE "-fexceptions")
+endif()
 set_target_properties(IACore_Test_Suite PROPERTIES USE_EXCEPTIONS ON)
 
 target_link_libraries(IACore_Test_Suite PRIVATE IACore)

Tests/Unit/DataOps.cpp

@@ -20,7 +20,8 @@ using namespace IACore;
 
 IAT_BEGIN_BLOCK(Core, DataOps)
 
-auto test_crc32() -> bool {
+auto test_crc32() -> bool
+{
   {
     const String s = "123456789";
     const Span<const u8> span(reinterpret_cast<const u8 *>(s.data()), s.size());
@@ -36,20 +37,20 @@ auto test_crc32() -> bool {
 
   {
     Vec<u8> buffer(33);
-    for (usize i = 1; i < 33; ++i) {
+    for (usize i = 1; i < 33; ++i)
+    {
       buffer[i] = static_cast<u8>(i);
     }
 
     Vec<u8> ref_data(32);
-    for (usize i = 0; i < 32; ++i) {
+    for (usize i = 0; i < 32; ++i)
+    {
       ref_data[i] = static_cast<u8>(i + 1);
     }
 
-    const u32 hash_ref =
-        DataOps::crc32(Span<const u8>(ref_data.data(), ref_data.size()));
+    const u32 hash_ref = DataOps::crc32(Span<const u8>(ref_data.data(), ref_data.size()));
 
-    const u32 hash_unaligned =
-        DataOps::crc32(Span<const u8>(buffer.data() + 1, 32));
+    const u32 hash_unaligned = DataOps::crc32(Span<const u8>(buffer.data() + 1, 32));
 
     IAT_CHECK_EQ(hash_ref, hash_unaligned);
   }
@@ -57,7 +58,8 @@ auto test_crc32() -> bool {
   return true;
 }
 
-auto test_hash_xxhash() -> bool {
+auto test_hash_xxhash() -> bool
+{
   {
     const String s = "123456789";
     const u32 result = DataOps::hash_xxhash(s);
@@ -73,19 +75,18 @@ auto test_hash_xxhash() -> bool {
   {
     const String s = "Test";
     const u32 r1 = DataOps::hash_xxhash(s);
-    const u32 r2 = DataOps::hash_xxhash(
-        Span<const u8>(reinterpret_cast<const u8 *>(s.data()), s.size()));
+    const u32 r2 = DataOps::hash_xxhash(Span<const u8>(reinterpret_cast<const u8 *>(s.data()), s.size()));
     IAT_CHECK_EQ(r1, r2);
   }
 
   return true;
 }
 
-auto test_hash_fnv1a() -> bool {
+auto test_hash_fnv1a() -> bool
+{
   {
     const String s = "123456789";
-    const u32 result = DataOps::hash_fnv1a(
-        Span<const u8>(reinterpret_cast<const u8 *>(s.data()), s.size()));
+    const u32 result = DataOps::hash_fnv1a(Span<const u8>(reinterpret_cast<const u8 *>(s.data()), s.size()));
     IAT_CHECK_EQ(result, 0xbb86b11c);
   }
 

Tests/Unit/Environment.cpp

@@ -23,9 +23,10 @@ static constexpr const char *TEST_VAL = "Hello World";
 
 IAT_BEGIN_BLOCK(Core, Environment)
 
-auto test_basic_cycle() -> bool {
+auto test_basic_cycle() -> bool
+{
 
-  (void)Environment::unset(TEST_KEY);
+  (void) Environment::unset(TEST_KEY);
   IAT_CHECK_NOT(Environment::exists(TEST_KEY));
 
   const auto set_res = Environment::set(TEST_KEY, TEST_VAL);
@@ -39,23 +40,25 @@ auto test_basic_cycle() -> bool {
   const String val = Environment::get(TEST_KEY);
   IAT_CHECK_EQ(val, String(TEST_VAL));
 
-  (void)Environment::unset(TEST_KEY);
+  (void) Environment::unset(TEST_KEY);
   return true;
 }
 
-auto test_overwrite() -> bool {
-  (void)Environment::set(TEST_KEY, "ValueA");
+auto test_overwrite() -> bool
+{
+  (void) Environment::set(TEST_KEY, "ValueA");
   IAT_CHECK_EQ(Environment::get(TEST_KEY), String("ValueA"));
 
-  (void)Environment::set(TEST_KEY, "ValueB");
+  (void) Environment::set(TEST_KEY, "ValueB");
   IAT_CHECK_EQ(Environment::get(TEST_KEY), String("ValueB"));
 
-  (void)Environment::unset(TEST_KEY);
+  (void) Environment::unset(TEST_KEY);
   return true;
 }
 
-auto test_unset() -> bool {
-  (void)Environment::set(TEST_KEY, "To Be Deleted");
+auto test_unset() -> bool
+{
+  (void) Environment::set(TEST_KEY, "To Be Deleted");
   IAT_CHECK(Environment::exists(TEST_KEY));
 
   const auto unset_res = Environment::unset(TEST_KEY);
@@ -69,10 +72,11 @@ auto test_unset() -> bool {
   return true;
 }
 
-auto test_defaults() -> bool {
+auto test_defaults() -> bool
+{
   const char *ghost_key = "IA_THIS_KEY_DOES_NOT_EXIST";
 
-  (void)Environment::unset(ghost_key);
+  (void) Environment::unset(ghost_key);
 
   const String empty = Environment::get(ghost_key);
   IAT_CHECK(empty.empty());
@@ -83,8 +87,9 @@ auto test_defaults() -> bool {
   return true;
 }
 
-auto test_empty_value() -> bool {
-  (void)Environment::set(TEST_KEY, "");
+auto test_empty_value() -> bool
+{
+  (void) Environment::set(TEST_KEY, "");
 
 #if IA_PLATFORM_WINDOWS
 
@@ -96,13 +101,14 @@ auto test_empty_value() -> bool {
   IAT_CHECK(opt->empty());
 #endif
 
-  (void)Environment::unset(TEST_KEY);
+  (void) Environment::unset(TEST_KEY);
   IAT_CHECK_NOT(Environment::exists(TEST_KEY));
 
   return true;
 }
 
-auto test_bad_input() -> bool {
+auto test_bad_input() -> bool
+{
 
   const auto res = Environment::set("", "Value");
   IAT_CHECK_NOT(res.has_value());

Tests/Unit/FileOps.cpp

@@ -20,14 +20,17 @@ using namespace IACore;
 
 IAT_BEGIN_BLOCK(Core, FileOps)
 
-void cleanup_file(const Path &path) {
+void cleanup_file(const Path &path)
+{
   std::error_code ec;
-  if (std::filesystem::exists(path, ec)) {
+  if (std::filesystem::exists(path, ec))
+  {
     std::filesystem::remove(path, ec);
   }
 }
 
-auto test_text_io() -> bool {
+auto test_text_io() -> bool
+{
   const Path path = "iatest_fileops_text.txt";
   const String content = "Hello IACore FileOps!\nLine 2";
 
@@ -43,7 +46,8 @@ auto test_text_io() -> bool {
   return true;
 }
 
-auto test_binary_io() -> bool {
+auto test_binary_io() -> bool
+{
   const Path path = "iatest_fileops_bin.bin";
   const Vec<u8> content = {0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0xFF};
 
@@ -55,7 +59,8 @@ auto test_binary_io() -> bool {
   IAT_CHECK(read_res.has_value());
   IAT_CHECK_EQ(read_res->size(), content.size());
 
-  for (usize i = 0; i < content.size(); ++i) {
+  for (usize i = 0; i < content.size(); ++i)
+  {
     IAT_CHECK_EQ((*read_res)[i], content[i]);
   }
 
@@ -63,11 +68,12 @@ auto test_binary_io() -> bool {
   return true;
 }
 
-auto test_file_mapping() -> bool {
+auto test_file_mapping() -> bool
+{
   const Path path = "iatest_fileops_map.txt";
   const String content = "MappedContent";
 
-  (void)FileOps::write_text_file(path, content, true);
+  (void) FileOps::write_text_file(path, content, true);
 
   usize size = 0;
   const auto map_res = FileOps::map_file(path, size);
@@ -86,7 +92,8 @@ auto test_file_mapping() -> bool {
   return true;
 }
 
-auto test_shared_memory() -> bool {
+auto test_shared_memory() -> bool
+{
   const String shm_name = "iatest_shm_block";
   const usize shm_size = 4096;
 
@@ -112,7 +119,8 @@ auto test_shared_memory() -> bool {
   return true;
 }
 
-auto test_stream_integration() -> bool {
+auto test_stream_integration() -> bool
+{
   const Path path = "iatest_fileops_stream.bin";
   cleanup_file(path);
 
@@ -121,8 +129,8 @@ auto test_stream_integration() -> bool {
     IAT_CHECK(writer_res.has_value());
     auto &writer = *writer_res;
 
-    (void)writer.write<u32>(0x12345678);
-    (void)writer.write<u8>(0xFF);
+    (void) writer.write<u32>(0x12345678);
+    (void) writer.write<u8>(0xFF);
   }
 
   {

Tests/Unit/IPC.cpp

@@ -21,27 +21,26 @@ using namespace IACore;
 
 IAT_BEGIN_BLOCK(Core, IPC)
 
-auto test_layout_constraints() -> bool {
+auto test_layout_constraints() -> bool
+{
 
   IAT_CHECK_EQ(alignof(IpcSharedMemoryLayout), static_cast<usize>(64));
 
   IAT_CHECK_EQ(offsetof(IpcSharedMemoryLayout, meta), static_cast<usize>(0));
 
-  IAT_CHECK_EQ(offsetof(IpcSharedMemoryLayout, moni_control),
-               static_cast<usize>(64));
+  IAT_CHECK_EQ(offsetof(IpcSharedMemoryLayout, moni_control), static_cast<usize>(64));
 
-  IAT_CHECK_EQ(offsetof(IpcSharedMemoryLayout, mino_control),
-               static_cast<usize>(192));
+  IAT_CHECK_EQ(offsetof(IpcSharedMemoryLayout, mino_control), static_cast<usize>(192));
 
-  IAT_CHECK_EQ(offsetof(IpcSharedMemoryLayout, moni_data_offset),
-               static_cast<usize>(320));
+  IAT_CHECK_EQ(offsetof(IpcSharedMemoryLayout, moni_data_offset), static_cast<usize>(320));
 
   IAT_CHECK_EQ(sizeof(IpcSharedMemoryLayout) % 64, static_cast<usize>(0));
 
   return true;
 }
 
-auto test_manual_shm_ringbuffer() -> bool {
+auto test_manual_shm_ringbuffer() -> bool
+{
   const String shm_name = "IA_TEST_IPC_LAYOUT_CHECK";
   const usize shm_size = 16 * 1024;
 
@@ -67,28 +66,20 @@ auto test_manual_shm_ringbuffer() -> bool {
   layout->mino_data_offset = header_size + half_data;
   layout->mino_data_size = half_data;
 
-  Span<u8> moni_data_span(base_ptr + layout->moni_data_offset,
-                          static_cast<usize>(layout->moni_data_size));
-  auto moni_res =
-      RingBufferView::create(&layout->moni_control, moni_data_span, true);
+  Span<u8> moni_data_span(base_ptr + layout->moni_data_offset, static_cast<usize>(layout->moni_data_size));
+  auto moni_res = RingBufferView::create(&layout->moni_control, moni_data_span, true);
   IAT_CHECK(moni_res.has_value());
   auto moni = std::move(*moni_res);
 
-  Span<u8> mino_data_span(base_ptr + layout->mino_data_offset,
-                          static_cast<usize>(layout->mino_data_size));
-  auto mino_res =
-      RingBufferView::create(&layout->mino_control, mino_data_span, true);
+  Span<u8> mino_data_span(base_ptr + layout->mino_data_offset, static_cast<usize>(layout->mino_data_size));
+  auto mino_res = RingBufferView::create(&layout->mino_control, mino_data_span, true);
   IAT_CHECK(mino_res.has_value());
   auto _ = std::move(*mino_res);
 
   String msg = "IPC_TEST_MESSAGE";
-  IAT_CHECK(
-      moni.push(100, Span<const u8>(reinterpret_cast<const u8 *>(msg.data()),
-                                    msg.size()))
-          .has_value());
+  IAT_CHECK(moni.push(100, Span<const u8>(reinterpret_cast<const u8 *>(msg.data()), msg.size())).has_value());
 
-  auto moni_reader_res =
-      RingBufferView::create(&layout->moni_control, moni_data_span, false);
+  auto moni_reader_res = RingBufferView::create(&layout->moni_control, moni_data_span, false);
   IAT_CHECK(moni_reader_res.has_value());
   auto moni_reader = std::move(*moni_reader_res);
 
@@ -99,7 +90,7 @@ auto test_manual_shm_ringbuffer() -> bool {
   IAT_CHECK(pop_res->has_value());
   IAT_CHECK_EQ(header.id, static_cast<u16>(100));
 
-  String received((char *)buffer, *pop_res.value());
+  String received((char *) buffer, *pop_res.value());
   IAT_CHECK_EQ(received, msg);
 
   FileOps::unmap_file(base_ptr);
@@ -108,13 +99,20 @@ auto test_manual_shm_ringbuffer() -> bool {
   return true;
 }
 
-class TestManager : public IpcManager {
-public:
-  void on_signal(NativeProcessID, u8) override {}
-  void on_packet(NativeProcessID, u16, Span<const u8>) override {}
+class TestManager : public IpcManager
+{
+  public:
+  void on_signal(NativeProcessID, u8) override
+  {
+  }
+
+  void on_packet(NativeProcessID, u16, Span<const u8>) override
+  {
+  }
 };
 
-auto test_manager_instantiation() -> bool {
+auto test_manager_instantiation() -> bool
+{
   TestManager mgr;
   return true;
 }

Tests/Unit/JSON.cpp

@@ -18,21 +18,23 @@
 
 using namespace IACore;
 
-struct UserProfile {
+struct UserProfile
+{
   String username;
   u32 id;
   bool is_active;
   Vec<String> roles;
 
-  bool operator==(const UserProfile &other) const {
-    return username == other.username && id == other.id &&
-           is_active == other.is_active && roles == other.roles;
+  bool operator==(const UserProfile &other) const
+  {
+    return username == other.username && id == other.id && is_active == other.is_active && roles == other.roles;
   }
 };
 
 IAT_BEGIN_BLOCK(Core, JSON)
 
-auto test_dynamic_parse() -> bool {
+auto test_dynamic_parse() -> bool
+{
   const String json_text = R"({
         "string": "Hello World",
         "int": 42,
@@ -69,7 +71,8 @@ auto test_dynamic_parse() -> bool {
   return true;
 }
 
-auto test_dynamic_encode() -> bool {
+auto test_dynamic_encode() -> bool
+{
   nlohmann::json j;
   j["name"] = "IACore";
   j["version"] = 2;
@@ -83,18 +86,17 @@ auto test_dynamic_encode() -> bool {
   return true;
 }
 
-auto test_parse_invalid() -> bool {
+auto test_parse_invalid() -> bool
+{
   const String bad_json = "{ key: value }";
   auto res = Json::parse(bad_json);
   IAT_CHECK_NOT(res.has_value());
   return true;
 }
 
-auto test_struct_round_trip() -> bool {
-  UserProfile original{.username = "test_user",
-                       .id = 12345,
-                       .is_active = true,
-                       .roles = {"admin", "editor"}};
+auto test_struct_round_trip() -> bool
+{
+  UserProfile original{.username = "test_user", .id = 12345, .is_active = true, .roles = {"admin", "editor"}};
 
   auto encode_res = Json::encode_struct(original);
   IAT_CHECK(encode_res.has_value());
@@ -112,14 +114,16 @@ auto test_struct_round_trip() -> bool {
   return true;
 }
 
-auto test_struct_parse_error() -> bool {
+auto test_struct_parse_error() -> bool
+{
   const String malformed = "{ broken_json: ";
   auto res = Json::parse_to_struct<UserProfile>(malformed);
   IAT_CHECK_NOT(res.has_value());
   return true;
 }
 
-auto test_read_only() -> bool {
+auto test_read_only() -> bool
+{
   const String json_text = R"({
         "id": 999,
         "name": "Simd",

Tests/Unit/Logger.cpp

@@ -23,7 +23,17 @@ IAT_BEGIN_BLOCK(Core, Logger)
 
 static constexpr const char *LOG_FILE = "iacore_test_log.txt";
 
-auto test_file_logging() -> bool {
+void cleanup_file(const Path &path)
+{
+  std::error_code ec;
+  if (std::filesystem::exists(path, ec))
+  {
+    std::filesystem::remove(path, ec);
+  }
+}
+
+auto test_file_logging() -> bool
+{
 
   const auto res = Logger::enable_logging_to_disk(LOG_FILE);
   IAT_CHECK(res.has_value());
@@ -41,9 +51,10 @@ auto test_file_logging() -> bool {
   Logger::flush_logs();
 
   auto read_res = FileOps::read_text_file(LOG_FILE);
-  if (!read_res) {
-    std::cout << console::YELLOW << "    Warning: Could not read log file ("
-              << read_res.error() << "). Skipping verification.\n"
+  if (!read_res)
+  {
+    std::cout << console::YELLOW << "    Warning: Could not read log file (" << read_res.error()
+              << "). Skipping verification.\n"
               << console::RESET;
     return true;
   }
@@ -58,10 +69,13 @@ auto test_file_logging() -> bool {
   IAT_CHECK(content.find("ERROR") != String::npos);
   IAT_CHECK(content.find("WARN") != String::npos);
 
+  cleanup_file(LOG_FILE);
+
   return true;
 }
 
-auto test_log_levels() -> bool {
+auto test_log_levels() -> bool
+{
 
   Logger::set_log_level(Logger::LogLevel::Warn);
 
@@ -74,7 +88,8 @@ auto test_log_levels() -> bool {
   Logger::flush_logs();
 
   auto read_res = FileOps::read_text_file(LOG_FILE);
-  if (!read_res) {
+  if (!read_res)
+  {
     return true;
   }
 
@@ -87,7 +102,8 @@ auto test_log_levels() -> bool {
   return true;
 }
 
-auto test_formatting() -> bool {
+auto test_formatting() -> bool
+{
   Logger::set_log_level(Logger::LogLevel::Info);
 
   const String name = "IACore";
@@ -97,7 +113,8 @@ auto test_formatting() -> bool {
   Logger::flush_logs();
 
   auto read_res = FileOps::read_text_file(LOG_FILE);
-  if (!read_res) {
+  if (!read_res)
+  {
     return true;
   }
 

Tests/Unit/Main.cpp

@@ -20,20 +20,17 @@
 
 using namespace IACore;
 
-IACORE_MAIN() {
-  (void)args;
+IACORE_MAIN()
+{
+  (void) args;
 
   AU_TRY_PURE(SocketOps::initialize());
 
-  std::cout
-      << console::GREEN
-      << "\n===============================================================\n";
+  std::cout << console::GREEN << "\n===============================================================\n";
   std::cout << "   IACore (Independent Architecture Core) - Unit Test Suite\n";
-  std::cout
-      << "===============================================================\n"
-      << console::RESET << "\n";
+  std::cout << "===============================================================\n" << console::RESET << "\n";
 
-  Const<i32> result = Test::TestRegistry::run_all();
+  const i32 result = Test::TestRegistry::run_all();
 
   SocketOps::terminate();
 

Tests/Unit/Platform.cpp

@@ -21,7 +21,8 @@ using namespace IACore;
 
 IAT_BEGIN_BLOCK(Core, Platform)
 
-auto test_os_name() -> bool {
+auto test_os_name() -> bool
+{
   const char *os_name = Platform::get_operating_system_name();
   IAT_CHECK(os_name != nullptr);
 
@@ -41,7 +42,8 @@ auto test_os_name() -> bool {
   return true;
 }
 
-auto test_arch_name() -> bool {
+auto test_arch_name() -> bool
+{
   const char *arch_name = Platform::get_architecture_name();
   IAT_CHECK(arch_name != nullptr);
 
@@ -59,7 +61,8 @@ auto test_arch_name() -> bool {
   return true;
 }
 
-auto test_capabilities() -> bool {
+auto test_capabilities() -> bool
+{
 
   const bool check_result = Platform::check_cpu();
   IAT_CHECK(check_result);
@@ -67,13 +70,14 @@ auto test_capabilities() -> bool {
   const auto &caps = Platform::get_capabilities();
 
   volatile bool has_crc = caps.hardware_crc32;
-  (void)has_crc;
+  (void) has_crc;
 
   return true;
 }
 
 #if IA_ARCH_X64
-auto test_cpuid() -> bool {
+auto test_cpuid() -> bool
+{
   i32 regs[4] = {0};
 
   Platform::cpuid(0, 0, regs);
@@ -91,12 +95,11 @@ auto test_cpuid() -> bool {
   const String vendor_str(vendor);
   IAT_CHECK(!vendor_str.empty());
 
-  bool is_known =
-      (vendor_str == "GenuineIntel" || vendor_str == "AuthenticAMD" ||
-       vendor_str == "KVMKVMKVM" || vendor_str == "Microsoft Hv" ||
-       vendor_str == "VBoxVBoxVBox");
+  bool is_known = (vendor_str == "GenuineIntel" || vendor_str == "AuthenticAMD" || vendor_str == "KVMKVMKVM" ||
+                   vendor_str == "Microsoft Hv" || vendor_str == "VBoxVBoxVBox");
 
-  if (!is_known) {
+  if (!is_known)
+  {
 
     std::cout << "      [Info] Unknown CPU Vendor: " << vendor_str << "\n";
   }

Tests/Unit/ProcessOps.cpp

@@ -19,23 +19,23 @@
 using namespace IACore;
 
 #if IA_PLATFORM_WINDOWS
-#define CMD_ECHO_EXE "cmd.exe"
-#define CMD_ARG_PREFIX "/c echo"
-#define NULL_DEVICE "NUL"
+#  define CMD_ECHO_EXE "cmd.exe"
+#  define CMD_ARG_PREFIX "/c echo"
+#  define NULL_DEVICE "NUL"
 #else
-#define CMD_ECHO_EXE "/bin/echo"
-#define CMD_ARG_PREFIX ""
-#define NULL_DEVICE "/dev/null"
+#  define CMD_ECHO_EXE "/bin/echo"
+#  define CMD_ARG_PREFIX ""
+#  define NULL_DEVICE "/dev/null"
 #endif
 
 IAT_BEGIN_BLOCK(Core, ProcessOps)
 
-auto test_basic_run() -> bool {
+auto test_basic_run() -> bool
+{
 
   String captured;
 
-  const auto result =
-      ProcessOps::spawn_process_sync(CMD_ECHO_EXE, CMD_ARG_PREFIX " HelloIA",
+  const auto result = ProcessOps::spawn_process_sync(CMD_ECHO_EXE, CMD_ARG_PREFIX " HelloIA",
                                                      [&](StringView line) { captured = line; });
 
   IAT_CHECK(result.has_value());
@@ -46,18 +46,18 @@ auto test_basic_run() -> bool {
   return true;
 }
 
-auto test_arguments() -> bool {
+auto test_arguments() -> bool
+{
   Vec<String> lines;
 
   String args = String(CMD_ARG_PREFIX) + " one two";
-  if (!args.empty() && args[0] == ' ') {
+  if (!args.empty() && args[0] == ' ')
+  {
     args.erase(0, 1);
   }
 
   const auto result =
-      ProcessOps::spawn_process_sync(CMD_ECHO_EXE, args, [&](StringView line) {
-        lines.push_back(String(line));
-      });
+      ProcessOps::spawn_process_sync(CMD_ECHO_EXE, args, [&](StringView line) { lines.push_back(String(line)); });
 
   IAT_CHECK_EQ(*result, 0);
   IAT_CHECK(lines.size() > 0);
@@ -67,7 +67,8 @@ auto test_arguments() -> bool {
   return true;
 }
 
-auto test_exit_codes() -> bool {
+auto test_exit_codes() -> bool
+{
 
   String cmd;
   String arg;
@@ -80,8 +81,7 @@ auto test_exit_codes() -> bool {
   arg = "-c \"exit 42\"";
 #endif
 
-  const auto result =
-      ProcessOps::spawn_process_sync(cmd, arg, [](StringView) {});
+  const auto result = ProcessOps::spawn_process_sync(cmd, arg, [](StringView) {});
 
   IAT_CHECK(result.has_value());
   IAT_CHECK_EQ(*result, 42);
@@ -89,10 +89,10 @@ auto test_exit_codes() -> bool {
   return true;
 }
 
-auto test_missing_exe() -> bool {
+auto test_missing_exe() -> bool
+{
 
-  const auto result =
-      ProcessOps::spawn_process_sync("sdflkjghsdflkjg", "", [](StringView) {});
+  const auto result = ProcessOps::spawn_process_sync("sdflkjghsdflkjg", "", [](StringView) {});
 
 #if IA_PLATFORM_WINDOWS
   IAT_CHECK_NOT(result.has_value());
@@ -105,11 +105,13 @@ auto test_missing_exe() -> bool {
   return true;
 }
 
-auto test_large_output() -> bool {
+auto test_large_output() -> bool
+{
 
   String massive_string;
   massive_string.reserve(5000);
-  for (i32 i = 0; i < 500; ++i) {
+  for (i32 i = 0; i < 500; ++i)
+  {
     massive_string += "1234567890";
   }
 
@@ -126,8 +128,7 @@ auto test_large_output() -> bool {
 #endif
 
   String captured;
-  const auto result = ProcessOps::spawn_process_sync(
-      cmd, arg, [&](StringView line) { captured += line; });
+  const auto result = ProcessOps::spawn_process_sync(cmd, arg, [&](StringView line) { captured += line; });
 
   IAT_CHECK(result.has_value());
   IAT_CHECK_EQ(*result, 0);
@@ -137,7 +138,8 @@ auto test_large_output() -> bool {
   return true;
 }
 
-auto test_multi_line() -> bool {
+auto test_multi_line() -> bool
+{
 
   String cmd;
   String arg;
@@ -153,13 +155,14 @@ auto test_multi_line() -> bool {
   bool found_a = false;
   bool found_b = false;
 
-  const auto res =
-      ProcessOps::spawn_process_sync(cmd, arg, [&](StringView line) {
+  const auto res = ProcessOps::spawn_process_sync(cmd, arg, [&](StringView line) {
     line_count++;
-        if (line.find("LineA") != String::npos) {
+    if (line.find("LineA") != String::npos)
+    {
       found_a = true;
     }
-        if (line.find("LineB") != String::npos) {
+    if (line.find("LineB") != String::npos)
+    {
       found_b = true;
     }
   });
@@ -173,10 +176,10 @@ auto test_multi_line() -> bool {
   return true;
 }
 
-auto test_complex_arguments() -> bool {
+auto test_complex_arguments() -> bool
+{
 
-  const String complex_args =
-      "-DDEFINED_MSG=\\\"Hello World\\\" -v path/to/file";
+  const String complex_args = "-DDEFINED_MSG=\\\"Hello World\\\" -v path/to/file";
 
   const String cmd = CMD_ECHO_EXE;
 
@@ -188,8 +191,7 @@ auto test_complex_arguments() -> bool {
 #endif
 
   String captured;
-  const auto result = ProcessOps::spawn_process_sync(
-      cmd, final_args, [&](StringView line) { captured += line; });
+  const auto result = ProcessOps::spawn_process_sync(cmd, final_args, [&](StringView line) { captured += line; });
 
   IAT_CHECK(result.has_value());
   IAT_CHECK_EQ(*result, 0);

Tests/Unit/RingBuffer.cpp

@@ -20,7 +20,8 @@ using namespace IACore;
 
 IAT_BEGIN_BLOCK(Core, RingBuffer)
 
-auto test_push_pop() -> bool {
+auto test_push_pop() -> bool
+{
 
   Vec<u8> memory(sizeof(RingBufferView::ControlBlock) + 1024);
 
@@ -33,8 +34,7 @@ auto test_push_pop() -> bool {
   auto consumer = std::move(*consumer_res);
 
   String msg = "Hello RingBuffer";
-  const auto push_res = producer.push(
-      1, Span<const u8>(reinterpret_cast<const u8 *>(msg.data()), msg.size()));
+  const auto push_res = producer.push(1, Span<const u8>(reinterpret_cast<const u8 *>(msg.data()), msg.size()));
   IAT_CHECK(push_res.has_value());
 
   RingBufferView::PacketHeader header;
@@ -57,7 +57,8 @@ auto test_push_pop() -> bool {
   return true;
 }
 
-auto test_wrap_around() -> bool {
+auto test_wrap_around() -> bool
+{
 
   Vec<u8> memory(sizeof(RingBufferView::ControlBlock) + 100);
 
@@ -87,8 +88,10 @@ auto test_wrap_around() -> bool {
   IAT_CHECK_EQ(pop_size, static_cast<usize>(40));
 
   bool match = true;
-  for (usize i = 0; i < 40; i++) {
-    if (out_buf[i] != 0xAA) {
+  for (usize i = 0; i < 40; i++)
+  {
+    if (out_buf[i] != 0xAA)
+    {
       match = false;
     }
   }

Tests/Unit/SIMD/FloatVec4.cpp

@@ -20,7 +20,8 @@ using namespace IACore;
 
 IAT_BEGIN_BLOCK(Core, FloatVec4)
 
-auto test_float_arithmetic() -> bool {
+auto test_float_arithmetic() -> bool
+{
   FloatVec4 v1(10.0f, 20.0f, 30.0f, 40.0f);
   FloatVec4 v2(2.0f, 4.0f, 5.0f, 8.0f);
 
@@ -39,7 +40,8 @@ auto test_float_arithmetic() -> bool {
   return true;
 }
 
-auto test_math_helpers() -> bool {
+auto test_math_helpers() -> bool
+{
   alignas(16) f32 res[4];
 
   FloatVec4 v_sq(4.0f, 9.0f, 16.0f, 25.0f);
@@ -61,7 +63,8 @@ auto test_math_helpers() -> bool {
   return true;
 }
 
-auto test_approx_math() -> bool {
+auto test_approx_math() -> bool
+{
   alignas(16) f32 res[4];
   FloatVec4 v(16.0f, 25.0f, 100.0f, 1.0f);
 
@@ -73,7 +76,8 @@ auto test_approx_math() -> bool {
   return true;
 }
 
-auto test_linear_algebra() -> bool {
+auto test_linear_algebra() -> bool
+{
   FloatVec4 v1(1.0f, 2.0f, 3.0f, 4.0f);
   FloatVec4 v2(1.0f, 0.0f, 1.0f, 0.0f);
 

Tests/Unit/SIMD/IntVec4.cpp

@@ -20,7 +20,8 @@ using namespace IACore;
 
 IAT_BEGIN_BLOCK(Core, IntVec4)
 
-auto test_constructors() -> bool {
+auto test_constructors() -> bool
+{
   IntVec4 v_broadcast(10);
   alignas(16) u32 store_buf[4];
   v_broadcast.store(store_buf);
@@ -41,7 +42,8 @@ auto test_constructors() -> bool {
   return true;
 }
 
-auto test_arithmetic() -> bool {
+auto test_arithmetic() -> bool
+{
   const IntVec4 v1(10, 20, 30, 40);
   const IntVec4 v2(1, 2, 3, 4);
 
@@ -64,9 +66,10 @@ auto test_arithmetic() -> bool {
   return true;
 }
 
-auto test_bitwise() -> bool {
+auto test_bitwise() -> bool
+{
   const IntVec4 v_all_ones(0xFFFFFFFF);
-  const IntVec4 v_zero((u32)0);
+  const IntVec4 v_zero((u32) 0);
   const IntVec4 v_pattern(0xAAAAAAAA);
 
   alignas(16) u32 res[4];
@@ -94,7 +97,8 @@ auto test_bitwise() -> bool {
   return true;
 }
 
-auto test_saturation() -> bool {
+auto test_saturation() -> bool
+{
   const u32 max = 0xFFFFFFFF;
   const IntVec4 v_high(max - 10);
   const IntVec4 v_add(20);
@@ -112,7 +116,8 @@ auto test_saturation() -> bool {
   return true;
 }
 
-auto test_advanced_ops() -> bool {
+auto test_advanced_ops() -> bool
+{
   const IntVec4 v(0, 50, 100, 150);
   alignas(16) u32 res[4];
 

Tests/Unit/SocketOps.cpp

@@ -20,7 +20,8 @@ using namespace IACore;
 
 IAT_BEGIN_BLOCK(Core, SocketOps)
 
-auto test_initialization() -> bool {
+auto test_initialization() -> bool
+{
   IAT_CHECK(SocketOps::is_initialized());
 
   const auto res = SocketOps::initialize();
@@ -33,17 +34,19 @@ auto test_initialization() -> bool {
   return true;
 }
 
-auto test_port_availability() -> bool {
+auto test_port_availability() -> bool
+{
 
   const u16 port = 54321;
 
-  (void)SocketOps::is_port_available_tcp(port);
-  (void)SocketOps::is_port_available_udp(port);
+  (void) SocketOps::is_port_available_tcp(port);
+  (void) SocketOps::is_port_available_udp(port);
 
   return true;
 }
 
-auto test_unix_socket_lifecycle() -> bool {
+auto test_unix_socket_lifecycle() -> bool
+{
   const String socket_path = "iatest_ipc.sock";
 
   SocketOps::unlink_file(socket_path.c_str());
@@ -53,7 +56,8 @@ auto test_unix_socket_lifecycle() -> bool {
   SocketHandle server = *server_res;
 
   auto bind_res = SocketOps::bind_unix_socket(server, socket_path.c_str());
-  if (!bind_res) {
+  if (!bind_res)
+  {
 
     SocketOps::close(server);
     return false;
@@ -66,8 +70,7 @@ auto test_unix_socket_lifecycle() -> bool {
   IAT_CHECK(client_res.has_value());
   SocketHandle client = *client_res;
 
-  auto connect_res =
-      SocketOps::connect_unix_socket(client, socket_path.c_str());
+  auto connect_res = SocketOps::connect_unix_socket(client, socket_path.c_str());
   IAT_CHECK(connect_res.has_value());
 
   SocketOps::close(client);
@@ -77,7 +80,8 @@ auto test_unix_socket_lifecycle() -> bool {
   return true;
 }
 
-auto test_unix_socket_errors() -> bool {
+auto test_unix_socket_errors() -> bool
+{
   const String socket_path = "iatest_missing.sock";
 
   SocketOps::unlink_file(socket_path.c_str());
@@ -86,8 +90,7 @@ auto test_unix_socket_errors() -> bool {
   IAT_CHECK(client_res.has_value());
   SocketHandle client = *client_res;
 
-  auto connect_res =
-      SocketOps::connect_unix_socket(client, socket_path.c_str());
+  auto connect_res = SocketOps::connect_unix_socket(client, socket_path.c_str());
   IAT_CHECK_NOT(connect_res.has_value());
 
   SocketOps::close(client);

Tests/Unit/StreamReader.cpp

@@ -20,7 +20,8 @@ using namespace IACore;
 
 IAT_BEGIN_BLOCK(Core, StreamReader)
 
-auto test_read_uint8() -> bool {
+auto test_read_uint8() -> bool
+{
   u8 data[] = {0xAA, 0xBB, 0xCC};
   StreamReader reader(data);
 
@@ -36,7 +37,8 @@ auto test_read_uint8() -> bool {
   return true;
 }
 
-auto test_read_multi_byte() -> bool {
+auto test_read_multi_byte() -> bool
+{
 
   u8 data[] = {0x01, 0x02, 0x03, 0x04};
   StreamReader reader(data);
@@ -52,7 +54,8 @@ auto test_read_multi_byte() -> bool {
   return true;
 }
 
-auto test_read_float() -> bool {
+auto test_read_float() -> bool
+{
   const f32 pi = 3.14159f;
 
   u8 data[4];
@@ -67,7 +70,8 @@ auto test_read_float() -> bool {
   return true;
 }
 
-auto test_read_buffer() -> bool {
+auto test_read_buffer() -> bool
+{
   u8 src[] = {1, 2, 3, 4, 5};
   u8 dst[3] = {0};
   StreamReader reader(src);
@@ -84,7 +88,8 @@ auto test_read_buffer() -> bool {
   return true;
 }
 
-auto test_navigation() -> bool {
+auto test_navigation() -> bool
+{
   u8 data[10] = {0};
   StreamReader reader(data);
 
@@ -106,11 +111,12 @@ auto test_navigation() -> bool {
   return true;
 }
 
-auto test_boundary_checks() -> bool {
+auto test_boundary_checks() -> bool
+{
   u8 data[] = {0x00, 0x00};
   StreamReader reader(data);
 
-  (void)reader.read<u16>();
+  (void) reader.read<u16>();
   IAT_CHECK(reader.is_eof());
 
   auto val = reader.read<u8>();

Tests/Unit/StreamWriter.cpp

@@ -21,7 +21,8 @@ using namespace IACore;
 
 IAT_BEGIN_BLOCK(Core, StreamWriter)
 
-auto test_memory_writer() -> bool {
+auto test_memory_writer() -> bool
+{
   StreamWriter writer;
 
   IAT_CHECK(writer.write(static_cast<u8>(0xAA), 1).has_value());
@@ -39,7 +40,8 @@ auto test_memory_writer() -> bool {
   return true;
 }
 
-auto test_fixed_buffer() -> bool {
+auto test_fixed_buffer() -> bool
+{
   u8 buffer[4] = {0};
   StreamWriter writer(Span<u8>(buffer, 4));
 
@@ -60,10 +62,12 @@ auto test_fixed_buffer() -> bool {
   return true;
 }
 
-auto test_file_writer() -> bool {
+auto test_file_writer() -> bool
+{
   const Path path = "test_stream_writer.bin";
 
-  if (std::filesystem::exists(path)) {
+  if (std::filesystem::exists(path))
+  {
     std::filesystem::remove(path);
   }
 
@@ -81,8 +85,7 @@ auto test_file_writer() -> bool {
   auto read_res = FileOps::read_binary_file(path);
   IAT_CHECK(read_res.has_value());
 
-  const String read_str(reinterpret_cast<const char *>(read_res->data()),
-                        read_res->size());
+  const String read_str(reinterpret_cast<const char *>(read_res->data()), read_res->size());
   IAT_CHECK_EQ(read_str, String("Hello World"));
 
   std::filesystem::remove(path);
@@ -90,7 +93,8 @@ auto test_file_writer() -> bool {
   return true;
 }
 
-auto test_primitives() -> bool {
+auto test_primitives() -> bool
+{
   StreamWriter writer;
 
   const f32 f = 1.5f;

Tests/Unit/StringOps.cpp

@@ -20,7 +20,8 @@ using namespace IACore;
 
 IAT_BEGIN_BLOCK(Core, StringOps)
 
-auto test_base64_encode() -> bool {
+auto test_base64_encode() -> bool
+{
 
   {
     const String s = "Hello World";
@@ -58,13 +59,13 @@ auto test_base64_encode() -> bool {
   return true;
 }
 
-auto test_base64_decode() -> bool {
+auto test_base64_decode() -> bool
+{
 
   {
     const String encoded = "SGVsbG8gV29ybGQ=";
     const Vec<u8> decoded = StringOps::decode_base64(encoded);
-    const String result(reinterpret_cast<const char *>(decoded.data()),
-                        decoded.size());
+    const String result(reinterpret_cast<const char *>(decoded.data()), decoded.size());
     IAT_CHECK_EQ(result, String("Hello World"));
   }
 
@@ -76,10 +77,12 @@ auto test_base64_decode() -> bool {
   return true;
 }
 
-auto test_base64_round_trip() -> bool {
+auto test_base64_round_trip() -> bool
+{
   Vec<u8> original;
   original.reserve(256);
-  for (usize i = 0; i < 256; ++i) {
+  for (usize i = 0; i < 256; ++i)
+  {
     original.push_back(static_cast<u8>(i));
   }
 
@@ -89,8 +92,10 @@ auto test_base64_round_trip() -> bool {
   IAT_CHECK_EQ(original.size(), decoded.size());
 
   bool match = true;
-  for (usize i = 0; i < original.size(); ++i) {
-    if (original[i] != decoded[i]) {
+  for (usize i = 0; i < original.size(); ++i)
+  {
+    if (original[i] != decoded[i])
+    {
       match = false;
       break;
     }

Tests/Unit/Utils.cpp

@@ -18,10 +18,12 @@
 
 using namespace IACore;
 
-struct TestVec3 {
+struct TestVec3
+{
   f32 x, y, z;
 
-  bool operator==(const TestVec3 &other) const {
+  bool operator==(const TestVec3 &other) const
+  {
     return x == other.x && y == other.y && z == other.z;
   }
 };
@@ -30,7 +32,8 @@ IA_MAKE_HASHABLE(TestVec3, &TestVec3::x, &TestVec3::y, &TestVec3::z);
 
 IAT_BEGIN_BLOCK(Core, Utils)
 
-auto test_hex_conversion() -> bool {
+auto test_hex_conversion() -> bool
+{
 
   u8 bin[] = {0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0xFF};
   String hex = Utils::binary_to_hex_string(bin);
@@ -57,7 +60,8 @@ auto test_hex_conversion() -> bool {
   return true;
 }
 
-auto test_hex_errors() -> bool {
+auto test_hex_errors() -> bool
+{
 
   auto odd = Utils::hex_string_to_binary("ABC");
   IAT_CHECK_NOT(odd.has_value());
@@ -72,7 +76,8 @@ auto test_hex_errors() -> bool {
   return true;
 }
 
-auto test_sort() -> bool {
+auto test_sort() -> bool
+{
   Vec<i32> nums = {5, 1, 4, 2, 3};
 
   Utils::sort(nums);
@@ -86,7 +91,8 @@ auto test_sort() -> bool {
   return true;
 }
 
-auto test_binary_search() -> bool {
+auto test_binary_search() -> bool
+{
 
   Vec<i32> nums = {10, 20, 20, 20, 30};
 
@@ -106,7 +112,8 @@ auto test_binary_search() -> bool {
   return true;
 }
 
-auto test_hash_basics() -> bool {
+auto test_hash_basics() -> bool
+{
   u64 h1 = Utils::compute_hash(10, 20.5f, "Hello");
   u64 h2 = Utils::compute_hash(10, 20.5f, "Hello");
   u64 h3 = Utils::compute_hash(10, 20.5f, "World");
@@ -122,7 +129,8 @@ auto test_hash_basics() -> bool {
   return true;
 }
 
-auto test_hash_macro() -> bool {
+auto test_hash_macro() -> bool
+{
   TestVec3 v1{1.0f, 2.0f, 3.0f};
   TestVec3 v2{1.0f, 2.0f, 3.0f};
   TestVec3 v3{1.0f, 2.0f, 4.0f};

Tests/Unit/XML.cpp

@@ -21,7 +21,8 @@ using namespace IACore;
 
 IAT_BEGIN_BLOCK(Core, XML)
 
-auto test_parse_string() -> bool {
+auto test_parse_string() -> bool
+{
   const String xml_content = R"(
         <root>
             <item id="1">Value1</item>
@@ -47,14 +48,16 @@ auto test_parse_string() -> bool {
   return true;
 }
 
-auto test_parse_error() -> bool {
+auto test_parse_error() -> bool
+{
   const String invalid_xml = "<root><unclosed>";
   auto res = XML::parse_from_string(invalid_xml);
   IAT_CHECK_NOT(res.has_value());
   return true;
 }
 
-auto test_serialize() -> bool {
+auto test_serialize() -> bool
+{
   const String xml_content = "<root><node>Text</node></root>";
   auto res = XML::parse_from_string(xml_content);
   IAT_CHECK(res.has_value());
@@ -67,7 +70,8 @@ auto test_serialize() -> bool {
   return true;
 }
 
-auto test_escape() -> bool {
+auto test_escape() -> bool
+{
   const String raw = "< & > \" '";
   const String escaped = XML::escape_xml_string(raw);
 
@@ -80,7 +84,8 @@ auto test_escape() -> bool {
   return true;
 }
 
-auto test_file_io() -> bool {
+auto test_file_io() -> bool
+{
   const Path path = "test_temp_xml_doc.xml";
   const String content = "<config><ver>1.0</ver></config>";
 
@@ -91,8 +96,7 @@ auto test_file_io() -> bool {
   IAT_CHECK(parse_res.has_value());
 
   auto &doc = *parse_res;
-  IAT_CHECK_EQ(String(doc.child("config").child("ver").child_value()),
-               String("1.0"));
+  IAT_CHECK_EQ(String(doc.child("config").child("ver").child_value()), String("1.0"));
 
   std::filesystem::remove(path);