Prepare class structure without applying logic yet

BaseRecord is now derived by its contained RecordComponent type.
If it is scalar, the idea is that the BaseRecord itself is used as a
RecordComponent, without needing to retrieve the [SCALAR] entry.
No logic implemented yet around this, this just prepares the class
structure.
Notice that this will write some unnecessary attributes since the
RecordComponent types initialize some default attributes upon
construction.

Author: franzpoeschel

include/openPMD/ParticleSpecies.hpp

@@ -61,6 +61,7 @@ namespace traits
     template <>
     struct GenerationPolicy<ParticleSpecies>
     {
+        constexpr static bool is_noop = false;
         template <typename T>
         void operator()(T &ret)
         {

include/openPMD/RecordComponent.hpp

@@ -95,6 +95,8 @@ namespace internal
          */
         bool m_hasBeenExtended = false;
     };
+    template <typename, typename>
+    class BaseRecordData;
 } // namespace internal
 
 class RecordComponent : public BaseRecordComponent
@@ -103,8 +105,10 @@ class RecordComponent : public BaseRecordComponent
     friend class Container;
     friend class Iteration;
     friend class ParticleSpecies;
-    template <typename T_elem>
+    template <typename>
     friend class BaseRecord;
+    template <typename, typename>
+    friend class internal::BaseRecordData;
     friend class Record;
     friend class Mesh;
     template <typename>
@@ -437,6 +441,7 @@ OPENPMD_protected
     std::shared_ptr<Data_t> m_recordComponentData;
 
     RecordComponent();
+    RecordComponent(NoInit);
 
     inline Data_t const &get() const
     {

include/openPMD/backend/Attributable.hpp

@@ -81,7 +81,7 @@ namespace internal
         A_MAP m_attributes;
     };
 
-    template <typename>
+    template <typename, typename>
     class BaseRecordData;
 } // namespace internal
 
@@ -99,7 +99,7 @@ class Attributable
     friend class BaseRecord;
     template <typename T_elem>
     friend class BaseRecordInterface;
-    template <typename>
+    template <typename, typename>
     friend class internal::BaseRecordData;
     template <typename T, typename T_key, typename T_container>
     friend class Container;

include/openPMD/backend/BaseRecord.hpp

@@ -32,8 +32,16 @@ namespace openPMD
 {
 namespace internal
 {
-    template <typename T_elem>
-    class BaseRecordData : public ContainerData<T_elem>
+    template <
+        typename T_elem, // = T_RecordComponent
+        /*
+         * Technically not necessary, but some old compilers ignore friend
+         * declarations at this place, so we specify the data class explicitly
+         */
+        typename T_RecordComponentData = typename T_elem::Data_t>
+    class BaseRecordData final
+        : public ContainerData<T_elem>
+        , public T_RecordComponentData
     {
     public:
         /**
@@ -55,17 +63,29 @@ namespace internal
 } // namespace internal
 
 template <typename T_elem>
-class BaseRecord : public Container<T_elem>
+class BaseRecord
+    : public Container<T_elem>
+    , public T_elem // T_RecordComponent
 {
+    using T_RecordComponent = T_elem;
+    using T_Container = Container<T_elem>;
+    using T_Self = BaseRecord<T_elem>;
     friend class Iteration;
     friend class ParticleSpecies;
     friend class PatchRecord;
     friend class Record;
     friend class Mesh;
+    template <typename, typename>
+    friend class internal::BaseRecordData;
 
-    using Data_t = internal::BaseRecordData<T_elem>;
+    using Data_t =
+        internal::BaseRecordData<T_elem, typename T_RecordComponent::Data_t>;
     std::shared_ptr<Data_t> m_baseRecordData;
 
+    static_assert(
+        traits::GenerationPolicy<T_RecordComponent>::is_noop,
+        "Internal error: Scalar components cannot have generation policies.");
+
     inline Data_t const &get() const
     {
         return *m_baseRecordData;
@@ -82,7 +102,8 @@ class BaseRecord : public Container<T_elem>
     inline void setData(std::shared_ptr<Data_t> data)
     {
         m_baseRecordData = std::move(data);
-        Container<T_elem>::setData(m_baseRecordData);
+        T_Container::setData(m_baseRecordData);
+        T_RecordComponent::setData(m_baseRecordData);
     }
 
 public:
@@ -96,8 +117,8 @@ class BaseRecord : public Container<T_elem>
     using const_reference = typename Container<T_elem>::const_reference;
     using pointer = typename Container<T_elem>::pointer;
     using const_pointer = typename Container<T_elem>::const_pointer;
-    using iterator = typename Container<T_elem>::iterator;
-    using const_iterator = typename Container<T_elem>::const_iterator;
+    using iterator = typename T_Container::iterator;
+    using const_iterator = typename T_Container::const_iterator;
 
     virtual ~BaseRecord() = default;
 
@@ -158,8 +179,8 @@ class BaseRecord : public Container<T_elem>
 
 namespace internal
 {
-    template <typename T_elem>
-    BaseRecordData<T_elem>::BaseRecordData()
+    template <typename T_elem, typename T_RecordComponentData>
+    BaseRecordData<T_elem, T_RecordComponentData>::BaseRecordData()
     {
         Attributable impl;
         impl.setData({this, [](auto const *) {}});
@@ -170,7 +191,9 @@ namespace internal
 } // namespace internal
 
 template <typename T_elem>
-BaseRecord<T_elem>::BaseRecord() : Container<T_elem>(Attributable::NoInit())
+BaseRecord<T_elem>::BaseRecord()
+    : T_Container(Attributable::NoInit())
+    , T_RecordComponent(Attributable::NoInit())
 {
     setData(std::make_shared<Data_t>());
 }
@@ -291,7 +314,7 @@ template <typename T_elem>
 inline std::array<double, 7> BaseRecord<T_elem>::unitDimension() const
 {
     return this->getAttribute("unitDimension")
-        .template get<std::array<double, 7> >();
+        .template get<std::array<double, 7>>();
 }
 
 template <typename T_elem>
@@ -310,7 +333,7 @@ inline void BaseRecord<T_elem>::readBase()
     this->IOHandler()->enqueue(IOTask(this, aRead));
     this->IOHandler()->flush(internal::defaultFlushParams);
     if (auto val =
-            Attribute(*aRead.resource).getOptional<std::array<double, 7> >();
+            Attribute(*aRead.resource).getOptional<std::array<double, 7>>();
         val.has_value())
         this->setAttribute("unitDimension", val.value());
     else
@@ -339,7 +362,7 @@ template <typename T_elem>
 inline void BaseRecord<T_elem>::flush(
     std::string const &name, internal::FlushParams const &flushParams)
 {
-    if (!this->written() && this->empty())
+    if (!this->written() && this->T_Container::empty())
         throw std::runtime_error(
             "A Record can not be written without any contained "
             "RecordComponents: " +

include/openPMD/backend/Container.hpp

@@ -49,6 +49,7 @@ namespace traits
     template <typename U>
     struct GenerationPolicy
     {
+        constexpr static bool is_noop = true;
         template <typename T>
         void operator()(T &)
         {}

include/openPMD/backend/MeshRecordComponent.hpp

@@ -30,11 +30,14 @@ class MeshRecordComponent : public RecordComponent
 {
     template <typename T, typename T_key, typename T_container>
     friend class Container;
+    template <typename>
+    friend class BaseRecord;
 
     friend class Mesh;
 
 private:
     MeshRecordComponent();
+    MeshRecordComponent(NoInit);
     void read() override;
 
 public:

include/openPMD/backend/PatchRecordComponent.hpp

@@ -56,6 +56,9 @@ namespace internal
 
         PatchRecordComponentData();
     };
+
+    template <typename, typename>
+    class BaseRecordData;
 } // namespace internal
 
 /**
@@ -67,6 +70,8 @@ class PatchRecordComponent : public BaseRecordComponent
     friend class Container;
     template <typename>
     friend class BaseRecord;
+    template <typename, typename>
+    friend class internal::BaseRecordData;
     friend class ParticlePatches;
     friend class PatchRecord;
     friend class ParticleSpecies;
@@ -121,6 +126,7 @@ OPENPMD_protected
     std::shared_ptr<Data_t> m_patchRecordComponentData;
 
     PatchRecordComponent();
+    PatchRecordComponent(NoInit);
 
     inline Data_t const &get() const
     {

src/RecordComponent.cpp

@@ -46,6 +46,9 @@ RecordComponent::RecordComponent() : BaseRecordComponent(NoInit())
     setUnitSI(1);
 }
 
+RecordComponent::RecordComponent(NoInit) : BaseRecordComponent(NoInit())
+{}
+
 // We need to instantiate this somewhere otherwise there might be linker issues
 // despite this thing actually being constepxr
 constexpr char const *const RecordComponent::SCALAR;

src/backend/MeshRecordComponent.cpp

@@ -27,6 +27,9 @@ MeshRecordComponent::MeshRecordComponent() : RecordComponent()
     setPosition(std::vector<double>{0});
 }
 
+MeshRecordComponent::MeshRecordComponent(NoInit) : RecordComponent(NoInit())
+{}
+
 void MeshRecordComponent::read()
 {
     using DT = Datatype;

src/backend/PatchRecordComponent.cpp

@@ -80,6 +80,10 @@ PatchRecordComponent::PatchRecordComponent() : BaseRecordComponent(NoInit())
     setUnitSI(1);
 }
 
+PatchRecordComponent::PatchRecordComponent(NoInit)
+    : BaseRecordComponent(NoInit())
+{}
+
 void PatchRecordComponent::flush(
     std::string const &name, internal::FlushParams const &flushParams)
 {