Rename MovableUniquePtr --> CopyableUniquePtr

Author: franzpoeschel

include/openPMD/auxiliary/Memory.hpp

@@ -48,18 +48,18 @@ namespace auxiliary
     {
         /*
          * Sic. Have to put the unique_ptr behind a shared_ptr because
-         * std::variant does not want immovable types.
+         * std::variant does not want non-copyable types.
          * Use a separate class to avoid mistakes in double dereference.
          */
-        struct MovableUniquePtr
+        struct CopyableUniquePtr
             : private std::shared_ptr<UniquePtrWithLambda<void>>
         {
         private:
             using parent_t = std::shared_ptr<UniquePtrWithLambda<void>>;
 
         public:
-            MovableUniquePtr();
-            MovableUniquePtr(UniquePtrWithLambda<void> ptr_in);
+            CopyableUniquePtr();
+            CopyableUniquePtr(UniquePtrWithLambda<void> ptr_in);
             auto get() -> void *;
             [[nodiscard]] auto get() const -> void const *;
             [[nodiscard]] auto release() -> UniquePtrWithLambda<void>;

include/openPMD/auxiliary/Memory_internal.hpp

@@ -26,5 +26,5 @@ namespace openPMD::auxiliary
 {
 // cannot use a unique_ptr inside a std::variant, so we represent it with this
 using WriteBufferTypes =
-    std::variant<WriteBuffer::MovableUniquePtr, WriteBuffer::SharedPtr>;
+    std::variant<WriteBuffer::CopyableUniquePtr, WriteBuffer::SharedPtr>;
 } // namespace openPMD::auxiliary

src/IO/ADIOS/ADIOS2File.cpp

@@ -116,7 +116,7 @@ void WriteDataset::call(ADIOS2File &ba, detail::BufferedPut &bp)
             }
             else if constexpr (std::is_same_v<
                                    ptr_type,
-                                   auxiliary::WriteBuffer::MovableUniquePtr>)
+                                   auxiliary::WriteBuffer::CopyableUniquePtr>)
             {
                 BufferedUniquePtrPut bput;
                 bput.name = std::move(bp.name);

src/auxiliary/Memory.cpp

@@ -161,24 +161,24 @@ allocatePtr(Datatype dtype, Extent const &e)
     return allocatePtr(dtype, numPoints);
 }
 
-WriteBuffer::MovableUniquePtr::MovableUniquePtr() = default;
+WriteBuffer::CopyableUniquePtr::CopyableUniquePtr() = default;
 
-WriteBuffer::MovableUniquePtr::MovableUniquePtr(
+WriteBuffer::CopyableUniquePtr::CopyableUniquePtr(
     UniquePtrWithLambda<void> ptr_in)
     : parent_t{std::make_shared<UniquePtrWithLambda<void>>(std::move(ptr_in))}
 {}
 
-auto WriteBuffer::MovableUniquePtr::get() -> void *
+auto WriteBuffer::CopyableUniquePtr::get() -> void *
 {
     return (**this).get();
 }
 
-auto WriteBuffer::MovableUniquePtr::get() const -> void const *
+auto WriteBuffer::CopyableUniquePtr::get() const -> void const *
 {
     return (**this).get();
 }
 
-auto WriteBuffer::MovableUniquePtr::release() -> UniquePtrWithLambda<void>
+auto WriteBuffer::CopyableUniquePtr::release() -> UniquePtrWithLambda<void>
 {
     if (parent_t::use_count() > 1)
     {
@@ -191,14 +191,14 @@ auto WriteBuffer::MovableUniquePtr::release() -> UniquePtrWithLambda<void>
     return res;
 }
 
-WriteBuffer::WriteBuffer() : m_buffer(std::make_any<MovableUniquePtr>())
+WriteBuffer::WriteBuffer() : m_buffer(std::make_any<CopyableUniquePtr>())
 {}
 WriteBuffer::WriteBuffer(std::shared_ptr<void const> ptr)
     : m_buffer(std::make_any<WriteBufferTypes>(std::move(ptr)))
 {}
 WriteBuffer::WriteBuffer(UniquePtrWithLambda<void> ptr)
     : m_buffer(
-          std::make_any<WriteBufferTypes>(MovableUniquePtr(std::move(ptr))))
+          std::make_any<WriteBufferTypes>(CopyableUniquePtr(std::move(ptr))))
 {}
 
 WriteBuffer::WriteBuffer(WriteBuffer &&) noexcept = default;
@@ -212,7 +212,7 @@ WriteBuffer const &WriteBuffer::operator=(std::shared_ptr<void const> ptr)
 WriteBuffer const &WriteBuffer::operator=(UniquePtrWithLambda<void> ptr)
 {
     m_buffer =
-        std::make_any<WriteBufferTypes>(MovableUniquePtr(std::move(ptr)));
+        std::make_any<WriteBufferTypes>(CopyableUniquePtr(std::move(ptr)));
     return *this;
 }