sysml-validate 0.10.18 → 0.14.2

package/resources/sysml.library/Kernel Libraries/Kernel Semantic Library/ControlPerformances.kerml

@@ -1,135 +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 }
-	}
+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/resources/sysml.library/Kernel Libraries/Kernel Semantic Library/FeatureReferencingPerformances.kerml

@@ -1,190 +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;
-	}
+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;
+	}
 }