From d1bb12c43d4da55005b2472ea590c0e180556708 Mon Sep 17 00:00:00 2001
From: Alexander Sherikov <alexander@sherikov.net>
Date: Fri, 26 Jul 2024 00:25:22 +0400
Subject: [PATCH] +ariles2::Any2: replacement for ariles2::Any

---
 CHANGELOG.md                           |   8 +
 README.md                              |   7 +
 include/ariles2/types.h                | 232 +++++++++++++++++++++++++
 tests/api_v2/fixtures/002_comparison.h |   5 +-
 tests/api_v2/types/any.h               | 129 +++++++++-----
 tests/api_v2/types/complex_base.h      |   4 +-
 6 files changed, 339 insertions(+), 46 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b13012c4..52a92860 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,14 @@
 CHANGELOG
 =========
 
+UNRELEASED
+==========
+
+Added
+-----
+* `ariles2::Any2`: a replacement for deprecated `ariles2::Any`.
+
+
 2.3.2
 =====
 
diff --git a/README.md b/README.md
index b69d70b9..658b98b5 100644
--- a/README.md
+++ b/README.md
@@ -270,3 +270,10 @@ Related software
 
 * A library with similar functionality in C++17
   <https://github.com/injae/serdepp>.
+
+
+Deprecated
+==========
+
+- `ariles2::namevalue`
+- `ariles2::Any`
diff --git a/include/ariles2/types.h b/include/ariles2/types.h
index 1bb188f0..f496951f 100644
--- a/include/ariles2/types.h
+++ b/include/ariles2/types.h
@@ -215,6 +215,238 @@ namespace ariles2
 }  // namespace ariles2
 
 
+namespace ariles2
+{
+    template <template <class> class t_Pointer, class t_Base, class t_Instantiator>
+    class ARILES2_VISIBILITY_ATTRIBUTE Any2 : public ariles2::DefaultBase
+    {
+#define ARILES2_ENTRIES(v)                                                                                             \
+    ARILES2_TYPED_ENTRY_(v, id, std::string)                                                                           \
+    ARILES2_TYPED_ENTRY_(v, value, t_Pointer<t_Base>)
+#include ARILES2_INITIALIZE
+
+    protected:
+        bool isConsistent() const
+        {
+            if (("" != id_) && (nullptr != value_.get()))
+            {
+                return (true);
+            }
+
+            if (("" == id_) && (nullptr == value_.get()))
+            {
+                return (true);
+            }
+
+            return (false);
+        }
+
+
+    public:
+        Any2()
+        {
+            ariles2::apply<ariles2::Defaults>(*this);
+        }
+
+
+        explicit Any2(const std::string &id)
+        {
+            build(id);
+        }
+
+
+        void build(const std::string &id)
+        {
+            id_ = id;
+            value_ = t_Instantiator::instantiate(id_);
+            CPPUT_ASSERT(nullptr != value_.get(), "Could not instantiate class.");
+        }
+
+
+        bool isInitialized() const
+        {
+            return ("" != id_ && nullptr != value_.get());
+        }
+
+
+        /// @{
+        /**
+         * @brief Cast methods are potentially dangerous, no id checks are
+         * performed. If value is not initialized the returned pointer may
+         * be nullptr.
+         */
+        template <class t_Derived>
+        t_Derived *cast()
+        {
+            return (dynamic_cast<t_Derived *>(value_.get()));
+        }
+
+
+        template <class t_Derived>
+        const t_Derived *cast() const
+        {
+            return (dynamic_cast<const t_Derived *>(value_.get()));
+        }
+        /// @}
+
+
+        /// @{
+        /**
+         * @brief These casts succeed if the Ariles config section id
+         * matches the given string.
+         */
+        template <class t_Derived>
+        t_Derived *cast(const std::string &config_section_id)
+        {
+            if (isInitialized())
+            {
+                if (config_section_id == value_->arilesDefaultID())
+                {
+                    return (dynamic_cast<t_Derived *>(value_.get()));
+                }
+            }
+            return (nullptr);
+        }
+
+
+        template <class t_Derived>
+        const t_Derived *cast(const std::string &config_section_id) const
+        {
+            if (isInitialized())
+            {
+                if (config_section_id == value_->arilesDefaultID())
+                {
+                    return (dynamic_cast<t_Derived *>(value_.get()));
+                }
+            }
+            return (nullptr);
+        }
+        /// @}
+
+
+        t_Base *operator->()
+        {
+            CPPUT_ASSERT(isInitialized(), "Not initialized");
+            return (value_.get());
+        }
+
+
+        const t_Base *operator->() const
+        {
+            CPPUT_ASSERT(isInitialized(), "Not initialized");
+            return (value_.get());
+        }
+
+
+        t_Base &operator*()
+        {
+            CPPUT_ASSERT(isInitialized(), "Not initialized");
+            return (*value_);
+        }
+
+
+        const t_Base &operator*() const
+        {
+            CPPUT_ASSERT(isInitialized(), "Not initialized");
+            return (*value_);
+        }
+
+
+        // Ariles methods
+
+        void arilesVisit(ariles2::Write &visitor, const ariles2::Write::Parameters &param) const
+        {
+            CPPUT_TRACE_FUNCTION;
+            CPPUT_ASSERT(
+                    isConsistent(),
+                    "Could not write config: entry is in an inconsistent (partially initialized) state.");
+
+            visitor.visitMapEntry(id_, "id", param);
+            if (isInitialized())
+            {
+                value_->arilesVirtualVisit(visitor, param);
+            }
+        }
+
+
+        void arilesVisit(ariles2::Read &visitor, const ariles2::Read::Parameters &param)
+        {
+            CPPUT_TRACE_FUNCTION;
+
+            if (visitor.visitMapEntry(id_, "id", param))
+            {
+                if ("" == id_)
+                {
+                    CPPUT_ASSERT(param.allow_missing_entries_, "Id is empty, value cannot be read.");
+                }
+                else
+                {
+                    build(id_);
+
+                    try
+                    {
+                        value_->arilesVirtualVisit(visitor, param);
+                    }
+                    catch (const std::exception &e)
+                    {
+                        CPPUT_THROW("Failed to parse entry <", id_, "> ||  ", e.what());
+                    }
+                }
+            }
+        }
+
+
+        void arilesVisit(const ariles2::Finalize &visitor, const ariles2::Finalize::Parameters &param)
+        {
+            CPPUT_TRACE_FUNCTION;
+            if (isInitialized())
+            {
+                value_->arilesVirtualVisit(visitor, param);
+            }
+        }
+
+
+        void arilesVisit(const ariles2::PreWrite &visitor, const ariles2::PreWrite::Parameters &param)
+        {
+            CPPUT_TRACE_FUNCTION;
+            if (isInitialized())
+            {
+                value_->arilesVirtualVisit(visitor, param);
+            }
+        }
+
+
+        void arilesVisit(const ariles2::Defaults &visitor, const ariles2::Defaults::Parameters &param)
+        {
+            CPPUT_TRACE_FUNCTION;
+            if (isInitialized())
+            {
+                value_->arilesVirtualVisit(visitor, param);
+            }
+        }
+
+
+        std::size_t arilesVisit(const ariles2::Count &visitor, const ariles2::Count::Parameters &param) const
+        {
+            if (isInitialized())
+            {
+                return (this->value_->arilesVirtualVisit(visitor, param) + 1);
+            }
+
+            return (1);
+        }
+
+
+        std::size_t arilesVisit(const ariles2::CountMissing &visitor, const ariles2::CountMissing::Parameters &param)
+                const
+        {
+            CPPUT_ASSERT(isInitialized(), "Not initialized");
+            return (this->value_->arilesVirtualVisit(visitor, param));
+        }
+    };
+}  // namespace ariles2
+
+
 namespace ariles2
 {
     template <class t_Pointer>
diff --git a/tests/api_v2/fixtures/002_comparison.h b/tests/api_v2/fixtures/002_comparison.h
index 4f824894..b5d3bec2 100644
--- a/tests/api_v2/fixtures/002_comparison.h
+++ b/tests/api_v2/fixtures/002_comparison.h
@@ -33,8 +33,11 @@ namespace ariles_tests
             // -------
 
             t_Configurable configurable_in;
+            /*
             BOOST_CHECK_NO_THROW(ariles2::apply<typename t_Visitor::Reader>(
-                                         getReaderInitializer("configurable_match_simple.cfg"), configurable_in););
+                                         getReaderInitializer("configurable_match_simple.cfg"), configurable_in););*/
+            ariles2::apply<typename t_Visitor::Reader>(
+                    getReaderInitializer("configurable_match_simple.cfg"), configurable_in);
 
             // -------
 
diff --git a/tests/api_v2/types/any.h b/tests/api_v2/types/any.h
index 91a8752c..c15dcdab 100644
--- a/tests/api_v2/types/any.h
+++ b/tests/api_v2/types/any.h
@@ -180,6 +180,59 @@ namespace ariles_tests
     };
 
 
+    template <template <class> class t_Pointer, class t_Instantiator>
+    class CommonAny2 : public ariles2::Any2<t_Pointer, Base, t_Instantiator>
+    {
+    public:
+#ifndef ARILES_TESTS_RANDOMIZE_DISABLED
+        void randomize()
+        {
+            boost::random::random_device random_generator;
+            BOOST_CHECK(not this->isInitialized());
+
+            this->id_ = "test";
+            BOOST_CHECK(not this->isInitialized());
+
+            BOOST_CHECK_THROW(this->build("test"), std::exception);
+
+            BOOST_CHECK_NO_THROW(this->build("Derived1"));
+            BOOST_CHECK(this->isInitialized());
+
+            BOOST_CHECK(nullptr != this->template cast<Derived1>());
+            BOOST_CHECK(nullptr != this->template cast<Derived1>("Derived1"));
+            BOOST_CHECK(nullptr == this->template cast<Derived1>("Derived2"));
+
+            double test = 0.0;
+
+            this->operator->()->real_ = 10.0;
+            test = this->operator->()->real_;
+            BOOST_CHECK_EQUAL(test, 10.0);
+
+            this->operator*().real_ = 10.0;
+            test = this->operator*().real_;
+            BOOST_CHECK_EQUAL(test, 10.0);
+
+            this->template cast<Derived1>()->real1_ = 10.0;
+            test = this->template cast<Derived1>()->real1_;
+            BOOST_CHECK_EQUAL(test, 10.0);
+
+
+            test = GET_RANDOM_REAL;
+            if (test > 0.0)
+            {
+                this->build("Derived1");
+            }
+            else
+            {
+                this->build("Derived2");
+            }
+
+            this->value_->randomize();
+        }
+#endif
+    };
+
+
 #ifdef ARILES_ADAPTER_BOOST_POINTER
     class BoostPtrInstantiator
     {
@@ -226,17 +279,21 @@ namespace ariles_tests
 #define ARILES2_ENTRIES_0(v)
 
         CommonAny<std::shared_ptr, StdPtrInstantiator> std_any_;
+        CommonAny2<std::shared_ptr, StdPtrInstantiator> std_any2_;
 
 #define ARILES2_ENTRIES_1(v)                                                                                           \
     ARILES2_ENTRIES_0(v)                                                                                               \
-    ARILES2_ENTRY_(v, std_any)
+    ARILES2_ENTRY_(v, std_any)                                                                                         \
+    ARILES2_ENTRY_(v, std_any2)
 
 
 #ifdef ARILES_ADAPTER_BOOST_POINTER
         CommonAny<boost::shared_ptr, BoostPtrInstantiator> boost_any_;
+        CommonAny2<boost::shared_ptr, BoostPtrInstantiator> boost_any2_;
 #    define ARILES2_ENTRIES_2(v)                                                                                       \
         ARILES2_ENTRIES_1(v)                                                                                           \
-        ARILES2_ENTRY_(v, boost_any)
+        ARILES2_ENTRY_(v, boost_any)                                                                                   \
+        ARILES2_ENTRY_(v, boost_any2)
 #else
 #    define ARILES2_ENTRIES_2(v) ARILES2_ENTRIES_1(v)
 #endif
@@ -261,9 +318,11 @@ namespace ariles_tests
         {
             boost::random::random_device random_generator;
             std_any_.randomize();
+            std_any2_.randomize();
 
 #    ifdef ARILES_ADAPTER_BOOST_POINTER
             boost_any_.randomize();
+            boost_any2_.randomize();
 #    endif
         }
 #endif
@@ -272,63 +331,47 @@ namespace ariles_tests
 
 #ifndef ARILES_TESTS_COMPARE_DISABLED
     template <class t_Configurable_out, class t_Configurable_in>
-    void compare(const t_Configurable_out &configurable_out, const t_Configurable_in &configurable_in)
+    void compare_any(const t_Configurable_out &configurable_out, const t_Configurable_in &configurable_in)
     {
-        BOOST_CHECK_EQUAL(configurable_out.std_any_.id_, configurable_in.std_any_.id_);
-        BOOST_CHECK_CLOSE((*configurable_out.std_any_).real_, (*configurable_in.std_any_).real_, g_tolerance);
-        if ("Derived1" == configurable_out.std_any_.id_)
+        BOOST_CHECK_EQUAL(configurable_out.id_, configurable_in.id_);
+        BOOST_CHECK_CLOSE((*configurable_out).real_, (*configurable_in).real_, g_tolerance);
+        if ("Derived1" == configurable_out.id_)
         {
             BOOST_CHECK_CLOSE(
-                    configurable_out.std_any_.template cast<Derived1>()->real1_,
-                    configurable_in.std_any_.template cast<Derived1>()->real1_,
+                    configurable_out.template cast<Derived1>()->real1_,
+                    configurable_in.template cast<Derived1>()->real1_,
                     g_tolerance);
             BOOST_CHECK_CLOSE(
-                    configurable_out.std_any_.template cast<Derived1>("Derived1")->real1_,
-                    configurable_in.std_any_.template cast<Derived1>("Derived1")->real1_,
+                    configurable_out.template cast<Derived1>("Derived1")->real1_,
+                    configurable_in.template cast<Derived1>("Derived1")->real1_,
                     g_tolerance);
         }
-        if ("Derived2" == configurable_out.std_any_.id_)
+        if ("Derived2" == configurable_out.id_)
         {
             BOOST_CHECK_CLOSE(
-                    configurable_out.std_any_.template cast<Derived2>()->real2_,
-                    configurable_in.std_any_.template cast<Derived2>()->real2_,
+                    configurable_out.template cast<Derived2>()->real2_,
+                    configurable_in.template cast<Derived2>()->real2_,
                     g_tolerance);
             BOOST_CHECK_CLOSE(
-                    configurable_out.std_any_.template cast<Derived2>("Derived2")->real2_,
-                    configurable_in.std_any_.template cast<Derived2>("Derived2")->real2_,
+                    configurable_out.template cast<Derived2>("Derived2")->real2_,
+                    configurable_in.template cast<Derived2>("Derived2")->real2_,
                     g_tolerance);
         }
-        BOOST_CHECK(configurable_in.std_any_->defaults_check_flag_);
-        BOOST_CHECK(configurable_in.std_any_->finalize_check_flag_);
+        BOOST_CHECK(configurable_in->defaults_check_flag_);
+        BOOST_CHECK(configurable_in->finalize_check_flag_);
+    }
+
+
+    template <class t_Configurable_out, class t_Configurable_in>
+    void compare(const t_Configurable_out &configurable_out, const t_Configurable_in &configurable_in)
+    {
+        compare_any(configurable_out.std_any_, configurable_in.std_any_);
+        compare_any(configurable_out.std_any2_, configurable_in.std_any2_);
 
 
 #    ifdef ARILES_ADAPTER_BOOST_POINTER
-        BOOST_CHECK_EQUAL(configurable_out.boost_any_.id_, configurable_in.boost_any_.id_);
-        BOOST_CHECK_CLOSE((*configurable_out.boost_any_).real_, (*configurable_in.boost_any_).real_, g_tolerance);
-        if ("Derived1" == configurable_out.boost_any_.id_)
-        {
-            BOOST_CHECK_CLOSE(
-                    configurable_out.boost_any_.template cast<Derived1>()->real1_,
-                    configurable_in.boost_any_.template cast<Derived1>()->real1_,
-                    g_tolerance);
-            BOOST_CHECK_CLOSE(
-                    configurable_out.boost_any_.template cast<Derived1>("Derived1")->real1_,
-                    configurable_in.boost_any_.template cast<Derived1>("Derived1")->real1_,
-                    g_tolerance);
-        }
-        if ("Derived2" == configurable_out.boost_any_.id_)
-        {
-            BOOST_CHECK_CLOSE(
-                    configurable_out.boost_any_.template cast<Derived2>()->real2_,
-                    configurable_in.boost_any_.template cast<Derived2>()->real2_,
-                    g_tolerance);
-            BOOST_CHECK_CLOSE(
-                    configurable_out.boost_any_.template cast<Derived2>("Derived2")->real2_,
-                    configurable_in.boost_any_.template cast<Derived2>("Derived2")->real2_,
-                    g_tolerance);
-        }
-        BOOST_CHECK(configurable_in.boost_any_->defaults_check_flag_);
-        BOOST_CHECK(configurable_in.boost_any_->finalize_check_flag_);
+        compare_any(configurable_out.boost_any_, configurable_in.boost_any_);
+        compare_any(configurable_out.boost_any2_, configurable_in.boost_any2_);
 #    endif
     }
 #endif
diff --git a/tests/api_v2/types/complex_base.h b/tests/api_v2/types/complex_base.h
index 446c83f2..0b3cde4e 100644
--- a/tests/api_v2/types/complex_base.h
+++ b/tests/api_v2/types/complex_base.h
@@ -51,7 +51,7 @@ namespace ariles_tests
                 impl->std_vector_[i] = i * 5.22 + 2.3;
             }
 
-            impl->std_vector_bool_ = {false, false, true, false};
+            impl->std_vector_bool_ = { false, false, true, false };
 
             impl->std_nested_vector_.resize(3);
             for (std::size_t i = 0; i < impl->std_nested_vector_.size(); ++i)
@@ -133,7 +133,7 @@ namespace ariles_tests
                 impl->std_vector_[i] = GET_RANDOM_REAL;
             }
 
-            impl->std_vector_bool_ = {false, true, false};
+            impl->std_vector_bool_ = { false, true, false };
 
             impl->std_nested_vector_.resize(3);
             for (std::size_t i = 0; i < impl->std_nested_vector_.size(); ++i)