Adding ParsePlatformProfileMap and refactored code to use it

Author: Neko-Box-Coder

Include/runcpp2/Data/ProfilesFlagsOverride.hpp

@@ -16,6 +16,8 @@ namespace runcpp2
                 std::unordered_map<ProfileName, FlagsOverrideInfo> FlagsOverrides;
 
                 bool ParseYAML_Node(ryml::ConstNodeRef node);
+                bool ParseYAML_NodeWithProfile(ryml::ConstNodeRef node, ProfileName profile);
+                bool IsYAML_NodeParsableAsDefault(ryml::ConstNodeRef node) const;
                 std::string ToString(std::string indentation) const;
                 bool Equals(const ProfilesFlagsOverride& other) const;
         };

Include/runcpp2/ParseUtil.hpp

@@ -2,8 +2,11 @@
 #define RUNCPP2_PARSE_UTIL_HPP
 
 #include "runcpp2/YamlLib.hpp"
+#include "runcpp2/Data/ParseCommon.hpp"
+#include "ssLogger/ssLog.hpp"
 
 #include <vector>
+#include <unordered_map>
 
 namespace runcpp2
 {
@@ -44,6 +47,48 @@ namespace runcpp2
     std::string GetEscapedYAMLString(const std::string& input);
 
     bool ParseIncludes(const std::string& line, std::string& outIncludePath);
+
+    template<typename T>
+    bool ParsePlatformProfileMap(   ryml::ConstNodeRef node, 
+                                    const std::string& key,
+                                    std::unordered_map<PlatformName, T>& result,
+                                    const std::string& errorMessage)
+    {
+        if(ExistAndHasChild(node, key))
+        {
+            ryml::ConstNodeRef mapNode = node[key.c_str()];
+            
+            //If we skip platform profile
+            T defaultValue;
+            if(defaultValue.IsYAML_NodeParsableAsDefault(mapNode))
+            {
+                if(defaultValue.ParseYAML_NodeWithProfile(mapNode, "DefaultProfile"))
+                    result["DefaultPlatform"] = defaultValue;
+                else
+                    return false;
+            }
+            else
+            {
+                if(!CheckNodeRequirement(mapNode, key, ryml::NodeType_e::MAP, false, true))
+                    return false;
+                
+                for(int i = 0; i < mapNode.num_children(); ++i)
+                {
+                    PlatformName platform = GetKey(mapNode[i]);
+                    T value;
+                    ryml::ConstNodeRef currentNode = mapNode[i];
+                    
+                    if(!value.ParseYAML_Node(currentNode))
+                    {
+                        ssLOG_ERROR("ScriptInfo: Failed to parse " << errorMessage);
+                        return false;
+                    }
+                    result[platform] = value;
+                }
+            }
+        }
+        return true;
+    }
 }
 
 #endif

Src/runcpp2/Data/ProfilesFlagsOverride.cpp

@@ -15,31 +15,54 @@ bool runcpp2::Data::ProfilesFlagsOverride::ParseYAML_Node(ryml::ConstNodeRef nod
 
     for(int i = 0; i < node.num_children(); ++i)
     {
-        if(!INTERNAL_RUNCPP2_BIT_CONTANTS(node[i].type().type, ryml::NodeType_e::MAP))
-        {
-            ssLOG_ERROR("ProfilesFlagsOverrides: FlagsOverrideInfo type requires a map");
-            return false;
-        }
-        
         ProfileName profile = GetKey(node[i]);
-        FlagsOverrideInfo flags;
-        
-        ryml::ConstNodeRef flagsOverrideNode = node[i];
-        
-        if(!flags.ParseYAML_Node(flagsOverrideNode))
-        {
-            ssLOG_ERROR("ProfilesFlagsOverrides: Unable to parse FlagsOverride.");
+        if(!ParseYAML_NodeWithProfile(node[i], profile))
             return false;
-        }
-        
-        FlagsOverrides[profile] = flags;
     }
 
     return true;
 
     INTERNAL_RUNCPP2_SAFE_CATCH_RETURN(false);
 }
 
+bool runcpp2::Data::ProfilesFlagsOverride::ParseYAML_NodeWithProfile(   ryml::ConstNodeRef node, 
+                                                                        ProfileName profile)
+{
+    ssLOG_FUNC_DEBUG();
+    INTERNAL_RUNCPP2_SAFE_START();
+    
+    if(!INTERNAL_RUNCPP2_BIT_CONTANTS(node.type().type, ryml::NodeType_e::MAP))
+    {
+        ssLOG_ERROR("ProfilesFlagsOverrides: FlagsOverrideInfo type requires a map");
+        return false;
+    }
+    
+    FlagsOverrideInfo flags;
+    ryml::ConstNodeRef flagsOverrideNode = node;
+    
+    if(!flags.ParseYAML_Node(flagsOverrideNode))
+    {
+        ssLOG_ERROR("ProfilesFlagsOverrides: Unable to parse FlagsOverride.");
+        return false;
+    }
+    
+    FlagsOverrides[profile] = flags;
+    
+    return true;
+    INTERNAL_RUNCPP2_SAFE_CATCH_RETURN(false);
+}
+
+bool runcpp2::Data::ProfilesFlagsOverride::IsYAML_NodeParsableAsDefault(ryml::ConstNodeRef node) const
+{
+    ssLOG_FUNC_DEBUG();
+    INTERNAL_RUNCPP2_SAFE_START();
+
+    FlagsOverrideInfo flags;
+    return flags.IsYAML_NodeParsableAsDefault(node);
+    
+    INTERNAL_RUNCPP2_SAFE_CATCH_RETURN(false);
+}
+
 std::string runcpp2::Data::ProfilesFlagsOverride::ToString(std::string indentation) const
 {
     std::string out;