Unify naming scheme for helper namespaces

franzpoeschel · franzpoeschel · commit b3a43a85d4c6 · 2024-01-23T14:26:59.000+01:00
diff --git a/include/openPMD/IO/ADIOS/ADIOS2Auxiliary.hpp b/include/openPMD/IO/ADIOS/ADIOS2Auxiliary.hpp
@@ -70,7 +70,7 @@ namespace adios_defs
  * The following strings are used during parsing of the JSON configuration
  * string for the ADIOS2 backend.
  */
-namespace ADIOS2Defaults
+namespace adios_defaults
 {
     using const_str = char const *const;
     constexpr const_str str_engine = "engine";
@@ -85,7 +85,7 @@ namespace ADIOS2Defaults
     constexpr const_str str_activeTablePrefix = "__openPMD_groups";
     constexpr const_str str_groupBasedWarning =
         "__openPMD_internal/warning_bugprone_groupbased_encoding";
-} // namespace ADIOS2Defaults
+} // namespace adios_defaults
 
 #if openPMD_HAVE_ADIOS2
 namespace detail
diff --git a/src/IO/ADIOS/ADIOS2Auxiliary.cpp b/src/IO/ADIOS/ADIOS2Auxiliary.cpp
@@ -51,7 +51,7 @@ FlushTarget flushTargetFromString(std::string const &str)
     else
     {
         throw error::BackendConfigSchema(
-            {"adios2", "engine", ADIOS2Defaults::str_flushtarget},
+            {"adios2", "engine", adios_defaults::str_flushtarget},
             "Flush target must be either 'disk' or 'buffer', but "
             "was " +
                 str + ".");
diff --git a/src/IO/ADIOS/ADIOS2File.cpp b/src/IO/ADIOS/ADIOS2File.cpp
@@ -494,10 +494,10 @@ void ADIOS2File::configure_IO()
     // set engine parameters
     std::set<std::string> alreadyConfigured;
     bool wasTheFlushTargetSpecifiedViaJSON = false;
-    auto engineConfig = m_impl->config(ADIOS2Defaults::str_engine);
+    auto engineConfig = m_impl->config(adios_defaults::str_engine);
     if (!engineConfig.json().is_null())
     {
-        auto params = m_impl->config(ADIOS2Defaults::str_params, engineConfig);
+        auto params = m_impl->config(adios_defaults::str_params, engineConfig);
         params.declareFullyRead();
         if (params.json().is_object())
         {
@@ -520,7 +520,7 @@ void ADIOS2File::configure_IO()
             }
         }
         auto _useAdiosSteps =
-            m_impl->config(ADIOS2Defaults::str_usesteps, engineConfig);
+            m_impl->config(adios_defaults::str_usesteps, engineConfig);
         if (!_useAdiosSteps.json().is_null() && writeOnly(m_mode))
         {
             std::cerr << "[ADIOS2 backend] WARNING: Parameter "
@@ -529,14 +529,14 @@ void ADIOS2File::configure_IO()
                       << std::endl;
         }
 
-        if (engineConfig.json().contains(ADIOS2Defaults::str_flushtarget))
+        if (engineConfig.json().contains(adios_defaults::str_flushtarget))
         {
             auto target = json::asLowerCaseStringDynamic(
-                engineConfig[ADIOS2Defaults::str_flushtarget].json());
+                engineConfig[adios_defaults::str_flushtarget].json());
             if (!target.has_value())
             {
                 throw error::BackendConfigSchema(
-                    {"adios2", "engine", ADIOS2Defaults::str_flushtarget},
+                    {"adios2", "engine", adios_defaults::str_flushtarget},
                     "Flush target must be either 'disk' or 'buffer', but "
                     "was non-literal type.");
             }
@@ -713,10 +713,10 @@ auto ADIOS2File::detectGroupTable() -> UseGroupTable
 {
     auto const &attributes = availableAttributes();
     auto lower_bound =
-        attributes.lower_bound(ADIOS2Defaults::str_activeTablePrefix);
+        attributes.lower_bound(adios_defaults::str_activeTablePrefix);
     if (lower_bound != attributes.end() &&
         auxiliary::starts_with(
-            lower_bound->first, ADIOS2Defaults::str_activeTablePrefix))
+            lower_bound->first, adios_defaults::str_activeTablePrefix))
     {
         return UseGroupTable::Yes;
     }
@@ -819,7 +819,7 @@ adios2::Engine &ADIOS2File::getEngine()
             {
             case StreamStatus::Undecided: {
                 auto attr = m_IO.InquireAttribute<bool_representation>(
-                    ADIOS2Defaults::str_usesstepsAttribute);
+                    adios_defaults::str_usesstepsAttribute);
                 if (attr && attr.Data()[0] == 1)
                 {
                     if (parsePreference == ParsePreference::UpFront)
@@ -861,7 +861,7 @@ adios2::Engine &ADIOS2File::getEngine()
                         if (m_impl->m_useGroupTable.value() ==
                                 UseGroupTable::No &&
                             m_IO.InquireAttribute<std::string>(
-                                ADIOS2Defaults::str_groupBasedWarning))
+                                adios_defaults::str_groupBasedWarning))
                         {
                             throw error::OperationUnsupportedInBackend(
                                 "ADIOS2",
@@ -969,7 +969,7 @@ void ADIOS2File::flush_impl(
         // Currently only schema 0 supported
         if (m_impl->m_writeAttributesFromThisRank)
         {
-            m_IO.DefineAttribute<uint64_t>(ADIOS2Defaults::str_adios2Schema, 0);
+            m_IO.DefineAttribute<uint64_t>(adios_defaults::str_adios2Schema, 0);
         }
         initializedDefaults = true;
     }
@@ -1132,10 +1132,10 @@ AdvanceStatus ADIOS2File::advance(AdvanceMode mode)
 
         if (writeOnly(m_mode) && m_impl->m_writeAttributesFromThisRank &&
             !m_IO.InquireAttribute<bool_representation>(
-                ADIOS2Defaults::str_usesstepsAttribute))
+                adios_defaults::str_usesstepsAttribute))
         {
             m_IO.DefineAttribute<bool_representation>(
-                ADIOS2Defaults::str_usesstepsAttribute, 1);
+                adios_defaults::str_usesstepsAttribute, 1);
         }
 
         flush(
@@ -1281,7 +1281,7 @@ void ADIOS2File::markActive(Writable *writable)
                 auto filePos = m_impl->setAndGetFilePosition(
                     writable, /* write = */ false);
                 auto fullPath =
-                    ADIOS2Defaults::str_activeTablePrefix + filePos->location;
+                    adios_defaults::str_activeTablePrefix + filePos->location;
                 m_IO.DefineAttribute<attr_t>(
                     fullPath,
                     currentStepBuffered,
diff --git a/src/IO/ADIOS/ADIOS2IOHandler.cpp b/src/IO/ADIOS/ADIOS2IOHandler.cpp
@@ -228,11 +228,11 @@ void ADIOS2IOHandlerImpl::init(
                 m_config["attribute_writing_ranks"].json());
         }
 
-        auto engineConfig = config(ADIOS2Defaults::str_engine);
+        auto engineConfig = config(adios_defaults::str_engine);
         if (!engineConfig.json().is_null())
         {
             auto engineTypeConfig =
-                config(ADIOS2Defaults::str_type, engineConfig).json();
+                config(adios_defaults::str_type, engineConfig).json();
             if (!engineTypeConfig.is_null())
             {
                 // convert to string
@@ -468,14 +468,14 @@ ADIOS2IOHandlerImpl::flush(internal::ParsedFlushParams &flushParams)
         if (adios2Config.json().contains("engine"))
         {
             auto engineConfig = adios2Config["engine"];
-            if (engineConfig.json().contains(ADIOS2Defaults::str_flushtarget))
+            if (engineConfig.json().contains(adios_defaults::str_flushtarget))
             {
                 auto target = json::asLowerCaseStringDynamic(
-                    engineConfig[ADIOS2Defaults::str_flushtarget].json());
+                    engineConfig[adios_defaults::str_flushtarget].json());
                 if (!target.has_value())
                 {
                     throw error::BackendConfigSchema(
-                        {"adios2", "engine", ADIOS2Defaults::str_flushtarget},
+                        {"adios2", "engine", adios_defaults::str_flushtarget},
                         "Flush target must be either 'disk' or 'buffer', but "
                         "was non-literal type.");
                 }
@@ -604,7 +604,7 @@ void ADIOS2IOHandlerImpl::createFile(
                 printedWarningsAlready.noGroupBased = true;
             }
             fileData.m_IO.DefineAttribute(
-                ADIOS2Defaults::str_groupBasedWarning,
+                adios_defaults::str_groupBasedWarning,
                 std::string("Consider using file-based or variable-based "
                             "encoding instead in ADIOS2."));
         }
@@ -1247,7 +1247,7 @@ void ADIOS2IOHandlerImpl::listPaths(
     }
     case UseGroupTable::Yes: {
         {
-            auto tablePrefix = ADIOS2Defaults::str_activeTablePrefix + myName;
+            auto tablePrefix = adios_defaults::str_activeTablePrefix + myName;
             std::vector attrs =
                 fileData.availableAttributesPrefixed(tablePrefix);
             if (fileData.streamStatus ==
@@ -1628,7 +1628,7 @@ namespace detail
             }
 
             std::string metaAttr;
-            metaAttr = ADIOS2Defaults::str_isBoolean + name;
+            metaAttr = adios_defaults::str_isBoolean + name;
             /*
              * In verbose mode, attributeInfo will yield a warning if not
              * finding the requested attribute. Since we expect the attribute
@@ -1862,7 +1862,7 @@ namespace detail
         else if constexpr (std::is_same_v<T, bool>)
         {
             IO.DefineAttribute<bool_representation>(
-                ADIOS2Defaults::str_isBoolean + fullName, 1);
+                adios_defaults::str_isBoolean + fullName, 1);
             auto representation = bool_repr::toRep(value);
             defineAttribute(representation);
         }

Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ FlushTarget flushTargetFromString(std::string const &str)`
`51`	`51`	`else`
`52`	`52`	`{`
`53`	`53`	`throw error::BackendConfigSchema(`
`54`		`- {"adios2", "engine", ADIOS2Defaults::str_flushtarget},`
	`54`	`+ {"adios2", "engine", adios_defaults::str_flushtarget},`
`55`	`55`	`"Flush target must be either 'disk' or 'buffer', but "`
`56`	`56`	`"was " +`
`57`	`57`	`str + ".");`
Original file line number	Diff line number	Diff line change
`@@ -494,10 +494,10 @@ void ADIOS2File::configure_IO()`
`494`	`494`	`// set engine parameters`
`495`	`495`	`std::set<std::string> alreadyConfigured;`
`496`	`496`	`bool wasTheFlushTargetSpecifiedViaJSON = false;`
`497`		`- auto engineConfig = m_impl->config(ADIOS2Defaults::str_engine);`
	`497`	`+ auto engineConfig = m_impl->config(adios_defaults::str_engine);`
`498`	`498`	`if (!engineConfig.json().is_null())`
`499`	`499`	`{`
`500`		`- auto params = m_impl->config(ADIOS2Defaults::str_params, engineConfig);`
	`500`	`+ auto params = m_impl->config(adios_defaults::str_params, engineConfig);`
`501`	`501`	`params.declareFullyRead();`
`502`	`502`	`if (params.json().is_object())`
`503`	`503`	`{`
`@@ -520,7 +520,7 @@ void ADIOS2File::configure_IO()`
`520`	`520`	`}`
`521`	`521`	`}`
`522`	`522`	`auto _useAdiosSteps =`
`523`		`- m_impl->config(ADIOS2Defaults::str_usesteps, engineConfig);`
	`523`	`+ m_impl->config(adios_defaults::str_usesteps, engineConfig);`
`524`	`524`	`if (!_useAdiosSteps.json().is_null() && writeOnly(m_mode))`
`525`	`525`	`{`
`526`	`526`	`std::cerr << "[ADIOS2 backend] WARNING: Parameter "`
`@@ -529,14 +529,14 @@ void ADIOS2File::configure_IO()`
`529`	`529`	`<< std::endl;`
`530`	`530`	`}`
`531`	`531`
`532`		`- if (engineConfig.json().contains(ADIOS2Defaults::str_flushtarget))`
	`532`	`+ if (engineConfig.json().contains(adios_defaults::str_flushtarget))`
`533`	`533`	`{`
`534`	`534`	`auto target = json::asLowerCaseStringDynamic(`
`535`		`- engineConfig[ADIOS2Defaults::str_flushtarget].json());`
	`535`	`+ engineConfig[adios_defaults::str_flushtarget].json());`
`536`	`536`	`if (!target.has_value())`
`537`	`537`	`{`
`538`	`538`	`throw error::BackendConfigSchema(`
`539`		`- {"adios2", "engine", ADIOS2Defaults::str_flushtarget},`
	`539`	`+ {"adios2", "engine", adios_defaults::str_flushtarget},`
`540`	`540`	`"Flush target must be either 'disk' or 'buffer', but "`
`541`	`541`	`"was non-literal type.");`
`542`	`542`	`}`
`@@ -713,10 +713,10 @@ auto ADIOS2File::detectGroupTable() -> UseGroupTable`
`713`	`713`	`{`
`714`	`714`	`auto const &attributes = availableAttributes();`
`715`	`715`	`auto lower_bound =`
`716`		`- attributes.lower_bound(ADIOS2Defaults::str_activeTablePrefix);`
	`716`	`+ attributes.lower_bound(adios_defaults::str_activeTablePrefix);`
`717`	`717`	`if (lower_bound != attributes.end() &&`
`718`	`718`	`auxiliary::starts_with(`
`719`		`- lower_bound->first, ADIOS2Defaults::str_activeTablePrefix))`
	`719`	`+ lower_bound->first, adios_defaults::str_activeTablePrefix))`
`720`	`720`	`{`
`721`	`721`	`return UseGroupTable::Yes;`
`722`	`722`	`}`
`@@ -819,7 +819,7 @@ adios2::Engine &ADIOS2File::getEngine()`
`819`	`819`	`{`
`820`	`820`	`case StreamStatus::Undecided: {`
`821`	`821`	`auto attr = m_IO.InquireAttribute<bool_representation>(`
`822`		`- ADIOS2Defaults::str_usesstepsAttribute);`
	`822`	`+ adios_defaults::str_usesstepsAttribute);`
`823`	`823`	`if (attr && attr.Data()[0] == 1)`
`824`	`824`	`{`
`825`	`825`	`if (parsePreference == ParsePreference::UpFront)`
`@@ -861,7 +861,7 @@ adios2::Engine &ADIOS2File::getEngine()`
`861`	`861`	`if (m_impl->m_useGroupTable.value() ==`
`862`	`862`	`UseGroupTable::No &&`
`863`	`863`	`m_IO.InquireAttribute<std::string>(`
`864`		`- ADIOS2Defaults::str_groupBasedWarning))`
	`864`	`+ adios_defaults::str_groupBasedWarning))`
`865`	`865`	`{`
`866`	`866`	`throw error::OperationUnsupportedInBackend(`
`867`	`867`	`"ADIOS2",`
`@@ -969,7 +969,7 @@ void ADIOS2File::flush_impl(`
`969`	`969`	`// Currently only schema 0 supported`
`970`	`970`	`if (m_impl->m_writeAttributesFromThisRank)`
`971`	`971`	`{`
`972`		`- m_IO.DefineAttribute<uint64_t>(ADIOS2Defaults::str_adios2Schema, 0);`
	`972`	`+ m_IO.DefineAttribute<uint64_t>(adios_defaults::str_adios2Schema, 0);`
`973`	`973`	`}`
`974`	`974`	`initializedDefaults = true;`
`975`	`975`	`}`
`@@ -1132,10 +1132,10 @@ AdvanceStatus ADIOS2File::advance(AdvanceMode mode)`
`1132`	`1132`
`1133`	`1133`	`if (writeOnly(m_mode) && m_impl->m_writeAttributesFromThisRank &&`
`1134`	`1134`	`!m_IO.InquireAttribute<bool_representation>(`
`1135`		`- ADIOS2Defaults::str_usesstepsAttribute))`
	`1135`	`+ adios_defaults::str_usesstepsAttribute))`
`1136`	`1136`	`{`
`1137`	`1137`	`m_IO.DefineAttribute<bool_representation>(`
`1138`		`- ADIOS2Defaults::str_usesstepsAttribute, 1);`
	`1138`	`+ adios_defaults::str_usesstepsAttribute, 1);`
`1139`	`1139`	`}`
`1140`	`1140`
`1141`	`1141`	`flush(`
`@@ -1281,7 +1281,7 @@ void ADIOS2File::markActive(Writable *writable)`
`1281`	`1281`	`auto filePos = m_impl->setAndGetFilePosition(`
`1282`	`1282`	`writable, /* write = */ false);`
`1283`	`1283`	`auto fullPath =`
`1284`		`- ADIOS2Defaults::str_activeTablePrefix + filePos->location;`
	`1284`	`+ adios_defaults::str_activeTablePrefix + filePos->location;`
`1285`	`1285`	`m_IO.DefineAttribute<attr_t>(`
`1286`	`1286`	`fullPath,`
`1287`	`1287`	`currentStepBuffered,`
Original file line number	Diff line number	Diff line change
`@@ -228,11 +228,11 @@ void ADIOS2IOHandlerImpl::init(`
`228`	`228`	`m_config["attribute_writing_ranks"].json());`
`229`	`229`	`}`
`230`	`230`
`231`		`- auto engineConfig = config(ADIOS2Defaults::str_engine);`
	`231`	`+ auto engineConfig = config(adios_defaults::str_engine);`
`232`	`232`	`if (!engineConfig.json().is_null())`
`233`	`233`	`{`
`234`	`234`	`auto engineTypeConfig =`
`235`		`- config(ADIOS2Defaults::str_type, engineConfig).json();`
	`235`	`+ config(adios_defaults::str_type, engineConfig).json();`
`236`	`236`	`if (!engineTypeConfig.is_null())`
`237`	`237`	`{`
`238`	`238`	`// convert to string`
`@@ -468,14 +468,14 @@ ADIOS2IOHandlerImpl::flush(internal::ParsedFlushParams &flushParams)`
`468`	`468`	`if (adios2Config.json().contains("engine"))`
`469`	`469`	`{`
`470`	`470`	`auto engineConfig = adios2Config["engine"];`
`471`		`- if (engineConfig.json().contains(ADIOS2Defaults::str_flushtarget))`
	`471`	`+ if (engineConfig.json().contains(adios_defaults::str_flushtarget))`
`472`	`472`	`{`
`473`	`473`	`auto target = json::asLowerCaseStringDynamic(`
`474`		`- engineConfig[ADIOS2Defaults::str_flushtarget].json());`
	`474`	`+ engineConfig[adios_defaults::str_flushtarget].json());`
`475`	`475`	`if (!target.has_value())`
`476`	`476`	`{`
`477`	`477`	`throw error::BackendConfigSchema(`
`478`		`- {"adios2", "engine", ADIOS2Defaults::str_flushtarget},`
	`478`	`+ {"adios2", "engine", adios_defaults::str_flushtarget},`
`479`	`479`	`"Flush target must be either 'disk' or 'buffer', but "`
`480`	`480`	`"was non-literal type.");`
`481`	`481`	`}`
`@@ -604,7 +604,7 @@ void ADIOS2IOHandlerImpl::createFile(`
`604`	`604`	`printedWarningsAlready.noGroupBased = true;`
`605`	`605`	`}`
`606`	`606`	`fileData.m_IO.DefineAttribute(`
`607`		`- ADIOS2Defaults::str_groupBasedWarning,`
	`607`	`+ adios_defaults::str_groupBasedWarning,`
`608`	`608`	`std::string("Consider using file-based or variable-based "`
`609`	`609`	`"encoding instead in ADIOS2."));`
`610`	`610`	`}`
`@@ -1247,7 +1247,7 @@ void ADIOS2IOHandlerImpl::listPaths(`
`1247`	`1247`	`}`
`1248`	`1248`	`case UseGroupTable::Yes: {`
`1249`	`1249`	`{`
`1250`		`- auto tablePrefix = ADIOS2Defaults::str_activeTablePrefix + myName;`
	`1250`	`+ auto tablePrefix = adios_defaults::str_activeTablePrefix + myName;`
`1251`	`1251`	`std::vector attrs =`
`1252`	`1252`	`fileData.availableAttributesPrefixed(tablePrefix);`
`1253`	`1253`	`if (fileData.streamStatus ==`
`@@ -1628,7 +1628,7 @@ namespace detail`
`1628`	`1628`	`}`
`1629`	`1629`
`1630`	`1630`	`std::string metaAttr;`
`1631`		`- metaAttr = ADIOS2Defaults::str_isBoolean + name;`
	`1631`	`+ metaAttr = adios_defaults::str_isBoolean + name;`
`1632`	`1632`	`/*`
`1633`	`1633`	`* In verbose mode, attributeInfo will yield a warning if not`
`1634`	`1634`	`* finding the requested attribute. Since we expect the attribute`
`@@ -1862,7 +1862,7 @@ namespace detail`
`1862`	`1862`	`else if constexpr (std::is_same_v<T, bool>)`
`1863`	`1863`	`{`
`1864`	`1864`	`IO.DefineAttribute<bool_representation>(`
`1865`		`- ADIOS2Defaults::str_isBoolean + fullName, 1);`
	`1865`	`+ adios_defaults::str_isBoolean + fullName, 1);`
`1866`	`1866`	`auto representation = bool_repr::toRep(value);`
`1867`	`1867`	`defineAttribute(representation);`
`1868`	`1868`	`}`