Remove variant from public interface of Memory.hpp

This should fix the Cuda issues.
Will not yet work with ADIOS2

Author: franzpoeschel

include/openPMD/auxiliary/Memory.hpp

@@ -24,6 +24,7 @@
 #include "openPMD/Datatype.hpp"
 #include "openPMD/auxiliary/UniquePtr.hpp"
 
+#include <any>
 #include <complex>
 #include <functional>
 #include <iostream>
@@ -48,30 +49,40 @@ namespace auxiliary
      */
     struct WriteBuffer
     {
-        using EligibleTypes = std::
-            variant<std::shared_ptr<void const>, UniquePtrWithLambda<void>>;
-        EligibleTypes m_buffer;
+        using UniquePtr = std::shared_ptr<UniquePtrWithLambda<void>>;
+        using SharedPtr = std::shared_ptr<void const>;
+        std::any m_buffer;
 
         WriteBuffer();
 
-        template <typename... Args>
-        explicit WriteBuffer(Args &&...args)
-            : m_buffer(std::forward<Args>(args)...)
-        {}
+        WriteBuffer(std::shared_ptr<void const> ptr);
+        // WriteBuffer(std::shared_ptr<void> const &ptr);
 
-        WriteBuffer(WriteBuffer &&) noexcept(
-            noexcept(EligibleTypes(std::declval<EligibleTypes &&>())));
+        WriteBuffer(UniquePtrWithLambda<void> ptr);
+
+        WriteBuffer(WriteBuffer &&) noexcept;
         WriteBuffer(WriteBuffer const &) = delete;
-        WriteBuffer &operator=(WriteBuffer &&) noexcept(noexcept(
-            std::declval<EligibleTypes &>() =
-                std::declval<EligibleTypes &&>()));
+        WriteBuffer &operator=(WriteBuffer &&) noexcept;
         WriteBuffer &operator=(WriteBuffer const &) = delete;
 
         WriteBuffer const &operator=(std::shared_ptr<void const> ptr);
+        // WriteBuffer const &operator=(std::shared_ptr<void> const &ptr);
 
-        WriteBuffer const &operator=(UniquePtrWithLambda<void const> ptr);
+        WriteBuffer const &operator=(UniquePtrWithLambda<void> ptr);
 
         void const *get() const;
+
+        template <typename variant_t>
+        auto as_variant() -> variant_t &
+        {
+            return *std::any_cast<variant_t>(&m_buffer);
+        }
+
+        template <typename variant_t>
+        auto as_variant() const -> variant_t const &
+        {
+            return *std::any_cast<variant_t>(&m_buffer);
+        }
     };
 } // namespace auxiliary
 } // namespace openPMD

include/openPMD/auxiliary/Memory_internal.hpp

@@ -0,0 +1,32 @@
+/* Copyright 2017-2021 Fabian Koller
+ *
+ * This file is part of openPMD-api.
+ *
+ * openPMD-api is free software: you can redistribute it and/or modify
+ * it under the terms of of either the GNU General Public License or
+ * the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * openPMD-api is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License and the GNU Lesser General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * and the GNU Lesser General Public License along with openPMD-api.
+ * If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+
+#include "openPMD/auxiliary/Memory.hpp"
+#include "openPMD/auxiliary/UniquePtr.hpp"
+#include <memory>
+
+namespace openPMD::auxiliary
+{
+// cannot use a unique_ptr inside a std::variant, so we represent it with this
+using WriteBufferTypes =
+    std::variant<WriteBuffer::UniquePtr, WriteBuffer::SharedPtr>;
+} // namespace openPMD::auxiliary

src/auxiliary/Memory.cpp

@@ -20,7 +20,11 @@
  */
 
 #include "openPMD/auxiliary/Memory.hpp"
+#include "openPMD/ChunkInfo.hpp"
+#include "openPMD/auxiliary/Memory_internal.hpp"
+#include "openPMD/auxiliary/UniquePtr.hpp"
 
+#include <any>
 #include <complex>
 #include <functional>
 #include <iostream>
@@ -157,24 +161,40 @@ allocatePtr(Datatype dtype, Extent const &e)
     return allocatePtr(dtype, numPoints);
 }
 
-WriteBuffer::WriteBuffer() : m_buffer(UniquePtrWithLambda<void>())
+WriteBuffer::WriteBuffer() : m_buffer(std::make_any<UniquePtr>())
 {}
 
-WriteBuffer::WriteBuffer(WriteBuffer &&) noexcept(
-    noexcept(EligibleTypes(std::declval<EligibleTypes &&>()))) = default;
-WriteBuffer &WriteBuffer::operator=(WriteBuffer &&) noexcept(noexcept(
-    std::declval<EligibleTypes &>() = std::declval<EligibleTypes &&>())) =
-    default;
+WriteBuffer::WriteBuffer(std::shared_ptr<void const> ptr)
+    : m_buffer(std::make_any<WriteBufferTypes>(std::move(ptr)))
+{}
+// WriteBuffer::WriteBuffer(std::shared_ptr<void> const &ptr)
+//     : WriteBuffer{std::static_pointer_cast<void const>(ptr)}
+// {}
+
+WriteBuffer::WriteBuffer(UniquePtrWithLambda<void> ptr)
+    : m_buffer(
+          std::make_any<WriteBufferTypes>(
+              std::make_shared<UniquePtrWithLambda<void>>(std::move(ptr))))
+{}
+
+WriteBuffer::WriteBuffer(WriteBuffer &&) noexcept = default;
+WriteBuffer &WriteBuffer::operator=(WriteBuffer &&) noexcept = default;
 
 WriteBuffer const &WriteBuffer::operator=(std::shared_ptr<void const> ptr)
 {
-    m_buffer = std::move(ptr);
+    m_buffer = std::make_any<WriteBufferTypes>(std::move(ptr));
     return *this;
 }
+// WriteBuffer const &WriteBuffer::operator=(std::shared_ptr<void> const &ptr)
+// {
+//     operator=(std::static_pointer_cast<void const>(ptr));
+//     return *this;
+// }
 
-WriteBuffer const &WriteBuffer::operator=(UniquePtrWithLambda<void const> ptr)
+WriteBuffer const &WriteBuffer::operator=(UniquePtrWithLambda<void> ptr)
 {
-    m_buffer = std::move(ptr);
+    m_buffer = std::make_any<WriteBufferTypes>(
+        std::make_shared<UniquePtrWithLambda<void>>(std::move(ptr)));
     return *this;
 }
 
@@ -186,6 +206,6 @@ void const *WriteBuffer::get() const
             // we're being sneaky and don't distinguish the types here
             return static_cast<void const *>(arg.get());
         },
-        m_buffer);
+        as_variant<WriteBufferTypes>());
 }
 } // namespace openPMD::auxiliary