ipc: Allow all trivially copyable objects to be passed directly into WriteBuffer (#4465)

* ipc: Allow all trivially copyable objects to be passed directly into WriteBuffer

With the support of C++20, we can use concepts to deduce if a type is an STL container or not.

* More agressive concept for stl containers

* Add -fconcepts

* Move to common namespace

* Add Common::IsBaseOf

1 files changed, 16 insertions, 14 deletions

diff --git a/src/core/hle/kernel/hle_ipc.h b/src/core/hle/kernel/hle_ipc.h
index b31673928..f3277b766 100644
--- a/src/core/hle/kernel/hle_ipc.h
+++ b/src/core/hle/kernel/hle_ipc.h
@@ -13,6 +13,7 @@
 #include <vector>
 #include <boost/container/small_vector.hpp>
 #include "common/common_types.h"
+#include "common/concepts.h"
 #include "common/swap.h"
 #include "core/hle/ipc.h"
 #include "core/hle/kernel/object.h"
@@ -193,23 +194,24 @@ public:
 
     /* Helper function to write a buffer using the appropriate buffer descriptor
      *
-     * @tparam ContiguousContainer an arbitrary container that satisfies the
-     *         ContiguousContainer concept in the C++ standard library.
+     * @tparam T an arbitrary container that satisfies the
+     *         ContiguousContainer concept in the C++ standard library or a trivially copyable type.
      *
-     * @param container    The container to write the data of into a buffer.
+     * @param data         The container/data to write into a buffer.
      * @param buffer_index The buffer in particular to write to.
      */
-    template <typename ContiguousContainer,
-              typename = std::enable_if_t<!std::is_pointer_v<ContiguousContainer>>>
-    std::size_t WriteBuffer(const ContiguousContainer& container,
-                            std::size_t buffer_index = 0) const {
-        using ContiguousType = typename ContiguousContainer::value_type;
-
-        static_assert(std::is_trivially_copyable_v<ContiguousType>,
-                      "Container to WriteBuffer must contain trivially copyable objects");
-
-        return WriteBuffer(std::data(container), std::size(container) * sizeof(ContiguousType),
-                           buffer_index);
+    template <typename T, typename = std::enable_if_t<!std::is_pointer_v<T>>>
+    std::size_t WriteBuffer(const T& data, std::size_t buffer_index = 0) const {
+        if constexpr (Common::IsSTLContainer<T>) {
+            using ContiguousType = typename T::value_type;
+            static_assert(std::is_trivially_copyable_v<ContiguousType>,
+                          "Container to WriteBuffer must contain trivially copyable objects");
+            return WriteBuffer(std::data(data), std::size(data) * sizeof(ContiguousType),
+                               buffer_index);
+        } else {
+            static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable");
+            return WriteBuffer(&data, sizeof(T), buffer_index);
+        }
     }
 
     /// Helper function to get the size of the input buffer