[template] Arguments substititation, class arguments checking, arguments in params duplication

docs/changelog.md

@@ -21,6 +21,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Add always generating for conclusion in implication
 
 ### Fixed
+- Check all var classes for argument
+- Arguments in params for different params duplication
 - Fixed applying rules chain
 
 ### Changed

problem-solver/cxx/inferenceModule/manager/TemplateManager.cpp

@@ -23,72 +23,86 @@ std::vector<ScTemplateParams> TemplateManager::createTemplateParams(
     ScAddrVector const & argumentList)
 {
   std::map<std::string, std::set<ScAddr, AddrComparator>> replacementsMultimap;
-  std::vector<ScTemplateParams> templateParamsVector;
 
   ScIterator3Ptr varIterator = context->Iterator3(scTemplate, ScType::EdgeAccessConstPosPerm, ScType::NodeVar);
   while (varIterator->Next())
   {
     ScAddr var = varIterator->Get(2);
     std::string varName = context->HelperGetSystemIdtf(var);
-    if (!replacementsMultimap[varName].empty())
-    {
-      continue;
-    }
     ScAddr argumentOfVar;
-    ScIterator5Ptr classesIterator = context->Iterator5(
-        ScType::NodeConstClass, ScType::EdgeAccessVarPosPerm, var, ScType::EdgeAccessConstPosPerm, scTemplate);
-    while (classesIterator->Next())
+    for (ScAddr const & argument : argumentList)
     {
-      ScAddr varClass = classesIterator->Get(0);
-      for (ScAddr const & argument : argumentList)  // this block is executed if inputStructure is valid
+      ScIterator5Ptr const & classesIterator = context->Iterator5(
+          ScType::NodeConstClass, ScType::EdgeAccessVarPosPerm, var, ScType::EdgeAccessConstPosPerm, scTemplate);
+      bool isBelong = false;
+      while (classesIterator->Next())
       {
+        ScAddr varClass = classesIterator->Get(0);
         if (context->HelperCheckEdge(varClass, argument, ScType::EdgeAccessConstPosPerm))
-          replacementsMultimap[varName].insert(argument);
+        {
+          isBelong = true;
+        }
+        else
+        {
+          isBelong = false;
+          break;
+        }
       }
-      if (argumentList.empty())  // this block is executed if inputStructure is not valid
+
+      if (isBelong)
       {
-        ScIterator3Ptr iterator3 = context->Iterator3(varClass, ScType::EdgeAccessConstPosPerm, ScType::Unknown);
-        while (iterator3->Next())
-          replacementsMultimap[varName].insert(iterator3->Get(2));
+        replacementsMultimap[varName].insert(argument);
       }
     }
-    if (templateParamsVector.empty())
+  }
+
+  std::vector<std::map<std::string, ScAddr>> paramsVector;
+  paramsVector.reserve(replacementsMultimap.size());
+  for (auto const & pair : replacementsMultimap)
+  {
+    std::vector<std::map<std::string, ScAddr>> newParamsVector;
+    newParamsVector.reserve(replacementsMultimap.size());
+    for (auto const & addr : pair.second)
     {
-      std::set<ScAddr, AddrComparator> addresses = replacementsMultimap[varName];
-      templateParamsVector.reserve(replacementsMultimap[varName].size());
-      for (ScAddr const & address : addresses)
+      bool isUploaded = false;
+      for (auto map : paramsVector)
       {
-        ScTemplateParams params;
-        params.Add(varName, address);
-        templateParamsVector.push_back(params);
-      }
-    }
-    else
-    {
-      std::set<ScAddr, AddrComparator> addresses = replacementsMultimap[varName];
-      size_t amountOfAddressesForVar = addresses.size();
-      size_t oldParamsSize = templateParamsVector.size();
+        bool isDuplicatedValue = false;
+        for (auto const & mapPair : map)
+        {
+          if (mapPair.second == addr)
+          {
+            isDuplicatedValue = true;
+          }
+        }
 
-      if (amountOfAddressesForVar == 0)
-        continue;
+        if (!isDuplicatedValue)
+        {
+          map.insert({ pair.first, addr });
+          newParamsVector.emplace_back(map);
+        }
 
-      size_t amountOfNewElements = oldParamsSize * amountOfAddressesForVar;
-      std::vector<ScTemplateParams> updatedParams;
-      updatedParams.reserve(amountOfNewElements);
+        isUploaded = true;
+      }
 
-      size_t beginOfCopy = 0;
-      size_t endOfCopy = oldParamsSize;
-      for (ScAddr const & address : addresses)
+      if (!isUploaded)
       {
-        copy_n(templateParamsVector.begin(), oldParamsSize, back_inserter(updatedParams));
-        for (size_t i = 0; i < oldParamsSize; ++i)
-          updatedParams[beginOfCopy + i].Add(varName, address);
-        beginOfCopy = endOfCopy;
-        endOfCopy += oldParamsSize;
+        std::map<std::string, ScAddr> map{{ pair.first, addr }};
+        newParamsVector.emplace_back(map);
       }
+    }
+    paramsVector = newParamsVector;
+  }
 
-      templateParamsVector = std::move(updatedParams);
+  std::vector<ScTemplateParams> templateParamsVector;
+  for (auto const & params : paramsVector)
+  {
+    ScTemplateParams templateParams;
+    for (auto const & param : params)
+    {
+      templateParams.Add(param.first, param.second);
     }
+    templateParamsVector.emplace_back(templateParams);
   }
 
   return templateParamsVector;

problem-solver/cxx/inferenceModule/test/testStructures/TemplateSearchModule/searchWithContentEqualResultTestStucture.scs

@@ -0,0 +1,31 @@
+@template = [*
+    _hum1
+    _=> nrel_father::
+        _hum2;;
+
+    _hum3
+    _=> nrel_father::
+        _hum2;;
+
+    concept_human
+    _-> _hum1;
+    _-> _hum3;;
+*];;
+@template
+	=> nrel_system_identifier: [search_template];;
+
+human_ivan_ivanov
+<- concept_human;
+=> nrel_father:
+    human_andrey_ivanov;;
+
+human_pavel_ivanov
+<- concept_human;
+=> nrel_father:
+    human_andrey_ivanov;;
+
+human_andrey_ivanov
+<- concept_human;;
+
+sc_node_class
+-> concept_human;;

problem-solver/cxx/inferenceModule/test/units/TestTemplateSearchModule.cpp

@@ -103,6 +103,32 @@ TEST_F(TemplateSearchManagerTest, SearchWithContent_MultipleResultTestCase)
       searchResults[0][searchLinkIdentifier] == context.HelperFindBySystemIdtf(secondCorrectResultLinkIdentifier));
 }
 
+TEST_F(TemplateSearchManagerTest, SearchWithContent_EqualResultTestCase)
+{
+  std::string firstHuman = "human_ivan_ivanov";
+  std::string secondHuman = "human_pavel_ivanov";
+  std::string varHumanName1 = "_hum1";
+  std::string varHumanName3 = "_hum3";
+
+  ScMemoryContext & context = *m_ctx;
+
+  loader.loadScsFile(context, TEST_FILES_DIR_PATH + "searchWithContentEqualResultTestStucture.scs");
+  initialize();
+
+  ScAddr searchTemplateAddr = context.HelperFindBySystemIdtf(TEST_SEARCH_TEMPLATE_ID);
+  inference::TemplateSearcher templateSearcher = inference::TemplateSearcher(&context);
+  ScTemplateParams templateParams;
+  std::vector<ScTemplateSearchResultItem> searchResults =
+      templateSearcher.searchTemplate(searchTemplateAddr, templateParams);
+
+  EXPECT_EQ(searchResults.size(), 1);
+  EXPECT_TRUE(searchResults[0][varHumanName1] == context.HelperFindBySystemIdtf(firstHuman) ||
+              searchResults[0][varHumanName1] == context.HelperFindBySystemIdtf(secondHuman));
+  EXPECT_TRUE(searchResults[0][varHumanName3] == context.HelperFindBySystemIdtf(firstHuman) ||
+              searchResults[0][varHumanName3] == context.HelperFindBySystemIdtf(secondHuman));
+  EXPECT_FALSE(searchResults[0][varHumanName1] == searchResults[0][varHumanName3]);
+}
+
 TEST_F(TemplateSearchManagerTest, SearchWithoutContent_NoStructuresTestCase)
 {
   ScMemoryContext & context = *m_ctx;