[memory][scs][parser] Don't generate arcs from sc-element classes

Author: NikitaZotov

sc-memory/sc-memory/CMakeLists.txt

@@ -57,6 +57,7 @@ add_dependencies(sc-memory
 )
 
 if(${SC_CLANG_FORMAT_CODE})
+    target_clangformat_setup(SCsParser)
     target_clangformat_setup(sc-memory)
 endif()
 

sc-memory/sc-memory/include/sc-memory/scs/scs_parser.hpp

@@ -44,6 +44,7 @@ class ParsedElement
   _SC_EXTERN ScType const & GetType() const;
 
   _SC_EXTERN Visibility GetVisibility() const;
+  _SC_EXTERN bool IsMetaElement() const;
 
   _SC_EXTERN std::string const & GetValue() const;
 
@@ -60,18 +61,21 @@ class ParsedElement
   bool m_isReversed : 1;    // flag used just for an connectors
   std::string m_value;      // string representation of content/link value
   bool m_isURL : 1;         // flag used to determine if ScLink value is an URL
+  bool m_isMetaElement;
 };
 
 class ElementHandle
 {
 public:
   _SC_EXTERN explicit ElementHandle(ElementID id);
   _SC_EXTERN ElementHandle();
-  _SC_EXTERN ElementHandle(ElementID id, bool isLocal);
+  _SC_EXTERN ElementHandle(ElementID id, Visibility visibility, bool isMetaElement = false);
   _SC_EXTERN ElementHandle(ElementHandle const & other) = default;
 
   _SC_EXTERN ElementID operator*() const;
+  _SC_EXTERN Visibility GetVisibility() const;
   _SC_EXTERN bool IsLocal() const;
+  _SC_EXTERN bool IsMetaElement() const;
   _SC_EXTERN bool IsValid() const;
   _SC_EXTERN bool operator==(ElementHandle const & other) const;
   _SC_EXTERN bool operator!=(ElementHandle const & other) const;
@@ -82,7 +86,8 @@ class ElementHandle
   static const ElementID INVALID_ID = std::numeric_limits<ElementID>::max();
 
   ElementID m_id;
-  bool m_isLocal;
+  Visibility m_visibility;
+  bool m_isMetaElement;
 };
 
 struct ParsedTriple
@@ -115,7 +120,7 @@ class Parser
   _SC_EXTERN Parser();
 
   _SC_EXTERN bool Parse(std::string const & str);
-  _SC_EXTERN ParsedElement const & GetParsedElement(ElementHandle const & elID) const;
+  _SC_EXTERN ParsedElement const & GetParsedElement(ElementHandle const & handle) const;
   _SC_EXTERN TripleVector const & GetParsedTriples() const;
   _SC_EXTERN std::string const & GetParseError() const;
   _SC_EXTERN AliasHandles const & GetAliases() const;
@@ -124,13 +129,21 @@ class Parser
   void ForEachParsedElement(TFunc && fn) const
   {
     for (auto const & el : m_parsedElementsLocal)
+    {
+      if (el.IsMetaElement())
+        continue;
       fn(el);
+    }
     for (auto const & el : m_parsedElements)
+    {
+      if (el.IsMetaElement())
+        continue;
       fn(el);
+    }
   }
 
 protected:
-  ParsedElement & GetParsedElementRef(ElementHandle const & elID);
+  ParsedElement & GetParsedElementRef(ElementHandle const & handle);
 
   ElementHandle ResolveAlias(std::string const & name);
   ElementHandle ProcessIdentifier(std::string const & name);
@@ -144,10 +157,12 @@ class Parser
   void ProcessContourBegin();
   void ProcessContourEnd(ElementHandle const & contourHandle);
 
-  void ProcessTriple(ElementHandle const & source, ElementHandle const & connector, ElementHandle const & target);
+  void ProcessTriple(ElementHandle const & sourceHandle, ElementHandle const & connectorHandle, ElementHandle const & targetHandle);
   void ProcessAssign(std::string const & alias, ElementHandle const & value);
 
 private:
+  ParsedElementVector & GetContainerByElementVisibilityRef(Visibility visibility);
+  ParsedElementVector const & GetContainerByElementVisibility(Visibility visibility) const;
   ElementHandle AppendElement(
       std::string idtf,
       ScType const & type = ScType::Unknown,

sc-memory/sc-memory/src/sc_scs_helper.cpp

@@ -44,34 +44,39 @@ class StructGenerator
 
     // generate triples
     auto const & triples = parser.GetParsedTriples();
+    std::unordered_set<std::string> typeArcsCache;
     for (auto const & t : triples)
     {
-      auto const & src = parser.GetParsedElement(t.m_source);
+      auto const & source = parser.GetParsedElement(t.m_source);
       auto const & connector = parser.GetParsedElement(t.m_connector);
-      auto const & trg = parser.GetParsedElement(t.m_target);
+      auto const & target = parser.GetParsedElement(t.m_target);
 
-      auto const & srcAddrResult = ResolveElement(src);
-      auto const & trgAddrResult = ResolveElement(trg);
+      auto const & sourceResult = ResolveElement(source);
+      auto const & targetResult = ResolveElement(target);
 
-      if (!connector.GetType().IsConnector())
-        SC_THROW_EXCEPTION(utils::ExceptionInvalidType, "Specified sc-connector in triple has incorrect type.");
+      ScType const & connectorType = connector.GetType();
+      std::string const & connectorIdtf = connector.GetIdtf();
+      if (!connectorType.IsConnector())
+        SC_THROW_EXCEPTION(
+            utils::ExceptionInvalidType,
+            "Specified in triple sc-connector `" << connectorIdtf << "` has incorrect type `"
+                                                 << std::string(connectorType) << "`.");
 
-      ScAddr const arcAddr = m_ctx.GenerateConnector(connector.GetType(), srcAddrResult.first, trgAddrResult.first);
-      m_idtfCache.insert({connector.GetIdtf(), arcAddr});
+      ScAddr const arcAddr = m_ctx.GenerateConnector(connectorType, sourceResult.first, targetResult.first);
+      m_idtfCache.insert({connectorIdtf, arcAddr});
 
       if (m_outputStructure.IsValid())
       {
-        AppendToOutputStructure(srcAddrResult.first, arcAddr, trgAddrResult.first);
-        AppendToOutputStructure(srcAddrResult.second);
-        AppendToOutputStructure(trgAddrResult.second);
+        AppendToOutputStructure(sourceResult.first, arcAddr, sourceResult.first);
+        AppendToOutputStructure(sourceResult.second);
+        AppendToOutputStructure(targetResult.second);
       }
     }
 
     parser.ForEachParsedElement(
         [this](scs::ParsedElement const & el)
         {
-          if (m_idtfCache.find(el.GetIdtf()) == m_idtfCache.end() && !el.GetType().IsConnector()
-              && !scs::TypeResolver::IsKeynodeType(el.GetIdtf()))
+          if (m_idtfCache.find(el.GetIdtf()) == m_idtfCache.cend() && !el.GetType().IsConnector())
             ResolveElement(el);
         });
   }
@@ -167,7 +172,9 @@ class StructGenerator
             resultAddr = m_ctx.GenerateNode(type);
         }
         else
-          SC_THROW_EXCEPTION(utils::ExceptionInvalidState, "Incorrect element type at this state.");
+          SC_THROW_EXCEPTION(
+              utils::ExceptionInvalidState,
+              "Incorrect element type `" << std::string(type) << "` for element `" << el.GetIdtf() << "`.");
 
         // setup system identifier
         if (el.GetVisibility() == scs::Visibility::System)
@@ -177,9 +184,7 @@ class StructGenerator
           result = {quintuple.addr2, quintuple.addr3, quintuple.addr4, quintuple.addr5};
         }
         else if (el.GetVisibility() == scs::Visibility::Global)
-        {
           result = SetSCsGlobalIdtf(el.GetIdtf(), resultAddr);
-        }
       }
       else
       {
@@ -190,12 +195,15 @@ class StructGenerator
           if (oldType.CanExtendTo(newType))
             m_ctx.SetElementSubtype(resultAddr, newType);
           else if (!newType.CanExtendTo(oldType))
-            SC_THROW_EXCEPTION(utils::ExceptionInvalidType, "Duplicate element type for " + el.GetIdtf());
+            SC_THROW_EXCEPTION(
+                utils::ExceptionInvalidType,
+                "Can't extend type `" << std::string(oldType) << "` to type `" << std::string(newType)
+                                      << "` for element `" << el.GetIdtf() << "`.");
         }
       }
 
       // anyway save in cache
-      m_idtfCache.insert(std::make_pair(idtf, resultAddr));
+      m_idtfCache.insert({idtf, resultAddr});
     }
 
     return {resultAddr, result};