sysmledgraph 0.7.0

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Systems Library/Cases.sysml

@@ -0,0 +1,71 @@
+standard library package Cases {
+	doc
+	/*
+	 * This package defines the base types for cases and related behavioral elements 
+	 * in the SysML language.
+	 */
+
+	private import Base::Anything;
+	private import Requirements::RequirementCheck;
+	private import Calculations::Calculation;
+	private import Calculations::calculations;
+	private import Parts::Part;
+	private import Parts::parts;
+	
+	abstract case def Case :> Calculation {
+		doc
+		/*
+		 * Case is the most general class of performances of CaseDefinitions. 
+		 * Case is the base class of all CaseDefinitions.
+		 */
+	
+		ref case self : Case :>> Calculation::self;
+		
+		subject subj : Anything[1] {
+			doc
+			/*
+			 * The subject that was investigated by this Case.
+			 */
+		}
+		
+		ref part actors : Part[0..*] :> parts {
+			doc
+			/*
+			 * The Parts that fill the role of actors for this Case.
+			 * (Note: This is not itself an actor parameter, because specific actor
+			 * parameters will be added for specific Cases.)
+			 */
+		}
+		
+		objective obj : RequirementCheck[1] {
+			doc
+			/*
+			 * A check of whether the objective RequirementUsage was satisfied for this Case.
+			 */
+		
+			subject subj default Case::result;
+		}
+		
+		return ref result[0..*] {
+			doc
+			/*
+			 * The result determined by the case, which should satisfy the case objective.
+			 */
+		}
+		
+		abstract case subcases : Case[0..*] :> cases, subcalculations {
+			doc
+			/*
+			 * Other Cases carried out as part of the performance of this Case.
+			 */
+		}
+	
+	}
+	
+	abstract case cases : Case[0..*] nonunique :> calculations {
+		doc
+		/*
+		 * cases is the base Feature of all CaseUsages.
+		 */
+	}
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Systems Library/Connections.sysml

@@ -0,0 +1,60 @@
+standard library package Connections {
+    doc
+    /*
+     * This package defines the base types for connections and related structural elements 
+     * in the SysML language.
+     */
+
+    private import Base::Anything;
+    private import Occurrences::Occurrence;
+    private import Occurrences::HappensDuring;
+    private import Objects::LinkObject;
+    private import Objects::linkObjects;
+    private import Objects::BinaryLinkObject;
+    private import Objects::binaryLinkObjects;
+    private import Transfers::Transfer;
+    private import Transfers::transfers;
+    private import Transfers::FlowTransfer;
+    private import Transfers::flowTransfers;
+    private import Transfers::FlowTransferBefore;
+    private import Transfers::flowTransfersBefore;
+    private import ScalarValues::Natural;
+    private import Parts::Part;
+    private import Parts::parts;
+    private import Actions::Action;
+    private import Actions::actions;
+
+    abstract connection def Connection :> LinkObject, Part {
+        doc
+        /*
+         * Connection is the most general class of links between things within some 
+         * containing structure. Connection is the base type of all ConnectionDefinitions.
+         */
+    }
+     
+    abstract connection def BinaryConnection :> BinaryLinkObject, Connection {
+        doc
+        /*
+         * BinaryConnection is the most general class of binary links between two things 
+         * within some containing structure. BinaryConnection is the base type of all 
+         * ConnectionDefinitions with exactly two ends.
+         */
+    
+        end source: Anything :>> BinaryLinkObject::source;
+        end target: Anything :>> BinaryLinkObject::target;
+    }
+    
+    abstract connection connections: Connection[0..*] nonunique :> linkObjects, parts {
+        doc
+        /*
+         * connections is the base feature of all ConnectionUsages.
+         */
+    }
+    
+    abstract connection binaryConnections: Connection[0..*] nonunique :> connections, binaryLinkObjects {
+        doc
+        /*
+         * binaryConnections is the base feature of all binary ConnectionUsages.
+         */
+    }
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Systems Library/Constraints.sysml

@@ -0,0 +1,44 @@
+standard library package Constraints {
+	doc
+	/*
+	 * This package defines the base types for constraints and related elements in the
+	 * SysML language.
+	 */
+
+	private import Performances::BooleanEvaluation;
+	private import Performances::booleanEvaluations;
+	private import Performances::trueEvaluations;
+	private import Performances::falseEvaluations;
+	
+	abstract constraint def ConstraintCheck :> BooleanEvaluation {
+		doc
+		/*
+		 * ConstraintCheck is the most general class for constraint checking. ConstraintCheck is the base
+		 * type of all ConstraintDefinitions.
+		 */
+	
+		ref constraint self: ConstraintCheck :>> BooleanEvaluation::self;
+	}
+	
+	abstract constraint constraintChecks: ConstraintCheck[0..*] nonunique :> booleanEvaluations {
+		doc
+		/*
+		 * constraintChecks is the base feature of all ConstraintUsages.
+		 */
+	}
+	
+	abstract constraint assertedConstraintChecks :> constraintChecks, trueEvaluations {
+		doc
+		/*
+		 * assertedConstraintChecks is the subset of constraintChecks for ConstraintChecks asserted to be true.
+		 */
+	}
+		
+	abstract constraint negatedConstraintChecks :> constraintChecks, falseEvaluations {
+		doc
+		/*
+		 * negatedConstraintChecks is the subset of constraintChecks for ConstraintChecks asserted to be false.
+		 */
+	}
+		
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Systems Library/Flows.sysml

@@ -0,0 +1,126 @@
+standard library package Flows {
+    doc
+    /*
+     * This package defines the base types for flows and related behavioral elements 
+     * in the SysML language.
+     */
+
+    private import Links::Link;
+    private import Occurrences::Occurrence;
+    private import Occurrences::HappensDuring;
+    private import Objects::binaryLinkObjects;
+    private import Transfers::Transfer;
+    private import Transfers::transfers;
+    private import Transfers::FlowTransfer;
+    private import Transfers::flowTransfers;
+    private import Transfers::FlowTransferBefore;
+    private import Transfers::flowTransfersBefore;
+    private import Actions::Action;
+    private import Actions::actions;
+    private import ScalarValues::Natural;
+    
+    abstract flow def MessageAction :> Action, Link {
+        doc
+        /*
+         * MessageAction is the most general class of actions that represent
+         * interactions between linked things. It is the base type of all
+         * FlowDefinitions.
+         */
+         
+         ref payload [0..*] {
+         	doc
+         	/*
+         	 * A payload that may be transferred during the interaction.
+         	 */
+         }
+    }
+
+    abstract flow def Message :> MessageAction, Transfer {
+        doc
+        /*
+         * Message is the subclass of message connections that represent 
+         * a transfer of objects or values between two occurrences. It is 
+         * the base type of all FlowUsages.
+         */
+        
+        ref payload :>> MessageAction::payload, Transfer::payload;
+        
+        private ref action thisConnection = self;
+        
+        in event occurrence sourceEvent [1] default thisConnection.start {
+            doc
+            /* 
+             * An occurrence happening during the source of this message
+             * that is either the start of the mssage or happens before it.
+             */
+        }
+        in event occurrence targetEvent [1] default thisConnection.done {
+            doc
+            /* 
+             * An occurrence happening during the target of this message
+             * that is either the end of the message or happens after it.
+             */
+        }
+        
+        connection :HappensDuring connect sourceEvent to [1] source;
+        connection :HappensDuring connect targetEvent to [1] target;
+        
+        private attribute seBeforeNum: Natural[1] = if sourceEvent==thisConnection.start ? 0 else 1;
+        private attribute teAfterNum: Natural[1] = if targetEvent==thisConnection.done ? 0 else 1;
+        succession [seBeforeNum] first [0..1] sourceEvent then [0..1] self;
+        succession [teAfterNum] first [0..1] self then [0..1] targetEvent;
+    }
+    
+    abstract flow def Flow :> Message, FlowTransfer {
+        doc
+        /*
+         * Flow is a subclass of messages that are also flow transfers.
+         * It is the base type for FlowUsages that identify their source output and
+         * target input.
+         */
+         
+        end occurrence source: Occurrence :>> Message::source, FlowTransfer::source;
+        end occurrence target: Occurrence :>> Message::target, FlowTransfer::target;
+    }
+    
+    abstract flow def SuccessionFlow :> Flow, FlowTransferBefore {
+        doc
+        /*
+         * SuccessionFlow is a subclass of flowss that appen after their source and 
+         * before their target. It is the base type for all SuccessionFlowUsages.
+         */
+         
+        ref self : SuccessionFlow :>> Flow::self, FlowTransferBefore::self;
+    
+        end occurrence source: Occurrence :>> Flow::source, FlowTransferBefore::source;
+        end occurrence target: Occurrence :>> Flow::target, FlowTransferBefore::target;
+    }
+    
+    abstract message messages: Message[0..*] nonunique :> transfers, actions {
+        doc
+        /*
+         * messages is the base feature of all FlowUsages.
+         */
+    }
+    
+    abstract flow flows: Flow[0..*] nonunique :> messages, flowTransfers {
+        doc
+        /*
+         * flows is the base feature for FlowUsages that identify their source output
+         * and target input.
+         */
+    
+        end occurrence source: Occurrence :>> Flow::source, messages::source, flowTransfers::source;
+        end occurrence target: Occurrence :>> Flow::target, messages::target, flowTransfers::target;
+    }
+    
+    abstract flow successionFlows: SuccessionFlow[0..*] nonunique :> flows, flowTransfersBefore {
+        doc
+        /*
+         * successionFlows is the base feature of all SuccessionFlowUsages.
+         */
+    
+        end occurrence source: Occurrence :>> SuccessionFlow::source, flows::source, flowTransfersBefore::source;
+        end occurrence target: Occurrence :>> SuccessionFlow::target, flows::target, flowTransfersBefore::target;
+    }
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Systems Library/Interfaces.sysml

@@ -0,0 +1,89 @@
+standard library package Interfaces {
+    doc
+    /*
+     * This package defines the base types for interfaces and related structural elements in the SysML language.
+     */
+     
+    private import Connections::Connection;
+    private import Connections::connections;
+    private import Connections::BinaryConnection;
+    private import Connections::binaryConnections;
+    private import Ports::Port;
+    
+    private import ScalarValues::Natural;
+    private import SequenceFunctions::size;
+    private import SequenceFunctions::excludingAt;
+    private import ControlFunctions::selectOne;
+    
+    private import SequenceFunctions::notEmpty;
+    
+    private calc def excludingOnce {
+        doc
+        /*
+         * Return a sequence that is the same as the input sequence, but with a single
+         * instance of a given value removed. The given value must be in the input sequence.
+         */
+        in seq[1..*] nonunique ordered; 
+        in value[1] :> seq;
+        
+        private attribute position : Natural[1] = (1..size(seq))->selectOne{in i; seq#(i) == value};
+        seq->excludingAt(position)
+    }
+    
+    abstract interface def Interface :> Connection {
+        doc
+        /*
+         * Interface is the most general class of links between Ports on Parts 
+         * within some containing structure. Interface is the base type of all
+         * InterfaceDefinitions. 
+         * 
+         * Transfers outgoing from any one of the participant Ports of an Interface 
+         * may be targeted to one of the other participant Ports (depending on any 
+         * other Interfaces in which the Port is also participating).
+         */
+         
+        ref port :>> participant : Port [2..*] nonunique ordered {
+            doc
+            /*
+             * The participants of an Interface must be Ports. The interfacingPorts of
+             * each participant Port include all the other participants in the Interface.
+             */
+              
+            protected ref thisParticipant :>> self;
+            protected ref otherParticipants : Port [1..*] nonunique :> interfacingPorts
+                default participant->excludingOnce(thisParticipant);            
+        }
+    }
+    
+    abstract interface def BinaryInterface :> Interface, BinaryConnection {
+        doc
+        /*
+         * BinaryInterface is the most general class of links between two Ports 
+         * on Parts within some containing structure. BinaryInterface is the base 
+         * type of all binary InterfaceDefinitions which have exactly two ends. 
+         * 
+         * Transfers outgoing from each participant Port of a BinaryInterface may be 
+         * targeted to the other participant Port (depending on any other Interfaces 
+         * in which the Port is also participating).
+         */
+        
+        ref port :>> Interface::participant, BinaryConnection::participant[2] nonunique ordered;
+     
+        end port source: Port :>> BinaryConnection::source; 
+        end port target: Port :>> BinaryConnection::target;
+    }
+    
+    abstract interface interfaces: Interface[0..*] nonunique :> connections {
+        doc
+        /*
+         * interfaces is the base feature of all InterfaceUsages.
+         */
+    }
+    
+    abstract interface binaryInterfaces: BinaryInterface[0..*] nonunique :> interfaces, binaryConnections {
+        doc
+        /*
+         * interfaces is the base feature of all binary InterfaceUsages.
+         */
+    }
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Systems Library/Items.sysml

@@ -0,0 +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.
+		 */
+	}
+	
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Systems Library/Metadata.sysml

@@ -0,0 +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.
+		 */
+	}
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Systems Library/Parts.sysml

@@ -0,0 +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.
+		 */
+	}
+	
+}