[Update] expected classes to be inline with SysML.ecore version 2302-02 release

Author: samatrhea

SysML2.NET.CodeGenerator.Tests/Expected/AutGenPoco/AnnotatingElement.cs

@@ -32,9 +32,9 @@ namespace SysML2.NET.Core.POCO
 
     /// <summary>
     /// An AnnotatingElement is an Element that provides additional description of or metadata on some other
-    /// Element. An AnnotatingElement is attached to its annotatedElement by an Annotation
-    /// Relationship.annotatedElement =  if annotation->notEmpty() then annotation.annotatedElement else
-    /// owningNamespace endif
+    /// Element. An AnnotatingElement is either attached to its annotatedElements by Annotation
+    /// Relationships, or it implicitly annotates its owningNamespace.annotatedElement =  if
+    /// annotation->notEmpty() then annotation.annotatedElement else Sequence{owningNamespace} endif
     /// </summary>
     public partial class AnnotatingElement : IAnnotatingElement
     {

SysML2.NET.CodeGenerator.Tests/Expected/AutGenPoco/Connector.cs

@@ -32,20 +32,20 @@ namespace SysML2.NET.Core.POCO
 
     /// <summary>
     /// A Connector is a usage of Associations, with links restricted according to instances of the Type in
-    /// which they are used (domain of the Connector). Associations restrict what kinds of things might be
-    /// linked. The Connector further restricts these links to between values of two Features on instances
-    /// of its domain.relatedFeature =
-    /// connectorEnd.ownedReferenceSubsetting.subsettedFeaturerelatedFeature->forAll(f |     if
-    /// featuringType->isEmpty() then f.isFeaturedWithin(null)    else featuringType->exists(t |
-    /// f.isFeaturedWithin(t))    endif)sourceFeature =     if relatedFeature->size() = 2 then
-    /// relatedFeature->at(1)     else null     endiftargetFeature =    if sourceFeature = null then
-    /// relatedFeature    else relatedFeature->excluding(sourceFeature)    endifconnectorEnd =
-    /// feature->select(isEnd)not isAbstract implies relatedFeature->size() >=
-    /// 2specializesFromLibrary("Links::links")connectorEnd->size() = 2 implies   
-    /// specializesFromLibrary('Links::binaryLinks')association->exists(oclIsKindOf(AssociationStructure))
+    /// which they are used (domain of the Connector). The associations of the Connector restrict what kinds
+    /// of things might be linked. The Connector further restricts these links to be between values of
+    /// Features on instances of its domain.relatedFeature = connectorEnd.ownedReferenceSubsetting->   
+    /// select(s | s <> null).subsettedFeaturerelatedFeature->forAll(f |     if featuringType->isEmpty()
+    /// then f.isFeaturedWithin(null)    else featuringType->exists(t | f.isFeaturedWithin(t))   
+    /// endif)sourceFeature =     if relatedFeature->isEmpty() then null     else relatedFeature->first()   
+    ///  endiftargetFeature =    if relatedFeature->size() < 2 then OrderedSet{}    else        
+    /// relatedFeature->            subSequence(2, relatedFeature->size())->            asOrderedSet()   
+    /// endifnot isAbstract implies relatedFeature->size() >=
+    /// 2specializesFromLibrary("Links::links")association->exists(oclIsKindOf(AssociationStructure))
     /// implies    specializesFromLibrary("Objects::linkObjects")connectorEnds->size() = 2
     /// andassociation->exists(oclIsKindOf(AssocationStructure)) implies   
-    /// specializesFromLibrary("Objects::binaryLinkObjects")connectorEnds->size() > 2 implies    not
+    /// specializesFromLibrary("Objects::binaryLinkObjects")connectorEnd->size() = 2 implies   
+    /// specializesFromLibrary("Links::binaryLinks")connectorEnds->size() > 2 implies    not
     /// specializesFromLibrary("Links::BinaryLink")
     /// </summary>
     public partial class Connector : IConnector
@@ -147,7 +147,8 @@ public List<Feature> QueryDirectedFeature()
         }
 
         /// <summary>
-        /// Determines how values of this Feature are determined or used (see FeatureDirectionKind).
+        /// Indicates how values of this Feature are determined or used (as specified for the
+        /// FeatureDirectionKind).
         /// </summary>
         [EFeature(isChangeable: true, isVolatile: false, isTransient: false, isUnsettable: false, isDerived: false, isOrdered: false, isUnique: true, lowerBound: 0, upperBound: 1, isMany: false, isRequired: false, isContainment: false)]
         public FeatureDirectionKind? Direction { get; set; }
@@ -267,7 +268,7 @@ public List<Type> QueryIntersectingType()
 
         /// <summary>
         /// Whether the Feature is a composite feature of its featuringType. If so, the values of the Feature
-        /// cannot exist after the instance of the featuringType no longer does.
+        /// cannot exist after its featuring instance no longer does.
         /// </summary>
         [EFeature(isChangeable: true, isVolatile: false, isTransient: false, isUnsettable: false, isDerived: false, isOrdered: false, isUnique: true, lowerBound: 1, upperBound: 1, isMany: false, isRequired: false, isContainment: false)]
         public bool IsComposite { get; set; }
@@ -282,22 +283,22 @@ public bool QueryIsConjugated()
         }
 
         /// <summary>
-        /// Whether the values of this Feature can always be computed from the values of other Features.
+        /// Whether the values of this Feature can always be computed from the values of other Feature.
         /// </summary>
         [EFeature(isChangeable: true, isVolatile: false, isTransient: false, isUnsettable: false, isDerived: false, isOrdered: false, isUnique: true, lowerBound: 1, upperBound: 1, isMany: false, isRequired: false, isContainment: false)]
         public bool IsDerived { get; set; }
 
         /// <summary>
         /// For a binary Connector, whether or not the Connector should be considered to have a direction from
-        /// source to target.
+        /// sourceFeature to targetFeature.
         /// </summary>
         [EFeature(isChangeable: true, isVolatile: false, isTransient: false, isUnsettable: false, isDerived: false, isOrdered: false, isUnique: true, lowerBound: 1, upperBound: 1, isMany: false, isRequired: false, isContainment: false)]
         public bool IsDirected { get; set; }
 
         /// <summary>
         /// Whether or not the this Feature is an end Feature, requiring a different interpretation of the
-        /// multiplicity of the Feature.An end Feature is always considered to map each domain entity to a
-        /// single co-domain entity, whether or not a Multiplicity is given for it. If a Multiplicity is given
+        /// multiplicity of the Feature.An end Feature is always considered to map each domain instance to a
+        /// single co-domain instance, whether or not a Multiplicity is given for it. If a Multiplicity is given
         /// for an end Feature, rather than giving the co-domain cardinality for the Feature as usual, it
         /// specifies a cardinality constraint for navigating across the endFeatures of the featuringType of the
         /// end Feature. That is, if a Type has n endFeatures, then the Multiplicity of any one of those end
@@ -349,8 +350,8 @@ public bool QueryIsNonunique()
         public bool IsOrdered { get; set; }
 
         /// <summary>
-        /// Whether the values of this Feature are contained in the space and time of instances of the
-        /// Feature&#39;s domain.
+        /// Whether the values of this Feature are contained in the space and time of instances of the domain of
+        /// the Feature and represent the same thing as those instances.
         /// </summary>
         [EFeature(isChangeable: true, isVolatile: false, isTransient: false, isUnsettable: false, isDerived: false, isOrdered: false, isUnique: true, lowerBound: 1, upperBound: 1, isMany: false, isRequired: false, isContainment: false)]
         public bool IsPortion { get; set; }
@@ -366,7 +367,7 @@ public bool QueryIsNonunique()
         /// Type.(A Type gives conditions that must be met by whatever it classifies, but when isSufficient
         /// is false, things may meet those conditions but still not be classified by the Type. For example, a
         /// Type Car that is not sufficient could require everything it classifies to have four wheels, but not
-        /// all four wheeled things would need to be cars. However, if the type Car were sufficient, it would
+        /// all four wheeled things would classify as cars. However, if the Type Car were sufficient, it would
         /// classify all four-wheeled things.)
         /// </summary>
         [EFeature(isChangeable: true, isVolatile: false, isTransient: false, isUnsettable: false, isDerived: false, isOrdered: false, isUnique: true, lowerBound: 1, upperBound: 1, isMany: false, isRequired: false, isContainment: false)]