Switch to in and out parameters in TypeConversion

In preparation for converting reading mpv_node data.

diff --git a/backendplugins/backend_mpv/mpvhelper.h b/backendplugins/backend_mpv/mpvhelper.h
index 18754007d5b5023583755d2ad9086c9e8c8828bd..e54f916f8b4da1cbc4fa5cc5209cd91bffc22a58 100644 (file)
--- 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));
       }
     }