Revert to design without dynamic_casting again

Author: franzpoeschel

include/openPMD/Iteration.hpp

@@ -244,14 +244,23 @@ class Iteration : public Attributable
 private:
     Iteration();
 
-    inline internal::IterationData const &get() const
+    using Data_t = internal::IterationData;
+    std::shared_ptr<Data_t> m_iterationData;
+
+    inline Data_t const &get() const
+    {
+        return *m_iterationData;
+    }
+
+    inline Data_t &get()
     {
-        return dynamic_cast<internal::IterationData const &>(*m_attri);
+        return *m_iterationData;
     }
 
-    inline internal::IterationData &get()
+    inline void setData(std::shared_ptr<Data_t> data)
     {
-        return dynamic_cast<internal::IterationData &>(*m_attri);
+        m_iterationData = std::move(data);
+        Attributable::setData(m_iterationData);
     }
 
     void flushFileBased(

include/openPMD/RecordComponent.hpp

@@ -434,18 +434,24 @@ OPENPMD_protected
     // clang-format on
 
     using Data_t = internal::RecordComponentData;
+    std::shared_ptr<Data_t> m_recordComponentData;
 
     RecordComponent();
 
     inline Data_t const &get() const
     {
-        return dynamic_cast<Data_t const &>(*m_attri);
+        return *m_recordComponentData;
     }
 
     inline Data_t &get()
     {
-        auto &res = dynamic_cast<Data_t &>(*m_attri);
-        return res;
+        return *m_recordComponentData;
+    }
+
+    inline void setData(std::shared_ptr<internal::RecordComponentData> data)
+    {
+        m_recordComponentData = std::move(data);
+        BaseRecordComponent::setData(m_recordComponentData);
     }
 
     void readBase();

include/openPMD/Series.hpp

@@ -534,11 +534,14 @@ OPENPMD_private
     using iterations_t = decltype(internal::SeriesData::iterations);
     using iterations_iterator = iterations_t::iterator;
 
-    inline internal::SeriesData &get()
+    using Data_t = internal::SeriesData;
+    std::shared_ptr<Data_t> m_series = nullptr;
+
+    inline Data_t &get()
     {
-        if (m_attri)
+        if (m_series)
         {
-            return dynamic_cast<internal::SeriesData &>(*m_attri);
+            return *m_series;
         }
         else
         {
@@ -547,11 +550,11 @@ OPENPMD_private
         }
     }
 
-    inline internal::SeriesData const &get() const
+    inline Data_t const &get() const
     {
-        if (m_attri)
+        if (m_series)
         {
-            return dynamic_cast<internal::SeriesData const &>(*m_attri);
+            return *m_series;
         }
         else
         {
@@ -562,8 +565,9 @@ OPENPMD_private
 
     inline void setData(std::shared_ptr<internal::SeriesData> series)
     {
-        iterations = series->iterations;
-        Attributable::setData(std::move(series));
+        m_series = std::move(series);
+        iterations = m_series->iterations;
+        Attributable::setData(m_series);
     }
 
     std::unique_ptr<ParsedInput> parseInput(std::string);

include/openPMD/backend/Attributable.hpp

@@ -111,11 +111,16 @@ class Attributable
     friend class WriteIterations;
 
 protected:
-    std::shared_ptr<internal::AttributableData> m_attri{
-        new internal::AttributableData()};
+    // tag for internal constructor
+    struct NoInit
+    {};
+
+    using Data_t = internal::AttributableData;
+    std::shared_ptr<Data_t> m_attri;
 
 public:
     Attributable();
+    Attributable(NoInit);
 
     virtual ~Attributable() = default;
 
@@ -353,11 +358,9 @@ OPENPMD_protected
         return m_attri->m_writable;
     }
 
-    template <typename T = internal::AttributableData>
-    inline void setData(std::shared_ptr<T> attri)
+    inline void setData(std::shared_ptr<internal::AttributableData> attri)
     {
-        m_attri = std::static_pointer_cast<internal::AttributableData>(
-            std::move(attri));
+        m_attri = std::move(attri);
     }
 
     inline internal::AttributableData &get()

include/openPMD/backend/BaseRecord.hpp

@@ -64,20 +64,27 @@ class BaseRecord : public Container<T_elem>
     friend class Mesh;
 
     using Data_t = internal::BaseRecordData<T_elem>;
-    std::shared_ptr<Data_t> m_baseRecordData{new Data_t()};
+    std::shared_ptr<Data_t> m_baseRecordData;
 
     inline Data_t const &get() const
     {
-        return dynamic_cast<Data_t const &>(*this->m_attri);
+        return *m_baseRecordData;
     }
 
     inline Data_t &get()
     {
-        return dynamic_cast<Data_t &>(*this->m_attri);
+        return *m_baseRecordData;
     }
 
     BaseRecord();
 
+protected:
+    inline void setData(std::shared_ptr<Data_t> data)
+    {
+        m_baseRecordData = std::move(data);
+        Container<T_elem>::setData(m_baseRecordData);
+    }
+
 public:
     using key_type = typename Container<T_elem>::key_type;
     using mapped_type = typename Container<T_elem>::mapped_type;
@@ -163,9 +170,9 @@ namespace internal
 } // namespace internal
 
 template <typename T_elem>
-BaseRecord<T_elem>::BaseRecord()
+BaseRecord<T_elem>::BaseRecord() : Container<T_elem>(Attributable::NoInit())
 {
-    Attributable::setData(std::make_shared<Data_t>());
+    setData(std::make_shared<Data_t>());
 }
 
 template <typename T_elem>

include/openPMD/backend/BaseRecordComponent.hpp

@@ -103,18 +103,26 @@ class BaseRecordComponent : virtual public Attributable
 
 protected:
     using Data_t = internal::BaseRecordComponentData;
+    std::shared_ptr<Data_t> m_baseRecordComponentData;
 
     inline Data_t const &get() const
     {
-        return dynamic_cast<Data_t const &>(*m_attri);
+        return *m_baseRecordComponentData;
     }
 
     inline Data_t &get()
     {
-        return dynamic_cast<Data_t &>(*m_attri);
+        return *m_baseRecordComponentData;
+    }
+
+    inline void setData(std::shared_ptr<Data_t> data)
+    {
+        m_baseRecordComponentData = std::move(data);
+        Attributable::setData(m_baseRecordComponentData);
     }
 
     BaseRecordComponent();
+    BaseRecordComponent(NoInit);
 }; // BaseRecordComponent
 
 namespace detail

include/openPMD/backend/Container.hpp

@@ -147,14 +147,22 @@ class Container : virtual public Attributable
     using ContainerData = internal::ContainerData<T, T_key, T_container>;
     using InternalContainer = T_container;
 
+    std::shared_ptr<ContainerData> m_containerData;
+
+    inline void setData(std::shared_ptr<ContainerData> containerData)
+    {
+        m_containerData = std::move(containerData);
+        Attributable::setData(m_containerData);
+    }
+
     inline InternalContainer const &container() const
     {
-        return dynamic_cast<ContainerData const &>(*m_attri).m_container;
+        return m_containerData->m_container;
     }
 
     inline InternalContainer &container()
     {
-        return dynamic_cast<ContainerData &>(*m_attri).m_container;
+        return m_containerData->m_container;
     }
 
 public:
@@ -442,10 +450,13 @@ OPENPMD_protected
         flushAttributes(flushParams);
     }
 
-    Container()
+    Container() : Attributable(NoInit())
     {
-        Attributable::setData(std::make_shared<ContainerData>());
+        setData(std::make_shared<ContainerData>());
     }
+
+    Container(NoInit) : Attributable(NoInit())
+    {}
 };
 
 namespace internal

include/openPMD/backend/PatchRecordComponent.hpp

@@ -118,17 +118,24 @@ OPENPMD_protected
 
     using Data_t = internal::PatchRecordComponentData;
 
+    std::shared_ptr<Data_t> m_patchRecordComponentData;
+
     PatchRecordComponent();
 
     inline Data_t const &get() const
     {
-        return dynamic_cast<Data_t const &>(*m_attri);
+        return *m_patchRecordComponentData;
     }
 
     inline Data_t &get()
     {
-        auto &res = dynamic_cast<Data_t &>(*m_attri);
-        return res;
+        return *m_patchRecordComponentData;
+    }
+
+    inline void setData(std::shared_ptr<Data_t> data)
+    {
+        m_patchRecordComponentData = std::move(data);
+        BaseRecordComponent::setData(m_patchRecordComponentData);
     }
 }; // PatchRecordComponent
 

src/Iteration.cpp

@@ -36,9 +36,9 @@ namespace openPMD
 using internal::CloseStatus;
 using internal::DeferredParseAccess;
 
-Iteration::Iteration()
+Iteration::Iteration() : Attributable(NoInit())
 {
-    Attributable::setData(std::make_shared<internal::IterationData>());
+    setData(std::make_shared<Data_t>());
     setTime(static_cast<double>(0));
     setDt(static_cast<double>(1));
     setTimeUnitSI(1);

src/RecordComponent.cpp

@@ -40,9 +40,9 @@ namespace internal
     RecordComponentData::RecordComponentData() = default;
 } // namespace internal
 
-RecordComponent::RecordComponent()
+RecordComponent::RecordComponent() : BaseRecordComponent(NoInit())
 {
-    Attributable::setData(std::make_shared<internal::RecordComponentData>());
+    setData(std::make_shared<Data_t>());
     setUnitSI(1);
 }