sysml-validate 0.11.0 → 0.14.3

package/resources/sysml.library/Systems Library/Items.sysml

@@ -1,153 +1,153 @@
-standard library package Items {
-	doc
-	/*
-	 * This package defines the base types for items and related structural elements in the
-	 * SysML language.
-	 */
-
-	private import Objects::Object;
-	private import Objects::objects;
-	private import Parts::Part;
-	private import Parts::parts;
-	private import Occurrences::HappensWhile;
-	private import Occurrences::JustOutsideOf;
-	private import Objects::StructuredSpaceObject;
-	private import Constraints::ConstraintCheck;
-	private import Constraints::constraintChecks;
-	private import CollectionFunctions::contains;
-	private import SequenceFunctions::isEmpty;
-	private import SequenceFunctions::notEmpty;
-	private import SequenceFunctions::includes;
-	private import SequenceFunctions::union;
-	private import ControlFunctions::forAll;
-	
-	abstract item def Item :> Object {
-		doc
-		/*
-		 * Item is the most general class of objects that are part of, exist in or flow through a system. 
-		 * Item is the base type of all ItemDefinitions.
-		 */
-	
-		ref self: Item :>> Object::self;
-		
-		item start: Item :>> startShot;
-		item done: Item :>> endShot;
-		
-		item shape : Item :>> spaceBoundary {
-		doc
-			/*
-			 * The shape of an Item is its spatial boundary.
-			 */
-		}
-		
-		item envelopingShapes : Item[0..*] {
-            doc
-			/*
-			 * Each enveloping shape is the shape of an Item that spacially overlaps this Item for its
-			 * entire lifetime.
-			 */
-			 
-			ref item envelopedItem :>> that;	
-
-			assert constraint { 
-                doc
-                /* 
-                 * Enables two dimensional items to be enveloped by two or three dimensional shapes.
-                 */             
-			    innerSpaceDimension == 
-    				(if envelopedItem.innerSpaceDimension == 3  | envelopedItem.outerSpaceDimension == 3? 2 
-    				else envelopedItem.outerSpaceDimension - 1)
-			}
-			assert constraint { (that as Item).innerSpaceDimension < 3 implies notEmpty(outerSpaceDimension) }
-
-			item envelopingItem [1];
-
-			assert constraint {
-				doc
-				/* 
-				 * This constraint prevents an envelopingShape from being a portion.
-				 */
-				 
-				envelopingItem.shape.spaceTimeCoincidentOccurrences->includes(that) and
-				envelopingItem.spaceTimeEnclosedOccurrences->includes(that.that) 
-			}
-		}
-		
-		item boundingShapes : StructuredSpaceObject [0..*] :> envelopingShapes {
-            doc
-			/*
-			 * envelopingShapes that are structured space objects with every face or every edge
-			 * intersecting this Item.
-			 */		
-            
-			ref item boundingShape: Item :>> self;
-
-			private item :>> faces {
-				ref item face :>> self;
-				item inter [1];
-				assert constraint { contains(inter.intersectionsOf, union(face, boundingShape)) }
-			}
-			private item :>> edges {
-				ref item edge :>> self;
-				item inter [1];
-				assert constraint { isEmpty(faces) implies
-							contains(inter.intersectionsOf, union(edge, boundingShape)) }
-			}
-		}
-
-		item voids :>> innerSpaceOccurrences [0..*] {
-			doc
-			/*
-			 * Voids are inner space occurrences of this Item.
-			 */
-		}
-
-		attribute isSolid = isEmpty(voids) {
-			doc
-			/*
-			 * An Item is solid if it has no voids.
-			 */
-		}
-		
-		abstract item subitems: Item[0..*] :> items, subobjects {
-			doc
-			/*
-			 * The Items that are composite subitems of this Item.
-			 */
-			 
-			private ref redefines Item::incomingTransferSort, subobjects::incomingTransferSort;
-		}
-		
-		abstract part subparts: Part[0..*] :> subitems, parts {
-			doc
-			/*
-			 * The subitems of this Item that are Parts.
-			 */
-		}
-		
-		abstract constraint checkedConstraints: ConstraintCheck[0..*] :> constraintChecks, ownedPerformances {
-			doc
-			/*
-			 * Constraints that have been checked by this Item.
-			 */
-		}
-	}
-	
-	connection def Touches :> JustOutsideOf, HappensWhile {
-		doc
-		/*
-		 * Touching items are just outside each other and happen at the same time.
-		 */
-	
-		end touchesToo [0..*] item touchedItemToo :>> separateSpaceToo, thisOccurrence;
-		end touches [0..*] item touchedItem :>> separateSpace, thatOccurrence;
-	}
-
-	abstract item items : Item[0..*] nonunique :> objects {
-		doc
-		/*
-		 * items is the base feature of all ItemUsages.
-		 */
-	}
-	
+standard library package Items {
+	doc
+	/*
+	 * This package defines the base types for items and related structural elements in the
+	 * SysML language.
+	 */
+
+	private import Objects::Object;
+	private import Objects::objects;
+	private import Parts::Part;
+	private import Parts::parts;
+	private import Occurrences::HappensWhile;
+	private import Occurrences::JustOutsideOf;
+	private import Objects::StructuredSpaceObject;
+	private import Constraints::ConstraintCheck;
+	private import Constraints::constraintChecks;
+	private import CollectionFunctions::contains;
+	private import SequenceFunctions::isEmpty;
+	private import SequenceFunctions::notEmpty;
+	private import SequenceFunctions::includes;
+	private import SequenceFunctions::union;
+	private import ControlFunctions::forAll;
+	
+	abstract item def Item :> Object {
+		doc
+		/*
+		 * Item is the most general class of objects that are part of, exist in or flow through a system. 
+		 * Item is the base type of all ItemDefinitions.
+		 */
+	
+		ref self: Item :>> Object::self;
+		
+		item start: Item :>> startShot;
+		item done: Item :>> endShot;
+		
+		item shape : Item :>> spaceBoundary {
+		doc
+			/*
+			 * The shape of an Item is its spatial boundary.
+			 */
+		}
+		
+		item envelopingShapes : Item[0..*] {
+            doc
+			/*
+			 * Each enveloping shape is the shape of an Item that spacially overlaps this Item for its
+			 * entire lifetime.
+			 */
+			 
+			ref item envelopedItem :>> that;	
+
+			assert constraint { 
+                doc
+                /* 
+                 * Enables two dimensional items to be enveloped by two or three dimensional shapes.
+                 */             
+			    innerSpaceDimension == 
+    				(if envelopedItem.innerSpaceDimension == 3  | envelopedItem.outerSpaceDimension == 3? 2 
+    				else envelopedItem.outerSpaceDimension - 1)
+			}
+			assert constraint { (that as Item).innerSpaceDimension < 3 implies notEmpty(outerSpaceDimension) }
+
+			item envelopingItem [1];
+
+			assert constraint {
+				doc
+				/* 
+				 * This constraint prevents an envelopingShape from being a portion.
+				 */
+				 
+				envelopingItem.shape.spaceTimeCoincidentOccurrences->includes(that) and
+				envelopingItem.spaceTimeEnclosedOccurrences->includes(that.that) 
+			}
+		}
+		
+		item boundingShapes : StructuredSpaceObject [0..*] :> envelopingShapes {
+            doc
+			/*
+			 * envelopingShapes that are structured space objects with every face or every edge
+			 * intersecting this Item.
+			 */		
+            
+			ref item boundingShape: Item :>> self;
+
+			private item :>> faces {
+				ref item face :>> self;
+				item inter [1];
+				assert constraint { contains(inter.intersectionsOf, union(face, boundingShape)) }
+			}
+			private item :>> edges {
+				ref item edge :>> self;
+				item inter [1];
+				assert constraint { isEmpty(faces) implies
+							contains(inter.intersectionsOf, union(edge, boundingShape)) }
+			}
+		}
+
+		item voids :>> innerSpaceOccurrences [0..*] {
+			doc
+			/*
+			 * Voids are inner space occurrences of this Item.
+			 */
+		}
+
+		attribute isSolid = isEmpty(voids) {
+			doc
+			/*
+			 * An Item is solid if it has no voids.
+			 */
+		}
+		
+		abstract item subitems: Item[0..*] :> items, subobjects {
+			doc
+			/*
+			 * The Items that are composite subitems of this Item.
+			 */
+			 
+			private ref redefines Item::incomingTransferSort, subobjects::incomingTransferSort;
+		}
+		
+		abstract part subparts: Part[0..*] :> subitems, parts {
+			doc
+			/*
+			 * The subitems of this Item that are Parts.
+			 */
+		}
+		
+		abstract constraint checkedConstraints: ConstraintCheck[0..*] :> constraintChecks, ownedPerformances {
+			doc
+			/*
+			 * Constraints that have been checked by this Item.
+			 */
+		}
+	}
+	
+	connection def Touches :> JustOutsideOf, HappensWhile {
+		doc
+		/*
+		 * Touching items are just outside each other and happen at the same time.
+		 */
+	
+		end touchesToo [0..*] item touchedItemToo :>> separateSpaceToo, thisOccurrence;
+		end touches [0..*] item touchedItem :>> separateSpace, thatOccurrence;
+	}
+
+	abstract item items : Item[0..*] nonunique :> objects {
+		doc
+		/*
+		 * items is the base feature of all ItemUsages.
+		 */
+	}
+	
 }

package/resources/sysml.library/Systems Library/Metadata.sysml

@@ -1,32 +1,32 @@
-standard library package Metadata {
-doc
-/*
- * This package defines the base types for metadata definitions and related 
- * metadata annotations in the SysML language.
- */
-
-	private import Metaobjects::Metaobject;
-	private import Metaobjects::metaobjects;
-	private import Items::Item;
-	private import Items::items;
-	
-	abstract metadata def MetadataItem :> Metaobject, Item {
-		doc
-		/*
-		 * MetadataItem is the most general class of Items that represent Metaobjects. 
-		 * MetadataItem is the base type of all MetadataDefinitions.
-		 */
-		 
-		 ref self : MetadataItem redefines Metaobject::self, Item::self;
-	}
-	
-	abstract item metadataItems : MetadataItem[0..*] :> metaobjects, items {
-		doc
-		/*
-		 * metadataItems is the base feature of all MetadataUsages.
-		 * 
-		 * Note: It is not itself a MetadataUsage, because it is not being used as an
-		 * AnnotatingElement here.
-		 */
-	}
+standard library package Metadata {
+doc
+/*
+ * This package defines the base types for metadata definitions and related 
+ * metadata annotations in the SysML language.
+ */
+
+	private import Metaobjects::Metaobject;
+	private import Metaobjects::metaobjects;
+	private import Items::Item;
+	private import Items::items;
+	
+	abstract metadata def MetadataItem :> Metaobject, Item {
+		doc
+		/*
+		 * MetadataItem is the most general class of Items that represent Metaobjects. 
+		 * MetadataItem is the base type of all MetadataDefinitions.
+		 */
+		 
+		 ref self : MetadataItem redefines Metaobject::self, Item::self;
+	}
+	
+	abstract item metadataItems : MetadataItem[0..*] :> metaobjects, items {
+		doc
+		/*
+		 * metadataItems is the base feature of all MetadataUsages.
+		 * 
+		 * Note: It is not itself a MetadataUsage, because it is not being used as an
+		 * AnnotatingElement here.
+		 */
+	}
 }

package/resources/sysml.library/Systems Library/Parts.sysml

@@ -1,81 +1,81 @@
-standard library package Parts {
-doc
-/*
- * This package defines the base types for parts and related structural elements in the
- * SysML language.
- */
-
-	private import Objects::Object;
-	private import Objects::objects;
-	private import Items::Item;
-	private import Items::items;
-	private import Ports::Port;
-	private import Ports::ports;
-	private import Actions::Action;
-	private import Actions::actions;
-	private import States::StateAction;
-	private import States::stateActions;
-	
-	abstract part def Part :> Item {
-		doc
-		/*
-		 * Part is the most general class of objects that represent all or a part of a system.
-		 * Part is the base type of all PartDefinitions.
-		 */
-	
-		ref self: Part :>> Item::self;
-		
-		part start: Part :>> Item::start;
-		part done: Part :>> Item::done;
-		
-		abstract port ownedPorts: Port[0..*] :> ports, timeEnclosedOccurrences {
-			doc
-			/*
-			 * Ports that are owned by this Part.
-			 */
-		}
-		
-		abstract ref action performedActions: Action[0..*] :> actions, enactedPerformances {
-			doc
-			/*
-			 * Actions that are performed by this Part.
-			 */
-		}
-		
-		abstract action ownedActions: Action[0..*] :> actions, ownedPerformances {
-			doc
-			/*
-			 * Actions that are owned by this Part.
-			 */
-		
-		 	ref part this : Part :>> Action::this, ownedPerformances::this = that as Part {
-				doc
-				/*
-				 * The "this" reference of an ownedAction is always its owning Part.
-				 */
-			}
-		}
-		
-		abstract ref state exhibitedStates: StateAction[0..*] :> stateActions, performedActions {
-			doc
-			/*
-			 * StateActions that are exhibited by this Part.
-			 */
-		}
-		
-		abstract state ownedStates: StateAction[0..*] :> stateActions, ownedActions {
-			doc
-			/*
-			 * StateActions that are owned by this Part.
-			 */
-		}
-	}
-	
-	abstract part parts: Part[0..*] nonunique :> items {
-		doc
-		/*
-		 * parts is the base feature of all part properties.
-		 */
-	}
-	
+standard library package Parts {
+doc
+/*
+ * This package defines the base types for parts and related structural elements in the
+ * SysML language.
+ */
+
+	private import Objects::Object;
+	private import Objects::objects;
+	private import Items::Item;
+	private import Items::items;
+	private import Ports::Port;
+	private import Ports::ports;
+	private import Actions::Action;
+	private import Actions::actions;
+	private import States::StateAction;
+	private import States::stateActions;
+	
+	abstract part def Part :> Item {
+		doc
+		/*
+		 * Part is the most general class of objects that represent all or a part of a system.
+		 * Part is the base type of all PartDefinitions.
+		 */
+	
+		ref self: Part :>> Item::self;
+		
+		part start: Part :>> Item::start;
+		part done: Part :>> Item::done;
+		
+		abstract port ownedPorts: Port[0..*] :> ports, timeEnclosedOccurrences {
+			doc
+			/*
+			 * Ports that are owned by this Part.
+			 */
+		}
+		
+		abstract ref action performedActions: Action[0..*] :> actions, enactedPerformances {
+			doc
+			/*
+			 * Actions that are performed by this Part.
+			 */
+		}
+		
+		abstract action ownedActions: Action[0..*] :> actions, ownedPerformances {
+			doc
+			/*
+			 * Actions that are owned by this Part.
+			 */
+		
+		 	ref part this : Part :>> Action::this, ownedPerformances::this = that as Part {
+				doc
+				/*
+				 * The "this" reference of an ownedAction is always its owning Part.
+				 */
+			}
+		}
+		
+		abstract ref state exhibitedStates: StateAction[0..*] :> stateActions, performedActions {
+			doc
+			/*
+			 * StateActions that are exhibited by this Part.
+			 */
+		}
+		
+		abstract state ownedStates: StateAction[0..*] :> stateActions, ownedActions {
+			doc
+			/*
+			 * StateActions that are owned by this Part.
+			 */
+		}
+	}
+	
+	abstract part parts: Part[0..*] nonunique :> items {
+		doc
+		/*
+		 * parts is the base feature of all part properties.
+		 */
+	}
+	
 }

package/resources/sysml.library/Systems Library/Ports.sysml

@@ -1,54 +1,54 @@
-standard library package Ports {
-    doc
-    /*
-     * This package defines the base types for ports and related structural elements 
-     * in the SysML language.
-     */
-
-    private import Objects::Object;
-    private import Objects::objects;
-    
-    abstract port def Port :> Object {
-        doc
-        /*
-         * Port is the most general class of objects that represent connection points
-         * for interacting with a Part. Port is the base type of all PortDefinitions.
-         * 
-         * Transfers outgoing from a Port are always targeted to a Port connected to
-         * the original Port by an Interface.
-         */
-    
-        ref self: Port :>> Object::self;
-        
-        port subports: Port [0..*] :> ports, timeEnclosedOccurrences {
-            doc
-            /*
-             * The Ports that are subports of this Port.
-             */
-        }
-        
-        abstract ref port interfacingPorts : Port[0..*] nonunique :> ports {
-            doc
-            /*
-             * Ports that are connected to this Port by an Interface.
-             */
-        }
-        
-        ref :>> outgoingTransfersFromSelf :> interfacingPorts.incomingTransfersToSelf {
-            doc
-            /* 
-             * The target of each of the outgoingTransfersFromSelf of a Port must be an interfacingPort.
-             */
-             
-             end ref source;
-             end ref target;
-        }
-    }
-    
-    abstract port ports : Port[0..*] nonunique :> objects {
-        doc
-        /*
-         * ports is the base feature of all PortUsages.
-         */
-    }
+standard library package Ports {
+    doc
+    /*
+     * This package defines the base types for ports and related structural elements 
+     * in the SysML language.
+     */
+
+    private import Objects::Object;
+    private import Objects::objects;
+    
+    abstract port def Port :> Object {
+        doc
+        /*
+         * Port is the most general class of objects that represent connection points
+         * for interacting with a Part. Port is the base type of all PortDefinitions.
+         * 
+         * Transfers outgoing from a Port are always targeted to a Port connected to
+         * the original Port by an Interface.
+         */
+    
+        ref self: Port :>> Object::self;
+        
+        port subports: Port [0..*] :> ports, timeEnclosedOccurrences {
+            doc
+            /*
+             * The Ports that are subports of this Port.
+             */
+        }
+        
+        abstract ref port interfacingPorts : Port[0..*] nonunique :> ports {
+            doc
+            /*
+             * Ports that are connected to this Port by an Interface.
+             */
+        }
+        
+        ref :>> outgoingTransfersFromSelf :> interfacingPorts.incomingTransfersToSelf {
+            doc
+            /* 
+             * The target of each of the outgoingTransfersFromSelf of a Port must be an interfacingPort.
+             */
+             
+             end ref source;
+             end ref target;
+        }
+    }
+    
+    abstract port ports : Port[0..*] nonunique :> objects {
+        doc
+        /*
+         * ports is the base feature of all PortUsages.
+         */
+    }
 }