Force enable MH_BROKEN_UNICODE and suppress codecvt deprecation warnings

Author: Matt Haynie

.gitignore

@@ -14,3 +14,5 @@ out_test_linux/
 CMakeSettings.json
 out_test/
 build/
+.claude/
+.cache/

.gitmodules

@@ -0,0 +1,108 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+This is **mh_stuff**, a C++20 utility library containing reusable components for system programming. The library operates in either header-only mode or as a compiled static/shared library, with minimal interdependencies between modules to support selective usage.
+
+**Important**: This library experiences significant API churn with no stability guarantees. It's designed for the author's personal projects and regular structural changes should be expected.
+
+## Build and Test Commands
+
+This project uses CMake with CPM (CMake Package Manager) for dependency management and Just for build task automation. The main dependencies are `mh-cmake-common` for build utilities and `Catch2` for testing.
+
+### Building the Project
+
+```bash
+# Using justfile (recommended)
+just build
+
+# Or using CMake presets directly
+cmake --preset default
+cmake --build --preset default
+
+# Or standard CMake build
+mkdir build && cd build
+cmake .. -G Ninja
+cmake --build .
+```
+
+### Running Tests
+
+The project uses Catch2 for testing:
+
+```bash
+# Using justfile (recommended)
+just test
+
+# Or using CMake presets
+ctest --preset default
+
+# Or from build directory
+cd build && ctest --output-on-failure
+
+# Or run the test executable directly
+./build/mh_stuff_tests
+```
+
+### Build Configuration Options
+
+- `MH_STUFF_BUILD_SHARED_LIBS=ON/OFF` - Build as shared library instead of static
+- `MH_STUFF_COMPILE_LIBRARY=ON/OFF` - Compile implementations vs header-only mode
+- `BUILD_TESTING=ON/OFF` - Enable/disable test compilation
+
+## Architecture Overview
+
+### Module Organization
+
+The library is organized into logical modules under `cpp/include/mh/`:
+
+- **`coroutine/`** - C++20 coroutine infrastructure including `task<T>` for async operations
+- **`error/`** - Error handling with `mh_ensure()` assertions and `expected<T,E>` monadic error types
+- **`concurrency/`** - Thread pools, async operations, and synchronization primitives
+- **`io/`** - Platform-agnostic async I/O with `source`/`sink` abstractions
+- **`memory/`** - Smart pointers, buffers, and memory management utilities
+- **`text/`** - String processing, formatting (fmtlib/std::format), and text utilities
+- **`data/`** - Data structures like `lazy<T>`, optional references, and bit manipulation
+- **`process/`** - Process management and async process I/O
+- **`math/`** - Mathematical utilities including interpolation and random number generation
+- **`reflection/`** - Compile-time reflection for enums and structs
+
+### Key Design Patterns
+
+1. **Header-Only with Selective Compilation**: `.hpp` files contain interfaces, `.inl` files contain implementations that can be compiled into a library or included directly
+2. **C++20 Coroutine-Based Async**: The `task<T>` type provides future-like semantics with coroutine support for async operations
+3. **Platform Abstraction**: Cross-platform code with platform-specific implementations hidden behind clean interfaces
+4. **Compile-Time Feature Detection**: Extensive use of `__has_include` and feature test macros for conditional compilation
+5. **RAII and Exception Safety**: Strong exception safety guarantees throughout with automatic resource management
+
+### Build System Notes
+
+- Uses CPM (CMake Package Manager) for automatic dependency fetching (Catch2 testing framework)
+- Automatically generates a library.cpp file from all .inl files when in compiled library mode  
+- Tests include compile-time verification that all headers can be included independently
+- Supports coverage reporting with gcov/gcovr on GCC/Clang
+
+### Important Compile-Time Configurations
+
+- `MH_COMPILE_LIBRARY` - Controls whether implementations are compiled into a library or included header-only
+- `MH_COROUTINES_SUPPORTED` - Enables C++20 coroutine functionality 
+- `MH_FORMATTER` - Selects formatting backend (fmtlib, std::format, or none)
+- `MH_BROKEN_UNICODE=1` - Forced workaround for compiler Unicode issues
+
+## Development Guidelines
+
+- This library requires C++20 and uses modern C++ features extensively
+- Platform support includes Windows (MSVC), Linux (GCC), and macOS (Clang)
+- Code follows RAII principles with move semantics preferred over copying
+- Exception safety is critical - all code should provide strong exception safety guarantees
+- The library is designed for zero-overhead abstractions with extensive use of `constexpr`
+
+## Testing
+
+Tests are located in the `test/` directory and use Catch2. The build system:
+- Automatically discovers all `*_test.cpp` files
+- Creates a unified test executable `mh_stuff_tests`
+- Includes compile-time tests to verify all headers can be included independently
+- Conditionally excludes platform-specific tests (e.g., `io_getopt_test.cpp` on systems without getopt)

CLAUDE.md

@@ -35,10 +35,6 @@ add_library(${PROJECT_NAME} ${MH_INTERFACE_OR_EMPTY}
 )
 add_library(mh::stuff ALIAS ${PROJECT_NAME})
 
-list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/mh-cmake-common")
-include(mh-BasicInstall)
-include(mh-CheckCoroutineSupport)
-
 if (MH_STUFF_COMPILE_LIBRARY)
 	find_package(CURL REQUIRED)
 
@@ -85,9 +81,6 @@ else()
 	)
 endif()
 
-mh_check_cxx_coroutine_support(SUPPORTS_COROUTINES COROUTINES_FLAGS)
-target_compile_options(${PROJECT_NAME} ${MH_PUBLIC_OR_INTERFACE} ${COROUTINES_FLAGS})
-
 target_include_directories(${PROJECT_NAME} ${MH_PUBLIC_OR_INTERFACE}
 	"$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/cpp/include>"
 	"$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
@@ -135,6 +128,8 @@ message(STATUS "Forcing MH_BROKEN_UNICODE=1 to work around compiler Unicode issu
 if (NOT DEFINED BUILD_TESTING)
 	if (CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
 		set(BUILD_TESTING ON)
+		# Define MH_STUFF_STANDALONE_BUILD when building as main project
+		target_compile_definitions(${PROJECT_NAME} ${MH_PUBLIC_OR_INTERFACE} "MH_STUFF_STANDALONE_BUILD")
 	else()
 		set(BUILD_TESTING OFF)
 	endif()
@@ -146,40 +141,4 @@ if (BUILD_TESTING)
 	add_subdirectory("test")
 endif()
 
-mh_basic_install(
-	PROJ_INCLUDE_DIRS "cpp/include/"
-)
 
-###########################################
-# "install" is intended for vcpkg support #
-###########################################
-# include(CMakePackageConfigHelpers)
-# configure_package_config_file(
-# 	cmake/config.cmake.in
-# 	"${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}-config.cmake"
-# 	INSTALL_DESTINATION "${CMAKE_INSTALL_DATADIR}/${PROJECT_NAME}"
-# )
-
-# include(GNUInstallDirs)
-
-# write_basic_package_version_file(
-# 	"${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}-config-version.cmake"
-# 	VERSION ${PROJECT_VERSION}
-# 	COMPATIBILITY SameMajorVersion
-# )
-
-# install(
-# 	FILES
-# 		"${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}-config.cmake"
-# 		"${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}-config-version.cmake"
-# 	DESTINATION
-# 		"${CMAKE_INSTALL_DATADIR}/${PROJECT_NAME}"
-# )
-
-# install(TARGETS stuff EXPORT ${PROJECT_NAME}_targets)
-# install(DIRECTORY cpp/include/ DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}")
-# install(
-# 	EXPORT ${PROJECT_NAME}_targets
-# 	NAMESPACE mh::
-# 	DESTINATION "${CMAKE_INSTALL_DATADIR}/${PROJECT_NAME}"
-# )

CMakeLists.txt

@@ -0,0 +1,126 @@
+{
+    "version": 3,
+    "cmakeMinimumRequired": {
+        "major": 3,
+        "minor": 16,
+        "patch": 3
+    },
+    "configurePresets": [
+        {
+            "name": "default",
+            "displayName": "Default Configuration",
+            "description": "Default build configuration with Ninja generator",
+            "generator": "Ninja",
+            "binaryDir": "${sourceDir}/build/default",
+            "cacheVariables": {
+                "CMAKE_BUILD_TYPE": "Debug",
+                "CMAKE_EXPORT_COMPILE_COMMANDS": "ON"
+            },
+            "condition": {
+                "type": "notEquals",
+                "lhs": "${hostSystemName}",
+                "rhs": "Windows"
+            }
+        },
+        {
+            "name": "debug",
+            "displayName": "Debug Configuration",
+            "description": "Debug build with coverage support",
+            "generator": "Ninja",
+            "binaryDir": "${sourceDir}/build/debug",
+            "cacheVariables": {
+                "CMAKE_BUILD_TYPE": "Debug",
+                "CMAKE_EXPORT_COMPILE_COMMANDS": "ON"
+            }
+        },
+        {
+            "name": "shared",
+            "displayName": "Shared Library",
+            "description": "Build as shared library",
+            "generator": "Ninja",
+            "binaryDir": "${sourceDir}/build/shared",
+            "cacheVariables": {
+                "CMAKE_BUILD_TYPE": "Release",
+                "CMAKE_EXPORT_COMPILE_COMMANDS": "ON",
+                "MH_STUFF_BUILD_SHARED_LIBS": "ON"
+            }
+        },
+        {
+            "name": "header-only",
+            "displayName": "Header-Only Mode",
+            "description": "Build in header-only mode",
+            "generator": "Ninja",
+            "binaryDir": "${sourceDir}/build/header-only",
+            "cacheVariables": {
+                "CMAKE_BUILD_TYPE": "Release",
+                "CMAKE_EXPORT_COMPILE_COMMANDS": "ON",
+                "MH_STUFF_COMPILE_LIBRARY": "OFF"
+            }
+        },
+        {
+            "name": "coverage",
+            "displayName": "Coverage Build",
+            "description": "Debug build optimized for coverage reporting",
+            "generator": "Ninja",
+            "binaryDir": "${sourceDir}/build/coverage",
+            "cacheVariables": {
+                "CMAKE_BUILD_TYPE": "Debug",
+                "CMAKE_EXPORT_COMPILE_COMMANDS": "ON",
+                "ENABLE_COVERAGE": "ON",
+                "CMAKE_CXX_FLAGS": "-g -O0 --coverage -fprofile-arcs -ftest-coverage",
+                "CMAKE_C_FLAGS": "-g -O0 --coverage -fprofile-arcs -ftest-coverage",
+                "CMAKE_EXE_LINKER_FLAGS": "--coverage"
+            },
+            "condition": {
+                "type": "notEquals",
+                "lhs": "${hostSystemName}",
+                "rhs": "Windows"
+            }
+        }
+    ],
+    "buildPresets": [
+        {
+            "name": "default",
+            "configurePreset": "default"
+        },
+        {
+            "name": "debug",
+            "configurePreset": "debug"
+        },
+        {
+            "name": "shared",
+            "configurePreset": "shared"
+        },
+        {
+            "name": "header-only",
+            "configurePreset": "header-only"
+        },
+        {
+            "name": "coverage",
+            "configurePreset": "coverage"
+        }
+    ],
+    "testPresets": [
+        {
+            "name": "default",
+            "configurePreset": "default",
+            "output": {
+                "outputOnFailure": true
+            }
+        },
+        {
+            "name": "debug",
+            "configurePreset": "debug",
+            "output": {
+                "outputOnFailure": true
+            }
+        },
+        {
+            "name": "coverage",
+            "configurePreset": "coverage",
+            "output": {
+                "outputOnFailure": true
+            }
+        }
+    ]
+}

CMakePresets.json

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2019 Matt Haynie
+Copyright (c) 2025 Matt Haynie
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

LICENSE

@@ -30,6 +30,7 @@ namespace mh
 		explicit heap(std::initializer_list<T> values, TComparator comparator = TComparator{}) :
 			m_Container(values.begin(), values.end()), m_Comparator(std::move(comparator))
 		{
+			std::make_heap(m_Container.begin(), m_Container.end(), m_Comparator);
 		}
 
 		void push(const T& value)

cpp/include/mh/containers/heap.hpp

@@ -15,9 +15,18 @@ namespace mh::io
 {
 #ifdef __unix__
     MH_COMPILE_LIBRARY_INLINE fd_sink::fd_sink(native_handle fd, bool take_ownership)
-        : fd_(take_ownership ? unique_native_handle(fd) : unique_native_handle(dup(fd))), 
+        : fd_(take_ownership ? unique_native_handle(fd) : unique_native_handle(dup(fd))),
           is_open_(fd >= 0)
     {
+        // Prevent multiple instantiations of standard streams
+        static bool stdin_created = false;
+
+        if (fd == STDIN_FILENO) {
+            if (stdin_created) {
+                throw std::runtime_error("Attempt to create multiple fd_sink instances for STDIN_FILENO");
+            }
+            stdin_created = true;
+        }
     }
 
     MH_COMPILE_LIBRARY_INLINE fd_sink::~fd_sink() = default;
@@ -26,11 +35,11 @@ namespace mh::io
     {
         if (!is_open_)
             throw std::runtime_error("fd_sink is not open");
-            
+
         ssize_t bytes_written = ::write(fd_.value(), buffer, size);
         if (bytes_written < 0)
             throw std::runtime_error("Failed to write to file descriptor");
-            
+
         co_return static_cast<size_t>(bytes_written);
     }
 
@@ -53,4 +62,20 @@ namespace mh::io
         return is_open_ && fd_;
     }
 #endif
-}
+
+    MH_COMPILE_LIBRARY_INLINE sink_ptr sink::create_file(const std::filesystem::path& filepath, bool append)
+    {
+#ifdef __unix__
+        int flags = O_WRONLY | O_CREAT | (append ? O_APPEND : O_TRUNC);
+        int fd = open(filepath.c_str(), flags, 0644);
+        if (fd == -1)
+        {
+            throw std::runtime_error("Failed to open file for writing: " + filepath.string());
+        }
+
+        return std::make_shared<fd_sink>(fd, true);
+#else
+        throw mh::not_implemented_error();
+#endif
+    }
+}