@auto_js/utility 0.0.7 → 0.0.8

package/functional/functional.cc

@@ -133,4 +133,19 @@ class reference_wrapper {
 		Type* value_;
 };
 
+// Wrapper allowing the return of temporaries from `operator->()`
+export template <class Type>
+class pointer_delegate {
+	public:
+		constexpr explicit pointer_delegate(const Type& value) : value{value} {}
+		constexpr explicit pointer_delegate(Type&& value) : value{std::move(value)} {}
+		constexpr auto operator*() -> Type& { return value; }
+		constexpr auto operator*() const -> const Type& { return value; }
+		constexpr auto operator->() -> Type* { return &value; }
+		constexpr auto operator->() const -> const Type* { return &value; }
+
+	private:
+		Type value;
+};
+
 } // namespace util

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@auto_js/utility",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "author": "https://github.com/laverdet/",
   "homepage": "https://github.com/laverdet/isolated-vm/tree/experimental/packages/utility",
   "license": "ISC",

package/utility/covariant_value.cc

@@ -10,10 +10,13 @@ export template <class Type, class... Types>
 // NOLINTNEXTLINE(cppcoreguidelines-special-member-functions)
 class covariant_value : public pointer_facade {
 	public:
+		constexpr covariant_value() : covariant_value{std::type_identity<Types...[ 0 ]>{}} {}
+
 		template <class Derived>
 			requires(... || (type<Derived> == type<Types>))
-		constexpr explicit covariant_value(Derived value) :
-				value_{std::move(value)} {}
+		// NOLINTNEXTLINE(google-explicit-constructor)
+		constexpr covariant_value(std::type_identity<Derived>, auto&&... args) :
+				value_{std::in_place_type<Derived>, std::forward<decltype(args)>(args)...} {}
 
 		constexpr auto operator*(this auto& self) noexcept -> auto& {
 			using reference_type = util::apply_cvref_t<decltype(self), Type>;

package/utility/utility.cc

@@ -157,4 +157,37 @@ auto make_inplace_container(auto&&... args) -> Type {
 	return inplace_container_constructor<Type>{}(std::forward<decltype(args)>(args)...);
 }
 
+// `std::bit_cast` into a type that is larger than needed. Useful for packing arbitrary small
+// trivials into C-style function callbacks which accept a `void*`
+export template <class Type>
+constexpr auto bit_padding_cast(const auto& value) -> Type {
+	using value_type = std::remove_cvref_t<decltype(value)>;
+	static_assert(sizeof(value_type) <= sizeof(Type), "'Type' must be larger than 'value'");
+	if constexpr (sizeof(value_type) == sizeof(Type)) {
+		return std::bit_cast<Type>(value);
+	} else {
+		struct [[gnu::packed]] holder {
+				value_type value;
+				std::array<std::byte, sizeof(Type) - sizeof(value_type)> padding;
+		};
+		return std::bit_cast<Type>(holder{.value = value, .padding = {}});
+	}
+}
+
+// `std::bit_cast` from the result of `util::bit_padding_cast`
+export template <class Type>
+constexpr auto bit_truncation_cast(const auto& value) -> Type {
+	using value_type = std::remove_cvref_t<decltype(value)>;
+	static_assert(sizeof(value_type) >= sizeof(Type), "'Type' must be smaller than 'value'");
+	if constexpr (sizeof(value_type) == sizeof(Type)) {
+		return std::bit_cast<Type>(value);
+	} else {
+		struct [[gnu::packed]] holder {
+				Type value;
+				std::array<std::byte, sizeof(value_type) - sizeof(Type)> padding;
+		};
+		return std::bit_cast<holder>(value).value;
+	}
+}
+
 } // namespace util