Use a std::optional for BaseRecordComponentData::m_dataset

franzpoeschel · franzpoeschel · commit bd1da15e8bea · 2022-09-15T11:59:37.000+02:00
diff --git a/include/openPMD/RecordComponent.tpp b/include/openPMD/RecordComponent.tpp
@@ -308,7 +308,13 @@ RecordComponent::storeChunk( Offset o, Extent e, F && createBuffer )
         dCreate.name = rc.m_name;
         dCreate.extent = getExtent();
         dCreate.dtype = getDatatype();
-        dCreate.options = rc.m_dataset.options;
+        if (!rc.m_dataset.has_value())
+        {
+            throw error::WrongAPIUsage(
+                "[RecordComponent] Must specify dataset type and extent before "
+                "using storeChunk() (see RecordComponent::resetDataset()).");
+        }
+        dCreate.options = rc.m_dataset.value().options;
         IOHandler()->enqueue(IOTask(this, dCreate));
     }
     Parameter< Operation::GET_BUFFER_VIEW > getBufferView;
diff --git a/include/openPMD/backend/BaseRecordComponent.hpp b/include/openPMD/backend/BaseRecordComponent.hpp
@@ -24,6 +24,8 @@
 #include "openPMD/Error.hpp"
 #include "openPMD/backend/Attributable.hpp"
 
+#include <optional>
+
 // expose private and protected members for invasive testing
 #ifndef OPENPMD_protected
 #define OPENPMD_protected protected:
@@ -39,7 +41,7 @@ namespace internal
         /**
          * The type and extent of the dataset defined by this component.
          */
-        Dataset m_dataset{Datatype::UNDEFINED, {}};
+        std::optional<Dataset> m_dataset;
         /**
          * True if this is defined as a constant record component as specified
          * in the openPMD standard.
diff --git a/src/RecordComponent.cpp b/src/RecordComponent.cpp
@@ -42,7 +42,6 @@ namespace internal
         RecordComponent impl{
             std::shared_ptr<RecordComponentData>{this, [](auto const *) {}}};
         impl.setUnitSI(1);
-        impl.resetDataset(Dataset(Datatype::CHAR, {1}));
     }
 } // namespace internal
 
@@ -71,11 +70,17 @@ RecordComponent &RecordComponent::resetDataset(Dataset d)
     auto &rc = get();
     if (written())
     {
+        if (!rc.m_dataset.has_value())
+        {
+            throw error::Internal(
+                "Internal control flow error: Written record component must "
+                "have defined datatype and extent.");
+        }
         if (d.dtype == Datatype::UNDEFINED)
         {
-            d.dtype = rc.m_dataset.dtype;
+            d.dtype = rc.m_dataset.value().dtype;
         }
-        else if (d.dtype != rc.m_dataset.dtype)
+        else if (d.dtype != rc.m_dataset.value().dtype)
         {
             throw std::runtime_error(
                 "Cannot change the datatype of a dataset.");
@@ -99,7 +104,7 @@ RecordComponent &RecordComponent::resetDataset(Dataset d)
     rc.m_isEmpty = false;
     if (written())
     {
-        rc.m_dataset.extend(std::move(d.extent));
+        rc.m_dataset.value().extend(std::move(d.extent));
     }
     else
     {
@@ -112,12 +117,28 @@ RecordComponent &RecordComponent::resetDataset(Dataset d)
 
 uint8_t RecordComponent::getDimensionality() const
 {
-    return get().m_dataset.rank;
+    auto &rc = get();
+    if (rc.m_dataset.has_value())
+    {
+        return rc.m_dataset.value().rank;
+    }
+    else
+    {
+        return 1;
+    }
 }
 
 Extent RecordComponent::getExtent() const
 {
-    return get().m_dataset.extent;
+    auto &rc = get();
+    if (rc.m_dataset.has_value())
+    {
+        return rc.m_dataset.value().extent;
+    }
+    else
+    {
+        return {1};
+    }
 }
 
 namespace detail
@@ -149,6 +170,12 @@ RecordComponent &RecordComponent::makeEmpty(Dataset d)
     auto &rc = get();
     if (written())
     {
+        if (!rc.m_dataset.has_value())
+        {
+            throw error::Internal(
+                "Internal control flow error: Written record component must "
+                "have defined datatype and extent.");
+        }
         if (!constant())
         {
             throw std::runtime_error(
@@ -158,30 +185,30 @@ RecordComponent &RecordComponent::makeEmpty(Dataset d)
         }
         if (d.dtype == Datatype::UNDEFINED)
         {
-            d.dtype = rc.m_dataset.dtype;
+            d.dtype = rc.m_dataset.value().dtype;
         }
-        else if (d.dtype != rc.m_dataset.dtype)
+        else if (d.dtype != rc.m_dataset.value().dtype)
         {
             throw std::runtime_error(
                 "Cannot change the datatype of a dataset.");
         }
-        rc.m_dataset.extend(std::move(d.extent));
+        rc.m_dataset.value().extend(std::move(d.extent));
         rc.m_hasBeenExtended = true;
     }
     else
     {
         rc.m_dataset = std::move(d);
     }
 
-    if (rc.m_dataset.extent.size() == 0)
+    if (rc.m_dataset.value().extent.size() == 0)
         throw std::runtime_error("Dataset extent must be at least 1D.");
 
     rc.m_isEmpty = true;
     dirty() = true;
     if (!written())
     {
         switchType<detail::DefaultValue<RecordComponent> >(
-            rc.m_dataset.dtype, *this);
+            rc.m_dataset.value().dtype, *this);
     }
     return *this;
 }
@@ -215,11 +242,11 @@ void RecordComponent::flush(
         /*
          * This catches when a user forgets to use resetDataset.
          */
-        if (rc.m_dataset.dtype == Datatype::UNDEFINED)
+        if (!rc.m_dataset.has_value())
         {
             throw error::WrongAPIUsage(
-                "[RecordComponent] Must set specific datatype (Use "
-                "resetDataset call).");
+                "[RecordComponent] Must specify dataset type and extent before "
+                "flushing (see RecordComponent::resetDataset()).");
         }
         if (!written())
         {
@@ -245,7 +272,7 @@ void RecordComponent::flush(
                 dCreate.name = name;
                 dCreate.extent = getExtent();
                 dCreate.dtype = getDatatype();
-                dCreate.options = rc.m_dataset.options;
+                dCreate.options = rc.m_dataset.value().options;
                 IOHandler()->enqueue(IOTask(this, dCreate));
             }
         }
@@ -264,7 +291,7 @@ void RecordComponent::flush(
             else
             {
                 Parameter<Operation::EXTEND_DATASET> pExtend;
-                pExtend.extent = rc.m_dataset.extent;
+                pExtend.extent = rc.m_dataset.value().extent;
                 IOHandler()->enqueue(IOTask(this, std::move(pExtend)));
                 rc.m_hasBeenExtended = false;
             }
diff --git a/src/backend/BaseRecordComponent.cpp b/src/backend/BaseRecordComponent.cpp
@@ -35,13 +35,29 @@ BaseRecordComponent &BaseRecordComponent::resetDatatype(Datatype d)
             "A Records Datatype can not (yet) be changed after it has been "
             "written.");
 
-    get().m_dataset.dtype = d;
+    auto &rc = get();
+    if (rc.m_dataset.has_value())
+    {
+        rc.m_dataset.value().dtype = d;
+    }
+    else
+    {
+        rc.m_dataset = Dataset{d, {1}};
+    }
     return *this;
 }
 
 Datatype BaseRecordComponent::getDatatype() const
 {
-    return get().m_dataset.dtype;
+    auto &rc = get();
+    if (rc.m_dataset.has_value())
+    {
+        return rc.m_dataset.value().dtype;
+    }
+    else
+    {
+        return Datatype::UNDEFINED;
+    }
 }
 
 bool BaseRecordComponent::constant() const
@@ -54,8 +70,12 @@ ChunkTable BaseRecordComponent::availableChunks()
     auto &rc = get();
     if (rc.m_isConstant)
     {
-        Offset offset(rc.m_dataset.extent.size(), 0);
-        return ChunkTable{{std::move(offset), rc.m_dataset.extent}};
+        if (!rc.m_dataset.has_value())
+        {
+            return ChunkTable{};
+        }
+        Offset offset(rc.m_dataset.value().extent.size(), 0);
+        return ChunkTable{{std::move(offset), rc.m_dataset.value().extent}};
     }
     containingIteration().open();
     Parameter<Operation::AVAILABLE_CHUNKS> param;
diff --git a/src/backend/PatchRecordComponent.cpp b/src/backend/PatchRecordComponent.cpp
@@ -67,7 +67,15 @@ uint8_t PatchRecordComponent::getDimensionality() const
 
 Extent PatchRecordComponent::getExtent() const
 {
-    return get().m_dataset.extent;
+    auto &rc = get();
+    if (rc.m_dataset.has_value())
+    {
+        return rc.m_dataset.value().extent;
+    }
+    else
+    {
+        return {1};
+    }
 }
 
 PatchRecordComponent::PatchRecordComponent() : BaseRecordComponent{nullptr}
@@ -97,13 +105,20 @@ void PatchRecordComponent::flush(
     case Access::READ_WRITE:
     case Access::CREATE:
     case Access::APPEND: {
+        if (!rc.m_dataset.has_value())
+        {
+            throw error::WrongAPIUsage(
+                "[PatchRecordComponent] Must specify dataset type and extent "
+                "before "
+                "flushing (see RecordComponent::resetDataset()).");
+        }
         if (!written())
         {
             Parameter<Operation::CREATE_DATASET> dCreate;
             dCreate.name = name;
             dCreate.extent = getExtent();
             dCreate.dtype = getDatatype();
-            dCreate.options = rc.m_dataset.options;
+            dCreate.options = rc.m_dataset.value().options;
             IOHandler()->enqueue(IOTask(this, dCreate));
         }
 

Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,6 @@ namespace internal`
`42`	`42`	`RecordComponent impl{`
`43`	`43`	`std::shared_ptr<RecordComponentData>{this, [](auto const *) {}}};`
`44`	`44`	`impl.setUnitSI(1);`
`45`		`- impl.resetDataset(Dataset(Datatype::CHAR, {1}));`
`46`	`45`	`}`
`47`	`46`	`} // namespace internal`
`48`	`47`
`@@ -71,11 +70,17 @@ RecordComponent &RecordComponent::resetDataset(Dataset d)`
`71`	`70`	`auto &rc = get();`
`72`	`71`	`if (written())`
`73`	`72`	`{`
	`73`	`+ if (!rc.m_dataset.has_value())`
	`74`	`+ {`
	`75`	`+ throw error::Internal(`
	`76`	`+ "Internal control flow error: Written record component must "`
	`77`	`+ "have defined datatype and extent.");`
	`78`	`+ }`
`74`	`79`	`if (d.dtype == Datatype::UNDEFINED)`
`75`	`80`	`{`
`76`		`- d.dtype = rc.m_dataset.dtype;`
	`81`	`+ d.dtype = rc.m_dataset.value().dtype;`
`77`	`82`	`}`
`78`		`- else if (d.dtype != rc.m_dataset.dtype)`
	`83`	`+ else if (d.dtype != rc.m_dataset.value().dtype)`
`79`	`84`	`{`
`80`	`85`	`throw std::runtime_error(`
`81`	`86`	`"Cannot change the datatype of a dataset.");`
`@@ -99,7 +104,7 @@ RecordComponent &RecordComponent::resetDataset(Dataset d)`
`99`	`104`	`rc.m_isEmpty = false;`
`100`	`105`	`if (written())`
`101`	`106`	`{`
`102`		`- rc.m_dataset.extend(std::move(d.extent));`
	`107`	`+ rc.m_dataset.value().extend(std::move(d.extent));`
`103`	`108`	`}`
`104`	`109`	`else`
`105`	`110`	`{`
`@@ -112,12 +117,28 @@ RecordComponent &RecordComponent::resetDataset(Dataset d)`
`112`	`117`
`113`	`118`	`uint8_t RecordComponent::getDimensionality() const`
`114`	`119`	`{`
`115`		`- return get().m_dataset.rank;`
	`120`	`+ auto &rc = get();`
	`121`	`+ if (rc.m_dataset.has_value())`
	`122`	`+ {`
	`123`	`+ return rc.m_dataset.value().rank;`
	`124`	`+ }`
	`125`	`+ else`
	`126`	`+ {`
	`127`	`+ return 1;`
	`128`	`+ }`
`116`	`129`	`}`
`117`	`130`
`118`	`131`	`Extent RecordComponent::getExtent() const`
`119`	`132`	`{`
`120`		`- return get().m_dataset.extent;`
	`133`	`+ auto &rc = get();`
	`134`	`+ if (rc.m_dataset.has_value())`
	`135`	`+ {`
	`136`	`+ return rc.m_dataset.value().extent;`
	`137`	`+ }`
	`138`	`+ else`
	`139`	`+ {`
	`140`	`+ return {1};`
	`141`	`+ }`
`121`	`142`	`}`
`122`	`143`
`123`	`144`	`namespace detail`
`@@ -149,6 +170,12 @@ RecordComponent &RecordComponent::makeEmpty(Dataset d)`
`149`	`170`	`auto &rc = get();`
`150`	`171`	`if (written())`
`151`	`172`	`{`
	`173`	`+ if (!rc.m_dataset.has_value())`
	`174`	`+ {`
	`175`	`+ throw error::Internal(`
	`176`	`+ "Internal control flow error: Written record component must "`
	`177`	`+ "have defined datatype and extent.");`
	`178`	`+ }`
`152`	`179`	`if (!constant())`
`153`	`180`	`{`
`154`	`181`	`throw std::runtime_error(`
`@@ -158,30 +185,30 @@ RecordComponent &RecordComponent::makeEmpty(Dataset d)`
`158`	`185`	`}`
`159`	`186`	`if (d.dtype == Datatype::UNDEFINED)`
`160`	`187`	`{`
`161`		`- d.dtype = rc.m_dataset.dtype;`
	`188`	`+ d.dtype = rc.m_dataset.value().dtype;`
`162`	`189`	`}`
`163`		`- else if (d.dtype != rc.m_dataset.dtype)`
	`190`	`+ else if (d.dtype != rc.m_dataset.value().dtype)`
`164`	`191`	`{`
`165`	`192`	`throw std::runtime_error(`
`166`	`193`	`"Cannot change the datatype of a dataset.");`
`167`	`194`	`}`
`168`		`- rc.m_dataset.extend(std::move(d.extent));`
	`195`	`+ rc.m_dataset.value().extend(std::move(d.extent));`
`169`	`196`	`rc.m_hasBeenExtended = true;`
`170`	`197`	`}`
`171`	`198`	`else`
`172`	`199`	`{`
`173`	`200`	`rc.m_dataset = std::move(d);`
`174`	`201`	`}`
`175`	`202`
`176`		`- if (rc.m_dataset.extent.size() == 0)`
	`203`	`+ if (rc.m_dataset.value().extent.size() == 0)`
`177`	`204`	`throw std::runtime_error("Dataset extent must be at least 1D.");`
`178`	`205`
`179`	`206`	`rc.m_isEmpty = true;`
`180`	`207`	`dirty() = true;`
`181`	`208`	`if (!written())`
`182`	`209`	`{`
`183`	`210`	`switchType<detail::DefaultValue<RecordComponent> >(`
`184`		`- rc.m_dataset.dtype, *this);`
	`211`	`+ rc.m_dataset.value().dtype, *this);`
`185`	`212`	`}`
`186`	`213`	`return *this;`
`187`	`214`	`}`
`@@ -215,11 +242,11 @@ void RecordComponent::flush(`
`215`	`242`	`/*`
`216`	`243`	`* This catches when a user forgets to use resetDataset.`
`217`	`244`	`*/`
`218`		`- if (rc.m_dataset.dtype == Datatype::UNDEFINED)`
	`245`	`+ if (!rc.m_dataset.has_value())`
`219`	`246`	`{`
`220`	`247`	`throw error::WrongAPIUsage(`
`221`		`- "[RecordComponent] Must set specific datatype (Use "`
`222`		`- "resetDataset call).");`
	`248`	`+ "[RecordComponent] Must specify dataset type and extent before "`
	`249`	`+ "flushing (see RecordComponent::resetDataset()).");`
`223`	`250`	`}`
`224`	`251`	`if (!written())`
`225`	`252`	`{`
`@@ -245,7 +272,7 @@ void RecordComponent::flush(`
`245`	`272`	`dCreate.name = name;`
`246`	`273`	`dCreate.extent = getExtent();`
`247`	`274`	`dCreate.dtype = getDatatype();`
`248`		`- dCreate.options = rc.m_dataset.options;`
	`275`	`+ dCreate.options = rc.m_dataset.value().options;`
`249`	`276`	`IOHandler()->enqueue(IOTask(this, dCreate));`
`250`	`277`	`}`
`251`	`278`	`}`
`@@ -264,7 +291,7 @@ void RecordComponent::flush(`
`264`	`291`	`else`
`265`	`292`	`{`
`266`	`293`	`Parameter<Operation::EXTEND_DATASET> pExtend;`
`267`		`- pExtend.extent = rc.m_dataset.extent;`
	`294`	`+ pExtend.extent = rc.m_dataset.value().extent;`
`268`	`295`	`IOHandler()->enqueue(IOTask(this, std::move(pExtend)));`
`269`	`296`	`rc.m_hasBeenExtended = false;`
`270`	`297`	`}`