[ox/std] Fix bugs in HashMap and SmallMap

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

@@ -133,17 +133,18 @@ constexpr HashMap<K, T> &HashMap<K, T>::operator=(HashMap<K, T> &&other) noexcep
 
 template<typename K, typename T>
 constexpr T &HashMap<K, T>::operator[](MaybeView_t<K> const&k) {
-	auto &p = access(m_pairs, k);
+	auto p = &access(m_pairs, k);
-	if (p == nullptr) {
+	if (*p == nullptr) {
 		if (static_cast<double>(m_pairs.size()) * 0.7 <
 			 static_cast<double>(m_keys.size())) {
 			expand();
+			p = &access(m_pairs, k);
 		}
-		p = new Pair;
+		*p = new Pair;
-		p->key = k;
+		(*p)->key = k;
 		m_keys.emplace_back(k);
 	}
-	return p->value;
+	return (*p)->value;
 }
 
 template<typename K, typename T>
@@ -208,7 +209,7 @@ constexpr void HashMap<K, T>::clear() {
 
 template<typename K, typename T>
 constexpr void HashMap<K, T>::expand() {
-	Vector<Pair*> r;
+	Vector<Pair*> r(m_pairs.size() * 2);
 	for (std::size_t i = 0; i < m_keys.size(); ++i) {
 		auto const&k = m_keys[i];
 		access(r, k) = std::move(access(m_pairs, k));
@@ -221,7 +222,7 @@ template<typename KK>
 constexpr typename HashMap<K, T>::Pair *const&HashMap<K, T>::access(Vector<Pair*> const&pairs, KK const&k) const {
 	auto h = static_cast<std::size_t>(ox::hash<KK>{}(k) % pairs.size());
 	while (true) {
-		const auto &p = pairs[h];
+		auto const&p = *pairs.at(h).unwrap();
 		if (p == nullptr || p->key == k) {
 			return p;
 		} else {
@@ -235,7 +236,7 @@ template<typename KK>
 constexpr typename HashMap<K, T>::Pair *&HashMap<K, T>::access(Vector<Pair*> &pairs, KK const&k) {
 	auto h = static_cast<std::size_t>(ox::hash<KK>{}(k) % pairs.size());
 	while (true) {
-		auto &p = pairs[h];
+		auto &p = *pairs.at(h).unwrap();
 		if (p == nullptr || p->key == k) {
 			return p;
 		} else {

deps/ox/src/ox/std/smallmap.hpp

@@ -67,13 +67,11 @@ class SmallMap {
 		constexpr void clear();
 
 	private:
-		constexpr void expand();
+		template<typename KK>
+		constexpr Pair const&access(Vector<Pair> const&pairs, KK const&key, bool &isNew) const;
 
 		template<typename KK>
-		constexpr Pair *const&access(Vector<Pair> const&pairs, KK const&key) const;
+		constexpr Pair &access(Vector<Pair> &pairs, KK const&key, bool &isNew);
-
-		template<typename KK>
-		constexpr Pair *&access(Vector<Pair> &pairs, KK const&key);
 
 };
 
@@ -133,15 +131,10 @@ constexpr SmallMap<K, T> &SmallMap<K, T>::operator=(SmallMap<K, T> &&other) noex
 
 template<typename K, typename T>
 constexpr T &SmallMap<K, T>::operator[](MaybeView_t<K> const&k) {
-	auto &p = access(m_pairs, k);
+	bool isNew{};
-	if (p == nullptr) {
+	auto p = &access(m_pairs, k, isNew);
-		if (static_cast<double>(m_pairs.size()) * 0.7 <
+	if (isNew) {
-			 static_cast<double>(m_keys.size())) {
-			expand();
-		}
-		p = new Pair;
 		p->key = k;
-		m_keys.emplace_back(k);
 	}
 	return p->value;
 }
@@ -194,45 +187,41 @@ constexpr Vector<K> const&SmallMap<K, T>::keys() const noexcept {
 
 template<typename K, typename T>
 constexpr void SmallMap<K, T>::clear() {
-	for (std::size_t i = 0; i < m_pairs.size(); i++) {
-		delete m_pairs[i];
-	}
 	m_pairs.clear();
 	m_pairs.resize(127);
 }
 
-template<typename K, typename T>
-constexpr void SmallMap<K, T>::expand() {
-	Vector<Pair*> r;
-	for (std::size_t i = 0; i < m_keys.size(); ++i) {
-		auto const&k = m_keys[i];
-		access(r, k) = std::move(access(m_pairs, k));
-	}
-	m_pairs = std::move(r);
-}
-
 template<typename K, typename T>
 template<typename KK>
-constexpr typename SmallMap<K, T>::Pair *const&SmallMap<K, T>::access(
+constexpr typename SmallMap<K, T>::Pair const&SmallMap<K, T>::access(
-		Vector<Pair> const&pairs, KK const&k) const {
+		Vector<Pair> const&pairs, KK const&k, bool &isNew) const {
 	for (auto const&p : pairs) {
 		if (p.key == k) {
-			return &p;
+			isNew = false;
+			return p;
 		}
 	}
-	return nullptr;
+	isNew = true;
+	m_keys.emplace_back(K(k));
+	return pairs.emplace_back();
 }
 
 template<typename K, typename T>
 template<typename KK>
-constexpr typename SmallMap<K, T>::Pair *&SmallMap<K, T>::access(
+constexpr typename SmallMap<K, T>::Pair &SmallMap<K, T>::access(
-		Vector<Pair> &pairs, KK const&k) {
+		Vector<Pair> &pairs, KK const&k, bool &isNew) {
 	for (auto &p : pairs) {
 		if (p.key == k) {
-			return &p;
+			isNew = false;
+			return p;
 		}
 	}
-	return nullptr;
+	isNew = true;
+	if (static_cast<double>(m_pairs.size()) * 0.7 <
+	    static_cast<double>(m_keys.size())) {
+	}
+	m_keys.emplace_back(K(k));
+	return pairs.emplace_back();
 }
 
 }

deps/ox/src/ox/std/uuid.hpp

@@ -146,6 +146,14 @@ class UUID {
 			return out;
 		}
 
+		constexpr bool operator==(UUID const&o) const noexcept {
+			return m_value == o.m_value;
+		}
+
+		constexpr bool operator!=(UUID const&o) const noexcept {
+			return !operator==(o);
+		}
+
 		[[nodiscard]]
 		constexpr ox::Error toString(Writer_c auto &writer) const noexcept {
 			auto valueI = 0u;

src/nostalgia/modules/core/src/keel/keelmodule.cpp

@@ -58,23 +58,25 @@ static class: public keel::Module {
 		ox::Vector<keel::PackTransform> packTransforms() const noexcept final {
 			return {
 				// convert tilesheets to CompactTileSheets
-				[](keel::Context &ctx, ox::Buffer &buff, ox::StringView typeId) -> ox::Error {
+				[](keel::Context &ctx, ox::Buffer &buff, ox::StringView typeId) -> ox::Result<bool> {
 					if (typeId == ox::ModelTypeId_v<TileSheetV1> ||
 					    typeId == ox::ModelTypeId_v<TileSheetV2> ||
 					    typeId == ox::ModelTypeId_v<TileSheetV3> ||
 					    typeId == ox::ModelTypeId_v<TileSheetV4>) {
-						return keel::convertBuffToBuff<CompactTileSheet>(
+						oxReturnError(keel::convertBuffToBuff<CompactTileSheet>(
-								ctx, buff, ox::ClawFormat::Metal).moveTo(buff);
+								ctx, buff, ox::ClawFormat::Metal).moveTo(buff));
+						return true;
 					}
-					return {};
+					return false;
 				},
-				[](keel::Context &ctx, ox::Buffer &buff, ox::StringView typeId) -> ox::Error {
+				[](keel::Context &ctx, ox::Buffer &buff, ox::StringView typeId) -> ox::Result<bool> {
 					if (typeId == ox::ModelTypeId_v<NostalgiaPalette> ||
 					    typeId == ox::ModelTypeId_v<PaletteV1>) {
-						return keel::convertBuffToBuff<Palette>(
+						oxReturnError(keel::convertBuffToBuff<Palette>(
-								ctx, buff, ox::ClawFormat::Metal).moveTo(buff);
+								ctx, buff, ox::ClawFormat::Metal).moveTo(buff));
+						return true;
 					}
-					return {};
+					return false;
 				},
 			};
 		}

src/olympic/keel/include/keel/context.hpp

@@ -12,7 +12,7 @@
 namespace keel {
 
 class Context;
-using PackTransform = ox::Error(*)(Context&, ox::Buffer &clawData, ox::StringView);
+using PackTransform = ox::Result<bool>(*)(Context&, ox::Buffer &clawData, ox::StringView);
 
 class Context {
 	public:

src/olympic/keel/include/keel/typeconv.hpp

@@ -162,11 +162,12 @@ ox::Result<ox::Buffer> convertBuffToBuff(
 }
 
 template<typename From, typename To, ox::ClawFormat fmt = ox::ClawFormat::Metal>
-auto transformRule(keel::Context &ctx, ox::Buffer &buff, ox::StringView typeId) noexcept -> ox::Error {
+ox::Result<bool> transformRule(keel::Context &ctx, ox::Buffer &buff, ox::StringView typeId) noexcept {
 	if (typeId == ox::ModelTypeId_v<From>) {
 		oxReturnError(keel::convertBuffToBuff<To>(ctx, buff, fmt).moveTo(buff));
+		return true;
 	}
-	return {};
+	return false;
 };
 
 

src/olympic/keel/src/media.cpp

@@ -102,9 +102,13 @@ ox::Result<ox::String> uuidToPath(Context &ctx, ox::UUID const&uuid) noexcept {
 }
 
 ox::Error performPackTransforms(Context &ctx, ox::Buffer &clawData) noexcept {
-	oxRequire(typeId, readAssetTypeId(clawData).to<ox::String>());
+	oxRequireM(typeId, readAssetTypeId(clawData));
 	for (auto const tr : packTransforms(ctx)) {
-		oxReturnError(tr(ctx, clawData, typeId));
+		bool changed{};
+		oxReturnError(tr(ctx, clawData, typeId).moveTo(changed));
+		if (changed) {
+			oxReturnError(readAssetTypeId(clawData).moveTo(typeId));
+		}
 	}
 	return {};
 }