[WIP] ix FeatureMembershipTextualNotationBuilder

antoineatstariongroup · antoineatstariongroup · commit a312e317a5c3 · 2026-03-05T17:18:54.000+01:00
diff --git a/SysML2.NET.CodeGenerator/HandleBarHelpers/RulesHelper.cs b/SysML2.NET.CodeGenerator/HandleBarHelpers/RulesHelper.cs
@@ -93,7 +93,7 @@ private static void ProcessAlternatives(EncodedTextWriter writer, IClass umlClas
                 var elements = alternative.Elements;
                 DeclareAllRequiredIterators(writer, umlClass, alternative, ruleGenerationContext);
                 
-                if (ruleGenerationContext.CallerRule is { IsOptional: true, IsCollection: false })
+                if (ruleGenerationContext.CallerContext?.CallerRule is { IsOptional: true, IsCollection: false })
                 {
                     var targetPropertiesName = elements.OfType<AssignmentElement>().Select(x => x.Property).Distinct().ToList();
                     var allProperties = umlClass.QueryAllProperties();
@@ -127,9 +127,9 @@ private static void ProcessAlternatives(EncodedTextWriter writer, IClass umlClas
 
                         foreach (var textualRuleElement in elements)
                         {
-                            var previousCaller = ruleGenerationContext.CallerRule;
+                            var previousCaller = ruleGenerationContext.CallerContext;
                             ProcessRuleElement(writer, umlClass, textualRuleElement, ruleGenerationContext);
-                            ruleGenerationContext.CallerRule = previousCaller;
+                            ruleGenerationContext.CallerContext = previousCaller;
                         }
                     }
                     else
@@ -150,9 +150,9 @@ private static void ProcessAlternatives(EncodedTextWriter writer, IClass umlClas
                 {
                     foreach (var textualRuleElement in elements)
                     {
-                        var previousCaller = ruleGenerationContext.CallerRule;
+                        var previousCaller = ruleGenerationContext.CallerContext;
                         ProcessRuleElement(writer, umlClass, textualRuleElement, ruleGenerationContext);
-                        ruleGenerationContext.CallerRule = previousCaller;
+                        ruleGenerationContext.CallerContext = previousCaller;
                     }    
                 }
             }
@@ -215,11 +215,18 @@ private static void ProcessRuleElement(EncodedTextWriter writer, IClass umlClass
                     writer.WriteSafeString($"stringBuilder.Append(\"{valueToAdd}\");");
                     break;
                 case NonTerminalElement nonTerminalElement:
-                    ProcessNonTerminalElement(writer, umlClass, nonTerminalElement, "poco", umlClass, ruleGenerationContext);
+                    if (ruleGenerationContext.CallerContext?.CallerRule is NonTerminalElement callerNonTerminalElement && callerNonTerminalElement.Container is AssignmentElement)
+                    {
+                        ProcessNonTerminalElement(writer, umlClass, nonTerminalElement, "poco", ruleGenerationContext.CallerContext.CallerClassContext, ruleGenerationContext);
+                    }
+                    else
+                    {
+                        ProcessNonTerminalElement(writer, umlClass, nonTerminalElement, "poco", umlClass, ruleGenerationContext);
+                    }
 
                     break;
                 case GroupElement groupElement:
-                    ruleGenerationContext.CallerRule = groupElement;
+                    ruleGenerationContext.CallerContext = new CallerContext(groupElement);
                     
                     if (groupElement.IsCollection)
                     {
@@ -304,10 +311,10 @@ private static void ProcessRuleElement(EncodedTextWriter writer, IClass umlClass
                                 {
                                     if (assignmentElement.Value is NonTerminalElement nonTerminalElement)
                                     {
-                                        var previousCaller = ruleGenerationContext.CallerRule;
-                                        ruleGenerationContext.CallerRule = nonTerminalElement;
+                                        var previousCaller = ruleGenerationContext.CallerContext;
+                                        ruleGenerationContext.CallerContext = new CallerContext(nonTerminalElement);
                                         ProcessNonTerminalElement(writer, targetProperty.Type as IClass, nonTerminalElement, $"poco.{targetProperty.QueryPropertyNameBasedOnUmlProperties()}", umlClass, ruleGenerationContext);
-                                        ruleGenerationContext.CallerRule = previousCaller;
+                                        ruleGenerationContext.CallerContext = previousCaller;
                                     }
                                     else
                                     {
@@ -385,18 +392,18 @@ private static void ProcessNonTerminalElement(EncodedTextWriter writer, IClass u
                     }
                     else
                     {
-                        var previousCaller = ruleGenerationContext.CallerRule;
-                        ruleGenerationContext.CallerRule = nonTerminalElement;
-                        ProcessAlternatives(writer, umlClass, referencedRule?.Alternatives, ruleGenerationContext);
-                        ruleGenerationContext.CallerRule = previousCaller;
+                        var previousCaller = ruleGenerationContext.CallerContext;
+                        ruleGenerationContext.CallerContext = new CallerContext(nonTerminalElement, targetType as  IClass);
+                        ProcessAlternatives(writer, callerClass, referencedRule?.Alternatives, ruleGenerationContext);
+                        ruleGenerationContext.CallerContext = previousCaller;
                     }
                 }
                 else
                 {
-                    var previousCaller = ruleGenerationContext.CallerRule;
-                    ruleGenerationContext.CallerRule = nonTerminalElement;
-                    ProcessAlternatives(writer, umlClass, referencedRule?.Alternatives, ruleGenerationContext);
-                    ruleGenerationContext.CallerRule = previousCaller;
+                    var previousCaller = ruleGenerationContext.CallerContext;
+                    ruleGenerationContext.CallerContext = new CallerContext(nonTerminalElement);
+                    ProcessAlternatives(writer, callerClass, referencedRule?.Alternatives, ruleGenerationContext);
+                    ruleGenerationContext.CallerContext = previousCaller;
                 }
             }
             else
@@ -552,6 +559,29 @@ public bool IsIteratorValidForProperty(IProperty property, TextualNotationRule t
             }
         }
 
+        /// <summary>
+        /// Provide context about the caller context 
+        /// </summary>
+        private class CallerContext
+        {
+            /// <summary>Initializes a new instance of the <see cref="CallerContext" /> class.</summary>
+            public CallerContext(RuleElement callerRule, IClass callerClassContext = null)
+            {
+                this.CallerRule = callerRule;
+                this.CallerClassContext = callerClassContext;
+            }
+
+            /// <summary>
+            /// Gets or sets the <see cref="RuleElement"/> that called other rule
+            /// </summary>
+            public RuleElement CallerRule { get; }
+
+            /// <summary>
+            /// Gets or sets the <see cref="IClass"/> used during the caller rule
+            /// </summary>
+            public IClass CallerClassContext { get; }
+        }
+
         /// <summary>
         /// Provides context over the rule generation history
         /// </summary>
@@ -563,14 +593,14 @@ private class RuleGenerationContext
             public List<IteratorDefinition> DefinedIterators { get; set; }
 
             /// <summary>
-            /// Gets or sets the <see cref="RuleElement"/> that called other rule
+            /// Gets the collection of all available <see cref="TextualNotationRule"/>
             /// </summary>
-            public RuleElement CallerRule { get; set; }
+            public List<TextualNotationRule> AllRules { get; } = [];
 
             /// <summary>
-            /// Gets the collection of all available <see cref="TextualNotationRule"/>
+            /// Gets or sets the <see cref="CallerContext"/>
             /// </summary>
-            public List<TextualNotationRule> AllRules { get; } = [];
+            public CallerContext CallerContext { get; set; }
         }
     }
 }
diff --git a/SysML2.NET/TextualNotation/AutoGenTextualNotationBuilder/FeatureMembershipTextualNotationBuilder.cs b/SysML2.NET/TextualNotation/AutoGenTextualNotationBuilder/FeatureMembershipTextualNotationBuilder.cs
@@ -379,9 +379,21 @@ public static void BuildMetadataBodyUsageMember(SysML2.NET.Core.POCO.Core.Types.
                 {
                     RedefinitionTextualNotationBuilder.BuildOwnedRedefinition(ownedRelationshipOfRedefinitionIterator.Current, stringBuilder);
                 }
-                BuildFeatureSpecializationPart(poco, stringBuilder);
-                BuildValuePart(poco, stringBuilder);
-                TypeTextualNotationBuilder.BuildMetadataBody(poco, stringBuilder);
+                throw new System.NotSupportedException("Multiple alternatives not implemented yet");
+                using var ownedRelationshipOfFeatureValueIterator = poco.OwnedRelationship.OfType<SysML2.NET.Core.POCO.Kernel.FeatureValues.FeatureValue>().GetEnumerator();
+
+                if (ownedRelationshipOfFeatureValueIterator.MoveNext())
+                {
+                    ownedRelationshipOfFeatureValueIterator.MoveNext();
+
+                    if (ownedRelationshipOfFeatureValueIterator.Current != null)
+                    {
+                        FeatureValueTextualNotationBuilder.BuildFeatureValue(ownedRelationshipOfFeatureValueIterator.Current, stringBuilder);
+                    }
+                    stringBuilder.Append(' ');
+                }
+
+                throw new System.NotSupportedException("Multiple alternatives not implemented yet");
 
             }
 
@@ -503,7 +515,25 @@ public static void BuildExpressionBodyMember(SysML2.NET.Core.POCO.Core.Types.IFe
             if (poco.ownedMemberFeature != null)
             {
                 stringBuilder.Append("{");
-                TypeTextualNotationBuilder.BuildFunctionBodyPart(poco, stringBuilder);
+                using var ownedRelationshipOfReturnParameterMembershipIterator = poco.OwnedRelationship.OfType<SysML2.NET.Core.POCO.Kernel.Functions.ReturnParameterMembership>().GetEnumerator();
+                using var ownedRelationshipOfResultExpressionMembershipIterator = poco.OwnedRelationship.OfType<SysML2.NET.Core.POCO.Kernel.Functions.ResultExpressionMembership>().GetEnumerator();
+
+                while (ownedRelationshipOfReturnParameterMembershipIterator.MoveNext())
+                {
+                    throw new System.NotSupportedException("Multiple alternatives not implemented yet");
+                }
+
+                if (ownedRelationshipOfResultExpressionMembershipIterator.MoveNext())
+                {
+
+                    if (ownedRelationshipOfResultExpressionMembershipIterator.Current != null)
+                    {
+                        ResultExpressionMembershipTextualNotationBuilder.BuildResultExpressionMember(ownedRelationshipOfResultExpressionMembershipIterator.Current, stringBuilder);
+                    }
+                    stringBuilder.Append(' ');
+                }
+
+
                 stringBuilder.Append("}");
 
             }

Original file line number	Diff line number	Diff line change
`@@ -93,7 +93,7 @@ private static void ProcessAlternatives(EncodedTextWriter writer, IClass umlClas`
`93`	`93`	`var elements = alternative.Elements;`
`94`	`94`	`DeclareAllRequiredIterators(writer, umlClass, alternative, ruleGenerationContext);`
`95`	`95`
`96`		`- if (ruleGenerationContext.CallerRule is { IsOptional: true, IsCollection: false })`
	`96`	`+ if (ruleGenerationContext.CallerContext?.CallerRule is { IsOptional: true, IsCollection: false })`
`97`	`97`	`{`
`98`	`98`	`var targetPropertiesName = elements.OfType<AssignmentElement>().Select(x => x.Property).Distinct().ToList();`
`99`	`99`	`var allProperties = umlClass.QueryAllProperties();`
`@@ -127,9 +127,9 @@ private static void ProcessAlternatives(EncodedTextWriter writer, IClass umlClas`
`127`	`127`
`128`	`128`	`foreach (var textualRuleElement in elements)`
`129`	`129`	`{`
`130`		`- var previousCaller = ruleGenerationContext.CallerRule;`
	`130`	`+ var previousCaller = ruleGenerationContext.CallerContext;`
`131`	`131`	`ProcessRuleElement(writer, umlClass, textualRuleElement, ruleGenerationContext);`
`132`		`- ruleGenerationContext.CallerRule = previousCaller;`
	`132`	`+ ruleGenerationContext.CallerContext = previousCaller;`
`133`	`133`	`}`
`134`	`134`	`}`
`135`	`135`	`else`
`@@ -150,9 +150,9 @@ private static void ProcessAlternatives(EncodedTextWriter writer, IClass umlClas`
`150`	`150`	`{`
`151`	`151`	`foreach (var textualRuleElement in elements)`
`152`	`152`	`{`
`153`		`- var previousCaller = ruleGenerationContext.CallerRule;`
	`153`	`+ var previousCaller = ruleGenerationContext.CallerContext;`
`154`	`154`	`ProcessRuleElement(writer, umlClass, textualRuleElement, ruleGenerationContext);`
`155`		`- ruleGenerationContext.CallerRule = previousCaller;`
	`155`	`+ ruleGenerationContext.CallerContext = previousCaller;`
`156`	`156`	`}`
`157`	`157`	`}`
`158`	`158`	`}`
`@@ -215,11 +215,18 @@ private static void ProcessRuleElement(EncodedTextWriter writer, IClass umlClass`
`215`	`215`	`writer.WriteSafeString($"stringBuilder.Append(\"{valueToAdd}\");");`
`216`	`216`	`break;`
`217`	`217`	`case NonTerminalElement nonTerminalElement:`
`218`		`- ProcessNonTerminalElement(writer, umlClass, nonTerminalElement, "poco", umlClass, ruleGenerationContext);`
	`218`	`+ if (ruleGenerationContext.CallerContext?.CallerRule is NonTerminalElement callerNonTerminalElement && callerNonTerminalElement.Container is AssignmentElement)`
	`219`	`+ {`
	`220`	`+ ProcessNonTerminalElement(writer, umlClass, nonTerminalElement, "poco", ruleGenerationContext.CallerContext.CallerClassContext, ruleGenerationContext);`
	`221`	`+ }`
	`222`	`+ else`
	`223`	`+ {`
	`224`	`+ ProcessNonTerminalElement(writer, umlClass, nonTerminalElement, "poco", umlClass, ruleGenerationContext);`
	`225`	`+ }`
`219`	`226`
`220`	`227`	`break;`
`221`	`228`	`case GroupElement groupElement:`
`222`		`- ruleGenerationContext.CallerRule = groupElement;`
	`229`	`+ ruleGenerationContext.CallerContext = new CallerContext(groupElement);`
`223`	`230`
`224`	`231`	`if (groupElement.IsCollection)`
`225`	`232`	`{`
`@@ -304,10 +311,10 @@ private static void ProcessRuleElement(EncodedTextWriter writer, IClass umlClass`
`304`	`311`	`{`
`305`	`312`	`if (assignmentElement.Value is NonTerminalElement nonTerminalElement)`
`306`	`313`	`{`
`307`		`- var previousCaller = ruleGenerationContext.CallerRule;`
`308`		`- ruleGenerationContext.CallerRule = nonTerminalElement;`
	`314`	`+ var previousCaller = ruleGenerationContext.CallerContext;`
	`315`	`+ ruleGenerationContext.CallerContext = new CallerContext(nonTerminalElement);`
`309`	`316`	`ProcessNonTerminalElement(writer, targetProperty.Type as IClass, nonTerminalElement, $"poco.{targetProperty.QueryPropertyNameBasedOnUmlProperties()}", umlClass, ruleGenerationContext);`
`310`		`- ruleGenerationContext.CallerRule = previousCaller;`
	`317`	`+ ruleGenerationContext.CallerContext = previousCaller;`
`311`	`318`	`}`
`312`	`319`	`else`
`313`	`320`	`{`
`@@ -385,18 +392,18 @@ private static void ProcessNonTerminalElement(EncodedTextWriter writer, IClass u`
`385`	`392`	`}`
`386`	`393`	`else`
`387`	`394`	`{`
`388`		`- var previousCaller = ruleGenerationContext.CallerRule;`
`389`		`- ruleGenerationContext.CallerRule = nonTerminalElement;`
`390`		`- ProcessAlternatives(writer, umlClass, referencedRule?.Alternatives, ruleGenerationContext);`
`391`		`- ruleGenerationContext.CallerRule = previousCaller;`
	`395`	`+ var previousCaller = ruleGenerationContext.CallerContext;`
	`396`	`+ ruleGenerationContext.CallerContext = new CallerContext(nonTerminalElement, targetType as IClass);`
	`397`	`+ ProcessAlternatives(writer, callerClass, referencedRule?.Alternatives, ruleGenerationContext);`
	`398`	`+ ruleGenerationContext.CallerContext = previousCaller;`
`392`	`399`	`}`
`393`	`400`	`}`
`394`	`401`	`else`
`395`	`402`	`{`
`396`		`- var previousCaller = ruleGenerationContext.CallerRule;`
`397`		`- ruleGenerationContext.CallerRule = nonTerminalElement;`
`398`		`- ProcessAlternatives(writer, umlClass, referencedRule?.Alternatives, ruleGenerationContext);`
`399`		`- ruleGenerationContext.CallerRule = previousCaller;`
	`403`	`+ var previousCaller = ruleGenerationContext.CallerContext;`
	`404`	`+ ruleGenerationContext.CallerContext = new CallerContext(nonTerminalElement);`
	`405`	`+ ProcessAlternatives(writer, callerClass, referencedRule?.Alternatives, ruleGenerationContext);`
	`406`	`+ ruleGenerationContext.CallerContext = previousCaller;`
`400`	`407`	`}`
`401`	`408`	`}`
`402`	`409`	`else`
`@@ -552,6 +559,29 @@ public bool IsIteratorValidForProperty(IProperty property, TextualNotationRule t`
`552`	`559`	`}`
`553`	`560`	`}`
`554`	`561`
	`562`	`+ /// <summary>`
	`563`	`+ /// Provide context about the caller context`
	`564`	`+ /// </summary>`
	`565`	`+ private class CallerContext`
	`566`	`+ {`
	`567`	`+ /// <summary>Initializes a new instance of the <see cref="CallerContext" /> class.</summary>`
	`568`	`+ public CallerContext(RuleElement callerRule, IClass callerClassContext = null)`
	`569`	`+ {`
	`570`	`+ this.CallerRule = callerRule;`
	`571`	`+ this.CallerClassContext = callerClassContext;`
	`572`	`+ }`
	`573`	`+`
	`574`	`+ /// <summary>`
	`575`	`+ /// Gets or sets the <see cref="RuleElement"/> that called other rule`
	`576`	`+ /// </summary>`
	`577`	`+ public RuleElement CallerRule { get; }`
	`578`	`+`
	`579`	`+ /// <summary>`
	`580`	`+ /// Gets or sets the <see cref="IClass"/> used during the caller rule`
	`581`	`+ /// </summary>`
	`582`	`+ public IClass CallerClassContext { get; }`
	`583`	`+ }`
	`584`	`+`
`555`	`585`	`/// <summary>`
`556`	`586`	`/// Provides context over the rule generation history`
`557`	`587`	`/// </summary>`
`@@ -563,14 +593,14 @@ private class RuleGenerationContext`
`563`	`593`	`public List<IteratorDefinition> DefinedIterators { get; set; }`
`564`	`594`
`565`	`595`	`/// <summary>`
`566`		`- /// Gets or sets the <see cref="RuleElement"/> that called other rule`
	`596`	`+ /// Gets the collection of all available <see cref="TextualNotationRule"/>`
`567`	`597`	`/// </summary>`
`568`		`- public RuleElement CallerRule { get; set; }`
	`598`	`+ public List<TextualNotationRule> AllRules { get; } = [];`
`569`	`599`
`570`	`600`	`/// <summary>`
`571`		`- /// Gets the collection of all available <see cref="TextualNotationRule"/>`
	`601`	`+ /// Gets or sets the <see cref="CallerContext"/>`
`572`	`602`	`/// </summary>`
`573`		`- public List<TextualNotationRule> AllRules { get; } = [];`
	`603`	`+ public CallerContext CallerContext { get; set; }`
`574`	`604`	`}`
`575`	`605`	`}`
`576`	`606`	`}`