[Core] Add methods to retrieve available sub-items and handle not found errors in Registry and RegistryItem

kratos/includes/registry.h

@@ -216,6 +216,17 @@ class KRATOS_API(KRATOS_CORE) Registry final
     ///@name Private Operations
     ///@{
 
+    /**
+     * @brief This method throws an error message for a not found item.
+     * @param rFullName The full name of the item.
+     * @param rItemName The name of the item.
+     * @param pCurrentItem The current item.
+     */
+    static void NotFoundError(
+        const std::string& rFullName,
+        const std::string& rItemName,
+        RegistryItem* pCurrentItem
+        );
 
     ///@}
     ///@name Private  Access

kratos/includes/registry_item.h

@@ -295,6 +295,16 @@ class KRATOS_API(KRATOS_CORE) RegistryItem
         return true;
     }
 
+    ///@}
+    ///@name Operations
+    ///@{
+
+    /**
+     * @brief Returns the sub items name list available in the registry item (for error messaged).
+     * @return std::vector<std::string> The sub items name list.
+     */
+    std::vector<std::string> GetSubItemAvailableList() const;
+
     ///@}
     ///@name Input and output
     ///@{
@@ -340,6 +350,12 @@ class KRATOS_API(KRATOS_CORE) RegistryItem
         return buffer.str();
     }
 
+    /**
+     * @brief This method throws an error message for a not found item.
+     * @param rItemName The name of the item.
+     */
+    void NotFoundError(const std::string& rItemName) const;
+
     ///@}
     ///@name Private classes
     ///@{

kratos/sources/registry.cpp

@@ -43,9 +43,8 @@ namespace
             auto& r_item_name = item_path[i];
             if(p_current_item->HasItem(r_item_name)){
                 p_current_item = &p_current_item->GetItem(r_item_name);
-            }
-            else{
-                KRATOS_ERROR << "The item \"" << rItemFullName << "\" is not found in the registry. The item \"" << p_current_item->Name() << "\" does not have \"" << r_item_name << "\"" << std::endl;
+            } else {
+                NotFoundError(rItemFullName, r_item_name, p_current_item);
             }
         }
 
@@ -65,18 +64,16 @@ namespace
             auto& r_item_name = item_path[i];
             if(p_current_item->HasItem(r_item_name)){
                 p_current_item = &p_current_item->GetItem(r_item_name);
-            }
-            else{
-                KRATOS_ERROR << "The item \"" << rItemFullName << "\" is not found in the registry. The item \"" << p_current_item->Name() << "\" does not have \"" << r_item_name << "\"" << std::endl;
+            } else {
+                NotFoundError(rItemFullName, r_item_name, p_current_item);
             }
         }
 
         auto& r_item_name = item_path.back();
         if(p_current_item->HasItem(r_item_name)){
             p_current_item->RemoveItem(r_item_name);
-        }
-        else{
-            KRATOS_ERROR << "The item \"" << rItemFullName << "\" is not found in the registry. The item \"" << p_current_item->Name() << "\" does not have \"" << r_item_name << "\"" << std::endl;
+        } else {
+            NotFoundError(rItemFullName, r_item_name, p_current_item);
         }
     }
 
@@ -158,6 +155,21 @@ namespace
         return GetRootRegistryItem().ToJson(Indentation);
     }
 
+    void Registry::NotFoundError(
+        const std::string& rFullName,
+        const std::string& rItemName,
+        RegistryItem* pCurrentItem
+        )
+    {
+        const std::vector<std::string> available_list = pCurrentItem->GetSubItemAvailableList();
+        std::stringstream error_message_buffer;
+        error_message_buffer << "The item \"" << rFullName << "\" is not found in the registry. The item \"" << pCurrentItem->Name() << "\" does not have \"" << rItemName << "\". The available objects are: \n";
+        for (std::string const& item : available_list) {
+            error_message_buffer << "\t\t" << item << "\n";
+        }
+        KRATOS_ERROR << error_message_buffer.str() << std::endl;
+    }
+
     RegistryItem& Registry::GetRootRegistryItem()
     {
         if (!mspRootRegistryItem) {

kratos/sources/registry_item.cpp

@@ -91,6 +91,29 @@ namespace Kratos
         }
     }
 
+    std::vector<std::string> RegistryItem::GetSubItemAvailableList() const
+    {
+        std::vector<std::string> available_list;
+        auto it_item_begin = this->cbegin();
+        auto it_item_end = this->cend();
+        available_list.reserve(std::distance(it_item_begin, it_item_end));
+        for (auto it_item = it_item_begin; it_item != it_item_end; ++it_item) {
+            available_list.push_back((it_item->second)->Name());
+        }
+        return available_list;
+    }
+
+    void RegistryItem::NotFoundError(const std::string& rItemName) const
+    {
+        const std::vector<std::string> available_list = GetSubItemAvailableList();
+        std::stringstream error_message_buffer;
+        error_message_buffer << "The RegistryItem " << this->Name() << " does not have an item with name " << rItemName << ". The available objects are: \n";
+        for (std::string const& item : available_list) {
+            error_message_buffer << "\t\t" << item << "\n";
+        }
+        KRATOS_ERROR << error_message_buffer.str() << std::endl;
+    }
+
     std::string RegistryItem::GetValueString() const
     {
         return (this->*(this->mGetValueStringMethod))();
@@ -163,23 +186,29 @@ namespace Kratos
     {
         SubRegistryItemType& r_map = GetSubRegistryItemMap();
         auto iterator = r_map.find(rItemName);
-        KRATOS_ERROR_IF(iterator == r_map.end()) << "The RegistryItem " << this->Name() << " does not have an item with name " << rItemName << std::endl;
+        if (iterator == r_map.end()) {
+            NotFoundError(rItemName);
+        }
         return *(iterator->second);
     }
 
     RegistryItem& RegistryItem::GetItem(std::string const& rItemName)
     {
         SubRegistryItemType& r_map = GetSubRegistryItemMap();
         auto iterator = r_map.find(rItemName);
-        KRATOS_ERROR_IF(iterator == r_map.end()) << "The RegistryItem " << this->Name() << " does not have an item with name " << rItemName << std::endl;
+        if (iterator == r_map.end()) {
+            NotFoundError(rItemName);
+        }
         return *(iterator->second);
     }
 
     void RegistryItem::RemoveItem(std::string const& rItemName)
     {
         SubRegistryItemType& r_map = GetSubRegistryItemMap();
         auto iterator = r_map.find(rItemName);
-        KRATOS_ERROR_IF(iterator == r_map.end()) << "The RegistryItem " << this->Name() << " does not have an item with name " << rItemName << std::endl;
+        if (iterator == r_map.end()) {
+            NotFoundError(rItemName);
+        }
         r_map.erase(iterator);
     }
 

kratos/tests/cpp_tests/sources/test_registry.cpp

@@ -21,9 +21,7 @@
 #include "includes/expect.h"
 #include "includes/registry.h"
 
-namespace Kratos {
-
-namespace Testing {
+namespace Kratos::Testing {
 
 namespace
 {
@@ -141,6 +139,7 @@ KRATOS_TEST_CASE_IN_SUITE(RegistrySubValue, KratosCoreFastSuite)
 
     registry_item.AddItem<double>("sub_value_item", value);
     auto& sub_item = registry_item.GetItem("sub_value_item");
+    KRATOS_EXPECT_EXCEPTION_IS_THROWN(registry_item.GetItem("sub_value_item_2"), "");
 
     KRATOS_EXPECT_EQ(sub_item.Name(),"sub_value_item");
     KRATOS_EXPECT_TRUE(sub_item.HasValue());
@@ -315,5 +314,4 @@ KRATOS_TEST_CASE_IN_SUITE(RegistryIsSameType, KratosCoreFastSuite) {
     KRATOS_EXPECT_FALSE(Registry::GetItem("variables.all.VELOCITY").IsSameType(test_double));
 }
 
-}
-}  // namespace Kratos.
+}  // namespace Kratos::Testing.

kratos/tests/cpp_tests/sources/test_registry_access.cpp

@@ -37,6 +37,8 @@ KRATOS_TEST_CASE_IN_SUITE(RegistryItemGetValueDerivedAsBase, KratosCoreFastSuite
     auto pProcess = Registry::GetValue<Process>("Processes.KratosMultiphysics.OutputProcess.Prototype");
 
     KRATOS_EXPECT_TRUE((std::is_same<Process,decltype(pProcess)>::value))
+
+    KRATOS_EXPECT_EXCEPTION_IS_THROWN(Registry::GetValue<Process>("Processes.KratosMultiphysics.output_process.Prototype"), "");
 }
 
 

kratos/tests/test_python_registry.py

@@ -12,6 +12,18 @@ def testHasItemCpp(self):
         # Check that base Process is registered in its corresponding module as well as in the All block
         self.assertTrue(KratosMultiphysics.Registry.HasItem("Processes.All.Process"))
         self.assertTrue(KratosMultiphysics.Registry.HasItem("Processes.KratosMultiphysics.Process"))
+        self.assertFalse(KratosMultiphysics.Registry.HasItem("Processes.KratosMultiphysics.ProcessPikachu"))
+
+    def testGetItemCpp(self):
+        # Check that base Process is registered in its corresponding module as well as in the All block
+        base_process = KratosMultiphysics.Registry["Processes.All.Process.Prototype"]
+        self.assertTrue(isinstance(base_process, KratosMultiphysics.Process))
+        base_process = KratosMultiphysics.Registry["Processes.KratosMultiphysics.Process.Prototype"]
+        self.assertTrue(isinstance(base_process, KratosMultiphysics.Process))
+
+    @KratosUnittest.expectedFailure
+    def testHasItemCppFail(self):
+        KratosMultiphysics.Registry["Processes.All.ProcessPikachu.Prototype"]
 
     def testHasItemPython(self):
         # Add a fake entity to the Python registry
@@ -39,7 +51,6 @@ def testNumberOfItems(self):
         # Remove the auxiliary testing tentities from the Python registry
         KratosMultiphysics.Registry.RemoveItem("FakeEntities")
 
-
     def testAddItem(self):
         # Add some fake entities to the Python registry
         KratosMultiphysics.Registry.AddItem("Processes.KratosMultiphysics.NewProcess1", KratosMultiphysics.Process())
@@ -217,4 +228,5 @@ def getA(self):
         KratosMultiphysics.Registry.RemoveItem("Processes")
 
 if __name__ == "__main__":
+    KratosMultiphysics.Logger.GetDefaultOutput().SetSeverity(KratosMultiphysics.Logger.Severity.WARNING)
     KratosUnittest.main()