From 6340bd45022a2e0fda8a0213b269a02880cf82b1 Mon Sep 17 00:00:00 2001
From: "Yu-Hsiang M. Tsai" <yhmtsai@gmail.com>
Date: Wed, 9 Aug 2023 16:55:02 +0200
Subject: [PATCH 01/25] try

---
 core/CMakeLists.txt                     |   1 +
 core/config/config.cpp                  |  63 ++++++++
 core/solver/cg.cpp                      |  35 +++++
 core/test/config/CMakeLists.txt         |   1 +
 core/test/config/config.cpp             | 157 ++++++++++++++++++++
 include/ginkgo/core/config/config.hpp   |  74 +++++++++
 include/ginkgo/core/config/registry.hpp | 190 ++++++++++++++++++++++++
 include/ginkgo/core/solver/cg.hpp       |  17 +++
 8 files changed, 538 insertions(+)
 create mode 100644 core/config/config.cpp
 create mode 100644 core/test/config/config.cpp
 create mode 100644 include/ginkgo/core/config/config.hpp
 create mode 100644 include/ginkgo/core/config/registry.hpp

diff --git a/core/CMakeLists.txt b/core/CMakeLists.txt
index ac15a869e79..a8142f1c72d 100644
--- a/core/CMakeLists.txt
+++ b/core/CMakeLists.txt
@@ -19,6 +19,7 @@ target_sources(ginkgo
     base/segmented_array.cpp
     base/timer.cpp
     base/version.cpp
+    config/config.cpp
     config/property_tree.cpp
     distributed/index_map.cpp
     distributed/partition.cpp
diff --git a/core/config/config.cpp b/core/config/config.cpp
new file mode 100644
index 00000000000..667ffc51e6a
--- /dev/null
+++ b/core/config/config.cpp
@@ -0,0 +1,63 @@
+/*******************************<GINKGO LICENSE>******************************
+Copyright (c) 2017-2023, the Ginkgo authors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+******************************<GINKGO LICENSE>*******************************/
+
+#include <ginkgo/core/config/config.hpp>
+
+
+#include <map>
+
+
+namespace gko {
+namespace config {
+
+
+BuildFromConfigMap generate_config_map()
+{
+    return {{"Cg", build_from_config<static_cast<int>(LinOpFactoryType::Cg)>}};
+}
+
+
+std::unique_ptr<gko::LinOpFactory> build_from_config(
+    const gko::config::Config& config, std::shared_ptr<const Executor>& exec,
+    const gko::config::registry& context)
+{
+    auto type = config.find("Type");
+    if (type != config.end()) {
+        auto func = context.get_build_map().at(type->second);
+        return func(config, exec, context);
+    }
+    return nullptr;
+}
+
+
+}  // namespace config
+}  // namespace gko
diff --git a/core/solver/cg.cpp b/core/solver/cg.cpp
index e445cfcafaf..7d1821e19e0 100644
--- a/core/solver/cg.cpp
+++ b/core/solver/cg.cpp
@@ -12,6 +12,8 @@
 #include <ginkgo/core/base/name_demangling.hpp>
 #include <ginkgo/core/base/precision_dispatch.hpp>
 #include <ginkgo/core/base/utils.hpp>
+#include <ginkgo/core/config/config.hpp>
+#include <ginkgo/core/stop/iteration.hpp>
 
 
 #include "core/distributed/helpers.hpp"
@@ -20,6 +22,39 @@
 
 
 namespace gko {
+namespace config {
+
+
+template <>
+std::unique_ptr<gko::LinOpFactory>
+build_from_config<static_cast<int>(gko::config::LinOpFactoryType::Cg)>(
+    const gko::config::Config& config, std::shared_ptr<const Executor>& exec,
+    const gko::config::registry& context)
+{
+    // TODO: select the type, always using double as demo.
+    // extract the following to another function (or build_from_config) to make
+    // this function only select type
+    auto factory = gko::solver::Cg<double>::build_from_config(config, context);
+    // handle parameter requires exec
+    // criteria and preconditioner are almost in each solver -> to another
+    // function.
+    factory.with_criteria(
+        gko::stop::Iteration::build().with_max_iters(1u).on(exec));
+    {
+        auto str = config.find("preconditioner");
+        if (str != config.end()) {
+            // assume we have the config for nest object
+            factory.with_preconditioner(build_from_config(
+                Config{{"Type", str->second}}, exec, context));
+        }
+    }
+    return std::move(factory.on(exec));
+}
+
+
+}  // namespace config
+
+
 namespace solver {
 namespace cg {
 namespace {
diff --git a/core/test/config/CMakeLists.txt b/core/test/config/CMakeLists.txt
index e842152634c..95ad05582cb 100644
--- a/core/test/config/CMakeLists.txt
+++ b/core/test/config/CMakeLists.txt
@@ -1 +1,2 @@
+ginkgo_create_test(config)
 ginkgo_create_test(property_tree)
diff --git a/core/test/config/config.cpp b/core/test/config/config.cpp
new file mode 100644
index 00000000000..8fa0df62fd2
--- /dev/null
+++ b/core/test/config/config.cpp
@@ -0,0 +1,157 @@
+/*******************************<GINKGO LICENSE>******************************
+Copyright (c) 2017-2023, the Ginkgo authors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+******************************<GINKGO LICENSE>*******************************/
+
+#include <ginkgo/core/config/config.hpp>
+
+
+#include <typeinfo>
+
+
+#include <gtest/gtest.h>
+
+
+#include <ginkgo/core/base/executor.hpp>
+#include <ginkgo/core/matrix/dense.hpp>
+#include <ginkgo/core/solver/bicg.hpp>
+#include <ginkgo/core/solver/cg.hpp>
+#include <ginkgo/core/stop/combined.hpp>
+#include <ginkgo/core/stop/iteration.hpp>
+#include <ginkgo/core/stop/residual_norm.hpp>
+
+
+#include "core/test/utils.hpp"
+
+
+namespace {
+
+
+template <typename T>
+class Config : public ::testing::Test {
+protected:
+    using value_type = double;
+    using Mtx = gko::matrix::Dense<value_type>;
+    Config()
+        : exec(gko::ReferenceExecutor::create()),
+          mtx(gko::initialize<Mtx>(
+              {{2, -1.0, 0.0}, {-1.0, 2, -1.0}, {0.0, -1.0, 2}}, exec))
+    {}
+
+    std::shared_ptr<const gko::Executor> exec;
+    std::shared_ptr<Mtx> mtx;
+};
+
+TYPED_TEST_SUITE(Config, gko::test::ValueTypes, TypenameNameGenerator);
+
+
+TYPED_TEST(Config, GenerateMap)
+{
+    ASSERT_NO_THROW(gko::config::generate_config_map());
+}
+
+
+TYPED_TEST(Config, GenerateObject)
+{
+    auto config_map = gko::config::generate_config_map();
+    auto reg = gko::config::registry(config_map);
+
+    auto obj = gko::config::build_from_config<0>(gko::config::Config{},
+                                                 this->exec, reg);
+
+    ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get()),
+              nullptr);
+}
+
+
+TYPED_TEST(Config, GenerateObjectWithData)
+{
+    auto config_map = gko::config::generate_config_map();
+    auto reg = gko::config::registry(config_map);
+    reg.emplace("precond", this->mtx);
+
+    auto obj = gko::config::build_from_config<0>(
+        gko::config::Config{{"generated_preconditioner", "precond"}},
+        this->exec, reg);
+
+    ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get()),
+              nullptr);
+    ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get())
+                  ->get_parameters()
+                  .generated_preconditioner,
+              nullptr);
+}
+
+
+TYPED_TEST(Config, GenerateObjectWithPreconditioner)
+{
+    auto config_map = gko::config::generate_config_map();
+    auto reg = gko::config::registry(config_map);
+
+    auto obj = gko::config::build_from_config<0>(
+        gko::config::Config{{"preconditioner", "Cg"}}, this->exec, reg);
+
+    ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get()),
+              nullptr);
+    ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get())
+                  ->get_parameters()
+                  .preconditioner,
+              nullptr);
+}
+
+
+TYPED_TEST(Config, GenerateObjectWithCustomBuild)
+{
+    auto config_map = gko::config::generate_config_map();
+
+    config_map["Custom"] = [](const gko::config::Config& config,
+                              std::shared_ptr<const gko::Executor>& exec,
+                              const gko::config::registry& context) {
+        return gko::solver::Bicg<double>::build()
+            .with_criteria(
+                gko::stop::Iteration::build().with_max_iters(2u).on(exec))
+            .on(exec);
+    };
+    auto reg = gko::config::registry(config_map);
+
+    auto obj = gko::config::build_from_config<0>(
+        gko::config::Config{{"preconditioner", "Custom"}}, this->exec, reg);
+
+    ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get()),
+              nullptr);
+    ASSERT_NE(dynamic_cast<const gko::solver::Bicg<double>::Factory*>(
+                  dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get())
+                      ->get_parameters()
+                      .preconditioner.get()),
+              nullptr);
+}
+
+
+}  // namespace
diff --git a/include/ginkgo/core/config/config.hpp b/include/ginkgo/core/config/config.hpp
new file mode 100644
index 00000000000..d8a07a5e914
--- /dev/null
+++ b/include/ginkgo/core/config/config.hpp
@@ -0,0 +1,74 @@
+/*******************************<GINKGO LICENSE>******************************
+Copyright (c) 2017-2023, the Ginkgo authors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+******************************<GINKGO LICENSE>*******************************/
+
+#ifndef GKO_PUBLIC_CORE_CONFIG_CONFIG_HPP_
+#define GKO_PUBLIC_CORE_CONFIG_CONFIG_HPP_
+
+
+#include <map>
+#include <string>
+#include <unordered_map>
+
+
+#include <ginkgo/core/base/lin_op.hpp>
+#include <ginkgo/core/base/types.hpp>
+#include <ginkgo/core/config/registry.hpp>
+
+
+namespace gko {
+namespace config {
+
+
+enum LinOpFactoryType : int { Cg = 0 };
+
+
+// It is only an intermediate step. If we do not provide the SolverType with VT,
+// IT selection, we do not need it in public.
+template <int flag>
+std::unique_ptr<gko::LinOpFactory> build_from_config(
+    const gko::config::Config& config, std::shared_ptr<const Executor>& exec,
+    const gko::config::registry& context);
+
+// The main function
+std::unique_ptr<gko::LinOpFactory> build_from_config(
+    const gko::config::Config& config, std::shared_ptr<const Executor>& exec,
+    const gko::config::registry& context);
+
+
+BuildFromConfigMap generate_config_map();
+
+
+}  // namespace config
+}  // namespace gko
+
+
+#endif  // GKO_PUBLIC_CORE_CONFIG_CONFIG_HPP_
diff --git a/include/ginkgo/core/config/registry.hpp b/include/ginkgo/core/config/registry.hpp
new file mode 100644
index 00000000000..9db9122f24e
--- /dev/null
+++ b/include/ginkgo/core/config/registry.hpp
@@ -0,0 +1,190 @@
+/*******************************<GINKGO LICENSE>******************************
+Copyright (c) 2017-2023, the Ginkgo authors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+******************************<GINKGO LICENSE>*******************************/
+
+#ifndef GKO_PUBLIC_CORE_CONFIG_REGISTRY_HPP_
+#define GKO_PUBLIC_CORE_CONFIG_REGISTRY_HPP_
+
+
+#include <map>
+#include <string>
+#include <unordered_map>
+
+
+#include <ginkgo/core/base/lin_op.hpp>
+#include <ginkgo/core/base/types.hpp>
+
+
+namespace gko {
+namespace config {
+
+
+using LinOpMap = std::unordered_map<std::string, std::shared_ptr<LinOp>>;
+using LinOpFactoryMap =
+    std::unordered_map<std::string, std::shared_ptr<LinOpFactory>>;
+using Config = std::map<std::string, std::string>;
+class registry;
+using BuildFunctionType = std::function<std::unique_ptr<gko::LinOpFactory>(
+    const Config&, std::shared_ptr<const Executor>&, const registry&)>;
+using BuildFromConfigMap = std::map<std::string, BuildFunctionType>;
+
+/**
+ * map_type gives the map type according to the base type of given type.
+ *
+ * @tparam T  the type
+ */
+template <typename T, typename = void>
+struct map_type {
+    using type = void;
+};
+
+template <typename T>
+struct map_type<
+    T, typename std::enable_if<std::is_convertible<T*, LinOp*>::value>::type> {
+    using type = LinOpMap;
+};
+
+template <typename T>
+struct map_type<T, typename std::enable_if<
+                       std::is_convertible<T*, LinOpFactory*>::value>::type> {
+    using type = LinOpFactoryMap;
+};
+
+
+class registry {
+public:
+    registry(BuildFromConfigMap build_map) : build_map_(build_map) {}
+
+    /**
+     * insert_data stores the data with the key.
+     *
+     * @tparam T  the type
+     *
+     * @param key  the unique key string
+     * @param data  the shared pointer of the object
+     */
+    template <typename T>
+    void emplace(std::string key, std::shared_ptr<T> data)
+    {
+        this->get_map<T>().emplace(key, data);
+    }
+
+    /**
+     * search_data searches the key on the corresponding map.
+     *
+     * @tparam T  the type
+     *
+     * @param key  the key string
+     *
+     * @return the shared pointer of the object
+     */
+    template <typename T>
+    std::shared_ptr<T> search_data(std::string key) const
+    {
+        auto idx = this->get_map<T>().find(key);
+        if (idx != this->get_map<T>().end()) {
+            return std::dynamic_pointer_cast<T>(idx->second);
+        }
+        // or throw the error
+        return nullptr;
+    }
+
+    const BuildFromConfigMap& get_build_map() const { return build_map_; }
+
+    /**
+     * get_map gets the member map
+     *
+     * @tparam T  the type
+     *
+     * @return the map
+     */
+    template <typename T>
+    typename map_type<T>::type& get_map()
+    {
+        return this->get_map_impl<typename map_type<T>::type>();
+    }
+
+    template <typename T>
+    const typename map_type<T>::type& get_map() const
+    {
+        return this->get_map_impl<typename map_type<T>::type>();
+    }
+
+protected:
+    /**
+     * get_map_impl is the implementation of get_map
+     *
+     * @tparam T  the map type
+     *
+     * @return the map
+     */
+    template <typename T>
+    T& get_map_impl();
+
+    template <typename T>
+    const T& get_map_impl() const;
+
+private:
+    LinOpMap linop_map_;
+    LinOpFactoryMap linopfactory_map_;
+    BuildFromConfigMap build_map_;
+};
+
+
+template <>
+inline LinOpMap& registry::get_map_impl<LinOpMap>()
+{
+    return linop_map_;
+}
+
+template <>
+inline LinOpFactoryMap& registry::get_map_impl<LinOpFactoryMap>()
+{
+    return linopfactory_map_;
+}
+
+template <>
+inline const LinOpMap& registry::get_map_impl<LinOpMap>() const
+{
+    return linop_map_;
+}
+
+template <>
+inline const LinOpFactoryMap& registry::get_map_impl<LinOpFactoryMap>() const
+{
+    return linopfactory_map_;
+}
+
+
+}  // namespace config
+}  // namespace gko
+
+#endif  // GKO_PUBLIC_CORE_CONFIG_REGISTRY_HPP_
diff --git a/include/ginkgo/core/solver/cg.hpp b/include/ginkgo/core/solver/cg.hpp
index a56e543d5ca..c337516a9a0 100644
--- a/include/ginkgo/core/solver/cg.hpp
+++ b/include/ginkgo/core/solver/cg.hpp
@@ -14,6 +14,7 @@
 #include <ginkgo/core/base/lin_op.hpp>
 #include <ginkgo/core/base/math.hpp>
 #include <ginkgo/core/base/types.hpp>
+#include <ginkgo/core/config/registry.hpp>
 #include <ginkgo/core/log/logger.hpp>
 #include <ginkgo/core/matrix/dense.hpp>
 #include <ginkgo/core/matrix/identity.hpp>
@@ -72,6 +73,22 @@ class Cg : public EnableLinOp<Cg<ValueType>>,
 
     GKO_ENABLE_LIN_OP_FACTORY(Cg, parameters, Factory);
     GKO_ENABLE_BUILD_METHOD(Factory);
+    static auto build_from_config(const gko::config::Config& config,
+                                  const gko::config::registry& context)
+        -> decltype(Factory::create())
+    {
+        auto factory = Factory::create();
+        {
+            auto str = config.find("generated_preconditioner");
+            if (str != config.end()) {
+                auto linop = context.search_data<gko::LinOp>(str->second);
+                factory.with_generated_preconditioner(linop);
+            }
+        }
+        // can also handle preconditioner, criterion here if they are in
+        // context.
+        return factory;
+    }
 
 protected:
     void apply_impl(const LinOp* b, LinOp* x) const override;

From 70f098e6904bcedcf7abea1c159a3303c81eb72d Mon Sep 17 00:00:00 2001
From: "Yu-Hsiang M. Tsai" <yhmtsai@gmail.com>
Date: Thu, 10 Aug 2023 16:16:48 +0200
Subject: [PATCH 02/25] change the order and put it into protected

---
 core/config/config.cpp                  |  8 ++--
 core/solver/cg.cpp                      | 60 +++++++++++++++++++------
 core/test/config/config.cpp             | 16 +++----
 include/ginkgo/core/config/config.hpp   |  8 ++--
 include/ginkgo/core/config/registry.hpp |  2 +-
 include/ginkgo/core/solver/cg.hpp       | 25 ++++-------
 6 files changed, 72 insertions(+), 47 deletions(-)

diff --git a/core/config/config.cpp b/core/config/config.cpp
index 667ffc51e6a..412ee2240ca 100644
--- a/core/config/config.cpp
+++ b/core/config/config.cpp
@@ -42,18 +42,18 @@ namespace config {
 
 BuildFromConfigMap generate_config_map()
 {
-    return {{"Cg", build_from_config<static_cast<int>(LinOpFactoryType::Cg)>}};
+    return {{"Cg", build_from_config<LinOpFactoryType::Cg>}};
 }
 
 
 std::unique_ptr<gko::LinOpFactory> build_from_config(
-    const gko::config::Config& config, std::shared_ptr<const Executor>& exec,
-    const gko::config::registry& context)
+    const gko::config::Config& config, const gko::config::registry& context,
+    std::shared_ptr<const Executor>& exec)
 {
     auto type = config.find("Type");
     if (type != config.end()) {
         auto func = context.get_build_map().at(type->second);
-        return func(config, exec, context);
+        return func(config, context, exec);
     }
     return nullptr;
 }
diff --git a/core/solver/cg.cpp b/core/solver/cg.cpp
index 7d1821e19e0..f0a1e5ffb15 100644
--- a/core/solver/cg.cpp
+++ b/core/solver/cg.cpp
@@ -28,27 +28,27 @@ namespace config {
 template <>
 std::unique_ptr<gko::LinOpFactory>
 build_from_config<static_cast<int>(gko::config::LinOpFactoryType::Cg)>(
-    const gko::config::Config& config, std::shared_ptr<const Executor>& exec,
-    const gko::config::registry& context)
+    const gko::config::Config& config, const gko::config::registry& context,
+    std::shared_ptr<const Executor>& exec)
 {
     // TODO: select the type, always using double as demo.
     // extract the following to another function (or build_from_config) to make
     // this function only select type
-    auto factory = gko::solver::Cg<double>::build_from_config(config, context);
-    // handle parameter requires exec
-    // criteria and preconditioner are almost in each solver -> to another
-    // function.
-    factory.with_criteria(
-        gko::stop::Iteration::build().with_max_iters(1u).on(exec));
+    std::string val_str = "double";  // get from default pack
     {
-        auto str = config.find("preconditioner");
-        if (str != config.end()) {
-            // assume we have the config for nest object
-            factory.with_preconditioner(build_from_config(
-                Config{{"Type", str->second}}, exec, context));
+        auto it = config.find("ValueType");
+        if (it != config.end()) {
+            val_str = it->second;
         }
     }
-    return std::move(factory.on(exec));
+    if (val_str == "double") {
+        return gko::solver::Cg<double>::build_from_config(config, context,
+                                                          exec);
+    } else if (val_str == "float") {
+        return gko::solver::Cg<float>::build_from_config(config, context, exec);
+    }
+
+    return nullptr;
 }
 
 
@@ -68,6 +68,38 @@ GKO_REGISTER_OPERATION(step_2, cg::step_2);
 }  // anonymous namespace
 }  // namespace cg
 
+template <typename ValueType>
+std::unique_ptr<typename Cg<ValueType>::Factory>
+Cg<ValueType>::build_from_config(const gko::config::Config& config,
+                                 const gko::config::registry& context,
+                                 std::shared_ptr<const Executor> exec)
+{
+    auto factory = Factory::create();
+    {
+        auto str = config.find("generated_preconditioner");
+        if (str != config.end()) {
+            auto linop = context.search_data<gko::LinOp>(str->second);
+            factory.with_generated_preconditioner(linop);
+        }
+    }
+    // handle parameter requires exec
+    // criteria and preconditioner are almost in each solver -> to another
+    // function.
+    factory.with_criteria(
+        gko::stop::Iteration::build().with_max_iters(1u).on(exec));
+    {
+        auto str = config.find("preconditioner");
+        if (str != config.end()) {
+            // assume we have the config for nest object
+            factory.with_preconditioner(gko::config::build_from_config(
+                gko::config::Config{{"Type", str->second}}, context, exec));
+        }
+    }
+    // can also handle preconditioner, criterion here if they are in
+    // context.
+    return factory.on(exec);
+}
+
 
 template <typename ValueType>
 std::unique_ptr<LinOp> Cg<ValueType>::transpose() const
diff --git a/core/test/config/config.cpp b/core/test/config/config.cpp
index 8fa0df62fd2..b18907e57f8 100644
--- a/core/test/config/config.cpp
+++ b/core/test/config/config.cpp
@@ -83,8 +83,8 @@ TYPED_TEST(Config, GenerateObject)
     auto config_map = gko::config::generate_config_map();
     auto reg = gko::config::registry(config_map);
 
-    auto obj = gko::config::build_from_config<0>(gko::config::Config{},
-                                                 this->exec, reg);
+    auto obj = gko::config::build_from_config<0>(gko::config::Config{}, reg,
+                                                 this->exec);
 
     ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get()),
               nullptr);
@@ -98,8 +98,8 @@ TYPED_TEST(Config, GenerateObjectWithData)
     reg.emplace("precond", this->mtx);
 
     auto obj = gko::config::build_from_config<0>(
-        gko::config::Config{{"generated_preconditioner", "precond"}},
-        this->exec, reg);
+        gko::config::Config{{"generated_preconditioner", "precond"}}, reg,
+        this->exec);
 
     ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get()),
               nullptr);
@@ -116,7 +116,7 @@ TYPED_TEST(Config, GenerateObjectWithPreconditioner)
     auto reg = gko::config::registry(config_map);
 
     auto obj = gko::config::build_from_config<0>(
-        gko::config::Config{{"preconditioner", "Cg"}}, this->exec, reg);
+        gko::config::Config{{"preconditioner", "Cg"}}, reg, this->exec);
 
     ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get()),
               nullptr);
@@ -132,8 +132,8 @@ TYPED_TEST(Config, GenerateObjectWithCustomBuild)
     auto config_map = gko::config::generate_config_map();
 
     config_map["Custom"] = [](const gko::config::Config& config,
-                              std::shared_ptr<const gko::Executor>& exec,
-                              const gko::config::registry& context) {
+                              const gko::config::registry& context,
+                              std::shared_ptr<const gko::Executor>& exec) {
         return gko::solver::Bicg<double>::build()
             .with_criteria(
                 gko::stop::Iteration::build().with_max_iters(2u).on(exec))
@@ -142,7 +142,7 @@ TYPED_TEST(Config, GenerateObjectWithCustomBuild)
     auto reg = gko::config::registry(config_map);
 
     auto obj = gko::config::build_from_config<0>(
-        gko::config::Config{{"preconditioner", "Custom"}}, this->exec, reg);
+        gko::config::Config{{"preconditioner", "Custom"}}, reg, this->exec);
 
     ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get()),
               nullptr);
diff --git a/include/ginkgo/core/config/config.hpp b/include/ginkgo/core/config/config.hpp
index d8a07a5e914..3df7d43b1a2 100644
--- a/include/ginkgo/core/config/config.hpp
+++ b/include/ginkgo/core/config/config.hpp
@@ -55,13 +55,13 @@ enum LinOpFactoryType : int { Cg = 0 };
 // IT selection, we do not need it in public.
 template <int flag>
 std::unique_ptr<gko::LinOpFactory> build_from_config(
-    const gko::config::Config& config, std::shared_ptr<const Executor>& exec,
-    const gko::config::registry& context);
+    const gko::config::Config& config, const gko::config::registry& context,
+    std::shared_ptr<const Executor>& exec);
 
 // The main function
 std::unique_ptr<gko::LinOpFactory> build_from_config(
-    const gko::config::Config& config, std::shared_ptr<const Executor>& exec,
-    const gko::config::registry& context);
+    const gko::config::Config& config, const gko::config::registry& context,
+    std::shared_ptr<const Executor>& exec);
 
 
 BuildFromConfigMap generate_config_map();
diff --git a/include/ginkgo/core/config/registry.hpp b/include/ginkgo/core/config/registry.hpp
index 9db9122f24e..160a903a200 100644
--- a/include/ginkgo/core/config/registry.hpp
+++ b/include/ginkgo/core/config/registry.hpp
@@ -53,7 +53,7 @@ using LinOpFactoryMap =
 using Config = std::map<std::string, std::string>;
 class registry;
 using BuildFunctionType = std::function<std::unique_ptr<gko::LinOpFactory>(
-    const Config&, std::shared_ptr<const Executor>&, const registry&)>;
+    const Config&, const registry&, std::shared_ptr<const Executor>&)>;
 using BuildFromConfigMap = std::map<std::string, BuildFunctionType>;
 
 /**
diff --git a/include/ginkgo/core/solver/cg.hpp b/include/ginkgo/core/solver/cg.hpp
index c337516a9a0..d8c33a905bc 100644
--- a/include/ginkgo/core/solver/cg.hpp
+++ b/include/ginkgo/core/solver/cg.hpp
@@ -14,6 +14,7 @@
 #include <ginkgo/core/base/lin_op.hpp>
 #include <ginkgo/core/base/math.hpp>
 #include <ginkgo/core/base/types.hpp>
+#include <ginkgo/core/config/config.hpp>
 #include <ginkgo/core/config/registry.hpp>
 #include <ginkgo/core/log/logger.hpp>
 #include <ginkgo/core/matrix/dense.hpp>
@@ -49,6 +50,10 @@ class Cg : public EnableLinOp<Cg<ValueType>>,
            public Transposable {
     friend class EnableLinOp<Cg>;
     friend class EnablePolymorphicObject<Cg, LinOp>;
+    friend std::unique_ptr<LinOpFactory> gko::config::build_from_config<
+        static_cast<int>(gko::config::LinOpFactoryType::Cg)>(
+        const gko::config::Config&, const gko::config::registry&,
+        std::shared_ptr<const Executor>&);
 
 public:
     using value_type = ValueType;
@@ -73,24 +78,12 @@ class Cg : public EnableLinOp<Cg<ValueType>>,
 
     GKO_ENABLE_LIN_OP_FACTORY(Cg, parameters, Factory);
     GKO_ENABLE_BUILD_METHOD(Factory);
-    static auto build_from_config(const gko::config::Config& config,
-                                  const gko::config::registry& context)
-        -> decltype(Factory::create())
-    {
-        auto factory = Factory::create();
-        {
-            auto str = config.find("generated_preconditioner");
-            if (str != config.end()) {
-                auto linop = context.search_data<gko::LinOp>(str->second);
-                factory.with_generated_preconditioner(linop);
-            }
-        }
-        // can also handle preconditioner, criterion here if they are in
-        // context.
-        return factory;
-    }
 
 protected:
+    static std::unique_ptr<Factory> build_from_config(
+        const gko::config::Config& config, const gko::config::registry& context,
+        std::shared_ptr<const Executor> exec);
+
     void apply_impl(const LinOp* b, LinOp* x) const override;
 
     template <typename VectorType>

From 284afede4c5ab4a7bb172db96c259082687fac13 Mon Sep 17 00:00:00 2001
From: "Yuhsiang M. Tsai" <yhmtsai@gmail.com>
Date: Fri, 11 Aug 2023 12:24:58 +0200
Subject: [PATCH 03/25] add type descripitor

---
 core/config/config.cpp                  |  4 +--
 core/solver/cg.cpp                      | 26 +++++++++++-----
 core/test/config/config.cpp             | 40 +++++++++++++++++++------
 include/ginkgo/core/config/config.hpp   |  6 ++--
 include/ginkgo/core/config/registry.hpp | 23 +++++++++++++-
 include/ginkgo/core/solver/cg.hpp       |  6 ++--
 6 files changed, 81 insertions(+), 24 deletions(-)

diff --git a/core/config/config.cpp b/core/config/config.cpp
index 412ee2240ca..419ba2abbcf 100644
--- a/core/config/config.cpp
+++ b/core/config/config.cpp
@@ -48,12 +48,12 @@ BuildFromConfigMap generate_config_map()
 
 std::unique_ptr<gko::LinOpFactory> build_from_config(
     const gko::config::Config& config, const gko::config::registry& context,
-    std::shared_ptr<const Executor>& exec)
+    std::shared_ptr<const Executor>& exec, TypeDescriptor td)
 {
     auto type = config.find("Type");
     if (type != config.end()) {
         auto func = context.get_build_map().at(type->second);
-        return func(config, context, exec);
+        return func(config, context, exec, td);
     }
     return nullptr;
 }
diff --git a/core/solver/cg.cpp b/core/solver/cg.cpp
index f0a1e5ffb15..68886f16605 100644
--- a/core/solver/cg.cpp
+++ b/core/solver/cg.cpp
@@ -29,23 +29,33 @@ template <>
 std::unique_ptr<gko::LinOpFactory>
 build_from_config<static_cast<int>(gko::config::LinOpFactoryType::Cg)>(
     const gko::config::Config& config, const gko::config::registry& context,
-    std::shared_ptr<const Executor>& exec)
+    std::shared_ptr<const Executor>& exec, gko::config::TypeDescriptor td)
 {
     // TODO: select the type, always using double as demo.
     // extract the following to another function (or build_from_config) to make
     // this function only select type
-    std::string val_str = "double";  // get from default pack
+    std::string val_str = td.first;  // get from default pack
     {
         auto it = config.find("ValueType");
         if (it != config.end()) {
             val_str = it->second;
         }
+        // propagate the type
+        td.first = val_str;
     }
+    // the following can be handled by auto selection. maybe reuse the macro?
     if (val_str == "double") {
-        return gko::solver::Cg<double>::build_from_config(config, context,
-                                                          exec);
+        return gko::solver::Cg<double>::build_from_config(config, context, exec,
+                                                          td);
     } else if (val_str == "float") {
-        return gko::solver::Cg<float>::build_from_config(config, context, exec);
+        return gko::solver::Cg<float>::build_from_config(config, context, exec,
+                                                         td);
+    } else if (val_str == "complex<double>") {
+        return gko::solver::Cg<std::complex<double>>::build_from_config(
+            config, context, exec, td);
+    } else if (val_str == "complex<float>") {
+        return gko::solver::Cg<std::complex<float>>::build_from_config(
+            config, context, exec, td);
     }
 
     return nullptr;
@@ -72,7 +82,8 @@ template <typename ValueType>
 std::unique_ptr<typename Cg<ValueType>::Factory>
 Cg<ValueType>::build_from_config(const gko::config::Config& config,
                                  const gko::config::registry& context,
-                                 std::shared_ptr<const Executor> exec)
+                                 std::shared_ptr<const Executor> exec,
+                                 gko::config::TypeDescriptor td_for_child)
 {
     auto factory = Factory::create();
     {
@@ -92,7 +103,8 @@ Cg<ValueType>::build_from_config(const gko::config::Config& config,
         if (str != config.end()) {
             // assume we have the config for nest object
             factory.with_preconditioner(gko::config::build_from_config(
-                gko::config::Config{{"Type", str->second}}, context, exec));
+                gko::config::Config{{"Type", str->second}}, context, exec,
+                td_for_child));
         }
     }
     // can also handle preconditioner, criterion here if they are in
diff --git a/core/test/config/config.cpp b/core/test/config/config.cpp
index b18907e57f8..351511312f7 100644
--- a/core/test/config/config.cpp
+++ b/core/test/config/config.cpp
@@ -78,13 +78,13 @@ TYPED_TEST(Config, GenerateMap)
 }
 
 
-TYPED_TEST(Config, GenerateObject)
+TYPED_TEST(Config, GenerateObjectWithoutDefault)
 {
     auto config_map = gko::config::generate_config_map();
     auto reg = gko::config::registry(config_map);
 
-    auto obj = gko::config::build_from_config<0>(gko::config::Config{}, reg,
-                                                 this->exec);
+    auto obj = gko::config::build_from_config<0>(
+        gko::config::Config{{"ValueType", "double"}}, reg, this->exec);
 
     ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get()),
               nullptr);
@@ -99,16 +99,35 @@ TYPED_TEST(Config, GenerateObjectWithData)
 
     auto obj = gko::config::build_from_config<0>(
         gko::config::Config{{"generated_preconditioner", "precond"}}, reg,
-        this->exec);
+        this->exec, {"float", ""});
 
-    ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get()),
+    ASSERT_NE(dynamic_cast<gko::solver::Cg<float>::Factory*>(obj.get()),
               nullptr);
-    ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get())
+    ASSERT_NE(dynamic_cast<gko::solver::Cg<float>::Factory*>(obj.get())
                   ->get_parameters()
                   .generated_preconditioner,
               nullptr);
 }
 
+// it is under protected namespace
+// TYPED_TEST(Config, GenerateObjectWithDataFromSolver)
+// {
+//     auto config_map = gko::config::generate_config_map();
+//     auto reg = gko::config::registry(config_map);
+//     reg.emplace("precond", this->mtx);
+
+//     auto obj = gko::solver::Cg<float>::build_from_config(
+//         gko::config::Config{{"generated_preconditioner", "precond"}}, reg,
+//         this->exec);
+
+//     ASSERT_NE(dynamic_cast<gko::solver::Cg<float>::Factory*>(obj.get()),
+//               nullptr);
+//     ASSERT_NE(dynamic_cast<gko::solver::Cg<float>::Factory*>(obj.get())
+//                   ->get_parameters()
+//                   .generated_preconditioner,
+//               nullptr);
+// }
+
 
 TYPED_TEST(Config, GenerateObjectWithPreconditioner)
 {
@@ -116,7 +135,8 @@ TYPED_TEST(Config, GenerateObjectWithPreconditioner)
     auto reg = gko::config::registry(config_map);
 
     auto obj = gko::config::build_from_config<0>(
-        gko::config::Config{{"preconditioner", "Cg"}}, reg, this->exec);
+        gko::config::Config{{"ValueType", "double"}, {"preconditioner", "Cg"}},
+        reg, this->exec);
 
     ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get()),
               nullptr);
@@ -133,7 +153,8 @@ TYPED_TEST(Config, GenerateObjectWithCustomBuild)
 
     config_map["Custom"] = [](const gko::config::Config& config,
                               const gko::config::registry& context,
-                              std::shared_ptr<const gko::Executor>& exec) {
+                              std::shared_ptr<const gko::Executor>& exec,
+                              gko::config::TypeDescriptor td_for_child) {
         return gko::solver::Bicg<double>::build()
             .with_criteria(
                 gko::stop::Iteration::build().with_max_iters(2u).on(exec))
@@ -142,7 +163,8 @@ TYPED_TEST(Config, GenerateObjectWithCustomBuild)
     auto reg = gko::config::registry(config_map);
 
     auto obj = gko::config::build_from_config<0>(
-        gko::config::Config{{"preconditioner", "Custom"}}, reg, this->exec);
+        gko::config::Config{{"preconditioner", "Custom"}}, reg, this->exec,
+        {"double", ""});
 
     ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get()),
               nullptr);
diff --git a/include/ginkgo/core/config/config.hpp b/include/ginkgo/core/config/config.hpp
index 3df7d43b1a2..eedb707e083 100644
--- a/include/ginkgo/core/config/config.hpp
+++ b/include/ginkgo/core/config/config.hpp
@@ -52,16 +52,16 @@ enum LinOpFactoryType : int { Cg = 0 };
 
 
 // It is only an intermediate step. If we do not provide the SolverType with VT,
-// IT selection, we do not need it in public.
+// IT selection, it can be in detail namespace.
 template <int flag>
 std::unique_ptr<gko::LinOpFactory> build_from_config(
     const gko::config::Config& config, const gko::config::registry& context,
-    std::shared_ptr<const Executor>& exec);
+    std::shared_ptr<const Executor>& exec, TypeDescriptor td = {"", ""});
 
 // The main function
 std::unique_ptr<gko::LinOpFactory> build_from_config(
     const gko::config::Config& config, const gko::config::registry& context,
-    std::shared_ptr<const Executor>& exec);
+    std::shared_ptr<const Executor>& exec, TypeDescriptor td = {"", ""});
 
 
 BuildFromConfigMap generate_config_map();
diff --git a/include/ginkgo/core/config/registry.hpp b/include/ginkgo/core/config/registry.hpp
index 160a903a200..e6832d4b394 100644
--- a/include/ginkgo/core/config/registry.hpp
+++ b/include/ginkgo/core/config/registry.hpp
@@ -34,9 +34,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define GKO_PUBLIC_CORE_CONFIG_REGISTRY_HPP_
 
 
+#include <complex>
 #include <map>
 #include <string>
 #include <unordered_map>
+#include <utility>
 
 
 #include <ginkgo/core/base/lin_op.hpp>
@@ -51,11 +53,14 @@ using LinOpMap = std::unordered_map<std::string, std::shared_ptr<LinOp>>;
 using LinOpFactoryMap =
     std::unordered_map<std::string, std::shared_ptr<LinOpFactory>>;
 using Config = std::map<std::string, std::string>;
+using TypeDescriptor = std::pair<std::string, std::string>;
 class registry;
 using BuildFunctionType = std::function<std::unique_ptr<gko::LinOpFactory>(
-    const Config&, const registry&, std::shared_ptr<const Executor>&)>;
+    const Config&, const registry&, std::shared_ptr<const Executor>&,
+    TypeDescriptor)>;
 using BuildFromConfigMap = std::map<std::string, BuildFunctionType>;
 
+
 /**
  * map_type gives the map type according to the base type of given type.
  *
@@ -184,6 +189,22 @@ inline const LinOpFactoryMap& registry::get_map_impl<LinOpFactoryMap>() const
 }
 
 
+template <typename T>
+struct type_string {
+    static std::string str() { return "N"; };
+};
+
+#define TYPE_STRING_OVERLOAD(_type, _str)         \
+    template <>                                   \
+    struct type_string<_type> {                   \
+        static std::string str() { return _str; } \
+    }
+
+TYPE_STRING_OVERLOAD(double, "double");
+TYPE_STRING_OVERLOAD(float, "float");
+TYPE_STRING_OVERLOAD(std::complex<double>, "complex<double>");
+TYPE_STRING_OVERLOAD(std::complex<float>, "complex<float>");
+
 }  // namespace config
 }  // namespace gko
 
diff --git a/include/ginkgo/core/solver/cg.hpp b/include/ginkgo/core/solver/cg.hpp
index d8c33a905bc..bebc087c359 100644
--- a/include/ginkgo/core/solver/cg.hpp
+++ b/include/ginkgo/core/solver/cg.hpp
@@ -53,7 +53,7 @@ class Cg : public EnableLinOp<Cg<ValueType>>,
     friend std::unique_ptr<LinOpFactory> gko::config::build_from_config<
         static_cast<int>(gko::config::LinOpFactoryType::Cg)>(
         const gko::config::Config&, const gko::config::registry&,
-        std::shared_ptr<const Executor>&);
+        std::shared_ptr<const Executor>&, gko::config::TypeDescriptor);
 
 public:
     using value_type = ValueType;
@@ -82,7 +82,9 @@ class Cg : public EnableLinOp<Cg<ValueType>>,
 protected:
     static std::unique_ptr<Factory> build_from_config(
         const gko::config::Config& config, const gko::config::registry& context,
-        std::shared_ptr<const Executor> exec);
+        std::shared_ptr<const Executor> exec,
+        gko::config::TypeDescriptor td_for_child = {
+            gko::config::type_string<ValueType>::str(), ""});
 
     void apply_impl(const LinOp* b, LinOp* x) const override;
 

From 9d11041b8ca4020152aec84dc0750f40024ef68e Mon Sep 17 00:00:00 2001
From: "Yuhsiang M. Tsai" <yhmtsai@gmail.com>
Date: Fri, 11 Aug 2023 22:50:50 +0200
Subject: [PATCH 04/25] add the general type dispatch

---
 core/config/config.hpp                  | 139 ++++++++++++++++++++++++
 core/config/dispatch.hpp                | 115 ++++++++++++++++++++
 core/solver/cg.cpp                      |  43 ++------
 include/ginkgo/core/config/config.hpp   |  10 ++
 include/ginkgo/core/config/registry.hpp |  24 ++++
 include/ginkgo/core/solver/cg.hpp       |  16 ++-
 6 files changed, 308 insertions(+), 39 deletions(-)
 create mode 100644 core/config/config.hpp
 create mode 100644 core/config/dispatch.hpp

diff --git a/core/config/config.hpp b/core/config/config.hpp
new file mode 100644
index 00000000000..6f49e7ca88a
--- /dev/null
+++ b/core/config/config.hpp
@@ -0,0 +1,139 @@
+/*******************************<GINKGO LICENSE>******************************
+Copyright (c) 2017-2023, the Ginkgo authors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+******************************<GINKGO LICENSE>*******************************/
+
+#ifndef GKO_CORE_CONFIG_CONFIG_HPP_
+#define GKO_CORE_CONFIG_CONFIG_HPP_
+
+
+#include <string>
+
+
+#include <ginkgo/core/base/lin_op.hpp>
+#include <ginkgo/core/config/registry.hpp>
+#include <ginkgo/core/stop/criterion.hpp>
+
+namespace gko {
+namespace config {
+
+/**
+ * This function is to update the default type setting from current config.
+ *
+ * @note It might update the unused type for the current class.
+ */
+inline TypeDescriptor update_type(const Config& config,
+                                  const TypeDescriptor& td)
+{
+    TypeDescriptor updated = td;
+    auto it = config.find("ValueType");
+    if (it != config.end()) {
+        updated.first = it->second;
+    }
+    it = config.find("IndexType");
+    if (it != config.end()) {
+        updated.second = it->second;
+    }
+    return updated;
+}
+
+
+using item = std::string;
+
+template <typename T>
+inline std::shared_ptr<T> get_pointer(const item& item, const registry& context,
+                                      std::shared_ptr<const Executor> exec,
+                                      TypeDescriptor td)
+{
+    std::shared_ptr<T> ptr;
+    using T_non_const = std::remove_const_t<T>;
+    ptr = context.search_data<T_non_const>(item);
+    assert(ptr.get() != nullptr);
+    return std::move(ptr);
+}
+
+template <>
+inline std::shared_ptr<const LinOpFactory> get_pointer<const LinOpFactory>(
+    const item& item, const registry& context,
+    std::shared_ptr<const Executor> exec, TypeDescriptor td)
+{
+    std::shared_ptr<const LinOpFactory> ptr;
+    ptr = context.search_data<LinOpFactory>(item);
+    // handle object is item
+    assert(ptr.get() != nullptr);
+    return std::move(ptr);
+}
+
+
+template <>
+inline std::shared_ptr<const stop::CriterionFactory>
+get_pointer<const stop::CriterionFactory>(const item& item,
+                                          const registry& context,
+                                          std::shared_ptr<const Executor> exec,
+                                          TypeDescriptor td)
+{
+    std::shared_ptr<const stop::CriterionFactory> ptr;
+    ptr = context.search_data<stop::CriterionFactory>(item);
+    // handle object is item
+    assert(ptr.get() != nullptr);
+    return std::move(ptr);
+}
+
+
+template <typename T>
+inline std::vector<std::shared_ptr<T>> get_pointer_vector(
+    const item& item, const registry& context,
+    std::shared_ptr<const Executor> exec, TypeDescriptor td)
+{
+    std::vector<std::shared_ptr<T>> res;
+    // for loop in item
+    res.push_back(get_pointer<T>(item, context, exec, td));
+    return res;
+}
+
+#define SET_POINTER(_factory, _param_type, _param_name, _config, _context,     \
+                    _exec, _td)                                                \
+    {                                                                          \
+        auto it = _config.find(#_param_name);                                  \
+        if (it != _config.end()) {                                             \
+            _factory.with_##_param_name(gko::config::get_pointer<_param_type>( \
+                it->second, _context, _exec, _td));                            \
+        }                                                                      \
+    }                                                                          \
+    static_assert(true,                                                        \
+                  "This assert is used to counter the false positive extra "   \
+                  "semi-colon warnings")
+
+
+}  // namespace config
+}  // namespace gko
+
+
+#endif  // GKO_CORE_CONFIG_CONFIG_HPP_
diff --git a/core/config/dispatch.hpp b/core/config/dispatch.hpp
new file mode 100644
index 00000000000..0ba85a20c0d
--- /dev/null
+++ b/core/config/dispatch.hpp
@@ -0,0 +1,115 @@
+/*******************************<GINKGO LICENSE>******************************
+Copyright (c) 2017-2023, the Ginkgo authors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+******************************<GINKGO LICENSE>*******************************/
+
+#ifndef GKO_CORE_CONFIG_DISPATCH_HPP_
+#define GKO_CORE_CONFIG_DISPATCH_HPP_
+
+
+#include <complex>
+#include <string>
+
+
+#include <ginkgo/core/config/config.hpp>
+#include <ginkgo/core/config/registry.hpp>
+#include <ginkgo/core/synthesizer/containers.hpp>
+
+
+namespace gko {
+namespace config {
+
+
+/**
+ * This function is to dispatch the type from runtime parameter.
+ * The concrete class need to have static member function
+ * build_from_config(Config, registry, std::shared_ptr<const Executor>,
+ * TypeDescriptor)
+ */
+template <template <class...> class Base, typename... Types>
+std::unique_ptr<LinOpFactory> dispatch(std::string str,
+                                       const gko::config::Config& config,
+                                       const gko::config::registry& context,
+                                       std::shared_ptr<const Executor>& exec,
+                                       const gko::config::TypeDescriptor& td)
+{
+    return Base<Types...>::build_from_config(config, context, exec, td);
+}
+
+// When the dispatch does not find match from the given list.
+template <template <class...> class Base, typename... Types, typename... List>
+std::unique_ptr<LinOpFactory> dispatch(std::string str,
+                                       const gko::config::Config& config,
+                                       const gko::config::registry& context,
+                                       std::shared_ptr<const Executor>& exec,
+                                       const gko::config::TypeDescriptor& td,
+                                       syn::type_list<>, List... list)
+{
+    throw std::runtime_error("Not Found");
+}
+
+/**
+ * @param str  the identifier for runtime type: the format is type1,type2,...
+ * @param config  the configuration
+ * @param context  the registry context
+ * @param exec  the executor
+ * @param td  the default type discriptor
+ * @param type_list  the type list for checking
+ * @param list...  the type list for the rest type
+ */
+template <template <class...> class Base, typename... Types, typename S,
+          typename... T, typename... List>
+std::unique_ptr<LinOpFactory> dispatch(std::string str,
+                                       const gko::config::Config& config,
+                                       const gko::config::registry& context,
+                                       std::shared_ptr<const Executor>& exec,
+                                       const gko::config::TypeDescriptor& td,
+                                       syn::type_list<S, T...>, List... list)
+{
+    auto pos = str.find(",");
+    auto item = str.substr(0, pos);
+    auto res = (pos == std::string::npos) ? "" : str.substr(pos + 1);
+    if (item == type_string<S>::str()) {
+        return dispatch<Base, Types..., S>(res, config, context, exec, td,
+                                           list...);
+    } else {
+        return dispatch<Base, Types...>(str, config, context, exec, td,
+                                        syn::type_list<T...>(), list...);
+    }
+}
+
+using value_type_list =
+    syn::type_list<double, float, std::complex<double>, std::complex<float>>;
+
+
+}  // namespace config
+}  // namespace gko
+
+#endif  // GKO_CORE_CONFIG_DISPATCH_HPP_
diff --git a/core/solver/cg.cpp b/core/solver/cg.cpp
index 68886f16605..9072f2ce8f2 100644
--- a/core/solver/cg.cpp
+++ b/core/solver/cg.cpp
@@ -16,6 +16,8 @@
 #include <ginkgo/core/stop/iteration.hpp>
 
 
+#include "core/config/config.hpp"
+#include "core/config/dispatch.hpp"
 #include "core/distributed/helpers.hpp"
 #include "core/solver/cg_kernels.hpp"
 #include "core/solver/solver_boilerplate.hpp"
@@ -31,34 +33,9 @@ build_from_config<static_cast<int>(gko::config::LinOpFactoryType::Cg)>(
     const gko::config::Config& config, const gko::config::registry& context,
     std::shared_ptr<const Executor>& exec, gko::config::TypeDescriptor td)
 {
-    // TODO: select the type, always using double as demo.
-    // extract the following to another function (or build_from_config) to make
-    // this function only select type
-    std::string val_str = td.first;  // get from default pack
-    {
-        auto it = config.find("ValueType");
-        if (it != config.end()) {
-            val_str = it->second;
-        }
-        // propagate the type
-        td.first = val_str;
-    }
-    // the following can be handled by auto selection. maybe reuse the macro?
-    if (val_str == "double") {
-        return gko::solver::Cg<double>::build_from_config(config, context, exec,
-                                                          td);
-    } else if (val_str == "float") {
-        return gko::solver::Cg<float>::build_from_config(config, context, exec,
-                                                         td);
-    } else if (val_str == "complex<double>") {
-        return gko::solver::Cg<std::complex<double>>::build_from_config(
-            config, context, exec, td);
-    } else if (val_str == "complex<float>") {
-        return gko::solver::Cg<std::complex<float>>::build_from_config(
-            config, context, exec, td);
-    }
-
-    return nullptr;
+    auto updated = update_type(config, td);
+    return dispatch<solver::Cg>(updated.first, config, context, exec, updated,
+                                value_type_list());
 }
 
 
@@ -78,6 +55,7 @@ GKO_REGISTER_OPERATION(step_2, cg::step_2);
 }  // anonymous namespace
 }  // namespace cg
 
+
 template <typename ValueType>
 std::unique_ptr<typename Cg<ValueType>::Factory>
 Cg<ValueType>::build_from_config(const gko::config::Config& config,
@@ -86,13 +64,8 @@ Cg<ValueType>::build_from_config(const gko::config::Config& config,
                                  gko::config::TypeDescriptor td_for_child)
 {
     auto factory = Factory::create();
-    {
-        auto str = config.find("generated_preconditioner");
-        if (str != config.end()) {
-            auto linop = context.search_data<gko::LinOp>(str->second);
-            factory.with_generated_preconditioner(linop);
-        }
-    }
+    SET_POINTER(factory, const LinOp, generated_preconditioner, config, context,
+                exec, td_for_child);
     // handle parameter requires exec
     // criteria and preconditioner are almost in each solver -> to another
     // function.
diff --git a/include/ginkgo/core/config/config.hpp b/include/ginkgo/core/config/config.hpp
index eedb707e083..f39ede71088 100644
--- a/include/ginkgo/core/config/config.hpp
+++ b/include/ginkgo/core/config/config.hpp
@@ -58,12 +58,22 @@ std::unique_ptr<gko::LinOpFactory> build_from_config(
     const gko::config::Config& config, const gko::config::registry& context,
     std::shared_ptr<const Executor>& exec, TypeDescriptor td = {"", ""});
 
+
 // The main function
 std::unique_ptr<gko::LinOpFactory> build_from_config(
     const gko::config::Config& config, const gko::config::registry& context,
     std::shared_ptr<const Executor>& exec, TypeDescriptor td = {"", ""});
 
 
+// dispatch function
+template <template <class...> class Base, typename... Types>
+std::unique_ptr<LinOpFactory> dispatch(std::string str,
+                                       const gko::config::Config& config,
+                                       const gko::config::registry& context,
+                                       std::shared_ptr<const Executor>& exec,
+                                       const gko::config::TypeDescriptor& td);
+
+
 BuildFromConfigMap generate_config_map();
 
 
diff --git a/include/ginkgo/core/config/registry.hpp b/include/ginkgo/core/config/registry.hpp
index e6832d4b394..0adb7c303c1 100644
--- a/include/ginkgo/core/config/registry.hpp
+++ b/include/ginkgo/core/config/registry.hpp
@@ -43,6 +43,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <ginkgo/core/base/lin_op.hpp>
 #include <ginkgo/core/base/types.hpp>
+#include <ginkgo/core/stop/criterion.hpp>
 
 
 namespace gko {
@@ -52,6 +53,8 @@ namespace config {
 using LinOpMap = std::unordered_map<std::string, std::shared_ptr<LinOp>>;
 using LinOpFactoryMap =
     std::unordered_map<std::string, std::shared_ptr<LinOpFactory>>;
+using CriterionFactoryMap =
+    std::unordered_map<std::string, std::shared_ptr<stop::CriterionFactory>>;
 using Config = std::map<std::string, std::string>;
 using TypeDescriptor = std::pair<std::string, std::string>;
 class registry;
@@ -83,6 +86,12 @@ struct map_type<T, typename std::enable_if<
     using type = LinOpFactoryMap;
 };
 
+template <typename T>
+struct map_type<T, typename std::enable_if<std::is_convertible<
+                       T*, stop::CriterionFactory*>::value>::type> {
+    using type = CriterionFactoryMap;
+};
+
 
 class registry {
 public:
@@ -160,6 +169,7 @@ class registry {
 private:
     LinOpMap linop_map_;
     LinOpFactoryMap linopfactory_map_;
+    CriterionFactoryMap criterionfactory_map_;
     BuildFromConfigMap build_map_;
 };
 
@@ -176,6 +186,12 @@ inline LinOpFactoryMap& registry::get_map_impl<LinOpFactoryMap>()
     return linopfactory_map_;
 }
 
+template <>
+inline CriterionFactoryMap& registry::get_map_impl<CriterionFactoryMap>()
+{
+    return criterionfactory_map_;
+}
+
 template <>
 inline const LinOpMap& registry::get_map_impl<LinOpMap>() const
 {
@@ -188,6 +204,13 @@ inline const LinOpFactoryMap& registry::get_map_impl<LinOpFactoryMap>() const
     return linopfactory_map_;
 }
 
+template <>
+inline const CriterionFactoryMap& registry::get_map_impl<CriterionFactoryMap>()
+    const
+{
+    return criterionfactory_map_;
+}
+
 
 template <typename T>
 struct type_string {
@@ -205,6 +228,7 @@ TYPE_STRING_OVERLOAD(float, "float");
 TYPE_STRING_OVERLOAD(std::complex<double>, "complex<double>");
 TYPE_STRING_OVERLOAD(std::complex<float>, "complex<float>");
 
+
 }  // namespace config
 }  // namespace gko
 
diff --git a/include/ginkgo/core/solver/cg.hpp b/include/ginkgo/core/solver/cg.hpp
index bebc087c359..6ab742d630f 100644
--- a/include/ginkgo/core/solver/cg.hpp
+++ b/include/ginkgo/core/solver/cg.hpp
@@ -50,10 +50,18 @@ class Cg : public EnableLinOp<Cg<ValueType>>,
            public Transposable {
     friend class EnableLinOp<Cg>;
     friend class EnablePolymorphicObject<Cg, LinOp>;
-    friend std::unique_ptr<LinOpFactory> gko::config::build_from_config<
-        static_cast<int>(gko::config::LinOpFactoryType::Cg)>(
-        const gko::config::Config&, const gko::config::registry&,
-        std::shared_ptr<const Executor>&, gko::config::TypeDescriptor);
+
+    template <template <class...> class Base, typename... Types>
+    friend std::unique_ptr<LinOpFactory> gko::config::dispatch(
+        std::string str, const gko::config::Config& config,
+        const gko::config::registry& context,
+        std::shared_ptr<const Executor>& exec,
+        const gko::config::TypeDescriptor& td);
+
+    // friend std::unique_ptr<LinOpFactory> gko::config::build_from_config<
+    //     static_cast<int>(gko::config::LinOpFactoryType::Cg)>(
+    //     const gko::config::Config&, const gko::config::registry&,
+    //     std::shared_ptr<const Executor>&, gko::config::TypeDescriptor);
 
 public:
     using value_type = ValueType;

From c272d6bfad0c140ea18ed865f4665547ccc56da5 Mon Sep 17 00:00:00 2001
From: "Yu-Hsiang M. Tsai" <yhmtsai@gmail.com>
Date: Tue, 15 Aug 2023 13:37:56 +0200
Subject: [PATCH 05/25] use property_tree as config type

---
 core/config/config.cpp                  |  5 ++--
 core/config/config.hpp                  | 31 ++++++++++++----------
 core/solver/cg.cpp                      | 11 ++------
 core/test/config/config.cpp             | 34 ++++++++++++++++---------
 include/ginkgo/core/config/registry.hpp |  3 ++-
 5 files changed, 45 insertions(+), 39 deletions(-)

diff --git a/core/config/config.cpp b/core/config/config.cpp
index 419ba2abbcf..c5f9d0ef310 100644
--- a/core/config/config.cpp
+++ b/core/config/config.cpp
@@ -50,9 +50,8 @@ std::unique_ptr<gko::LinOpFactory> build_from_config(
     const gko::config::Config& config, const gko::config::registry& context,
     std::shared_ptr<const Executor>& exec, TypeDescriptor td)
 {
-    auto type = config.find("Type");
-    if (type != config.end()) {
-        auto func = context.get_build_map().at(type->second);
+    if (config.contains("Type")) {
+        auto func = context.get_build_map().at(config.get<std::string>("Type"));
         return func(config, context, exec, td);
     }
     return nullptr;
diff --git a/core/config/config.hpp b/core/config/config.hpp
index 6f49e7ca88a..469546e1c37 100644
--- a/core/config/config.hpp
+++ b/core/config/config.hpp
@@ -41,6 +41,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <ginkgo/core/config/registry.hpp>
 #include <ginkgo/core/stop/criterion.hpp>
 
+
 namespace gko {
 namespace config {
 
@@ -53,19 +54,18 @@ inline TypeDescriptor update_type(const Config& config,
                                   const TypeDescriptor& td)
 {
     TypeDescriptor updated = td;
-    auto it = config.find("ValueType");
-    if (it != config.end()) {
-        updated.first = it->second;
+
+    if (config.contains("ValueType")) {
+        updated.first = config.get<std::string>("ValueType");
     }
-    it = config.find("IndexType");
-    if (it != config.end()) {
-        updated.second = it->second;
+    if (config.contains("IndexType")) {
+        updated.second = config.get<std::string>("IndexType");
     }
     return updated;
 }
 
 
-using item = std::string;
+using item = pnode;
 
 template <typename T>
 inline std::shared_ptr<T> get_pointer(const item& item, const registry& context,
@@ -74,7 +74,7 @@ inline std::shared_ptr<T> get_pointer(const item& item, const registry& context,
 {
     std::shared_ptr<T> ptr;
     using T_non_const = std::remove_const_t<T>;
-    ptr = context.search_data<T_non_const>(item);
+    ptr = context.search_data<T_non_const>(item.get<std::string>());
     assert(ptr.get() != nullptr);
     return std::move(ptr);
 }
@@ -85,13 +85,16 @@ inline std::shared_ptr<const LinOpFactory> get_pointer<const LinOpFactory>(
     std::shared_ptr<const Executor> exec, TypeDescriptor td)
 {
     std::shared_ptr<const LinOpFactory> ptr;
-    ptr = context.search_data<LinOpFactory>(item);
+    if (item.is(pnode::status_t::object)) {
+        ptr = context.search_data<LinOpFactory>(item.get<std::string>());
+    } else if (item.is(pnode::status_t::object_list)) {
+        ptr = build_from_config(item, context, exec, td);
+    }
     // handle object is item
     assert(ptr.get() != nullptr);
     return std::move(ptr);
 }
 
-
 template <>
 inline std::shared_ptr<const stop::CriterionFactory>
 get_pointer<const stop::CriterionFactory>(const item& item,
@@ -100,7 +103,7 @@ get_pointer<const stop::CriterionFactory>(const item& item,
                                           TypeDescriptor td)
 {
     std::shared_ptr<const stop::CriterionFactory> ptr;
-    ptr = context.search_data<stop::CriterionFactory>(item);
+    ptr = context.search_data<stop::CriterionFactory>(item.get<std::string>());
     // handle object is item
     assert(ptr.get() != nullptr);
     return std::move(ptr);
@@ -118,13 +121,13 @@ inline std::vector<std::shared_ptr<T>> get_pointer_vector(
     return res;
 }
 
+
 #define SET_POINTER(_factory, _param_type, _param_name, _config, _context,     \
                     _exec, _td)                                                \
     {                                                                          \
-        auto it = _config.find(#_param_name);                                  \
-        if (it != _config.end()) {                                             \
+        if (_config.contains(#_param_name)) {                                  \
             _factory.with_##_param_name(gko::config::get_pointer<_param_type>( \
-                it->second, _context, _exec, _td));                            \
+                _config.get_child(#_param_name), _context, _exec, _td));       \
         }                                                                      \
     }                                                                          \
     static_assert(true,                                                        \
diff --git a/core/solver/cg.cpp b/core/solver/cg.cpp
index 9072f2ce8f2..3b4720e1112 100644
--- a/core/solver/cg.cpp
+++ b/core/solver/cg.cpp
@@ -71,15 +71,8 @@ Cg<ValueType>::build_from_config(const gko::config::Config& config,
     // function.
     factory.with_criteria(
         gko::stop::Iteration::build().with_max_iters(1u).on(exec));
-    {
-        auto str = config.find("preconditioner");
-        if (str != config.end()) {
-            // assume we have the config for nest object
-            factory.with_preconditioner(gko::config::build_from_config(
-                gko::config::Config{{"Type", str->second}}, context, exec,
-                td_for_child));
-        }
-    }
+    SET_POINTER(factory, const LinOpFactory, preconditioner, config, context,
+                exec, td_for_child);
     // can also handle preconditioner, criterion here if they are in
     // context.
     return factory.on(exec);
diff --git a/core/test/config/config.cpp b/core/test/config/config.cpp
index 351511312f7..85586c34e1f 100644
--- a/core/test/config/config.cpp
+++ b/core/test/config/config.cpp
@@ -48,9 +48,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <ginkgo/core/stop/residual_norm.hpp>
 
 
+#include "core/test/config/utils.hpp"
 #include "core/test/utils.hpp"
 
-
 namespace {
 
 
@@ -83,8 +83,9 @@ TYPED_TEST(Config, GenerateObjectWithoutDefault)
     auto config_map = gko::config::generate_config_map();
     auto reg = gko::config::registry(config_map);
 
-    auto obj = gko::config::build_from_config<0>(
-        gko::config::Config{{"ValueType", "double"}}, reg, this->exec);
+    gko::config::pnode p;
+    p.insert("ValueType", "double");
+    auto obj = gko::config::build_from_config<0>(p, reg, this->exec);
 
     ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get()),
               nullptr);
@@ -97,9 +98,11 @@ TYPED_TEST(Config, GenerateObjectWithData)
     auto reg = gko::config::registry(config_map);
     reg.emplace("precond", this->mtx);
 
-    auto obj = gko::config::build_from_config<0>(
-        gko::config::Config{{"generated_preconditioner", "precond"}}, reg,
-        this->exec, {"float", ""});
+    gko::config::pnode p;
+    p.insert("generated_preconditioner", "precond");
+    print(std::cout, p);
+    auto obj =
+        gko::config::build_from_config<0>(p, reg, this->exec, {"float", ""});
 
     ASSERT_NE(dynamic_cast<gko::solver::Cg<float>::Factory*>(obj.get()),
               nullptr);
@@ -134,9 +137,14 @@ TYPED_TEST(Config, GenerateObjectWithPreconditioner)
     auto config_map = gko::config::generate_config_map();
     auto reg = gko::config::registry(config_map);
 
-    auto obj = gko::config::build_from_config<0>(
-        gko::config::Config{{"ValueType", "double"}, {"preconditioner", "Cg"}},
-        reg, this->exec);
+    gko::config::pnode p;
+    p.insert("ValueType", "double");
+    p.allocate("preconditioner");
+    p.get_child("preconditioner").insert("Type", "Cg");
+    // p_prec.insert("Type", "Cg");
+    print(std::cout, p);
+    // print(std::cout, p_prec);
+    auto obj = gko::config::build_from_config<0>(p, reg, this->exec);
 
     ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get()),
               nullptr);
@@ -162,9 +170,11 @@ TYPED_TEST(Config, GenerateObjectWithCustomBuild)
     };
     auto reg = gko::config::registry(config_map);
 
-    auto obj = gko::config::build_from_config<0>(
-        gko::config::Config{{"preconditioner", "Custom"}}, reg, this->exec,
-        {"double", ""});
+    gko::config::pnode p;
+    p.allocate("preconditioner");
+    p.get_child("preconditioner").insert("Type", "Custom");
+    auto obj =
+        gko::config::build_from_config<0>(p, reg, this->exec, {"double", ""});
 
     ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get()),
               nullptr);
diff --git a/include/ginkgo/core/config/registry.hpp b/include/ginkgo/core/config/registry.hpp
index 0adb7c303c1..6da3f406958 100644
--- a/include/ginkgo/core/config/registry.hpp
+++ b/include/ginkgo/core/config/registry.hpp
@@ -43,6 +43,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <ginkgo/core/base/lin_op.hpp>
 #include <ginkgo/core/base/types.hpp>
+#include <ginkgo/core/config/property_tree.hpp>
 #include <ginkgo/core/stop/criterion.hpp>
 
 
@@ -55,7 +56,7 @@ using LinOpFactoryMap =
     std::unordered_map<std::string, std::shared_ptr<LinOpFactory>>;
 using CriterionFactoryMap =
     std::unordered_map<std::string, std::shared_ptr<stop::CriterionFactory>>;
-using Config = std::map<std::string, std::string>;
+using Config = pnode;
 using TypeDescriptor = std::pair<std::string, std::string>;
 class registry;
 using BuildFunctionType = std::function<std::unique_ptr<gko::LinOpFactory>(

From 6ebce2eac865662d8e86a87cacd3ec99650470b6 Mon Sep 17 00:00:00 2001
From: "Yu-Hsiang M. Tsai" <yhmtsai@gmail.com>
Date: Tue, 15 Aug 2023 15:56:59 +0200
Subject: [PATCH 06/25] update the usage of property tree

---
 core/config/config.cpp      |  3 ++-
 core/config/config.hpp      | 15 +++++++------
 core/test/config/config.cpp | 43 ++++++++-----------------------------
 3 files changed, 19 insertions(+), 42 deletions(-)

diff --git a/core/config/config.cpp b/core/config/config.cpp
index c5f9d0ef310..da5f98dfd39 100644
--- a/core/config/config.cpp
+++ b/core/config/config.cpp
@@ -51,7 +51,8 @@ std::unique_ptr<gko::LinOpFactory> build_from_config(
     std::shared_ptr<const Executor>& exec, TypeDescriptor td)
 {
     if (config.contains("Type")) {
-        auto func = context.get_build_map().at(config.get<std::string>("Type"));
+        auto func = context.get_build_map().at(
+            config.at("Type").get_data<std::string>());
         return func(config, context, exec, td);
     }
     return nullptr;
diff --git a/core/config/config.hpp b/core/config/config.hpp
index 469546e1c37..326f256fc87 100644
--- a/core/config/config.hpp
+++ b/core/config/config.hpp
@@ -56,10 +56,10 @@ inline TypeDescriptor update_type(const Config& config,
     TypeDescriptor updated = td;
 
     if (config.contains("ValueType")) {
-        updated.first = config.get<std::string>("ValueType");
+        updated.first = config.at("ValueType").get_data<std::string>();
     }
     if (config.contains("IndexType")) {
-        updated.second = config.get<std::string>("IndexType");
+        updated.second = config.at("IndexType").get_data<std::string>();
     }
     return updated;
 }
@@ -74,7 +74,7 @@ inline std::shared_ptr<T> get_pointer(const item& item, const registry& context,
 {
     std::shared_ptr<T> ptr;
     using T_non_const = std::remove_const_t<T>;
-    ptr = context.search_data<T_non_const>(item.get<std::string>());
+    ptr = context.search_data<T_non_const>(item.get_data<std::string>());
     assert(ptr.get() != nullptr);
     return std::move(ptr);
 }
@@ -86,8 +86,8 @@ inline std::shared_ptr<const LinOpFactory> get_pointer<const LinOpFactory>(
 {
     std::shared_ptr<const LinOpFactory> ptr;
     if (item.is(pnode::status_t::object)) {
-        ptr = context.search_data<LinOpFactory>(item.get<std::string>());
-    } else if (item.is(pnode::status_t::object_list)) {
+        ptr = context.search_data<LinOpFactory>(item.get_data<std::string>());
+    } else if (item.is(pnode::status_t::list)) {
         ptr = build_from_config(item, context, exec, td);
     }
     // handle object is item
@@ -103,7 +103,8 @@ get_pointer<const stop::CriterionFactory>(const item& item,
                                           TypeDescriptor td)
 {
     std::shared_ptr<const stop::CriterionFactory> ptr;
-    ptr = context.search_data<stop::CriterionFactory>(item.get<std::string>());
+    ptr = context.search_data<stop::CriterionFactory>(
+        item.get_data<std::string>());
     // handle object is item
     assert(ptr.get() != nullptr);
     return std::move(ptr);
@@ -127,7 +128,7 @@ inline std::vector<std::shared_ptr<T>> get_pointer_vector(
     {                                                                          \
         if (_config.contains(#_param_name)) {                                  \
             _factory.with_##_param_name(gko::config::get_pointer<_param_type>( \
-                _config.get_child(#_param_name), _context, _exec, _td));       \
+                _config.at(#_param_name), _context, _exec, _td));              \
         }                                                                      \
     }                                                                          \
     static_assert(true,                                                        \
diff --git a/core/test/config/config.cpp b/core/test/config/config.cpp
index 85586c34e1f..4ad7d9c2a70 100644
--- a/core/test/config/config.cpp
+++ b/core/test/config/config.cpp
@@ -72,6 +72,9 @@ class Config : public ::testing::Test {
 TYPED_TEST_SUITE(Config, gko::test::ValueTypes, TypenameNameGenerator);
 
 
+using gko::config::pnode;
+
+
 TYPED_TEST(Config, GenerateMap)
 {
     ASSERT_NO_THROW(gko::config::generate_config_map());
@@ -83,8 +86,7 @@ TYPED_TEST(Config, GenerateObjectWithoutDefault)
     auto config_map = gko::config::generate_config_map();
     auto reg = gko::config::registry(config_map);
 
-    gko::config::pnode p;
-    p.insert("ValueType", "double");
+    pnode p{{{"ValueType", pnode{"double"}}}};
     auto obj = gko::config::build_from_config<0>(p, reg, this->exec);
 
     ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get()),
@@ -98,9 +100,7 @@ TYPED_TEST(Config, GenerateObjectWithData)
     auto reg = gko::config::registry(config_map);
     reg.emplace("precond", this->mtx);
 
-    gko::config::pnode p;
-    p.insert("generated_preconditioner", "precond");
-    print(std::cout, p);
+    pnode p{{{"generated_preconditioner", pnode{"precond"}}}};
     auto obj =
         gko::config::build_from_config<0>(p, reg, this->exec, {"float", ""});
 
@@ -112,38 +112,14 @@ TYPED_TEST(Config, GenerateObjectWithData)
               nullptr);
 }
 
-// it is under protected namespace
-// TYPED_TEST(Config, GenerateObjectWithDataFromSolver)
-// {
-//     auto config_map = gko::config::generate_config_map();
-//     auto reg = gko::config::registry(config_map);
-//     reg.emplace("precond", this->mtx);
-
-//     auto obj = gko::solver::Cg<float>::build_from_config(
-//         gko::config::Config{{"generated_preconditioner", "precond"}}, reg,
-//         this->exec);
-
-//     ASSERT_NE(dynamic_cast<gko::solver::Cg<float>::Factory*>(obj.get()),
-//               nullptr);
-//     ASSERT_NE(dynamic_cast<gko::solver::Cg<float>::Factory*>(obj.get())
-//                   ->get_parameters()
-//                   .generated_preconditioner,
-//               nullptr);
-// }
-
 
 TYPED_TEST(Config, GenerateObjectWithPreconditioner)
 {
     auto config_map = gko::config::generate_config_map();
     auto reg = gko::config::registry(config_map);
 
-    gko::config::pnode p;
-    p.insert("ValueType", "double");
-    p.allocate("preconditioner");
-    p.get_child("preconditioner").insert("Type", "Cg");
-    // p_prec.insert("Type", "Cg");
-    print(std::cout, p);
-    // print(std::cout, p_prec);
+    pnode p{{{"ValueType", pnode{"double"}}}};
+    p.get_list()["preconditioner"] = pnode{{{"Type", pnode{"Cg"}}}};
     auto obj = gko::config::build_from_config<0>(p, reg, this->exec);
 
     ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get()),
@@ -170,9 +146,8 @@ TYPED_TEST(Config, GenerateObjectWithCustomBuild)
     };
     auto reg = gko::config::registry(config_map);
 
-    gko::config::pnode p;
-    p.allocate("preconditioner");
-    p.get_child("preconditioner").insert("Type", "Custom");
+    pnode p{{{"ValueType", pnode{"double"}}}};
+    p.get_list()["preconditioner"] = pnode{{{"Type", pnode{"Custom"}}}};
     auto obj =
         gko::config::build_from_config<0>(p, reg, this->exec, {"double", ""});
 

From bcc54a13ddb3f35baca8e926a4a09bc121a2e0a8 Mon Sep 17 00:00:00 2001
From: "Yu-Hsiang M. Tsai" <yhmtsai@gmail.com>
Date: Tue, 15 Aug 2023 16:53:12 +0200
Subject: [PATCH 07/25] move the function into internal not protected

---
 core/config/config.hpp                  | 20 +++++++++
 core/config/dispatch.hpp                |  3 ++
 core/solver/cg.cpp                      | 55 ++++++++++++++-----------
 include/ginkgo/core/config/config.hpp   | 11 +----
 include/ginkgo/core/config/registry.hpp | 17 --------
 include/ginkgo/core/solver/cg.hpp       | 20 ---------
 6 files changed, 54 insertions(+), 72 deletions(-)

diff --git a/core/config/config.hpp b/core/config/config.hpp
index 326f256fc87..75ef0928b5f 100644
--- a/core/config/config.hpp
+++ b/core/config/config.hpp
@@ -38,6 +38,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 
 #include <ginkgo/core/base/lin_op.hpp>
+#include <ginkgo/core/config/config.hpp>
 #include <ginkgo/core/config/registry.hpp>
 #include <ginkgo/core/stop/criterion.hpp>
 
@@ -136,6 +137,25 @@ inline std::vector<std::shared_ptr<T>> get_pointer_vector(
                   "semi-colon warnings")
 
 
+// If we do not put the build_from_config in the class directly, the following
+// can also be in internal header.
+template <typename T>
+struct type_string {
+    static std::string str() { return "N"; };
+};
+
+#define TYPE_STRING_OVERLOAD(_type, _str)         \
+    template <>                                   \
+    struct type_string<_type> {                   \
+        static std::string str() { return _str; } \
+    }
+
+TYPE_STRING_OVERLOAD(double, "double");
+TYPE_STRING_OVERLOAD(float, "float");
+TYPE_STRING_OVERLOAD(std::complex<double>, "complex<double>");
+TYPE_STRING_OVERLOAD(std::complex<float>, "complex<float>");
+
+
 }  // namespace config
 }  // namespace gko
 
diff --git a/core/config/dispatch.hpp b/core/config/dispatch.hpp
index 0ba85a20c0d..a44ba148d7d 100644
--- a/core/config/dispatch.hpp
+++ b/core/config/dispatch.hpp
@@ -43,6 +43,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <ginkgo/core/synthesizer/containers.hpp>
 
 
+#include "core/config/config.hpp"
+
+
 namespace gko {
 namespace config {
 
diff --git a/core/solver/cg.cpp b/core/solver/cg.cpp
index 3b4720e1112..8e8ac9c3f22 100644
--- a/core/solver/cg.cpp
+++ b/core/solver/cg.cpp
@@ -27,6 +27,34 @@ namespace gko {
 namespace config {
 
 
+// It can also be directly in solver::Cg (or in proteced part) if we also allow
+// the executor as input there.
+template <typename ValueType>
+class CgConfigurer {
+public:
+    static std::unique_ptr<typename solver::Cg<ValueType>::Factory>
+    build_from_config(const gko::config::Config& config,
+                      const gko::config::registry& context,
+                      std::shared_ptr<const Executor> exec,
+                      gko::config::TypeDescriptor td_for_child)
+    {
+        auto factory = solver::Cg<ValueType>::Factory::create();
+        SET_POINTER(factory, const LinOp, generated_preconditioner, config,
+                    context, exec, td_for_child);
+        // handle parameter requires exec
+        // criteria and preconditioner are almost in each solver -> to another
+        // function.
+        factory.with_criteria(
+            gko::stop::Iteration::build().with_max_iters(1u).on(exec));
+        SET_POINTER(factory, const LinOpFactory, preconditioner, config,
+                    context, exec, td_for_child);
+        // can also handle preconditioner, criterion here if they are in
+        // context.
+        return factory.on(exec);
+    }
+};
+
+
 template <>
 std::unique_ptr<gko::LinOpFactory>
 build_from_config<static_cast<int>(gko::config::LinOpFactoryType::Cg)>(
@@ -34,8 +62,8 @@ build_from_config<static_cast<int>(gko::config::LinOpFactoryType::Cg)>(
     std::shared_ptr<const Executor>& exec, gko::config::TypeDescriptor td)
 {
     auto updated = update_type(config, td);
-    return dispatch<solver::Cg>(updated.first, config, context, exec, updated,
-                                value_type_list());
+    return dispatch<CgConfigurer>(updated.first, config, context, exec, updated,
+                                  value_type_list());
 }
 
 
@@ -56,29 +84,6 @@ GKO_REGISTER_OPERATION(step_2, cg::step_2);
 }  // namespace cg
 
 
-template <typename ValueType>
-std::unique_ptr<typename Cg<ValueType>::Factory>
-Cg<ValueType>::build_from_config(const gko::config::Config& config,
-                                 const gko::config::registry& context,
-                                 std::shared_ptr<const Executor> exec,
-                                 gko::config::TypeDescriptor td_for_child)
-{
-    auto factory = Factory::create();
-    SET_POINTER(factory, const LinOp, generated_preconditioner, config, context,
-                exec, td_for_child);
-    // handle parameter requires exec
-    // criteria and preconditioner are almost in each solver -> to another
-    // function.
-    factory.with_criteria(
-        gko::stop::Iteration::build().with_max_iters(1u).on(exec));
-    SET_POINTER(factory, const LinOpFactory, preconditioner, config, context,
-                exec, td_for_child);
-    // can also handle preconditioner, criterion here if they are in
-    // context.
-    return factory.on(exec);
-}
-
-
 template <typename ValueType>
 std::unique_ptr<LinOp> Cg<ValueType>::transpose() const
 {
diff --git a/include/ginkgo/core/config/config.hpp b/include/ginkgo/core/config/config.hpp
index f39ede71088..8e7eb397f0d 100644
--- a/include/ginkgo/core/config/config.hpp
+++ b/include/ginkgo/core/config/config.hpp
@@ -52,7 +52,7 @@ enum LinOpFactoryType : int { Cg = 0 };
 
 
 // It is only an intermediate step. If we do not provide the SolverType with VT,
-// IT selection, it can be in detail namespace.
+// IT selection, it can be in detail namespace or hide it by structure
 template <int flag>
 std::unique_ptr<gko::LinOpFactory> build_from_config(
     const gko::config::Config& config, const gko::config::registry& context,
@@ -65,15 +65,6 @@ std::unique_ptr<gko::LinOpFactory> build_from_config(
     std::shared_ptr<const Executor>& exec, TypeDescriptor td = {"", ""});
 
 
-// dispatch function
-template <template <class...> class Base, typename... Types>
-std::unique_ptr<LinOpFactory> dispatch(std::string str,
-                                       const gko::config::Config& config,
-                                       const gko::config::registry& context,
-                                       std::shared_ptr<const Executor>& exec,
-                                       const gko::config::TypeDescriptor& td);
-
-
 BuildFromConfigMap generate_config_map();
 
 
diff --git a/include/ginkgo/core/config/registry.hpp b/include/ginkgo/core/config/registry.hpp
index 6da3f406958..fb0a8ee08a1 100644
--- a/include/ginkgo/core/config/registry.hpp
+++ b/include/ginkgo/core/config/registry.hpp
@@ -213,23 +213,6 @@ inline const CriterionFactoryMap& registry::get_map_impl<CriterionFactoryMap>()
 }
 
 
-template <typename T>
-struct type_string {
-    static std::string str() { return "N"; };
-};
-
-#define TYPE_STRING_OVERLOAD(_type, _str)         \
-    template <>                                   \
-    struct type_string<_type> {                   \
-        static std::string str() { return _str; } \
-    }
-
-TYPE_STRING_OVERLOAD(double, "double");
-TYPE_STRING_OVERLOAD(float, "float");
-TYPE_STRING_OVERLOAD(std::complex<double>, "complex<double>");
-TYPE_STRING_OVERLOAD(std::complex<float>, "complex<float>");
-
-
 }  // namespace config
 }  // namespace gko
 
diff --git a/include/ginkgo/core/solver/cg.hpp b/include/ginkgo/core/solver/cg.hpp
index 6ab742d630f..a56e543d5ca 100644
--- a/include/ginkgo/core/solver/cg.hpp
+++ b/include/ginkgo/core/solver/cg.hpp
@@ -14,8 +14,6 @@
 #include <ginkgo/core/base/lin_op.hpp>
 #include <ginkgo/core/base/math.hpp>
 #include <ginkgo/core/base/types.hpp>
-#include <ginkgo/core/config/config.hpp>
-#include <ginkgo/core/config/registry.hpp>
 #include <ginkgo/core/log/logger.hpp>
 #include <ginkgo/core/matrix/dense.hpp>
 #include <ginkgo/core/matrix/identity.hpp>
@@ -51,18 +49,6 @@ class Cg : public EnableLinOp<Cg<ValueType>>,
     friend class EnableLinOp<Cg>;
     friend class EnablePolymorphicObject<Cg, LinOp>;
 
-    template <template <class...> class Base, typename... Types>
-    friend std::unique_ptr<LinOpFactory> gko::config::dispatch(
-        std::string str, const gko::config::Config& config,
-        const gko::config::registry& context,
-        std::shared_ptr<const Executor>& exec,
-        const gko::config::TypeDescriptor& td);
-
-    // friend std::unique_ptr<LinOpFactory> gko::config::build_from_config<
-    //     static_cast<int>(gko::config::LinOpFactoryType::Cg)>(
-    //     const gko::config::Config&, const gko::config::registry&,
-    //     std::shared_ptr<const Executor>&, gko::config::TypeDescriptor);
-
 public:
     using value_type = ValueType;
     using transposed_type = Cg<ValueType>;
@@ -88,12 +74,6 @@ class Cg : public EnableLinOp<Cg<ValueType>>,
     GKO_ENABLE_BUILD_METHOD(Factory);
 
 protected:
-    static std::unique_ptr<Factory> build_from_config(
-        const gko::config::Config& config, const gko::config::registry& context,
-        std::shared_ptr<const Executor> exec,
-        gko::config::TypeDescriptor td_for_child = {
-            gko::config::type_string<ValueType>::str(), ""});
-
     void apply_impl(const LinOp* b, LinOp* x) const override;
 
     template <typename VectorType>

From 1f9386c1b1143bd548fc0696105356f75416edba Mon Sep 17 00:00:00 2001
From: "Yu-Hsiang M. Tsai" <yhmtsai@gmail.com>
Date: Wed, 16 Aug 2023 11:59:50 +0200
Subject: [PATCH 08/25] update stop config

---
 core/CMakeLists.txt         |   1 +
 core/config/config.hpp      |  65 +++++++++++---
 core/config/dispatch.hpp    |  52 ++++++------
 core/config/stop_config.cpp | 163 ++++++++++++++++++++++++++++++++++++
 core/solver/cg.cpp          |  10 +--
 core/test/config/config.cpp |  22 +++--
 6 files changed, 263 insertions(+), 50 deletions(-)
 create mode 100644 core/config/stop_config.cpp

diff --git a/core/CMakeLists.txt b/core/CMakeLists.txt
index a8142f1c72d..3f9350acdec 100644
--- a/core/CMakeLists.txt
+++ b/core/CMakeLists.txt
@@ -21,6 +21,7 @@ target_sources(ginkgo
     base/version.cpp
     config/config.cpp
     config/property_tree.cpp
+    config/stop_config.cpp
     distributed/index_map.cpp
     distributed/partition.cpp
     factorization/cholesky.cpp
diff --git a/core/config/config.hpp b/core/config/config.hpp
index 75ef0928b5f..0843b7f3973 100644
--- a/core/config/config.hpp
+++ b/core/config/config.hpp
@@ -97,19 +97,11 @@ inline std::shared_ptr<const LinOpFactory> get_pointer<const LinOpFactory>(
 }
 
 template <>
-inline std::shared_ptr<const stop::CriterionFactory>
+std::shared_ptr<const stop::CriterionFactory>
 get_pointer<const stop::CriterionFactory>(const item& item,
                                           const registry& context,
                                           std::shared_ptr<const Executor> exec,
-                                          TypeDescriptor td)
-{
-    std::shared_ptr<const stop::CriterionFactory> ptr;
-    ptr = context.search_data<stop::CriterionFactory>(
-        item.get_data<std::string>());
-    // handle object is item
-    assert(ptr.get() != nullptr);
-    return std::move(ptr);
-}
+                                          TypeDescriptor td);
 
 
 template <typename T>
@@ -119,10 +111,35 @@ inline std::vector<std::shared_ptr<T>> get_pointer_vector(
 {
     std::vector<std::shared_ptr<T>> res;
     // for loop in item
-    res.push_back(get_pointer<T>(item, context, exec, td));
+    if (item.is(pnode::status_t::array)) {
+        for (const auto& it : item.get_array()) {
+            res.push_back(get_pointer<T>(it, context, exec, td));
+        }
+    } else {
+        // only one item can be passed without array
+        res.push_back(get_pointer<T>(item, context, exec, td));
+    }
+
     return res;
 }
 
+template <>
+std::vector<std::shared_ptr<const stop::CriterionFactory>>
+get_pointer_vector<const stop::CriterionFactory>(
+    const item& item, const registry& context,
+    std::shared_ptr<const Executor> exec, TypeDescriptor td);
+
+
+template <typename IndexType, typename = typename std::enable_if<
+                                  std::is_integral<IndexType>::value>::type>
+inline IndexType get_value(const item& item)
+{
+    auto val = item.get_data<long long int>();
+    assert(val <= std::numeric_limits<IndexType>::max() &&
+           val >= std::numeric_limits<IndexType>::min());
+    return static_cast<IndexType>(val);
+}
+
 
 #define SET_POINTER(_factory, _param_type, _param_name, _config, _context,     \
                     _exec, _td)                                                \
@@ -137,6 +154,32 @@ inline std::vector<std::shared_ptr<T>> get_pointer_vector(
                   "semi-colon warnings")
 
 
+#define SET_POINTER_VECTOR(_factory, _param_type, _param_name, _config,      \
+                           _context, _exec, _td)                             \
+    {                                                                        \
+        if (_config.contains(#_param_name)) {                                \
+            _factory.with_##_param_name(                                     \
+                gko::config::get_pointer_vector<_param_type>(                \
+                    _config.at(#_param_name), _context, _exec, _td));        \
+        }                                                                    \
+    }                                                                        \
+    static_assert(true,                                                      \
+                  "This assert is used to counter the false positive extra " \
+                  "semi-colon warnings")
+
+
+#define SET_VALUE(_factory, _param_type, _param_name, _config)               \
+    {                                                                        \
+        if (_config.contains(#_param_name)) {                                \
+            _factory.with_##_param_name(gko::config::get_value<_param_type>( \
+                _config.at(#_param_name)));                                  \
+        }                                                                    \
+    }                                                                        \
+    static_assert(true,                                                      \
+                  "This assert is used to counter the false positive extra " \
+                  "semi-colon warnings")
+
+
 // If we do not put the build_from_config in the class directly, the following
 // can also be in internal header.
 template <typename T>
diff --git a/core/config/dispatch.hpp b/core/config/dispatch.hpp
index a44ba148d7d..f0c448aeced 100644
--- a/core/config/dispatch.hpp
+++ b/core/config/dispatch.hpp
@@ -56,24 +56,26 @@ namespace config {
  * build_from_config(Config, registry, std::shared_ptr<const Executor>,
  * TypeDescriptor)
  */
-template <template <class...> class Base, typename... Types>
-std::unique_ptr<LinOpFactory> dispatch(std::string str,
-                                       const gko::config::Config& config,
-                                       const gko::config::registry& context,
-                                       std::shared_ptr<const Executor>& exec,
-                                       const gko::config::TypeDescriptor& td)
+template <typename ReturnType, template <class...> class Base,
+          typename... Types>
+std::unique_ptr<ReturnType> dispatch(std::string str,
+                                     const gko::config::Config& config,
+                                     const gko::config::registry& context,
+                                     std::shared_ptr<const Executor>& exec,
+                                     const gko::config::TypeDescriptor& td)
 {
     return Base<Types...>::build_from_config(config, context, exec, td);
 }
 
 // When the dispatch does not find match from the given list.
-template <template <class...> class Base, typename... Types, typename... List>
-std::unique_ptr<LinOpFactory> dispatch(std::string str,
-                                       const gko::config::Config& config,
-                                       const gko::config::registry& context,
-                                       std::shared_ptr<const Executor>& exec,
-                                       const gko::config::TypeDescriptor& td,
-                                       syn::type_list<>, List... list)
+template <typename ReturnType, template <class...> class Base,
+          typename... Types, typename... List>
+std::unique_ptr<ReturnType> dispatch(std::string str,
+                                     const gko::config::Config& config,
+                                     const gko::config::registry& context,
+                                     std::shared_ptr<const Executor>& exec,
+                                     const gko::config::TypeDescriptor& td,
+                                     syn::type_list<>, List... list)
 {
     throw std::runtime_error("Not Found");
 }
@@ -87,24 +89,24 @@ std::unique_ptr<LinOpFactory> dispatch(std::string str,
  * @param type_list  the type list for checking
  * @param list...  the type list for the rest type
  */
-template <template <class...> class Base, typename... Types, typename S,
-          typename... T, typename... List>
-std::unique_ptr<LinOpFactory> dispatch(std::string str,
-                                       const gko::config::Config& config,
-                                       const gko::config::registry& context,
-                                       std::shared_ptr<const Executor>& exec,
-                                       const gko::config::TypeDescriptor& td,
-                                       syn::type_list<S, T...>, List... list)
+template <typename ReturnType, template <class...> class Base,
+          typename... Types, typename S, typename... T, typename... List>
+std::unique_ptr<ReturnType> dispatch(std::string str,
+                                     const gko::config::Config& config,
+                                     const gko::config::registry& context,
+                                     std::shared_ptr<const Executor>& exec,
+                                     const gko::config::TypeDescriptor& td,
+                                     syn::type_list<S, T...>, List... list)
 {
     auto pos = str.find(",");
     auto item = str.substr(0, pos);
     auto res = (pos == std::string::npos) ? "" : str.substr(pos + 1);
     if (item == type_string<S>::str()) {
-        return dispatch<Base, Types..., S>(res, config, context, exec, td,
-                                           list...);
+        return dispatch<ReturnType, Base, Types..., S>(res, config, context,
+                                                       exec, td, list...);
     } else {
-        return dispatch<Base, Types...>(str, config, context, exec, td,
-                                        syn::type_list<T...>(), list...);
+        return dispatch<ReturnType, Base, Types...>(
+            str, config, context, exec, td, syn::type_list<T...>(), list...);
     }
 }
 
diff --git a/core/config/stop_config.cpp b/core/config/stop_config.cpp
new file mode 100644
index 00000000000..600d3af34ae
--- /dev/null
+++ b/core/config/stop_config.cpp
@@ -0,0 +1,163 @@
+#include <ginkgo/core/config/config.hpp>
+#include <ginkgo/core/config/registry.hpp>
+#include <ginkgo/core/stop/criterion.hpp>
+#include <ginkgo/core/stop/iteration.hpp>
+#include <ginkgo/core/stop/residual_norm.hpp>
+#include <ginkgo/core/stop/time.hpp>
+#include "core/config/config.hpp"
+#include "core/config/dispatch.hpp"
+
+namespace gko {
+namespace config {
+
+
+inline std::unique_ptr<stop::CriterionFactory> configure_time(
+    const item& item, const registry& context,
+    std::shared_ptr<const Executor> exec, TypeDescriptor td)
+{
+    auto factory = stop::Time::build();
+    SET_VALUE(factory, long long int, time_limit, item);
+    return factory.on(exec);
+}
+
+
+inline std::unique_ptr<stop::CriterionFactory> configure_iter(
+    const item& item, const registry& context,
+    std::shared_ptr<const Executor> exec, TypeDescriptor td)
+{
+    auto factory = stop::Iteration::build();
+    SET_VALUE(factory, size_type, max_iters, item);
+    return factory.on(exec);
+}
+
+
+stop::mode get_mode(const std::string& str)
+{
+    if (str == "absolute") {
+        return stop::mode::absolute;
+    } else if (str == "initial_resnorm") {
+        return stop::mode::initial_resnorm;
+    } else if (str == "rhs_norm") {
+        return stop::mode::rhs_norm;
+    }
+}
+
+
+template <typename ValueType>
+class ResidualNormConfigurer {
+public:
+    static std::unique_ptr<typename stop::ResidualNorm<ValueType>::Factory>
+    build_from_config(const gko::config::Config& config,
+                      const gko::config::registry& context,
+                      std::shared_ptr<const Executor> exec,
+                      gko::config::TypeDescriptor td_for_child)
+    {
+        auto factory = stop::ResidualNorm<ValueType>::build();
+        // SET_VALUE(factory, remove_complex<ValueType>, reduction_factor,
+        // item);
+        if (config.contains("baseline")) {
+            factory.with_baseline(
+                get_mode(config.at("baseline").get_data<std::string>()));
+        }
+        return factory.on(exec);
+    }
+};
+
+
+inline std::unique_ptr<stop::CriterionFactory> configure_residual(
+    const item& item, const registry& context,
+    std::shared_ptr<const Executor> exec, TypeDescriptor td)
+{
+    auto updated = update_type(item, td);
+    return dispatch<stop::CriterionFactory, ResidualNormConfigurer>(
+        updated.first, item, context, exec, updated, value_type_list());
+}
+
+
+template <typename ValueType>
+class ImplicitResidualNormConfigurer {
+public:
+    static std::unique_ptr<
+        typename stop::ImplicitResidualNorm<ValueType>::Factory>
+    build_from_config(const gko::config::Config& config,
+                      const gko::config::registry& context,
+                      std::shared_ptr<const Executor> exec,
+                      gko::config::TypeDescriptor td_for_child)
+    {
+        auto factory = stop::ImplicitResidualNorm<ValueType>::build();
+        // SET_VALUE(factory, remove_complex<ValueType>, reduction_factor,
+        // item);
+        if (config.contains("baseline")) {
+            factory.with_baseline(
+                get_mode(config.at("baseline").get_data<std::string>()));
+        }
+        return factory.on(exec);
+    }
+};
+
+
+inline std::unique_ptr<stop::CriterionFactory> configure_implicit_residual(
+    const item& item, const registry& context,
+    std::shared_ptr<const Executor> exec, TypeDescriptor td)
+{
+    auto updated = update_type(item, td);
+    return dispatch<stop::CriterionFactory, ImplicitResidualNormConfigurer>(
+        updated.first, item, context, exec, updated, value_type_list());
+}
+
+
+template <>
+std::shared_ptr<const stop::CriterionFactory>
+get_pointer<const stop::CriterionFactory>(const item& item,
+                                          const registry& context,
+                                          std::shared_ptr<const Executor> exec,
+                                          TypeDescriptor td)
+{
+    std::shared_ptr<const stop::CriterionFactory> ptr;
+    if (item.is(pnode::status_t::object)) {
+        return context.search_data<stop::CriterionFactory>(
+            item.get_data<std::string>());
+    } else if (item.is(pnode::status_t::list)) {
+        static std::map<
+            std::string,
+            std::function<std::unique_ptr<gko::stop::CriterionFactory>(
+                const Config&, const registry&,
+                std::shared_ptr<const Executor>&, TypeDescriptor)>>
+            criterion_map{
+                {{"Time", configure_time},
+                 {"Iteration", configure_iter},
+                 {"ResidualNorm", configure_residual},
+                 {"ImplicitResidualNorm", configure_implicit_residual}}};
+        return criterion_map.at(item.at("Type").get_data<std::string>())(
+            item, context, exec, td);
+    }
+    // handle object is item
+    assert(ptr.get() != nullptr);
+    return std::move(ptr);
+}
+
+template <>
+std::vector<std::shared_ptr<const stop::CriterionFactory>>
+get_pointer_vector<const stop::CriterionFactory>(
+    const item& item, const registry& context,
+    std::shared_ptr<const Executor> exec, TypeDescriptor td)
+{
+    std::vector<std::shared_ptr<const stop::CriterionFactory>> res;
+    if (item.is(pnode::status_t::array)) {
+        for (const auto& it : item.get_array()) {
+            res.push_back(get_pointer<const stop::CriterionFactory>(it, context,
+                                                                    exec, td));
+        }
+    } else {
+        res.push_back(
+            get_pointer<const stop::CriterionFactory>(item, context, exec, td));
+    }
+    // TODO: handle shortcut version by item.is(pnode::status_t::list) &&
+    // !item.contains("Type")
+
+    return res;
+}
+
+
+}  // namespace config
+}  // namespace gko
\ No newline at end of file
diff --git a/core/solver/cg.cpp b/core/solver/cg.cpp
index 8e8ac9c3f22..47ffc7514fd 100644
--- a/core/solver/cg.cpp
+++ b/core/solver/cg.cpp
@@ -38,14 +38,14 @@ class CgConfigurer {
                       std::shared_ptr<const Executor> exec,
                       gko::config::TypeDescriptor td_for_child)
     {
-        auto factory = solver::Cg<ValueType>::Factory::create();
+        auto factory = solver::Cg<ValueType>::build();
         SET_POINTER(factory, const LinOp, generated_preconditioner, config,
                     context, exec, td_for_child);
         // handle parameter requires exec
         // criteria and preconditioner are almost in each solver -> to another
         // function.
-        factory.with_criteria(
-            gko::stop::Iteration::build().with_max_iters(1u).on(exec));
+        SET_POINTER_VECTOR(factory, const stop::CriterionFactory, criteria,
+                           config, context, exec, td_for_child);
         SET_POINTER(factory, const LinOpFactory, preconditioner, config,
                     context, exec, td_for_child);
         // can also handle preconditioner, criterion here if they are in
@@ -62,8 +62,8 @@ build_from_config<static_cast<int>(gko::config::LinOpFactoryType::Cg)>(
     std::shared_ptr<const Executor>& exec, gko::config::TypeDescriptor td)
 {
     auto updated = update_type(config, td);
-    return dispatch<CgConfigurer>(updated.first, config, context, exec, updated,
-                                  value_type_list());
+    return dispatch<gko::LinOpFactory, CgConfigurer>(
+        updated.first, config, context, exec, updated, value_type_list());
 }
 
 
diff --git a/core/test/config/config.cpp b/core/test/config/config.cpp
index 4ad7d9c2a70..b9488da07b5 100644
--- a/core/test/config/config.cpp
+++ b/core/test/config/config.cpp
@@ -54,6 +54,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 namespace {
 
 
+using gko::config::pnode;
+
+
 template <typename T>
 class Config : public ::testing::Test {
 protected:
@@ -62,19 +65,18 @@ class Config : public ::testing::Test {
     Config()
         : exec(gko::ReferenceExecutor::create()),
           mtx(gko::initialize<Mtx>(
-              {{2, -1.0, 0.0}, {-1.0, 2, -1.0}, {0.0, -1.0, 2}}, exec))
+              {{2, -1.0, 0.0}, {-1.0, 2, -1.0}, {0.0, -1.0, 2}}, exec)),
+          stop_config({{"Type", pnode{"Iteration"}}, {"max_iters", pnode{1}}})
     {}
 
     std::shared_ptr<const gko::Executor> exec;
     std::shared_ptr<Mtx> mtx;
+    pnode stop_config;
 };
 
 TYPED_TEST_SUITE(Config, gko::test::ValueTypes, TypenameNameGenerator);
 
 
-using gko::config::pnode;
-
-
 TYPED_TEST(Config, GenerateMap)
 {
     ASSERT_NO_THROW(gko::config::generate_config_map());
@@ -86,7 +88,7 @@ TYPED_TEST(Config, GenerateObjectWithoutDefault)
     auto config_map = gko::config::generate_config_map();
     auto reg = gko::config::registry(config_map);
 
-    pnode p{{{"ValueType", pnode{"double"}}}};
+    pnode p{{{"ValueType", pnode{"double"}}, {"criteria", this->stop_config}}};
     auto obj = gko::config::build_from_config<0>(p, reg, this->exec);
 
     ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get()),
@@ -100,7 +102,8 @@ TYPED_TEST(Config, GenerateObjectWithData)
     auto reg = gko::config::registry(config_map);
     reg.emplace("precond", this->mtx);
 
-    pnode p{{{"generated_preconditioner", pnode{"precond"}}}};
+    pnode p{{{"generated_preconditioner", pnode{"precond"}},
+             {"criteria", this->stop_config}}};
     auto obj =
         gko::config::build_from_config<0>(p, reg, this->exec, {"float", ""});
 
@@ -118,8 +121,9 @@ TYPED_TEST(Config, GenerateObjectWithPreconditioner)
     auto config_map = gko::config::generate_config_map();
     auto reg = gko::config::registry(config_map);
 
-    pnode p{{{"ValueType", pnode{"double"}}}};
-    p.get_list()["preconditioner"] = pnode{{{"Type", pnode{"Cg"}}}};
+    pnode p{{{"ValueType", pnode{"double"}}, {"criteria", this->stop_config}}};
+    p.get_list()["preconditioner"] =
+        pnode{{{"Type", pnode{"Cg"}}, {"criteria", this->stop_config}}};
     auto obj = gko::config::build_from_config<0>(p, reg, this->exec);
 
     ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get()),
@@ -146,7 +150,7 @@ TYPED_TEST(Config, GenerateObjectWithCustomBuild)
     };
     auto reg = gko::config::registry(config_map);
 
-    pnode p{{{"ValueType", pnode{"double"}}}};
+    pnode p{{{"ValueType", pnode{"double"}}, {"criteria", this->stop_config}}};
     p.get_list()["preconditioner"] = pnode{{{"Type", pnode{"Custom"}}}};
     auto obj =
         gko::config::build_from_config<0>(p, reg, this->exec, {"double", ""});

From 0c2506325a4892361313a7ca4c83d7be24232118 Mon Sep 17 00:00:00 2001
From: "Yu-Hsiang M. Tsai" <yhmtsai@gmail.com>
Date: Wed, 16 Aug 2023 16:46:48 +0200
Subject: [PATCH 09/25] add registry test

---
 core/config/config.cpp                  |   6 +-
 core/config/config.hpp                  |  59 ++++----
 core/config/dispatch.hpp                |  25 ++--
 core/config/stop_config.cpp             | 111 +++++++++-----
 core/solver/cg.cpp                      |  11 +-
 core/test/config/CMakeLists.txt         |   1 +
 core/test/config/config.cpp             |   4 +-
 core/test/config/registry.cpp           | 183 ++++++++++++++++++++++++
 include/ginkgo/core/config/config.hpp   |  10 +-
 include/ginkgo/core/config/registry.hpp |  69 +++++----
 10 files changed, 346 insertions(+), 133 deletions(-)
 create mode 100644 core/test/config/registry.cpp

diff --git a/core/config/config.cpp b/core/config/config.cpp
index da5f98dfd39..5a278861ef9 100644
--- a/core/config/config.cpp
+++ b/core/config/config.cpp
@@ -40,15 +40,15 @@ namespace gko {
 namespace config {
 
 
-BuildFromConfigMap generate_config_map()
+buildfromconfig_map generate_config_map()
 {
     return {{"Cg", build_from_config<LinOpFactoryType::Cg>}};
 }
 
 
 std::unique_ptr<gko::LinOpFactory> build_from_config(
-    const gko::config::Config& config, const gko::config::registry& context,
-    std::shared_ptr<const Executor>& exec, TypeDescriptor td)
+    const pnode& config, const registry& context,
+    std::shared_ptr<const Executor>& exec, type_descriptor td)
 {
     if (config.contains("Type")) {
         auto func = context.get_build_map().at(
diff --git a/core/config/config.hpp b/core/config/config.hpp
index 0843b7f3973..31b7def40b4 100644
--- a/core/config/config.hpp
+++ b/core/config/config.hpp
@@ -34,11 +34,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define GKO_CORE_CONFIG_CONFIG_HPP_
 
 
+#include <ginkgo/core/config/config.hpp>
+
+
 #include <string>
 
 
 #include <ginkgo/core/base/lin_op.hpp>
-#include <ginkgo/core/config/config.hpp>
 #include <ginkgo/core/config/registry.hpp>
 #include <ginkgo/core/stop/criterion.hpp>
 
@@ -51,10 +53,10 @@ namespace config {
  *
  * @note It might update the unused type for the current class.
  */
-inline TypeDescriptor update_type(const Config& config,
-                                  const TypeDescriptor& td)
+inline type_descriptor update_type(const pnode& config,
+                                   const type_descriptor& td)
 {
-    TypeDescriptor updated = td;
+    type_descriptor updated = td;
 
     if (config.contains("ValueType")) {
         updated.first = config.at("ValueType").get_data<std::string>();
@@ -66,58 +68,57 @@ inline TypeDescriptor update_type(const Config& config,
 }
 
 
-using item = pnode;
-
 template <typename T>
-inline std::shared_ptr<T> get_pointer(const item& item, const registry& context,
+inline std::shared_ptr<T> get_pointer(const pnode& config,
+                                      const registry& context,
                                       std::shared_ptr<const Executor> exec,
-                                      TypeDescriptor td)
+                                      type_descriptor td)
 {
     std::shared_ptr<T> ptr;
     using T_non_const = std::remove_const_t<T>;
-    ptr = context.search_data<T_non_const>(item.get_data<std::string>());
+    ptr = context.search_data<T_non_const>(config.get_data<std::string>());
     assert(ptr.get() != nullptr);
     return std::move(ptr);
 }
 
 template <>
 inline std::shared_ptr<const LinOpFactory> get_pointer<const LinOpFactory>(
-    const item& item, const registry& context,
-    std::shared_ptr<const Executor> exec, TypeDescriptor td)
+    const pnode& config, const registry& context,
+    std::shared_ptr<const Executor> exec, type_descriptor td)
 {
     std::shared_ptr<const LinOpFactory> ptr;
-    if (item.is(pnode::status_t::object)) {
-        ptr = context.search_data<LinOpFactory>(item.get_data<std::string>());
-    } else if (item.is(pnode::status_t::list)) {
-        ptr = build_from_config(item, context, exec, td);
+    if (config.is(pnode::status_t::object)) {
+        ptr = context.search_data<LinOpFactory>(config.get_data<std::string>());
+    } else if (config.is(pnode::status_t::list)) {
+        ptr = build_from_config(config, context, exec, td);
     }
-    // handle object is item
+    // handle object is config
     assert(ptr.get() != nullptr);
     return std::move(ptr);
 }
 
 template <>
 std::shared_ptr<const stop::CriterionFactory>
-get_pointer<const stop::CriterionFactory>(const item& item,
+get_pointer<const stop::CriterionFactory>(const pnode& config,
                                           const registry& context,
                                           std::shared_ptr<const Executor> exec,
-                                          TypeDescriptor td);
+                                          type_descriptor td);
 
 
 template <typename T>
 inline std::vector<std::shared_ptr<T>> get_pointer_vector(
-    const item& item, const registry& context,
-    std::shared_ptr<const Executor> exec, TypeDescriptor td)
+    const pnode& config, const registry& context,
+    std::shared_ptr<const Executor> exec, type_descriptor td)
 {
     std::vector<std::shared_ptr<T>> res;
-    // for loop in item
-    if (item.is(pnode::status_t::array)) {
-        for (const auto& it : item.get_array()) {
+    // for loop in config
+    if (config.is(pnode::status_t::array)) {
+        for (const auto& it : config.get_array()) {
             res.push_back(get_pointer<T>(it, context, exec, td));
         }
     } else {
-        // only one item can be passed without array
-        res.push_back(get_pointer<T>(item, context, exec, td));
+        // only one config can be passed without array
+        res.push_back(get_pointer<T>(config, context, exec, td));
     }
 
     return res;
@@ -126,15 +127,15 @@ inline std::vector<std::shared_ptr<T>> get_pointer_vector(
 template <>
 std::vector<std::shared_ptr<const stop::CriterionFactory>>
 get_pointer_vector<const stop::CriterionFactory>(
-    const item& item, const registry& context,
-    std::shared_ptr<const Executor> exec, TypeDescriptor td);
+    const pnode& config, const registry& context,
+    std::shared_ptr<const Executor> exec, type_descriptor td);
 
 
 template <typename IndexType, typename = typename std::enable_if<
                                   std::is_integral<IndexType>::value>::type>
-inline IndexType get_value(const item& item)
+inline IndexType get_value(const pnode& config)
 {
-    auto val = item.get_data<long long int>();
+    auto val = config.get_data<long long int>();
     assert(val <= std::numeric_limits<IndexType>::max() &&
            val >= std::numeric_limits<IndexType>::min());
     return static_cast<IndexType>(val);
diff --git a/core/config/dispatch.hpp b/core/config/dispatch.hpp
index f0c448aeced..33a466bdde4 100644
--- a/core/config/dispatch.hpp
+++ b/core/config/dispatch.hpp
@@ -53,16 +53,15 @@ namespace config {
 /**
  * This function is to dispatch the type from runtime parameter.
  * The concrete class need to have static member function
- * build_from_config(Config, registry, std::shared_ptr<const Executor>,
- * TypeDescriptor)
+ * build_from_config(pnode, registry, std::shared_ptr<const Executor>,
+ * type_descriptor)
  */
 template <typename ReturnType, template <class...> class Base,
           typename... Types>
-std::unique_ptr<ReturnType> dispatch(std::string str,
-                                     const gko::config::Config& config,
-                                     const gko::config::registry& context,
+std::unique_ptr<ReturnType> dispatch(std::string str, const pnode& config,
+                                     const registry& context,
                                      std::shared_ptr<const Executor>& exec,
-                                     const gko::config::TypeDescriptor& td)
+                                     const type_descriptor& td)
 {
     return Base<Types...>::build_from_config(config, context, exec, td);
 }
@@ -70,11 +69,10 @@ std::unique_ptr<ReturnType> dispatch(std::string str,
 // When the dispatch does not find match from the given list.
 template <typename ReturnType, template <class...> class Base,
           typename... Types, typename... List>
-std::unique_ptr<ReturnType> dispatch(std::string str,
-                                     const gko::config::Config& config,
-                                     const gko::config::registry& context,
+std::unique_ptr<ReturnType> dispatch(std::string str, const pnode& config,
+                                     const registry& context,
                                      std::shared_ptr<const Executor>& exec,
-                                     const gko::config::TypeDescriptor& td,
+                                     const type_descriptor& td,
                                      syn::type_list<>, List... list)
 {
     throw std::runtime_error("Not Found");
@@ -91,11 +89,10 @@ std::unique_ptr<ReturnType> dispatch(std::string str,
  */
 template <typename ReturnType, template <class...> class Base,
           typename... Types, typename S, typename... T, typename... List>
-std::unique_ptr<ReturnType> dispatch(std::string str,
-                                     const gko::config::Config& config,
-                                     const gko::config::registry& context,
+std::unique_ptr<ReturnType> dispatch(std::string str, const pnode& config,
+                                     const registry& context,
                                      std::shared_ptr<const Executor>& exec,
-                                     const gko::config::TypeDescriptor& td,
+                                     const type_descriptor& td,
                                      syn::type_list<S, T...>, List... list)
 {
     auto pos = str.find(",");
diff --git a/core/config/stop_config.cpp b/core/config/stop_config.cpp
index 600d3af34ae..45fb0552a4f 100644
--- a/core/config/stop_config.cpp
+++ b/core/config/stop_config.cpp
@@ -1,9 +1,43 @@
+/*******************************<GINKGO LICENSE>******************************
+Copyright (c) 2017-2023, the Ginkgo authors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+******************************<GINKGO LICENSE>*******************************/
+
 #include <ginkgo/core/config/config.hpp>
 #include <ginkgo/core/config/registry.hpp>
 #include <ginkgo/core/stop/criterion.hpp>
 #include <ginkgo/core/stop/iteration.hpp>
 #include <ginkgo/core/stop/residual_norm.hpp>
 #include <ginkgo/core/stop/time.hpp>
+
+
 #include "core/config/config.hpp"
 #include "core/config/dispatch.hpp"
 
@@ -12,21 +46,21 @@ namespace config {
 
 
 inline std::unique_ptr<stop::CriterionFactory> configure_time(
-    const item& item, const registry& context,
-    std::shared_ptr<const Executor> exec, TypeDescriptor td)
+    const pnode& config, const registry& context,
+    std::shared_ptr<const Executor> exec, type_descriptor td)
 {
     auto factory = stop::Time::build();
-    SET_VALUE(factory, long long int, time_limit, item);
+    SET_VALUE(factory, long long int, time_limit, config);
     return factory.on(exec);
 }
 
 
 inline std::unique_ptr<stop::CriterionFactory> configure_iter(
-    const item& item, const registry& context,
-    std::shared_ptr<const Executor> exec, TypeDescriptor td)
+    const pnode& config, const registry& context,
+    std::shared_ptr<const Executor> exec, type_descriptor td)
 {
     auto factory = stop::Iteration::build();
-    SET_VALUE(factory, size_type, max_iters, item);
+    SET_VALUE(factory, size_type, max_iters, config);
     return factory.on(exec);
 }
 
@@ -47,14 +81,14 @@ template <typename ValueType>
 class ResidualNormConfigurer {
 public:
     static std::unique_ptr<typename stop::ResidualNorm<ValueType>::Factory>
-    build_from_config(const gko::config::Config& config,
+    build_from_config(const gko::config::pnode& config,
                       const gko::config::registry& context,
                       std::shared_ptr<const Executor> exec,
-                      gko::config::TypeDescriptor td_for_child)
+                      gko::config::type_descriptor td_for_child)
     {
         auto factory = stop::ResidualNorm<ValueType>::build();
         // SET_VALUE(factory, remove_complex<ValueType>, reduction_factor,
-        // item);
+        // config);
         if (config.contains("baseline")) {
             factory.with_baseline(
                 get_mode(config.at("baseline").get_data<std::string>()));
@@ -65,12 +99,12 @@ class ResidualNormConfigurer {
 
 
 inline std::unique_ptr<stop::CriterionFactory> configure_residual(
-    const item& item, const registry& context,
-    std::shared_ptr<const Executor> exec, TypeDescriptor td)
+    const pnode& config, const registry& context,
+    std::shared_ptr<const Executor> exec, type_descriptor td)
 {
-    auto updated = update_type(item, td);
+    auto updated = update_type(config, td);
     return dispatch<stop::CriterionFactory, ResidualNormConfigurer>(
-        updated.first, item, context, exec, updated, value_type_list());
+        updated.first, config, context, exec, updated, value_type_list());
 }
 
 
@@ -79,14 +113,14 @@ class ImplicitResidualNormConfigurer {
 public:
     static std::unique_ptr<
         typename stop::ImplicitResidualNorm<ValueType>::Factory>
-    build_from_config(const gko::config::Config& config,
+    build_from_config(const gko::config::pnode& config,
                       const gko::config::registry& context,
                       std::shared_ptr<const Executor> exec,
-                      gko::config::TypeDescriptor td_for_child)
+                      gko::config::type_descriptor td_for_child)
     {
         auto factory = stop::ImplicitResidualNorm<ValueType>::build();
         // SET_VALUE(factory, remove_complex<ValueType>, reduction_factor,
-        // item);
+        // config);
         if (config.contains("baseline")) {
             factory.with_baseline(
                 get_mode(config.at("baseline").get_data<std::string>()));
@@ -97,41 +131,40 @@ class ImplicitResidualNormConfigurer {
 
 
 inline std::unique_ptr<stop::CriterionFactory> configure_implicit_residual(
-    const item& item, const registry& context,
-    std::shared_ptr<const Executor> exec, TypeDescriptor td)
+    const pnode& config, const registry& context,
+    std::shared_ptr<const Executor> exec, type_descriptor td)
 {
-    auto updated = update_type(item, td);
+    auto updated = update_type(config, td);
     return dispatch<stop::CriterionFactory, ImplicitResidualNormConfigurer>(
-        updated.first, item, context, exec, updated, value_type_list());
+        updated.first, config, context, exec, updated, value_type_list());
 }
 
 
 template <>
 std::shared_ptr<const stop::CriterionFactory>
-get_pointer<const stop::CriterionFactory>(const item& item,
+get_pointer<const stop::CriterionFactory>(const pnode& config,
                                           const registry& context,
                                           std::shared_ptr<const Executor> exec,
-                                          TypeDescriptor td)
+                                          type_descriptor td)
 {
     std::shared_ptr<const stop::CriterionFactory> ptr;
-    if (item.is(pnode::status_t::object)) {
+    if (config.is(pnode::status_t::object)) {
         return context.search_data<stop::CriterionFactory>(
-            item.get_data<std::string>());
-    } else if (item.is(pnode::status_t::list)) {
+            config.get_data<std::string>());
+    } else if (config.is(pnode::status_t::list)) {
         static std::map<
             std::string,
             std::function<std::unique_ptr<gko::stop::CriterionFactory>(
-                const Config&, const registry&,
-                std::shared_ptr<const Executor>&, TypeDescriptor)>>
+                const pnode&, const registry&, std::shared_ptr<const Executor>&,
+                type_descriptor)>>
             criterion_map{
                 {{"Time", configure_time},
                  {"Iteration", configure_iter},
                  {"ResidualNorm", configure_residual},
                  {"ImplicitResidualNorm", configure_implicit_residual}}};
-        return criterion_map.at(item.at("Type").get_data<std::string>())(
-            item, context, exec, td);
+        return criterion_map.at(config.at("Type").get_data<std::string>())(
+            config, context, exec, td);
     }
-    // handle object is item
     assert(ptr.get() != nullptr);
     return std::move(ptr);
 }
@@ -139,25 +172,25 @@ get_pointer<const stop::CriterionFactory>(const item& item,
 template <>
 std::vector<std::shared_ptr<const stop::CriterionFactory>>
 get_pointer_vector<const stop::CriterionFactory>(
-    const item& item, const registry& context,
-    std::shared_ptr<const Executor> exec, TypeDescriptor td)
+    const pnode& config, const registry& context,
+    std::shared_ptr<const Executor> exec, type_descriptor td)
 {
     std::vector<std::shared_ptr<const stop::CriterionFactory>> res;
-    if (item.is(pnode::status_t::array)) {
-        for (const auto& it : item.get_array()) {
+    if (config.is(pnode::status_t::array)) {
+        for (const auto& it : config.get_array()) {
             res.push_back(get_pointer<const stop::CriterionFactory>(it, context,
                                                                     exec, td));
         }
     } else {
-        res.push_back(
-            get_pointer<const stop::CriterionFactory>(item, context, exec, td));
+        res.push_back(get_pointer<const stop::CriterionFactory>(config, context,
+                                                                exec, td));
     }
-    // TODO: handle shortcut version by item.is(pnode::status_t::list) &&
-    // !item.contains("Type")
+    // TODO: handle shortcut version by config.is(pnode::status_t::list) &&
+    // !config.contains("Type")
 
     return res;
 }
 
 
 }  // namespace config
-}  // namespace gko
\ No newline at end of file
+}  // namespace gko
diff --git a/core/solver/cg.cpp b/core/solver/cg.cpp
index 47ffc7514fd..4469a7fb86a 100644
--- a/core/solver/cg.cpp
+++ b/core/solver/cg.cpp
@@ -33,10 +33,9 @@ template <typename ValueType>
 class CgConfigurer {
 public:
     static std::unique_ptr<typename solver::Cg<ValueType>::Factory>
-    build_from_config(const gko::config::Config& config,
-                      const gko::config::registry& context,
+    build_from_config(const pnode& config, const registry& context,
                       std::shared_ptr<const Executor> exec,
-                      gko::config::TypeDescriptor td_for_child)
+                      type_descriptor td_for_child)
     {
         auto factory = solver::Cg<ValueType>::build();
         SET_POINTER(factory, const LinOp, generated_preconditioner, config,
@@ -57,9 +56,9 @@ class CgConfigurer {
 
 template <>
 std::unique_ptr<gko::LinOpFactory>
-build_from_config<static_cast<int>(gko::config::LinOpFactoryType::Cg)>(
-    const gko::config::Config& config, const gko::config::registry& context,
-    std::shared_ptr<const Executor>& exec, gko::config::TypeDescriptor td)
+build_from_config<static_cast<int>(LinOpFactoryType::Cg)>(
+    const pnode& config, const registry& context,
+    std::shared_ptr<const Executor>& exec, gko::config::type_descriptor td)
 {
     auto updated = update_type(config, td);
     return dispatch<gko::LinOpFactory, CgConfigurer>(
diff --git a/core/test/config/CMakeLists.txt b/core/test/config/CMakeLists.txt
index 95ad05582cb..a8783cd4a20 100644
--- a/core/test/config/CMakeLists.txt
+++ b/core/test/config/CMakeLists.txt
@@ -1,2 +1,3 @@
 ginkgo_create_test(config)
 ginkgo_create_test(property_tree)
+ginkgo_create_test(registry)
diff --git a/core/test/config/config.cpp b/core/test/config/config.cpp
index b9488da07b5..3cd98d8af4b 100644
--- a/core/test/config/config.cpp
+++ b/core/test/config/config.cpp
@@ -139,10 +139,10 @@ TYPED_TEST(Config, GenerateObjectWithCustomBuild)
 {
     auto config_map = gko::config::generate_config_map();
 
-    config_map["Custom"] = [](const gko::config::Config& config,
+    config_map["Custom"] = [](const gko::config::pnode& config,
                               const gko::config::registry& context,
                               std::shared_ptr<const gko::Executor>& exec,
-                              gko::config::TypeDescriptor td_for_child) {
+                              gko::config::type_descriptor td_for_child) {
         return gko::solver::Bicg<double>::build()
             .with_criteria(
                 gko::stop::Iteration::build().with_max_iters(2u).on(exec))
diff --git a/core/test/config/registry.cpp b/core/test/config/registry.cpp
new file mode 100644
index 00000000000..0023e214ed0
--- /dev/null
+++ b/core/test/config/registry.cpp
@@ -0,0 +1,183 @@
+/*******************************<GINKGO LICENSE>******************************
+Copyright (c) 2017-2023, the Ginkgo authors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+******************************<GINKGO LICENSE>*******************************/
+
+#include <ginkgo/core/config/registry.hpp>
+
+
+#include <functional>
+#include <type_traits>
+
+
+#include <gtest/gtest.h>
+
+
+#include <ginkgo/core/base/exception.hpp>
+#include <ginkgo/core/base/executor.hpp>
+#include <ginkgo/core/matrix/dense.hpp>
+#include <ginkgo/core/solver/cg.hpp>
+#include <ginkgo/core/stop/iteration.hpp>
+#include <ginkgo/core/stop/time.hpp>
+
+
+#include "core/test/utils.hpp"
+
+
+class Registry : public ::testing::Test {
+protected:
+    using Matrix = gko::matrix::Dense<float>;
+    using Solver = gko::solver::Cg<float>;
+    using Stop = gko::stop::Iteration;
+
+    Registry()
+        : exec{gko::ReferenceExecutor::create()},
+          matrix{Matrix::create(exec)},
+          solver_factory{Solver::build().on(exec)},
+          stop_factory{Stop::build().on(exec)},
+          func{[](const gko::config::pnode& config,
+                  const gko::config::registry& context,
+                  std::shared_ptr<const gko::Executor>& exec,
+                  gko::config::type_descriptor td_for_child) {
+              return gko::solver::Cg<float>::build().on(exec);
+          }},
+          reg{{{"func", func}}}
+    {}
+
+    std::shared_ptr<const gko::Executor> exec;
+    std::shared_ptr<Matrix> matrix;
+    std::shared_ptr<typename Solver::Factory> solver_factory;
+    std::shared_ptr<typename Stop::Factory> stop_factory;
+    std::function<std::unique_ptr<gko::LinOpFactory>(
+        const gko::config::pnode&, const gko::config::registry&,
+        std::shared_ptr<const gko::Executor>&, gko::config::type_descriptor)>
+        func;
+    gko::config::registry reg;
+};
+
+
+TEST_F(Registry, InsertData)
+{
+    // Can put data
+    ASSERT_TRUE(reg.emplace("matrix", matrix));
+    ASSERT_TRUE(reg.emplace("solver_factory", solver_factory));
+    ASSERT_TRUE(reg.emplace("stop_factory", stop_factory));
+    // Do not insert the same key like normal map
+    ASSERT_FALSE(reg.emplace("matrix", matrix));
+    ASSERT_FALSE(reg.emplace("solver_factory", solver_factory));
+    ASSERT_FALSE(reg.emplace("stop_factory", stop_factory));
+}
+
+
+TEST_F(Registry, SearchData)
+{
+    reg.emplace("matrix", matrix);
+    reg.emplace("solver_factory", solver_factory);
+    reg.emplace("stop_factory", stop_factory);
+
+    auto found_matrix = reg.search_data<gko::LinOp>("matrix");
+    auto found_solver_factory =
+        reg.search_data<gko::LinOpFactory>("solver_factory");
+    auto found_stop_factory =
+        reg.search_data<gko::stop::CriterionFactory>("stop_factory");
+
+    // get correct ptrs
+    ASSERT_EQ(found_matrix, matrix);
+    ASSERT_EQ(found_solver_factory, solver_factory);
+    ASSERT_EQ(found_stop_factory, stop_factory);
+    // get correct types
+    ASSERT_TRUE((std::is_same<decltype(found_matrix),
+                              std::shared_ptr<gko::LinOp>>::value));
+    ASSERT_TRUE((std::is_same<decltype(found_solver_factory),
+                              std::shared_ptr<gko::LinOpFactory>>::value));
+    ASSERT_TRUE(
+        (std::is_same<decltype(found_stop_factory),
+                      std::shared_ptr<gko::stop::CriterionFactory>>::value));
+}
+
+
+TEST_F(Registry, SearchDataWithType)
+{
+    reg.emplace("matrix", matrix);
+    reg.emplace("solver_factory", solver_factory);
+    reg.emplace("stop_factory", stop_factory);
+
+    auto found_matrix = reg.search_data<Matrix>("matrix");
+    auto found_solver_factory =
+        reg.search_data<Solver::Factory>("solver_factory");
+    auto found_stop_factory = reg.search_data<Stop::Factory>("stop_factory");
+
+    // get correct ptrs
+    ASSERT_EQ(found_matrix, matrix);
+    ASSERT_EQ(found_solver_factory, solver_factory);
+    ASSERT_EQ(found_stop_factory, stop_factory);
+    // get correct types
+    ASSERT_TRUE(
+        (std::is_same<decltype(found_matrix), std::shared_ptr<Matrix>>::value));
+    ASSERT_TRUE(
+        (std::is_same<decltype(found_solver_factory),
+                      std::shared_ptr<typename Solver::Factory>>::value));
+    ASSERT_TRUE((std::is_same<decltype(found_stop_factory),
+                              std::shared_ptr<typename Stop::Factory>>::value));
+}
+
+
+TEST_F(Registry, ThrowIfNotFound)
+{
+    ASSERT_THROW(reg.search_data<gko::LinOp>("N"), std::out_of_range);
+    ASSERT_THROW(reg.search_data<gko::LinOpFactory>("N"), std::out_of_range);
+    ASSERT_THROW(reg.search_data<gko::stop::CriterionFactory>("N"),
+                 std::out_of_range);
+}
+
+
+TEST_F(Registry, ThrowWithWrongType)
+{
+    reg.emplace("matrix", matrix);
+    reg.emplace("solver_factory", solver_factory);
+    reg.emplace("stop_factory", stop_factory);
+
+    ASSERT_THROW(reg.search_data<gko::matrix::Dense<double>>("matrix"),
+                 gko::NotSupported);
+    ASSERT_THROW(
+        reg.search_data<gko::solver::Cg<double>::Factory>("solver_factory"),
+        gko::NotSupported);
+    ASSERT_THROW(reg.search_data<gko::stop::Time::Factory>("stop_factory"),
+                 gko::NotSupported);
+}
+
+
+TEST_F(Registry, GetBuildMap)
+{
+    auto factory = reg.get_build_map().at("func")(gko::config::pnode{"unused"},
+                                                  reg, exec, {"", ""});
+
+    ASSERT_NE(factory, nullptr);
+}
diff --git a/include/ginkgo/core/config/config.hpp b/include/ginkgo/core/config/config.hpp
index 8e7eb397f0d..9475ba28b55 100644
--- a/include/ginkgo/core/config/config.hpp
+++ b/include/ginkgo/core/config/config.hpp
@@ -55,17 +55,17 @@ enum LinOpFactoryType : int { Cg = 0 };
 // IT selection, it can be in detail namespace or hide it by structure
 template <int flag>
 std::unique_ptr<gko::LinOpFactory> build_from_config(
-    const gko::config::Config& config, const gko::config::registry& context,
-    std::shared_ptr<const Executor>& exec, TypeDescriptor td = {"", ""});
+    const pnode& config, const registry& context,
+    std::shared_ptr<const Executor>& exec, type_descriptor td = {"", ""});
 
 
 // The main function
 std::unique_ptr<gko::LinOpFactory> build_from_config(
-    const gko::config::Config& config, const gko::config::registry& context,
-    std::shared_ptr<const Executor>& exec, TypeDescriptor td = {"", ""});
+    const pnode& config, const registry& context,
+    std::shared_ptr<const Executor>& exec, type_descriptor td = {"", ""});
 
 
-BuildFromConfigMap generate_config_map();
+buildfromconfig_map generate_config_map();
 
 
 }  // namespace config
diff --git a/include/ginkgo/core/config/registry.hpp b/include/ginkgo/core/config/registry.hpp
index fb0a8ee08a1..3b02b2b6c1e 100644
--- a/include/ginkgo/core/config/registry.hpp
+++ b/include/ginkgo/core/config/registry.hpp
@@ -43,6 +43,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <ginkgo/core/base/lin_op.hpp>
 #include <ginkgo/core/base/types.hpp>
+#include <ginkgo/core/base/utils_helper.hpp>
 #include <ginkgo/core/config/property_tree.hpp>
 #include <ginkgo/core/stop/criterion.hpp>
 
@@ -51,18 +52,20 @@ namespace gko {
 namespace config {
 
 
-using LinOpMap = std::unordered_map<std::string, std::shared_ptr<LinOp>>;
-using LinOpFactoryMap =
+class registry;
+
+
+using linop_map = std::unordered_map<std::string, std::shared_ptr<LinOp>>;
+using linopfactory_map =
     std::unordered_map<std::string, std::shared_ptr<LinOpFactory>>;
-using CriterionFactoryMap =
+using criterionfactory_map =
     std::unordered_map<std::string, std::shared_ptr<stop::CriterionFactory>>;
-using Config = pnode;
-using TypeDescriptor = std::pair<std::string, std::string>;
-class registry;
-using BuildFunctionType = std::function<std::unique_ptr<gko::LinOpFactory>(
-    const Config&, const registry&, std::shared_ptr<const Executor>&,
-    TypeDescriptor)>;
-using BuildFromConfigMap = std::map<std::string, BuildFunctionType>;
+using type_descriptor = std::pair<std::string, std::string>;
+using buildfromconfig_map =
+    std::map<std::string,
+             std::function<std::unique_ptr<gko::LinOpFactory>(
+                 const pnode&, const registry&,
+                 std::shared_ptr<const Executor>&, type_descriptor)>>;
 
 
 /**
@@ -78,25 +81,25 @@ struct map_type {
 template <typename T>
 struct map_type<
     T, typename std::enable_if<std::is_convertible<T*, LinOp*>::value>::type> {
-    using type = LinOpMap;
+    using type = linop_map;
 };
 
 template <typename T>
 struct map_type<T, typename std::enable_if<
                        std::is_convertible<T*, LinOpFactory*>::value>::type> {
-    using type = LinOpFactoryMap;
+    using type = linopfactory_map;
 };
 
 template <typename T>
 struct map_type<T, typename std::enable_if<std::is_convertible<
                        T*, stop::CriterionFactory*>::value>::type> {
-    using type = CriterionFactoryMap;
+    using type = criterionfactory_map;
 };
 
 
 class registry {
 public:
-    registry(BuildFromConfigMap build_map) : build_map_(build_map) {}
+    registry(buildfromconfig_map build_map) : build_map_(build_map) {}
 
     /**
      * insert_data stores the data with the key.
@@ -107,9 +110,10 @@ class registry {
      * @param data  the shared pointer of the object
      */
     template <typename T>
-    void emplace(std::string key, std::shared_ptr<T> data)
+    bool emplace(std::string key, std::shared_ptr<T> data)
     {
-        this->get_map<T>().emplace(key, data);
+        auto it = this->get_map<T>().emplace(key, data);
+        return it.second;
     }
 
     /**
@@ -124,16 +128,12 @@ class registry {
     template <typename T>
     std::shared_ptr<T> search_data(std::string key) const
     {
-        auto idx = this->get_map<T>().find(key);
-        if (idx != this->get_map<T>().end()) {
-            return std::dynamic_pointer_cast<T>(idx->second);
-        }
-        // or throw the error
-        return nullptr;
+        return gko::as<T>(this->get_map<T>().at(key));
     }
 
-    const BuildFromConfigMap& get_build_map() const { return build_map_; }
+    const buildfromconfig_map& get_build_map() const { return build_map_; }
 
+protected:
     /**
      * get_map gets the member map
      *
@@ -153,7 +153,6 @@ class registry {
         return this->get_map_impl<typename map_type<T>::type>();
     }
 
-protected:
     /**
      * get_map_impl is the implementation of get_map
      *
@@ -168,46 +167,46 @@ class registry {
     const T& get_map_impl() const;
 
 private:
-    LinOpMap linop_map_;
-    LinOpFactoryMap linopfactory_map_;
-    CriterionFactoryMap criterionfactory_map_;
-    BuildFromConfigMap build_map_;
+    linop_map linop_map_;
+    linopfactory_map linopfactory_map_;
+    criterionfactory_map criterionfactory_map_;
+    buildfromconfig_map build_map_;
 };
 
 
 template <>
-inline LinOpMap& registry::get_map_impl<LinOpMap>()
+inline linop_map& registry::get_map_impl<linop_map>()
 {
     return linop_map_;
 }
 
 template <>
-inline LinOpFactoryMap& registry::get_map_impl<LinOpFactoryMap>()
+inline linopfactory_map& registry::get_map_impl<linopfactory_map>()
 {
     return linopfactory_map_;
 }
 
 template <>
-inline CriterionFactoryMap& registry::get_map_impl<CriterionFactoryMap>()
+inline criterionfactory_map& registry::get_map_impl<criterionfactory_map>()
 {
     return criterionfactory_map_;
 }
 
 template <>
-inline const LinOpMap& registry::get_map_impl<LinOpMap>() const
+inline const linop_map& registry::get_map_impl<linop_map>() const
 {
     return linop_map_;
 }
 
 template <>
-inline const LinOpFactoryMap& registry::get_map_impl<LinOpFactoryMap>() const
+inline const linopfactory_map& registry::get_map_impl<linopfactory_map>() const
 {
     return linopfactory_map_;
 }
 
 template <>
-inline const CriterionFactoryMap& registry::get_map_impl<CriterionFactoryMap>()
-    const
+inline const criterionfactory_map&
+registry::get_map_impl<criterionfactory_map>() const
 {
     return criterionfactory_map_;
 }

From 2941cb29700dd011d9ea5b33f042107a4be2df28 Mon Sep 17 00:00:00 2001
From: "Yu-Hsiang M. Tsai" <yhmtsai@gmail.com>
Date: Thu, 17 Aug 2023 11:12:12 +0200
Subject: [PATCH 10/25] throw gko::Error

---
 core/config/config.cpp                  | 5 ++++-
 core/config/dispatch.hpp                | 3 ++-
 core/config/stop_config.cpp             | 3 +++
 include/ginkgo/core/config/registry.hpp | 1 +
 4 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/core/config/config.cpp b/core/config/config.cpp
index 5a278861ef9..abdb5b71fd4 100644
--- a/core/config/config.cpp
+++ b/core/config/config.cpp
@@ -36,6 +36,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <map>
 
 
+#include <ginkgo/core/base/exception_helpers.hpp>
+
+
 namespace gko {
 namespace config {
 
@@ -55,7 +58,7 @@ std::unique_ptr<gko::LinOpFactory> build_from_config(
             config.at("Type").get_data<std::string>());
         return func(config, context, exec, td);
     }
-    return nullptr;
+    GKO_INVALID_STATE("Should contain Type property");
 }
 
 
diff --git a/core/config/dispatch.hpp b/core/config/dispatch.hpp
index 33a466bdde4..e6e8f1d0b58 100644
--- a/core/config/dispatch.hpp
+++ b/core/config/dispatch.hpp
@@ -38,6 +38,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <string>
 
 
+#include <ginkgo/core/base/exception_helpers.hpp>
 #include <ginkgo/core/config/config.hpp>
 #include <ginkgo/core/config/registry.hpp>
 #include <ginkgo/core/synthesizer/containers.hpp>
@@ -75,7 +76,7 @@ std::unique_ptr<ReturnType> dispatch(std::string str, const pnode& config,
                                      const type_descriptor& td,
                                      syn::type_list<>, List... list)
 {
-    throw std::runtime_error("Not Found");
+    GKO_INVALID_STATE("Can not figure out the actual type");
 }
 
 /**
diff --git a/core/config/stop_config.cpp b/core/config/stop_config.cpp
index 45fb0552a4f..5d5774585f2 100644
--- a/core/config/stop_config.cpp
+++ b/core/config/stop_config.cpp
@@ -30,6 +30,7 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ******************************<GINKGO LICENSE>*******************************/
 
+#include <ginkgo/core/base/exception_helpers.hpp>
 #include <ginkgo/core/config/config.hpp>
 #include <ginkgo/core/config/registry.hpp>
 #include <ginkgo/core/stop/criterion.hpp>
@@ -41,6 +42,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "core/config/config.hpp"
 #include "core/config/dispatch.hpp"
 
+
 namespace gko {
 namespace config {
 
@@ -74,6 +76,7 @@ stop::mode get_mode(const std::string& str)
     } else if (str == "rhs_norm") {
         return stop::mode::rhs_norm;
     }
+    GKO_INVALID_STATE("Not valid " + str);
 }
 
 
diff --git a/include/ginkgo/core/config/registry.hpp b/include/ginkgo/core/config/registry.hpp
index 3b02b2b6c1e..ac58696b7af 100644
--- a/include/ginkgo/core/config/registry.hpp
+++ b/include/ginkgo/core/config/registry.hpp
@@ -35,6 +35,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 
 #include <complex>
+#include <functional>
 #include <map>
 #include <string>
 #include <unordered_map>

From d52036d8ded90ba0e34dc5abbfeec905b741f05a Mon Sep 17 00:00:00 2001
From: "Yu-Hsiang M. Tsai" <yhmtsai@gmail.com>
Date: Thu, 17 Aug 2023 12:03:24 +0200
Subject: [PATCH 11/25] add get_value

---
 core/config/config.hpp      |  36 +++++++++++-
 core/config/stop_config.cpp |   6 +-
 core/test/config/config.cpp | 108 ++++++++++++++++++++++++++----------
 3 files changed, 114 insertions(+), 36 deletions(-)

diff --git a/core/config/config.hpp b/core/config/config.hpp
index 31b7def40b4..7212011ddfc 100644
--- a/core/config/config.hpp
+++ b/core/config/config.hpp
@@ -38,9 +38,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 
 #include <string>
+#include <type_traits>
 
 
+#include <ginkgo/core/base/exception_helpers.hpp>
 #include <ginkgo/core/base/lin_op.hpp>
+#include <ginkgo/core/base/math.hpp>
 #include <ginkgo/core/config/registry.hpp>
 #include <ginkgo/core/stop/criterion.hpp>
 
@@ -131,9 +134,10 @@ get_pointer_vector<const stop::CriterionFactory>(
     std::shared_ptr<const Executor> exec, type_descriptor td);
 
 
-template <typename IndexType, typename = typename std::enable_if<
-                                  std::is_integral<IndexType>::value>::type>
-inline IndexType get_value(const pnode& config)
+template <typename IndexType>
+inline
+    typename std::enable_if<std::is_integral<IndexType>::value, IndexType>::type
+    get_value(const pnode& config)
 {
     auto val = config.get_data<long long int>();
     assert(val <= std::numeric_limits<IndexType>::max() &&
@@ -141,6 +145,32 @@ inline IndexType get_value(const pnode& config)
     return static_cast<IndexType>(val);
 }
 
+template <typename ValueType>
+inline typename std::enable_if<std::is_floating_point<ValueType>::value,
+                               ValueType>::type
+get_value(const pnode& config)
+{
+    auto val = config.get_data<double>();
+    assert(val <= std::numeric_limits<ValueType>::max() &&
+           val >= -std::numeric_limits<ValueType>::max());
+    return static_cast<ValueType>(val);
+}
+
+template <typename ValueType>
+inline typename std::enable_if<gko::is_complex_s<ValueType>::value,
+                               ValueType>::type
+get_value(const pnode& config)
+{
+    using real_type = gko::remove_complex<ValueType>;
+    if (config.is(pnode::status_t::object)) {
+        return static_cast<ValueType>(get_value<real_type>(config));
+    } else if (config.is(pnode::status_t::array)) {
+        return ValueType{get_value<real_type>(config.at(0)),
+                         get_value<real_type>(config.at(1))};
+    }
+    GKO_INVALID_STATE("Can not get complex value");
+}
+
 
 #define SET_POINTER(_factory, _param_type, _param_name, _config, _context,     \
                     _exec, _td)                                                \
diff --git a/core/config/stop_config.cpp b/core/config/stop_config.cpp
index 5d5774585f2..c92dbe0b5e7 100644
--- a/core/config/stop_config.cpp
+++ b/core/config/stop_config.cpp
@@ -90,8 +90,7 @@ class ResidualNormConfigurer {
                       gko::config::type_descriptor td_for_child)
     {
         auto factory = stop::ResidualNorm<ValueType>::build();
-        // SET_VALUE(factory, remove_complex<ValueType>, reduction_factor,
-        // config);
+        SET_VALUE(factory, remove_complex<ValueType>, reduction_factor, config);
         if (config.contains("baseline")) {
             factory.with_baseline(
                 get_mode(config.at("baseline").get_data<std::string>()));
@@ -122,8 +121,7 @@ class ImplicitResidualNormConfigurer {
                       gko::config::type_descriptor td_for_child)
     {
         auto factory = stop::ImplicitResidualNorm<ValueType>::build();
-        // SET_VALUE(factory, remove_complex<ValueType>, reduction_factor,
-        // config);
+        SET_VALUE(factory, remove_complex<ValueType>, reduction_factor, config);
         if (config.contains("baseline")) {
             factory.with_baseline(
                 get_mode(config.at("baseline").get_data<std::string>()));
diff --git a/core/test/config/config.cpp b/core/test/config/config.cpp
index 3cd98d8af4b..6051a4812c2 100644
--- a/core/test/config/config.cpp
+++ b/core/test/config/config.cpp
@@ -48,16 +48,17 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <ginkgo/core/stop/residual_norm.hpp>
 
 
+#include "core/config/config.hpp"
 #include "core/test/config/utils.hpp"
 #include "core/test/utils.hpp"
 
+
 namespace {
 
 
-using gko::config::pnode;
+using namespace gko::config;
 
 
-template <typename T>
 class Config : public ::testing::Test {
 protected:
     using value_type = double;
@@ -74,38 +75,32 @@ class Config : public ::testing::Test {
     pnode stop_config;
 };
 
-TYPED_TEST_SUITE(Config, gko::test::ValueTypes, TypenameNameGenerator);
 
+TEST_F(Config, GenerateMap) { ASSERT_NO_THROW(generate_config_map()); }
 
-TYPED_TEST(Config, GenerateMap)
-{
-    ASSERT_NO_THROW(gko::config::generate_config_map());
-}
 
-
-TYPED_TEST(Config, GenerateObjectWithoutDefault)
+TEST_F(Config, GenerateObjectWithoutDefault)
 {
-    auto config_map = gko::config::generate_config_map();
-    auto reg = gko::config::registry(config_map);
+    auto config_map = generate_config_map();
+    auto reg = registry(config_map);
 
     pnode p{{{"ValueType", pnode{"double"}}, {"criteria", this->stop_config}}};
-    auto obj = gko::config::build_from_config<0>(p, reg, this->exec);
+    auto obj = build_from_config<0>(p, reg, this->exec);
 
     ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get()),
               nullptr);
 }
 
 
-TYPED_TEST(Config, GenerateObjectWithData)
+TEST_F(Config, GenerateObjectWithData)
 {
-    auto config_map = gko::config::generate_config_map();
-    auto reg = gko::config::registry(config_map);
+    auto config_map = generate_config_map();
+    auto reg = registry(config_map);
     reg.emplace("precond", this->mtx);
 
     pnode p{{{"generated_preconditioner", pnode{"precond"}},
              {"criteria", this->stop_config}}};
-    auto obj =
-        gko::config::build_from_config<0>(p, reg, this->exec, {"float", ""});
+    auto obj = build_from_config<0>(p, reg, this->exec, {"float", ""});
 
     ASSERT_NE(dynamic_cast<gko::solver::Cg<float>::Factory*>(obj.get()),
               nullptr);
@@ -116,15 +111,15 @@ TYPED_TEST(Config, GenerateObjectWithData)
 }
 
 
-TYPED_TEST(Config, GenerateObjectWithPreconditioner)
+TEST_F(Config, GenerateObjectWithPreconditioner)
 {
-    auto config_map = gko::config::generate_config_map();
-    auto reg = gko::config::registry(config_map);
+    auto config_map = generate_config_map();
+    auto reg = registry(config_map);
 
     pnode p{{{"ValueType", pnode{"double"}}, {"criteria", this->stop_config}}};
     p.get_list()["preconditioner"] =
         pnode{{{"Type", pnode{"Cg"}}, {"criteria", this->stop_config}}};
-    auto obj = gko::config::build_from_config<0>(p, reg, this->exec);
+    auto obj = build_from_config<0>(p, reg, this->exec);
 
     ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get()),
               nullptr);
@@ -135,25 +130,23 @@ TYPED_TEST(Config, GenerateObjectWithPreconditioner)
 }
 
 
-TYPED_TEST(Config, GenerateObjectWithCustomBuild)
+TEST_F(Config, GenerateObjectWithCustomBuild)
 {
-    auto config_map = gko::config::generate_config_map();
+    auto config_map = generate_config_map();
 
-    config_map["Custom"] = [](const gko::config::pnode& config,
-                              const gko::config::registry& context,
+    config_map["Custom"] = [](const pnode& config, const registry& context,
                               std::shared_ptr<const gko::Executor>& exec,
-                              gko::config::type_descriptor td_for_child) {
+                              type_descriptor td_for_child) {
         return gko::solver::Bicg<double>::build()
             .with_criteria(
                 gko::stop::Iteration::build().with_max_iters(2u).on(exec))
             .on(exec);
     };
-    auto reg = gko::config::registry(config_map);
+    auto reg = registry(config_map);
 
     pnode p{{{"ValueType", pnode{"double"}}, {"criteria", this->stop_config}}};
     p.get_list()["preconditioner"] = pnode{{{"Type", pnode{"Custom"}}}};
-    auto obj =
-        gko::config::build_from_config<0>(p, reg, this->exec, {"double", ""});
+    auto obj = build_from_config<0>(p, reg, this->exec, {"double", ""});
 
     ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get()),
               nullptr);
@@ -165,4 +158,61 @@ TYPED_TEST(Config, GenerateObjectWithCustomBuild)
 }
 
 
+TEST(GetValue, IndexType)
+{
+    long long int value = 123;
+    pnode config{value};
+
+    ASSERT_EQ(get_value<int>(config), value);
+    ASSERT_EQ(get_value<long>(config), value);
+    ASSERT_EQ(get_value<unsigned>(config), value);
+    ASSERT_EQ(get_value<long long int>(config), value);
+    ASSERT_EQ(typeid(get_value<int>(config)), typeid(int));
+    ASSERT_EQ(typeid(get_value<long>(config)), typeid(long));
+    ASSERT_EQ(typeid(get_value<unsigned>(config)), typeid(unsigned));
+    ASSERT_EQ(typeid(get_value<long long int>(config)), typeid(long long int));
+}
+
+
+TEST(GetValue, RealType)
+{
+    double value = 1.0;
+    pnode config{value};
+
+    ASSERT_EQ(get_value<float>(config), value);
+    ASSERT_EQ(get_value<double>(config), value);
+    ASSERT_EQ(typeid(get_value<float>(config)), typeid(float));
+    ASSERT_EQ(typeid(get_value<double>(config)), typeid(double));
+}
+
+
+TEST(GetValue, ComplexType)
+{
+    double real = 1.0;
+    double imag = -1.0;
+    pnode config{real};
+    pnode array_config;
+    array_config.get_array() = {pnode{real}, pnode{imag}};
+
+    // Only one value
+    ASSERT_EQ(get_value<std::complex<float>>(config),
+              std::complex<float>(real));
+    ASSERT_EQ(get_value<std::complex<double>>(config),
+              std::complex<double>(real));
+    ASSERT_EQ(typeid(get_value<std::complex<float>>(config)),
+              typeid(std::complex<float>));
+    ASSERT_EQ(typeid(get_value<std::complex<double>>(config)),
+              typeid(std::complex<double>));
+    // Two value [real, imag]
+    ASSERT_EQ(get_value<std::complex<float>>(array_config),
+              std::complex<float>(real, imag));
+    ASSERT_EQ(get_value<std::complex<double>>(array_config),
+              std::complex<double>(real, imag));
+    ASSERT_EQ(typeid(get_value<std::complex<float>>(array_config)),
+              typeid(std::complex<float>));
+    ASSERT_EQ(typeid(get_value<std::complex<double>>(array_config)),
+              typeid(std::complex<double>));
+}
+
+
 }  // namespace

From 8f66c8544f4197b4d95ec3869662a488f4a9a67c Mon Sep 17 00:00:00 2001
From: "Yu-Hsiang M. Tsai" <yhmtsai@gmail.com>
Date: Tue, 22 Aug 2023 11:11:15 +0200
Subject: [PATCH 12/25] update usage of property tree

---
 core/config/config.cpp      |  5 ++---
 core/config/config.hpp      | 30 +++++++++++++++---------------
 core/config/stop_config.cpp | 16 +++++++---------
 core/test/config/config.cpp |  5 +++--
 4 files changed, 27 insertions(+), 29 deletions(-)

diff --git a/core/config/config.cpp b/core/config/config.cpp
index abdb5b71fd4..f124927c222 100644
--- a/core/config/config.cpp
+++ b/core/config/config.cpp
@@ -53,9 +53,8 @@ std::unique_ptr<gko::LinOpFactory> build_from_config(
     const pnode& config, const registry& context,
     std::shared_ptr<const Executor>& exec, type_descriptor td)
 {
-    if (config.contains("Type")) {
-        auto func = context.get_build_map().at(
-            config.at("Type").get_data<std::string>());
+    if (auto& obj = config.get("Type")) {
+        auto func = context.get_build_map().at(obj.get_data<std::string>());
         return func(config, context, exec, td);
     }
     GKO_INVALID_STATE("Should contain Type property");
diff --git a/core/config/config.hpp b/core/config/config.hpp
index 7212011ddfc..c39b039d672 100644
--- a/core/config/config.hpp
+++ b/core/config/config.hpp
@@ -61,11 +61,11 @@ inline type_descriptor update_type(const pnode& config,
 {
     type_descriptor updated = td;
 
-    if (config.contains("ValueType")) {
-        updated.first = config.at("ValueType").get_data<std::string>();
+    if (auto& obj = config.get("ValueType")) {
+        updated.first = obj.get_data<std::string>();
     }
-    if (config.contains("IndexType")) {
-        updated.second = config.at("IndexType").get_data<std::string>();
+    if (auto& obj = config.get("IndexType")) {
+        updated.second = obj.get_data<std::string>();
     }
     return updated;
 }
@@ -90,9 +90,9 @@ inline std::shared_ptr<const LinOpFactory> get_pointer<const LinOpFactory>(
     std::shared_ptr<const Executor> exec, type_descriptor td)
 {
     std::shared_ptr<const LinOpFactory> ptr;
-    if (config.is(pnode::status_t::object)) {
+    if (config.is(pnode::status_t::data)) {
         ptr = context.search_data<LinOpFactory>(config.get_data<std::string>());
-    } else if (config.is(pnode::status_t::list)) {
+    } else if (config.is(pnode::status_t::map)) {
         ptr = build_from_config(config, context, exec, td);
     }
     // handle object is config
@@ -162,7 +162,7 @@ inline typename std::enable_if<gko::is_complex_s<ValueType>::value,
 get_value(const pnode& config)
 {
     using real_type = gko::remove_complex<ValueType>;
-    if (config.is(pnode::status_t::object)) {
+    if (config.is(pnode::status_t::data)) {
         return static_cast<ValueType>(get_value<real_type>(config));
     } else if (config.is(pnode::status_t::array)) {
         return ValueType{get_value<real_type>(config.at(0)),
@@ -175,9 +175,9 @@ get_value(const pnode& config)
 #define SET_POINTER(_factory, _param_type, _param_name, _config, _context,     \
                     _exec, _td)                                                \
     {                                                                          \
-        if (_config.contains(#_param_name)) {                                  \
+        if (auto& obj = _config.get(#_param_name)) {                           \
             _factory.with_##_param_name(gko::config::get_pointer<_param_type>( \
-                _config.at(#_param_name), _context, _exec, _td));              \
+                obj, _context, _exec, _td));                                   \
         }                                                                      \
     }                                                                          \
     static_assert(true,                                                        \
@@ -188,10 +188,10 @@ get_value(const pnode& config)
 #define SET_POINTER_VECTOR(_factory, _param_type, _param_name, _config,      \
                            _context, _exec, _td)                             \
     {                                                                        \
-        if (_config.contains(#_param_name)) {                                \
+        if (auto& obj = _config.get(#_param_name)) {                         \
             _factory.with_##_param_name(                                     \
-                gko::config::get_pointer_vector<_param_type>(                \
-                    _config.at(#_param_name), _context, _exec, _td));        \
+                gko::config::get_pointer_vector<_param_type>(obj, _context,  \
+                                                             _exec, _td));   \
         }                                                                    \
     }                                                                        \
     static_assert(true,                                                      \
@@ -201,9 +201,9 @@ get_value(const pnode& config)
 
 #define SET_VALUE(_factory, _param_type, _param_name, _config)               \
     {                                                                        \
-        if (_config.contains(#_param_name)) {                                \
-            _factory.with_##_param_name(gko::config::get_value<_param_type>( \
-                _config.at(#_param_name)));                                  \
+        if (auto& obj = _config.get(#_param_name)) {                         \
+            _factory.with_##_param_name(                                     \
+                gko::config::get_value<_param_type>(obj));                   \
         }                                                                    \
     }                                                                        \
     static_assert(true,                                                      \
diff --git a/core/config/stop_config.cpp b/core/config/stop_config.cpp
index c92dbe0b5e7..f5a05664462 100644
--- a/core/config/stop_config.cpp
+++ b/core/config/stop_config.cpp
@@ -91,9 +91,8 @@ class ResidualNormConfigurer {
     {
         auto factory = stop::ResidualNorm<ValueType>::build();
         SET_VALUE(factory, remove_complex<ValueType>, reduction_factor, config);
-        if (config.contains("baseline")) {
-            factory.with_baseline(
-                get_mode(config.at("baseline").get_data<std::string>()));
+        if (auto& obj = config.get("baseline")) {
+            factory.with_baseline(get_mode(obj.get_data<std::string>()));
         }
         return factory.on(exec);
     }
@@ -122,9 +121,8 @@ class ImplicitResidualNormConfigurer {
     {
         auto factory = stop::ImplicitResidualNorm<ValueType>::build();
         SET_VALUE(factory, remove_complex<ValueType>, reduction_factor, config);
-        if (config.contains("baseline")) {
-            factory.with_baseline(
-                get_mode(config.at("baseline").get_data<std::string>()));
+        if (auto& obj = config.get("baseline")) {
+            factory.with_baseline(get_mode(obj.get_data<std::string>()));
         }
         return factory.on(exec);
     }
@@ -149,10 +147,10 @@ get_pointer<const stop::CriterionFactory>(const pnode& config,
                                           type_descriptor td)
 {
     std::shared_ptr<const stop::CriterionFactory> ptr;
-    if (config.is(pnode::status_t::object)) {
+    if (config.is(pnode::status_t::data)) {
         return context.search_data<stop::CriterionFactory>(
             config.get_data<std::string>());
-    } else if (config.is(pnode::status_t::list)) {
+    } else if (config.is(pnode::status_t::map)) {
         static std::map<
             std::string,
             std::function<std::unique_ptr<gko::stop::CriterionFactory>(
@@ -186,7 +184,7 @@ get_pointer_vector<const stop::CriterionFactory>(
         res.push_back(get_pointer<const stop::CriterionFactory>(config, context,
                                                                 exec, td));
     }
-    // TODO: handle shortcut version by config.is(pnode::status_t::list) &&
+    // TODO: handle shortcut version by config.is(pnode::status_t::map) &&
     // !config.contains("Type")
 
     return res;
diff --git a/core/test/config/config.cpp b/core/test/config/config.cpp
index 6051a4812c2..9b49253044c 100644
--- a/core/test/config/config.cpp
+++ b/core/test/config/config.cpp
@@ -117,7 +117,7 @@ TEST_F(Config, GenerateObjectWithPreconditioner)
     auto reg = registry(config_map);
 
     pnode p{{{"ValueType", pnode{"double"}}, {"criteria", this->stop_config}}};
-    p.get_list()["preconditioner"] =
+    p.get_map()["preconditioner"] =
         pnode{{{"Type", pnode{"Cg"}}, {"criteria", this->stop_config}}};
     auto obj = build_from_config<0>(p, reg, this->exec);
 
@@ -145,7 +145,8 @@ TEST_F(Config, GenerateObjectWithCustomBuild)
     auto reg = registry(config_map);
 
     pnode p{{{"ValueType", pnode{"double"}}, {"criteria", this->stop_config}}};
-    p.get_list()["preconditioner"] = pnode{{{"Type", pnode{"Custom"}}}};
+    p.get_map()["preconditioner"] =
+        pnode{std::map<std::string, pnode>{{"Type", pnode{"Custom"}}}};
     auto obj = build_from_config<0>(p, reg, this->exec, {"double", ""});
 
     ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get()),

From 88a41fa439c165319bd03c719691676573040c65 Mon Sep 17 00:00:00 2001
From: "Yu-Hsiang M. Tsai" <yhmtsai@gmail.com>
Date: Wed, 11 Oct 2023 09:29:10 +0200
Subject: [PATCH 13/25] use deferred_factory_parameter (generate param)

---
 core/config/config.cpp                  |   8 +-
 core/config/config.hpp                  |  85 +++++++++++--------
 core/config/dispatch.hpp                |  39 ++++-----
 core/config/stop_config.cpp             | 106 ++++++++++++------------
 core/solver/cg.cpp                      |  56 ++++++-------
 core/test/config/config.cpp             |  38 ++++-----
 core/test/config/registry.cpp           |  13 +--
 include/ginkgo/core/config/config.hpp   |   9 +-
 include/ginkgo/core/config/registry.hpp |   5 +-
 include/ginkgo/core/solver/cg.hpp       |   6 ++
 10 files changed, 187 insertions(+), 178 deletions(-)

diff --git a/core/config/config.cpp b/core/config/config.cpp
index f124927c222..8332f50ec34 100644
--- a/core/config/config.cpp
+++ b/core/config/config.cpp
@@ -37,6 +37,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 
 #include <ginkgo/core/base/exception_helpers.hpp>
+#include <ginkgo/core/solver/solver_base.hpp>
 
 
 namespace gko {
@@ -49,13 +50,12 @@ buildfromconfig_map generate_config_map()
 }
 
 
-std::unique_ptr<gko::LinOpFactory> build_from_config(
-    const pnode& config, const registry& context,
-    std::shared_ptr<const Executor>& exec, type_descriptor td)
+deferred_factory_parameter<gko::LinOpFactory> build_from_config(
+    const pnode& config, const registry& context, type_descriptor td)
 {
     if (auto& obj = config.get("Type")) {
         auto func = context.get_build_map().at(obj.get_data<std::string>());
-        return func(config, context, exec, td);
+        return func(config, context, td);
     }
     GKO_INVALID_STATE("Should contain Type property");
 }
diff --git a/core/config/config.hpp b/core/config/config.hpp
index c39b039d672..a0ffefcf9f8 100644
--- a/core/config/config.hpp
+++ b/core/config/config.hpp
@@ -45,6 +45,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <ginkgo/core/base/lin_op.hpp>
 #include <ginkgo/core/base/math.hpp>
 #include <ginkgo/core/config/registry.hpp>
+#include <ginkgo/core/solver/solver_base.hpp>
 #include <ginkgo/core/stop/criterion.hpp>
 
 
@@ -74,7 +75,6 @@ inline type_descriptor update_type(const pnode& config,
 template <typename T>
 inline std::shared_ptr<T> get_pointer(const pnode& config,
                                       const registry& context,
-                                      std::shared_ptr<const Executor> exec,
                                       type_descriptor td)
 {
     std::shared_ptr<T> ptr;
@@ -84,54 +84,57 @@ inline std::shared_ptr<T> get_pointer(const pnode& config,
     return std::move(ptr);
 }
 
+
+template <typename T>
+inline deferred_factory_parameter<std::remove_const_t<T>> get_factory(
+    const pnode& config, const registry& context, type_descriptor td);
+
 template <>
-inline std::shared_ptr<const LinOpFactory> get_pointer<const LinOpFactory>(
-    const pnode& config, const registry& context,
-    std::shared_ptr<const Executor> exec, type_descriptor td)
+inline deferred_factory_parameter<LinOpFactory> get_factory<const LinOpFactory>(
+    const pnode& config, const registry& context, type_descriptor td)
 {
-    std::shared_ptr<const LinOpFactory> ptr;
+    deferred_factory_parameter<LinOpFactory> ptr;
     if (config.is(pnode::status_t::data)) {
         ptr = context.search_data<LinOpFactory>(config.get_data<std::string>());
     } else if (config.is(pnode::status_t::map)) {
-        ptr = build_from_config(config, context, exec, td);
+        ptr = build_from_config(config, context, td);
     }
     // handle object is config
-    assert(ptr.get() != nullptr);
+    assert(!ptr.is_empty());
     return std::move(ptr);
 }
 
 template <>
-std::shared_ptr<const stop::CriterionFactory>
-get_pointer<const stop::CriterionFactory>(const pnode& config,
+deferred_factory_parameter<stop::CriterionFactory>
+get_factory<const stop::CriterionFactory>(const pnode& config,
                                           const registry& context,
-                                          std::shared_ptr<const Executor> exec,
                                           type_descriptor td);
 
 
 template <typename T>
-inline std::vector<std::shared_ptr<T>> get_pointer_vector(
-    const pnode& config, const registry& context,
-    std::shared_ptr<const Executor> exec, type_descriptor td)
+inline std::vector<deferred_factory_parameter<std::remove_const_t<T>>>
+get_factory_vector(const pnode& config, const registry& context,
+                   type_descriptor td)
 {
-    std::vector<std::shared_ptr<T>> res;
+    std::vector<deferred_factory_parameter<std::remove_const_t<T>>> res;
     // for loop in config
     if (config.is(pnode::status_t::array)) {
         for (const auto& it : config.get_array()) {
-            res.push_back(get_pointer<T>(it, context, exec, td));
+            res.push_back(get_factory<T>(it, context, td));
         }
     } else {
         // only one config can be passed without array
-        res.push_back(get_pointer<T>(config, context, exec, td));
+        res.push_back(get_factory<T>(config, context, td));
     }
 
     return res;
 }
 
-template <>
-std::vector<std::shared_ptr<const stop::CriterionFactory>>
-get_pointer_vector<const stop::CriterionFactory>(
-    const pnode& config, const registry& context,
-    std::shared_ptr<const Executor> exec, type_descriptor td);
+// template <>
+// std::vector<std::shared_ptr<const stop::CriterionFactory>>
+// get_pointer_vector<const stop::CriterionFactory>(
+//     const pnode& config, const registry& context,
+//     std::shared_ptr<const Executor> exec, type_descriptor td);
 
 
 template <typename IndexType>
@@ -172,26 +175,38 @@ get_value(const pnode& config)
 }
 
 
-#define SET_POINTER(_factory, _param_type, _param_name, _config, _context,     \
-                    _exec, _td)                                                \
-    {                                                                          \
-        if (auto& obj = _config.get(#_param_name)) {                           \
-            _factory.with_##_param_name(gko::config::get_pointer<_param_type>( \
-                obj, _context, _exec, _td));                                   \
-        }                                                                      \
-    }                                                                          \
-    static_assert(true,                                                        \
-                  "This assert is used to counter the false positive extra "   \
+#define SET_POINTER(_factory, _param_type, _param_name, _config, _context,   \
+                    _td)                                                     \
+    {                                                                        \
+        if (auto& obj = _config.get(#_param_name)) {                         \
+            _factory.with_##_param_name(                                     \
+                gko::config::get_pointer<_param_type>(obj, _context, _td));  \
+        }                                                                    \
+    }                                                                        \
+    static_assert(true,                                                      \
+                  "This assert is used to counter the false positive extra " \
+                  "semi-colon warnings")
+
+#define SET_FACTORY(_factory, _param_type, _param_name, _config, _context,   \
+                    _td)                                                     \
+    {                                                                        \
+        if (auto& obj = _config.get(#_param_name)) {                         \
+            _factory.with_##_param_name(                                     \
+                gko::config::get_factory<_param_type>(obj, _context, _td));  \
+        }                                                                    \
+    }                                                                        \
+    static_assert(true,                                                      \
+                  "This assert is used to counter the false positive extra " \
                   "semi-colon warnings")
 
 
-#define SET_POINTER_VECTOR(_factory, _param_type, _param_name, _config,      \
-                           _context, _exec, _td)                             \
+#define SET_FACTORY_VECTOR(_factory, _param_type, _param_name, _config,      \
+                           _context, _td)                                    \
     {                                                                        \
         if (auto& obj = _config.get(#_param_name)) {                         \
             _factory.with_##_param_name(                                     \
-                gko::config::get_pointer_vector<_param_type>(obj, _context,  \
-                                                             _exec, _td));   \
+                gko::config::get_factory_vector<_param_type>(obj, _context,  \
+                                                             _td));          \
         }                                                                    \
     }                                                                        \
     static_assert(true,                                                      \
diff --git a/core/config/dispatch.hpp b/core/config/dispatch.hpp
index e6e8f1d0b58..fa9ecca2e66 100644
--- a/core/config/dispatch.hpp
+++ b/core/config/dispatch.hpp
@@ -41,6 +41,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <ginkgo/core/base/exception_helpers.hpp>
 #include <ginkgo/core/config/config.hpp>
 #include <ginkgo/core/config/registry.hpp>
+#include <ginkgo/core/solver/solver_base.hpp>
 #include <ginkgo/core/synthesizer/containers.hpp>
 
 
@@ -54,27 +55,26 @@ namespace config {
 /**
  * This function is to dispatch the type from runtime parameter.
  * The concrete class need to have static member function
- * build_from_config(pnode, registry, std::shared_ptr<const Executor>,
- * type_descriptor)
+ * build_from_config(pnode, registry, type_descriptor)
  */
 template <typename ReturnType, template <class...> class Base,
           typename... Types>
-std::unique_ptr<ReturnType> dispatch(std::string str, const pnode& config,
-                                     const registry& context,
-                                     std::shared_ptr<const Executor>& exec,
-                                     const type_descriptor& td)
+deferred_factory_parameter<ReturnType> dispatch(std::string str,
+                                                const pnode& config,
+                                                const registry& context,
+                                                const type_descriptor& td)
 {
-    return Base<Types...>::build_from_config(config, context, exec, td);
+    return Base<Types...>::build_from_config(config, context, td);
 }
 
 // When the dispatch does not find match from the given list.
 template <typename ReturnType, template <class...> class Base,
           typename... Types, typename... List>
-std::unique_ptr<ReturnType> dispatch(std::string str, const pnode& config,
-                                     const registry& context,
-                                     std::shared_ptr<const Executor>& exec,
-                                     const type_descriptor& td,
-                                     syn::type_list<>, List... list)
+deferred_factory_parameter<ReturnType> dispatch(std::string str,
+                                                const pnode& config,
+                                                const registry& context,
+                                                const type_descriptor& td,
+                                                syn::type_list<>, List... list)
 {
     GKO_INVALID_STATE("Can not figure out the actual type");
 }
@@ -83,28 +83,25 @@ std::unique_ptr<ReturnType> dispatch(std::string str, const pnode& config,
  * @param str  the identifier for runtime type: the format is type1,type2,...
  * @param config  the configuration
  * @param context  the registry context
- * @param exec  the executor
  * @param td  the default type discriptor
  * @param type_list  the type list for checking
  * @param list...  the type list for the rest type
  */
 template <typename ReturnType, template <class...> class Base,
           typename... Types, typename S, typename... T, typename... List>
-std::unique_ptr<ReturnType> dispatch(std::string str, const pnode& config,
-                                     const registry& context,
-                                     std::shared_ptr<const Executor>& exec,
-                                     const type_descriptor& td,
-                                     syn::type_list<S, T...>, List... list)
+deferred_factory_parameter<ReturnType> dispatch(
+    std::string str, const pnode& config, const registry& context,
+    const type_descriptor& td, syn::type_list<S, T...>, List... list)
 {
     auto pos = str.find(",");
     auto item = str.substr(0, pos);
     auto res = (pos == std::string::npos) ? "" : str.substr(pos + 1);
     if (item == type_string<S>::str()) {
-        return dispatch<ReturnType, Base, Types..., S>(res, config, context,
-                                                       exec, td, list...);
+        return dispatch<ReturnType, Base, Types..., S>(res, config, context, td,
+                                                       list...);
     } else {
         return dispatch<ReturnType, Base, Types...>(
-            str, config, context, exec, td, syn::type_list<T...>(), list...);
+            str, config, context, td, syn::type_list<T...>(), list...);
     }
 }
 
diff --git a/core/config/stop_config.cpp b/core/config/stop_config.cpp
index f5a05664462..4fa20ea1ba2 100644
--- a/core/config/stop_config.cpp
+++ b/core/config/stop_config.cpp
@@ -33,6 +33,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <ginkgo/core/base/exception_helpers.hpp>
 #include <ginkgo/core/config/config.hpp>
 #include <ginkgo/core/config/registry.hpp>
+#include <ginkgo/core/solver/solver_base.hpp>
 #include <ginkgo/core/stop/criterion.hpp>
 #include <ginkgo/core/stop/iteration.hpp>
 #include <ginkgo/core/stop/residual_norm.hpp>
@@ -47,23 +48,21 @@ namespace gko {
 namespace config {
 
 
-inline std::unique_ptr<stop::CriterionFactory> configure_time(
-    const pnode& config, const registry& context,
-    std::shared_ptr<const Executor> exec, type_descriptor td)
+inline deferred_factory_parameter<stop::CriterionFactory> configure_time(
+    const pnode& config, const registry& context, type_descriptor td)
 {
     auto factory = stop::Time::build();
     SET_VALUE(factory, long long int, time_limit, config);
-    return factory.on(exec);
+    return factory;
 }
 
 
-inline std::unique_ptr<stop::CriterionFactory> configure_iter(
-    const pnode& config, const registry& context,
-    std::shared_ptr<const Executor> exec, type_descriptor td)
+inline deferred_factory_parameter<stop::CriterionFactory> configure_iter(
+    const pnode& config, const registry& context, type_descriptor td)
 {
     auto factory = stop::Iteration::build();
     SET_VALUE(factory, size_type, max_iters, config);
-    return factory.on(exec);
+    return factory;
 }
 
 
@@ -83,10 +82,10 @@ stop::mode get_mode(const std::string& str)
 template <typename ValueType>
 class ResidualNormConfigurer {
 public:
-    static std::unique_ptr<typename stop::ResidualNorm<ValueType>::Factory>
+    static deferred_factory_parameter<
+        typename stop::ResidualNorm<ValueType>::Factory>
     build_from_config(const gko::config::pnode& config,
                       const gko::config::registry& context,
-                      std::shared_ptr<const Executor> exec,
                       gko::config::type_descriptor td_for_child)
     {
         auto factory = stop::ResidualNorm<ValueType>::build();
@@ -94,29 +93,27 @@ class ResidualNormConfigurer {
         if (auto& obj = config.get("baseline")) {
             factory.with_baseline(get_mode(obj.get_data<std::string>()));
         }
-        return factory.on(exec);
+        return factory;
     }
 };
 
 
-inline std::unique_ptr<stop::CriterionFactory> configure_residual(
-    const pnode& config, const registry& context,
-    std::shared_ptr<const Executor> exec, type_descriptor td)
+inline deferred_factory_parameter<stop::CriterionFactory> configure_residual(
+    const pnode& config, const registry& context, type_descriptor td)
 {
     auto updated = update_type(config, td);
     return dispatch<stop::CriterionFactory, ResidualNormConfigurer>(
-        updated.first, config, context, exec, updated, value_type_list());
+        updated.first, config, context, updated, value_type_list());
 }
 
 
 template <typename ValueType>
 class ImplicitResidualNormConfigurer {
 public:
-    static std::unique_ptr<
+    static deferred_factory_parameter<
         typename stop::ImplicitResidualNorm<ValueType>::Factory>
     build_from_config(const gko::config::pnode& config,
                       const gko::config::registry& context,
-                      std::shared_ptr<const Executor> exec,
                       gko::config::type_descriptor td_for_child)
     {
         auto factory = stop::ImplicitResidualNorm<ValueType>::build();
@@ -124,71 +121,72 @@ class ImplicitResidualNormConfigurer {
         if (auto& obj = config.get("baseline")) {
             factory.with_baseline(get_mode(obj.get_data<std::string>()));
         }
-        return factory.on(exec);
+        return factory;
     }
 };
 
 
-inline std::unique_ptr<stop::CriterionFactory> configure_implicit_residual(
-    const pnode& config, const registry& context,
-    std::shared_ptr<const Executor> exec, type_descriptor td)
+inline deferred_factory_parameter<stop::CriterionFactory>
+configure_implicit_residual(const pnode& config, const registry& context,
+                            type_descriptor td)
 {
     auto updated = update_type(config, td);
     return dispatch<stop::CriterionFactory, ImplicitResidualNormConfigurer>(
-        updated.first, config, context, exec, updated, value_type_list());
+        updated.first, config, context, updated, value_type_list());
 }
 
 
 template <>
-std::shared_ptr<const stop::CriterionFactory>
-get_pointer<const stop::CriterionFactory>(const pnode& config,
+deferred_factory_parameter<stop::CriterionFactory>
+get_factory<const stop::CriterionFactory>(const pnode& config,
                                           const registry& context,
-                                          std::shared_ptr<const Executor> exec,
                                           type_descriptor td)
 {
-    std::shared_ptr<const stop::CriterionFactory> ptr;
+    deferred_factory_parameter<stop::CriterionFactory> ptr;
     if (config.is(pnode::status_t::data)) {
         return context.search_data<stop::CriterionFactory>(
             config.get_data<std::string>());
     } else if (config.is(pnode::status_t::map)) {
-        static std::map<
-            std::string,
-            std::function<std::unique_ptr<gko::stop::CriterionFactory>(
-                const pnode&, const registry&, std::shared_ptr<const Executor>&,
-                type_descriptor)>>
+        static std::map<std::string,
+                        std::function<deferred_factory_parameter<
+                            gko::stop::CriterionFactory>(
+                            const pnode&, const registry&, type_descriptor)>>
             criterion_map{
                 {{"Time", configure_time},
                  {"Iteration", configure_iter},
                  {"ResidualNorm", configure_residual},
                  {"ImplicitResidualNorm", configure_implicit_residual}}};
         return criterion_map.at(config.at("Type").get_data<std::string>())(
-            config, context, exec, td);
+            config, context, td);
     }
-    assert(ptr.get() != nullptr);
+    assert(!ptr.is_empty());
     return std::move(ptr);
 }
 
-template <>
-std::vector<std::shared_ptr<const stop::CriterionFactory>>
-get_pointer_vector<const stop::CriterionFactory>(
-    const pnode& config, const registry& context,
-    std::shared_ptr<const Executor> exec, type_descriptor td)
-{
-    std::vector<std::shared_ptr<const stop::CriterionFactory>> res;
-    if (config.is(pnode::status_t::array)) {
-        for (const auto& it : config.get_array()) {
-            res.push_back(get_pointer<const stop::CriterionFactory>(it, context,
-                                                                    exec, td));
-        }
-    } else {
-        res.push_back(get_pointer<const stop::CriterionFactory>(config, context,
-                                                                exec, td));
-    }
-    // TODO: handle shortcut version by config.is(pnode::status_t::map) &&
-    // !config.contains("Type")
-
-    return res;
-}
+// template <>
+// std::vector<std::shared_ptr<const stop::CriterionFactory>>
+// get_pointer_vector<const stop::CriterionFactory>(
+//     const pnode& config, const registry& context,
+//     std::shared_ptr<const Executor> exec, type_descriptor td)
+// {
+//     std::vector<std::shared_ptr<const stop::CriterionFactory>> res;
+//     if (config.is(pnode::status_t::array)) {
+//         for (const auto& it : config.get_array()) {
+//             res.push_back(get_pointer<const stop::CriterionFactory>(it,
+//             context,
+//                                                                     exec,
+//                                                                     td));
+//         }
+//     } else {
+//         res.push_back(get_pointer<const stop::CriterionFactory>(config,
+//         context,
+//                                                                 exec, td));
+//     }
+//     // TODO: handle shortcut version by config.is(pnode::status_t::map) &&
+//     // !config.contains("Type")
+
+//     return res;
+// }
 
 
 }  // namespace config
diff --git a/core/solver/cg.cpp b/core/solver/cg.cpp
index 4469a7fb86a..ac50fa0ec35 100644
--- a/core/solver/cg.cpp
+++ b/core/solver/cg.cpp
@@ -27,42 +27,15 @@ namespace gko {
 namespace config {
 
 
-// It can also be directly in solver::Cg (or in proteced part) if we also allow
-// the executor as input there.
-template <typename ValueType>
-class CgConfigurer {
-public:
-    static std::unique_ptr<typename solver::Cg<ValueType>::Factory>
-    build_from_config(const pnode& config, const registry& context,
-                      std::shared_ptr<const Executor> exec,
-                      type_descriptor td_for_child)
-    {
-        auto factory = solver::Cg<ValueType>::build();
-        SET_POINTER(factory, const LinOp, generated_preconditioner, config,
-                    context, exec, td_for_child);
-        // handle parameter requires exec
-        // criteria and preconditioner are almost in each solver -> to another
-        // function.
-        SET_POINTER_VECTOR(factory, const stop::CriterionFactory, criteria,
-                           config, context, exec, td_for_child);
-        SET_POINTER(factory, const LinOpFactory, preconditioner, config,
-                    context, exec, td_for_child);
-        // can also handle preconditioner, criterion here if they are in
-        // context.
-        return factory.on(exec);
-    }
-};
-
-
 template <>
-std::unique_ptr<gko::LinOpFactory>
+deferred_factory_parameter<gko::LinOpFactory>
 build_from_config<static_cast<int>(LinOpFactoryType::Cg)>(
     const pnode& config, const registry& context,
-    std::shared_ptr<const Executor>& exec, gko::config::type_descriptor td)
+    gko::config::type_descriptor td)
 {
     auto updated = update_type(config, td);
-    return dispatch<gko::LinOpFactory, CgConfigurer>(
-        updated.first, config, context, exec, updated, value_type_list());
+    return dispatch<gko::LinOpFactory, gko::solver::Cg>(
+        updated.first, config, context, updated, value_type_list());
 }
 
 
@@ -83,6 +56,27 @@ GKO_REGISTER_OPERATION(step_2, cg::step_2);
 }  // namespace cg
 
 
+template <typename ValueType>
+typename Cg<ValueType>::parameters_type Cg<ValueType>::build_from_config(
+    const config::pnode& config, const config::registry& context,
+    config::type_descriptor td_for_child)
+{
+    auto factory = solver::Cg<ValueType>::build();
+    SET_POINTER(factory, const LinOp, generated_preconditioner, config, context,
+                td_for_child);
+    // handle parameter requires exec
+    // criteria and preconditioner are almost in each solver -> to another
+    // function.
+    SET_FACTORY_VECTOR(factory, const stop::CriterionFactory, criteria, config,
+                       context, td_for_child);
+    SET_FACTORY(factory, const LinOpFactory, preconditioner, config, context,
+                td_for_child);
+    // can also handle preconditioner, criterion here if they are in
+    // context.
+    return factory;
+}
+
+
 template <typename ValueType>
 std::unique_ptr<LinOp> Cg<ValueType>::transpose() const
 {
diff --git a/core/test/config/config.cpp b/core/test/config/config.cpp
index 9b49253044c..b137b220f3f 100644
--- a/core/test/config/config.cpp
+++ b/core/test/config/config.cpp
@@ -85,9 +85,9 @@ TEST_F(Config, GenerateObjectWithoutDefault)
     auto reg = registry(config_map);
 
     pnode p{{{"ValueType", pnode{"double"}}, {"criteria", this->stop_config}}};
-    auto obj = build_from_config<0>(p, reg, this->exec);
+    auto obj = build_from_config<0>(p, reg).on(this->exec);
 
-    ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get()),
+    ASSERT_NE(dynamic_cast<const gko::solver::Cg<double>::Factory*>(obj.get()),
               nullptr);
 }
 
@@ -100,11 +100,11 @@ TEST_F(Config, GenerateObjectWithData)
 
     pnode p{{{"generated_preconditioner", pnode{"precond"}},
              {"criteria", this->stop_config}}};
-    auto obj = build_from_config<0>(p, reg, this->exec, {"float", ""});
+    auto obj = build_from_config<0>(p, reg, {"float", ""}).on(this->exec);
 
-    ASSERT_NE(dynamic_cast<gko::solver::Cg<float>::Factory*>(obj.get()),
+    ASSERT_NE(dynamic_cast<const gko::solver::Cg<float>::Factory*>(obj.get()),
               nullptr);
-    ASSERT_NE(dynamic_cast<gko::solver::Cg<float>::Factory*>(obj.get())
+    ASSERT_NE(dynamic_cast<const gko::solver::Cg<float>::Factory*>(obj.get())
                   ->get_parameters()
                   .generated_preconditioner,
               nullptr);
@@ -119,11 +119,11 @@ TEST_F(Config, GenerateObjectWithPreconditioner)
     pnode p{{{"ValueType", pnode{"double"}}, {"criteria", this->stop_config}}};
     p.get_map()["preconditioner"] =
         pnode{{{"Type", pnode{"Cg"}}, {"criteria", this->stop_config}}};
-    auto obj = build_from_config<0>(p, reg, this->exec);
+    auto obj = build_from_config<0>(p, reg).on(this->exec);
 
-    ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get()),
+    ASSERT_NE(dynamic_cast<const gko::solver::Cg<double>::Factory*>(obj.get()),
               nullptr);
-    ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get())
+    ASSERT_NE(dynamic_cast<const gko::solver::Cg<double>::Factory*>(obj.get())
                   ->get_parameters()
                   .preconditioner,
               nullptr);
@@ -135,27 +135,25 @@ TEST_F(Config, GenerateObjectWithCustomBuild)
     auto config_map = generate_config_map();
 
     config_map["Custom"] = [](const pnode& config, const registry& context,
-                              std::shared_ptr<const gko::Executor>& exec,
                               type_descriptor td_for_child) {
-        return gko::solver::Bicg<double>::build()
-            .with_criteria(
-                gko::stop::Iteration::build().with_max_iters(2u).on(exec))
-            .on(exec);
+        return gko::solver::Bicg<double>::build().with_criteria(
+            gko::stop::Iteration::build().with_max_iters(2u));
     };
     auto reg = registry(config_map);
 
     pnode p{{{"ValueType", pnode{"double"}}, {"criteria", this->stop_config}}};
     p.get_map()["preconditioner"] =
         pnode{std::map<std::string, pnode>{{"Type", pnode{"Custom"}}}};
-    auto obj = build_from_config<0>(p, reg, this->exec, {"double", ""});
+    auto obj = build_from_config<0>(p, reg, {"double", ""}).on(this->exec);
 
-    ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get()),
-              nullptr);
-    ASSERT_NE(dynamic_cast<const gko::solver::Bicg<double>::Factory*>(
-                  dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get())
-                      ->get_parameters()
-                      .preconditioner.get()),
+    ASSERT_NE(dynamic_cast<const gko::solver::Cg<double>::Factory*>(obj.get()),
               nullptr);
+    ASSERT_NE(
+        dynamic_cast<const gko::solver::Bicg<double>::Factory*>(
+            dynamic_cast<const gko::solver::Cg<double>::Factory*>(obj.get())
+                ->get_parameters()
+                .preconditioner.get()),
+        nullptr);
 }
 
 
diff --git a/core/test/config/registry.cpp b/core/test/config/registry.cpp
index 0023e214ed0..64867ec972f 100644
--- a/core/test/config/registry.cpp
+++ b/core/test/config/registry.cpp
@@ -44,6 +44,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <ginkgo/core/base/executor.hpp>
 #include <ginkgo/core/matrix/dense.hpp>
 #include <ginkgo/core/solver/cg.hpp>
+#include <ginkgo/core/solver/solver_base.hpp>
 #include <ginkgo/core/stop/iteration.hpp>
 #include <ginkgo/core/stop/time.hpp>
 
@@ -64,9 +65,8 @@ class Registry : public ::testing::Test {
           stop_factory{Stop::build().on(exec)},
           func{[](const gko::config::pnode& config,
                   const gko::config::registry& context,
-                  std::shared_ptr<const gko::Executor>& exec,
                   gko::config::type_descriptor td_for_child) {
-              return gko::solver::Cg<float>::build().on(exec);
+              return gko::solver::Cg<float>::build();
           }},
           reg{{{"func", func}}}
     {}
@@ -75,9 +75,9 @@ class Registry : public ::testing::Test {
     std::shared_ptr<Matrix> matrix;
     std::shared_ptr<typename Solver::Factory> solver_factory;
     std::shared_ptr<typename Stop::Factory> stop_factory;
-    std::function<std::unique_ptr<gko::LinOpFactory>(
+    std::function<gko::deferred_factory_parameter<gko::LinOpFactory>(
         const gko::config::pnode&, const gko::config::registry&,
-        std::shared_ptr<const gko::Executor>&, gko::config::type_descriptor)>
+        gko::config::type_descriptor)>
         func;
     gko::config::registry reg;
 };
@@ -176,8 +176,9 @@ TEST_F(Registry, ThrowWithWrongType)
 
 TEST_F(Registry, GetBuildMap)
 {
-    auto factory = reg.get_build_map().at("func")(gko::config::pnode{"unused"},
-                                                  reg, exec, {"", ""});
+    auto factory = reg.get_build_map()
+                       .at("func")(gko::config::pnode{"unused"}, reg, {"", ""})
+                       .on(exec);
 
     ASSERT_NE(factory, nullptr);
 }
diff --git a/include/ginkgo/core/config/config.hpp b/include/ginkgo/core/config/config.hpp
index 9475ba28b55..b17fd216916 100644
--- a/include/ginkgo/core/config/config.hpp
+++ b/include/ginkgo/core/config/config.hpp
@@ -42,6 +42,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <ginkgo/core/base/lin_op.hpp>
 #include <ginkgo/core/base/types.hpp>
 #include <ginkgo/core/config/registry.hpp>
+#include <ginkgo/core/solver/solver_base.hpp>
 
 
 namespace gko {
@@ -54,15 +55,15 @@ enum LinOpFactoryType : int { Cg = 0 };
 // It is only an intermediate step. If we do not provide the SolverType with VT,
 // IT selection, it can be in detail namespace or hide it by structure
 template <int flag>
-std::unique_ptr<gko::LinOpFactory> build_from_config(
+deferred_factory_parameter<gko::LinOpFactory> build_from_config(
     const pnode& config, const registry& context,
-    std::shared_ptr<const Executor>& exec, type_descriptor td = {"", ""});
+    type_descriptor td = {"", ""});
 
 
 // The main function
-std::unique_ptr<gko::LinOpFactory> build_from_config(
+deferred_factory_parameter<gko::LinOpFactory> build_from_config(
     const pnode& config, const registry& context,
-    std::shared_ptr<const Executor>& exec, type_descriptor td = {"", ""});
+    type_descriptor td = {"", ""});
 
 
 buildfromconfig_map generate_config_map();
diff --git a/include/ginkgo/core/config/registry.hpp b/include/ginkgo/core/config/registry.hpp
index ac58696b7af..ca6853f2e35 100644
--- a/include/ginkgo/core/config/registry.hpp
+++ b/include/ginkgo/core/config/registry.hpp
@@ -64,9 +64,8 @@ using criterionfactory_map =
 using type_descriptor = std::pair<std::string, std::string>;
 using buildfromconfig_map =
     std::map<std::string,
-             std::function<std::unique_ptr<gko::LinOpFactory>(
-                 const pnode&, const registry&,
-                 std::shared_ptr<const Executor>&, type_descriptor)>>;
+             std::function<deferred_factory_parameter<gko::LinOpFactory>(
+                 const pnode&, const registry&, type_descriptor)>>;
 
 
 /**
diff --git a/include/ginkgo/core/solver/cg.hpp b/include/ginkgo/core/solver/cg.hpp
index a56e543d5ca..5356b837477 100644
--- a/include/ginkgo/core/solver/cg.hpp
+++ b/include/ginkgo/core/solver/cg.hpp
@@ -14,6 +14,8 @@
 #include <ginkgo/core/base/lin_op.hpp>
 #include <ginkgo/core/base/math.hpp>
 #include <ginkgo/core/base/types.hpp>
+#include <ginkgo/core/config/config.hpp>
+#include <ginkgo/core/config/registry.hpp>
 #include <ginkgo/core/log/logger.hpp>
 #include <ginkgo/core/matrix/dense.hpp>
 #include <ginkgo/core/matrix/identity.hpp>
@@ -73,6 +75,10 @@ class Cg : public EnableLinOp<Cg<ValueType>>,
     GKO_ENABLE_LIN_OP_FACTORY(Cg, parameters, Factory);
     GKO_ENABLE_BUILD_METHOD(Factory);
 
+    static parameters_type build_from_config(
+        const config::pnode& config, const config::registry& context,
+        config::type_descriptor td_for_child);
+
 protected:
     void apply_impl(const LinOp* b, LinOp* x) const override;
 

From 557c6d68e98d3512426b133f131e19b14a18bec9 Mon Sep 17 00:00:00 2001
From: "Yu-Hsiang M. Tsai" <yhmtsai@gmail.com>
Date: Wed, 11 Oct 2023 15:26:44 +0200
Subject: [PATCH 14/25] adapt with the explicit deferred type

---
 core/config/config.cpp                  | 34 ++-------------
 core/config/config.hpp                  | 55 +++++++------------------
 core/config/dispatch.hpp                | 36 ++--------------
 core/config/stop_config.cpp             | 38 +++--------------
 core/test/config/config.cpp             | 55 ++++++-------------------
 core/test/config/registry.cpp           | 34 ++-------------
 include/ginkgo/core/config/config.hpp   | 34 ++-------------
 include/ginkgo/core/config/registry.hpp | 34 ++-------------
 include/ginkgo/ginkgo.hpp               |  2 +
 9 files changed, 50 insertions(+), 272 deletions(-)

diff --git a/core/config/config.cpp b/core/config/config.cpp
index 8332f50ec34..9f9bb3e2caf 100644
--- a/core/config/config.cpp
+++ b/core/config/config.cpp
@@ -1,34 +1,6 @@
-/*******************************<GINKGO LICENSE>******************************
-Copyright (c) 2017-2023, the Ginkgo authors
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions
-are met:
-
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in the
-documentation and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holder nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
-IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
-TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
-PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-******************************<GINKGO LICENSE>*******************************/
+// SPDX-FileCopyrightText: 2017-2023 The Ginkgo authors
+//
+// SPDX-License-Identifier: BSD-3-Clause
 
 #include <ginkgo/core/config/config.hpp>
 
diff --git a/core/config/config.hpp b/core/config/config.hpp
index a0ffefcf9f8..3c86e288699 100644
--- a/core/config/config.hpp
+++ b/core/config/config.hpp
@@ -1,34 +1,6 @@
-/*******************************<GINKGO LICENSE>******************************
-Copyright (c) 2017-2023, the Ginkgo authors
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions
-are met:
-
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in the
-documentation and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holder nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
-IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
-TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
-PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-******************************<GINKGO LICENSE>*******************************/
+// SPDX-FileCopyrightText: 2017-2023 The Ginkgo authors
+//
+// SPDX-License-Identifier: BSD-3-Clause
 
 #ifndef GKO_CORE_CONFIG_CONFIG_HPP_
 #define GKO_CORE_CONFIG_CONFIG_HPP_
@@ -86,14 +58,16 @@ inline std::shared_ptr<T> get_pointer(const pnode& config,
 
 
 template <typename T>
-inline deferred_factory_parameter<std::remove_const_t<T>> get_factory(
-    const pnode& config, const registry& context, type_descriptor td);
+inline deferred_factory_parameter<T> get_factory(const pnode& config,
+                                                 const registry& context,
+                                                 type_descriptor td);
 
 template <>
-inline deferred_factory_parameter<LinOpFactory> get_factory<const LinOpFactory>(
-    const pnode& config, const registry& context, type_descriptor td)
+inline deferred_factory_parameter<const LinOpFactory>
+get_factory<const LinOpFactory>(const pnode& config, const registry& context,
+                                type_descriptor td)
 {
-    deferred_factory_parameter<LinOpFactory> ptr;
+    deferred_factory_parameter<const LinOpFactory> ptr;
     if (config.is(pnode::status_t::data)) {
         ptr = context.search_data<LinOpFactory>(config.get_data<std::string>());
     } else if (config.is(pnode::status_t::map)) {
@@ -105,18 +79,17 @@ inline deferred_factory_parameter<LinOpFactory> get_factory<const LinOpFactory>(
 }
 
 template <>
-deferred_factory_parameter<stop::CriterionFactory>
+deferred_factory_parameter<const stop::CriterionFactory>
 get_factory<const stop::CriterionFactory>(const pnode& config,
                                           const registry& context,
                                           type_descriptor td);
 
 
 template <typename T>
-inline std::vector<deferred_factory_parameter<std::remove_const_t<T>>>
-get_factory_vector(const pnode& config, const registry& context,
-                   type_descriptor td)
+inline std::vector<deferred_factory_parameter<T>> get_factory_vector(
+    const pnode& config, const registry& context, type_descriptor td)
 {
-    std::vector<deferred_factory_parameter<std::remove_const_t<T>>> res;
+    std::vector<deferred_factory_parameter<T>> res;
     // for loop in config
     if (config.is(pnode::status_t::array)) {
         for (const auto& it : config.get_array()) {
diff --git a/core/config/dispatch.hpp b/core/config/dispatch.hpp
index fa9ecca2e66..9323d44978a 100644
--- a/core/config/dispatch.hpp
+++ b/core/config/dispatch.hpp
@@ -1,34 +1,6 @@
-/*******************************<GINKGO LICENSE>******************************
-Copyright (c) 2017-2023, the Ginkgo authors
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions
-are met:
-
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in the
-documentation and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holder nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
-IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
-TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
-PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-******************************<GINKGO LICENSE>*******************************/
+// SPDX-FileCopyrightText: 2017-2023 The Ginkgo authors
+//
+// SPDX-License-Identifier: BSD-3-Clause
 
 #ifndef GKO_CORE_CONFIG_DISPATCH_HPP_
 #define GKO_CORE_CONFIG_DISPATCH_HPP_
@@ -83,7 +55,7 @@ deferred_factory_parameter<ReturnType> dispatch(std::string str,
  * @param str  the identifier for runtime type: the format is type1,type2,...
  * @param config  the configuration
  * @param context  the registry context
- * @param td  the default type discriptor
+ * @param td  the default type descriptor
  * @param type_list  the type list for checking
  * @param list...  the type list for the rest type
  */
diff --git a/core/config/stop_config.cpp b/core/config/stop_config.cpp
index 4fa20ea1ba2..a3bc0725c65 100644
--- a/core/config/stop_config.cpp
+++ b/core/config/stop_config.cpp
@@ -1,34 +1,6 @@
-/*******************************<GINKGO LICENSE>******************************
-Copyright (c) 2017-2023, the Ginkgo authors
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions
-are met:
-
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in the
-documentation and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holder nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
-IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
-TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
-PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-******************************<GINKGO LICENSE>*******************************/
+// SPDX-FileCopyrightText: 2017-2023 The Ginkgo authors
+//
+// SPDX-License-Identifier: BSD-3-Clause
 
 #include <ginkgo/core/base/exception_helpers.hpp>
 #include <ginkgo/core/config/config.hpp>
@@ -137,12 +109,12 @@ configure_implicit_residual(const pnode& config, const registry& context,
 
 
 template <>
-deferred_factory_parameter<stop::CriterionFactory>
+deferred_factory_parameter<const stop::CriterionFactory>
 get_factory<const stop::CriterionFactory>(const pnode& config,
                                           const registry& context,
                                           type_descriptor td)
 {
-    deferred_factory_parameter<stop::CriterionFactory> ptr;
+    deferred_factory_parameter<const stop::CriterionFactory> ptr;
     if (config.is(pnode::status_t::data)) {
         return context.search_data<stop::CriterionFactory>(
             config.get_data<std::string>());
diff --git a/core/test/config/config.cpp b/core/test/config/config.cpp
index b137b220f3f..90eb0c9348d 100644
--- a/core/test/config/config.cpp
+++ b/core/test/config/config.cpp
@@ -1,34 +1,6 @@
-/*******************************<GINKGO LICENSE>******************************
-Copyright (c) 2017-2023, the Ginkgo authors
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions
-are met:
-
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in the
-documentation and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holder nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
-IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
-TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
-PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-******************************<GINKGO LICENSE>*******************************/
+// SPDX-FileCopyrightText: 2017-2023 The Ginkgo authors
+//
+// SPDX-License-Identifier: BSD-3-Clause
 
 #include <ginkgo/core/config/config.hpp>
 
@@ -102,9 +74,9 @@ TEST_F(Config, GenerateObjectWithData)
              {"criteria", this->stop_config}}};
     auto obj = build_from_config<0>(p, reg, {"float", ""}).on(this->exec);
 
-    ASSERT_NE(dynamic_cast<const gko::solver::Cg<float>::Factory*>(obj.get()),
+    ASSERT_NE(dynamic_cast<gko::solver::Cg<float>::Factory*>(obj.get()),
               nullptr);
-    ASSERT_NE(dynamic_cast<const gko::solver::Cg<float>::Factory*>(obj.get())
+    ASSERT_NE(dynamic_cast<gko::solver::Cg<float>::Factory*>(obj.get())
                   ->get_parameters()
                   .generated_preconditioner,
               nullptr);
@@ -121,9 +93,9 @@ TEST_F(Config, GenerateObjectWithPreconditioner)
         pnode{{{"Type", pnode{"Cg"}}, {"criteria", this->stop_config}}};
     auto obj = build_from_config<0>(p, reg).on(this->exec);
 
-    ASSERT_NE(dynamic_cast<const gko::solver::Cg<double>::Factory*>(obj.get()),
+    ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get()),
               nullptr);
-    ASSERT_NE(dynamic_cast<const gko::solver::Cg<double>::Factory*>(obj.get())
+    ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get())
                   ->get_parameters()
                   .preconditioner,
               nullptr);
@@ -146,14 +118,13 @@ TEST_F(Config, GenerateObjectWithCustomBuild)
         pnode{std::map<std::string, pnode>{{"Type", pnode{"Custom"}}}};
     auto obj = build_from_config<0>(p, reg, {"double", ""}).on(this->exec);
 
-    ASSERT_NE(dynamic_cast<const gko::solver::Cg<double>::Factory*>(obj.get()),
+    ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get()),
+              nullptr);
+    ASSERT_NE(dynamic_cast<const gko::solver::Bicg<double>::Factory*>(
+                  dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get())
+                      ->get_parameters()
+                      .preconditioner.get()),
               nullptr);
-    ASSERT_NE(
-        dynamic_cast<const gko::solver::Bicg<double>::Factory*>(
-            dynamic_cast<const gko::solver::Cg<double>::Factory*>(obj.get())
-                ->get_parameters()
-                .preconditioner.get()),
-        nullptr);
 }
 
 
diff --git a/core/test/config/registry.cpp b/core/test/config/registry.cpp
index 64867ec972f..a28dfa370d8 100644
--- a/core/test/config/registry.cpp
+++ b/core/test/config/registry.cpp
@@ -1,34 +1,6 @@
-/*******************************<GINKGO LICENSE>******************************
-Copyright (c) 2017-2023, the Ginkgo authors
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions
-are met:
-
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in the
-documentation and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holder nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
-IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
-TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
-PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-******************************<GINKGO LICENSE>*******************************/
+// SPDX-FileCopyrightText: 2017-2023 The Ginkgo authors
+//
+// SPDX-License-Identifier: BSD-3-Clause
 
 #include <ginkgo/core/config/registry.hpp>
 
diff --git a/include/ginkgo/core/config/config.hpp b/include/ginkgo/core/config/config.hpp
index b17fd216916..3efccd1f605 100644
--- a/include/ginkgo/core/config/config.hpp
+++ b/include/ginkgo/core/config/config.hpp
@@ -1,34 +1,6 @@
-/*******************************<GINKGO LICENSE>******************************
-Copyright (c) 2017-2023, the Ginkgo authors
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions
-are met:
-
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in the
-documentation and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holder nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
-IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
-TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
-PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-******************************<GINKGO LICENSE>*******************************/
+// SPDX-FileCopyrightText: 2017-2023 The Ginkgo authors
+//
+// SPDX-License-Identifier: BSD-3-Clause
 
 #ifndef GKO_PUBLIC_CORE_CONFIG_CONFIG_HPP_
 #define GKO_PUBLIC_CORE_CONFIG_CONFIG_HPP_
diff --git a/include/ginkgo/core/config/registry.hpp b/include/ginkgo/core/config/registry.hpp
index ca6853f2e35..b9b5569f30d 100644
--- a/include/ginkgo/core/config/registry.hpp
+++ b/include/ginkgo/core/config/registry.hpp
@@ -1,34 +1,6 @@
-/*******************************<GINKGO LICENSE>******************************
-Copyright (c) 2017-2023, the Ginkgo authors
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions
-are met:
-
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in the
-documentation and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holder nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
-IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
-TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
-PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-******************************<GINKGO LICENSE>*******************************/
+// SPDX-FileCopyrightText: 2017-2023 The Ginkgo authors
+//
+// SPDX-License-Identifier: BSD-3-Clause
 
 #ifndef GKO_PUBLIC_CORE_CONFIG_REGISTRY_HPP_
 #define GKO_PUBLIC_CORE_CONFIG_REGISTRY_HPP_
diff --git a/include/ginkgo/ginkgo.hpp b/include/ginkgo/ginkgo.hpp
index 854fb8c03da..50d19865d54 100644
--- a/include/ginkgo/ginkgo.hpp
+++ b/include/ginkgo/ginkgo.hpp
@@ -53,7 +53,9 @@
 #include <ginkgo/core/base/utils_helper.hpp>
 #include <ginkgo/core/base/version.hpp>
 
+#include <ginkgo/core/config/config.hpp>
 #include <ginkgo/core/config/property_tree.hpp>
+#include <ginkgo/core/config/registry.hpp>
 
 #include <ginkgo/core/distributed/base.hpp>
 #include <ginkgo/core/distributed/index_map.hpp>

From bf30b5db9174378ce9893ec3ca4ca644f05fd2c2 Mon Sep 17 00:00:00 2001
From: "Yu-Hsiang M. Tsai" <yhmtsai@gmail.com>
Date: Thu, 28 Mar 2024 10:34:33 +0100
Subject: [PATCH 15/25] adapt the corresponding changes

---
 core/config/config.cpp      |  4 ++--
 core/config/config.hpp      | 28 ++++++++++++++--------------
 core/config/stop_config.cpp | 17 ++++++++---------
 core/test/config/config.cpp | 22 ++++++++++++----------
 4 files changed, 36 insertions(+), 35 deletions(-)

diff --git a/core/config/config.cpp b/core/config/config.cpp
index 9f9bb3e2caf..e2e1aa13b3a 100644
--- a/core/config/config.cpp
+++ b/core/config/config.cpp
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2017-2023 The Ginkgo authors
+// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
 //
 // SPDX-License-Identifier: BSD-3-Clause
 
@@ -26,7 +26,7 @@ deferred_factory_parameter<gko::LinOpFactory> build_from_config(
     const pnode& config, const registry& context, type_descriptor td)
 {
     if (auto& obj = config.get("Type")) {
-        auto func = context.get_build_map().at(obj.get_data<std::string>());
+        auto func = context.get_build_map().at(obj.get_string());
         return func(config, context, td);
     }
     GKO_INVALID_STATE("Should contain Type property");
diff --git a/core/config/config.hpp b/core/config/config.hpp
index 3c86e288699..4ed9c25e658 100644
--- a/core/config/config.hpp
+++ b/core/config/config.hpp
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2017-2023 The Ginkgo authors
+// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
 //
 // SPDX-License-Identifier: BSD-3-Clause
 
@@ -35,10 +35,10 @@ inline type_descriptor update_type(const pnode& config,
     type_descriptor updated = td;
 
     if (auto& obj = config.get("ValueType")) {
-        updated.first = obj.get_data<std::string>();
+        updated.first = obj.get_string();
     }
     if (auto& obj = config.get("IndexType")) {
-        updated.second = obj.get_data<std::string>();
+        updated.second = obj.get_string();
     }
     return updated;
 }
@@ -51,7 +51,7 @@ inline std::shared_ptr<T> get_pointer(const pnode& config,
 {
     std::shared_ptr<T> ptr;
     using T_non_const = std::remove_const_t<T>;
-    ptr = context.search_data<T_non_const>(config.get_data<std::string>());
+    ptr = context.search_data<T_non_const>(config.get_string());
     assert(ptr.get() != nullptr);
     return std::move(ptr);
 }
@@ -68,9 +68,9 @@ get_factory<const LinOpFactory>(const pnode& config, const registry& context,
                                 type_descriptor td)
 {
     deferred_factory_parameter<const LinOpFactory> ptr;
-    if (config.is(pnode::status_t::data)) {
-        ptr = context.search_data<LinOpFactory>(config.get_data<std::string>());
-    } else if (config.is(pnode::status_t::map)) {
+    if (config.get_status() == pnode::status_t::string) {
+        ptr = context.search_data<LinOpFactory>(config.get_string());
+    } else if (config.get_status() == pnode::status_t::map) {
         ptr = build_from_config(config, context, td);
     }
     // handle object is config
@@ -91,7 +91,7 @@ inline std::vector<deferred_factory_parameter<T>> get_factory_vector(
 {
     std::vector<deferred_factory_parameter<T>> res;
     // for loop in config
-    if (config.is(pnode::status_t::array)) {
+    if (config.get_status() == pnode::status_t::array) {
         for (const auto& it : config.get_array()) {
             res.push_back(get_factory<T>(it, context, td));
         }
@@ -115,7 +115,7 @@ inline
     typename std::enable_if<std::is_integral<IndexType>::value, IndexType>::type
     get_value(const pnode& config)
 {
-    auto val = config.get_data<long long int>();
+    auto val = config.get_integer();
     assert(val <= std::numeric_limits<IndexType>::max() &&
            val >= std::numeric_limits<IndexType>::min());
     return static_cast<IndexType>(val);
@@ -126,7 +126,7 @@ inline typename std::enable_if<std::is_floating_point<ValueType>::value,
                                ValueType>::type
 get_value(const pnode& config)
 {
-    auto val = config.get_data<double>();
+    auto val = config.get_real();
     assert(val <= std::numeric_limits<ValueType>::max() &&
            val >= -std::numeric_limits<ValueType>::max());
     return static_cast<ValueType>(val);
@@ -138,11 +138,11 @@ inline typename std::enable_if<gko::is_complex_s<ValueType>::value,
 get_value(const pnode& config)
 {
     using real_type = gko::remove_complex<ValueType>;
-    if (config.is(pnode::status_t::data)) {
+    if (config.get_status() == pnode::status_t::real) {
         return static_cast<ValueType>(get_value<real_type>(config));
-    } else if (config.is(pnode::status_t::array)) {
-        return ValueType{get_value<real_type>(config.at(0)),
-                         get_value<real_type>(config.at(1))};
+    } else if (config.get_status() == pnode::status_t::array) {
+        return ValueType{get_value<real_type>(config.get(0)),
+                         get_value<real_type>(config.get(1))};
     }
     GKO_INVALID_STATE("Can not get complex value");
 }
diff --git a/core/config/stop_config.cpp b/core/config/stop_config.cpp
index a3bc0725c65..d4ad5093a5d 100644
--- a/core/config/stop_config.cpp
+++ b/core/config/stop_config.cpp
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2017-2023 The Ginkgo authors
+// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
 //
 // SPDX-License-Identifier: BSD-3-Clause
 
@@ -63,7 +63,7 @@ class ResidualNormConfigurer {
         auto factory = stop::ResidualNorm<ValueType>::build();
         SET_VALUE(factory, remove_complex<ValueType>, reduction_factor, config);
         if (auto& obj = config.get("baseline")) {
-            factory.with_baseline(get_mode(obj.get_data<std::string>()));
+            factory.with_baseline(get_mode(obj.get_string()));
         }
         return factory;
     }
@@ -91,7 +91,7 @@ class ImplicitResidualNormConfigurer {
         auto factory = stop::ImplicitResidualNorm<ValueType>::build();
         SET_VALUE(factory, remove_complex<ValueType>, reduction_factor, config);
         if (auto& obj = config.get("baseline")) {
-            factory.with_baseline(get_mode(obj.get_data<std::string>()));
+            factory.with_baseline(get_mode(obj.get_string()));
         }
         return factory;
     }
@@ -115,10 +115,9 @@ get_factory<const stop::CriterionFactory>(const pnode& config,
                                           type_descriptor td)
 {
     deferred_factory_parameter<const stop::CriterionFactory> ptr;
-    if (config.is(pnode::status_t::data)) {
-        return context.search_data<stop::CriterionFactory>(
-            config.get_data<std::string>());
-    } else if (config.is(pnode::status_t::map)) {
+    if (config.get_status() == pnode::status_t::string) {
+        return context.search_data<stop::CriterionFactory>(config.get_string());
+    } else if (config.get_status() == pnode::status_t::map) {
         static std::map<std::string,
                         std::function<deferred_factory_parameter<
                             gko::stop::CriterionFactory>(
@@ -128,8 +127,8 @@ get_factory<const stop::CriterionFactory>(const pnode& config,
                  {"Iteration", configure_iter},
                  {"ResidualNorm", configure_residual},
                  {"ImplicitResidualNorm", configure_implicit_residual}}};
-        return criterion_map.at(config.at("Type").get_data<std::string>())(
-            config, context, td);
+        return criterion_map.at(config.get("Type").get_string())(config,
+                                                                 context, td);
     }
     assert(!ptr.is_empty());
     return std::move(ptr);
diff --git a/core/test/config/config.cpp b/core/test/config/config.cpp
index 90eb0c9348d..06a8a102033 100644
--- a/core/test/config/config.cpp
+++ b/core/test/config/config.cpp
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2017-2023 The Ginkgo authors
+// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
 //
 // SPDX-License-Identifier: BSD-3-Clause
 
@@ -21,7 +21,6 @@
 
 
 #include "core/config/config.hpp"
-#include "core/test/config/utils.hpp"
 #include "core/test/utils.hpp"
 
 
@@ -87,10 +86,12 @@ TEST_F(Config, GenerateObjectWithPreconditioner)
 {
     auto config_map = generate_config_map();
     auto reg = registry(config_map);
-
-    pnode p{{{"ValueType", pnode{"double"}}, {"criteria", this->stop_config}}};
-    p.get_map()["preconditioner"] =
+    auto precond_node =
         pnode{{{"Type", pnode{"Cg"}}, {"criteria", this->stop_config}}};
+    pnode p{{{"ValueType", pnode{"double"}},
+             {"criteria", this->stop_config},
+             {"preconditioner", precond_node}}};
+
     auto obj = build_from_config<0>(p, reg).on(this->exec);
 
     ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get()),
@@ -112,10 +113,12 @@ TEST_F(Config, GenerateObjectWithCustomBuild)
             gko::stop::Iteration::build().with_max_iters(2u));
     };
     auto reg = registry(config_map);
-
-    pnode p{{{"ValueType", pnode{"double"}}, {"criteria", this->stop_config}}};
-    p.get_map()["preconditioner"] =
+    auto precond_node =
         pnode{std::map<std::string, pnode>{{"Type", pnode{"Custom"}}}};
+    pnode p{{{"ValueType", pnode{"double"}},
+             {"criteria", this->stop_config},
+             {"preconditioner", precond_node}}};
+
     auto obj = build_from_config<0>(p, reg, {"double", ""}).on(this->exec);
 
     ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get()),
@@ -161,8 +164,7 @@ TEST(GetValue, ComplexType)
     double real = 1.0;
     double imag = -1.0;
     pnode config{real};
-    pnode array_config;
-    array_config.get_array() = {pnode{real}, pnode{imag}};
+    pnode array_config{pnode::array_type{real, imag}};
 
     // Only one value
     ASSERT_EQ(get_value<std::complex<float>>(config),

From a2cc99c171cf523ffc9601120139b05ebebef4fa Mon Sep 17 00:00:00 2001
From: "Yu-Hsiang M. Tsai" <yhmtsai@gmail.com>
Date: Thu, 28 Mar 2024 11:52:57 +0100
Subject: [PATCH 16/25] reduce the macro usage

---
 core/config/config.hpp                  | 57 -------------------------
 core/config/dispatch.hpp                |  2 +-
 core/config/stop_config.cpp             | 43 ++++++-------------
 core/solver/cg.cpp                      | 26 ++++++-----
 core/test/config/registry.cpp           |  2 +-
 include/ginkgo/core/config/config.hpp   |  2 +-
 include/ginkgo/core/config/registry.hpp |  2 +-
 7 files changed, 33 insertions(+), 101 deletions(-)

diff --git a/core/config/config.hpp b/core/config/config.hpp
index 4ed9c25e658..e5b14ded215 100644
--- a/core/config/config.hpp
+++ b/core/config/config.hpp
@@ -103,12 +103,6 @@ inline std::vector<deferred_factory_parameter<T>> get_factory_vector(
     return res;
 }
 
-// template <>
-// std::vector<std::shared_ptr<const stop::CriterionFactory>>
-// get_pointer_vector<const stop::CriterionFactory>(
-//     const pnode& config, const registry& context,
-//     std::shared_ptr<const Executor> exec, type_descriptor td);
-
 
 template <typename IndexType>
 inline
@@ -148,57 +142,6 @@ get_value(const pnode& config)
 }
 
 
-#define SET_POINTER(_factory, _param_type, _param_name, _config, _context,   \
-                    _td)                                                     \
-    {                                                                        \
-        if (auto& obj = _config.get(#_param_name)) {                         \
-            _factory.with_##_param_name(                                     \
-                gko::config::get_pointer<_param_type>(obj, _context, _td));  \
-        }                                                                    \
-    }                                                                        \
-    static_assert(true,                                                      \
-                  "This assert is used to counter the false positive extra " \
-                  "semi-colon warnings")
-
-#define SET_FACTORY(_factory, _param_type, _param_name, _config, _context,   \
-                    _td)                                                     \
-    {                                                                        \
-        if (auto& obj = _config.get(#_param_name)) {                         \
-            _factory.with_##_param_name(                                     \
-                gko::config::get_factory<_param_type>(obj, _context, _td));  \
-        }                                                                    \
-    }                                                                        \
-    static_assert(true,                                                      \
-                  "This assert is used to counter the false positive extra " \
-                  "semi-colon warnings")
-
-
-#define SET_FACTORY_VECTOR(_factory, _param_type, _param_name, _config,      \
-                           _context, _td)                                    \
-    {                                                                        \
-        if (auto& obj = _config.get(#_param_name)) {                         \
-            _factory.with_##_param_name(                                     \
-                gko::config::get_factory_vector<_param_type>(obj, _context,  \
-                                                             _td));          \
-        }                                                                    \
-    }                                                                        \
-    static_assert(true,                                                      \
-                  "This assert is used to counter the false positive extra " \
-                  "semi-colon warnings")
-
-
-#define SET_VALUE(_factory, _param_type, _param_name, _config)               \
-    {                                                                        \
-        if (auto& obj = _config.get(#_param_name)) {                         \
-            _factory.with_##_param_name(                                     \
-                gko::config::get_value<_param_type>(obj));                   \
-        }                                                                    \
-    }                                                                        \
-    static_assert(true,                                                      \
-                  "This assert is used to counter the false positive extra " \
-                  "semi-colon warnings")
-
-
 // If we do not put the build_from_config in the class directly, the following
 // can also be in internal header.
 template <typename T>
diff --git a/core/config/dispatch.hpp b/core/config/dispatch.hpp
index 9323d44978a..663a20534b4 100644
--- a/core/config/dispatch.hpp
+++ b/core/config/dispatch.hpp
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2017-2023 The Ginkgo authors
+// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
 //
 // SPDX-License-Identifier: BSD-3-Clause
 
diff --git a/core/config/stop_config.cpp b/core/config/stop_config.cpp
index d4ad5093a5d..4606f483afe 100644
--- a/core/config/stop_config.cpp
+++ b/core/config/stop_config.cpp
@@ -24,7 +24,9 @@ inline deferred_factory_parameter<stop::CriterionFactory> configure_time(
     const pnode& config, const registry& context, type_descriptor td)
 {
     auto factory = stop::Time::build();
-    SET_VALUE(factory, long long int, time_limit, config);
+    if (auto& obj = config.get("time_limit")) {
+        factory.with_time_limit(gko::config::get_value<long long int>(obj));
+    }
     return factory;
 }
 
@@ -33,7 +35,9 @@ inline deferred_factory_parameter<stop::CriterionFactory> configure_iter(
     const pnode& config, const registry& context, type_descriptor td)
 {
     auto factory = stop::Iteration::build();
-    SET_VALUE(factory, size_type, max_iters, config);
+    if (auto& obj = config.get("max_iters")) {
+        factory.with_max_iters(gko::config::get_value<size_type>(obj));
+    }
     return factory;
 }
 
@@ -61,7 +65,10 @@ class ResidualNormConfigurer {
                       gko::config::type_descriptor td_for_child)
     {
         auto factory = stop::ResidualNorm<ValueType>::build();
-        SET_VALUE(factory, remove_complex<ValueType>, reduction_factor, config);
+        if (auto& obj = config.get("reduction_factor")) {
+            factory.with_reduction_factor(
+                gko::config::get_value<remove_complex<ValueType>>(obj));
+        }
         if (auto& obj = config.get("baseline")) {
             factory.with_baseline(get_mode(obj.get_string()));
         }
@@ -89,7 +96,10 @@ class ImplicitResidualNormConfigurer {
                       gko::config::type_descriptor td_for_child)
     {
         auto factory = stop::ImplicitResidualNorm<ValueType>::build();
-        SET_VALUE(factory, remove_complex<ValueType>, reduction_factor, config);
+        if (auto& obj = config.get("reduction_factor")) {
+            factory.with_reduction_factor(
+                gko::config::get_value<remove_complex<ValueType>>(obj));
+        }
         if (auto& obj = config.get("baseline")) {
             factory.with_baseline(get_mode(obj.get_string()));
         }
@@ -134,31 +144,6 @@ get_factory<const stop::CriterionFactory>(const pnode& config,
     return std::move(ptr);
 }
 
-// template <>
-// std::vector<std::shared_ptr<const stop::CriterionFactory>>
-// get_pointer_vector<const stop::CriterionFactory>(
-//     const pnode& config, const registry& context,
-//     std::shared_ptr<const Executor> exec, type_descriptor td)
-// {
-//     std::vector<std::shared_ptr<const stop::CriterionFactory>> res;
-//     if (config.is(pnode::status_t::array)) {
-//         for (const auto& it : config.get_array()) {
-//             res.push_back(get_pointer<const stop::CriterionFactory>(it,
-//             context,
-//                                                                     exec,
-//                                                                     td));
-//         }
-//     } else {
-//         res.push_back(get_pointer<const stop::CriterionFactory>(config,
-//         context,
-//                                                                 exec, td));
-//     }
-//     // TODO: handle shortcut version by config.is(pnode::status_t::map) &&
-//     // !config.contains("Type")
-
-//     return res;
-// }
-
 
 }  // namespace config
 }  // namespace gko
diff --git a/core/solver/cg.cpp b/core/solver/cg.cpp
index ac50fa0ec35..a2570589ccb 100644
--- a/core/solver/cg.cpp
+++ b/core/solver/cg.cpp
@@ -62,17 +62,21 @@ typename Cg<ValueType>::parameters_type Cg<ValueType>::build_from_config(
     config::type_descriptor td_for_child)
 {
     auto factory = solver::Cg<ValueType>::build();
-    SET_POINTER(factory, const LinOp, generated_preconditioner, config, context,
-                td_for_child);
-    // handle parameter requires exec
-    // criteria and preconditioner are almost in each solver -> to another
-    // function.
-    SET_FACTORY_VECTOR(factory, const stop::CriterionFactory, criteria, config,
-                       context, td_for_child);
-    SET_FACTORY(factory, const LinOpFactory, preconditioner, config, context,
-                td_for_child);
-    // can also handle preconditioner, criterion here if they are in
-    // context.
+    // The following will be moved to the common solver function in another pr
+    if (auto& obj = config.get("generated_preconditioner")) {
+        factory.with_generated_preconditioner(
+            gko::config::get_pointer<const LinOp>(obj, context, td_for_child));
+    }
+    if (auto& obj = config.get("criteria")) {
+        factory.with_criteria(
+            gko::config::get_factory_vector<const stop::CriterionFactory>(
+                obj, context, td_for_child));
+    }
+    if (auto& obj = config.get("preconditioner")) {
+        factory.with_preconditioner(
+            gko::config::get_factory<const LinOpFactory>(obj, context,
+                                                         td_for_child));
+    }
     return factory;
 }
 
diff --git a/core/test/config/registry.cpp b/core/test/config/registry.cpp
index a28dfa370d8..72c1dfc524a 100644
--- a/core/test/config/registry.cpp
+++ b/core/test/config/registry.cpp
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2017-2023 The Ginkgo authors
+// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
 //
 // SPDX-License-Identifier: BSD-3-Clause
 
diff --git a/include/ginkgo/core/config/config.hpp b/include/ginkgo/core/config/config.hpp
index 3efccd1f605..5882195f8f5 100644
--- a/include/ginkgo/core/config/config.hpp
+++ b/include/ginkgo/core/config/config.hpp
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2017-2023 The Ginkgo authors
+// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
 //
 // SPDX-License-Identifier: BSD-3-Clause
 
diff --git a/include/ginkgo/core/config/registry.hpp b/include/ginkgo/core/config/registry.hpp
index b9b5569f30d..900fe1569c4 100644
--- a/include/ginkgo/core/config/registry.hpp
+++ b/include/ginkgo/core/config/registry.hpp
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2017-2023 The Ginkgo authors
+// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
 //
 // SPDX-License-Identifier: BSD-3-Clause
 

From b26951c0bf8e4bd784acd1b9199707530e6ebaba Mon Sep 17 00:00:00 2001
From: "Yu-Hsiang M. Tsai" <yhmtsai@gmail.com>
Date: Fri, 29 Mar 2024 00:55:12 +0100
Subject: [PATCH 17/25] export less function in public and move def. to cpp

---
 core/CMakeLists.txt                           |   1 +
 core/config/config.cpp                        |   3 +
 core/config/config_helper.cpp                 |  50 +++++
 core/config/{config.hpp => config_helper.hpp} | 187 +++++++++++-------
 core/config/dispatch.hpp                      |   2 +-
 core/config/stop_config.cpp                   |   2 +-
 core/solver/cg.cpp                            |   8 +-
 core/test/config/config.cpp                   |  12 +-
 include/ginkgo/core/config/config.hpp         |  31 +--
 9 files changed, 205 insertions(+), 91 deletions(-)
 create mode 100644 core/config/config_helper.cpp
 rename core/config/{config.hpp => config_helper.hpp} (52%)

diff --git a/core/CMakeLists.txt b/core/CMakeLists.txt
index 3f9350acdec..c703288985b 100644
--- a/core/CMakeLists.txt
+++ b/core/CMakeLists.txt
@@ -20,6 +20,7 @@ target_sources(ginkgo
     base/timer.cpp
     base/version.cpp
     config/config.cpp
+    config/config_helper.cpp
     config/property_tree.cpp
     config/stop_config.cpp
     distributed/index_map.cpp
diff --git a/core/config/config.cpp b/core/config/config.cpp
index e2e1aa13b3a..36745d909e4 100644
--- a/core/config/config.cpp
+++ b/core/config/config.cpp
@@ -12,6 +12,9 @@
 #include <ginkgo/core/solver/solver_base.hpp>
 
 
+#include "core/config/config_helper.hpp"
+
+
 namespace gko {
 namespace config {
 
diff --git a/core/config/config_helper.cpp b/core/config/config_helper.cpp
new file mode 100644
index 00000000000..7912bfe91ca
--- /dev/null
+++ b/core/config/config_helper.cpp
@@ -0,0 +1,50 @@
+// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#include <type_traits>
+
+
+#include <ginkgo/core/base/exception_helpers.hpp>
+#include <ginkgo/core/base/lin_op.hpp>
+#include <ginkgo/core/config/registry.hpp>
+
+
+#include "core/config/config_helper.hpp"
+
+
+namespace gko {
+namespace config {
+
+
+type_descriptor update_type(const pnode& config, const type_descriptor& td)
+{
+    type_descriptor updated = td;
+
+    if (auto& obj = config.get("ValueType")) {
+        updated.first = obj.get_string();
+    }
+    if (auto& obj = config.get("IndexType")) {
+        updated.second = obj.get_string();
+    }
+    return updated;
+}
+
+
+template <>
+deferred_factory_parameter<const LinOpFactory> get_factory<const LinOpFactory>(
+    const pnode& config, const registry& context, type_descriptor td)
+{
+    deferred_factory_parameter<const LinOpFactory> ptr;
+    if (config.get_status() == pnode::status_t::string) {
+        ptr = context.search_data<LinOpFactory>(config.get_string());
+    } else if (config.get_status() == pnode::status_t::map) {
+        ptr = build_from_config(config, context, td);
+    }
+    assert(!ptr.is_empty());
+    return std::move(ptr);
+}
+
+
+}  // namespace config
+}  // namespace gko
diff --git a/core/config/config.hpp b/core/config/config_helper.hpp
similarity index 52%
rename from core/config/config.hpp
rename to core/config/config_helper.hpp
index e5b14ded215..d094bf55f0f 100644
--- a/core/config/config.hpp
+++ b/core/config/config_helper.hpp
@@ -2,11 +2,8 @@
 //
 // SPDX-License-Identifier: BSD-3-Clause
 
-#ifndef GKO_CORE_CONFIG_CONFIG_HPP_
-#define GKO_CORE_CONFIG_CONFIG_HPP_
-
-
-#include <ginkgo/core/config/config.hpp>
+#ifndef GKO_CORE_CONFIG_CONFIG_HELPER_HPP_
+#define GKO_CORE_CONFIG_CONFIG_HELPER_HPP_
 
 
 #include <string>
@@ -16,6 +13,7 @@
 #include <ginkgo/core/base/exception_helpers.hpp>
 #include <ginkgo/core/base/lin_op.hpp>
 #include <ginkgo/core/base/math.hpp>
+#include <ginkgo/core/config/config.hpp>
 #include <ginkgo/core/config/registry.hpp>
 #include <ginkgo/core/solver/solver_base.hpp>
 #include <ginkgo/core/stop/criterion.hpp>
@@ -24,66 +22,133 @@
 namespace gko {
 namespace config {
 
+
+/**
+ * LinOpFactoryType enum is to avoid forward declartion, linopfactory header,
+ * two template versions of build_from_config
+ */
+enum class LinOpFactoryType : int { Cg = 0 };
+
+
+/**
+ * It is only an intermediate step after dispatching the class base type. Each
+ * implementation needs to deal with the template selection.
+ */
+template <LinOpFactoryType flag>
+deferred_factory_parameter<gko::LinOpFactory> build_from_config(
+    const pnode& config, const registry& context,
+    type_descriptor td = {"", ""});
+
 /**
  * This function is to update the default type setting from current config.
  *
  * @note It might update the unused type for the current class.
  */
-inline type_descriptor update_type(const pnode& config,
-                                   const type_descriptor& td)
-{
-    type_descriptor updated = td;
-
-    if (auto& obj = config.get("ValueType")) {
-        updated.first = obj.get_string();
-    }
-    if (auto& obj = config.get("IndexType")) {
-        updated.second = obj.get_string();
-    }
-    return updated;
-}
-
+type_descriptor update_type(const pnode& config, const type_descriptor& td);
 
+/**
+ * get_pointer searches the pointer in the registry by string
+ */
 template <typename T>
 inline std::shared_ptr<T> get_pointer(const pnode& config,
                                       const registry& context,
-                                      type_descriptor td)
-{
-    std::shared_ptr<T> ptr;
-    using T_non_const = std::remove_const_t<T>;
-    ptr = context.search_data<T_non_const>(config.get_string());
-    assert(ptr.get() != nullptr);
-    return std::move(ptr);
-}
+                                      type_descriptor td);
 
 
+/**
+ * get_factory builds the factory from config (map) or searches the pointers in
+ * the registry by string.
+ */
 template <typename T>
-inline deferred_factory_parameter<T> get_factory(const pnode& config,
-                                                 const registry& context,
-                                                 type_descriptor td);
+deferred_factory_parameter<T> get_factory(const pnode& config,
+                                          const registry& context,
+                                          type_descriptor td);
 
+/**
+ * specialize for const LinOpFactory
+ */
 template <>
-inline deferred_factory_parameter<const LinOpFactory>
-get_factory<const LinOpFactory>(const pnode& config, const registry& context,
-                                type_descriptor td)
-{
-    deferred_factory_parameter<const LinOpFactory> ptr;
-    if (config.get_status() == pnode::status_t::string) {
-        ptr = context.search_data<LinOpFactory>(config.get_string());
-    } else if (config.get_status() == pnode::status_t::map) {
-        ptr = build_from_config(config, context, td);
-    }
-    // handle object is config
-    assert(!ptr.is_empty());
-    return std::move(ptr);
-}
+deferred_factory_parameter<const LinOpFactory> get_factory<const LinOpFactory>(
+    const pnode& config, const registry& context, type_descriptor td);
 
+/**
+ * specialize for const stop::CriterionFactory
+ */
 template <>
 deferred_factory_parameter<const stop::CriterionFactory>
 get_factory<const stop::CriterionFactory>(const pnode& config,
                                           const registry& context,
                                           type_descriptor td);
 
+/**
+ * get_factory_vector will gives a vector of factory by calling get_factory.
+ */
+template <typename T>
+inline std::vector<deferred_factory_parameter<T>> get_factory_vector(
+    const pnode& config, const registry& context, type_descriptor td);
+
+
+/**
+ * get_value gets the corresponding type value from config.
+ *
+ * This is specialization for integral type
+ */
+template <typename IndexType>
+inline
+    typename std::enable_if<std::is_integral<IndexType>::value, IndexType>::type
+    get_value(const pnode& config);
+
+/**
+ * get_value gets the corresponding type value from config.
+ *
+ * This is specialization for floating point type
+ */
+template <typename ValueType>
+inline typename std::enable_if<std::is_floating_point<ValueType>::value,
+                               ValueType>::type
+get_value(const pnode& config);
+
+/**
+ * get_value gets the corresponding type value from config.
+ *
+ * This is specialization for complex type
+ */
+template <typename ValueType>
+inline typename std::enable_if<gko::is_complex_s<ValueType>::value,
+                               ValueType>::type
+get_value(const pnode& config);
+
+
+// type_string providing the mapping from type to string.
+template <typename T>
+struct type_string {
+    static std::string str() { return "N"; };
+};
+
+#define TYPE_STRING_OVERLOAD(_type, _str)         \
+    template <>                                   \
+    struct type_string<_type> {                   \
+        static std::string str() { return _str; } \
+    }
+
+TYPE_STRING_OVERLOAD(double, "double");
+TYPE_STRING_OVERLOAD(float, "float");
+TYPE_STRING_OVERLOAD(std::complex<double>, "complex<double>");
+TYPE_STRING_OVERLOAD(std::complex<float>, "complex<float>");
+
+
+template <typename T>
+inline std::shared_ptr<T> get_pointer(const pnode& config,
+                                      const registry& context,
+                                      type_descriptor td)
+{
+    std::shared_ptr<T> ptr;
+    using T_non_const = std::remove_const_t<T>;
+    ptr = context.search_data<T_non_const>(config.get_string());
+    assert(ptr.get() != nullptr);
+    return std::move(ptr);
+}
+
 
 template <typename T>
 inline std::vector<deferred_factory_parameter<T>> get_factory_vector(
@@ -110,8 +175,10 @@ inline
     get_value(const pnode& config)
 {
     auto val = config.get_integer();
-    assert(val <= std::numeric_limits<IndexType>::max() &&
-           val >= std::numeric_limits<IndexType>::min());
+    GKO_THROW_IF_INVALID(
+        val <= std::numeric_limits<IndexType>::max() &&
+            val >= std::numeric_limits<IndexType>::min(),
+        "the config value is out of the range of the require type.");
     return static_cast<IndexType>(val);
 }
 
@@ -121,8 +188,11 @@ inline typename std::enable_if<std::is_floating_point<ValueType>::value,
 get_value(const pnode& config)
 {
     auto val = config.get_real();
-    assert(val <= std::numeric_limits<ValueType>::max() &&
-           val >= -std::numeric_limits<ValueType>::max());
+    // the max, min of floating point only consider positive value.
+    GKO_THROW_IF_INVALID(
+        val <= std::numeric_limits<ValueType>::max() &&
+            val >= -std::numeric_limits<ValueType>::max(),
+        "the config value is out of the range of the require type.");
     return static_cast<ValueType>(val);
 }
 
@@ -142,27 +212,8 @@ get_value(const pnode& config)
 }
 
 
-// If we do not put the build_from_config in the class directly, the following
-// can also be in internal header.
-template <typename T>
-struct type_string {
-    static std::string str() { return "N"; };
-};
-
-#define TYPE_STRING_OVERLOAD(_type, _str)         \
-    template <>                                   \
-    struct type_string<_type> {                   \
-        static std::string str() { return _str; } \
-    }
-
-TYPE_STRING_OVERLOAD(double, "double");
-TYPE_STRING_OVERLOAD(float, "float");
-TYPE_STRING_OVERLOAD(std::complex<double>, "complex<double>");
-TYPE_STRING_OVERLOAD(std::complex<float>, "complex<float>");
-
-
 }  // namespace config
 }  // namespace gko
 
 
-#endif  // GKO_CORE_CONFIG_CONFIG_HPP_
+#endif  // GKO_CORE_CONFIG_CONFIG_HELPER_HPP_
diff --git a/core/config/dispatch.hpp b/core/config/dispatch.hpp
index 663a20534b4..cb8bd5e776f 100644
--- a/core/config/dispatch.hpp
+++ b/core/config/dispatch.hpp
@@ -17,7 +17,7 @@
 #include <ginkgo/core/synthesizer/containers.hpp>
 
 
-#include "core/config/config.hpp"
+#include "core/config/config_helper.hpp"
 
 
 namespace gko {
diff --git a/core/config/stop_config.cpp b/core/config/stop_config.cpp
index 4606f483afe..a539f7dc251 100644
--- a/core/config/stop_config.cpp
+++ b/core/config/stop_config.cpp
@@ -12,7 +12,7 @@
 #include <ginkgo/core/stop/time.hpp>
 
 
-#include "core/config/config.hpp"
+#include "core/config/config_helper.hpp"
 #include "core/config/dispatch.hpp"
 
 
diff --git a/core/solver/cg.cpp b/core/solver/cg.cpp
index a2570589ccb..e1a66e5c920 100644
--- a/core/solver/cg.cpp
+++ b/core/solver/cg.cpp
@@ -16,7 +16,7 @@
 #include <ginkgo/core/stop/iteration.hpp>
 
 
-#include "core/config/config.hpp"
+#include "core/config/config_helper.hpp"
 #include "core/config/dispatch.hpp"
 #include "core/distributed/helpers.hpp"
 #include "core/solver/cg_kernels.hpp"
@@ -29,9 +29,9 @@ namespace config {
 
 template <>
 deferred_factory_parameter<gko::LinOpFactory>
-build_from_config<static_cast<int>(LinOpFactoryType::Cg)>(
-    const pnode& config, const registry& context,
-    gko::config::type_descriptor td)
+build_from_config<LinOpFactoryType::Cg>(const pnode& config,
+                                        const registry& context,
+                                        gko::config::type_descriptor td)
 {
     auto updated = update_type(config, td);
     return dispatch<gko::LinOpFactory, gko::solver::Cg>(
diff --git a/core/test/config/config.cpp b/core/test/config/config.cpp
index 06a8a102033..3e06437e14f 100644
--- a/core/test/config/config.cpp
+++ b/core/test/config/config.cpp
@@ -20,7 +20,7 @@
 #include <ginkgo/core/stop/residual_norm.hpp>
 
 
-#include "core/config/config.hpp"
+#include "core/config/config_helper.hpp"
 #include "core/test/utils.hpp"
 
 
@@ -56,7 +56,7 @@ TEST_F(Config, GenerateObjectWithoutDefault)
     auto reg = registry(config_map);
 
     pnode p{{{"ValueType", pnode{"double"}}, {"criteria", this->stop_config}}};
-    auto obj = build_from_config<0>(p, reg).on(this->exec);
+    auto obj = build_from_config<LinOpFactoryType::Cg>(p, reg).on(this->exec);
 
     ASSERT_NE(dynamic_cast<const gko::solver::Cg<double>::Factory*>(obj.get()),
               nullptr);
@@ -71,7 +71,8 @@ TEST_F(Config, GenerateObjectWithData)
 
     pnode p{{{"generated_preconditioner", pnode{"precond"}},
              {"criteria", this->stop_config}}};
-    auto obj = build_from_config<0>(p, reg, {"float", ""}).on(this->exec);
+    auto obj = build_from_config<LinOpFactoryType::Cg>(p, reg, {"float", ""})
+                   .on(this->exec);
 
     ASSERT_NE(dynamic_cast<gko::solver::Cg<float>::Factory*>(obj.get()),
               nullptr);
@@ -92,7 +93,7 @@ TEST_F(Config, GenerateObjectWithPreconditioner)
              {"criteria", this->stop_config},
              {"preconditioner", precond_node}}};
 
-    auto obj = build_from_config<0>(p, reg).on(this->exec);
+    auto obj = build_from_config<LinOpFactoryType::Cg>(p, reg).on(this->exec);
 
     ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get()),
               nullptr);
@@ -119,7 +120,8 @@ TEST_F(Config, GenerateObjectWithCustomBuild)
              {"criteria", this->stop_config},
              {"preconditioner", precond_node}}};
 
-    auto obj = build_from_config<0>(p, reg, {"double", ""}).on(this->exec);
+    auto obj = build_from_config<LinOpFactoryType::Cg>(p, reg, {"double", ""})
+                   .on(this->exec);
 
     ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get()),
               nullptr);
diff --git a/include/ginkgo/core/config/config.hpp b/include/ginkgo/core/config/config.hpp
index 5882195f8f5..98eb243bce4 100644
--- a/include/ginkgo/core/config/config.hpp
+++ b/include/ginkgo/core/config/config.hpp
@@ -21,23 +21,30 @@ namespace gko {
 namespace config {
 
 
-enum LinOpFactoryType : int { Cg = 0 };
-
-
-// It is only an intermediate step. If we do not provide the SolverType with VT,
-// IT selection, it can be in detail namespace or hide it by structure
-template <int flag>
-deferred_factory_parameter<gko::LinOpFactory> build_from_config(
-    const pnode& config, const registry& context,
-    type_descriptor td = {"", ""});
-
-
-// The main function
+/**
+ * build_from_config is the main function for file config. It can read the
+ * property tree to create the desired type. `build_from_config(...).on(exec) ->
+ * LinOpFactory`.
+ *
+ * @param config  The property tree which must include `Type` for the class base
+ * and the corresponding template selection.
+ * @param context  The registry which stores the building function map and the
+ * storage for generated object.
+ * @param type_descriptor  The default common type. If the ValueType or
+ * IndexType is required by the class base but user does not provide it, this
+ * function will take this input as the default.
+ *
+ * @return deferred_factory_parameter, user can get LinOpFactory after giving
+ * the executor.
+ */
 deferred_factory_parameter<gko::LinOpFactory> build_from_config(
     const pnode& config, const registry& context,
     type_descriptor td = {"", ""});
 
 
+/**
+ * Generate the configuration map.
+ */
 buildfromconfig_map generate_config_map();
 
 

From 3db920347d7479ea8fbf48c964d558a5bde9f446 Mon Sep 17 00:00:00 2001
From: "Yu-Hsiang M. Tsai" <yhmtsai@gmail.com>
Date: Fri, 29 Mar 2024 01:19:35 +0100
Subject: [PATCH 18/25] move the def to source of registry

---
 core/CMakeLists.txt                     |   1 +
 core/config/registry.cpp                |  50 ++++++++++
 include/ginkgo/core/config/registry.hpp | 119 +++++++++++-------------
 3 files changed, 106 insertions(+), 64 deletions(-)
 create mode 100644 core/config/registry.cpp

diff --git a/core/CMakeLists.txt b/core/CMakeLists.txt
index c703288985b..1fc33c791ab 100644
--- a/core/CMakeLists.txt
+++ b/core/CMakeLists.txt
@@ -22,6 +22,7 @@ target_sources(ginkgo
     config/config.cpp
     config/config_helper.cpp
     config/property_tree.cpp
+    config/registry.cpp
     config/stop_config.cpp
     distributed/index_map.cpp
     distributed/partition.cpp
diff --git a/core/config/registry.cpp b/core/config/registry.cpp
new file mode 100644
index 00000000000..ea377a1c305
--- /dev/null
+++ b/core/config/registry.cpp
@@ -0,0 +1,50 @@
+// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#include <ginkgo/core/config/registry.hpp>
+
+
+namespace gko {
+namespace config {
+
+
+template <>
+linop_map& registry::get_map_impl<linop_map>()
+{
+    return linop_map_;
+}
+
+template <>
+linopfactory_map& registry::get_map_impl<linopfactory_map>()
+{
+    return linopfactory_map_;
+}
+
+template <>
+criterionfactory_map& registry::get_map_impl<criterionfactory_map>()
+{
+    return criterionfactory_map_;
+}
+
+template <>
+const linop_map& registry::get_map_impl<linop_map>() const
+{
+    return linop_map_;
+}
+
+template <>
+const linopfactory_map& registry::get_map_impl<linopfactory_map>() const
+{
+    return linopfactory_map_;
+}
+
+template <>
+const criterionfactory_map& registry::get_map_impl<criterionfactory_map>() const
+{
+    return criterionfactory_map_;
+}
+
+
+}  // namespace config
+}  // namespace gko
diff --git a/include/ginkgo/core/config/registry.hpp b/include/ginkgo/core/config/registry.hpp
index 900fe1569c4..7fcf82bc996 100644
--- a/include/ginkgo/core/config/registry.hpp
+++ b/include/ginkgo/core/config/registry.hpp
@@ -41,36 +41,47 @@ using buildfromconfig_map =
 
 
 /**
- * map_type gives the map type according to the base type of given type.
- *
- * @tparam T  the type
+ * registry is the storage for file config usage. It stores the building
+ * function, linop, linop_factory, criterion
  */
-template <typename T, typename = void>
-struct map_type {
-    using type = void;
-};
-
-template <typename T>
-struct map_type<
-    T, typename std::enable_if<std::is_convertible<T*, LinOp*>::value>::type> {
-    using type = linop_map;
-};
+class registry {
+private:
+    /**
+     * map_type gives the map type according to the base type of given type.
+     *
+     * @tparam T  the type
+     */
+    template <typename T, typename = void>
+    struct map_type {
+        using type = void;
+    };
 
-template <typename T>
-struct map_type<T, typename std::enable_if<
-                       std::is_convertible<T*, LinOpFactory*>::value>::type> {
-    using type = linopfactory_map;
-};
+    template <typename T>
+    struct map_type<T, typename std::enable_if<
+                           std::is_convertible<T*, LinOp*>::value>::type> {
+        using type = linop_map;
+    };
 
-template <typename T>
-struct map_type<T, typename std::enable_if<std::is_convertible<
-                       T*, stop::CriterionFactory*>::value>::type> {
-    using type = criterionfactory_map;
-};
+    template <typename T>
+    struct map_type<T, typename std::enable_if<std::is_convertible<
+                           T*, LinOpFactory*>::value>::type> {
+        using type = linopfactory_map;
+    };
 
+    template <typename T>
+    struct map_type<T, typename std::enable_if<std::is_convertible<
+                           T*, stop::CriterionFactory*>::value>::type> {
+        using type = criterionfactory_map;
+    };
 
-class registry {
 public:
+    /**
+     * registry constructor
+     *
+     * @param build_map  the build map to dispatch the class base. Ginkgo
+     * provides `generate_config_map()` in config.hpp to provide the ginkgo
+     * build map. Users can extend this map to fit their own LinOpFactory.
+     */
     registry(buildfromconfig_map build_map) : build_map_(build_map) {}
 
     /**
@@ -82,11 +93,7 @@ class registry {
      * @param data  the shared pointer of the object
      */
     template <typename T>
-    bool emplace(std::string key, std::shared_ptr<T> data)
-    {
-        auto it = this->get_map<T>().emplace(key, data);
-        return it.second;
-    }
+    bool emplace(std::string key, std::shared_ptr<T> data);
 
     /**
      * search_data searches the key on the corresponding map.
@@ -98,11 +105,11 @@ class registry {
      * @return the shared pointer of the object
      */
     template <typename T>
-    std::shared_ptr<T> search_data(std::string key) const
-    {
-        return gko::as<T>(this->get_map<T>().at(key));
-    }
+    std::shared_ptr<T> search_data(std::string key) const;
 
+    /**
+     * get the stored build map
+     */
     const buildfromconfig_map& get_build_map() const { return build_map_; }
 
 protected:
@@ -114,16 +121,10 @@ class registry {
      * @return the map
      */
     template <typename T>
-    typename map_type<T>::type& get_map()
-    {
-        return this->get_map_impl<typename map_type<T>::type>();
-    }
+    typename map_type<T>::type& get_map();
 
     template <typename T>
-    const typename map_type<T>::type& get_map() const
-    {
-        return this->get_map_impl<typename map_type<T>::type>();
-    }
+    const typename map_type<T>::type& get_map() const;
 
     /**
      * get_map_impl is the implementation of get_map
@@ -146,41 +147,31 @@ class registry {
 };
 
 
-template <>
-inline linop_map& registry::get_map_impl<linop_map>()
+template <typename T>
+inline bool registry::emplace(std::string key, std::shared_ptr<T> data)
 {
-    return linop_map_;
+    auto it = this->get_map<T>().emplace(key, data);
+    return it.second;
 }
 
-template <>
-inline linopfactory_map& registry::get_map_impl<linopfactory_map>()
-{
-    return linopfactory_map_;
-}
 
-template <>
-inline criterionfactory_map& registry::get_map_impl<criterionfactory_map>()
+template <typename T>
+inline std::shared_ptr<T> registry::search_data(std::string key) const
 {
-    return criterionfactory_map_;
+    return gko::as<T>(this->get_map<T>().at(key));
 }
 
-template <>
-inline const linop_map& registry::get_map_impl<linop_map>() const
-{
-    return linop_map_;
-}
 
-template <>
-inline const linopfactory_map& registry::get_map_impl<linopfactory_map>() const
+template <typename T>
+inline typename registry::map_type<T>::type& registry::get_map()
 {
-    return linopfactory_map_;
+    return this->get_map_impl<typename map_type<T>::type>();
 }
 
-template <>
-inline const criterionfactory_map&
-registry::get_map_impl<criterionfactory_map>() const
+template <typename T>
+inline const typename registry::map_type<T>::type& registry::get_map() const
 {
-    return criterionfactory_map_;
+    return this->get_map_impl<typename map_type<T>::type>();
 }
 
 

From da4a31b61f9d9dbf488f2bac8d43e6ac327ca899 Mon Sep 17 00:00:00 2001
From: "Yu-Hsiang M. Tsai" <yhmtsai@gmail.com>
Date: Sun, 14 Apr 2024 21:13:55 +0200
Subject: [PATCH 19/25] adapt the changes

---
 core/config/config_helper.cpp | 4 ++--
 core/config/config_helper.hpp | 6 +++---
 core/config/stop_config.cpp   | 4 ++--
 core/test/config/config.cpp   | 2 +-
 4 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/core/config/config_helper.cpp b/core/config/config_helper.cpp
index 7912bfe91ca..0c203a69ac9 100644
--- a/core/config/config_helper.cpp
+++ b/core/config/config_helper.cpp
@@ -36,9 +36,9 @@ deferred_factory_parameter<const LinOpFactory> get_factory<const LinOpFactory>(
     const pnode& config, const registry& context, type_descriptor td)
 {
     deferred_factory_parameter<const LinOpFactory> ptr;
-    if (config.get_status() == pnode::status_t::string) {
+    if (config.get_tag() == pnode::tag_t::string) {
         ptr = context.search_data<LinOpFactory>(config.get_string());
-    } else if (config.get_status() == pnode::status_t::map) {
+    } else if (config.get_tag() == pnode::tag_t::map) {
         ptr = build_from_config(config, context, td);
     }
     assert(!ptr.is_empty());
diff --git a/core/config/config_helper.hpp b/core/config/config_helper.hpp
index d094bf55f0f..a89439959c0 100644
--- a/core/config/config_helper.hpp
+++ b/core/config/config_helper.hpp
@@ -156,7 +156,7 @@ inline std::vector<deferred_factory_parameter<T>> get_factory_vector(
 {
     std::vector<deferred_factory_parameter<T>> res;
     // for loop in config
-    if (config.get_status() == pnode::status_t::array) {
+    if (config.get_tag() == pnode::tag_t::array) {
         for (const auto& it : config.get_array()) {
             res.push_back(get_factory<T>(it, context, td));
         }
@@ -202,9 +202,9 @@ inline typename std::enable_if<gko::is_complex_s<ValueType>::value,
 get_value(const pnode& config)
 {
     using real_type = gko::remove_complex<ValueType>;
-    if (config.get_status() == pnode::status_t::real) {
+    if (config.get_tag() == pnode::tag_t::real) {
         return static_cast<ValueType>(get_value<real_type>(config));
-    } else if (config.get_status() == pnode::status_t::array) {
+    } else if (config.get_tag() == pnode::tag_t::array) {
         return ValueType{get_value<real_type>(config.get(0)),
                          get_value<real_type>(config.get(1))};
     }
diff --git a/core/config/stop_config.cpp b/core/config/stop_config.cpp
index a539f7dc251..097f29d808a 100644
--- a/core/config/stop_config.cpp
+++ b/core/config/stop_config.cpp
@@ -125,9 +125,9 @@ get_factory<const stop::CriterionFactory>(const pnode& config,
                                           type_descriptor td)
 {
     deferred_factory_parameter<const stop::CriterionFactory> ptr;
-    if (config.get_status() == pnode::status_t::string) {
+    if (config.get_tag() == pnode::tag_t::string) {
         return context.search_data<stop::CriterionFactory>(config.get_string());
-    } else if (config.get_status() == pnode::status_t::map) {
+    } else if (config.get_tag() == pnode::tag_t::map) {
         static std::map<std::string,
                         std::function<deferred_factory_parameter<
                             gko::stop::CriterionFactory>(
diff --git a/core/test/config/config.cpp b/core/test/config/config.cpp
index 3e06437e14f..5f747ac4695 100644
--- a/core/test/config/config.cpp
+++ b/core/test/config/config.cpp
@@ -166,7 +166,7 @@ TEST(GetValue, ComplexType)
     double real = 1.0;
     double imag = -1.0;
     pnode config{real};
-    pnode array_config{pnode::array_type{real, imag}};
+    pnode array_config{pnode::array_type{pnode{real}, pnode{imag}}};
 
     // Only one value
     ASSERT_EQ(get_value<std::complex<float>>(config),

From 92bf10ae08ebb06f51277c0dbf7c22e123f3e300 Mon Sep 17 00:00:00 2001
From: "Yu-Hsiang M. Tsai" <yhmtsai@gmail.com>
Date: Wed, 17 Apr 2024 22:33:10 +0200
Subject: [PATCH 20/25] add type_descriptor class

---
 core/config/config_helper.cpp           |  9 ++--
 core/config/config_helper.hpp           |  9 ++--
 core/config/registry.cpp                | 43 +++++++++++++++++++
 core/config/stop_config.cpp             |  6 ++-
 core/solver/cg.cpp                      |  3 +-
 core/test/config/config.cpp             |  6 ++-
 core/test/config/registry.cpp           | 57 +++++++++++++++++++++----
 include/ginkgo/core/config/config.hpp   |  2 +-
 include/ginkgo/core/config/registry.hpp | 41 +++++++++++++++++-
 9 files changed, 152 insertions(+), 24 deletions(-)

diff --git a/core/config/config_helper.cpp b/core/config/config_helper.cpp
index 0c203a69ac9..fc572c16659 100644
--- a/core/config/config_helper.cpp
+++ b/core/config/config_helper.cpp
@@ -19,15 +19,16 @@ namespace config {
 
 type_descriptor update_type(const pnode& config, const type_descriptor& td)
 {
-    type_descriptor updated = td;
+    auto value_typestr = td.get_value_typestr();
+    auto index_typestr = td.get_index_typestr();
 
     if (auto& obj = config.get("ValueType")) {
-        updated.first = obj.get_string();
+        value_typestr = obj.get_string();
     }
     if (auto& obj = config.get("IndexType")) {
-        updated.second = obj.get_string();
+        index_typestr = obj.get_string();
     }
-    return updated;
+    return type_descriptor{value_typestr, index_typestr};
 }
 
 
diff --git a/core/config/config_helper.hpp b/core/config/config_helper.hpp
index a89439959c0..c545ce8b469 100644
--- a/core/config/config_helper.hpp
+++ b/core/config/config_helper.hpp
@@ -37,7 +37,7 @@ enum class LinOpFactoryType : int { Cg = 0 };
 template <LinOpFactoryType flag>
 deferred_factory_parameter<gko::LinOpFactory> build_from_config(
     const pnode& config, const registry& context,
-    type_descriptor td = {"", ""});
+    type_descriptor td = type_descriptor{"void", "void"});
 
 /**
  * This function is to update the default type setting from current config.
@@ -121,9 +121,7 @@ get_value(const pnode& config);
 
 // type_string providing the mapping from type to string.
 template <typename T>
-struct type_string {
-    static std::string str() { return "N"; };
-};
+struct type_string {};
 
 #define TYPE_STRING_OVERLOAD(_type, _str)         \
     template <>                                   \
@@ -131,10 +129,13 @@ struct type_string {
         static std::string str() { return _str; } \
     }
 
+TYPE_STRING_OVERLOAD(void, "void");
 TYPE_STRING_OVERLOAD(double, "double");
 TYPE_STRING_OVERLOAD(float, "float");
 TYPE_STRING_OVERLOAD(std::complex<double>, "complex<double>");
 TYPE_STRING_OVERLOAD(std::complex<float>, "complex<float>");
+TYPE_STRING_OVERLOAD(int32, "int");
+TYPE_STRING_OVERLOAD(int64, "int64");
 
 
 template <typename T>
diff --git a/core/config/registry.cpp b/core/config/registry.cpp
index ea377a1c305..1e5dccc61ad 100644
--- a/core/config/registry.cpp
+++ b/core/config/registry.cpp
@@ -5,6 +5,9 @@
 #include <ginkgo/core/config/registry.hpp>
 
 
+#include "core/config/config_helper.hpp"
+
+
 namespace gko {
 namespace config {
 
@@ -46,5 +49,45 @@ const criterionfactory_map& registry::get_map_impl<criterionfactory_map>() const
 }
 
 
+template <typename ValueType, typename IndexType>
+type_descriptor make_type_descriptor()
+{
+    return type_descriptor{type_string<ValueType>::str(),
+                           type_string<IndexType>::str()};
+}
+
+template type_descriptor make_type_descriptor<void, void>();
+template type_descriptor make_type_descriptor<float, void>();
+template type_descriptor make_type_descriptor<double, void>();
+template type_descriptor make_type_descriptor<std::complex<float>, void>();
+template type_descriptor make_type_descriptor<std::complex<double>, void>();
+template type_descriptor make_type_descriptor<void, int32>();
+template type_descriptor make_type_descriptor<float, int32>();
+template type_descriptor make_type_descriptor<double, int32>();
+template type_descriptor make_type_descriptor<std::complex<float>, int32>();
+template type_descriptor make_type_descriptor<std::complex<double>, int32>();
+template type_descriptor make_type_descriptor<void, int64>();
+template type_descriptor make_type_descriptor<float, int64>();
+template type_descriptor make_type_descriptor<double, int64>();
+template type_descriptor make_type_descriptor<std::complex<float>, int64>();
+template type_descriptor make_type_descriptor<std::complex<double>, int64>();
+
+
+type_descriptor::type_descriptor(std::string value_typestr,
+                                 std::string index_typestr)
+    : value_typestr_(value_typestr), index_typestr_(index_typestr)
+{}
+
+const std::string& type_descriptor::get_value_typestr() const
+{
+    return value_typestr_;
+}
+
+const std::string& type_descriptor::get_index_typestr() const
+{
+    return index_typestr_;
+}
+
+
 }  // namespace config
 }  // namespace gko
diff --git a/core/config/stop_config.cpp b/core/config/stop_config.cpp
index 097f29d808a..675733c1833 100644
--- a/core/config/stop_config.cpp
+++ b/core/config/stop_config.cpp
@@ -82,7 +82,8 @@ inline deferred_factory_parameter<stop::CriterionFactory> configure_residual(
 {
     auto updated = update_type(config, td);
     return dispatch<stop::CriterionFactory, ResidualNormConfigurer>(
-        updated.first, config, context, updated, value_type_list());
+        updated.get_value_typestr(), config, context, updated,
+        value_type_list());
 }
 
 
@@ -114,7 +115,8 @@ configure_implicit_residual(const pnode& config, const registry& context,
 {
     auto updated = update_type(config, td);
     return dispatch<stop::CriterionFactory, ImplicitResidualNormConfigurer>(
-        updated.first, config, context, updated, value_type_list());
+        updated.get_value_typestr(), config, context, updated,
+        value_type_list());
 }
 
 
diff --git a/core/solver/cg.cpp b/core/solver/cg.cpp
index e1a66e5c920..44b2e6cbd2f 100644
--- a/core/solver/cg.cpp
+++ b/core/solver/cg.cpp
@@ -35,7 +35,8 @@ build_from_config<LinOpFactoryType::Cg>(const pnode& config,
 {
     auto updated = update_type(config, td);
     return dispatch<gko::LinOpFactory, gko::solver::Cg>(
-        updated.first, config, context, updated, value_type_list());
+        updated.get_value_typestr(), config, context, updated,
+        value_type_list());
 }
 
 
diff --git a/core/test/config/config.cpp b/core/test/config/config.cpp
index 5f747ac4695..9fc098d5e96 100644
--- a/core/test/config/config.cpp
+++ b/core/test/config/config.cpp
@@ -71,7 +71,8 @@ TEST_F(Config, GenerateObjectWithData)
 
     pnode p{{{"generated_preconditioner", pnode{"precond"}},
              {"criteria", this->stop_config}}};
-    auto obj = build_from_config<LinOpFactoryType::Cg>(p, reg, {"float", ""})
+    auto obj = build_from_config<LinOpFactoryType::Cg>(
+                   p, reg, type_descriptor{"float", "void"})
                    .on(this->exec);
 
     ASSERT_NE(dynamic_cast<gko::solver::Cg<float>::Factory*>(obj.get()),
@@ -120,7 +121,8 @@ TEST_F(Config, GenerateObjectWithCustomBuild)
              {"criteria", this->stop_config},
              {"preconditioner", precond_node}}};
 
-    auto obj = build_from_config<LinOpFactoryType::Cg>(p, reg, {"double", ""})
+    auto obj = build_from_config<LinOpFactoryType::Cg>(
+                   p, reg, type_descriptor{"double", "void"})
                    .on(this->exec);
 
     ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get()),
diff --git a/core/test/config/registry.cpp b/core/test/config/registry.cpp
index 72c1dfc524a..6e3173996e7 100644
--- a/core/test/config/registry.cpp
+++ b/core/test/config/registry.cpp
@@ -21,9 +21,13 @@
 #include <ginkgo/core/stop/time.hpp>
 
 
+#include "core/config/config_helper.hpp"
 #include "core/test/utils.hpp"
 
 
+using namespace gko::config;
+
+
 class Registry : public ::testing::Test {
 protected:
     using Matrix = gko::matrix::Dense<float>;
@@ -35,9 +39,8 @@ class Registry : public ::testing::Test {
           matrix{Matrix::create(exec)},
           solver_factory{Solver::build().on(exec)},
           stop_factory{Stop::build().on(exec)},
-          func{[](const gko::config::pnode& config,
-                  const gko::config::registry& context,
-                  gko::config::type_descriptor td_for_child) {
+          func{[](const pnode& config, const registry& context,
+                  type_descriptor td_for_child) {
               return gko::solver::Cg<float>::build();
           }},
           reg{{{"func", func}}}
@@ -48,10 +51,9 @@ class Registry : public ::testing::Test {
     std::shared_ptr<typename Solver::Factory> solver_factory;
     std::shared_ptr<typename Stop::Factory> stop_factory;
     std::function<gko::deferred_factory_parameter<gko::LinOpFactory>(
-        const gko::config::pnode&, const gko::config::registry&,
-        gko::config::type_descriptor)>
+        const pnode&, const registry&, type_descriptor)>
         func;
-    gko::config::registry reg;
+    registry reg;
 };
 
 
@@ -148,9 +150,46 @@ TEST_F(Registry, ThrowWithWrongType)
 
 TEST_F(Registry, GetBuildMap)
 {
-    auto factory = reg.get_build_map()
-                       .at("func")(gko::config::pnode{"unused"}, reg, {"", ""})
-                       .on(exec);
+    auto factory =
+        reg.get_build_map()
+            .at("func")(pnode{"unused"}, reg, type_descriptor{"void", "void"})
+            .on(exec);
 
     ASSERT_NE(factory, nullptr);
 }
+
+
+TEST(TypeDescriptor, TemplateCreate)
+{
+    auto td1 = make_type_descriptor<double, int>();
+    auto td2 = make_type_descriptor<float>();
+    auto td3 = make_type_descriptor<void, gko::int64>();
+    auto td4 = make_type_descriptor<std::complex<float>, gko::int32>();
+    auto td5 = make_type_descriptor<>();
+
+    ASSERT_EQ(td1.get_value_typestr(), "double");
+    ASSERT_EQ(td1.get_index_typestr(), "int");
+    ASSERT_EQ(td2.get_value_typestr(), "float");
+    ASSERT_EQ(td2.get_index_typestr(), "void");
+    ASSERT_EQ(td3.get_value_typestr(), "void");
+    ASSERT_EQ(td3.get_index_typestr(), "int64");
+    ASSERT_EQ(td4.get_value_typestr(), "complex<float>");
+    ASSERT_EQ(td4.get_index_typestr(), "int");
+    ASSERT_EQ(td5.get_value_typestr(), "void");
+    ASSERT_EQ(td5.get_index_typestr(), "void");
+}
+
+
+TEST(TypeDescriptor, Constructor)
+{
+    type_descriptor td1;
+    type_descriptor td2("float");
+    type_descriptor td3("double", "int");
+
+    ASSERT_EQ(td1.get_value_typestr(), "void");
+    ASSERT_EQ(td1.get_index_typestr(), "void");
+    ASSERT_EQ(td2.get_value_typestr(), "float");
+    ASSERT_EQ(td2.get_index_typestr(), "void");
+    ASSERT_EQ(td3.get_value_typestr(), "double");
+    ASSERT_EQ(td3.get_index_typestr(), "int");
+}
diff --git a/include/ginkgo/core/config/config.hpp b/include/ginkgo/core/config/config.hpp
index 98eb243bce4..74461f83314 100644
--- a/include/ginkgo/core/config/config.hpp
+++ b/include/ginkgo/core/config/config.hpp
@@ -39,7 +39,7 @@ namespace config {
  */
 deferred_factory_parameter<gko::LinOpFactory> build_from_config(
     const pnode& config, const registry& context,
-    type_descriptor td = {"", ""});
+    type_descriptor td = type_descriptor{"void", "void"});
 
 
 /**
diff --git a/include/ginkgo/core/config/registry.hpp b/include/ginkgo/core/config/registry.hpp
index 7fcf82bc996..4e9abea5902 100644
--- a/include/ginkgo/core/config/registry.hpp
+++ b/include/ginkgo/core/config/registry.hpp
@@ -27,13 +27,52 @@ namespace config {
 
 class registry;
 
+/**
+ * type_descriptor gives the initial default type for common type in ginkgo such
+ * as ValueType and IndexType. If the factory config does not specify these
+ * type, the configuration will use this as the default.
+ */
+class type_descriptor {
+public:
+    /**
+     * type_descriptor constructor. The correctness is checked in
+     * factory configuration. There is free function `make_type_descriptor` to
+     * create the object by template.
+     *
+     * @param value_typestr  the value type string. "void" means no default.
+     * @param index_typestr  the index type string. "void" means no default.
+     *
+     * @note there is no way to call the constructor with explicit template, so
+     * we create another free function to handle it.
+     */
+    explicit type_descriptor(std::string value_typestr = "void",
+                             std::string index_typestr = "void");
+
+    /**
+     * Get the value type string.
+     */
+    const std::string& get_value_typestr() const;
+
+    /**
+     * Get the index type string
+     */
+    const std::string& get_index_typestr() const;
+
+private:
+    std::string value_typestr_;
+    std::string index_typestr_;
+};
+
+
+template <typename ValueType = void, typename IndexType = void>
+type_descriptor make_type_descriptor();
+
 
 using linop_map = std::unordered_map<std::string, std::shared_ptr<LinOp>>;
 using linopfactory_map =
     std::unordered_map<std::string, std::shared_ptr<LinOpFactory>>;
 using criterionfactory_map =
     std::unordered_map<std::string, std::shared_ptr<stop::CriterionFactory>>;
-using type_descriptor = std::pair<std::string, std::string>;
 using buildfromconfig_map =
     std::map<std::string,
              std::function<deferred_factory_parameter<gko::LinOpFactory>(

From 4535b587da808583da7c27fe549f8afec11c831a Mon Sep 17 00:00:00 2001
From: "Yu-Hsiang M. Tsai" <yhmtsai@gmail.com>
Date: Mon, 29 Apr 2024 21:10:26 +0200
Subject: [PATCH 21/25] split file, update doc and name, couple type_list and
 str

Co-authored-by: Marcel Koch <marcel.koch@kit.edu>
---
 core/CMakeLists.txt                           |  1 +
 core/config/config.cpp                        |  9 +-
 core/config/config_helper.cpp                 | 11 ++-
 core/config/config_helper.hpp                 | 58 ++++--------
 core/config/dispatch.hpp                      | 66 +++++++++-----
 core/config/registry.cpp                      | 47 ++--------
 core/config/stop_config.cpp                   | 51 +++++------
 core/config/type_descriptor.cpp               | 56 ++++++++++++
 core/config/type_descriptor_helper.hpp        | 57 ++++++++++++
 core/solver/cg.cpp                            | 30 +++----
 core/test/config/config.cpp                   | 20 ++---
 core/test/config/registry.cpp                 | 58 +++---------
 core/test/config/type_descriptor.cpp          | 74 +++++++++++++++
 include/ginkgo/core/config/config.hpp         | 89 ++++++++++++++++---
 include/ginkgo/core/config/registry.hpp       | 83 ++++++-----------
 .../ginkgo/core/config/type_descriptor.hpp    | 74 +++++++++++++++
 include/ginkgo/core/solver/cg.hpp             |  7 +-
 include/ginkgo/ginkgo.hpp                     |  1 +
 18 files changed, 513 insertions(+), 279 deletions(-)
 create mode 100644 core/config/type_descriptor.cpp
 create mode 100644 core/config/type_descriptor_helper.hpp
 create mode 100644 core/test/config/type_descriptor.cpp
 create mode 100644 include/ginkgo/core/config/type_descriptor.hpp

diff --git a/core/CMakeLists.txt b/core/CMakeLists.txt
index 1fc33c791ab..341983e72fd 100644
--- a/core/CMakeLists.txt
+++ b/core/CMakeLists.txt
@@ -24,6 +24,7 @@ target_sources(ginkgo
     config/property_tree.cpp
     config/registry.cpp
     config/stop_config.cpp
+    config/type_descriptor.cpp
     distributed/index_map.cpp
     distributed/partition.cpp
     factorization/cholesky.cpp
diff --git a/core/config/config.cpp b/core/config/config.cpp
index 36745d909e4..81fc51bba6b 100644
--- a/core/config/config.cpp
+++ b/core/config/config.cpp
@@ -19,14 +19,15 @@ namespace gko {
 namespace config {
 
 
-buildfromconfig_map generate_config_map()
+configuration_map generate_config_map()
 {
-    return {{"Cg", build_from_config<LinOpFactoryType::Cg>}};
+    return {{"solver::Cg", parse<LinOpFactoryType::Cg>}};
 }
 
 
-deferred_factory_parameter<gko::LinOpFactory> build_from_config(
-    const pnode& config, const registry& context, type_descriptor td)
+deferred_factory_parameter<gko::LinOpFactory> parse(const pnode& config,
+                                                    const registry& context,
+                                                    const type_descriptor& td)
 {
     if (auto& obj = config.get("Type")) {
         auto func = context.get_build_map().at(obj.get_string());
diff --git a/core/config/config_helper.cpp b/core/config/config_helper.cpp
index fc572c16659..6fdfaa423df 100644
--- a/core/config/config_helper.cpp
+++ b/core/config/config_helper.cpp
@@ -34,16 +34,19 @@ type_descriptor update_type(const pnode& config, const type_descriptor& td)
 
 template <>
 deferred_factory_parameter<const LinOpFactory> get_factory<const LinOpFactory>(
-    const pnode& config, const registry& context, type_descriptor td)
+    const pnode& config, const registry& context, const type_descriptor& td)
 {
     deferred_factory_parameter<const LinOpFactory> ptr;
     if (config.get_tag() == pnode::tag_t::string) {
         ptr = context.search_data<LinOpFactory>(config.get_string());
     } else if (config.get_tag() == pnode::tag_t::map) {
-        ptr = build_from_config(config, context, td);
+        ptr = parse(config, context, td);
+    } else {
+        GKO_INVALID_STATE("The data of config is not valid.");
     }
-    assert(!ptr.is_empty());
-    return std::move(ptr);
+    GKO_THROW_IF_INVALID(!ptr.is_empty(), "Parse get nullptr in the end");
+
+    return ptr;
 }
 
 
diff --git a/core/config/config_helper.hpp b/core/config/config_helper.hpp
index c545ce8b469..19ba64d0c28 100644
--- a/core/config/config_helper.hpp
+++ b/core/config/config_helper.hpp
@@ -25,7 +25,7 @@ namespace config {
 
 /**
  * LinOpFactoryType enum is to avoid forward declartion, linopfactory header,
- * two template versions of build_from_config
+ * two template versions of parse
  */
 enum class LinOpFactoryType : int { Cg = 0 };
 
@@ -35,24 +35,23 @@ enum class LinOpFactoryType : int { Cg = 0 };
  * implementation needs to deal with the template selection.
  */
 template <LinOpFactoryType flag>
-deferred_factory_parameter<gko::LinOpFactory> build_from_config(
+deferred_factory_parameter<gko::LinOpFactory> parse(
     const pnode& config, const registry& context,
-    type_descriptor td = type_descriptor{"void", "void"});
+    const type_descriptor& td = make_type_descriptor<>());
 
 /**
- * This function is to update the default type setting from current config.
- *
- * @note It might update the unused type for the current class.
+ * This function updates the default type setting from current config. Any type
+ * that is not specified in the config will fall back to the type stored in the
+ * current type_descriptor.
  */
 type_descriptor update_type(const pnode& config, const type_descriptor& td);
 
 /**
- * get_pointer searches the pointer in the registry by string
+ * get_stored_obj searches the object pointer stored in the registry by string
  */
 template <typename T>
-inline std::shared_ptr<T> get_pointer(const pnode& config,
-                                      const registry& context,
-                                      type_descriptor td);
+inline std::shared_ptr<T> get_stored_obj(const pnode& config,
+                                         const registry& context);
 
 
 /**
@@ -62,14 +61,14 @@ inline std::shared_ptr<T> get_pointer(const pnode& config,
 template <typename T>
 deferred_factory_parameter<T> get_factory(const pnode& config,
                                           const registry& context,
-                                          type_descriptor td);
+                                          const type_descriptor& td);
 
 /**
  * specialize for const LinOpFactory
  */
 template <>
 deferred_factory_parameter<const LinOpFactory> get_factory<const LinOpFactory>(
-    const pnode& config, const registry& context, type_descriptor td);
+    const pnode& config, const registry& context, const type_descriptor& td);
 
 /**
  * specialize for const stop::CriterionFactory
@@ -78,14 +77,14 @@ template <>
 deferred_factory_parameter<const stop::CriterionFactory>
 get_factory<const stop::CriterionFactory>(const pnode& config,
                                           const registry& context,
-                                          type_descriptor td);
+                                          const type_descriptor& td);
 
 /**
  * get_factory_vector will gives a vector of factory by calling get_factory.
  */
 template <typename T>
 inline std::vector<deferred_factory_parameter<T>> get_factory_vector(
-    const pnode& config, const registry& context, type_descriptor td);
+    const pnode& config, const registry& context, const type_descriptor& td);
 
 
 /**
@@ -119,44 +118,23 @@ inline typename std::enable_if<gko::is_complex_s<ValueType>::value,
 get_value(const pnode& config);
 
 
-// type_string providing the mapping from type to string.
-template <typename T>
-struct type_string {};
-
-#define TYPE_STRING_OVERLOAD(_type, _str)         \
-    template <>                                   \
-    struct type_string<_type> {                   \
-        static std::string str() { return _str; } \
-    }
-
-TYPE_STRING_OVERLOAD(void, "void");
-TYPE_STRING_OVERLOAD(double, "double");
-TYPE_STRING_OVERLOAD(float, "float");
-TYPE_STRING_OVERLOAD(std::complex<double>, "complex<double>");
-TYPE_STRING_OVERLOAD(std::complex<float>, "complex<float>");
-TYPE_STRING_OVERLOAD(int32, "int");
-TYPE_STRING_OVERLOAD(int64, "int64");
-
-
 template <typename T>
-inline std::shared_ptr<T> get_pointer(const pnode& config,
-                                      const registry& context,
-                                      type_descriptor td)
+inline std::shared_ptr<T> get_stored_obj(const pnode& config,
+                                         const registry& context)
 {
     std::shared_ptr<T> ptr;
     using T_non_const = std::remove_const_t<T>;
     ptr = context.search_data<T_non_const>(config.get_string());
-    assert(ptr.get() != nullptr);
-    return std::move(ptr);
+    GKO_THROW_IF_INVALID(ptr.get() != nullptr, "Do not get the stored data");
+    return ptr;
 }
 
 
 template <typename T>
 inline std::vector<deferred_factory_parameter<T>> get_factory_vector(
-    const pnode& config, const registry& context, type_descriptor td)
+    const pnode& config, const registry& context, const type_descriptor& td)
 {
     std::vector<deferred_factory_parameter<T>> res;
-    // for loop in config
     if (config.get_tag() == pnode::tag_t::array) {
         for (const auto& it : config.get_array()) {
             res.push_back(get_factory<T>(it, context, td));
diff --git a/core/config/dispatch.hpp b/core/config/dispatch.hpp
index cb8bd5e776f..25b7af425c0 100644
--- a/core/config/dispatch.hpp
+++ b/core/config/dispatch.hpp
@@ -18,62 +18,84 @@
 
 
 #include "core/config/config_helper.hpp"
+#include "core/config/type_descriptor_helper.hpp"
 
 
 namespace gko {
 namespace config {
 
 
+/**
+ * type_selector connect the runtime string and the allowed type list together
+ */
+template <typename... T>
+struct type_selector {
+    explicit type_selector(const std::string& input) : runtime(input) {}
+
+    std::string runtime;
+};
+
+
+/**
+ * It is the helper function to create type_selector with the type_list as the
+ * argument.
+ */
+template <typename... T>
+type_selector<T...> make_type_selector(const std::string& runtime_type,
+                                       syn::type_list<T...>)
+{
+    return type_selector<T...>{runtime_type};
+}
+
+
 /**
  * This function is to dispatch the type from runtime parameter.
  * The concrete class need to have static member function
- * build_from_config(pnode, registry, type_descriptor)
+ * parse(pnode, registry, type_descriptor)
  */
 template <typename ReturnType, template <class...> class Base,
           typename... Types>
-deferred_factory_parameter<ReturnType> dispatch(std::string str,
-                                                const pnode& config,
+deferred_factory_parameter<ReturnType> dispatch(const pnode& config,
                                                 const registry& context,
                                                 const type_descriptor& td)
 {
-    return Base<Types...>::build_from_config(config, context, td);
+    return Base<Types...>::parse(config, context, td);
 }
 
 // When the dispatch does not find match from the given list.
 template <typename ReturnType, template <class...> class Base,
-          typename... Types, typename... List>
-deferred_factory_parameter<ReturnType> dispatch(std::string str,
-                                                const pnode& config,
+          typename... Types, typename... Rest>
+deferred_factory_parameter<ReturnType> dispatch(const pnode& config,
                                                 const registry& context,
                                                 const type_descriptor& td,
-                                                syn::type_list<>, List... list)
+                                                type_selector<> selector,
+                                                Rest... rest)
 {
-    GKO_INVALID_STATE("Can not figure out the actual type");
+    GKO_INVALID_STATE("The provided runtime type >" + selector.runtime +
+                      "< doesn't match any of the allowed compile time types.");
 }
 
 /**
- * @param str  the identifier for runtime type: the format is type1,type2,...
  * @param config  the configuration
  * @param context  the registry context
  * @param td  the default type descriptor
- * @param type_list  the type list for checking
- * @param list...  the type list for the rest type
+ * @param selector  the current dispatching type_selector
+ * @param rest...  the type_selector list for the rest
  */
 template <typename ReturnType, template <class...> class Base,
-          typename... Types, typename S, typename... T, typename... List>
+          typename... Types, typename S, typename... AllowedTypes,
+          typename... Rest>
 deferred_factory_parameter<ReturnType> dispatch(
-    std::string str, const pnode& config, const registry& context,
-    const type_descriptor& td, syn::type_list<S, T...>, List... list)
+    const pnode& config, const registry& context, const type_descriptor& td,
+    type_selector<S, AllowedTypes...> selector, Rest... rest)
 {
-    auto pos = str.find(",");
-    auto item = str.substr(0, pos);
-    auto res = (pos == std::string::npos) ? "" : str.substr(pos + 1);
-    if (item == type_string<S>::str()) {
-        return dispatch<ReturnType, Base, Types..., S>(res, config, context, td,
-                                                       list...);
+    if (selector.runtime == type_string<S>::str()) {
+        return dispatch<ReturnType, Base, Types..., S>(config, context, td,
+                                                       rest...);
     } else {
         return dispatch<ReturnType, Base, Types...>(
-            str, config, context, td, syn::type_list<T...>(), list...);
+            config, context, td,
+            type_selector<AllowedTypes...>(selector.runtime), rest...);
     }
 }
 
diff --git a/core/config/registry.cpp b/core/config/registry.cpp
index 1e5dccc61ad..d816be2551a 100644
--- a/core/config/registry.cpp
+++ b/core/config/registry.cpp
@@ -12,6 +12,13 @@ namespace gko {
 namespace config {
 
 
+using linop_map = std::unordered_map<std::string, std::shared_ptr<LinOp>>;
+using linopfactory_map =
+    std::unordered_map<std::string, std::shared_ptr<LinOpFactory>>;
+using criterionfactory_map =
+    std::unordered_map<std::string, std::shared_ptr<stop::CriterionFactory>>;
+
+
 template <>
 linop_map& registry::get_map_impl<linop_map>()
 {
@@ -49,45 +56,5 @@ const criterionfactory_map& registry::get_map_impl<criterionfactory_map>() const
 }
 
 
-template <typename ValueType, typename IndexType>
-type_descriptor make_type_descriptor()
-{
-    return type_descriptor{type_string<ValueType>::str(),
-                           type_string<IndexType>::str()};
-}
-
-template type_descriptor make_type_descriptor<void, void>();
-template type_descriptor make_type_descriptor<float, void>();
-template type_descriptor make_type_descriptor<double, void>();
-template type_descriptor make_type_descriptor<std::complex<float>, void>();
-template type_descriptor make_type_descriptor<std::complex<double>, void>();
-template type_descriptor make_type_descriptor<void, int32>();
-template type_descriptor make_type_descriptor<float, int32>();
-template type_descriptor make_type_descriptor<double, int32>();
-template type_descriptor make_type_descriptor<std::complex<float>, int32>();
-template type_descriptor make_type_descriptor<std::complex<double>, int32>();
-template type_descriptor make_type_descriptor<void, int64>();
-template type_descriptor make_type_descriptor<float, int64>();
-template type_descriptor make_type_descriptor<double, int64>();
-template type_descriptor make_type_descriptor<std::complex<float>, int64>();
-template type_descriptor make_type_descriptor<std::complex<double>, int64>();
-
-
-type_descriptor::type_descriptor(std::string value_typestr,
-                                 std::string index_typestr)
-    : value_typestr_(value_typestr), index_typestr_(index_typestr)
-{}
-
-const std::string& type_descriptor::get_value_typestr() const
-{
-    return value_typestr_;
-}
-
-const std::string& type_descriptor::get_index_typestr() const
-{
-    return index_typestr_;
-}
-
-
 }  // namespace config
 }  // namespace gko
diff --git a/core/config/stop_config.cpp b/core/config/stop_config.cpp
index 675733c1833..d7279720b5f 100644
--- a/core/config/stop_config.cpp
+++ b/core/config/stop_config.cpp
@@ -14,6 +14,7 @@
 
 #include "core/config/config_helper.hpp"
 #include "core/config/dispatch.hpp"
+#include "core/config/type_descriptor_helper.hpp"
 
 
 namespace gko {
@@ -21,7 +22,7 @@ namespace config {
 
 
 inline deferred_factory_parameter<stop::CriterionFactory> configure_time(
-    const pnode& config, const registry& context, type_descriptor td)
+    const pnode& config, const registry& context, const type_descriptor& td)
 {
     auto factory = stop::Time::build();
     if (auto& obj = config.get("time_limit")) {
@@ -32,7 +33,7 @@ inline deferred_factory_parameter<stop::CriterionFactory> configure_time(
 
 
 inline deferred_factory_parameter<stop::CriterionFactory> configure_iter(
-    const pnode& config, const registry& context, type_descriptor td)
+    const pnode& config, const registry& context, const type_descriptor& td)
 {
     auto factory = stop::Iteration::build();
     if (auto& obj = config.get("max_iters")) {
@@ -60,30 +61,30 @@ class ResidualNormConfigurer {
 public:
     static deferred_factory_parameter<
         typename stop::ResidualNorm<ValueType>::Factory>
-    build_from_config(const gko::config::pnode& config,
-                      const gko::config::registry& context,
-                      gko::config::type_descriptor td_for_child)
+    parse(const gko::config::pnode& config,
+          const gko::config::registry& context,
+          const gko::config::type_descriptor& td_for_child)
     {
-        auto factory = stop::ResidualNorm<ValueType>::build();
+        auto params = stop::ResidualNorm<ValueType>::build();
         if (auto& obj = config.get("reduction_factor")) {
-            factory.with_reduction_factor(
+            params.with_reduction_factor(
                 gko::config::get_value<remove_complex<ValueType>>(obj));
         }
         if (auto& obj = config.get("baseline")) {
-            factory.with_baseline(get_mode(obj.get_string()));
+            params.with_baseline(get_mode(obj.get_string()));
         }
-        return factory;
+        return params;
     }
 };
 
 
 inline deferred_factory_parameter<stop::CriterionFactory> configure_residual(
-    const pnode& config, const registry& context, type_descriptor td)
+    const pnode& config, const registry& context, const type_descriptor& td)
 {
     auto updated = update_type(config, td);
     return dispatch<stop::CriterionFactory, ResidualNormConfigurer>(
-        updated.get_value_typestr(), config, context, updated,
-        value_type_list());
+        config, context, updated,
+        make_type_selector(updated.get_value_typestr(), value_type_list()));
 }
 
 
@@ -92,31 +93,31 @@ class ImplicitResidualNormConfigurer {
 public:
     static deferred_factory_parameter<
         typename stop::ImplicitResidualNorm<ValueType>::Factory>
-    build_from_config(const gko::config::pnode& config,
-                      const gko::config::registry& context,
-                      gko::config::type_descriptor td_for_child)
+    parse(const gko::config::pnode& config,
+          const gko::config::registry& context,
+          const gko::config::type_descriptor& td_for_child)
     {
-        auto factory = stop::ImplicitResidualNorm<ValueType>::build();
+        auto params = stop::ImplicitResidualNorm<ValueType>::build();
         if (auto& obj = config.get("reduction_factor")) {
-            factory.with_reduction_factor(
+            params.with_reduction_factor(
                 gko::config::get_value<remove_complex<ValueType>>(obj));
         }
         if (auto& obj = config.get("baseline")) {
-            factory.with_baseline(get_mode(obj.get_string()));
+            params.with_baseline(get_mode(obj.get_string()));
         }
-        return factory;
+        return params;
     }
 };
 
 
 inline deferred_factory_parameter<stop::CriterionFactory>
 configure_implicit_residual(const pnode& config, const registry& context,
-                            type_descriptor td)
+                            const type_descriptor& td)
 {
     auto updated = update_type(config, td);
     return dispatch<stop::CriterionFactory, ImplicitResidualNormConfigurer>(
-        updated.get_value_typestr(), config, context, updated,
-        value_type_list());
+        config, context, updated,
+        make_type_selector(updated.get_value_typestr(), value_type_list()));
 }
 
 
@@ -124,7 +125,7 @@ template <>
 deferred_factory_parameter<const stop::CriterionFactory>
 get_factory<const stop::CriterionFactory>(const pnode& config,
                                           const registry& context,
-                                          type_descriptor td)
+                                          const type_descriptor& td)
 {
     deferred_factory_parameter<const stop::CriterionFactory> ptr;
     if (config.get_tag() == pnode::tag_t::string) {
@@ -142,8 +143,8 @@ get_factory<const stop::CriterionFactory>(const pnode& config,
         return criterion_map.at(config.get("Type").get_string())(config,
                                                                  context, td);
     }
-    assert(!ptr.is_empty());
-    return std::move(ptr);
+    GKO_THROW_IF_INVALID(!ptr.is_empty(), "Parse get nullptr in the end");
+    return ptr;
 }
 
 
diff --git a/core/config/type_descriptor.cpp b/core/config/type_descriptor.cpp
new file mode 100644
index 00000000000..0c4bdb475b6
--- /dev/null
+++ b/core/config/type_descriptor.cpp
@@ -0,0 +1,56 @@
+// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#include <ginkgo/core/config/type_descriptor.hpp>
+
+
+#include "core/config/type_descriptor_helper.hpp"
+
+
+namespace gko {
+namespace config {
+
+
+template <typename ValueType, typename IndexType>
+type_descriptor make_type_descriptor()
+{
+    return type_descriptor{type_string<ValueType>::str(),
+                           type_string<IndexType>::str()};
+}
+
+template type_descriptor make_type_descriptor<void, void>();
+template type_descriptor make_type_descriptor<float, void>();
+template type_descriptor make_type_descriptor<double, void>();
+template type_descriptor make_type_descriptor<std::complex<float>, void>();
+template type_descriptor make_type_descriptor<std::complex<double>, void>();
+template type_descriptor make_type_descriptor<void, int32>();
+template type_descriptor make_type_descriptor<float, int32>();
+template type_descriptor make_type_descriptor<double, int32>();
+template type_descriptor make_type_descriptor<std::complex<float>, int32>();
+template type_descriptor make_type_descriptor<std::complex<double>, int32>();
+template type_descriptor make_type_descriptor<void, int64>();
+template type_descriptor make_type_descriptor<float, int64>();
+template type_descriptor make_type_descriptor<double, int64>();
+template type_descriptor make_type_descriptor<std::complex<float>, int64>();
+template type_descriptor make_type_descriptor<std::complex<double>, int64>();
+
+
+type_descriptor::type_descriptor(std::string value_typestr,
+                                 std::string index_typestr)
+    : value_typestr_(value_typestr), index_typestr_(index_typestr)
+{}
+
+const std::string& type_descriptor::get_value_typestr() const
+{
+    return value_typestr_;
+}
+
+const std::string& type_descriptor::get_index_typestr() const
+{
+    return index_typestr_;
+}
+
+
+}  // namespace config
+}  // namespace gko
diff --git a/core/config/type_descriptor_helper.hpp b/core/config/type_descriptor_helper.hpp
new file mode 100644
index 00000000000..261250ab9ed
--- /dev/null
+++ b/core/config/type_descriptor_helper.hpp
@@ -0,0 +1,57 @@
+// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#ifndef GKO_CORE_CONFIG_TYPE_DESCRIPTOR_HELPER_HPP_
+#define GKO_CORE_CONFIG_TYPE_DESCRIPTOR_HELPER_HPP_
+
+
+#include <string>
+#include <type_traits>
+
+
+#include <ginkgo/core/base/exception_helpers.hpp>
+#include <ginkgo/core/base/lin_op.hpp>
+#include <ginkgo/core/base/math.hpp>
+#include <ginkgo/core/config/config.hpp>
+#include <ginkgo/core/config/registry.hpp>
+#include <ginkgo/core/solver/solver_base.hpp>
+#include <ginkgo/core/stop/criterion.hpp>
+
+
+namespace gko {
+namespace config {
+
+
+/**
+ This function updates the default type setting from current config. Any type
+ that is not specified in the config will fall back to the type stored in the
+ current type_descriptor.
+ */
+type_descriptor update_type(const pnode& config, const type_descriptor& td);
+
+
+// type_string providing the mapping from type to string.
+template <typename T>
+struct type_string {};
+
+#define TYPE_STRING_OVERLOAD(_type, _str)         \
+    template <>                                   \
+    struct type_string<_type> {                   \
+        static std::string str() { return _str; } \
+    }
+
+TYPE_STRING_OVERLOAD(void, "void");
+TYPE_STRING_OVERLOAD(double, "double");
+TYPE_STRING_OVERLOAD(float, "float");
+TYPE_STRING_OVERLOAD(std::complex<double>, "complex<double>");
+TYPE_STRING_OVERLOAD(std::complex<float>, "complex<float>");
+TYPE_STRING_OVERLOAD(int32, "int");
+TYPE_STRING_OVERLOAD(int64, "int64");
+
+
+}  // namespace config
+}  // namespace gko
+
+
+#endif  // GKO_CORE_CONFIG_TYPE_DESCRIPTOR_HELPER_HPP_
diff --git a/core/solver/cg.cpp b/core/solver/cg.cpp
index 44b2e6cbd2f..5452fe2bb7a 100644
--- a/core/solver/cg.cpp
+++ b/core/solver/cg.cpp
@@ -18,6 +18,7 @@
 
 #include "core/config/config_helper.hpp"
 #include "core/config/dispatch.hpp"
+#include "core/config/type_descriptor_helper.hpp"
 #include "core/distributed/helpers.hpp"
 #include "core/solver/cg_kernels.hpp"
 #include "core/solver/solver_boilerplate.hpp"
@@ -28,15 +29,13 @@ namespace config {
 
 
 template <>
-deferred_factory_parameter<gko::LinOpFactory>
-build_from_config<LinOpFactoryType::Cg>(const pnode& config,
-                                        const registry& context,
-                                        gko::config::type_descriptor td)
+deferred_factory_parameter<gko::LinOpFactory> parse<LinOpFactoryType::Cg>(
+    const pnode& config, const registry& context, const type_descriptor& td)
 {
     auto updated = update_type(config, td);
     return dispatch<gko::LinOpFactory, gko::solver::Cg>(
-        updated.get_value_typestr(), config, context, updated,
-        value_type_list());
+        config, context, updated,
+        make_type_selector(updated.get_value_typestr(), value_type_list()));
 }
 
 
@@ -58,27 +57,26 @@ GKO_REGISTER_OPERATION(step_2, cg::step_2);
 
 
 template <typename ValueType>
-typename Cg<ValueType>::parameters_type Cg<ValueType>::build_from_config(
+typename Cg<ValueType>::parameters_type Cg<ValueType>::parse(
     const config::pnode& config, const config::registry& context,
-    config::type_descriptor td_for_child)
+    const config::type_descriptor& td_for_child)
 {
-    auto factory = solver::Cg<ValueType>::build();
+    auto params = solver::Cg<ValueType>::build();
     // The following will be moved to the common solver function in another pr
     if (auto& obj = config.get("generated_preconditioner")) {
-        factory.with_generated_preconditioner(
-            gko::config::get_pointer<const LinOp>(obj, context, td_for_child));
+        params.with_generated_preconditioner(
+            gko::config::get_stored_obj<const LinOp>(obj, context));
     }
     if (auto& obj = config.get("criteria")) {
-        factory.with_criteria(
+        params.with_criteria(
             gko::config::get_factory_vector<const stop::CriterionFactory>(
                 obj, context, td_for_child));
     }
     if (auto& obj = config.get("preconditioner")) {
-        factory.with_preconditioner(
-            gko::config::get_factory<const LinOpFactory>(obj, context,
-                                                         td_for_child));
+        params.with_preconditioner(gko::config::get_factory<const LinOpFactory>(
+            obj, context, td_for_child));
     }
-    return factory;
+    return params;
 }
 
 
diff --git a/core/test/config/config.cpp b/core/test/config/config.cpp
index 9fc098d5e96..84af76c7b84 100644
--- a/core/test/config/config.cpp
+++ b/core/test/config/config.cpp
@@ -56,7 +56,7 @@ TEST_F(Config, GenerateObjectWithoutDefault)
     auto reg = registry(config_map);
 
     pnode p{{{"ValueType", pnode{"double"}}, {"criteria", this->stop_config}}};
-    auto obj = build_from_config<LinOpFactoryType::Cg>(p, reg).on(this->exec);
+    auto obj = parse<LinOpFactoryType::Cg>(p, reg).on(this->exec);
 
     ASSERT_NE(dynamic_cast<const gko::solver::Cg<double>::Factory*>(obj.get()),
               nullptr);
@@ -71,9 +71,9 @@ TEST_F(Config, GenerateObjectWithData)
 
     pnode p{{{"generated_preconditioner", pnode{"precond"}},
              {"criteria", this->stop_config}}};
-    auto obj = build_from_config<LinOpFactoryType::Cg>(
-                   p, reg, type_descriptor{"float", "void"})
-                   .on(this->exec);
+    auto obj =
+        parse<LinOpFactoryType::Cg>(p, reg, type_descriptor{"float", "void"})
+            .on(this->exec);
 
     ASSERT_NE(dynamic_cast<gko::solver::Cg<float>::Factory*>(obj.get()),
               nullptr);
@@ -89,12 +89,12 @@ TEST_F(Config, GenerateObjectWithPreconditioner)
     auto config_map = generate_config_map();
     auto reg = registry(config_map);
     auto precond_node =
-        pnode{{{"Type", pnode{"Cg"}}, {"criteria", this->stop_config}}};
+        pnode{{{"Type", pnode{"solver::Cg"}}, {"criteria", this->stop_config}}};
     pnode p{{{"ValueType", pnode{"double"}},
              {"criteria", this->stop_config},
              {"preconditioner", precond_node}}};
 
-    auto obj = build_from_config<LinOpFactoryType::Cg>(p, reg).on(this->exec);
+    auto obj = parse<LinOpFactoryType::Cg>(p, reg).on(this->exec);
 
     ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get()),
               nullptr);
@@ -110,7 +110,7 @@ TEST_F(Config, GenerateObjectWithCustomBuild)
     auto config_map = generate_config_map();
 
     config_map["Custom"] = [](const pnode& config, const registry& context,
-                              type_descriptor td_for_child) {
+                              const type_descriptor& td_for_child) {
         return gko::solver::Bicg<double>::build().with_criteria(
             gko::stop::Iteration::build().with_max_iters(2u));
     };
@@ -121,9 +121,9 @@ TEST_F(Config, GenerateObjectWithCustomBuild)
              {"criteria", this->stop_config},
              {"preconditioner", precond_node}}};
 
-    auto obj = build_from_config<LinOpFactoryType::Cg>(
-                   p, reg, type_descriptor{"double", "void"})
-                   .on(this->exec);
+    auto obj =
+        parse<LinOpFactoryType::Cg>(p, reg, type_descriptor{"double", "void"})
+            .on(this->exec);
 
     ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get()),
               nullptr);
diff --git a/core/test/config/registry.cpp b/core/test/config/registry.cpp
index 6e3173996e7..8e8c530ab4a 100644
--- a/core/test/config/registry.cpp
+++ b/core/test/config/registry.cpp
@@ -40,7 +40,7 @@ class Registry : public ::testing::Test {
           solver_factory{Solver::build().on(exec)},
           stop_factory{Stop::build().on(exec)},
           func{[](const pnode& config, const registry& context,
-                  type_descriptor td_for_child) {
+                  const type_descriptor& td_for_child) {
               return gko::solver::Cg<float>::build();
           }},
           reg{{{"func", func}}}
@@ -59,14 +59,18 @@ class Registry : public ::testing::Test {
 
 TEST_F(Registry, InsertData)
 {
-    // Can put data
-    ASSERT_TRUE(reg.emplace("matrix", matrix));
-    ASSERT_TRUE(reg.emplace("solver_factory", solver_factory));
-    ASSERT_TRUE(reg.emplace("stop_factory", stop_factory));
-    // Do not insert the same key like normal map
-    ASSERT_FALSE(reg.emplace("matrix", matrix));
-    ASSERT_FALSE(reg.emplace("solver_factory", solver_factory));
-    ASSERT_FALSE(reg.emplace("stop_factory", stop_factory));
+    {
+        SCOPED_TRACE("can put data");
+        ASSERT_TRUE(reg.emplace("matrix", matrix));
+        ASSERT_TRUE(reg.emplace("solver_factory", solver_factory));
+        ASSERT_TRUE(reg.emplace("stop_factory", stop_factory));
+    }
+    {
+        SCOPED_TRACE("do not insert the same key like normal map");
+        ASSERT_FALSE(reg.emplace("matrix", matrix));
+        ASSERT_FALSE(reg.emplace("solver_factory", solver_factory));
+        ASSERT_FALSE(reg.emplace("stop_factory", stop_factory));
+    }
 }
 
 
@@ -157,39 +161,3 @@ TEST_F(Registry, GetBuildMap)
 
     ASSERT_NE(factory, nullptr);
 }
-
-
-TEST(TypeDescriptor, TemplateCreate)
-{
-    auto td1 = make_type_descriptor<double, int>();
-    auto td2 = make_type_descriptor<float>();
-    auto td3 = make_type_descriptor<void, gko::int64>();
-    auto td4 = make_type_descriptor<std::complex<float>, gko::int32>();
-    auto td5 = make_type_descriptor<>();
-
-    ASSERT_EQ(td1.get_value_typestr(), "double");
-    ASSERT_EQ(td1.get_index_typestr(), "int");
-    ASSERT_EQ(td2.get_value_typestr(), "float");
-    ASSERT_EQ(td2.get_index_typestr(), "void");
-    ASSERT_EQ(td3.get_value_typestr(), "void");
-    ASSERT_EQ(td3.get_index_typestr(), "int64");
-    ASSERT_EQ(td4.get_value_typestr(), "complex<float>");
-    ASSERT_EQ(td4.get_index_typestr(), "int");
-    ASSERT_EQ(td5.get_value_typestr(), "void");
-    ASSERT_EQ(td5.get_index_typestr(), "void");
-}
-
-
-TEST(TypeDescriptor, Constructor)
-{
-    type_descriptor td1;
-    type_descriptor td2("float");
-    type_descriptor td3("double", "int");
-
-    ASSERT_EQ(td1.get_value_typestr(), "void");
-    ASSERT_EQ(td1.get_index_typestr(), "void");
-    ASSERT_EQ(td2.get_value_typestr(), "float");
-    ASSERT_EQ(td2.get_index_typestr(), "void");
-    ASSERT_EQ(td3.get_value_typestr(), "double");
-    ASSERT_EQ(td3.get_index_typestr(), "int");
-}
diff --git a/core/test/config/type_descriptor.cpp b/core/test/config/type_descriptor.cpp
new file mode 100644
index 00000000000..d45cb47e730
--- /dev/null
+++ b/core/test/config/type_descriptor.cpp
@@ -0,0 +1,74 @@
+// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#include <ginkgo/core/config/type_descriptor.hpp>
+
+
+#include <gtest/gtest.h>
+
+
+#include "core/config/type_descriptor_helper.hpp"
+#include "core/test/utils.hpp"
+
+
+using namespace gko::config;
+
+
+TEST(TypeDescriptor, TemplateCreate)
+{
+    {
+        SCOPED_TRACE("defaule template");
+        auto td = make_type_descriptor<>();
+
+        ASSERT_EQ(td.get_value_typestr(), "double");
+        ASSERT_EQ(td.get_index_typestr(), "int");
+    }
+    {
+        SCOPED_TRACE("specify valuetype");
+        auto td = make_type_descriptor<float>();
+
+        ASSERT_EQ(td.get_value_typestr(), "float");
+        ASSERT_EQ(td.get_index_typestr(), "int");
+    }
+    {
+        SCOPED_TRACE("specify all template");
+        auto td = make_type_descriptor<std::complex<float>, gko::int64>();
+
+        ASSERT_EQ(td.get_value_typestr(), "complex<float>");
+        ASSERT_EQ(td.get_index_typestr(), "int64");
+    }
+    {
+        SCOPED_TRACE("specify void");
+        auto td = make_type_descriptor<void, void>();
+
+        ASSERT_EQ(td.get_value_typestr(), "void");
+        ASSERT_EQ(td.get_index_typestr(), "void");
+    }
+}
+
+
+TEST(TypeDescriptor, Constructor)
+{
+    {
+        SCOPED_TRACE("defaule constructor");
+        type_descriptor td;
+
+        ASSERT_EQ(td.get_value_typestr(), "double");
+        ASSERT_EQ(td.get_index_typestr(), "int");
+    }
+    {
+        SCOPED_TRACE("specify valuetype");
+        type_descriptor td("float");
+
+        ASSERT_EQ(td.get_value_typestr(), "float");
+        ASSERT_EQ(td.get_index_typestr(), "int");
+    }
+    {
+        SCOPED_TRACE("specify all parameters");
+        type_descriptor td("void", "int64");
+
+        ASSERT_EQ(td.get_value_typestr(), "void");
+        ASSERT_EQ(td.get_index_typestr(), "int64");
+    }
+}
diff --git a/include/ginkgo/core/config/config.hpp b/include/ginkgo/core/config/config.hpp
index 74461f83314..9bbd9cbb238 100644
--- a/include/ginkgo/core/config/config.hpp
+++ b/include/ginkgo/core/config/config.hpp
@@ -14,6 +14,7 @@
 #include <ginkgo/core/base/lin_op.hpp>
 #include <ginkgo/core/base/types.hpp>
 #include <ginkgo/core/config/registry.hpp>
+#include <ginkgo/core/config/type_descriptor.hpp>
 #include <ginkgo/core/solver/solver_base.hpp>
 
 
@@ -22,30 +23,90 @@ namespace config {
 
 
 /**
- * build_from_config is the main function for file config. It can read the
- * property tree to create the desired type. `build_from_config(...).on(exec) ->
- * LinOpFactory`.
+ * parse is the main entry point to create an Ginkgo object based on
+ * some file configuration. It reads a configuration stored as a property tree
+ * and creates the desired type.
  *
- * @param config  The property tree which must include `Type` for the class base
- * and the corresponding template selection.
+ * The configuration needs to specify the resulting type by the field:
+ * ```
+ * type: "some_supported_ginkgo_type"
+ * ```
+ * The result will be a deferred_factory_parameter, which can be thought of as
+ * an intermediate step before a LinOpFactory. Providing the result an Executor
+ * through the function `.on(exec)` will then create the factory with the
+ * parameters as defined in the configuration.
+ *
+ * Given a configuration that is defined as
+ * ```
+ * type: "solver::Gmres",
+ * krylov_dim: 20,
+ * stop: [
+ *   {iteration: 10},
+ *   {residual_norm: 1e-6}
+ * ]
+ * ```
+ * then passing it to this function like this:
+ * ```c++
+ * auto gmres_factory = build_from_config(config, context);
+ * ```
+ * will create a factory for a GMRES solver, with the parameters `krylov_dim`
+ * set to 20, and a combined stopping criteria, consisting of an Iteration
+ * criteria with maximal 10 iterations, and a ResidualNorm criteria with a
+ * reduction factor of 1e-6.
+ *
+ * By default, the factory will use the value type double, and index type
+ * int32 when creating templated types. This can be changed by passing in a
+ * type_descriptor. For example:
+ * ```c++
+ * auto gmres_factory = build_from_config(config, context,
+ *                                        make_type_descriptor<float, int>());
+ * ```
+ * will lead to a GMRES solver that uses `float` as its value type.
+ * Additionally, the config can be used to set these types through the fields:
+ * ```
+ * value_type: "some_value_type"
+ * index_type: "some_index_type"
+ * ```
+ * These types take precedence over the type descriptor and they are used for
+ * every created object beginning from the config level they are defined on and
+ * every deeper nested level, until a new type is defined. So, considering the
+ * following example
+ * ```
+ * type: "solver::Ir",
+ * value_type: "float32"
+ * solver: {
+ *   type: "solver::Gmres",
+ *   preconditioner: {
+ *     type: "preconditioner::Jacobi"
+ *     value_type: "float64"
+ *   }
+ * }
+ * ```
+ * both the Ir and Gmres are using `float32` as a value type, and the
+ * Jacobi uses `float64`.
+ *
+ * @param config  The property tree which must include `Type` for the class
+ * base.
  * @param context  The registry which stores the building function map and the
- * storage for generated object.
- * @param type_descriptor  The default common type. If the ValueType or
- * IndexType is required by the class base but user does not provide it, this
- * function will take this input as the default.
+ * storage for generated objects.
+ * @param type_descriptor  The default value and index type. If any object that
+ * is created as part of this configuration has a templated type, then the value
+ * and/or index type from the descriptor will be used. Any definition of the
+ * value and/or index type within the config will take precedence over the
+ * descriptor.
  *
- * @return deferred_factory_parameter, user can get LinOpFactory after giving
- * the executor.
+ * @return a deferred_factory_parameter which creates an LinOpFactory after
+ *         `.on(exec)` is called on it.
  */
-deferred_factory_parameter<gko::LinOpFactory> build_from_config(
+deferred_factory_parameter<gko::LinOpFactory> parse(
     const pnode& config, const registry& context,
-    type_descriptor td = type_descriptor{"void", "void"});
+    const type_descriptor& td = make_type_descriptor<>());
 
 
 /**
  * Generate the configuration map.
  */
-buildfromconfig_map generate_config_map();
+configuration_map generate_config_map();
 
 
 }  // namespace config
diff --git a/include/ginkgo/core/config/registry.hpp b/include/ginkgo/core/config/registry.hpp
index 4e9abea5902..d38355311ca 100644
--- a/include/ginkgo/core/config/registry.hpp
+++ b/include/ginkgo/core/config/registry.hpp
@@ -27,61 +27,27 @@ namespace config {
 
 class registry;
 
-/**
- * type_descriptor gives the initial default type for common type in ginkgo such
- * as ValueType and IndexType. If the factory config does not specify these
- * type, the configuration will use this as the default.
- */
-class type_descriptor {
-public:
-    /**
-     * type_descriptor constructor. The correctness is checked in
-     * factory configuration. There is free function `make_type_descriptor` to
-     * create the object by template.
-     *
-     * @param value_typestr  the value type string. "void" means no default.
-     * @param index_typestr  the index type string. "void" means no default.
-     *
-     * @note there is no way to call the constructor with explicit template, so
-     * we create another free function to handle it.
-     */
-    explicit type_descriptor(std::string value_typestr = "void",
-                             std::string index_typestr = "void");
-
-    /**
-     * Get the value type string.
-     */
-    const std::string& get_value_typestr() const;
-
-    /**
-     * Get the index type string
-     */
-    const std::string& get_index_typestr() const;
-
-private:
-    std::string value_typestr_;
-    std::string index_typestr_;
-};
-
-
-template <typename ValueType = void, typename IndexType = void>
-type_descriptor make_type_descriptor();
+class type_descriptor;
 
 
-using linop_map = std::unordered_map<std::string, std::shared_ptr<LinOp>>;
-using linopfactory_map =
-    std::unordered_map<std::string, std::shared_ptr<LinOpFactory>>;
-using criterionfactory_map =
-    std::unordered_map<std::string, std::shared_ptr<stop::CriterionFactory>>;
-using buildfromconfig_map =
+using configuration_map =
     std::map<std::string,
              std::function<deferred_factory_parameter<gko::LinOpFactory>(
                  const pnode&, const registry&, type_descriptor)>>;
 
 
 /**
- * registry is the storage for file config usage. It stores the building
- * function, linop, linop_factory, criterion
+ * This class stores additional context for creating Ginkgo objects from
+ * configuration files.
+ *
+ * The context can contain user provided objects of the following types:
+ * - LinOp
+ * - LinOpFactory
+ * - CriterionFactory
+ *
+ * Additionally, users can provide mappings from a configuration (provided as
+ * a pnode) to user-defined types that are derived from one of the previous
+ * stated types.
  */
 class registry {
 private:
@@ -98,19 +64,22 @@ class registry {
     template <typename T>
     struct map_type<T, typename std::enable_if<
                            std::is_convertible<T*, LinOp*>::value>::type> {
-        using type = linop_map;
+        using type = std::unordered_map<std::string, std::shared_ptr<LinOp>>;
     };
 
     template <typename T>
     struct map_type<T, typename std::enable_if<std::is_convertible<
                            T*, LinOpFactory*>::value>::type> {
-        using type = linopfactory_map;
+        using type =
+            std::unordered_map<std::string, std::shared_ptr<LinOpFactory>>;
     };
 
     template <typename T>
     struct map_type<T, typename std::enable_if<std::is_convertible<
                            T*, stop::CriterionFactory*>::value>::type> {
-        using type = criterionfactory_map;
+        using type =
+            std::unordered_map<std::string,
+                               std::shared_ptr<stop::CriterionFactory>>;
     };
 
 public:
@@ -121,7 +90,7 @@ class registry {
      * provides `generate_config_map()` in config.hpp to provide the ginkgo
      * build map. Users can extend this map to fit their own LinOpFactory.
      */
-    registry(buildfromconfig_map build_map) : build_map_(build_map) {}
+    registry(configuration_map build_map) : build_map_(build_map) {}
 
     /**
      * insert_data stores the data with the key.
@@ -149,7 +118,7 @@ class registry {
     /**
      * get the stored build map
      */
-    const buildfromconfig_map& get_build_map() const { return build_map_; }
+    const configuration_map& get_build_map() const { return build_map_; }
 
 protected:
     /**
@@ -179,10 +148,12 @@ class registry {
     const T& get_map_impl() const;
 
 private:
-    linop_map linop_map_;
-    linopfactory_map linopfactory_map_;
-    criterionfactory_map criterionfactory_map_;
-    buildfromconfig_map build_map_;
+    std::unordered_map<std::string, std::shared_ptr<LinOp>> linop_map_;
+    std::unordered_map<std::string, std::shared_ptr<LinOpFactory>>
+        linopfactory_map_;
+    std::unordered_map<std::string, std::shared_ptr<stop::CriterionFactory>>
+        criterionfactory_map_;
+    configuration_map build_map_;
 };
 
 
diff --git a/include/ginkgo/core/config/type_descriptor.hpp b/include/ginkgo/core/config/type_descriptor.hpp
new file mode 100644
index 00000000000..7167a7650cd
--- /dev/null
+++ b/include/ginkgo/core/config/type_descriptor.hpp
@@ -0,0 +1,74 @@
+// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#ifndef GKO_PUBLIC_CORE_CONFIG_TYPE_DESCRIPTOR_HPP_
+#define GKO_PUBLIC_CORE_CONFIG_TYPE_DESCRIPTOR_HPP_
+
+
+#include <string>
+
+namespace gko {
+namespace config {
+
+
+/**
+ * This class describes the value and index types to be used when building a
+ * Ginkgo type from a configuration file.
+ *
+ * A type_descriptor is passed to the parse function defines which
+ * template parameters, in terms of value_type and/or index_type, the created
+ * object will have. For example, a CG solver created like this:
+ * ```
+ * auto cg = parse(config, context, type_descriptor("float64", "int32"));
+ * ```
+ * will have the value type `float64` and the index type `int32`. Any Ginkgo
+ * object that does not require one of these types will just ignore it. We used
+ * void type to specify no default type.
+ *
+ * If the configurations specifies one of the fields (or both):
+ * ```
+ * value_type: "some_value_type"
+ * index_type: "some_index_type"
+ * ```
+ * these types will take precedence over the type_descriptor.
+ */
+class type_descriptor {
+public:
+    /**
+     * type_descriptor constructor. There is free function
+     * `make_type_descriptor` to create the object by template.
+     *
+     * @param value_typestr  the value type string. "void" means no default.
+     * @param index_typestr  the index type string. "void" means no default.
+     *
+     * @note there is no way to call the constructor with explicit template, so
+     * we create another free function to handle it.
+     */
+    explicit type_descriptor(std::string value_typestr = "float64",
+                             std::string index_typestr = "int32");
+
+    /**
+     * Get the value type string.
+     */
+    const std::string& get_value_typestr() const;
+
+    /**
+     * Get the index type string
+     */
+    const std::string& get_index_typestr() const;
+
+private:
+    std::string value_typestr_;
+    std::string index_typestr_;
+};
+
+
+template <typename ValueType = double, typename IndexType = int>
+type_descriptor make_type_descriptor();
+
+
+}  // namespace config
+}  // namespace gko
+
+#endif  // GKO_PUBLIC_CORE_CONFIG_TYPE_DESCRIPTOR_HPP_
diff --git a/include/ginkgo/core/solver/cg.hpp b/include/ginkgo/core/solver/cg.hpp
index 5356b837477..6678d8ac618 100644
--- a/include/ginkgo/core/solver/cg.hpp
+++ b/include/ginkgo/core/solver/cg.hpp
@@ -75,9 +75,10 @@ class Cg : public EnableLinOp<Cg<ValueType>>,
     GKO_ENABLE_LIN_OP_FACTORY(Cg, parameters, Factory);
     GKO_ENABLE_BUILD_METHOD(Factory);
 
-    static parameters_type build_from_config(
-        const config::pnode& config, const config::registry& context,
-        config::type_descriptor td_for_child);
+    static parameters_type parse(const config::pnode& config,
+                                 const config::registry& context,
+                                 const config::type_descriptor& td_for_child =
+                                     config::make_type_descriptor<ValueType>());
 
 protected:
     void apply_impl(const LinOp* b, LinOp* x) const override;
diff --git a/include/ginkgo/ginkgo.hpp b/include/ginkgo/ginkgo.hpp
index 50d19865d54..f835eba9c26 100644
--- a/include/ginkgo/ginkgo.hpp
+++ b/include/ginkgo/ginkgo.hpp
@@ -56,6 +56,7 @@
 #include <ginkgo/core/config/config.hpp>
 #include <ginkgo/core/config/property_tree.hpp>
 #include <ginkgo/core/config/registry.hpp>
+#include <ginkgo/core/config/type_descriptor.hpp>
 
 #include <ginkgo/core/distributed/base.hpp>
 #include <ginkgo/core/distributed/index_map.hpp>

From 3b6ff478e18efc3eb53a9356c01a528a28df9787 Mon Sep 17 00:00:00 2001
From: "Yu-Hsiang M. Tsai" <yhmtsai@gmail.com>
Date: Tue, 30 Apr 2024 01:10:08 +0200
Subject: [PATCH 22/25] combine map together

Co-authored-by: Marcel Koch <marcel.koch@kit.edu>
---
 core/config/registry.cpp                |  51 +-----
 core/test/config/registry.cpp           |  26 +++
 include/ginkgo/core/config/config.hpp   |  12 +-
 include/ginkgo/core/config/registry.hpp | 211 +++++++++++++++---------
 4 files changed, 175 insertions(+), 125 deletions(-)

diff --git a/core/config/registry.cpp b/core/config/registry.cpp
index d816be2551a..f6aca7fc346 100644
--- a/core/config/registry.cpp
+++ b/core/config/registry.cpp
@@ -5,55 +5,22 @@
 #include <ginkgo/core/config/registry.hpp>
 
 
+#include <ginkgo/core/config/config.hpp>
+
+
 #include "core/config/config_helper.hpp"
 
 
 namespace gko {
 namespace config {
 
+registry::registry(configuration_map build_map) : build_map_(build_map) {}
 
-using linop_map = std::unordered_map<std::string, std::shared_ptr<LinOp>>;
-using linopfactory_map =
-    std::unordered_map<std::string, std::shared_ptr<LinOpFactory>>;
-using criterionfactory_map =
-    std::unordered_map<std::string, std::shared_ptr<stop::CriterionFactory>>;
-
-
-template <>
-linop_map& registry::get_map_impl<linop_map>()
-{
-    return linop_map_;
-}
-
-template <>
-linopfactory_map& registry::get_map_impl<linopfactory_map>()
-{
-    return linopfactory_map_;
-}
-
-template <>
-criterionfactory_map& registry::get_map_impl<criterionfactory_map>()
-{
-    return criterionfactory_map_;
-}
-
-template <>
-const linop_map& registry::get_map_impl<linop_map>() const
-{
-    return linop_map_;
-}
-
-template <>
-const linopfactory_map& registry::get_map_impl<linopfactory_map>() const
-{
-    return linopfactory_map_;
-}
-
-template <>
-const criterionfactory_map& registry::get_map_impl<criterionfactory_map>() const
-{
-    return criterionfactory_map_;
-}
+registry::registry(
+    std::unordered_map<std::string, detail::allowed_ptr> stored_map,
+    configuration_map build_map)
+    : stored_map_(stored_map), build_map_(build_map)
+{}
 
 
 }  // namespace config
diff --git a/core/test/config/registry.cpp b/core/test/config/registry.cpp
index 8e8c530ab4a..04dee4a8316 100644
--- a/core/test/config/registry.cpp
+++ b/core/test/config/registry.cpp
@@ -127,6 +127,32 @@ TEST_F(Registry, SearchDataWithType)
 }
 
 
+TEST_F(Registry, BuildFromConstructor)
+{
+    registry reg_obj{{{"matrix", matrix},
+                      {"solver_factory", solver_factory},
+                      {"stop_factory", stop_factory}}};
+
+    auto found_matrix = reg_obj.search_data<Matrix>("matrix");
+    auto found_solver_factory =
+        reg_obj.search_data<Solver::Factory>("solver_factory");
+    auto found_stop_factory =
+        reg_obj.search_data<Stop::Factory>("stop_factory");
+    // get correct ptrs
+    ASSERT_EQ(found_matrix, matrix);
+    ASSERT_EQ(found_solver_factory, solver_factory);
+    ASSERT_EQ(found_stop_factory, stop_factory);
+    // get correct types
+    ASSERT_TRUE(
+        (std::is_same<decltype(found_matrix), std::shared_ptr<Matrix>>::value));
+    ASSERT_TRUE(
+        (std::is_same<decltype(found_solver_factory),
+                      std::shared_ptr<typename Solver::Factory>>::value));
+    ASSERT_TRUE((std::is_same<decltype(found_stop_factory),
+                              std::shared_ptr<typename Stop::Factory>>::value));
+}
+
+
 TEST_F(Registry, ThrowIfNotFound)
 {
     ASSERT_THROW(reg.search_data<gko::LinOp>("N"), std::out_of_range);
diff --git a/include/ginkgo/core/config/config.hpp b/include/ginkgo/core/config/config.hpp
index 9bbd9cbb238..681a9182192 100644
--- a/include/ginkgo/core/config/config.hpp
+++ b/include/ginkgo/core/config/config.hpp
@@ -13,7 +13,6 @@
 
 #include <ginkgo/core/base/lin_op.hpp>
 #include <ginkgo/core/base/types.hpp>
-#include <ginkgo/core/config/registry.hpp>
 #include <ginkgo/core/config/type_descriptor.hpp>
 #include <ginkgo/core/solver/solver_base.hpp>
 
@@ -21,6 +20,17 @@
 namespace gko {
 namespace config {
 
+class registry;
+
+
+class pnode;
+
+
+using configuration_map =
+    std::map<std::string,
+             std::function<deferred_factory_parameter<gko::LinOpFactory>(
+                 const pnode&, const registry&, type_descriptor)>>;
+
 
 /**
  * parse is the main entry point to create an Ginkgo object based on
diff --git a/include/ginkgo/core/config/registry.hpp b/include/ginkgo/core/config/registry.hpp
index d38355311ca..c25132f75aa 100644
--- a/include/ginkgo/core/config/registry.hpp
+++ b/include/ginkgo/core/config/registry.hpp
@@ -14,9 +14,11 @@
 #include <utility>
 
 
+#include <ginkgo/core/base/exception_helpers.hpp>
 #include <ginkgo/core/base/lin_op.hpp>
 #include <ginkgo/core/base/types.hpp>
 #include <ginkgo/core/base/utils_helper.hpp>
+#include <ginkgo/core/config/config.hpp>
 #include <ginkgo/core/config/property_tree.hpp>
 #include <ginkgo/core/stop/criterion.hpp>
 
@@ -30,10 +32,112 @@ class registry;
 class type_descriptor;
 
 
-using configuration_map =
-    std::map<std::string,
-             std::function<deferred_factory_parameter<gko::LinOpFactory>(
-                 const pnode&, const registry&, type_descriptor)>>;
+namespace detail {
+
+
+/**
+ * base_type gives the base type according to given type.
+ *
+ * @tparam T  the type
+ */
+template <typename T, typename = void>
+struct base_type {};
+
+template <typename T>
+struct base_type<
+    T, typename std::enable_if<std::is_convertible<T*, LinOp*>::value>::type> {
+    using type = LinOp;
+};
+
+template <typename T>
+struct base_type<T, typename std::enable_if<
+                        std::is_convertible<T*, LinOpFactory*>::value>::type> {
+    using type = LinOpFactory;
+};
+
+template <typename T>
+struct base_type<T, typename std::enable_if<std::is_convertible<
+                        T*, stop::CriterionFactory*>::value>::type> {
+    using type = stop::CriterionFactory;
+};
+
+
+/**
+ * allowed_ptr is a type-erased object for LinOp/LinOpFactory/CriterionFactory
+ * shared_ptr.
+ */
+class allowed_ptr {
+public:
+    /**
+     * The constructor accept any shared pointer whose base type is LinOp,
+     * LinOpFactory, or CriterionFactory. We use template rather than
+     * constructor without template because it allows user to directly use
+     * uninitialized_list in registry constructor without wrapping allowed_ptr
+     * manually.
+     */
+    template <typename Type>
+    allowed_ptr(std::shared_ptr<Type> obj);
+
+    /**
+     * Check whether it contains the Type data
+     *
+     * @tparam Type  the checking type
+     */
+    template <typename Type>
+    bool contains() const;
+
+    /**
+     * Get the shared pointer with Type
+     *
+     * @tparam Type  the desired type
+     *
+     * @return the shared pointer of Type
+     */
+    template <typename Type>
+    std::shared_ptr<Type> get() const;
+
+private:
+    struct generic_container {
+        virtual ~generic_container() = default;
+    };
+
+    template <typename Type>
+    struct concrete_container : generic_container {
+        concrete_container(std::shared_ptr<Type> obj) : ptr{obj} {}
+
+        std::shared_ptr<Type> ptr;
+    };
+
+    std::shared_ptr<generic_container> data_;
+};
+
+
+template <typename Type>
+inline allowed_ptr::allowed_ptr(std::shared_ptr<Type> obj)
+{
+    data_ =
+        std::make_shared<concrete_container<typename base_type<Type>::type>>(
+            obj);
+}
+
+
+template <typename Type>
+inline bool allowed_ptr::contains() const
+{
+    return dynamic_cast<const concrete_container<Type>*>(data_.get());
+}
+
+
+template <typename Type>
+inline std::shared_ptr<Type> allowed_ptr::get() const
+{
+    GKO_THROW_IF_INVALID(this->template contains<Type>(),
+                         "does not hold the requested type.");
+    return dynamic_cast<concrete_container<Type>*>(data_.get())->ptr;
+}
+
+
+}  // namespace detail
 
 
 /**
@@ -50,47 +154,34 @@ using configuration_map =
  * stated types.
  */
 class registry {
-private:
+public:
     /**
-     * map_type gives the map type according to the base type of given type.
+     * registry constructor
      *
-     * @tparam T  the type
+     * @param build_map  the build map to dispatch the class base. Ginkgo
+     * provides `generate_config_map()` in config.hpp to provide the ginkgo
+     * build map. Users can extend this map to fit their own LinOpFactory.
      */
-    template <typename T, typename = void>
-    struct map_type {
-        using type = void;
-    };
-
-    template <typename T>
-    struct map_type<T, typename std::enable_if<
-                           std::is_convertible<T*, LinOp*>::value>::type> {
-        using type = std::unordered_map<std::string, std::shared_ptr<LinOp>>;
-    };
-
-    template <typename T>
-    struct map_type<T, typename std::enable_if<std::is_convertible<
-                           T*, LinOpFactory*>::value>::type> {
-        using type =
-            std::unordered_map<std::string, std::shared_ptr<LinOpFactory>>;
-    };
-
-    template <typename T>
-    struct map_type<T, typename std::enable_if<std::is_convertible<
-                           T*, stop::CriterionFactory*>::value>::type> {
-        using type =
-            std::unordered_map<std::string,
-                               std::shared_ptr<stop::CriterionFactory>>;
-    };
+    registry(configuration_map build_map = generate_config_map());
 
-public:
     /**
      * registry constructor
      *
+     * @param stored_map  the map stores the shared pointer of users' objects.
+     * It can hold any type whose base type is
+     * LinOp/LinOpFactory/CriterionFactory. For example,
+     * ```
+     * {{
+     *   {"csr", csr_shared_ptr},
+     *   {"cg", cg_shared_ptr}
+     * }}
+     * ```
      * @param build_map  the build map to dispatch the class base. Ginkgo
      * provides `generate_config_map()` in config.hpp to provide the ginkgo
      * build map. Users can extend this map to fit their own LinOpFactory.
      */
-    registry(configuration_map build_map) : build_map_(build_map) {}
+    registry(std::unordered_map<std::string, detail::allowed_ptr> stored_map,
+             configuration_map build_map = generate_config_map());
 
     /**
      * insert_data stores the data with the key.
@@ -120,39 +211,8 @@ class registry {
      */
     const configuration_map& get_build_map() const { return build_map_; }
 
-protected:
-    /**
-     * get_map gets the member map
-     *
-     * @tparam T  the type
-     *
-     * @return the map
-     */
-    template <typename T>
-    typename map_type<T>::type& get_map();
-
-    template <typename T>
-    const typename map_type<T>::type& get_map() const;
-
-    /**
-     * get_map_impl is the implementation of get_map
-     *
-     * @tparam T  the map type
-     *
-     * @return the map
-     */
-    template <typename T>
-    T& get_map_impl();
-
-    template <typename T>
-    const T& get_map_impl() const;
-
 private:
-    std::unordered_map<std::string, std::shared_ptr<LinOp>> linop_map_;
-    std::unordered_map<std::string, std::shared_ptr<LinOpFactory>>
-        linopfactory_map_;
-    std::unordered_map<std::string, std::shared_ptr<stop::CriterionFactory>>
-        criterionfactory_map_;
+    std::unordered_map<std::string, detail::allowed_ptr> stored_map_;
     configuration_map build_map_;
 };
 
@@ -160,7 +220,7 @@ class registry {
 template <typename T>
 inline bool registry::emplace(std::string key, std::shared_ptr<T> data)
 {
-    auto it = this->get_map<T>().emplace(key, data);
+    auto it = stored_map_.emplace(key, data);
     return it.second;
 }
 
@@ -168,23 +228,10 @@ inline bool registry::emplace(std::string key, std::shared_ptr<T> data)
 template <typename T>
 inline std::shared_ptr<T> registry::search_data(std::string key) const
 {
-    return gko::as<T>(this->get_map<T>().at(key));
-}
-
-
-template <typename T>
-inline typename registry::map_type<T>::type& registry::get_map()
-{
-    return this->get_map_impl<typename map_type<T>::type>();
-}
-
-template <typename T>
-inline const typename registry::map_type<T>::type& registry::get_map() const
-{
-    return this->get_map_impl<typename map_type<T>::type>();
+    return gko::as<T>(stored_map_.at(key)
+                          .template get<typename detail::base_type<T>::type>());
 }
 
-
 }  // namespace config
 }  // namespace gko
 

From 69de11acf89678750883d953cd907b5d04c7503c Mon Sep 17 00:00:00 2001
From: "Yu-Hsiang M. Tsai" <yhmtsai@gmail.com>
Date: Tue, 30 Apr 2024 18:37:37 +0200
Subject: [PATCH 23/25] rename, always contain gko map, move getter into
 protect

Co-authored-by: Marcel Koch <marcel.koch@kit.edu>
---
 core/config/config.cpp                  | 10 ++---
 core/config/config_helper.cpp           |  4 +-
 core/config/config_helper.hpp           |  6 ++-
 core/config/registry.cpp                | 28 ++++++++++---
 core/config/registry_accessor.hpp       | 41 +++++++++++++++++++
 core/config/stop_config.cpp             |  4 +-
 core/test/config/config.cpp             | 14 ++-----
 core/test/config/registry.cpp           | 53 +++++++++++++++++--------
 include/ginkgo/core/config/config.hpp   | 12 ------
 include/ginkgo/core/config/registry.hpp | 36 +++++++++++------
 10 files changed, 142 insertions(+), 66 deletions(-)
 create mode 100644 core/config/registry_accessor.hpp

diff --git a/core/config/config.cpp b/core/config/config.cpp
index 81fc51bba6b..8ff232f7af5 100644
--- a/core/config/config.cpp
+++ b/core/config/config.cpp
@@ -13,24 +13,20 @@
 
 
 #include "core/config/config_helper.hpp"
+#include "core/config/registry_accessor.hpp"
 
 
 namespace gko {
 namespace config {
 
 
-configuration_map generate_config_map()
-{
-    return {{"solver::Cg", parse<LinOpFactoryType::Cg>}};
-}
-
-
 deferred_factory_parameter<gko::LinOpFactory> parse(const pnode& config,
                                                     const registry& context,
                                                     const type_descriptor& td)
 {
     if (auto& obj = config.get("Type")) {
-        auto func = context.get_build_map().at(obj.get_string());
+        auto func = detail::registry_accessor::get_build_map(context).at(
+            obj.get_string());
         return func(config, context, td);
     }
     GKO_INVALID_STATE("Should contain Type property");
diff --git a/core/config/config_helper.cpp b/core/config/config_helper.cpp
index 6fdfaa423df..89f7589e1ee 100644
--- a/core/config/config_helper.cpp
+++ b/core/config/config_helper.cpp
@@ -11,6 +11,7 @@
 
 
 #include "core/config/config_helper.hpp"
+#include "core/config/registry_accessor.hpp"
 
 
 namespace gko {
@@ -38,7 +39,8 @@ deferred_factory_parameter<const LinOpFactory> get_factory<const LinOpFactory>(
 {
     deferred_factory_parameter<const LinOpFactory> ptr;
     if (config.get_tag() == pnode::tag_t::string) {
-        ptr = context.search_data<LinOpFactory>(config.get_string());
+        ptr = detail::registry_accessor::get_data<LinOpFactory>(
+            context, config.get_string());
     } else if (config.get_tag() == pnode::tag_t::map) {
         ptr = parse(config, context, td);
     } else {
diff --git a/core/config/config_helper.hpp b/core/config/config_helper.hpp
index 19ba64d0c28..75018a04c0e 100644
--- a/core/config/config_helper.hpp
+++ b/core/config/config_helper.hpp
@@ -19,6 +19,9 @@
 #include <ginkgo/core/stop/criterion.hpp>
 
 
+#include "core/config/registry_accessor.hpp"
+
+
 namespace gko {
 namespace config {
 
@@ -124,7 +127,8 @@ inline std::shared_ptr<T> get_stored_obj(const pnode& config,
 {
     std::shared_ptr<T> ptr;
     using T_non_const = std::remove_const_t<T>;
-    ptr = context.search_data<T_non_const>(config.get_string());
+    ptr = detail::registry_accessor::get_data<T_non_const>(context,
+                                                           config.get_string());
     GKO_THROW_IF_INVALID(ptr.get() != nullptr, "Do not get the stored data");
     return ptr;
 }
diff --git a/core/config/registry.cpp b/core/config/registry.cpp
index f6aca7fc346..1113adb93f4 100644
--- a/core/config/registry.cpp
+++ b/core/config/registry.cpp
@@ -5,6 +5,7 @@
 #include <ginkgo/core/config/registry.hpp>
 
 
+#include <ginkgo/core/base/exception_helpers.hpp>
 #include <ginkgo/core/config/config.hpp>
 
 
@@ -14,14 +15,31 @@
 namespace gko {
 namespace config {
 
-registry::registry(configuration_map build_map) : build_map_(build_map) {}
 
-registry::registry(
-    std::unordered_map<std::string, detail::allowed_ptr> stored_map,
-    configuration_map build_map)
-    : stored_map_(stored_map), build_map_(build_map)
+configuration_map generate_config_map()
+{
+    return {{"solver::Cg", parse<LinOpFactoryType::Cg>}};
+}
+
+
+registry::registry(const configuration_map& additional_map)
+    : registry({}, additional_map)
 {}
 
 
+registry::registry(
+    const std::unordered_map<std::string, detail::allowed_ptr>& stored_map,
+    const configuration_map& additional_map)
+    : stored_map_(stored_map), build_map_(generate_config_map())
+{
+    // merge additional_map into build_map_
+    for (auto& item : additional_map) {
+        auto res = build_map_.emplace(item.first, item.second);
+        GKO_THROW_IF_INVALID(res.second,
+                             "failed when adding the key " + item.first);
+    }
+}
+
+
 }  // namespace config
 }  // namespace gko
diff --git a/core/config/registry_accessor.hpp b/core/config/registry_accessor.hpp
new file mode 100644
index 00000000000..002e6245811
--- /dev/null
+++ b/core/config/registry_accessor.hpp
@@ -0,0 +1,41 @@
+// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#ifndef GKO_CORE_CONFIG_REGISTRY_ACCESSOR_HPP_
+#define GKO_CORE_CONFIG_REGISTRY_ACCESSOR_HPP_
+
+
+#include <string>
+
+
+#include <ginkgo/core/config/registry.hpp>
+
+
+namespace gko {
+namespace config {
+namespace detail {
+
+
+class registry_accessor {
+public:
+    template <typename T>
+    static inline std::shared_ptr<T> get_data(const registry& reg,
+                                              std::string key)
+    {
+        return reg.get_data<T>(key);
+    }
+
+    static inline const configuration_map& get_build_map(const registry& reg)
+    {
+        return reg.get_build_map();
+    }
+};
+
+
+}  // namespace detail
+}  // namespace config
+}  // namespace gko
+
+
+#endif  // GKO_CORE_CONFIG_REGISTRY_ACCESSOR_HPP_
diff --git a/core/config/stop_config.cpp b/core/config/stop_config.cpp
index d7279720b5f..fdfdaab8e0b 100644
--- a/core/config/stop_config.cpp
+++ b/core/config/stop_config.cpp
@@ -14,6 +14,7 @@
 
 #include "core/config/config_helper.hpp"
 #include "core/config/dispatch.hpp"
+#include "core/config/registry_accessor.hpp"
 #include "core/config/type_descriptor_helper.hpp"
 
 
@@ -129,7 +130,8 @@ get_factory<const stop::CriterionFactory>(const pnode& config,
 {
     deferred_factory_parameter<const stop::CriterionFactory> ptr;
     if (config.get_tag() == pnode::tag_t::string) {
-        return context.search_data<stop::CriterionFactory>(config.get_string());
+        return detail::registry_accessor::get_data<stop::CriterionFactory>(
+            context, config.get_string());
     } else if (config.get_tag() == pnode::tag_t::map) {
         static std::map<std::string,
                         std::function<deferred_factory_parameter<
diff --git a/core/test/config/config.cpp b/core/test/config/config.cpp
index 84af76c7b84..815ca674770 100644
--- a/core/test/config/config.cpp
+++ b/core/test/config/config.cpp
@@ -47,13 +47,9 @@ class Config : public ::testing::Test {
 };
 
 
-TEST_F(Config, GenerateMap) { ASSERT_NO_THROW(generate_config_map()); }
-
-
 TEST_F(Config, GenerateObjectWithoutDefault)
 {
-    auto config_map = generate_config_map();
-    auto reg = registry(config_map);
+    auto reg = registry();
 
     pnode p{{{"ValueType", pnode{"double"}}, {"criteria", this->stop_config}}};
     auto obj = parse<LinOpFactoryType::Cg>(p, reg).on(this->exec);
@@ -65,8 +61,7 @@ TEST_F(Config, GenerateObjectWithoutDefault)
 
 TEST_F(Config, GenerateObjectWithData)
 {
-    auto config_map = generate_config_map();
-    auto reg = registry(config_map);
+    auto reg = registry();
     reg.emplace("precond", this->mtx);
 
     pnode p{{{"generated_preconditioner", pnode{"precond"}},
@@ -86,8 +81,7 @@ TEST_F(Config, GenerateObjectWithData)
 
 TEST_F(Config, GenerateObjectWithPreconditioner)
 {
-    auto config_map = generate_config_map();
-    auto reg = registry(config_map);
+    auto reg = registry();
     auto precond_node =
         pnode{{{"Type", pnode{"solver::Cg"}}, {"criteria", this->stop_config}}};
     pnode p{{{"ValueType", pnode{"double"}},
@@ -107,7 +101,7 @@ TEST_F(Config, GenerateObjectWithPreconditioner)
 
 TEST_F(Config, GenerateObjectWithCustomBuild)
 {
-    auto config_map = generate_config_map();
+    configuration_map config_map;
 
     config_map["Custom"] = [](const pnode& config, const registry& context,
                               const type_descriptor& td_for_child) {
diff --git a/core/test/config/registry.cpp b/core/test/config/registry.cpp
index 04dee4a8316..78137fd95bf 100644
--- a/core/test/config/registry.cpp
+++ b/core/test/config/registry.cpp
@@ -22,6 +22,7 @@
 
 
 #include "core/config/config_helper.hpp"
+#include "core/config/registry_accessor.hpp"
 #include "core/test/utils.hpp"
 
 
@@ -80,11 +81,14 @@ TEST_F(Registry, SearchData)
     reg.emplace("solver_factory", solver_factory);
     reg.emplace("stop_factory", stop_factory);
 
-    auto found_matrix = reg.search_data<gko::LinOp>("matrix");
+    auto found_matrix =
+        detail::registry_accessor::get_data<gko::LinOp>(reg, "matrix");
     auto found_solver_factory =
-        reg.search_data<gko::LinOpFactory>("solver_factory");
+        detail::registry_accessor::get_data<gko::LinOpFactory>(
+            reg, "solver_factory");
     auto found_stop_factory =
-        reg.search_data<gko::stop::CriterionFactory>("stop_factory");
+        detail::registry_accessor::get_data<gko::stop::CriterionFactory>(
+            reg, "stop_factory");
 
     // get correct ptrs
     ASSERT_EQ(found_matrix, matrix);
@@ -107,10 +111,13 @@ TEST_F(Registry, SearchDataWithType)
     reg.emplace("solver_factory", solver_factory);
     reg.emplace("stop_factory", stop_factory);
 
-    auto found_matrix = reg.search_data<Matrix>("matrix");
+    auto found_matrix =
+        detail::registry_accessor::get_data<Matrix>(reg, "matrix");
     auto found_solver_factory =
-        reg.search_data<Solver::Factory>("solver_factory");
-    auto found_stop_factory = reg.search_data<Stop::Factory>("stop_factory");
+        detail::registry_accessor::get_data<Solver::Factory>(reg,
+                                                             "solver_factory");
+    auto found_stop_factory =
+        detail::registry_accessor::get_data<Stop::Factory>(reg, "stop_factory");
 
     // get correct ptrs
     ASSERT_EQ(found_matrix, matrix);
@@ -133,11 +140,14 @@ TEST_F(Registry, BuildFromConstructor)
                       {"solver_factory", solver_factory},
                       {"stop_factory", stop_factory}}};
 
-    auto found_matrix = reg_obj.search_data<Matrix>("matrix");
+    auto found_matrix =
+        detail::registry_accessor::get_data<Matrix>(reg_obj, "matrix");
     auto found_solver_factory =
-        reg_obj.search_data<Solver::Factory>("solver_factory");
+        detail::registry_accessor::get_data<Solver::Factory>(reg_obj,
+                                                             "solver_factory");
     auto found_stop_factory =
-        reg_obj.search_data<Stop::Factory>("stop_factory");
+        detail::registry_accessor::get_data<Stop::Factory>(reg_obj,
+                                                           "stop_factory");
     // get correct ptrs
     ASSERT_EQ(found_matrix, matrix);
     ASSERT_EQ(found_solver_factory, solver_factory);
@@ -155,10 +165,15 @@ TEST_F(Registry, BuildFromConstructor)
 
 TEST_F(Registry, ThrowIfNotFound)
 {
-    ASSERT_THROW(reg.search_data<gko::LinOp>("N"), std::out_of_range);
-    ASSERT_THROW(reg.search_data<gko::LinOpFactory>("N"), std::out_of_range);
-    ASSERT_THROW(reg.search_data<gko::stop::CriterionFactory>("N"),
+    ASSERT_THROW(detail::registry_accessor::get_data<gko::LinOp>(reg, "N"),
                  std::out_of_range);
+    ASSERT_THROW(
+        detail::registry_accessor::get_data<gko::LinOpFactory>(reg, "N"),
+        std::out_of_range);
+    ASSERT_THROW(
+        detail::registry_accessor::get_data<gko::stop::CriterionFactory>(reg,
+                                                                         "N"),
+        std::out_of_range);
 }
 
 
@@ -168,12 +183,16 @@ TEST_F(Registry, ThrowWithWrongType)
     reg.emplace("solver_factory", solver_factory);
     reg.emplace("stop_factory", stop_factory);
 
-    ASSERT_THROW(reg.search_data<gko::matrix::Dense<double>>("matrix"),
-                 gko::NotSupported);
     ASSERT_THROW(
-        reg.search_data<gko::solver::Cg<double>::Factory>("solver_factory"),
+        detail::registry_accessor::get_data<gko::matrix::Dense<double>>(
+            reg, "matrix"),
+        gko::NotSupported);
+    ASSERT_THROW(
+        detail::registry_accessor::get_data<gko::solver::Cg<double>::Factory>(
+            reg, "solver_factory"),
         gko::NotSupported);
-    ASSERT_THROW(reg.search_data<gko::stop::Time::Factory>("stop_factory"),
+    ASSERT_THROW(detail::registry_accessor::get_data<gko::stop::Time::Factory>(
+                     reg, "stop_factory"),
                  gko::NotSupported);
 }
 
@@ -181,7 +200,7 @@ TEST_F(Registry, ThrowWithWrongType)
 TEST_F(Registry, GetBuildMap)
 {
     auto factory =
-        reg.get_build_map()
+        detail::registry_accessor::get_build_map(reg)
             .at("func")(pnode{"unused"}, reg, type_descriptor{"void", "void"})
             .on(exec);
 
diff --git a/include/ginkgo/core/config/config.hpp b/include/ginkgo/core/config/config.hpp
index 681a9182192..04d1528f637 100644
--- a/include/ginkgo/core/config/config.hpp
+++ b/include/ginkgo/core/config/config.hpp
@@ -26,12 +26,6 @@ class registry;
 class pnode;
 
 
-using configuration_map =
-    std::map<std::string,
-             std::function<deferred_factory_parameter<gko::LinOpFactory>(
-                 const pnode&, const registry&, type_descriptor)>>;
-
-
 /**
  * parse is the main entry point to create an Ginkgo object based on
  * some file configuration. It reads a configuration stored as a property tree
@@ -113,12 +107,6 @@ deferred_factory_parameter<gko::LinOpFactory> parse(
     const type_descriptor& td = make_type_descriptor<>());
 
 
-/**
- * Generate the configuration map.
- */
-configuration_map generate_config_map();
-
-
 }  // namespace config
 }  // namespace gko
 
diff --git a/include/ginkgo/core/config/registry.hpp b/include/ginkgo/core/config/registry.hpp
index c25132f75aa..8a4958bd64a 100644
--- a/include/ginkgo/core/config/registry.hpp
+++ b/include/ginkgo/core/config/registry.hpp
@@ -18,7 +18,6 @@
 #include <ginkgo/core/base/lin_op.hpp>
 #include <ginkgo/core/base/types.hpp>
 #include <ginkgo/core/base/utils_helper.hpp>
-#include <ginkgo/core/config/config.hpp>
 #include <ginkgo/core/config/property_tree.hpp>
 #include <ginkgo/core/stop/criterion.hpp>
 
@@ -31,10 +30,18 @@ class registry;
 
 class type_descriptor;
 
+using configuration_map =
+    std::map<std::string,
+             std::function<deferred_factory_parameter<gko::LinOpFactory>(
+                 const pnode&, const registry&, type_descriptor)>>;
+
 
 namespace detail {
 
 
+class registry_accessor;
+
+
 /**
  * base_type gives the base type according to given type.
  *
@@ -150,23 +157,26 @@ inline std::shared_ptr<Type> allowed_ptr::get() const
  * - CriterionFactory
  *
  * Additionally, users can provide mappings from a configuration (provided as
- * a pnode) to user-defined types that are derived from one of the previous
- * stated types.
+ * a pnode) to user-defined types that are derived from LinOpFactory
  */
 class registry {
 public:
+    friend class detail::registry_accessor;
+
+
     /**
      * registry constructor
      *
-     * @param build_map  the build map to dispatch the class base. Ginkgo
-     * provides `generate_config_map()` in config.hpp to provide the ginkgo
-     * build map. Users can extend this map to fit their own LinOpFactory.
+     * @param additional_map  the additional map to dispatch the class base.
+     * Users can extend this map to fit their own LinOpFactory.
      */
-    registry(configuration_map build_map = generate_config_map());
+    registry(const configuration_map& additional_map = {});
 
     /**
      * registry constructor
      *
+     * @param additional_map  the additional map to dispatch the class base.
+     * Users can extend this map to fit their own LinOpFactory.
      * @param stored_map  the map stores the shared pointer of users' objects.
      * It can hold any type whose base type is
      * LinOp/LinOpFactory/CriterionFactory. For example,
@@ -180,8 +190,9 @@ class registry {
      * provides `generate_config_map()` in config.hpp to provide the ginkgo
      * build map. Users can extend this map to fit their own LinOpFactory.
      */
-    registry(std::unordered_map<std::string, detail::allowed_ptr> stored_map,
-             configuration_map build_map = generate_config_map());
+    registry(
+        const std::unordered_map<std::string, detail::allowed_ptr>& stored_map,
+        const configuration_map& additional_map = {});
 
     /**
      * insert_data stores the data with the key.
@@ -194,8 +205,9 @@ class registry {
     template <typename T>
     bool emplace(std::string key, std::shared_ptr<T> data);
 
+protected:
     /**
-     * search_data searches the key on the corresponding map.
+     * get_data searches the key on the corresponding map.
      *
      * @tparam T  the type
      *
@@ -204,7 +216,7 @@ class registry {
      * @return the shared pointer of the object
      */
     template <typename T>
-    std::shared_ptr<T> search_data(std::string key) const;
+    std::shared_ptr<T> get_data(std::string key) const;
 
     /**
      * get the stored build map
@@ -226,7 +238,7 @@ inline bool registry::emplace(std::string key, std::shared_ptr<T> data)
 
 
 template <typename T>
-inline std::shared_ptr<T> registry::search_data(std::string key) const
+inline std::shared_ptr<T> registry::get_data(std::string key) const
 {
     return gko::as<T>(stored_map_.at(key)
                           .template get<typename detail::base_type<T>::type>());

From 5412de5a2532d549b519ab70e57db19c7f4112cb Mon Sep 17 00:00:00 2001
From: "Yu-Hsiang M. Tsai" <yhmtsai@gmail.com>
Date: Wed, 8 May 2024 21:27:40 +0200
Subject: [PATCH 24/25] add general intro, use snake_case, and fixed-width
 notation

Co-authored-by: Marcel Koch <marcel.koch@kit.edu>
---
 core/config/config.cpp                        |  4 +-
 core/config/config_helper.cpp                 | 15 ----
 core/config/config_helper.hpp                 | 83 ++++++-------------
 core/config/dispatch.hpp                      |  4 +
 core/config/stop_config.cpp                   | 10 +--
 core/config/type_descriptor.cpp               | 15 ++++
 core/config/type_descriptor_helper.hpp        | 10 +--
 core/test/config/config.cpp                   | 19 +++--
 core/test/config/type_descriptor.cpp          | 24 +++---
 include/ginkgo/core/config/config.hpp         | 70 +++++++++++-----
 include/ginkgo/core/config/property_tree.hpp  |  2 +-
 include/ginkgo/core/config/registry.hpp       | 18 ++--
 .../ginkgo/core/config/type_descriptor.hpp    |  9 +-
 13 files changed, 146 insertions(+), 137 deletions(-)

diff --git a/core/config/config.cpp b/core/config/config.cpp
index 8ff232f7af5..8c97c0038ed 100644
--- a/core/config/config.cpp
+++ b/core/config/config.cpp
@@ -24,12 +24,12 @@ deferred_factory_parameter<gko::LinOpFactory> parse(const pnode& config,
                                                     const registry& context,
                                                     const type_descriptor& td)
 {
-    if (auto& obj = config.get("Type")) {
+    if (auto& obj = config.get("type")) {
         auto func = detail::registry_accessor::get_build_map(context).at(
             obj.get_string());
         return func(config, context, td);
     }
-    GKO_INVALID_STATE("Should contain Type property");
+    GKO_INVALID_STATE("Should contain type property");
 }
 
 
diff --git a/core/config/config_helper.cpp b/core/config/config_helper.cpp
index 89f7589e1ee..4423080866c 100644
--- a/core/config/config_helper.cpp
+++ b/core/config/config_helper.cpp
@@ -18,21 +18,6 @@ namespace gko {
 namespace config {
 
 
-type_descriptor update_type(const pnode& config, const type_descriptor& td)
-{
-    auto value_typestr = td.get_value_typestr();
-    auto index_typestr = td.get_index_typestr();
-
-    if (auto& obj = config.get("ValueType")) {
-        value_typestr = obj.get_string();
-    }
-    if (auto& obj = config.get("IndexType")) {
-        index_typestr = obj.get_string();
-    }
-    return type_descriptor{value_typestr, index_typestr};
-}
-
-
 template <>
 deferred_factory_parameter<const LinOpFactory> get_factory<const LinOpFactory>(
     const pnode& config, const registry& context, const type_descriptor& td)
diff --git a/core/config/config_helper.hpp b/core/config/config_helper.hpp
index 75018a04c0e..19aadda71e7 100644
--- a/core/config/config_helper.hpp
+++ b/core/config/config_helper.hpp
@@ -27,7 +27,7 @@ namespace config {
 
 
 /**
- * LinOpFactoryType enum is to avoid forward declartion, linopfactory header,
+ * LinOpFactoryType enum is to avoid forward declaration, linopfactory header,
  * two template versions of parse
  */
 enum class LinOpFactoryType : int { Cg = 0 };
@@ -42,19 +42,21 @@ deferred_factory_parameter<gko::LinOpFactory> parse(
     const pnode& config, const registry& context,
     const type_descriptor& td = make_type_descriptor<>());
 
-/**
- * This function updates the default type setting from current config. Any type
- * that is not specified in the config will fall back to the type stored in the
- * current type_descriptor.
- */
-type_descriptor update_type(const pnode& config, const type_descriptor& td);
 
 /**
  * get_stored_obj searches the object pointer stored in the registry by string
  */
 template <typename T>
 inline std::shared_ptr<T> get_stored_obj(const pnode& config,
-                                         const registry& context);
+                                         const registry& context)
+{
+    std::shared_ptr<T> ptr;
+    using T_non_const = std::remove_const_t<T>;
+    ptr = detail::registry_accessor::get_data<T_non_const>(context,
+                                                           config.get_string());
+    GKO_THROW_IF_INVALID(ptr.get() != nullptr, "Do not get the stored data");
+    return ptr;
+}
 
 
 /**
@@ -85,55 +87,6 @@ get_factory<const stop::CriterionFactory>(const pnode& config,
 /**
  * get_factory_vector will gives a vector of factory by calling get_factory.
  */
-template <typename T>
-inline std::vector<deferred_factory_parameter<T>> get_factory_vector(
-    const pnode& config, const registry& context, const type_descriptor& td);
-
-
-/**
- * get_value gets the corresponding type value from config.
- *
- * This is specialization for integral type
- */
-template <typename IndexType>
-inline
-    typename std::enable_if<std::is_integral<IndexType>::value, IndexType>::type
-    get_value(const pnode& config);
-
-/**
- * get_value gets the corresponding type value from config.
- *
- * This is specialization for floating point type
- */
-template <typename ValueType>
-inline typename std::enable_if<std::is_floating_point<ValueType>::value,
-                               ValueType>::type
-get_value(const pnode& config);
-
-/**
- * get_value gets the corresponding type value from config.
- *
- * This is specialization for complex type
- */
-template <typename ValueType>
-inline typename std::enable_if<gko::is_complex_s<ValueType>::value,
-                               ValueType>::type
-get_value(const pnode& config);
-
-
-template <typename T>
-inline std::shared_ptr<T> get_stored_obj(const pnode& config,
-                                         const registry& context)
-{
-    std::shared_ptr<T> ptr;
-    using T_non_const = std::remove_const_t<T>;
-    ptr = detail::registry_accessor::get_data<T_non_const>(context,
-                                                           config.get_string());
-    GKO_THROW_IF_INVALID(ptr.get() != nullptr, "Do not get the stored data");
-    return ptr;
-}
-
-
 template <typename T>
 inline std::vector<deferred_factory_parameter<T>> get_factory_vector(
     const pnode& config, const registry& context, const type_descriptor& td)
@@ -152,6 +105,11 @@ inline std::vector<deferred_factory_parameter<T>> get_factory_vector(
 }
 
 
+/**
+ * get_value gets the corresponding type value from config.
+ *
+ * This is specialization for integral type
+ */
 template <typename IndexType>
 inline
     typename std::enable_if<std::is_integral<IndexType>::value, IndexType>::type
@@ -165,6 +123,12 @@ inline
     return static_cast<IndexType>(val);
 }
 
+
+/**
+ * get_value gets the corresponding type value from config.
+ *
+ * This is specialization for floating point type
+ */
 template <typename ValueType>
 inline typename std::enable_if<std::is_floating_point<ValueType>::value,
                                ValueType>::type
@@ -179,6 +143,11 @@ get_value(const pnode& config)
     return static_cast<ValueType>(val);
 }
 
+/**
+ * get_value gets the corresponding type value from config.
+ *
+ * This is specialization for complex type
+ */
 template <typename ValueType>
 inline typename std::enable_if<gko::is_complex_s<ValueType>::value,
                                ValueType>::type
diff --git a/core/config/dispatch.hpp b/core/config/dispatch.hpp
index 25b7af425c0..c765150f72a 100644
--- a/core/config/dispatch.hpp
+++ b/core/config/dispatch.hpp
@@ -76,6 +76,10 @@ deferred_factory_parameter<ReturnType> dispatch(const pnode& config,
 }
 
 /**
+ * This function is to dispatch the type from runtime parameter.
+ * The concrete class need to have static member function
+ * `parse(pnode, registry, type_descriptor)`
+ *
  * @param config  the configuration
  * @param context  the registry context
  * @param td  the default type descriptor
diff --git a/core/config/stop_config.cpp b/core/config/stop_config.cpp
index fdfdaab8e0b..55670377b27 100644
--- a/core/config/stop_config.cpp
+++ b/core/config/stop_config.cpp
@@ -138,11 +138,11 @@ get_factory<const stop::CriterionFactory>(const pnode& config,
                             gko::stop::CriterionFactory>(
                             const pnode&, const registry&, type_descriptor)>>
             criterion_map{
-                {{"Time", configure_time},
-                 {"Iteration", configure_iter},
-                 {"ResidualNorm", configure_residual},
-                 {"ImplicitResidualNorm", configure_implicit_residual}}};
-        return criterion_map.at(config.get("Type").get_string())(config,
+                {{"stop::Time", configure_time},
+                 {"stop::Iteration", configure_iter},
+                 {"stop::ResidualNorm", configure_residual},
+                 {"stop::ImplicitResidualNorm", configure_implicit_residual}}};
+        return criterion_map.at(config.get("type").get_string())(config,
                                                                  context, td);
     }
     GKO_THROW_IF_INVALID(!ptr.is_empty(), "Parse get nullptr in the end");
diff --git a/core/config/type_descriptor.cpp b/core/config/type_descriptor.cpp
index 0c4bdb475b6..de44d19700c 100644
--- a/core/config/type_descriptor.cpp
+++ b/core/config/type_descriptor.cpp
@@ -12,6 +12,21 @@ namespace gko {
 namespace config {
 
 
+type_descriptor update_type(const pnode& config, const type_descriptor& td)
+{
+    auto value_typestr = td.get_value_typestr();
+    auto index_typestr = td.get_index_typestr();
+
+    if (auto& obj = config.get("value_type")) {
+        value_typestr = obj.get_string();
+    }
+    if (auto& obj = config.get("index_type")) {
+        index_typestr = obj.get_string();
+    }
+    return type_descriptor{value_typestr, index_typestr};
+}
+
+
 template <typename ValueType, typename IndexType>
 type_descriptor make_type_descriptor()
 {
diff --git a/core/config/type_descriptor_helper.hpp b/core/config/type_descriptor_helper.hpp
index 261250ab9ed..1a4ca1ac613 100644
--- a/core/config/type_descriptor_helper.hpp
+++ b/core/config/type_descriptor_helper.hpp
@@ -42,11 +42,11 @@ struct type_string {};
     }
 
 TYPE_STRING_OVERLOAD(void, "void");
-TYPE_STRING_OVERLOAD(double, "double");
-TYPE_STRING_OVERLOAD(float, "float");
-TYPE_STRING_OVERLOAD(std::complex<double>, "complex<double>");
-TYPE_STRING_OVERLOAD(std::complex<float>, "complex<float>");
-TYPE_STRING_OVERLOAD(int32, "int");
+TYPE_STRING_OVERLOAD(double, "float64");
+TYPE_STRING_OVERLOAD(float, "float32");
+TYPE_STRING_OVERLOAD(std::complex<double>, "complex<float64>");
+TYPE_STRING_OVERLOAD(std::complex<float>, "complex<float32>");
+TYPE_STRING_OVERLOAD(int32, "int32");
 TYPE_STRING_OVERLOAD(int64, "int64");
 
 
diff --git a/core/test/config/config.cpp b/core/test/config/config.cpp
index 815ca674770..a791667b8e2 100644
--- a/core/test/config/config.cpp
+++ b/core/test/config/config.cpp
@@ -38,7 +38,8 @@ class Config : public ::testing::Test {
         : exec(gko::ReferenceExecutor::create()),
           mtx(gko::initialize<Mtx>(
               {{2, -1.0, 0.0}, {-1.0, 2, -1.0}, {0.0, -1.0, 2}}, exec)),
-          stop_config({{"Type", pnode{"Iteration"}}, {"max_iters", pnode{1}}})
+          stop_config(
+              {{"type", pnode{"stop::Iteration"}}, {"max_iters", pnode{1}}})
     {}
 
     std::shared_ptr<const gko::Executor> exec;
@@ -51,7 +52,8 @@ TEST_F(Config, GenerateObjectWithoutDefault)
 {
     auto reg = registry();
 
-    pnode p{{{"ValueType", pnode{"double"}}, {"criteria", this->stop_config}}};
+    pnode p{
+        {{"value_type", pnode{"float64"}}, {"criteria", this->stop_config}}};
     auto obj = parse<LinOpFactoryType::Cg>(p, reg).on(this->exec);
 
     ASSERT_NE(dynamic_cast<const gko::solver::Cg<double>::Factory*>(obj.get()),
@@ -67,7 +69,7 @@ TEST_F(Config, GenerateObjectWithData)
     pnode p{{{"generated_preconditioner", pnode{"precond"}},
              {"criteria", this->stop_config}}};
     auto obj =
-        parse<LinOpFactoryType::Cg>(p, reg, type_descriptor{"float", "void"})
+        parse<LinOpFactoryType::Cg>(p, reg, type_descriptor{"float32", "void"})
             .on(this->exec);
 
     ASSERT_NE(dynamic_cast<gko::solver::Cg<float>::Factory*>(obj.get()),
@@ -83,8 +85,8 @@ TEST_F(Config, GenerateObjectWithPreconditioner)
 {
     auto reg = registry();
     auto precond_node =
-        pnode{{{"Type", pnode{"solver::Cg"}}, {"criteria", this->stop_config}}};
-    pnode p{{{"ValueType", pnode{"double"}},
+        pnode{{{"type", pnode{"solver::Cg"}}, {"criteria", this->stop_config}}};
+    pnode p{{{"value_type", pnode{"float64"}},
              {"criteria", this->stop_config},
              {"preconditioner", precond_node}}};
 
@@ -102,7 +104,6 @@ TEST_F(Config, GenerateObjectWithPreconditioner)
 TEST_F(Config, GenerateObjectWithCustomBuild)
 {
     configuration_map config_map;
-
     config_map["Custom"] = [](const pnode& config, const registry& context,
                               const type_descriptor& td_for_child) {
         return gko::solver::Bicg<double>::build().with_criteria(
@@ -110,13 +111,13 @@ TEST_F(Config, GenerateObjectWithCustomBuild)
     };
     auto reg = registry(config_map);
     auto precond_node =
-        pnode{std::map<std::string, pnode>{{"Type", pnode{"Custom"}}}};
-    pnode p{{{"ValueType", pnode{"double"}},
+        pnode{std::map<std::string, pnode>{{"type", pnode{"Custom"}}}};
+    pnode p{{{"value_type", pnode{"float64"}},
              {"criteria", this->stop_config},
              {"preconditioner", precond_node}}};
 
     auto obj =
-        parse<LinOpFactoryType::Cg>(p, reg, type_descriptor{"double", "void"})
+        parse<LinOpFactoryType::Cg>(p, reg, type_descriptor{"float64", "void"})
             .on(this->exec);
 
     ASSERT_NE(dynamic_cast<gko::solver::Cg<double>::Factory*>(obj.get()),
diff --git a/core/test/config/type_descriptor.cpp b/core/test/config/type_descriptor.cpp
index d45cb47e730..a387ebe44b7 100644
--- a/core/test/config/type_descriptor.cpp
+++ b/core/test/config/type_descriptor.cpp
@@ -18,24 +18,24 @@ using namespace gko::config;
 TEST(TypeDescriptor, TemplateCreate)
 {
     {
-        SCOPED_TRACE("defaule template");
+        SCOPED_TRACE("default template");
         auto td = make_type_descriptor<>();
 
-        ASSERT_EQ(td.get_value_typestr(), "double");
-        ASSERT_EQ(td.get_index_typestr(), "int");
+        ASSERT_EQ(td.get_value_typestr(), "float64");
+        ASSERT_EQ(td.get_index_typestr(), "int32");
     }
     {
         SCOPED_TRACE("specify valuetype");
         auto td = make_type_descriptor<float>();
 
-        ASSERT_EQ(td.get_value_typestr(), "float");
-        ASSERT_EQ(td.get_index_typestr(), "int");
+        ASSERT_EQ(td.get_value_typestr(), "float32");
+        ASSERT_EQ(td.get_index_typestr(), "int32");
     }
     {
         SCOPED_TRACE("specify all template");
         auto td = make_type_descriptor<std::complex<float>, gko::int64>();
 
-        ASSERT_EQ(td.get_value_typestr(), "complex<float>");
+        ASSERT_EQ(td.get_value_typestr(), "complex<float32>");
         ASSERT_EQ(td.get_index_typestr(), "int64");
     }
     {
@@ -51,18 +51,18 @@ TEST(TypeDescriptor, TemplateCreate)
 TEST(TypeDescriptor, Constructor)
 {
     {
-        SCOPED_TRACE("defaule constructor");
+        SCOPED_TRACE("default constructor");
         type_descriptor td;
 
-        ASSERT_EQ(td.get_value_typestr(), "double");
-        ASSERT_EQ(td.get_index_typestr(), "int");
+        ASSERT_EQ(td.get_value_typestr(), "float64");
+        ASSERT_EQ(td.get_index_typestr(), "int32");
     }
     {
         SCOPED_TRACE("specify valuetype");
-        type_descriptor td("float");
+        type_descriptor td("float32");
 
-        ASSERT_EQ(td.get_value_typestr(), "float");
-        ASSERT_EQ(td.get_index_typestr(), "int");
+        ASSERT_EQ(td.get_value_typestr(), "float32");
+        ASSERT_EQ(td.get_index_typestr(), "int32");
     }
     {
         SCOPED_TRACE("specify all parameters");
diff --git a/include/ginkgo/core/config/config.hpp b/include/ginkgo/core/config/config.hpp
index 04d1528f637..376ee14f7c7 100644
--- a/include/ginkgo/core/config/config.hpp
+++ b/include/ginkgo/core/config/config.hpp
@@ -31,27 +31,53 @@ class pnode;
  * some file configuration. It reads a configuration stored as a property tree
  * and creates the desired type.
  *
- * The configuration needs to specify the resulting type by the field:
+ * General rules for configuration
+ * 1. all parameter and template usage are according to the class directly. It
+ *    has the same behavior as the class like default setting without specifying
+ *    anything. When the class factory parameters allows `with_<key>(value)`,
+ *    the file configuration will allow `"<key>": value`
+ * 2. all key will use snake_case including template. For example, ValueType ->
+ *    value_type
+ * 3. If the value is not bool, integer, or floating point, we will use string
+ *    to represent everything. For example, we will use string to select the
+ *    enum value. `"baseline": "absolute"` will select the absolute baseline in
+ *    ResidualNorm critrion
+ * 4. `"type"` is the new key to select the class without template type. We also
+ *    prepend the namespace except for gko. For example, we use "solver::Cg" for
+ *    Cg solver. Note. the template type is given by the another entry or from
+ *    the type_descriptor.
+ * 5. the data type uses fixed-width representation
+ *    void, int32, int64, float32, float64, complex<float32>, complex<float64>
+ * 6. We use [real, imag] to represent complex value. If it only contains one
+ *    value or without [], we will treat it as the complex number with imaginary
+ *    part = 0.
+ * 7. In many cases, the parameter allows vector input and we handle it by array
+ *    of property tree. If the array only contains one object, users can
+ *    directly provide the object without putting it into an array.
+ *    `"criteria": [{...}]` and `"criteria": {...}` are the same.
+ *
+ * The configuration needs
+ * to specify the resulting type by the field:
  * ```
- * type: "some_supported_ginkgo_type"
+ * "type": "some_supported_ginkgo_type"
  * ```
- * The result will be a deferred_factory_parameter, which can be thought of as
- * an intermediate step before a LinOpFactory. Providing the result an Executor
- * through the function `.on(exec)` will then create the factory with the
- * parameters as defined in the configuration.
+ * The result will be a deferred_factory_parameter,
+ * which can be thought of as an intermediate step before a LinOpFactory.
+ * Providing the result an Executor through the function `.on(exec)` will then
+ * create the factory with the parameters as defined in the configuration.
  *
  * Given a configuration that is defined as
  * ```
- * type: "solver::Gmres",
- * krylov_dim: 20,
- * stop: [
- *   {iteration: 10},
- *   {residual_norm: 1e-6}
+ * "type": "solver::Gmres",
+ * "krylov_dim": 20,
+ * "criteria": [
+ *   {"type": "stop::Iteration", "max_iters": 10},
+ *   {"type": "stop::ResidualNorm", "reduction_factor": 1e-6}
  * ]
  * ```
  * then passing it to this function like this:
  * ```c++
- * auto gmres_factory = build_from_config(config, context);
+ * auto gmres_factory = parse(config, context);
  * ```
  * will create a factory for a GMRES solver, with the parameters `krylov_dim`
  * set to 20, and a combined stopping criteria, consisting of an Iteration
@@ -62,8 +88,9 @@ class pnode;
  * int32 when creating templated types. This can be changed by passing in a
  * type_descriptor. For example:
  * ```c++
- * auto gmres_factory = build_from_config(config, context,
- *                                        make_type_descriptor<float, int>());
+ * auto gmres_factory =
+ *     parse(config, context,
+ *           make_type_descriptor<float32, int32>());
  * ```
  * will lead to a GMRES solver that uses `float` as its value type.
  * Additionally, the config can be used to set these types through the fields:
@@ -89,15 +116,16 @@ class pnode;
  * both the Ir and Gmres are using `float32` as a value type, and the
  * Jacobi uses `float64`.
  *
- * @param config  The property tree which must include `Type` for the class
- * base.
+ * @param config  The property tree which must include `type` for the class
+ *                base.
  * @param context  The registry which stores the building function map and the
- * storage for generated objects.
+ *                 storage for generated objects.
  * @param type_descriptor  The default value and index type. If any object that
- * is created as part of this configuration has a templated type, then the value
- * and/or index type from the descriptor will be used. Any definition of the
- * value and/or index type within the config will take precedence over the
- * descriptor.
+ *                         is created as part of this configuration has a
+ *                         templated type, then the value and/or index type from
+ *                         the descriptor will be used. Any definition of the
+ *                         value and/or index type within the config will take
+ *                         precedence over the descriptor.
  *
  * @return a deferred_factory_parameter which creates an LinOpFactory after
  *         `.on(exec)` is called on it.
diff --git a/include/ginkgo/core/config/property_tree.hpp b/include/ginkgo/core/config/property_tree.hpp
index e1ef2f00dfb..2ddf42f5a27 100644
--- a/include/ginkgo/core/config/property_tree.hpp
+++ b/include/ginkgo/core/config/property_tree.hpp
@@ -25,7 +25,7 @@ namespace config {
  * A pnode can either be empty, hold a value (a string, integer, real, or bool),
  * contain an array of pnode., or contain a mapping between strings and pnodes.
  */
-class pnode {
+class pnode final {
 public:
     using key_type = std::string;
     using map_type = std::map<key_type, pnode>;
diff --git a/include/ginkgo/core/config/registry.hpp b/include/ginkgo/core/config/registry.hpp
index 8a4958bd64a..b4c1658c037 100644
--- a/include/ginkgo/core/config/registry.hpp
+++ b/include/ginkgo/core/config/registry.hpp
@@ -159,7 +159,7 @@ inline std::shared_ptr<Type> allowed_ptr::get() const
  * Additionally, users can provide mappings from a configuration (provided as
  * a pnode) to user-defined types that are derived from LinOpFactory
  */
-class registry {
+class registry final {
 public:
     friend class detail::registry_accessor;
 
@@ -168,27 +168,27 @@ class registry {
      * registry constructor
      *
      * @param additional_map  the additional map to dispatch the class base.
-     * Users can extend this map to fit their own LinOpFactory.
+     *                        Users can extend map to fit their own
+     *                        LinOpFactory.
      */
     registry(const configuration_map& additional_map = {});
 
     /**
      * registry constructor
      *
-     * @param additional_map  the additional map to dispatch the class base.
-     * Users can extend this map to fit their own LinOpFactory.
      * @param stored_map  the map stores the shared pointer of users' objects.
-     * It can hold any type whose base type is
-     * LinOp/LinOpFactory/CriterionFactory. For example,
+     *                    It can hold any type whose base type is
+     *                    LinOp/LinOpFactory/CriterionFactory.
+     * For example,
      * ```
      * {{
      *   {"csr", csr_shared_ptr},
      *   {"cg", cg_shared_ptr}
      * }}
      * ```
-     * @param build_map  the build map to dispatch the class base. Ginkgo
-     * provides `generate_config_map()` in config.hpp to provide the ginkgo
-     * build map. Users can extend this map to fit their own LinOpFactory.
+     * @param additional_map  the additional map to dispatch the class base.
+     *                        Users can extend map to fit their own
+     *                        LinOpFactory.
      */
     registry(
         const std::unordered_map<std::string, detail::allowed_ptr>& stored_map,
diff --git a/include/ginkgo/core/config/type_descriptor.hpp b/include/ginkgo/core/config/type_descriptor.hpp
index 7167a7650cd..3a05ee33aac 100644
--- a/include/ginkgo/core/config/type_descriptor.hpp
+++ b/include/ginkgo/core/config/type_descriptor.hpp
@@ -33,7 +33,7 @@ namespace config {
  * ```
  * these types will take precedence over the type_descriptor.
  */
-class type_descriptor {
+class type_descriptor final {
 public:
     /**
      * type_descriptor constructor. There is free function
@@ -64,6 +64,13 @@ class type_descriptor {
 };
 
 
+/**
+ * make_type_descriptor is a helper function to properly set up the descriptor
+ * from template type directly.
+ *
+ * @tparam ValueType  the value type in descriptor
+ * @tparam IndexType  the index type in descriptor
+ */
 template <typename ValueType = double, typename IndexType = int>
 type_descriptor make_type_descriptor();
 

From 2629167f0526526ef282499934f0a31454ce012f Mon Sep 17 00:00:00 2001
From: "Yu-Hsiang M. Tsai" <yhmtsai@gmail.com>
Date: Mon, 13 May 2024 16:56:19 +0200
Subject: [PATCH 25/25] update documentation, rename, complex number and rm
 stop::, index_type
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Thomas Grützmacher <thomas.gruetzmacher@kit.edu>
Co-authored-by: Tobias Ribizel <ribizel@kit.edu>
Co-authored-by: Marcel Koch <marcel.koch@kit.edu>
---
 core/config/config_helper.cpp                 |  42 ++++++--
 core/config/config_helper.hpp                 |  53 ++++++----
 core/config/stop_config.cpp                   |  43 ++------
 core/config/stop_config.hpp                   |  35 ++++++
 core/config/type_descriptor.cpp               |   7 +-
 core/config/type_descriptor_helper.hpp        |  13 +--
 core/solver/cg.cpp                            |   9 +-
 core/test/config/config.cpp                   |  40 +++----
 core/test/config/registry.cpp                 |  43 ++++----
 include/ginkgo/core/config/config.hpp         | 100 ++++++++++++------
 include/ginkgo/core/config/registry.hpp       |  50 +++++----
 .../ginkgo/core/config/type_descriptor.hpp    |  15 +--
 include/ginkgo/core/solver/cg.hpp             |  13 +++
 13 files changed, 279 insertions(+), 184 deletions(-)
 create mode 100644 core/config/stop_config.hpp

diff --git a/core/config/config_helper.cpp b/core/config/config_helper.cpp
index 4423080866c..5f26d927cad 100644
--- a/core/config/config_helper.cpp
+++ b/core/config/config_helper.cpp
@@ -12,30 +12,54 @@
 
 #include "core/config/config_helper.hpp"
 #include "core/config/registry_accessor.hpp"
-
+#include "core/config/stop_config.hpp"
 
 namespace gko {
 namespace config {
 
 
 template <>
-deferred_factory_parameter<const LinOpFactory> get_factory<const LinOpFactory>(
-    const pnode& config, const registry& context, const type_descriptor& td)
+deferred_factory_parameter<const LinOpFactory>
+parse_or_get_factory<const LinOpFactory>(const pnode& config,
+                                         const registry& context,
+                                         const type_descriptor& td)
 {
-    deferred_factory_parameter<const LinOpFactory> ptr;
     if (config.get_tag() == pnode::tag_t::string) {
-        ptr = detail::registry_accessor::get_data<LinOpFactory>(
+        return detail::registry_accessor::get_data<LinOpFactory>(
             context, config.get_string());
     } else if (config.get_tag() == pnode::tag_t::map) {
-        ptr = parse(config, context, td);
+        return parse(config, context, td);
     } else {
         GKO_INVALID_STATE("The data of config is not valid.");
     }
-    GKO_THROW_IF_INVALID(!ptr.is_empty(), "Parse get nullptr in the end");
-
-    return ptr;
 }
 
 
+template <>
+deferred_factory_parameter<const stop::CriterionFactory>
+parse_or_get_factory<const stop::CriterionFactory>(const pnode& config,
+                                                   const registry& context,
+                                                   const type_descriptor& td)
+{
+    if (config.get_tag() == pnode::tag_t::string) {
+        return detail::registry_accessor::get_data<stop::CriterionFactory>(
+            context, config.get_string());
+    } else if (config.get_tag() == pnode::tag_t::map) {
+        static std::map<std::string,
+                        std::function<deferred_factory_parameter<
+                            gko::stop::CriterionFactory>(
+                            const pnode&, const registry&, type_descriptor)>>
+            criterion_map{
+                {{"Time", configure_time},
+                 {"Iteration", configure_iter},
+                 {"ResidualNorm", configure_residual},
+                 {"ImplicitResidualNorm", configure_implicit_residual}}};
+        return criterion_map.at(config.get("type").get_string())(config,
+                                                                 context, td);
+    } else {
+        GKO_INVALID_STATE("The data of config is not valid.");
+    }
+}
+
 }  // namespace config
 }  // namespace gko
diff --git a/core/config/config_helper.hpp b/core/config/config_helper.hpp
index 19aadda71e7..798d3623856 100644
--- a/core/config/config_helper.hpp
+++ b/core/config/config_helper.hpp
@@ -60,45 +60,47 @@ inline std::shared_ptr<T> get_stored_obj(const pnode& config,
 
 
 /**
- * get_factory builds the factory from config (map) or searches the pointers in
+ * Build the factory from config (map) or search the pointers in
  * the registry by string.
  */
 template <typename T>
-deferred_factory_parameter<T> get_factory(const pnode& config,
-                                          const registry& context,
-                                          const type_descriptor& td);
+deferred_factory_parameter<T> parse_or_get_factory(const pnode& config,
+                                                   const registry& context,
+                                                   const type_descriptor& td);
 
 /**
  * specialize for const LinOpFactory
  */
 template <>
-deferred_factory_parameter<const LinOpFactory> get_factory<const LinOpFactory>(
-    const pnode& config, const registry& context, const type_descriptor& td);
+deferred_factory_parameter<const LinOpFactory>
+parse_or_get_factory<const LinOpFactory>(const pnode& config,
+                                         const registry& context,
+                                         const type_descriptor& td);
 
 /**
  * specialize for const stop::CriterionFactory
  */
 template <>
 deferred_factory_parameter<const stop::CriterionFactory>
-get_factory<const stop::CriterionFactory>(const pnode& config,
-                                          const registry& context,
-                                          const type_descriptor& td);
+parse_or_get_factory<const stop::CriterionFactory>(const pnode& config,
+                                                   const registry& context,
+                                                   const type_descriptor& td);
 
 /**
- * get_factory_vector will gives a vector of factory by calling get_factory.
+ * give a vector of factory by calling parse_or_get_factory.
  */
 template <typename T>
-inline std::vector<deferred_factory_parameter<T>> get_factory_vector(
+inline std::vector<deferred_factory_parameter<T>> parse_or_get_factory_vector(
     const pnode& config, const registry& context, const type_descriptor& td)
 {
     std::vector<deferred_factory_parameter<T>> res;
     if (config.get_tag() == pnode::tag_t::array) {
         for (const auto& it : config.get_array()) {
-            res.push_back(get_factory<T>(it, context, td));
+            res.push_back(parse_or_get_factory<T>(it, context, td));
         }
     } else {
         // only one config can be passed without array
-        res.push_back(get_factory<T>(config, context, td));
+        res.push_back(parse_or_get_factory<T>(config, context, td));
     }
 
     return res;
@@ -111,9 +113,8 @@ inline std::vector<deferred_factory_parameter<T>> get_factory_vector(
  * This is specialization for integral type
  */
 template <typename IndexType>
-inline
-    typename std::enable_if<std::is_integral<IndexType>::value, IndexType>::type
-    get_value(const pnode& config)
+inline std::enable_if_t<std::is_integral<IndexType>::value, IndexType>
+get_value(const pnode& config)
 {
     auto val = config.get_integer();
     GKO_THROW_IF_INVALID(
@@ -130,8 +131,7 @@ inline
  * This is specialization for floating point type
  */
 template <typename ValueType>
-inline typename std::enable_if<std::is_floating_point<ValueType>::value,
-                               ValueType>::type
+inline std::enable_if_t<std::is_floating_point<ValueType>::value, ValueType>
 get_value(const pnode& config)
 {
     auto val = config.get_real();
@@ -149,16 +149,25 @@ get_value(const pnode& config)
  * This is specialization for complex type
  */
 template <typename ValueType>
-inline typename std::enable_if<gko::is_complex_s<ValueType>::value,
-                               ValueType>::type
+inline std::enable_if_t<gko::is_complex_s<ValueType>::value, ValueType>
 get_value(const pnode& config)
 {
     using real_type = gko::remove_complex<ValueType>;
     if (config.get_tag() == pnode::tag_t::real) {
         return static_cast<ValueType>(get_value<real_type>(config));
     } else if (config.get_tag() == pnode::tag_t::array) {
-        return ValueType{get_value<real_type>(config.get(0)),
-                         get_value<real_type>(config.get(1))};
+        real_type real(0);
+        real_type imag(0);
+        if (config.get_array().size() >= 1) {
+            real = get_value<real_type>(config.get(0));
+        }
+        if (config.get_array().size() >= 2) {
+            imag = get_value<real_type>(config.get(1));
+        }
+        GKO_THROW_IF_INVALID(
+            config.get_array().size() <= 2,
+            "complex value array expression only accept up to two elements");
+        return ValueType{real, imag};
     }
     GKO_INVALID_STATE("Can not get complex value");
 }
diff --git a/core/config/stop_config.cpp b/core/config/stop_config.cpp
index 55670377b27..63148cbfcd9 100644
--- a/core/config/stop_config.cpp
+++ b/core/config/stop_config.cpp
@@ -5,6 +5,7 @@
 #include <ginkgo/core/base/exception_helpers.hpp>
 #include <ginkgo/core/config/config.hpp>
 #include <ginkgo/core/config/registry.hpp>
+#include <ginkgo/core/config/type_descriptor.hpp>
 #include <ginkgo/core/solver/solver_base.hpp>
 #include <ginkgo/core/stop/criterion.hpp>
 #include <ginkgo/core/stop/iteration.hpp>
@@ -15,6 +16,7 @@
 #include "core/config/config_helper.hpp"
 #include "core/config/dispatch.hpp"
 #include "core/config/registry_accessor.hpp"
+#include "core/config/stop_config.hpp"
 #include "core/config/type_descriptor_helper.hpp"
 
 
@@ -22,7 +24,7 @@ namespace gko {
 namespace config {
 
 
-inline deferred_factory_parameter<stop::CriterionFactory> configure_time(
+deferred_factory_parameter<stop::CriterionFactory> configure_time(
     const pnode& config, const registry& context, const type_descriptor& td)
 {
     auto factory = stop::Time::build();
@@ -33,7 +35,7 @@ inline deferred_factory_parameter<stop::CriterionFactory> configure_time(
 }
 
 
-inline deferred_factory_parameter<stop::CriterionFactory> configure_iter(
+deferred_factory_parameter<stop::CriterionFactory> configure_iter(
     const pnode& config, const registry& context, const type_descriptor& td)
 {
     auto factory = stop::Iteration::build();
@@ -44,7 +46,7 @@ inline deferred_factory_parameter<stop::CriterionFactory> configure_iter(
 }
 
 
-stop::mode get_mode(const std::string& str)
+inline stop::mode get_mode(const std::string& str)
 {
     if (str == "absolute") {
         return stop::mode::absolute;
@@ -79,7 +81,7 @@ class ResidualNormConfigurer {
 };
 
 
-inline deferred_factory_parameter<stop::CriterionFactory> configure_residual(
+deferred_factory_parameter<stop::CriterionFactory> configure_residual(
     const pnode& config, const registry& context, const type_descriptor& td)
 {
     auto updated = update_type(config, td);
@@ -111,9 +113,8 @@ class ImplicitResidualNormConfigurer {
 };
 
 
-inline deferred_factory_parameter<stop::CriterionFactory>
-configure_implicit_residual(const pnode& config, const registry& context,
-                            const type_descriptor& td)
+deferred_factory_parameter<stop::CriterionFactory> configure_implicit_residual(
+    const pnode& config, const registry& context, const type_descriptor& td)
 {
     auto updated = update_type(config, td);
     return dispatch<stop::CriterionFactory, ImplicitResidualNormConfigurer>(
@@ -122,33 +123,5 @@ configure_implicit_residual(const pnode& config, const registry& context,
 }
 
 
-template <>
-deferred_factory_parameter<const stop::CriterionFactory>
-get_factory<const stop::CriterionFactory>(const pnode& config,
-                                          const registry& context,
-                                          const type_descriptor& td)
-{
-    deferred_factory_parameter<const stop::CriterionFactory> ptr;
-    if (config.get_tag() == pnode::tag_t::string) {
-        return detail::registry_accessor::get_data<stop::CriterionFactory>(
-            context, config.get_string());
-    } else if (config.get_tag() == pnode::tag_t::map) {
-        static std::map<std::string,
-                        std::function<deferred_factory_parameter<
-                            gko::stop::CriterionFactory>(
-                            const pnode&, const registry&, type_descriptor)>>
-            criterion_map{
-                {{"stop::Time", configure_time},
-                 {"stop::Iteration", configure_iter},
-                 {"stop::ResidualNorm", configure_residual},
-                 {"stop::ImplicitResidualNorm", configure_implicit_residual}}};
-        return criterion_map.at(config.get("type").get_string())(config,
-                                                                 context, td);
-    }
-    GKO_THROW_IF_INVALID(!ptr.is_empty(), "Parse get nullptr in the end");
-    return ptr;
-}
-
-
 }  // namespace config
 }  // namespace gko
diff --git a/core/config/stop_config.hpp b/core/config/stop_config.hpp
new file mode 100644
index 00000000000..edb99c6a634
--- /dev/null
+++ b/core/config/stop_config.hpp
@@ -0,0 +1,35 @@
+// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#ifndef GKO_CORE_CONFIG_STOP_CONFIG_HPP_
+#define GKO_CORE_CONFIG_STOP_CONFIG_HPP_
+
+
+#include <ginkgo/core/config/config.hpp>
+#include <ginkgo/core/config/registry.hpp>
+#include <ginkgo/core/config/type_descriptor.hpp>
+#include <ginkgo/core/stop/criterion.hpp>
+
+
+namespace gko {
+namespace config {
+
+
+deferred_factory_parameter<stop::CriterionFactory> configure_time(
+    const pnode& config, const registry& context, const type_descriptor& td);
+
+deferred_factory_parameter<stop::CriterionFactory> configure_iter(
+    const pnode& config, const registry& context, const type_descriptor& td);
+
+deferred_factory_parameter<stop::CriterionFactory> configure_residual(
+    const pnode& config, const registry& context, const type_descriptor& td);
+
+deferred_factory_parameter<stop::CriterionFactory> configure_implicit_residual(
+    const pnode& config, const registry& context, const type_descriptor& td);
+
+}  // namespace config
+}  // namespace gko
+
+
+#endif  // GKO_CORE_CONFIG_STOP_CONFIG_HPP_
diff --git a/core/config/type_descriptor.cpp b/core/config/type_descriptor.cpp
index de44d19700c..c2885407cad 100644
--- a/core/config/type_descriptor.cpp
+++ b/core/config/type_descriptor.cpp
@@ -5,6 +5,9 @@
 #include <ginkgo/core/config/type_descriptor.hpp>
 
 
+#include <ginkgo/core/base/exception_helpers.hpp>
+
+
 #include "core/config/type_descriptor_helper.hpp"
 
 
@@ -21,7 +24,9 @@ type_descriptor update_type(const pnode& config, const type_descriptor& td)
         value_typestr = obj.get_string();
     }
     if (auto& obj = config.get("index_type")) {
-        index_typestr = obj.get_string();
+        GKO_INVALID_STATE(
+            "Setting index_type in the config is not allowed. Please set the "
+            "proper index_type through type_descriptor of parse");
     }
     return type_descriptor{value_typestr, index_typestr};
 }
diff --git a/core/config/type_descriptor_helper.hpp b/core/config/type_descriptor_helper.hpp
index 1a4ca1ac613..3917e317773 100644
--- a/core/config/type_descriptor_helper.hpp
+++ b/core/config/type_descriptor_helper.hpp
@@ -7,16 +7,11 @@
 
 
 #include <string>
-#include <type_traits>
 
 
-#include <ginkgo/core/base/exception_helpers.hpp>
-#include <ginkgo/core/base/lin_op.hpp>
-#include <ginkgo/core/base/math.hpp>
-#include <ginkgo/core/config/config.hpp>
-#include <ginkgo/core/config/registry.hpp>
-#include <ginkgo/core/solver/solver_base.hpp>
-#include <ginkgo/core/stop/criterion.hpp>
+#include <ginkgo/core/base/types.hpp>
+#include <ginkgo/core/config/property_tree.hpp>
+#include <ginkgo/core/config/type_descriptor.hpp>
 
 
 namespace gko {
@@ -49,6 +44,8 @@ TYPE_STRING_OVERLOAD(std::complex<float>, "complex<float32>");
 TYPE_STRING_OVERLOAD(int32, "int32");
 TYPE_STRING_OVERLOAD(int64, "int64");
 
+#undef TYPE_STRING_OVERLOAD
+
 
 }  // namespace config
 }  // namespace gko
diff --git a/core/solver/cg.cpp b/core/solver/cg.cpp
index 5452fe2bb7a..71e5fcfbb3b 100644
--- a/core/solver/cg.cpp
+++ b/core/solver/cg.cpp
@@ -69,12 +69,13 @@ typename Cg<ValueType>::parameters_type Cg<ValueType>::parse(
     }
     if (auto& obj = config.get("criteria")) {
         params.with_criteria(
-            gko::config::get_factory_vector<const stop::CriterionFactory>(
-                obj, context, td_for_child));
+            gko::config::parse_or_get_factory_vector<
+                const stop::CriterionFactory>(obj, context, td_for_child));
     }
     if (auto& obj = config.get("preconditioner")) {
-        params.with_preconditioner(gko::config::get_factory<const LinOpFactory>(
-            obj, context, td_for_child));
+        params.with_preconditioner(
+            gko::config::parse_or_get_factory<const LinOpFactory>(
+                obj, context, td_for_child));
     }
     return params;
 }
diff --git a/core/test/config/config.cpp b/core/test/config/config.cpp
index a791667b8e2..163f6936de2 100644
--- a/core/test/config/config.cpp
+++ b/core/test/config/config.cpp
@@ -5,9 +5,6 @@
 #include <ginkgo/core/config/config.hpp>
 
 
-#include <typeinfo>
-
-
 #include <gtest/gtest.h>
 
 
@@ -38,8 +35,7 @@ class Config : public ::testing::Test {
         : exec(gko::ReferenceExecutor::create()),
           mtx(gko::initialize<Mtx>(
               {{2, -1.0, 0.0}, {-1.0, 2, -1.0}, {0.0, -1.0, 2}}, exec)),
-          stop_config(
-              {{"type", pnode{"stop::Iteration"}}, {"max_iters", pnode{1}}})
+          stop_config({{"type", pnode{"Iteration"}}, {"max_iters", pnode{1}}})
     {}
 
     std::shared_ptr<const gko::Executor> exec;
@@ -139,10 +135,12 @@ TEST(GetValue, IndexType)
     ASSERT_EQ(get_value<long>(config), value);
     ASSERT_EQ(get_value<unsigned>(config), value);
     ASSERT_EQ(get_value<long long int>(config), value);
-    ASSERT_EQ(typeid(get_value<int>(config)), typeid(int));
-    ASSERT_EQ(typeid(get_value<long>(config)), typeid(long));
-    ASSERT_EQ(typeid(get_value<unsigned>(config)), typeid(unsigned));
-    ASSERT_EQ(typeid(get_value<long long int>(config)), typeid(long long int));
+    testing::StaticAssertTypeEq<decltype(get_value<int>(config)), int>();
+    testing::StaticAssertTypeEq<decltype(get_value<long>(config)), long>();
+    testing::StaticAssertTypeEq<decltype(get_value<unsigned>(config)),
+                                unsigned>();
+    testing::StaticAssertTypeEq<decltype(get_value<long long int>(config)),
+                                long long int>();
 }
 
 
@@ -153,8 +151,8 @@ TEST(GetValue, RealType)
 
     ASSERT_EQ(get_value<float>(config), value);
     ASSERT_EQ(get_value<double>(config), value);
-    ASSERT_EQ(typeid(get_value<float>(config)), typeid(float));
-    ASSERT_EQ(typeid(get_value<double>(config)), typeid(double));
+    testing::StaticAssertTypeEq<decltype(get_value<float>(config)), float>();
+    testing::StaticAssertTypeEq<decltype(get_value<double>(config)), double>();
 }
 
 
@@ -170,19 +168,23 @@ TEST(GetValue, ComplexType)
               std::complex<float>(real));
     ASSERT_EQ(get_value<std::complex<double>>(config),
               std::complex<double>(real));
-    ASSERT_EQ(typeid(get_value<std::complex<float>>(config)),
-              typeid(std::complex<float>));
-    ASSERT_EQ(typeid(get_value<std::complex<double>>(config)),
-              typeid(std::complex<double>));
+    testing::StaticAssertTypeEq<decltype(get_value<std::complex<float>>(
+                                    config)),
+                                std::complex<float>>();
+    testing::StaticAssertTypeEq<decltype(get_value<std::complex<double>>(
+                                    config)),
+                                std::complex<double>>();
     // Two value [real, imag]
     ASSERT_EQ(get_value<std::complex<float>>(array_config),
               std::complex<float>(real, imag));
     ASSERT_EQ(get_value<std::complex<double>>(array_config),
               std::complex<double>(real, imag));
-    ASSERT_EQ(typeid(get_value<std::complex<float>>(array_config)),
-              typeid(std::complex<float>));
-    ASSERT_EQ(typeid(get_value<std::complex<double>>(array_config)),
-              typeid(std::complex<double>));
+    testing::StaticAssertTypeEq<decltype(get_value<std::complex<float>>(
+                                    array_config)),
+                                std::complex<float>>();
+    testing::StaticAssertTypeEq<decltype(get_value<std::complex<double>>(
+                                    array_config)),
+                                std::complex<double>>();
 }
 
 
diff --git a/core/test/config/registry.cpp b/core/test/config/registry.cpp
index 78137fd95bf..e6fc8eef671 100644
--- a/core/test/config/registry.cpp
+++ b/core/test/config/registry.cpp
@@ -5,10 +5,6 @@
 #include <ginkgo/core/config/registry.hpp>
 
 
-#include <functional>
-#include <type_traits>
-
-
 #include <gtest/gtest.h>
 
 
@@ -95,13 +91,12 @@ TEST_F(Registry, SearchData)
     ASSERT_EQ(found_solver_factory, solver_factory);
     ASSERT_EQ(found_stop_factory, stop_factory);
     // get correct types
-    ASSERT_TRUE((std::is_same<decltype(found_matrix),
-                              std::shared_ptr<gko::LinOp>>::value));
-    ASSERT_TRUE((std::is_same<decltype(found_solver_factory),
-                              std::shared_ptr<gko::LinOpFactory>>::value));
-    ASSERT_TRUE(
-        (std::is_same<decltype(found_stop_factory),
-                      std::shared_ptr<gko::stop::CriterionFactory>>::value));
+    testing::StaticAssertTypeEq<decltype(found_matrix),
+                                std::shared_ptr<gko::LinOp>>();
+    testing::StaticAssertTypeEq<decltype(found_solver_factory),
+                                std::shared_ptr<gko::LinOpFactory>>();
+    testing::StaticAssertTypeEq<decltype(found_stop_factory),
+                                std::shared_ptr<gko::stop::CriterionFactory>>();
 }
 
 
@@ -124,13 +119,12 @@ TEST_F(Registry, SearchDataWithType)
     ASSERT_EQ(found_solver_factory, solver_factory);
     ASSERT_EQ(found_stop_factory, stop_factory);
     // get correct types
-    ASSERT_TRUE(
-        (std::is_same<decltype(found_matrix), std::shared_ptr<Matrix>>::value));
-    ASSERT_TRUE(
-        (std::is_same<decltype(found_solver_factory),
-                      std::shared_ptr<typename Solver::Factory>>::value));
-    ASSERT_TRUE((std::is_same<decltype(found_stop_factory),
-                              std::shared_ptr<typename Stop::Factory>>::value));
+    testing::StaticAssertTypeEq<decltype(found_matrix),
+                                std::shared_ptr<Matrix>>();
+    testing::StaticAssertTypeEq<decltype(found_solver_factory),
+                                std::shared_ptr<typename Solver::Factory>>();
+    testing::StaticAssertTypeEq<decltype(found_stop_factory),
+                                std::shared_ptr<typename Stop::Factory>>();
 }
 
 
@@ -153,13 +147,12 @@ TEST_F(Registry, BuildFromConstructor)
     ASSERT_EQ(found_solver_factory, solver_factory);
     ASSERT_EQ(found_stop_factory, stop_factory);
     // get correct types
-    ASSERT_TRUE(
-        (std::is_same<decltype(found_matrix), std::shared_ptr<Matrix>>::value));
-    ASSERT_TRUE(
-        (std::is_same<decltype(found_solver_factory),
-                      std::shared_ptr<typename Solver::Factory>>::value));
-    ASSERT_TRUE((std::is_same<decltype(found_stop_factory),
-                              std::shared_ptr<typename Stop::Factory>>::value));
+    testing::StaticAssertTypeEq<decltype(found_matrix),
+                                std::shared_ptr<Matrix>>();
+    testing::StaticAssertTypeEq<decltype(found_solver_factory),
+                                std::shared_ptr<typename Solver::Factory>>();
+    testing::StaticAssertTypeEq<decltype(found_stop_factory),
+                                std::shared_ptr<typename Stop::Factory>>();
 }
 
 
diff --git a/include/ginkgo/core/config/config.hpp b/include/ginkgo/core/config/config.hpp
index 376ee14f7c7..5d77c6f71c7 100644
--- a/include/ginkgo/core/config/config.hpp
+++ b/include/ginkgo/core/config/config.hpp
@@ -27,52 +27,82 @@ class pnode;
 
 
 /**
- * parse is the main entry point to create an Ginkgo object based on
+ * parse is the main entry point to create an Ginkgo LinOpFactory based on
  * some file configuration. It reads a configuration stored as a property tree
  * and creates the desired type.
  *
  * General rules for configuration
- * 1. all parameter and template usage are according to the class directly. It
- *    has the same behavior as the class like default setting without specifying
- *    anything. When the class factory parameters allows `with_<key>(value)`,
- *    the file configuration will allow `"<key>": value`
- * 2. all key will use snake_case including template. For example, ValueType ->
- *    value_type
- * 3. If the value is not bool, integer, or floating point, we will use string
- *    to represent everything. For example, we will use string to select the
- *    enum value. `"baseline": "absolute"` will select the absolute baseline in
- *    ResidualNorm critrion
- * 4. `"type"` is the new key to select the class without template type. We also
- *    prepend the namespace except for gko. For example, we use "solver::Cg" for
- *    Cg solver. Note. the template type is given by the another entry or from
- *    the type_descriptor.
- * 5. the data type uses fixed-width representation
- *    void, int32, int64, float32, float64, complex<float32>, complex<float64>
- * 6. We use [real, imag] to represent complex value. If it only contains one
- *    value or without [], we will treat it as the complex number with imaginary
- *    part = 0.
- * 7. In many cases, the parameter allows vector input and we handle it by array
- *    of property tree. If the array only contains one object, users can
- *    directly provide the object without putting it into an array.
- *    `"criteria": [{...}]` and `"criteria": {...}` are the same.
+ * 1. The configuration can be used to define factory parameters and class
+ *    template parameters. Any factory parameter that is not defined in the
+ *    configuration will fallback to their default value. Any template parameter
+ *    that is not defined will fallback to the type_descriptor argument
+ * 2. The new `"type"` key determines which Ginkgo object to create. The value
+ *    for this key is the desired class name with namespaces (except for
+ *    `gko::`, `experimental::`, `stop::`). Any template parameters a class
+ *    might have are left out. Only classes with a factory are supported. For
+ *    example, the configuration `"type": "solver::Cg"` specifies that a Cg
+ *    solver will be created. Note: template parameters can either be given in
+ *    the configuration as separate key-value pairs, or in the type_descriptor.
+ * 3. Factory and class template parameters can be defined with key-value pairs
+ *    that are derived from the class they are referring to. When a factory has
+ *    a parameter with the function `with_<key>(value)`, then the configuration
+ *    allows `"<key>": value` to define this parameter. When a class has a
+ *    template parameter `template<typename/specific_type... key> class`, then
+ *    the configuration allows `"<key>": value`  to the template parameter. The
+ *    supported values of the template parameter depend on the context. For
+ *    index and value types, these are listed under 4.
+ * 4. Values for template parameters are represented with strings. The following
+ *    datatypes, with postfix to indicate their size, are supported: int32,
+ *    int64, float32, float64, complex<float32>, complex<float64>.
+ * 5. All keys use snake_case including template parameters. Factory parameter
+ *    keys are already defined with snake_case in their factories, while class
+ *    template arguments need to be translated, i.e. `ValueType -> value_type`.
+ * 6. The allowed values for factory parameters depend on the type the parameter
+ *    is stored as. There are three distinct options:
+ *    - POD types (bool, integer, floating point, or enum): Except for enum,
+ *      the value has to be the POD type. For enums, a string value is used to
+ *      represent them. The string has to be one of the possible enum values.
+ *      An example of this type of parameter is the `krylov_dim` parameter for
+ *      the Gmres solver.
+ *    - LinOp (smart) pointers: The value has to be a string. The string is used
+ *      to look up a LinOp object in the registry.
+ *      An example is the `generated_preconditioner` parameter for iterative
+ *      solvers such as Cg.
+ *    - LinOpFactory (smart) pointers: The value can either be a string, or a
+ *      nested configuration. The string has the same behavior as for LinOp
+ *      pointers, i.e. an LinOpFactory object from the registry is taken. The
+ *      nested configuration has to adhere to the general configuration rules
+ *      again. See the examples below for some use-cases.
+ *      An example is the `preconditioner` parameter for iterative solvers
+ *      such as Cg.
+ *    - CriterionFactory (smart) pointers: The value can either be a string, or
+ *      a nested configuration. It has the same behavior as for LinOpFactory.
+ *    - A vector of the types above: The value has to be an array with the
+ *      inner values specified as above.
+ * 7. Complex values are represented as an 2-element array [real, imag]. If the
+ *    array contains only one value, it will be considered as a complex number
+ *    with an imaginary part = 0. An empty array will be treated as zero.
+ * 8. Keys that expect array of objects also accept single object which is
+ *    interpreted as a 1-element array. This means the following configurations
+ *    are equivalent if the key expects an array value: `"<key>": [{object}]`
+ *    and `"<key>": {object}`.
  *
- * The configuration needs
- * to specify the resulting type by the field:
+ * All configurations need to specify the resulting type by the field:
  * ```
  * "type": "some_supported_ginkgo_type"
  * ```
- * The result will be a deferred_factory_parameter,
- * which can be thought of as an intermediate step before a LinOpFactory.
- * Providing the result an Executor through the function `.on(exec)` will then
- * create the factory with the parameters as defined in the configuration.
+ * The result will be a deferred_factory_parameter, which is an intermediate
+ * step before a LinOpFactory. Providing an Executor through the function
+ * `.on(exec)` will then create the factory with the parameters as defined in
+ * the configuration.
  *
  * Given a configuration that is defined as
  * ```
  * "type": "solver::Gmres",
  * "krylov_dim": 20,
  * "criteria": [
- *   {"type": "stop::Iteration", "max_iters": 10},
- *   {"type": "stop::ResidualNorm", "reduction_factor": 1e-6}
+ *   {"type": "Iteration", "max_iters": 10},
+ *   {"type": "ResidualNorm", "reduction_factor": 1e-6}
  * ]
  * ```
  * then passing it to this function like this:
@@ -96,7 +126,6 @@ class pnode;
  * Additionally, the config can be used to set these types through the fields:
  * ```
  * value_type: "some_value_type"
- * index_type: "some_index_type"
  * ```
  * These types take precedence over the type descriptor and they are used for
  * every created object beginning from the config level they are defined on and
@@ -125,7 +154,10 @@ class pnode;
  *                         templated type, then the value and/or index type from
  *                         the descriptor will be used. Any definition of the
  *                         value and/or index type within the config will take
- *                         precedence over the descriptor.
+ *                         precedence over the descriptor. If `void` is used for
+ *                         one or both of the types, then the corresponding type
+ *                         has to be defined in the config, otherwise the
+ *                         parsing will fail.
  *
  * @return a deferred_factory_parameter which creates an LinOpFactory after
  *         `.on(exec)` is called on it.
diff --git a/include/ginkgo/core/config/registry.hpp b/include/ginkgo/core/config/registry.hpp
index b4c1658c037..2efa160ee65 100644
--- a/include/ginkgo/core/config/registry.hpp
+++ b/include/ginkgo/core/config/registry.hpp
@@ -51,20 +51,20 @@ template <typename T, typename = void>
 struct base_type {};
 
 template <typename T>
-struct base_type<
-    T, typename std::enable_if<std::is_convertible<T*, LinOp*>::value>::type> {
+struct base_type<T, std::enable_if_t<std::is_convertible<T*, LinOp*>::value>> {
     using type = LinOp;
 };
 
 template <typename T>
-struct base_type<T, typename std::enable_if<
-                        std::is_convertible<T*, LinOpFactory*>::value>::type> {
+struct base_type<
+    T, std::enable_if_t<std::is_convertible<T*, LinOpFactory*>::value>> {
     using type = LinOpFactory;
 };
 
 template <typename T>
-struct base_type<T, typename std::enable_if<std::is_convertible<
-                        T*, stop::CriterionFactory*>::value>::type> {
+struct base_type<
+    T,
+    std::enable_if_t<std::is_convertible<T*, stop::CriterionFactory*>::value>> {
     using type = stop::CriterionFactory;
 };
 
@@ -76,11 +76,11 @@ struct base_type<T, typename std::enable_if<std::is_convertible<
 class allowed_ptr {
 public:
     /**
-     * The constructor accept any shared pointer whose base type is LinOp,
-     * LinOpFactory, or CriterionFactory. We use template rather than
-     * constructor without template because it allows user to directly use
-     * uninitialized_list in registry constructor without wrapping allowed_ptr
-     * manually.
+     * The constructor accepts any shared pointer whose base type is LinOp,
+     * LinOpFactory, or CriterionFactory. We use a template rather than
+     * a constructor without a template because it allows the user to directly
+     * use uninitialized_list in the registry constructor without wrapping
+     * allowed_ptr manually.
      */
     template <typename Type>
     allowed_ptr(std::shared_ptr<Type> obj);
@@ -110,7 +110,12 @@ class allowed_ptr {
 
     template <typename Type>
     struct concrete_container : generic_container {
-        concrete_container(std::shared_ptr<Type> obj) : ptr{obj} {}
+        concrete_container(std::shared_ptr<Type> obj) : ptr{obj}
+        {
+            static_assert(
+                std::is_same<Type, typename base_type<Type>::type>::value,
+                "The given type must be a base_type");
+        }
 
         std::shared_ptr<Type> ptr;
     };
@@ -151,7 +156,8 @@ inline std::shared_ptr<Type> allowed_ptr::get() const
  * This class stores additional context for creating Ginkgo objects from
  * configuration files.
  *
- * The context can contain user provided objects of the following types:
+ * The context can contain user-provided objects that derive from the following
+ * base types:
  * - LinOp
  * - LinOpFactory
  * - CriterionFactory
@@ -168,8 +174,10 @@ class registry final {
      * registry constructor
      *
      * @param additional_map  the additional map to dispatch the class base.
-     *                        Users can extend map to fit their own
-     *                        LinOpFactory.
+     *                        Users can extend the map to fit their own
+     *                        LinOpFactory. We suggest using "usr::" as the
+     *                        prefix in the key to simply avoid conflict with
+     *                        ginkgo's map.
      */
     registry(const configuration_map& additional_map = {});
 
@@ -187,15 +195,17 @@ class registry final {
      * }}
      * ```
      * @param additional_map  the additional map to dispatch the class base.
-     *                        Users can extend map to fit their own
-     *                        LinOpFactory.
+     *                        Users can extend the map to fit their own
+     *                        LinOpFactory. We suggest using "usr::" as the
+     *                        prefix in the key to simply avoid conflict with
+     *                        ginkgo's map.
      */
     registry(
         const std::unordered_map<std::string, detail::allowed_ptr>& stored_map,
         const configuration_map& additional_map = {});
 
     /**
-     * insert_data stores the data with the key.
+     * Store the data with the key.
      *
      * @tparam T  the type
      *
@@ -207,7 +217,7 @@ class registry final {
 
 protected:
     /**
-     * get_data searches the key on the corresponding map.
+     * Search the key on the corresponding map.
      *
      * @tparam T  the type
      *
@@ -219,7 +229,7 @@ class registry final {
     std::shared_ptr<T> get_data(std::string key) const;
 
     /**
-     * get the stored build map
+     * Get the stored build map
      */
     const configuration_map& get_build_map() const { return build_map_; }
 
diff --git a/include/ginkgo/core/config/type_descriptor.hpp b/include/ginkgo/core/config/type_descriptor.hpp
index 3a05ee33aac..48475f7f469 100644
--- a/include/ginkgo/core/config/type_descriptor.hpp
+++ b/include/ginkgo/core/config/type_descriptor.hpp
@@ -16,17 +16,18 @@ namespace config {
  * This class describes the value and index types to be used when building a
  * Ginkgo type from a configuration file.
  *
- * A type_descriptor is passed to the parse function defines which
- * template parameters, in terms of value_type and/or index_type, the created
- * object will have. For example, a CG solver created like this:
+ * A type_descriptor is passed in order to define the parse function defines
+ * which template parameters, in terms of value_type and/or index_type, the
+ * created object will have. For example, a CG solver created like this:
  * ```
  * auto cg = parse(config, context, type_descriptor("float64", "int32"));
  * ```
  * will have the value type `float64` and the index type `int32`. Any Ginkgo
- * object that does not require one of these types will just ignore it. We used
- * void type to specify no default type.
+ * object that does not require one of these types will just ignore it. The
+ * value `void` can be used to specify that no default type is provided. In this
+ * case, the configuration has to provide the necessary template types.
  *
- * If the configurations specifies one of the fields (or both):
+ * If the configuration specifies one of the fields (or both):
  * ```
  * value_type: "some_value_type"
  * index_type: "some_index_type"
@@ -65,7 +66,7 @@ class type_descriptor final {
 
 
 /**
- * make_type_descriptor is a helper function to properly set up the descriptor
+ * A helper function to properly set up the descriptor
  * from template type directly.
  *
  * @tparam ValueType  the value type in descriptor
diff --git a/include/ginkgo/core/solver/cg.hpp b/include/ginkgo/core/solver/cg.hpp
index 6678d8ac618..9302f2297b3 100644
--- a/include/ginkgo/core/solver/cg.hpp
+++ b/include/ginkgo/core/solver/cg.hpp
@@ -16,6 +16,7 @@
 #include <ginkgo/core/base/types.hpp>
 #include <ginkgo/core/config/config.hpp>
 #include <ginkgo/core/config/registry.hpp>
+#include <ginkgo/core/config/type_descriptor.hpp>
 #include <ginkgo/core/log/logger.hpp>
 #include <ginkgo/core/matrix/dense.hpp>
 #include <ginkgo/core/matrix/identity.hpp>
@@ -75,6 +76,18 @@ class Cg : public EnableLinOp<Cg<ValueType>>,
     GKO_ENABLE_LIN_OP_FACTORY(Cg, parameters, Factory);
     GKO_ENABLE_BUILD_METHOD(Factory);
 
+    /**
+     * Create the parameters from the property_tree.
+     * Because this is directly tied to the specific type. The value/index type
+     * settings are ignored and type_descriptor is for children objects.
+     *
+     * @param config  the property tree for setting
+     * @param context  the registry
+     * @param td_for_child  the type descriptor for children objects. The
+     *                      default will directly from the specific type.
+     *
+     * @return parameters
+     */
     static parameters_type parse(const config::pnode& config,
                                  const config::registry& context,
                                  const config::type_descriptor& td_for_child =