sysmledgraph 0.7.0

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Kernel Libraries/Kernel Semantic Library/Transfers.kerml

@@ -0,0 +1,281 @@
+standard library package Transfers {
+    doc
+    /*
+     * This package defines the transfer interactions used to type flows.
+     */
+
+    private import Base::Anything;
+    private import Occurrences::*;
+    private import Links::*;
+    private import Objects::BinaryLinkObject;
+    private import Performances::Performance;
+    private import Performances::performances;
+    private import ScalarValues::Boolean;
+    private import ScalarValues::Natural;
+    private import SequenceFunctions::*;
+    
+    interaction Transfer specializes Performance, BinaryLink {
+        doc
+        /*
+         * A Transfer represents the transfer of a payload from the source of the interaction 
+         * to the target of the interaction.
+         */
+    
+        end feature source: Occurrence redefines BinaryLink::source {
+            doc
+            /*
+             * The entity whose output is the source of the payload to be transferred.
+             */
+        
+            feature sourceOutput: Anything[0..*];
+        }
+        
+        end feature target: Occurrence redefines BinaryLink::target {
+            doc
+            /*
+             * The entity whose input is the target of the payload to be transferred.
+             */
+        
+            feature targetInput: Anything[0..*];
+        }
+        
+        feature isInstant: Boolean[1] {
+            doc
+            /*
+             * If isInstance is true, then the transfer is instantaneous.
+             */
+        }
+        
+        feature payload: Anything[1..*] {
+            doc
+            /*
+             * The things that are to be transferred.
+             */
+        }
+        
+        feature payloadNum: Natural [1] = size(payload);
+        
+        private instantNum: Natural[1] = if isInstant? 1 else 0;
+        private binding instant[instantNum] of [0..1] startShot = [0..1] endShot {
+            doc
+            /*
+             * If isInstant is true, then the start and end of the transfer happen at the same time.
+             */
+        }
+    }
+    
+    interaction MessageTransfer specializes Transfer {
+        doc
+        /*
+         * A MessageTransfer is a Transfer that does not specify where the payload is picked
+         * up and dropped off (see FlowTransfer). They are sent by SendPerformances and
+         * accepted by AcceptPerformances.
+         */
+    }
+     
+    interaction FlowTransfer specializes Transfer disjoint from MessageTransfer {
+        doc
+        /*
+         * A FlowTransfer is a Transfer identifying an output feature of the source from which
+         * to pick up a payload and an input feature of the target to which to drop it off. They can
+         * start when the payload is available at the source and move or copy it to the target.
+         */
+         
+        feature isMove: Boolean[1] default true {
+            doc
+            /*
+             * If isMove is true, then the entire payload leaves the source at the start
+             * of the transfer.
+             */
+        }
+        
+        feature isPush: Boolean[1] default true {
+            doc
+            /*
+             * If isPush is true, then the transfer begins when the payload is available
+             * at the source.
+             */
+        }
+        
+        connector sourceOutputLink: BinaryLinkObject[payloadNum] {
+            doc
+            /*
+             * The output of the payloads from the sourceOutput.
+             */
+        
+            end [1] feature transferSource references source;
+            end [payloadNum] feature transferPayload references payload subsets transferSource.sourceOutput;
+        }
+        
+        connector targetInputLink: BinaryLinkObject[payloadNum] {
+            doc
+            /*
+             * The input of the payload to the targetInput.
+             */
+        
+            end [1] feature transferTarget references target;
+            end [payloadNum] feature transferPayload references payload subsets transferTarget.targetInput;
+        }
+        
+        private connector sending: HappensDuring[payloadNum] from [1] startShot to [payloadNum] sourceOutputLink {
+          doc
+            /*
+             * The start of the transfer happens during the output of each of the payloads from the
+             * source. 
+             */
+        }
+        
+        private connector moving: HappensWhile[0..*] from [0..*] sourceOutputLink.endShot to [0..1] startShot {
+            doc
+            /*
+             * If isMove is true, then all payloads leave the source at the start
+             * of the transfer.
+             */
+        }
+        private inv { isMove implies size(moving) == size(sourceOutputLink) }
+        
+        private connector pushing: HappensWhile[0..*] from [0..*] sourceOutputLink.startShot to [0..1] startShot {
+            doc
+            /*
+             * If isPush is true, then the transfer begins when the payloads are available
+             * at the source.
+             */
+        }
+        private inv { isPush implies size(pushing) == size(sourceOutputLink) }
+        
+        private connector delivering: HappensWhile[payloadNum] from [payloadNum] targetInputLink.startShot to [1] endShot {
+            doc
+            /*
+             * The input of each of the payloads to the target starts at the end of the transfer.
+             */
+        }
+    }
+    
+    interaction TransferBefore specializes Transfer, HappensBefore intersects Transfer, HappensBefore {
+        doc
+        /*
+         * TransferBefore is a specialization of Transfer in which the source happens before
+         * the transfer, which happens before the target.
+         */
+    
+        end feature source: Occurrence redefines Transfer::source, HappensBefore::earlierOccurrence;
+        end feature target: Occurrence redefines Transfer::target, HappensBefore::laterOccurrence;
+        
+        feature self: TransferBefore redefines Performance::self;
+        
+        private succession source then self;
+        private succession self then target;
+    }
+    
+    interaction FlowTransferBefore specializes TransferBefore, FlowTransfer intersects FlowTransfer, TransferBefore {
+        doc
+        /*
+         * FlowTransferBefore is a FlowTransfer that is also a TransferBefore. 
+         */
+         
+        end feature source: Occurrence redefines Transfer::source, TransferBefore::source;
+        end feature target: Occurrence redefines Transfer::target, TransferBefore::target;         
+    }
+    
+    abstract step transfers: Transfer[0..*] nonunique subsets performances, binaryLinks {
+        doc
+        /*
+         * transfers is a specialization of performances and binaryLinks restricted to type 
+         * Transfer.
+         */
+    
+        end feature source: Occurrence redefines Transfer::source, binaryLinks::source;
+        end feature target: Occurrence redefines Transfer::target, binaryLinks::target;
+    }
+    
+    abstract step messageTransfers: MessageTransfer[0..*] nonunique subsets transfers {
+        doc
+        /*
+         * messageTransfers is a specialization of transfers restricted to type MessageTransfers.
+         */
+        
+        end feature source: Occurrence redefines MessageTransfer::source, transfers::source;
+        end feature target: Occurrence redefines MessageTransfer::target, transfers::target;      
+    }
+    
+    abstract flow flowTransfers: FlowTransfer[0..*] nonunique subsets transfers {
+        doc
+        /*
+         * flowTransfers is a specialization of transfers restricted to type FlowTransfers.
+         * It is the default subsetting for non-succession flows.
+         */
+         
+        end feature source: Occurrence redefines FlowTransfer::source, transfers::source;
+        end feature target: Occurrence redefines FlowTransfer::target, transfers::target;
+    }
+      
+    abstract flow transfersBefore: TransferBefore[0..*] nonunique subsets transfers, happensBeforeLinks
+        intersects transfers, happensBeforeLinks {
+        doc
+        /*
+         * transfersBefore is a specialization of transfers and happensBeforeLinks restricted to
+         * type TransferBefore.
+         */
+    
+        end feature source: Occurrence redefines TransferBefore::source, transfers::source, happensBeforeLinks::earlierOccurrence;
+        end feature target: Occurrence redefines TransferBefore::target, transfers::target, happensBeforeLinks::laterOccurrence;
+    }
+    
+    abstract flow flowTransfersBefore: FlowTransferBefore[0..*] nonunique subsets flowTransfers, transfersBefore
+        intersects flowTransfers, transfersBefore {
+        doc
+        /*
+         * flowTransfersBefore is a specialization of flowTransfers and transfersBefore that is restricted
+         * to type FlowTransferBefore. IT is the default subsetting for succession flows.
+         */
+    
+        end feature source: Occurrence redefines FlowTransferBefore::source, flowTransfers::source, transfersBefore::source;
+        end feature target: Occurrence redefines FlowTransferBefore::target, flowTransfers::target, transfersBefore::target;
+    }
+
+    behavior SendPerformance specializes Performance  {
+        doc
+        /*
+         * SendPerformances are Performance that require an outgoingTransferFromSelf 
+         * from a designated sender Occurrence carrying a given payload, optionally to a designated receiver.
+         */
+    
+        in feature payload [0..*];
+        in feature sender: Occurrence[1] default this;
+        in feature receiver: Occurrence[0..1];
+        feature sentTransfer: MessageTransfer [1] subsets sender.outgoingTransfersFromSelf {
+            feature redefines payload = SendPerformance::payload;
+        }
+        binding [0..1] receiver.incomingTransfersToSelf = [1] sentTransfer;
+
+        succession self then sentTransfer;
+    }
+    
+    behavior AcceptPerformance specializes Performance {
+        doc
+        /*
+         * AcceptPerformance is a performance that requires an incomingTransferToSelf
+         * of a desigated receiver Occurrence, providing its payload as output.
+         */
+        inout feature payload[0..*];
+        in feature receiver: Occurrence[1] default this;
+        feature acceptedTransfer: MessageTransfer[1] subsets receiver.incomingTransfersToSelf;
+        succession acceptedTransfer then self.endShot;
+        
+        binding payload = acceptedTransfer.payload;
+    }
+
+    abstract step sendPerformances: SendPerformance[0..*] nonunique subsets performances {
+        doc
+        /*
+         * sendPerformances is a specialization of performances for SendPerformances.
+         */
+    }
+        
+    abstract step acceptPerformances: AcceptPerformance[0..*] nonunique subsets performances {
+        doc
+        /*
+         * acceptPerformances is a specialization of performances for AcceptPerformances.
+         */
+    }
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Kernel Libraries/Kernel Semantic Library/TransitionPerformances.kerml

@@ -0,0 +1,66 @@
+standard library package TransitionPerformances {
+	doc
+	/*
+	 * This package contains a library model of the semantics of conditional transitions between occurrences, 
+	 * including the performance of specified Behaviors when the transition occurs.
+	 */
+
+	private import ScalarValues::Boolean;
+	private import ScalarValues::Natural;
+	private import SequenceFunctions::isEmpty;
+	private import Occurrences::Occurrence;
+	private import Occurrences::HappensBefore;
+	private import Performances::Performance;
+	private import Performances::Evaluation;
+	private import Transfers::MessageTransfer;
+	private import Transfers::AcceptPerformance;
+	private import Transfers::acceptPerformances;
+	private import ControlFunctions::allTrue;
+	private import SequenceFunctions::size;
+	
+	abstract behavior TransitionPerformance {
+		in feature transitionLinkSource: Performance[1];
+		
+		feature trigger: MessageTransfer[*];
+		bool guard[*] subsets enclosedPerformances;
+		step effect[*] subsets enclosedPerformances;
+
+		feature triggerTarget : Occurrence [1] default this;
+		feature transitionLink: HappensBefore[0..1];
+		
+		private binding [0..1] transitionLink.earlierOccurrence = [1] transitionLinkSource;
+		private succession [1] transitionLinkSource then [*] effect;
+		private succession [*] effect then [1] transitionLink.laterOccurrence;
+		
+		private connector [0..1] transitionLink to [1..*] trigger;
+		private connector all guardConstraint: TPCGuardConstraint[*] 
+			from [0..1] transitionLink to [*] guard;
+			
+		private succession all [*] trigger then [*] guard;
+		private succession all [*] guard then [*] effect;
+
+		feature accNum: Natural [1] = if isEmpty(trigger) ? 0 else 1;
+		step accept: AcceptPerformance[accNum] subsets timeEnclosedOccurrences, acceptPerformances {
+			feature redefines acceptedTransfer = trigger;
+		}
+        binding accept.receiver = triggerTarget;
+
+		private succession [*] guard then [accNum] accept;
+	}
+	
+	behavior NonStateTransitionPerformance specializes TransitionPerformance {
+		feature isTriggerAfter: Boolean default true;
+		private succession [1] transitionLinkSource then [1] Performance::self;
+		private feature taNum: Natural [1] = if isTriggerAfter ? size(trigger) else 0;
+		private succession triggerAfter [taNum] first [0..1] transitionLinkSource then [*] trigger.endShot;
+				
+		private succession all [*] guard then [0..1] transitionLink.laterOccurrence;
+	}
+	
+	assoc struct TPCGuardConstraint {
+		end guardedLink [0..1] feature constrainedHBLink: HappensBefore;
+		end bool constrainedGuard;
+		
+		private inv { allTrue(constrainedGuard()) }
+	}	
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Kernel Libraries/Kernel Semantic Library/Triggers.kerml

@@ -0,0 +1,188 @@
+standard library package Triggers {
+	doc
+	/*
+	 * This package contains functions that return ChangeSignals for triggering
+	 * when a Boolean condition changes from false to true, at a specific time
+	 * or after a specific time delay.
+	 */
+
+	private import ScalarValues::Boolean;
+	private import ScalarValues::NumericalValue;
+	private import Occurrences::Occurrence;
+	
+	public import Clocks::*;
+	public import Observation::*;
+	
+	struct TimeSignal :> ChangeSignal {
+		doc
+		/*
+		 * A TimeSignal is a ChangeSignal whose condition is the currentTime
+		 * of a given Clock reaching a specific signalTime.
+		 */
+	
+		feature signalTime : NumericalValue[1] {
+			doc
+			/*
+			 * The time at which the TimeSignal should be sent.
+			 */
+		}
+		
+		feature signalClock : Clock[1] {
+			doc
+			/*
+			 * The Clock whose currentTime is being monitored.
+			 */
+		}
+		
+		private bool :>> signalCondition {
+			doc
+			/*
+			 * The Boolean condition of the currentTime of the signalClock being
+			 * equal to the signalTime.
+			 */
+		
+			signalClock.currentTime == signalTime
+		}
+	}
+	
+	function TriggerWhen {
+		doc
+		/*
+		 * TriggerWhen returns a monitored ChangeSignal for a given condition,
+		 * to be sent to a given receiver when the condition occurs.
+		 */
+	
+		in bool condition[1] {
+			doc
+			/*
+			 * The BooleanExpression to be monitored for changing from 
+			 * false to true.
+		 */
+		}
+		
+		in feature receiver : Occurrence [1] {
+			doc
+			/*
+			 * The Occurrence to which the ChangeSignal is to be sent.
+			 */
+		}
+		
+		in feature monitor : ChangeMonitor[1] default defaultMonitor {
+			doc
+			/*
+			 * The ChangeMonitor to be used to monitor the ChangeSignal condition.
+			 * The default is the Observation::defaultMonitor.
+			 */
+		}
+		
+		return feature changeSignal : ChangeSignal[1] = new ChangeSignal(condition, monitor) {
+			doc
+			/*
+			 * The ChangeSignal for the condition, as monitored by the monitor.
+			 */
+		}
+		
+		step :> monitor.startObservation {
+			in observer = receiver;
+			in signal = changeSignal;
+		}		
+	}
+	
+	function TriggerAt {
+		doc
+		/*
+		 * TriggerAt returns a monitored TimeSignal to be sent to a receiver when
+		 * the currentTime of a given Clock reaches a specific timeInstant. 
+		 */
+	
+		in feature timeInstant : NumericalValue[1] {
+			doc
+			/*
+			 * The time instant, relative to the clock, at which the TimeSignal should be sent. 
+			 */
+		}
+		
+		in feature receiver : Occurrence[1] {
+			doc
+			/*
+			 * The Occurrence to which the TimeSignal is to be sent.
+			 */
+		}
+		
+		in feature clock : Clock[1] default localClock {
+			doc
+			/*
+			 * The Clock to be used as the reference for the timeInstant. The default is
+			 * the localClock, which will be bound when the function is invoked. 
+			 */
+		}
+		
+		in feature monitor : ChangeMonitor[1] default defaultMonitor {
+			doc
+			/*
+			 * The ChangeMonitor to be used to monitor the TimeSignal condition.
+			 * The default is the Observation::defaultMonitor.
+			 */
+		}
+		
+		return feature timeSignal : TimeSignal[1] = new TimeSignal(timeInstant, clock, monitor) {
+			doc
+			/*
+			 * The TimeSignal for the given timeInstant, as monitored by the monitor.
+			 */
+		}
+		
+		step :> monitor.startObservation {
+			in observer = receiver;
+			in signal = timeSignal;
+		}
+	}
+	
+	function TriggerAfter {
+		doc
+		/*
+		 * TriggerAfter returns a monitored TimeSignal to be sent to a receiver after
+		 * a certain time delay relative to a given Clock.
+		 */
+	
+		in feature delay : NumericalValue[1] {
+			doc
+			/*
+			 * The time duration, relative to the clock, after which the TimeSignal is sent.
+			 */
+		}
+		
+		in feature receiver : Occurrence[1] {
+			doc
+			/*
+			 * The Occurrence to which the TimeSignal is to be sent.
+			 */
+		}
+		
+		in feature clock : Clock[1] default localClock {
+			doc
+			/*
+			 * The Clock to be used as the reference for the time delay. The default is
+			 * the localClock, which will be bound when the function is invoked. 
+			 */
+		}
+		
+		in feature monitor : ChangeMonitor[1] default defaultMonitor {
+			doc
+			/*
+			 * The ChangeMonitor to be used to monitor the TimeSignal condition.
+			 * The default is the Observation::defaultMonitor.
+			 */
+		}
+		
+		return signal : TimeSignal[1] = 
+			TriggerAt(clock.currentTime + delay, receiver, clock, monitor) {
+			doc
+			/*
+			 * The TimeSignal for the currentTime of the clock when the function is invoked
+			 * plus the given time delay, as monitored by the monitor.
+			 */
+		}
+	}	
+	
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Systems Library/.meta.json

@@ -0,0 +1,27 @@
+{
+  "index": {
+    "Actions": "Actions.sysml",
+    "Allocations": "Allocations.sysml",
+    "AnalysisCases": "AnalysisCases.sysml",
+    "Attributes": "Attributes.sysml",
+    "Calculations": "Calculations.sysml",
+    "Cases": "Cases.sysml",
+    "Connections": "Connections.sysml",
+    "Constraints": "Constraints.sysml",
+    "Flows": "Flows.sysml",
+    "Interfaces": "Interfaces.sysml",
+    "Items": "Items.sysml",
+    "Metadata": "Metadata.sysml",
+    "Parts": "Parts.sysml",
+    "Ports": "Ports.sysml",
+    "Requirements": "Requirements.sysml",
+    "StandardViewDefinitions": "StandardViewDefinitions.sysml",
+    "States": "States.sysml",
+    "SysML": "SysML.sysml",
+    "UseCases": "UseCases.sysml",
+    "VerificationCases": "VerificationCases.sysml",
+    "Views": "Views.sysml"
+  },
+  "created": "2025-03-13T00:00:00Z",
+  "metamodel": "https://www.omg.org/spec/SysML/20250201"
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Systems Library/.project.json

@@ -0,0 +1,19 @@
+{
+  "name": "SysML Systems Library",
+  "version": "2.0.0",
+  "description": "Standard semantic library for the Systems Modeling Language (SysML)",
+  "usage": [
+    {
+      "resource": "https://www.omg.org/spec/KerML/20250201/Semantic-Library.kpar",
+      "versionConstraint": "1.0.0"
+    },
+    {
+      "resource": "https://www.omg.org/spec/KerML/20250201/Data-Type-Library.kpar",
+      "versionConstraint": "1.0.0"
+    },
+    {
+      "resource": "https://www.omg.org/spec/KerML/20250201/Function-Library.kpar",
+      "versionConstraint": "1.0.0"
+    }
+  ]
+}