Adapt myPath() functionality

Author: franzpoeschel

CMakeLists.txt

@@ -456,7 +456,6 @@ set(CORE_SOURCE
         src/auxiliary/JSON.cpp
         src/backend/Attributable.cpp
         src/backend/BaseRecordComponent.cpp
-        src/backend/Container.cpp
         src/backend/MeshRecordComponent.cpp
         src/backend/PatchRecord.cpp
         src/backend/PatchRecordComponent.cpp

include/openPMD/backend/Container.hpp

@@ -86,36 +86,6 @@ namespace internal
     };
 } // namespace internal
 
-namespace detail
-{
-    /*
-     * This converts the key (first parameter) to its string name within the
-     * openPMD hierarchy.
-     * If the key is found to be equal to RecordComponent::SCALAR, the parentKey
-     * will be returned, adding RecordComponent::SCALAR to its back.
-     * Reason: Scalar record components do not link their containing record as
-     * parent, but rather the parent's parent, so the own key within the
-     * "apparent" parent must be given as two steps.
-     */
-    template <typename T>
-    std::vector<std::string>
-    keyAsString(T &&key, std::vector<std::string> const &parentKey)
-    {
-        (void)parentKey;
-        return {std::to_string(std::forward<T>(key))};
-    }
-
-    // moved to a *.cpp file so we don't need to include RecordComponent.hpp
-    // here
-    template <>
-    std::vector<std::string> keyAsString<std::string const &>(
-        std::string const &key, std::vector<std::string> const &parentKey);
-
-    template <>
-    std::vector<std::string> keyAsString<std::string>(
-        std::string &&key, std::vector<std::string> const &parentKey);
-} // namespace detail
-
 /** @brief Map-like container that enforces openPMD requirements and handles IO.
  *
  * @see http://en.cppreference.com/w/cpp/container/map
@@ -328,8 +298,14 @@ class Container : virtual public Attributable
             T t = T();
             t.linkHierarchy(writable());
             auto &ret = container().insert({key, std::move(t)}).first->second;
-            ret.writable().ownKeyWithinParent =
-                detail::keyAsString(key, writable().ownKeyWithinParent);
+            if constexpr (std::is_same_v<T_key, std::string>)
+            {
+                ret.writable().ownKeyWithinParent = key;
+            }
+            else
+            {
+                ret.writable().ownKeyWithinParent = std::to_string(key);
+            }
             traits::GenerationPolicy<T> gen;
             gen(ret);
             return ret;
@@ -363,8 +339,15 @@ class Container : virtual public Attributable
             T t = T();
             t.linkHierarchy(writable());
             auto &ret = container().insert({key, std::move(t)}).first->second;
-            ret.writable().ownKeyWithinParent = detail::keyAsString(
-                std::move(key), writable().ownKeyWithinParent);
+            if constexpr (std::is_same_v<T_key, std::string>)
+            {
+                ret.writable().ownKeyWithinParent = std::move(key);
+            }
+            else
+            {
+                ret.writable().ownKeyWithinParent =
+                    std::to_string(std::move(key));
+            }
             traits::GenerationPolicy<T> gen;
             gen(ret);
             return ret;

include/openPMD/backend/Writable.hpp

@@ -131,12 +131,10 @@ OPENPMD_private
     Writable *parent = nullptr;
     bool dirty = true;
     /**
-     * If parent is not null, then this is a vector of keys such that:
-     * &(*parent)[key_1]...[key_n] == this
-     * (Notice that scalar record components do not link their direct parent,
-     * but instead their parent's parent, hence a vector of keys)
+     * If parent is not null, then this is a key such that:
+     * &(*parent)[key] == this
      */
-    std::vector<std::string> ownKeyWithinParent;
+    std::string ownKeyWithinParent;
     /**
      * @brief Whether a Writable has been written to the backend.
      *

src/Iteration.cpp

@@ -42,8 +42,8 @@ Iteration::Iteration() : Attributable(NoInit())
     setTime(static_cast<double>(0));
     setDt(static_cast<double>(1));
     setTimeUnitSI(1);
-    meshes.writable().ownKeyWithinParent = {"meshes"};
-    particles.writable().ownKeyWithinParent = {"particles"};
+    meshes.writable().ownKeyWithinParent = "meshes";
+    particles.writable().ownKeyWithinParent = "particles";
 }
 
 template <typename T>

src/ParticleSpecies.cpp

@@ -30,7 +30,7 @@ namespace openPMD
 {
 ParticleSpecies::ParticleSpecies()
 {
-    particlePatches.writable().ownKeyWithinParent = {"particlePatches"};
+    particlePatches.writable().ownKeyWithinParent = "particlePatches";
 }
 
 void ParticleSpecies::read()

src/Series.cpp

@@ -560,7 +560,7 @@ void Series::init(
         std::make_shared<std::optional<std::unique_ptr<AbstractIOHandler>>>(
             std::move(ioHandler));
     series.iterations.linkHierarchy(writable());
-    series.iterations.writable().ownKeyWithinParent = {"iterations"};
+    series.iterations.writable().ownKeyWithinParent = "iterations";
 
     series.m_name = input->name;
 

src/backend/Attributable.cpp

@@ -197,13 +197,7 @@ auto Attributable::myPath() const -> MyPath
         // so it's alright that this loop doesn't ask the key of the last found
         // Writable
 
-        // push these in reverse because we're building the list from the back
-        for (auto it = findSeries->ownKeyWithinParent.rbegin();
-             it != findSeries->ownKeyWithinParent.rend();
-             ++it)
-        {
-            res.group.push_back(*it);
-        }
+        res.group.push_back(findSeries->ownKeyWithinParent);
         findSeries = findSeries->parent;
     }
     std::reverse(res.group.begin(), res.group.end());

src/backend/Container.cpp

@@ -193,12 +193,7 @@ TEST_CASE("myPath", "[core]")
     auto scalarMeshComponent = scalarMesh[RecordComponent::SCALAR];
     REQUIRE(
         pathOf(scalarMeshComponent) ==
-        vec_t{
-            "iterations",
-            "1234",
-            "meshes",
-            "e_chargeDensity",
-            RecordComponent::SCALAR});
+        vec_t{"iterations", "1234", "meshes", "e_chargeDensity"});
     writeSomething(scalarMeshComponent);
 
     auto vectorMesh = iteration.meshes["E"];
@@ -234,13 +229,7 @@ TEST_CASE("myPath", "[core]")
     auto speciesWeightingX = speciesWeighting[RecordComponent::SCALAR];
     REQUIRE(
         pathOf(speciesWeightingX) ==
-        vec_t{
-            "iterations",
-            "1234",
-            "particles",
-            "e",
-            "weighting",
-            RecordComponent::SCALAR});
+        vec_t{"iterations", "1234", "particles", "e", "weighting"});
     writeSomething(speciesWeightingX);
 
     REQUIRE(