@auto_js/utility 0.0.1

package/memory/memory.cc

@@ -0,0 +1,64 @@
+module;
+#include <concepts>
+#include <functional>
+#include <memory>
+#include <type_traits>
+export module util:memory;
+export import :memory.autorelease_pool;
+export import :memory.comparator;
+export import :memory.noinit_allocator;
+
+namespace util {
+
+// Deleter object for base class which does not have a virtual destructor
+export template <class Type>
+class derived_delete {
+	public:
+		template <std::derived_from<Type> As>
+		explicit constexpr derived_delete(std::type_identity<As> /*type*/) noexcept :
+				delete_{[](Type* pointer) noexcept -> void {
+					delete static_cast<As*>(pointer);
+				}} {}
+
+		constexpr auto operator()(Type* value) const noexcept {
+			delete_(value);
+		}
+
+	private:
+		using function_type = auto(Type*) noexcept -> void;
+		function_type* delete_;
+};
+
+export template <class Type, class Deleter>
+auto move_pointer_operation(
+	std::unique_ptr<Type, Deleter> unique,
+	std::invocable<Type*, std::unique_ptr<Type, Deleter>> auto function
+) -> decltype(auto) {
+	auto* ptr = unique.get();
+	return std::invoke(std::move(function), ptr, std::move(unique));
+}
+
+export template <class Type>
+auto move_pointer_operation(
+	std::shared_ptr<Type> shared,
+	std::invocable<Type*, std::shared_ptr<Type>> auto function
+) -> decltype(auto) {
+	auto* ptr = shared.get();
+	return std::invoke(std::move(function), ptr, std::move(shared));
+}
+
+export template <class To, std::derived_from<To> Type, class Deleter>
+auto safe_pointer_upcast(std::unique_ptr<Type, Deleter> unique) {
+	struct cast_deleter : Deleter {
+			cast_deleter() = default;
+			// NOLINTNEXTLINE(google-explicit-constructor)
+			cast_deleter(Deleter deleter) noexcept : Deleter{std::move(deleter)} {}
+			using Deleter::operator();
+			constexpr auto operator()(To* ptr) const noexcept {
+				(*this)(static_cast<Type*>(ptr));
+			}
+	};
+	return std::unique_ptr<To, cast_deleter>{std::move(unique)};
+}
+
+} // namespace util

package/memory/noinit_allocator.cc

@@ -0,0 +1,64 @@
+module;
+#include "auto_js/no_unique_address.h"
+#include <concepts>
+#include <memory>
+#include <type_traits>
+#include <utility>
+export module util:memory.noinit_allocator;
+
+namespace util {
+
+// Allocator which skips default construction of trivial types during runtime.
+export template <class Type, class Allocator = std::allocator<Type>>
+class noinit_allocator {
+	public:
+		template <class, class> friend class noinit_allocator;
+		using value_type = Type;
+		using pointer = value_type*;
+
+		template <class T>
+		struct rebind {
+				using other = noinit_allocator<T, typename std::allocator_traits<Allocator>::template rebind_alloc<T>>;
+		};
+
+		noinit_allocator() = default;
+
+		template <class T>
+		constexpr explicit noinit_allocator(const noinit_allocator<T>& allocator) :
+				allocator_{allocator.allocator_} {}
+
+		auto operator==(const noinit_allocator&) const -> bool = default;
+
+		constexpr auto allocate(std::size_t count) -> pointer {
+			return allocator_.allocate(count);
+		}
+
+		constexpr auto construct(pointer ptr, auto&&... args) -> void
+			requires std::constructible_from<Type, decltype(args)...> {
+			auto construct = [ & ]() constexpr -> void {
+				std::allocator_traits<Allocator>::construct(allocator_, ptr, std::forward<decltype(args)>(args)...);
+			};
+			if consteval {
+				construct();
+			} else {
+				if constexpr (sizeof...(args) > 0) {
+					construct();
+				} else {
+					static_assert(std::is_trivially_constructible_v<Type>);
+				}
+			}
+		}
+
+		constexpr auto deallocate(pointer ptr, std::size_t count) -> void {
+			allocator_.deallocate(ptr, count);
+		}
+
+		constexpr auto destroy(pointer ptr) -> void {
+			std::allocator_traits<Allocator>::destroy(allocator_, ptr);
+		}
+
+	private:
+		NO_UNIQUE_ADDRESS Allocator allocator_;
+};
+
+} // namespace util

package/meta/algorithm.cc

@@ -0,0 +1,74 @@
+module;
+#include <type_traits>
+export module util:meta.algorithm;
+import :functional;
+import :utility;
+
+namespace util {
+
+// Makes a `util::type_pack<T...>` from `Something<T...>`
+export constexpr auto make_type_pack = util::overloaded{
+	// nb: Prevent `make_type_pack{type_pack_of{...}}` from turning into a mess of hidden types
+	[]<class... Types>(type_pack_of<Types...> pack) consteval -> auto { return pack; },
+	[]<template <class> class Pack, class... Types>(std::type_identity<Pack<Types...>> /*type*/) consteval -> auto {
+		return type_pack_of{type<Types>...};
+	},
+};
+
+// Concatenate 0..N `util::type_packs` together
+export constexpr auto pack_concat = util::overloaded{
+	[]() consteval -> auto { return type_pack{}; },
+	[](auto&&... packs) consteval -> auto { return (... + make_type_pack(packs)); },
+};
+
+// Apply transformation function to each type in the pack
+export constexpr auto pack_transform = [](auto pack, auto unary) consteval -> auto {
+	const auto [... types ] = pack;
+	return pack_concat(unary(types)...);
+};
+
+// Return a new `type_pack` with types matching the predicate
+// nb: `predicate` must be `util::fn<...>`
+export constexpr auto pack_filter = [](auto pack, auto predicate) consteval -> auto {
+	constexpr auto filter = [ = ](auto type) {
+		if constexpr (predicate(type)) {
+			return type_pack{type};
+		} else {
+			return type_pack{};
+		}
+	};
+	return pack_transform(pack, filter);
+};
+
+// Return a nested `type_pack` of `tuple_pack`'s containing types filtered by the predicates
+// nb: `predicates` must be `util::fn<...>`
+export constexpr auto pack_partition = util::overloaded{
+	[](auto pack) consteval -> auto { return type_pack{pack}; },
+	[]<class Predicate>(this auto pack_partition, auto pack, Predicate predicate, auto... predicates) consteval -> auto {
+		// `std::not_fn()` doesn't work
+		constexpr auto not_fn = util::fn<[](auto type) -> bool { return !Predicate{}(type); }>;
+		const auto left = pack_filter(pack, predicate);
+		const auto right = pack_filter(pack, not_fn);
+		return pack_concat(pack_partition(left), pack_partition(right, predicates...));
+	},
+};
+
+// Return unique types from the pack
+export constexpr auto pack_unique = util::overloaded{
+	[]() consteval -> auto { return type_pack{}; },
+	[](auto... types) consteval -> auto {
+		constexpr auto transform = [ = ](auto index) {
+			constexpr auto subject = types...[ index ];
+			const auto [... indices ] = util::sequence<index>;
+			if constexpr ((... || (subject == types...[ indices ]))) {
+				return type_pack_of{};
+			} else {
+				return type_pack_of{subject};
+			}
+		};
+		const auto [... indices ] = util::sequence<sizeof...(types)>;
+		return (... + transform(indices));
+	},
+};
+
+} // namespace util

package/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@auto_js/utility",
+  "version": "0.0.1",
+  "author": "https://github.com/laverdet/",
+  "homepage": "https://github.com/laverdet/isolated-vm/tree/experimental/packages/utility",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/laverdet/isolated-vm.git"
+  }
+}

package/platform/lockable.cc

@@ -0,0 +1,261 @@
+module;
+#include "auto_js/no_unique_address.h"
+#include <cassert>
+#include <concepts>
+#include <condition_variable>
+#include <functional>
+#include <mutex>
+#include <shared_mutex>
+#include <stop_token>
+#include <utility>
+#include <variant>
+export module util:platform.lockable;
+import :type_traits;
+import :utility;
+
+namespace util {
+
+template <class Type>
+concept basic_lockable = requires(Type lock) {
+	{ lock.lock() } -> std::same_as<void>;
+	{ lock.unlock() } -> std::same_as<void>;
+};
+
+template <class Type>
+concept shared_lockable =
+	basic_lockable<Type> &&
+	requires(Type lock) {
+		{ lock.lock_shared() } -> std::same_as<void>;
+		{ lock.unlock_shared() } -> std::same_as<void>;
+	};
+
+template <class Type>
+concept notifiable = requires(Type cv) {
+	{ cv.notify_one() } -> std::same_as<void>;
+	{ cv.notify_all() } -> std::same_as<void>;
+};
+
+template <class Type, class Lock>
+concept waitable = requires(Type cv, Lock lock) {
+	{ cv.wait(lock) } -> std::same_as<void>;
+};
+
+// Predicate wrapper, binding to resource reference
+template <class Resource, std::predicate<const Resource&> Predicate>
+class resource_predicate {
+	public:
+		resource_predicate(const Resource& resource, Predicate predicate) :
+				resource_{resource},
+				predicate_{std::move(predicate)} {}
+
+		auto operator()() const -> bool {
+			// nb: `std::invoke` used so member function predicates work
+			return std::invoke(predicate_, resource_.get());
+		}
+
+	private:
+		std::reference_wrapper<const Resource> resource_;
+		NO_UNIQUE_ADDRESS Predicate predicate_;
+};
+
+// This is the return value of `read`, `write`, etc
+template <class Resource, class Lock>
+class locked : public Lock, public pointer_facade {
+	public:
+		explicit locked(Resource& resource, auto&&... lock_args)
+			requires std::constructible_from<Lock, decltype(lock_args)...> :
+				Lock{std::forward<decltype(lock_args)>(lock_args)...},
+				resource_{resource} {}
+
+		auto operator*() const -> Resource& { return resource_.get(); }
+
+	private:
+		std::reference_wrapper<Resource> resource_;
+};
+
+// Holds a lock and on destruction notifies the given condition variable
+template <std::predicate Predicate, class Lock, notifiable Notifiable>
+class lock_notify {
+	public:
+		lock_notify(Predicate predicate, Notifiable& cv, auto&&... lock_args)
+			requires std::constructible_from<Lock, decltype(lock_args)...> :
+				predicate_{std::move(predicate)},
+				cv_{&cv},
+				lock_{std::forward<decltype(lock_args)>(lock_args)...} {}
+
+		lock_notify(const lock_notify&) = delete;
+		lock_notify(lock_notify&& that) noexcept :
+				cv_{std::exchange(that.cv_, nullptr)},
+				lock_{std::move(that).lock_} {};
+
+		~lock_notify() {
+			if (cv_ != nullptr && predicate_()) {
+				cv_->notify_one();
+			}
+		}
+
+		auto operator=(const lock_notify&) = delete;
+		auto operator=(lock_notify&& that) = delete;
+
+	private:
+		Predicate predicate_;
+		Notifiable* cv_;
+		Lock lock_;
+};
+
+// Holds a lock with the option to wait on a condition variable
+template <std::predicate Predicate, basic_lockable Lock, waitable<Lock> Waitable>
+class lock_waitable : public Lock {
+	public:
+		lock_waitable(Predicate predicate, Waitable& cv, auto&&... lock_args)
+			requires std::constructible_from<Lock, decltype(lock_args)...> :
+				Lock{std::forward<decltype(lock_args)>(lock_args)...},
+				predicate_{std::move(predicate)},
+				cv_{&cv} {}
+
+		auto notify_all() -> void { cv_->notify_one(); }
+		auto notify_one() -> void { cv_->notify_one(); }
+
+		auto wait() -> void {
+			cv_->wait(*this, predicate_);
+		}
+
+		template <class Rep, class Period>
+		auto wait(std::chrono::duration<Rep, Period> duration) -> bool {
+			return cv_->wait_for(*this, duration, predicate_);
+		}
+
+		template <class Rep, class Period>
+		auto wait(std::chrono::time_point<Rep, Period> time_point) -> bool {
+			return cv_->wait_until(*this, time_point, predicate_);
+		}
+
+		auto wait(std::stop_token stop_token) -> bool
+			requires(type<Waitable> == type<std::condition_variable_any>) {
+			assert(stop_token.stop_possible());
+			return cv_->wait(*this, stop_token, predicate_);
+		}
+
+		template <class Rep, class Period>
+		auto wait(std::stop_token stop_token, std::chrono::duration<Rep, Period> duration) -> bool
+			requires(type<Waitable> == type<std::condition_variable_any>) {
+			return cv_->wait_for(*this, stop_token, duration, predicate_);
+		}
+
+		template <class Rep, class Period>
+		auto wait(std::stop_token stop_token, std::chrono::time_point<Rep, Period> time_point) -> bool
+			requires(type<Waitable> == type<std::condition_variable_any>) {
+			return cv_->wait_until(*this, stop_token, time_point, predicate_);
+		}
+
+	private:
+		Predicate predicate_;
+		Waitable* cv_;
+};
+
+// Lockable resource with configurable mutex and condition variable types
+export template <class Resource, basic_lockable Mutex = std::mutex, class ConditionVariable = std::monostate>
+class lockable {
+	public:
+		using mutex_type = Mutex;
+		using resource_type = Resource;
+
+	private:
+		using scoped_read_lock =
+			std::conditional_t<shared_lockable<mutex_type>, std::shared_lock<mutex_type>, std::scoped_lock<mutex_type>>;
+		using unique_read_lock =
+			std::conditional_t<shared_lockable<mutex_type>, std::shared_lock<mutex_type>, std::unique_lock<mutex_type>>;
+
+		using scoped_write_lock = std::scoped_lock<mutex_type>;
+		using unique_write_lock = std::unique_lock<mutex_type>;
+
+		template <class Lock, class Predicate>
+		using notify_type = lock_notify<resource_predicate<resource_type, Predicate>, Lock, ConditionVariable>;
+
+		template <class Lock, class Predicate>
+		using waitable_type = lock_waitable<resource_predicate<resource_type, Predicate>, Lock, ConditionVariable>;
+
+	public:
+		explicit lockable(auto&&... args) noexcept :
+				resource_{std::forward<decltype(args)>(args)...} {}
+
+		// `read`
+		using read_type = locked<const resource_type, scoped_read_lock>;
+
+		auto read() -> read_type {
+			return read_type{resource_, mutex_};
+		}
+
+		// `read_waitable`
+		template <class Predicate>
+		using read_waitable_type = locked<const resource_type, waitable_type<unique_read_lock, Predicate>>;
+
+		template <std::predicate<const resource_type&> Predicate>
+		auto read_waitable(Predicate predicate) -> read_waitable_type<Predicate> {
+			return read_waitable_type<Predicate>{resource_, resource_predicate{resource_, std::move(predicate)}, condition_variable_, mutex_};
+		}
+
+		// `write`
+		using write_type = locked<resource_type, scoped_write_lock>;
+
+		auto write() -> write_type {
+			return write_type{resource_, mutex_};
+		}
+
+		// `write_notify`
+		template <class Predicate>
+		using write_notify_type = locked<resource_type, notify_type<unique_write_lock, Predicate>>;
+
+		auto write_notify() {
+			return write_notify([](const auto&) -> bool { return true; });
+		}
+
+		template <std::predicate<const resource_type&> Predicate>
+		auto write_notify(Predicate predicate) -> write_notify_type<Predicate> {
+			return write_notify_type<Predicate>{resource_, resource_predicate{resource_, std::move(predicate)}, condition_variable_, mutex_};
+		}
+
+		// `write_waitable`
+		template <class Predicate>
+		using write_waitable_type = locked<resource_type, waitable_type<unique_write_lock, Predicate>>;
+
+		template <std::predicate<const resource_type&> Predicate>
+		auto write_waitable(Predicate predicate) -> write_waitable_type<Predicate> {
+			return write_waitable_type<Predicate>{resource_, resource_predicate{resource_, std::move(predicate)}, condition_variable_, mutex_};
+		}
+
+	private:
+		mutex_type mutex_;
+		Resource resource_;
+		NO_UNIQUE_ADDRESS ConditionVariable condition_variable_;
+};
+
+// Preset lockable types
+struct lockable_traits {
+		bool interuptable{};
+		bool notifiable{};
+		bool shared{};
+};
+
+export template <class Resource, lockable_traits Traits = {}>
+using lockable_with = type_t<[]() consteval {
+	using mutex_type = type_t<[]() {
+		if constexpr (Traits.shared) {
+			return type<std::shared_mutex>;
+		} else {
+			return type<std::mutex>;
+		}
+	}()>;
+	using cv_type = type_t<[]() {
+		if constexpr (Traits.interuptable) {
+			return type<std::condition_variable_any>;
+		} else if constexpr (Traits.notifiable) {
+			return type<std::condition_variable>;
+		} else {
+			return type<std::monostate>;
+		}
+	}()>;
+	return type<lockable<Resource, mutex_type, cv_type>>;
+}()>;
+
+} // namespace util

package/platform/shim/darwin.cc

@@ -0,0 +1,8 @@
+#include <__functional/hash.h>
+#if _LIBCPP_AVAILABILITY_HAS_HASH_MEMORY
+namespace std::inline __1 {
+[[__gnu__::__pure__]] _LIBCPP_EXPORTED_FROM_ABI size_t __hash_memory(_LIBCPP_NOESCAPE const void* __ptr, size_t __size) _NOEXCEPT {
+	return __murmur2_or_cityhash<size_t>()(__ptr, __size);
+}
+} // namespace std::inline __1
+#endif

package/platform/stop_token.cc

@@ -0,0 +1,107 @@
+module;
+#include <stop_token>
+#include <utility>
+export module util:platform.stop_token;
+import :functional;
+import :utility;
+
+namespace util {
+
+// Combine multiple `std::stop_token`s into one `std::stop_token` that is stopped when any of the
+// source tokens is stopped.
+export template <size_t Size>
+class composite_stop_token : private std::stop_source, public std::stop_token {
+	private:
+		static auto make_callback(std::stop_source stop_source) {
+			// I wonder what's better: copying the stop state into each callback, or using function
+			// pointer..
+			return [ stop_source = std::move(stop_source) ]() mutable -> void { stop_source.request_stop(); };
+		}
+
+		using callback_type = decltype(make_callback(std::declval<std::stop_source>()));
+		using stop_callback_type = std::stop_callback<callback_type>;
+		using callback_pack_type = std::array<stop_callback_type, Size>;
+
+	public:
+		using std::stop_token::stop_possible;
+		using std::stop_token::stop_requested;
+
+		// Check stoppability of the tokens
+		template <std::convertible_to<std::stop_source> Source, std::convertible_to<std::stop_token>... Tokens>
+			requires(Size == sizeof...(Tokens))
+		explicit composite_stop_token(Source&& source, Tokens&&... tokens) :
+				composite_stop_token{
+					std::forward<Source>(source),
+					(... + (tokens.stop_possible() ? 1 : 0)),
+					std::forward<Tokens>(tokens)...
+				} {}
+
+		// Makes a fresh `std::stop_source` internally
+		template <std::convertible_to<std::stop_token>... Tokens>
+		explicit composite_stop_token(Tokens&&... tokens) :
+				composite_stop_token{std::stop_source{}, std::forward<decltype(tokens)>(tokens)...} {}
+
+	private:
+		// Some finesse is required because `std::stop_callback` is not move constructible
+		template <class Source, class... Tokens>
+		explicit composite_stop_token(Source&& source, int stoppable, Tokens&&... tokens) :
+				std::stop_source{std::forward<Source>(source)},
+				std::stop_token{util::elide{[ & ]() -> std::stop_token {
+					switch (stoppable) {
+						// No `stop_token`
+						case 0: return std::stop_token{};
+						// Delegated `stop_token`
+						case 1:
+							{
+								constexpr auto fold = util::overloaded{
+									[]() -> std::stop_token { std::unreachable(); },
+									[](auto&& token) -> std::stop_token { return std::forward<decltype(token)>(token); },
+									[](this auto& fold, auto&& token, auto&&... tokens) -> std::stop_token {
+										if (token.stop_possible()) {
+											return std::forward<decltype(token)>(token);
+										} else {
+											return fold(std::forward<decltype(tokens)>(tokens)...);
+										}
+									},
+								};
+								return fold(std::forward<decltype(tokens)>(tokens)...);
+							}
+						// Callback `stop_token`
+						default: return std::stop_source::get_token();
+					}
+				}}},
+				callbacks_{[ & ]() -> callback_pack_type {
+					switch (stoppable) {
+						// No-op callback pack
+						case 0:
+						case 1:
+							{
+								auto callback = make_callback(std::stop_source{});
+								return {stop_callback_type{(util::unused(tokens), std::stop_token{}), callback}...};
+							}
+						// Make callback pack
+						default:
+							{
+								auto callback = make_callback(std::move(static_cast<std::stop_source&>(*this)));
+								return {stop_callback_type{std::forward<decltype(tokens)>(tokens), callback}...};
+							}
+					}
+				}()} {}
+
+		// Default init callbacks with no tokens
+		callback_pack_type callbacks_;
+};
+
+template <std::convertible_to<std::stop_token>... Tokens>
+composite_stop_token(Tokens&&... tokens) -> composite_stop_token<sizeof...(tokens)>;
+
+template <std::convertible_to<std::stop_source> Source, std::convertible_to<std::stop_token>... Tokens>
+composite_stop_token(Source&& source, Tokens&&... tokens) -> composite_stop_token<sizeof...(tokens)>;
+
+// `std::stop_source` that stops itself on destruction.
+export class scope_stop_source : util::non_copyable, public std::stop_source {
+	public:
+		~scope_stop_source() { request_stop(); }
+};
+
+} // namespace util