From 9adf5a3add53129d005f7dc5fb259b8447010c73 Mon Sep 17 00:00:00 2001
From: APTX <marek321@gmail.com>
Date: Sun, 20 Feb 2022 21:11:32 +0900
Subject: [PATCH] Switch to in and out parameters in TypeConversion

In preparation for converting reading mpv_node data.
---
 backendplugins/backend_mpv/mpvhelper.h | 35 +++++++++++++++-----------
 1 file changed, 20 insertions(+), 15 deletions(-)

diff --git a/backendplugins/backend_mpv/mpvhelper.h b/backendplugins/backend_mpv/mpvhelper.h
index 1875400..e54f916 100644
--- a/backendplugins/backend_mpv/mpvhelper.h
+++ b/backendplugins/backend_mpv/mpvhelper.h
@@ -136,41 +136,43 @@ struct TypeConversion
   static_assert(std::is_convertible_v<From, To>,
                 "Default type conversion not possible, new TypeConversion "
                 "specialization required");
-  static To convert(const From &from) { return To{from}; }
+  static void convert(const From &from, To &to) { to = std::move(To{from}); }
 };
 
 template<typename T>
 struct TypeConversion<T, T>
 {
-  static const T &convert(const T &from) { return from; }
+  static void convert(const T &from, T &to) { to = from; }
 };
 
 template<>
 struct TypeConversion<QString, const char *>
 {
-  static const char *convert(const QString &from) {
-    return qUtf8Printable(from);
+  static void convert(const QString &from, const char *&to) {
+    to = qUtf8Printable(from);
   }
 };
 
 template<>
 struct TypeConversion<const char *, QString>
 {
-  static QString convert(const char *from) { return QString::fromUtf8(from); }
+  static void convert(const char *from, QString &to) {
+    to = std::move(QString::fromUtf8(from));
+  }
 };
 
 // Avoids narrwoing conversion warnings
 template<>
 struct TypeConversion<int, bool>
 {
-  static bool convert(const int &from) { return from != 0; }
+  static void convert(const int &from, bool &to) { to = (from != 0); }
 };
 
 template<>
 struct TypeConversion<mpv_node, QVariant>
 {
-  static QVariant convert(const mpv_node &from) {
-    return qt::node_to_variant(&from);
+  static void convert(const mpv_node &from, QVariant &to) {
+    to = mpv::qt::node_to_variant(&from);
   }
 };
 
@@ -185,16 +187,18 @@ auto ReadFormat(const Handle &handle, Format format, const char *name)
   if (error != MPV_ERROR_SUCCESS) {
     return Error{error};
   }
-  return TypeConversion<typename Format::MpvInternalType,
-                        typename Format::type>::convert(data);
+  typename Format::type ret;
+  TypeConversion<typename Format::MpvInternalType,
+                 typename Format::type>::convert(data, ret);
+  return ret;
 }
 
 template<typename Format>
 int WriteFormat(const Handle &handle, Format format, const char *name,
                 const typename Format::type &value) {
-  const auto &data =
-      TypeConversion<typename Format::type,
-                     typename Format::MpvInternalType>::convert(value);
+  typename Format::MpvInternalType data;
+  TypeConversion<typename Format::type,
+                 typename Format::MpvInternalType>::convert(value, data);
   int error =
       mpv_set_property(handle.get(), name, format.format,
                        const_cast<typename Format::MpvInternalType *>(&data));
@@ -302,9 +306,10 @@ class EventHandler {
         const auto &mpvData = *static_cast<
             typename decltype(Property::format)::MpvInternalType *>(
             event->data);
-        auto data = detail::TypeConversion<
+        typename decltype(Property::format)::type data;
+        detail::TypeConversion<
             typename decltype(Property::format)::MpvInternalType,
-            typename decltype(Property::format)::type>::convert(mpvData);
+            typename decltype(Property::format)::type>::convert(mpvData, data);
         (obj->*m_callback)(std::move(data));
       }
     }
-- 
2.52.0