[nostalgia/studio] Bump version to 2024.12.4

deps/ox/src/ox/model/typestore.hpp

@@ -58,7 +58,11 @@ class TypeStore {
 				if (!std::is_constant_evaluated()) {
 					OX_REQUIRE_M(dt, loadDescriptor(typeId));
 					for (auto &f : dt->fieldList) {
-						OX_RETURN_ERROR(this->getLoad(f.typeId).moveTo(f.type));
+						if (typeId == f.typeId) {
+							f.type = dt.get();
+						} else {
+							OX_RETURN_ERROR(this->getLoad(f.typeId).moveTo(f.type));
+						}
 					}
 					auto &out = m_cache[typeId];
 					out = std::move(dt);

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

@@ -11,6 +11,7 @@
 #include "algorithm.hpp"
 #include "hash.hpp"
 #include "ignore.hpp"
+#include "optional.hpp"
 #include "stringview.hpp"
 #include "strops.hpp"
 #include "vector.hpp"
@@ -26,11 +27,12 @@ class HashMap {
 
 	private:
 		struct Pair {
+			UPtr<Pair> next;
 			K key = {};
 			T value{};
 		};
 		Vector<K> m_keys;
-		Vector<Pair*> m_pairs;
+		Vector<UPtr<Pair>> m_pairs;
 
 	public:
 		explicit constexpr HashMap(std::size_t size = 127);
@@ -73,10 +75,10 @@ class HashMap {
 		constexpr void expand();
 
 		template<typename KK>
-		constexpr Pair *const&access(Vector<Pair*> const&pairs, KK const&key) const;
+		constexpr UPtr<Pair> const &access(Vector<UPtr<Pair>> const &pairs, KK const &key) const;
 
 		template<typename KK>
-		constexpr Pair *&access(Vector<Pair*> &pairs, KK const&key);
+		constexpr UPtr<Pair> &access(Vector<UPtr<Pair>> &pairs, KK const &key);
 
 };
 
@@ -85,14 +87,13 @@ constexpr HashMap<K, T>::HashMap(std::size_t size): m_pairs(size) {
 }
 
 template<typename K, typename T>
-constexpr HashMap<K, T>::HashMap(HashMap<K, T> const&other) {
+constexpr HashMap<K, T>::HashMap(HashMap const &other) {
-	m_pairs = other.m_pairs;
+	operator=(other);
 }
 
 template<typename K, typename T>
-constexpr HashMap<K, T>::HashMap(HashMap<K, T> &&other) noexcept {
+constexpr HashMap<K, T>::HashMap(HashMap &&other) noexcept {
-	m_keys = std::move(other.m_keys);
+	operator=(std::move(other));
-	m_pairs = std::move(other.m_pairs);
 }
 
 template<typename K, typename T>
@@ -101,7 +102,7 @@ constexpr HashMap<K, T>::~HashMap() {
 }
 
 template<typename K, typename T>
-constexpr bool HashMap<K, T>::operator==(HashMap const&other) const {
+constexpr bool HashMap<K, T>::operator==(HashMap const &other) const {
 	if (m_keys != other.m_keys) {
 		return false;
 	}
@@ -115,19 +116,25 @@ constexpr bool HashMap<K, T>::operator==(HashMap const&other) const {
 }
 
 template<typename K, typename T>
-constexpr HashMap<K, T> &HashMap<K, T>::operator=(HashMap<K, T> const&other) {
+constexpr HashMap<K, T> &HashMap<K, T>::operator=(HashMap const &other) {
 	if (this != &other) {
 		clear();
 		m_keys = other.m_keys;
-		m_pairs = other.m_pairs;
+		m_pairs.resize(other.m_pairs.size());
+		for (auto const&k : m_keys) {
+			auto const &src = access(other.m_pairs, k);
+			auto &dst = access(m_pairs, k);
+			dst = ox::make_unique<Pair>();
+			dst->key = src->key;
+			dst->value = src->value;
+		}
 	}
 	return *this;
 }
 
 template<typename K, typename T>
-constexpr HashMap<K, T> &HashMap<K, T>::operator=(HashMap<K, T> &&other) noexcept {
+constexpr HashMap<K, T> &HashMap<K, T>::operator=(HashMap &&other) noexcept {
 	if (this != &other) {
-		clear();
 		m_keys = std::move(other.m_keys);
 		m_pairs = std::move(other.m_pairs);
 	}
@@ -135,60 +142,52 @@ 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) {
+constexpr T &HashMap<K, T>::operator[](MaybeView_t<K> const &key) {
-	auto p = &access(m_pairs, k);
+	auto p = &access(m_pairs, key);
 	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 = &access(m_pairs, key);
 		}
-		*p = new Pair;
+		*p = ox::make_unique<Pair>();
-		(*p)->key = k;
+		(*p)->key = key;
-		m_keys.emplace_back(k);
+		m_keys.emplace_back(key);
 	}
 	return (*p)->value;
 }
 
 template<typename K, typename T>
-constexpr Result<T*> HashMap<K, T>::at(MaybeView_t<K> const&k) noexcept {
+constexpr Result<T*> HashMap<K, T>::at(MaybeView_t<K> const &key) noexcept {
-	auto p = access(m_pairs, k);
+	auto &p = access(m_pairs, key);
 	if (!p) {
-		return {nullptr, ox::Error(1, "value not found for given key")};
+		return ox::Error{1, "value not found for given key"};
 	}
 	return &p->value;
 }
 
 template<typename K, typename T>
-constexpr Result<const T*> HashMap<K, T>::at(MaybeView_t<K> const&k) const noexcept {
+constexpr Result<const T*> HashMap<K, T>::at(MaybeView_t<K> const &key) const noexcept {
-	auto p = access(m_pairs, k);
+	auto &p = access(m_pairs, key);
 	if (!p) {
-		return {nullptr, ox::Error(1, "value not found for given key")};
+		return ox::Error{1, "value not found for given key"};
 	}
 	return &p->value;
 }
 
 template<typename K, typename T>
-constexpr void HashMap<K, T>::erase(MaybeView_t<K> const&k) {
+constexpr void HashMap<K, T>::erase(MaybeView_t<K> const &key) {
-	if (!contains(k)) {
+	if (!contains(key)) {
 		return;
 	}
-	auto h = ox::hash<MaybeView_t<K>>{}(k) % m_pairs.size();
+	auto &c = access(m_pairs, key);
-	while (true) {
+	c = std::move(c->next);
-		const auto &p = m_pairs[h];
+	std::ignore = m_keys.erase(ox::find(m_keys.begin(), m_keys.end(), key));
-		if (p == nullptr || p->key == k) {
-			std::ignore = m_pairs.erase(h);
-			break;
-		} else {
-			h = ox::hash<MaybeView_t<K>>{}(k) % m_pairs.size();
-		}
-	}
-	std::ignore = m_keys.erase(ox::find(m_keys.begin(), m_keys.end(), k));
 }
 
 template<typename K, typename T>
-constexpr bool HashMap<K, T>::contains(MaybeView_t<K> const&k) const noexcept {
+constexpr bool HashMap<K, T>::contains(MaybeView_t<K> const &key) const noexcept {
-	return access(m_pairs, k) != nullptr;
+	return access(m_pairs, key).get() != nullptr;
 }
 
 template<typename K, typename T>
@@ -204,27 +203,26 @@ constexpr Vector<K> const&HashMap<K, T>::keys() const noexcept {
 template<typename K, typename T>
 constexpr Vector<T> HashMap<K, T>::values() const noexcept {
 	Vector<T> out;
-	out.reserve(m_pairs.size());
+	out.reserve(m_keys.size());
-	for (auto const&p : m_pairs) {
+	for (auto const &p : m_pairs) {
-		out.emplace_back(p->value);
+		if (out) {
+			out.emplace_back(p->value);
+		}
 	}
 	return out;
 }
 
 template<typename K, typename T>
 constexpr void HashMap<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 HashMap<K, T>::expand() {
-	Vector<Pair*> r(m_pairs.size() * 2);
+	Vector<UPtr<Pair>> r{m_pairs.size() * 2};
 	for (std::size_t i = 0; i < m_keys.size(); ++i) {
-		auto const&k = m_keys[i];
+		auto const &k = m_keys[i];
 		access(r, k) = std::move(access(m_pairs, k));
 	}
 	m_pairs = std::move(r);
@@ -232,29 +230,39 @@ constexpr void HashMap<K, T>::expand() {
 
 template<typename K, typename T>
 template<typename KK>
-constexpr typename HashMap<K, T>::Pair *const&HashMap<K, T>::access(Vector<Pair*> const&pairs, KK const&k) const {
+constexpr UPtr<typename HashMap<K, T>::Pair> const &HashMap<K, T>::access(
-	auto h = static_cast<std::size_t>(ox::hash<KK>{}(k) % pairs.size());
+		Vector<UPtr<Pair>> const& pairs,
+		KK const &key) const {
+	auto const h = static_cast<std::size_t>(ox::hash<KK>{}(key) % pairs.size());
+	auto const &p = *pairs.at(h).unwrap();
+	if (p == nullptr || p->key == key) {
+		return p;
+	}
+	auto c = &p->next;
 	while (true) {
-		auto const&p = *pairs.at(h).unwrap();
+		if (*c == nullptr || (*c)->key == key) {
-		if (p == nullptr || p->key == k) {
+			return *c;
-			return p;
-		} else {
-			h = (h + 1) % pairs.size();
 		}
+		c = &(*c)->next;
 	}
 }
 
 template<typename K, typename T>
 template<typename KK>
-constexpr typename HashMap<K, T>::Pair *&HashMap<K, T>::access(Vector<Pair*> &pairs, KK const&k) {
+constexpr UPtr<typename HashMap<K, T>::Pair> &HashMap<K, T>::access(
-	auto h = static_cast<std::size_t>(ox::hash<KK>{}(k) % pairs.size());
+		Vector<UPtr<Pair>> &pairs,
+		KK const &key) {
+	auto const h = static_cast<std::size_t>(ox::hash<KK>{}(key) % pairs.size());
+	auto &p = *pairs.at(h).unwrap();
+	if (p == nullptr || p->key == key) {
+		return p;
+	}
+	auto c = &p->next;
 	while (true) {
-		auto &p = *pairs.at(h).unwrap();
+		if (*c == nullptr || (*c)->key == key) {
-		if (p == nullptr || p->key == k) {
+			return *c;
-			return p;
-		} else {
-			h = (h + 1) % pairs.size();
 		}
+		c = &(*c)->next;
 	}
 }
 

deps/ox/src/ox/std/memory.hpp

@@ -260,12 +260,12 @@ constexpr bool operator==(const UniquePtr<T> &p1, const UniquePtr<T> &p2) noexce
 
 template<typename T>
 constexpr bool operator==(const UniquePtr<T> &p1, std::nullptr_t) noexcept {
-	return p1.get();
+	return p1.get() == nullptr;
 }
 
 template<typename T>
 constexpr bool operator==(std::nullptr_t, const UniquePtr<T> &p2) noexcept {
-	return p2.get();
+	return p2.get() == nullptr;
 }
 
 

deps/ox/src/ox/std/test/tests.cpp

@@ -273,6 +273,16 @@ OX_CLANG_NOWARN_END
 			si["aoeu"] = 100;
 			oxAssert(si["asdf"] == 42, "asdf != 42");
 			oxAssert(si["aoeu"] == 100, "aoeu != 100");
+			si.erase("asdf");
+			oxAssert(!si.contains("asdf"), "wrongly contains asdf");
+			oxAssert(si.contains("aoeu"), "does not contains aoeu");
+			oxAssert(!si.at("asdf").ok(), "asdf != 0");
+			oxExpect(si["asdf"], 0);
+			oxAssert(si["aoeu"] == 100, "aoeu != 100");
+			auto si2 = si;
+			oxDebugf("{}", si2["asdf"]);
+			oxExpect(si2["asdf"], 0);
+			oxAssert(si2["aoeu"] == 100, "aoeu != 100");
 			ox::HashMap<int, int> ii;
 			ii[4] = 42;
 			ii[5] = 100;

src/nostalgia/studio/CMakeLists.txt

@@ -11,7 +11,7 @@ target_link_libraries(
 
 target_compile_definitions(
 	NostalgiaStudio PUBLIC
-		OLYMPIC_APP_VERSION="d2024.12.3"
+		OLYMPIC_APP_VERSION="d2024.12.4"
 )
 
 install(

src/nostalgia/studio/Info.plist

@@ -18,7 +18,7 @@
 	<string>APPL</string>
 
 	<key>CFBundleVersion</key>
-	<string>0.0.0</string>
+	<string>d2024.12.4</string>
 
 	<key>LSMinimumSystemVersion</key>
 	<string>12.0.0</string>
@@ -30,6 +30,6 @@
 	<string>True</string>
 
 	<key>NSHumanReadableCopyright</key>
-	<string>Copyright (c) 2016-2023 Gary Talent &lt;gary@drinkingtea.net&gt;</string>
+	<string>Copyright (c) 2016-2025 Gary Talent &lt;gary@drinkingtea.net&gt;</string>
 </dict>
 </plist>