deps/ox/src/ox/oc/read.cpp

@@ -36,6 +36,135 @@ OrganicClawReader::OrganicClawReader(Json::Value json, int unionIdx) noexcept:
 	m_unionIdx(unionIdx) {
 }
 
+Error OrganicClawReader::field(const char *key, int8_t *val) noexcept {
+	auto err = OxError(0);
+	if (targetValid()) {
+		const auto &jv = value(key);
+		if (jv.empty()) {
+			*val = 0;
+		} else if (jv.isInt()) {
+			*val = static_cast<int8_t>(jv.asInt());
+		} else {
+			err = OxError(1, "Type mismatch");
+		}
+	}
+	++m_fieldIt;
+	return err;
+}
+
+Error OrganicClawReader::field(const char *key, int16_t *val) noexcept {
+	auto err = OxError(0);
+	if (targetValid()) {
+		const auto &jv = value(key);
+		if (jv.empty()) {
+			*val = 0;
+		} else if (jv.isInt()) {
+			*val = static_cast<int16_t>(jv.asInt());
+		} else {
+			err = OxError(1, "Type mismatch");
+		}
+	}
+	++m_fieldIt;
+	return err;
+}
+
+Error OrganicClawReader::field(const char *key, int32_t *val) noexcept {
+	auto err = OxError(0);
+	if (targetValid()) {
+		const auto &jv = value(key);
+		if (jv.empty()) {
+			*val = 0;
+		} else if (jv.isInt()) {
+			*val = static_cast<int32_t>(jv.asInt());
+		} else {
+			err = OxError(1, "Type mismatch");
+		}
+	}
+	++m_fieldIt;
+	return err;
+}
+
+Error OrganicClawReader::field(const char *key, int64_t *val) noexcept {
+	auto err = OxError(0);
+	if (targetValid()) {
+		const auto &jv = value(key);
+		if (jv.empty()) {
+			*val = 0;
+		} else if (jv.isInt() || jv.isInt64()) {
+			*val = static_cast<int64_t>(jv.asInt64());
+		} else {
+			err = OxError(1, "Type mismatch");
+		}
+	}
+	++m_fieldIt;
+	return err;
+}
+
+
+Error OrganicClawReader::field(const char *key, uint8_t *val) noexcept {
+	auto err = OxError(0);
+	if (targetValid()) {
+		const auto &jv = value(key);
+		if (jv.empty()) {
+			*val = 0;
+		} else if (jv.isUInt()) {
+			*val = static_cast<uint8_t>(jv.asUInt());
+		} else {
+			err = OxError(1, "Type mismatch");
+		}
+	}
+	++m_fieldIt;
+	return err;
+}
+
+Error OrganicClawReader::field(const char *key, uint16_t *val) noexcept {
+	auto err = OxError(0);
+	if (targetValid()) {
+		const auto &jv = value(key);
+		if (jv.empty()) {
+			*val = 0;
+		} else if (jv.isUInt()) {
+			*val = static_cast<uint16_t>(jv.asUInt());
+		} else {
+			err = OxError(1, "Type mismatch");
+		}
+	}
+	++m_fieldIt;
+	return err;
+}
+
+Error OrganicClawReader::field(const char *key, uint32_t *val) noexcept {
+	auto err = OxError(0);
+	if (targetValid()) {
+		const auto &jv = value(key);
+		if (jv.empty()) {
+			*val = 0;
+		} else if (jv.isUInt()) {
+			*val = static_cast<uint32_t>(jv.asUInt());
+		} else {
+			err = OxError(1, "Type mismatch");
+		}
+	}
+	++m_fieldIt;
+	return err;
+}
+
+Error OrganicClawReader::field(const char *key, uint64_t *val) noexcept {
+	auto err = OxError(0);
+	if (targetValid()) {
+		const auto &jv = value(key);
+		if (jv.empty()) {
+			*val = 0;
+		} else if (jv.isUInt() || jv.isUInt64()) {
+			*val = static_cast<uint64_t>(jv.asUInt64());
+		} else {
+			err = OxError(1, "Type mismatch");
+		}
+	}
+	++m_fieldIt;
+	return err;
+}
+
 Error OrganicClawReader::field(const char *key, bool *val) noexcept {
 	auto err = OxError(0);
 	if (targetValid()) {

deps/ox/src/ox/oc/read.hpp

@@ -41,6 +41,16 @@ class OrganicClawReader {
 
 		explicit OrganicClawReader(Json::Value json, int unionIdx = -1) noexcept;
 
+		Error field(const char *key, int8_t *val) noexcept;
+		Error field(const char *key, int16_t *val) noexcept;
+		Error field(const char *key, int32_t *val) noexcept;
+		Error field(const char *key, int64_t *val) noexcept;
+
+		Error field(const char *key, uint8_t *val) noexcept;
+		Error field(const char *key, uint16_t *val) noexcept;
+		Error field(const char *key, uint32_t *val) noexcept;
+		Error field(const char *key, uint64_t *val) noexcept;
+
 		Error field(const char *key, bool *val) noexcept;
 
 		// array handler
@@ -134,22 +144,7 @@ class OrganicClawReader {
 template<typename T>
 Error OrganicClawReader::field(const char *key, T *val) noexcept {
 	auto err = OxError(0);
-	try {
-		if constexpr (is_integer_v<T>) {
-			if (targetValid()) {
-				auto const&jv = value(key);
-				auto const rightType = sizeof(T) == 8 ?
-				                       (ox::is_signed_v<T> ? jv.isInt64() : jv.isUInt64()) :
-				                       (ox::is_signed_v<T> ? jv.isInt() : jv.isUInt());
-				if (jv.empty()) {
-					*val = 0;
-				} else if (rightType) {
-					*val = static_cast<T>(jv.asUInt());
-				} else {
-					err = OxError(1, "Type mismatch");
-				}
-			}
-		} else if constexpr (isVector_v<T>) {
+	if constexpr(isVector_v<T>) {
 		const auto &srcVal = value(key);
 		const auto srcSize = srcVal.size();
 		oxReturnError(ox::resizeVector(*val, srcSize));
@@ -172,9 +167,6 @@ Error OrganicClawReader::field(const char *key, T *val) noexcept {
 			err = OxError(1, "Type mismatch");
 		}
 	}
-	} catch (Json::LogicError const&) {
-		err = OxError(1, "error reading JSON data");
-	}
 	++m_fieldIt;
 	return err;
 }

deps/ox/src/ox/oc/write.hpp

@@ -209,17 +209,7 @@ Error OrganicClawWriter::field(const char *key, const T *val, std::size_t len) n
 
 template<typename T>
 Error OrganicClawWriter::field(const char *key, const T *val) noexcept {
-	if constexpr(is_integer_v<T>) {
-		if (targetValid() && (*val || m_json.isArray())) {
-			// the int type needs to be normalized because jsoncpp doesn't
-			// factor in every permutation unsigned long, etc.
-			if constexpr(ox::is_signed_v<T>) {
-				value(key) = static_cast<ox::Int<8 * sizeof(*val)>>(*val);
-			} else {
-				value(key) = static_cast<ox::Uint<8 * sizeof(*val)>>(*val);
-			}
-		}
-	} else if constexpr(isVector_v<T> || isArray_v<T>) {
+	if constexpr(isVector_v<T> || isArray_v<T>) {
 		return field(key, val->data(), val->size());
 	} else if (val && targetValid()) {
 		OrganicClawWriter w;

src/olympic/keel/include/keel/assetmanager.hpp

@@ -247,7 +247,10 @@ class AssetManager {
 		};
 
 		ox::HashMap<ox::String, ox::UPtr<AssetTypeManagerBase>> m_assetTypeManagers;
-		ox::HashMap<ox::String, ox::Signal<ox::Error(ox::StringView assetId)>> m_fileUpdated;
+		struct FileTracker {
+			ox::Signal<ox::Error(ox::StringView assetId)> updated;
+		};
+		ox::HashMap<ox::String, FileTracker> m_fileTrackers;
 
 		template<typename T>
 		ox::Result<AssetTypeManager<T>*> getTypeManager() noexcept {
@@ -279,7 +282,7 @@ class AssetManager {
 		}
 
 		ox::Error reloadAsset(ox::StringView assetId) noexcept {
-			m_fileUpdated[assetId].emit(assetId);
+			m_fileTrackers[assetId].updated.emit(assetId);
 			return {};
 		}
 
@@ -287,7 +290,7 @@ class AssetManager {
 		ox::Result<AssetRef<T>> loadAsset(ox::StringView assetId) noexcept {
 			oxRequire(m, getTypeManager<T>());
 			oxRequire(out, m->loadAsset(assetId));
-			m_fileUpdated[assetId].connect(m, &AssetTypeManager<T>::reloadAsset);
+			m_fileTrackers[assetId].updated.connect(m, &AssetTypeManager<T>::reloadAsset);
 			return out;
 		}