sysmledgraph 0.7.0

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

@@ -0,0 +1,156 @@
+standard library package Clocks {
+	doc
+	/*
+	 * This package models Clocks that provide an advancing numerical reference 
+	 * usable for quantifying the time of an Occurrence.
+	 */
+
+	private import ScalarValues::NumericalValue;
+	private import ScalarValues::Real;
+	private import Occurrences::Occurrence;
+	private import Occurrences::Life;
+	private import ControlFunctions::forAll;
+	
+	private struct UniversalClockLife[1] :> Clock, Life {
+	    doc
+	    /*
+	     * UniversalClockLife is the classifier of the singleton Life of the universalClock.
+	     */
+	}
+	
+	feature universalClock : UniversalClockLife[1] {
+		doc
+		/*
+		 * universalClock is a single Clock that can be used as a default universal
+		 * time reference.
+		 */
+	}
+	
+	abstract struct Clock {
+		doc
+		/*
+		 * A Clock provides a numerical currentTime that advances montonically
+		 * over its lifetime. Clock is an abstract base Structure that can be
+		 * specialized for different kinds of time quantification (e.g., discrete
+		 * time, continuous time, time with units, etc.).
+		 */
+		 
+		private thisClock : Clock :>> self;
+		
+		var feature currentTime : NumericalValue[1] {
+			doc
+			/*
+			 * A scalar time reference that advances over the lifetime of the Clock. 
+			 */
+		}
+						
+		inv timeFlowConstraint {
+			doc
+			/*
+			 * The currentTime of a snapshot of a Clock is equal to
+			 * the TimeOf the snapshot relative to that Clock.
+			 */
+			
+			snapshots->forAll{in s : Clock; 
+				TimeOf(s, thisClock) == s.currentTime
+			}
+		}		
+	}
+	
+	abstract function TimeOf {
+		doc
+		/*
+		 * TimeOf returns a numerical timeInstant for a given Occurrence relative to
+		 * a given Clock. The timeInstant is the time of the start of the Occurrence,
+		 * which is considered to be synchronized with the snapshot of the Clock 
+		 * with a currentTime equal to the returned timeInstant.
+		 */
+		
+		in o : Occurrence[1];
+		in clock : Clock[1] default localClock;
+		return timeInstant : NumericalValue[1];
+		
+		 inv startTimeConstraint {
+		 	doc
+			/*
+			 * The TimeOf an Occurrence is equal to the time of its start snapshot.
+			 */
+			 
+		 	timeInstant == TimeOf(o.startShot, clock)
+		 }	 
+
+		inv timeOrderingConstraint {
+			doc
+			/*
+			 * If one Occurrence happens before another, then the TimeOf the end
+			 * snapshot of the first Occurrence is no greater than the TimeOf the 
+			 * second Occurrence.
+			 */
+			
+			o.predecessors->forAll{in p : Occurrence; 
+				TimeOf(p.endShot, clock) <= timeInstant
+			}
+		}
+				
+		inv timeContinuityConstraint {
+			doc
+			/*
+			 * If one Occurrence happens immediately before another, then the TimeOf 
+			 * the end snapshot of the first Occurrence equals the TimeOf the second
+			 * Occurrence.
+			 */
+		 
+			o.immediatePredecessors->forAll{in p : Occurrence; 
+				TimeOf(p.endShot, clock) == timeInstant
+			}
+		}				
+	}
+	
+	function DurationOf {
+		doc
+		/*
+		 * DurationOf returns the duration of a given Occurrence relative to a
+		 * given Clock, which is equal to the TimeOf the end snapshot of the
+		 * Occurrence minus the TimeOf its start snapshot.
+		 */
+		
+		in o : Occurrence[1]; 
+		in clock : Clock[1] default localClock;
+		return duration : NumericalValue =
+			TimeOf(o.endShot, clock) - TimeOf(o.startShot, clock);
+	}
+	
+	struct BasicClock :> Clock {
+		doc
+		/*
+		 * A BasicClock is a Clock whose currentTime is a Real number.
+		 */
+		
+		var feature :>> currentTime : Real;
+	}
+	
+	function BasicTimeOf :> TimeOf {
+		doc
+		/*
+		 * BasicTimeOf returns the TimeOf an Occurrence as a Real number relative
+		 * to a BasicClock.
+		 */
+
+		in o : Occurrence[1];
+		in clock : BasicClock[1];
+		return : Real[1];
+	}
+	
+	function BasicDurationOf :> DurationOf {
+		doc
+		/*
+		 * BasicDurationOf returns the DurationOf an Occurrence as a Real number relative
+		 * to a BasicClock.
+		 */
+		
+		in o : Occurrence[1];
+		in clock : BasicClock[1];
+		return : Real[1];
+	}
+
+}

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

@@ -0,0 +1,135 @@
+standard library package ControlPerformances {
+	doc
+	/*
+	 * This package defines Behaviors to be used to type Steps that control the sequencing of performance
+	 * of other Steps. 
+	 */
+
+	private import ScalarValues::Boolean;
+	private import SequenceFunctions::size;
+	private import SequenceFunctions::notEmpty;
+	private import Occurrences::Occurrence;
+	private import Occurrences::HappensBefore;
+	private import Occurrences::SelfSameLifeLink;
+	private import Performances::Performance;
+	private import Performances::BooleanEvaluation;
+	
+	behavior DecisionPerformance specializes Performance {
+		doc
+		/*
+		 * A DecisionPerformance is a Performance that represents the selection of one of the Successions
+		 * that have the DecisionPerforance behavior as their source. All such Successions must subset the 
+		 * outgoingHBLink feature of the source DecisionPerformance. For each instance of DecisionPerformance, 
+		 * the outgoingHBLink is an instance of exactly one of the Successions, ordering the DecisionPerformance
+		 * as happening before an instance of the target of that Succcession.
+		 */
+		
+		feature outgoingHBLink: HappensBefore[1] {
+			doc
+			/*
+			 * Specializations subset this by all
+			 * successions going out of a decision step.
+			 */
+
+			 end feature redefines earlierOccurrence subsets that;
+		}
+	}
+	
+	behavior MergePerformance specializes Performance {
+		doc
+		/*
+		 * A MergePerformance is a Performance that represents the merging of all Successions that
+		 * target the MergePerforance behavior. All such Successions must subset the incomingHBLink
+		 * feature of the target MergePerformance. For each instance of MergePerformance, the
+		 * incomingHBLink is an instance of exactly one of the Successions, ordering the
+		 * MergePerformance as happening after an instance of the source of that Succession.
+		 */
+
+		feature incomingHBLink: HappensBefore[1] {
+			doc
+			/*
+			 * Specializations subset this by all
+			 * successions coming into a merge step.
+			 */
+
+			 end feature redefines laterOccurrence subsets that;
+		}
+	}
+
+	abstract behavior IfPerformance specializes Performance {
+		doc
+		/*
+		 * An IfPerformance is a Performance that determines whether the ifTest evaluation result is true 
+		 * (by whether ifTrue has a value).
+		 */	
+		 
+		in ifTest : BooleanEvaluation[1];
+	}
+	
+	behavior IfThenPerformance specializes IfPerformance {
+		doc
+		/*
+		 * An IfThenPerformance is an IfPerformance where the thenClause occurs after and only after the 
+		 * ifTest evaluation result is true.
+		 */
+		
+		in redefines ifTest;
+		in thenClause : Occurrence[0..1];
+		succession [1] ifTest then [0..1] thenClause;
+		inv { ifTest() == thenClause->notEmpty() }
+	}
+	
+	behavior IfElsePerformance specializes IfPerformance {
+		doc
+		/*
+		 * An IfElsePerformance is an IfPerformance where the elseClause occurs after and only 
+		 * after the ifTest evaluation result is not true.
+		 */
+
+		in redefines ifTest;
+		in elseClause : Occurrence[0..1];
+		succession [1] ifTest then [0..1] elseClause;
+		inv { not ifTest() == elseClause->notEmpty() }
+	}
+	
+	behavior IfThenElsePerformance specializes IfThenPerformance {
+		doc
+		/*
+		 * An IfThenElsePerformance is an IfThenPerformance with an additional elseClause that
+		 * occurs after and only after the ifTest evaluation is false.
+		 */
+		 
+		in redefines ifTest;
+		in redefines thenClause;
+        in elseClause : Occurrence[0..1];
+        succession [1] ifTest then [0..1] elseClause;
+        inv { not ifTest() == elseClause->notEmpty() }
+	}
+	
+	behavior LoopPerformance specializes Performance {
+		doc
+		/*
+		 * A LoopPerformance is a Performance where the body occurs repeatedly in sequence (iterates) 
+		 * as long as the whileTest evaluation result is true before each iteration (and after the 
+		 * previous one, except the first time) and the untilTest evaluation result is not true after 
+		 * each iteration and before the next one (except the last one).
+		 */
+		 
+		in whileTest : BooleanEvaluation[1..*];
+		in body : Occurrence[0..*];
+        in untilTest : BooleanEvaluation[0..*];
+		
+		step whileDecision : IfThenPerformance[1..*];
+		step untilDecision : IfElsePerformance[0..*];
+		
+		binding [1] whileDecision.ifTest = [1] whileTest;
+		binding [1] whileDecision.thenClause = [1] body;
+		
+		succession body then untilDecision;
+		
+		binding [1] untilDecision.ifTest = [1] untilTest;
+		binding loopBack of [0..1] untilDecision.elseClause = [1] whileDecision;
+		
+		inv { loopBack->size() == whileDecision->size() - 1 }
+	}
+}

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

@@ -0,0 +1,190 @@
+standard library package FeatureReferencingPerformances {
+	doc
+	/*
+	 * This package defines Behaviors used to read, write and monitor values of a referenced Feature of an 
+	 * Occurrence.
+	 */
+
+	private import Base::Anything;
+	private import Base::things;
+	private import Occurrences::Occurrence;
+	private import Occurrences::HappensWhile;
+	private import Occurrences::HappensBefore;
+	private import Occurrences::HappensJustBefore;
+	private import Occurrences::SelfSameLifeLink;
+	private import Performances::Performance;
+	private import Performances::Evaluation;
+	private import ScalarValues::Boolean;
+	private import SequenceFunctions::isEmpty;
+	private import SequenceFunctions::equals;
+
+	abstract behavior FeatureReferencingPerformance specializes Performance {
+		doc
+		/*
+		 * A FeatureReferencingPerformance is the base Performance for specialized behaviors related 
+		 * to values of a referenced Feature of a given Occurrence, as identified in specializations 
+		 * of this Behavior.
+		 */
+		
+		in abstract feature onOccurrence : Occurrence [1] {
+			doc
+			/*
+			 * Occurrence with values for the referenced feature in specializations of this behavior.
+			 */
+		}
+		 
+		inout feature values : Anything [*] nonunique {
+			doc
+			/*
+			 * Values of the referenced feature, as specified in specializations of this behavior.
+			 */
+		}	
+	}
+
+    abstract behavior FeatureAccessPerformance specializes FeatureReferencingPerformance {
+    	doc
+		/*
+		 * A FeatureAccessPerformance is a FeatureReferencingPerformance where the result values
+		 * are all the values of a feature of onOccurrence at the time the Performance ends. The
+		 * feature is specified by restricting accessedFeature in specializations or usages.
+		 */
+     	
+		in abstract feature onOccurrence : Occurrence {
+			abstract feature startingAt : Occurrence [1] subsets timeSlices {
+				abstract feature accessedFeature : Anything [*] nonunique;
+			}
+		}
+
+	  	 connector :HappensWhile from onOccurrence.startingAt.startShot to endShot {
+	  	 	doc
+			/*
+			 * Requires some time slice of onOccurrence to start when this performance
+			 * ends (this connector), with particular feature values (following connector).
+			 * The feature is specified by restricting the onOccurrence::accessedFeature 
+			 * on usages of this behavior.
+			 */
+	  	 }
+	  	 connector :SelfSameLifeLink from onOccurrence.startingAt.accessedFeature to values;
+	}
+
+	abstract function FeatureReadEvaluation specializes FeatureAccessPerformance, Evaluation { 
+		doc
+		/*
+		 * A FeatureReadEvaluation is a FeatureAccessPerformance that is a function providing as
+		 * its result the values of a feature on an occurrence at the time its evaluation ends.
+		 */
+
+		in onOccurrence: Occurrence [1];
+		return resultValues : Anything [*] nonunique redefines result redefines values;
+	}
+
+	abstract behavior FeatureWritePerformance specializes FeatureAccessPerformance {
+		doc
+		/*
+		 * A FeatureWritePerformance is a FeatureAccessPerformance that assigns the values of a 
+		 * feature on an occurrence to the given replacementValues at time its performance ends.
+		 */
+		 
+		in feature onOccurrence : Occurrence[1] redefines onOccurrence;
+		inout feature replacementValues : Anything redefines values [*] nonunique;
+	}
+	
+	abstract behavior FeatureMonitorPerformance specializes FeatureReferencingPerformance {
+		doc
+		/*
+		 * A FeatureMonitorPerformance is a FeatureReferencingPerformance that waits for values
+		 * of monitoredFeature to change on onOccurrence from what they were when the performance 
+		 * started. The values before and after the change are given by beforeValues and afterValues.
+		 */	
+
+		in feature redefines onOccurrence {
+	    	feature monitoredOccurrence : Occurrence [1] subsets timeSlices {
+	      		abstract feature monitoredFeature : Anything[*] nonunique;
+	      		feature beforeTimeSlice : Occurrence [1] subsets timeSlices {
+	        		feature redefines monitoredFeature;
+	        	}
+	      		feature afterSnapshot : Occurrence [1] subsets snapshots {
+	        		feature redefines monitoredFeature;
+	        	}
+	      		connector :HappensJustBefore from beforeTimeSlice to afterSnapshot;
+	        }
+	  	}
+	  	out feature afterValues redefines values;
+	  	out feature beforeValues : Anything[*] nonunique;
+	  	inv { not beforeValues->equals(afterValues) }
+	
+	  	private connector : HappensWhile 
+	  		from [1] onOccurrence.monitoredOccurrence.beforeTimeSlice.startShot to [1] startShot;
+	  	private connector : SelfSameLifeLink 
+	  		from [1] onOccurrence.monitoredOccurrence.beforeTimeSlice.monitoredFeature to [1] beforeValues;
+	  	private connector : SelfSameLifeLink 
+	  		from [1] onOccurrence.monitoredOccurrence.afterSnapshot.monitoredFeature to [1] afterValues;
+	  	protected connector endWhen : HappensBefore 
+	  		from [1] onOccurrence.monitoredOccurrence.afterSnapshot to [1] endShot;
+	}
+		
+	behavior EvaluationResultMonitorPerformance specializes FeatureMonitorPerformance {
+		doc
+		/*
+		 * An EvaluationResultMonitorPerformance is a FeatureMonitorPerformance that waits for changes 
+		 * in the result of an Evaluation identified by onOccurrence. The Predicate being evaluated must 
+		 * be able to produce multiple results over time, for example by only using BindingConnectors 
+		 * between Steps, rather than Successions or Flows, including in its Step behaviors.
+		 */
+		
+		in feature onOccurrence : Evaluation redefines onOccurrence {
+	    	protected expr monitoredOccurrence : Evaluation [1] redefines monitoredOccurrence {
+				return result : Anything[*] redefines result, monitoredFeature; 
+			} 
+		} 
+	}
+	
+	behavior BooleanEvaluationResultMonitorPerformance specializes EvaluationResultMonitorPerformance {
+		doc
+		/*
+		 * A BooleanEvaluationResultMonitorPerformance is a EvaluationResultMonitorPerformance
+		 * that waits for changes in the result of a BooleanEvaluation identified by onOccurrence.
+		 */	
+		
+	  	in bool redefines onOccurrence {
+	    	protected bool redefines monitoredOccurrence[1] {
+	    	    return result : Boolean [1];
+	    	}
+		}
+		out redefines afterValues : Boolean [1]; 
+		out redefines beforeValues : Boolean [1];	 
+	}
+	
+	behavior BooleanEvaluationResultToMonitorPerformance specializes FeatureReferencingPerformance {
+		doc
+		/*
+		 * A BooleanEvaluationResultToMonitorPerformance is a FeatureReferencingPerformance that waits 
+		 * for the result of a BooleanEvaluation (identified by onOccurrence) to change to either true 
+		 * or false, as indicated by isToTrue (defaulting to true). If the result is already true (or false), 
+		 * the performance waits for the result to become false (or true) before waiting again for it to 
+		 * change back.
+		 */	
+		 
+  		in bool redefines onOccurrence;
+  		feature isToTrue : Boolean [1] default true;
+  		out afterValues: Boolean[1] redefines values  = isToTrue;
+  		private feature monitor1 : BooleanEvaluationResultMonitorPerformance [1] {
+    		feature redefines endWhen : HappensJustBefore {
+    		    end feature earlierOccurrence;
+    		    end feature laterOccurrence;
+    		}
+  		}
+  		private feature monitor2 : BooleanEvaluationResultMonitorPerformance [1] {
+    		feature redefines endWhen : HappensJustBefore {
+                end feature earlierOccurrence;
+                end feature laterOccurrence;
+            }
+  		}
+
+  		private connector : HappensJustBefore from [1] monitor1 to [0..1] monitor2;
+  		inv { isEmpty(monitor2) == (monitor1.afterValues == isToTrue) }
+
+  		private binding [1] monitor1.onOccurrence = [1] onOccurrence;
+  		private binding [1] monitor2.onOccurrence = [1] onOccurrence;
+	}
+}