deps/ox/src/ox/model/typenamecatcher.hpp

@@ -140,16 +140,16 @@ constexpr Str getModelTypeName() noexcept {
 	return out;
 }
 
-template<typename T, typename Str = const char*>
+template<typename T>
 [[nodiscard]]
 consteval auto requireModelTypeName() noexcept {
-	constexpr auto name = getModelTypeName<T, Str>();
+	constexpr auto name = getModelTypeName<T>();
 	static_assert(ox::StringView{name}.len(), "Type lacks required TypeName");
 	return name;
 }
 
 template<typename T, typename Str = const char*>
-constexpr auto ModelTypeName_v = requireModelTypeName<T, Str>();
+constexpr auto ModelTypeName_v = getModelTypeName<T, Str>();
 
 template<typename T, typename Str = const char*>
 constexpr auto ModelTypeVersion_v = requireModelTypeVersion<T>();

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

@@ -67,7 +67,7 @@ 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::StringViewCR typeId) -> ox::Result<bool> {
+				[](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> ||
@@ -78,7 +78,7 @@ static class: public keel::Module {
 					}
 					return false;
 				},
-				[](keel::Context &ctx, ox::Buffer &buff, ox::StringViewCR typeId) -> ox::Result<bool> {
+				[](keel::Context &ctx, ox::Buffer &buff, ox::StringView typeId) -> ox::Result<bool> {
 					if (typeId == ox::ModelTypeId_v<NostalgiaPalette> ||
 					    typeId == ox::ModelTypeId_v<PaletteV1> ||
 					    typeId == ox::ModelTypeId_v<PaletteV2> ||

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

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

src/olympic/keel/include/keel/media.hpp

@@ -70,7 +70,7 @@ constexpr auto makeLoader(Context &ctx) {
 			if (err != ox::Error_ClawTypeVersionMismatch && err != ox::Error_ClawTypeMismatch) {
 				return err;
 			}
-			OX_RETURN_ERROR(convert<T>(ctx, buff, obj));
+			OX_RETURN_ERROR(convert<T>(ctx, buff, &obj));
 		}
 		return std::move(obj);
 	};

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

@@ -16,43 +16,10 @@ namespace keel {
 class Wrap {
 	public:
 		virtual ~Wrap() = default;
-		[[nodiscard]]
-		virtual ox::CStringView typeName() const noexcept = 0;
-		[[nodiscard]]
-		virtual int typeVersion() const noexcept = 0;
 };
 
 template<typename T>
-class WrapT: public Wrap {
+class WrapInline: public Wrap {
-	public:
-		[[nodiscard]]
-		virtual constexpr T &obj() noexcept = 0;
-};
-
-template<typename T>
-class WrapRef final: public WrapT<T> {
-	private:
-		T &m_obj;
-
-	public:
-		constexpr explicit WrapRef(T &obj): m_obj{obj} {}
-
-		ox::CStringView typeName() const noexcept override {
-			return ox::ModelTypeName_v<T>;
-		}
-
-		int typeVersion() const noexcept override {
-			return ox::ModelTypeVersion_v<T>;
-		}
-
-		constexpr T &obj() noexcept override {
-			return m_obj;
-		}
-
-};
-
-template<typename T>
-class WrapInline final: public WrapT<T> {
 	private:
 		T m_obj;
 
@@ -63,15 +30,8 @@ class WrapInline final: public WrapT<T> {
 		constexpr explicit WrapInline(Args &&...args): m_obj(ox::forward<Args>(args)...) {
 		}
 
-		ox::CStringView typeName() const noexcept override {
+		[[nodiscard]]
-			return ox::ModelTypeName_v<T>;
+		constexpr T &obj() noexcept {
-		}
-
-		int typeVersion() const noexcept override {
-			return ox::ModelTypeVersion_v<T>;
-		}
-
-		constexpr T &obj() noexcept override {
 			return m_obj;
 		}
 
@@ -84,7 +44,7 @@ constexpr ox::UPtr<Wrap> makeWrap(Args &&...args) noexcept {
 
 template<typename T>
 constexpr T &wrapCast(Wrap &ptr) noexcept {
-	return static_cast<WrapT<T>&>(ptr).obj();
+	return static_cast<WrapInline<T>&>(ptr).obj();
 }
 
 class BaseConverter {
@@ -110,10 +70,10 @@ class BaseConverter {
 
 		[[nodiscard]]
 		constexpr bool matches(
-				ox::StringViewCR srcTypeName, int const srcTypeVersion,
+				ox::StringViewCR srcTypeName, int srcTypeVersion,
-				ox::StringViewCR dstTypeName, int const dstTypeVersion) const noexcept {
+				ox::StringViewCR dstTypeName, int dstTypeVersion) const noexcept {
 			return srcMatches(srcTypeName, srcTypeVersion)
-			    && dstMatches(dstTypeName, dstTypeVersion);
+				 && dstMatches(dstTypeName, dstTypeVersion);
 		}
 
 };
@@ -149,17 +109,17 @@ class Converter: public BaseConverter {
 
 		ox::Result<ox::UPtr<Wrap>> convertPtrToPtr(
 				keel::Context &ctx, Wrap &src) const noexcept final {
-			ox::Result<ox::UPtr<Wrap>> dst{makeWrap<DstType>()};
+			auto dst = makeWrap<DstType>();
-			OX_RETURN_ERROR(convert(ctx, wrapCast<SrcType>(src), wrapCast<DstType>(*dst.value)));
+			OX_RETURN_ERROR(convert(ctx, wrapCast<SrcType>(src), wrapCast<DstType>(*dst)));
-			return dst;
+			return {std::move(dst)};
 		}
 
 		ox::Result<ox::UPtr<Wrap>> convertBuffToPtr(
 				keel::Context &ctx, ox::BufferView const&srcBuff) const noexcept final {
 			OX_REQUIRE_M(src, readAsset<SrcType>(srcBuff));
-			ox::Result<ox::UPtr<Wrap>> dst{makeWrap<DstType>()};
+			auto dst = makeWrap<DstType>();
-			OX_RETURN_ERROR(convert(ctx, src, wrapCast<DstType>(*dst.value)));
+			OX_RETURN_ERROR(convert(ctx, src, wrapCast<DstType>(*dst)));
-			return dst;
+			return {std::move(dst)};
 		}
 
 	protected:
@@ -173,57 +133,34 @@ ox::Result<ox::UPtr<Wrap>> convert(
 		ox::StringViewCR dstTypeName,
 		int dstTypeVersion) noexcept;
 
-ox::Result<ox::UPtr<Wrap>> convert(
-		keel::Context &ctx,
-		Wrap &src,
-		ox::StringViewCR dstTypeName,
-		int dstTypeVersion) noexcept;
-
-ox::Result<ox::UPtr<Wrap>> convert(
-		keel::Context &ctx,
-		auto &src,
-		ox::StringViewCR dstTypeName,
-		int const dstTypeVersion) noexcept {
-	return convert(ctx, WrapRef{src}, dstTypeName, dstTypeVersion);
-}
-
 template<typename DstType>
-ox::Result<DstType> convertObjToObj(
+ox::Result<DstType> convert(keel::Context &ctx, ox::BufferView const&srcBuffer) noexcept {
-		keel::Context &ctx,
+	static constexpr auto DstTypeName = ox::requireModelTypeName<DstType>();
-		auto &src) noexcept {
+	static constexpr auto DstTypeVersion = ox::requireModelTypeVersion<DstType>();
-	OX_REQUIRE_M(out, convert(ctx, WrapRef{src}, ox::ModelTypeName_v<DstType>, ox::ModelTypeVersion_v<DstType>));
+	OX_REQUIRE(out, convert(ctx, srcBuffer, DstTypeName, DstTypeVersion));
-	return std::move(wrapCast(*out));
-}
-
-template<typename DstType>
-ox::Result<DstType> convert(keel::Context &ctx, ox::BufferView const&src) noexcept {
-	OX_REQUIRE(out, convert(ctx, src, ox::ModelTypeName_v<DstType>, ox::ModelTypeVersion_v<DstType>));
 	return std::move(wrapCast<DstType>(out));
 }
 
 template<typename DstType>
-ox::Error convert(keel::Context &ctx, ox::BufferView const&buff, DstType &outObj) noexcept {
+ox::Error convert(keel::Context &ctx, ox::BufferView const&buff, DstType *outObj) noexcept {
-	OX_REQUIRE(out, convert(ctx, buff, ox::ModelTypeName_v<DstType>, ox::ModelTypeVersion_v<DstType>));
+	static constexpr auto DstTypeName = ox::requireModelTypeName<DstType>();
-	outObj = std::move(wrapCast<DstType>(*out));
+	static constexpr auto DstTypeVersion = ox::requireModelTypeVersion<DstType>();
-	return {};
+	OX_REQUIRE(outPtr, convert(ctx, buff, DstTypeName, DstTypeVersion));
-}
+	*outObj = std::move(wrapCast<DstType>(*outPtr));
-
-template<typename DstType>
-ox::Error convertObjToObj(keel::Context &ctx, auto &src, DstType &outObj) noexcept {
-	OX_REQUIRE(outPtr, convert(ctx, src, ox::ModelTypeName_v<DstType>, ox::ModelTypeVersion_v<DstType>));
-	outObj = std::move(wrapCast<DstType>(*outPtr));
 	return {};
 }
 
 template<typename DstType>
 ox::Result<ox::Buffer> convertBuffToBuff(
-		keel::Context &ctx, ox::BufferView const&src, ox::ClawFormat const fmt) noexcept {
+		keel::Context &ctx, ox::BufferView const&srcBuffer, ox::ClawFormat fmt) noexcept {
-	OX_REQUIRE(out, convert(ctx, src, ox::ModelTypeName_v<DstType>, ox::ModelTypeVersion_v<DstType>));
+	static constexpr auto DstTypeName = ox::requireModelTypeName<DstType>();
+	static constexpr auto DstTypeVersion = ox::requireModelTypeVersion<DstType>();
+	OX_REQUIRE(out, convert(ctx, srcBuffer, DstTypeName, DstTypeVersion));
 	return ox::writeClaw<DstType>(wrapCast<DstType>(*out), fmt);
 }
 
 template<typename From, typename To, ox::ClawFormat fmt = ox::ClawFormat::Metal>
-ox::Result<bool> transformRule(keel::Context &ctx, ox::Buffer &buff, ox::StringViewCR typeId) noexcept {
+ox::Result<bool> transformRule(keel::Context &ctx, ox::Buffer &buff, ox::StringView typeId) noexcept {
 	if (typeId == ox::ModelTypeId_v<From>) {
 		OX_RETURN_ERROR(keel::convertBuffToBuff<To>(ctx, buff, fmt).moveTo(buff));
 		return true;
@@ -231,4 +168,5 @@ ox::Result<bool> transformRule(keel::Context &ctx, ox::Buffer &buff, ox::StringV
 	return false;
 };
 
+
 }

src/olympic/keel/src/typeconv.cpp

@@ -10,38 +10,30 @@ namespace keel {
 static ox::Result<BaseConverter const*> findConverter(
 		ox::SpanView<BaseConverter const*> const&converters,
 		ox::StringViewCR srcTypeName,
-		int const srcTypeVersion,
+		int srcTypeVersion,
 		ox::StringViewCR dstTypeName,
-		int const dstTypeVersion) noexcept {
+		int dstTypeVersion) noexcept {
 	for (auto const&c : converters) {
 		if (c->matches(srcTypeName, srcTypeVersion, dstTypeName, dstTypeVersion)) {
 			return c;
 		}
 	}
-	return ox::Error{1, "Could not find converter"};
+	return ox::Error(1, "Could not find converter");
 };
 
-static ox::Result<ox::UPtr<Wrap>> convert(BaseConverter const&c, Context &ctx, ox::BufferView const&src) noexcept {
-	return c.convertBuffToPtr(ctx, src);
-}
-
-static ox::Result<ox::UPtr<Wrap>> convert(BaseConverter const&c, Context &ctx, Wrap &src) noexcept {
-	return c.convertPtrToPtr(ctx, src);
-}
-
 static ox::Result<ox::UPtr<Wrap>> convert(
-		Context &ctx,
+		keel::Context &ctx,
 		ox::SpanView<BaseConverter const*> const&converters,
-		auto &src,
+		ox::BufferView const&srcBuffer,
 		ox::StringViewCR srcTypeName,
-		int const srcTypeVersion,
+		int srcTypeVersion,
 		ox::StringViewCR dstTypeName,
-		int const dstTypeVersion) noexcept {
+		int dstTypeVersion) noexcept {
 	// look for direct converter
-	auto const [c, err] = findConverter(
+	auto [c, err] = findConverter(
 			converters, srcTypeName, srcTypeVersion, dstTypeName, dstTypeVersion);
 	if (!err) {
-		return convert(*c, ctx, src);
+		return c->convertBuffToPtr(ctx, srcBuffer);
 	}
 	// try to chain multiple converters
 	for (auto const&subConverter : converters) {
@@ -49,20 +41,20 @@ static ox::Result<ox::UPtr<Wrap>> convert(
 			continue;
 		}
 		const auto [intermediate, chainErr] =
-			convert(ctx, converters, src, srcTypeName, srcTypeVersion,
+			convert(ctx, converters, srcBuffer, srcTypeName, srcTypeVersion,
 			        subConverter->srcTypeName(), subConverter->srcTypeVersion());
 		if (!chainErr) {
 			return subConverter->convertPtrToPtr(ctx, *intermediate);
 		}
 	}
-	return ox::Error{1, "Could not convert between types"};
+	return ox::Error(1, "Could not convert between types");
 }
 
 ox::Result<ox::UPtr<Wrap>> convert(
-		Context &ctx,
+		keel::Context &ctx,
 		ox::BufferView const&srcBuffer,
 		ox::StringViewCR dstTypeName,
-		int const dstTypeVersion) noexcept {
+		int dstTypeVersion) noexcept {
 	OX_REQUIRE(hdr, readAssetHeader(srcBuffer));
 	return convert(
 			ctx,
@@ -74,19 +66,4 @@ ox::Result<ox::UPtr<Wrap>> convert(
 			dstTypeVersion);
 }
 
-ox::Result<ox::UPtr<Wrap>> convert(
-		Context &ctx,
-		Wrap &src,
-		ox::StringViewCR dstTypeName,
-		int const dstTypeVersion) noexcept {
-	return convert(
-			ctx,
-			converters(ctx),
-			src,
-			src.typeName(),
-			src.typeVersion(),
-			dstTypeName,
-			dstTypeVersion);
-}
-
 }