sysmlpy 0.1.0__py3-none-any.whl

sysmlpy/library/kernel/Objects.kerml

@@ -0,0 +1,212 @@
+standard library package Objects {
+	doc
+	/*
+	 * This package defines classifiers and features that are related to the typing of objects, including link objects.
+	 */
+
+	private import Base::Anything;
+	private import Base::things;
+	private import Links::*;
+	private import Occurrences::Occurrence;
+	private import Occurrences::occurrences;
+	private import Occurrences::HappensLink;
+	private import Occurrences::SelfSameLifeLink;
+	private import Occurrences::WithinBoth;	       
+	private import Performances::Performance;
+	private import Performances::performances;
+	private import SequenceFunctions::isEmpty;
+	private import SequenceFunctions::notEmpty;
+	private import SequenceFunctions::union;
+	private import CollectionFunctions::contains;
+	private import ScalarValues::Integer;
+	private import ScalarValues::Natural;
+	
+	abstract struct Object specializes Occurrence {
+		doc
+		/*
+		 * Object is the most general class of structural occurrences that may change over time.
+		 */
+
+		feature self: Object redefines Occurrence::self;
+		
+		composite feature subobjects: Object[0..*] subsets objects, suboccurrences
+			intersects objects, suboccurrences {
+			doc
+			/*
+			 * The suboccurrences of this Object that are also Objects.
+			 */
+		}
+		
+		feature involvingPerformances: Performance[0..*] subsets performances {
+			doc
+			/*
+			 * Performances in which this object is involved.
+			 */
+		}
+		
+		abstract step enactedPerformances: Performance[0..*] subsets involvingPerformances, timeEnclosedOccurrences
+			intersects involvingPerformances, timeEnclosedOccurrences {
+			doc
+			/*
+			 * Performances that are enacted by this object.
+			 */
+		}
+		
+		composite step ownedPerformances: Performance[0..*] subsets involvingPerformances, timeEnclosedOccurrences, suboccurrences
+			intersects involvingPerformances, timeEnclosedOccurrences, suboccurrences {
+			doc
+			/*
+			 * Performances that are owned by this object.
+			 */
+			 
+			feature redefines this default that {
+				doc
+				/*
+				 * The owning object is the default "this" reference for all ownedPerformances.
+				 */
+			}
+		}
+
+		portion structuredSpaceBoundary : StructuredSpaceObject[0..1] subsets spaceBoundary {
+			doc
+			/*
+			 * A space boundary that is a structured space object.
+			 */
+		}
+	}
+	
+	abstract assoc struct LinkObject specializes Link, Object intersects Link, Object {
+		doc
+		/*
+		 * LinkObject is the most general association structure, being both a Link and an Object.
+		 */
+	}
+	
+	assoc struct BinaryLinkObject specializes BinaryLink, LinkObject intersects BinaryLink, LinkObject {
+		doc
+		/*
+		 * BinaryLinkObject is the most general binary association structure, being both a 
+		 * BinaryLink and a LinkObject.
+		 */
+	}
+	
+	abstract feature objects: Object[0..*] nonunique subsets occurrences {
+		doc
+		/*
+		 * objects is a specialization of occurrences restricted to type Object.
+		 */
+	}
+	
+	abstract feature linkObjects: LinkObject[0..*] nonunique subsets links, objects intersects links, objects {
+		doc
+		/*
+		 * linkObjects is a specializations of links and objects restricted to type LinkObjects. 
+		 */
+	}
+	
+	abstract feature binaryLinkObjects: BinaryLinkObject[0..*] nonunique subsets binaryLinks, linkObjects
+		intersects binaryLinks, linkObjects {
+		doc
+		/*
+		 * binaryLinkObjects is a specialization of binaryLinks and linkObjects restricted to 
+		 * type BinaryLinkObjects.
+		 */
+	}
+	
+
+	struct all Body specializes Object {
+		doc
+		/*
+		 * A Body is an Object of inner space dimension 3.
+		 */
+
+		feature redefines innerSpaceDimension = 3;
+	}
+
+	struct all Surface specializes Object {
+		doc
+		/*
+		 * A Surface is an Object of inner space dimension 2.
+		 */
+		
+		feature redefines innerSpaceDimension = 2;
+		  /* The number of  "holes" in this Surface, assuming it isClosed. */
+		feature genus : Natural[0..1] default 0;
+
+		inv { notEmpty(genus) implies isClosed }
+	}
+
+	struct all Curve specializes Object {
+		doc
+		/*
+		 * A Curve is an Object of inner space dimension 1.
+		 */
+
+		feature redefines innerSpaceDimension = 1;
+	}
+
+	struct all Point specializes Object {
+		doc
+		/*
+		 * A Point is an Object of inner space dimension 0.
+		 */
+		 
+		feature redefines innerSpaceDimension = 0;
+	}
+
+	abstract struct StructuredSpaceObject specializes Object {
+		doc
+		/*
+		 * A StructuredSpaceObject is an Object that is broken up into smaller structured space objects (cells) of
+		 * the same or lower inner space dimension: faces that are surfaces, edges that are curves, and vertices
+		 * that are points, with edges and vertices on the boundary of faces, and vertices on the boundary of
+		 * edges. Cells meet when a structured space object is closed, as required to be a space boundary of
+		 * an object (faces meet at their edges and/or vertices, while edges meet at their vertices). The
+		 * inner space dimension of structured space object is the highest of their cells.
+		 */
+
+        abstract portion feature structuredSpaceObjectCells : StructuredSpaceObject[1..*] subsets Occurrence::spaceSlices { 
+            feature cellOrientation : Integer [0..1];
+		    inv { notEmpty(cellOrientation) implies (cellOrientation >= -1 & cellOrientation <= 1) }
+		}
+		
+		comment about StructuredSurface, StructuredCurve, StructuredPoint
+		/*
+		 * The structures StructuredSurface, StructuredCurve and StructuredPoint provide common, necessary redefinitions of
+		 * innerSpaceDimension. They also provide single types for the StructuredSpaceObject features faces, edges and
+		 * vertices, which avoids problems when these features are related by connectors with ends that have owned
+		 * cross features.
+		 */
+		struct StructuredSurface specializes StructuredSpaceObject, Surface {
+            feature redefines StructuredSpaceObject::innerSpaceDimension, Surface::innerSpaceDimension;		    
+		}
+        struct StructuredCurve specializes StructuredSpaceObject, Curve {
+            feature redefines StructuredSpaceObject::innerSpaceDimension, Curve::innerSpaceDimension;         
+        }
+        struct StructuredPoint specializes StructuredSpaceObject, Point {
+            feature redefines StructuredSpaceObject::innerSpaceDimension, Point::innerSpaceDimension;         
+        }
+
+		portion feature faces : StructuredSurface[0..*] ordered subsets structuredSpaceObjectCells {
+		    feature redefines that : StructuredSpaceObject;
+			feature redefines edges subsets that.edges;
+			feature redefines vertices subsets that.vertices;
+			derived feature redefines spaceBoundary; 
+			inv { isEmpty(spaceBoundary) == isEmpty(union(edges, vertices)) }
+			inv { notEmpty(spaceBoundary) implies contains(spaceBoundary.unionsOf, union(edges, vertices)) }
+		}
+
+		portion feature edges : StructuredCurve[0..*] ordered subsets structuredSpaceObjectCells {
+            feature redefines that : StructuredSpaceObject;
+			feature redefines vertices subsets that.vertices;
+			derived feature redefines spaceBoundary;
+			inv { isEmpty(spaceBoundary) == isEmpty(vertices) }
+			inv { notEmpty(spaceBoundary) implies contains(spaceBoundary.unionsOf, vertices) }
+		}
+
+		portion feature vertices : StructuredPoint[0..*] ordered subsets structuredSpaceObjectCells;
+		
+		derived feature redefines innerSpaceDimension = 
+			if notEmpty(faces) ? 2 else if notEmpty(edges) ? 1 else 0;
+	  }
+}

sysmlpy/library/kernel/Observation.kerml

@@ -0,0 +1,161 @@
+standard library package Observation {
+	doc
+	/*
+	 * This package models a framework for monitoring Boolean conditions and notifying
+	 * registered observers when they change from false to true.
+	 */
+	 
+	private import ScalarValues::Boolean;
+	private import Occurrences::Occurrence;
+	private import Occurrences::Life;
+	private import SequenceFunctions::including;
+	private import SequenceFunctions::excluding;
+	private import ControlFunctions::select;
+	private import ControlPerformances::DecisionPerformance;
+	private import ControlPerformances::IfThenPerformance;
+	private import FeatureReferencingPerformances::FeatureWritePerformance;
+	private import FeatureReferencingPerformances::BooleanEvaluationResultToMonitorPerformance;
+	private import Transfers::TransferBefore;
+
+    private struct DefaultMonitorLife[1] :> ChangeMonitor, Life {
+        doc
+        /*
+         * DefaultMonitorLife is the classifier of the singleton Life of the defaultMonitor.
+         */
+    }
+    
+	feature defaultMonitor[1] : DefaultMonitorLife {
+		doc
+		/*
+		 * defaultMonitor is a single ChangeMonitor that can be used as a default.
+		 */
+	}
+
+	struct ChangeSignal {
+		doc
+		/*
+		 * A ChangeSignal is a signal to be sent when the Boolean result of its
+		 * changeCondition Expression changes from false to true.
+		 */
+
+		bool signalCondition {
+			doc
+			/*
+			 * A BooleanExpression whose result is being monitored.
+			 */
+		}
+		
+		feature signalMonitor : ChangeMonitor {
+			doc
+			/*
+			 * The ChangeMonitor responsible for monitoring the signalCondition.
+			 */
+		}
+	}
+	
+	private behavior ObserveChange {
+		doc
+		/*
+		 * Each Performance of ObserveChange waits for the result of the Boolean 
+		 * condition of a given ChangeSignal to change from false to true, and, when 
+		 * it does, sends the ChangeSignal to a given observer Occurrence.
+		 */
+
+		in feature changeObserver : Occurrence[1];
+		in feature changeSignal : ChangeSignal[1];
+		
+		composite step wait : IfThenPerformance {
+			doc
+			/*
+			 * If the result of the changeSignal.signalCondition is false, then wait for 
+			 * it to become true.
+			 */
+
+			in bool redefines ifTest {
+				not changeSignal.signalCondition()
+			}
+			in step redefines thenClause : BooleanEvaluationResultToMonitorPerformance {
+				in bool onOccurrence = changeSignal.signalCondition;
+			}
+		}		
+		
+		succession wait then transfer;
+		
+	    step transfer : TransferBefore[1] 
+	    	redefines outgoingTransfersFromSelf 
+	    	subsets changeObserver.incomingTransfers {
+	    	doc
+			/*
+			 * Then send changeSignal to changeObserver.
+			 */
+			 
+	    	end feature source {
+	    		feature redefines sourceOutput = changeSignal;
+	    	}
+	    	end feature target;
+	    }
+	}
+	
+	struct ChangeMonitor {
+		doc
+		/*
+		 * A ChangeMonitor is a collection of ongoing ChangeSignal observations 
+		 * for various observer Occurrences. It provides convenient operations for 
+		 * starting and canceling the observations it manages.
+		 */
+
+		private thisMonitor : ChangeMonitor redefines self;
+		private composite feature observations[0..*] : ObserveChange;
+		
+		private behavior AssignObservations specializes FeatureWritePerformance {
+			doc
+			/*
+			 * Assign a replacement set of observations as those being managed by a
+			 * given ChangeMonitor.
+			 */
+
+			in feature monitor : ChangeMonitor redefines onOccurrence {
+				feature redefines startingAt {
+					feature redefines accessedFeature, observations;
+				}
+			}
+			inout feature redefines replacementValues[0..*] : ObserveChange;
+		}
+		
+		step startObservation { 
+			doc
+			/*
+			 * Start an observation of a given ChangeSignal for a given Occurrence.
+			 */
+
+			in observer : Occurrence[1]; 
+			in signal : ChangeSignal[1];
+			private composite step observation : ObserveChange {
+				in changeObserver = observer;
+				in changeSignal = signal;
+			}
+			private composite step addObservation : AssignObservations[1] {
+				in monitor = thisMonitor; 
+				inout replacementValues = observations->including(observation);	
+			}
+		}
+		
+		step cancelObservation { 
+			doc
+			/*
+			 * Cancel all observations of a given ChangeSignal for a given Occurrence. 
+			 */
+
+			in observer : Occurrence[1]; 
+			in signal : ChangeSignal[1];
+			private feature observations[0..*] : ObserveChange = 
+				observations->select{in observation : ObserveChange; 
+					observation.changeObserver == observer and observation.changeSignal == signal
+				};
+			private composite step removeObservation : AssignObservations[1] {
+				in monitor = thisMonitor; 
+				inout replacementValues = observations->excluding(observations);
+			}
+		}
+	}	
+}

sysmlpy/library/kernel/OccurrenceFunctions.kerml

@@ -0,0 +1,154 @@
+standard library package OccurrenceFunctions {
+	doc
+	/*
+	 * This package defines utility functions that operate on occurrences, primarily related to 
+	 * time during which those occurrences exist.
+	 */
+	
+	private import Occurrences::Occurrence;
+	private import Occurrences::HappensDuring;
+	private import ScalarValues::Boolean;
+	private import ScalarValues::Positive;
+	private import SequenceFunctions::notEmpty;
+	private import SequenceFunctions::size;
+	private import SequenceFunctions::add;
+	private import SequenceFunctions::addAt;
+	private import SequenceFunctions::remove;
+	private import SequenceFunctions::removeAt;
+	private import ControlFunctions::forAll;
+	 
+	function '==='  specializes BaseFunctions::'===' { 
+		doc
+		/*
+		 * Test whether two occurrences are portions of the same life. That is, whether they 
+		 * represent different portions of the same entity (colloquially, whether they have
+		 * the same "identity").
+		 */
+		 
+		in x: Occurrence[0..1]; 
+		in y: Occurrence[0..1];
+		
+		return : Boolean[1] = x.portionOfLife == y.portionOfLife;
+	}
+	
+	function isDuring {
+		doc
+		/*
+		 * Test whether a performance of this function happens during the input occurrence.
+		 */
+		
+		in occ: Occurrence[1];
+		
+		private connector all during: HappensDuring[0..1] from self to occ;
+		
+		return : Boolean[1] = notEmpty(during);
+	}
+	
+	function create {
+		doc
+		/*
+		 * Ensure that the start of a given occurrence happens during a performance of this
+		 * function. The occurrence is also returned from the function.
+		 */
+		
+		inout occ: Occurrence[1];
+			
+		private connector : HappensDuring from occ.startShot to self;	
+		
+		return : Occurrence[1] = occ;
+	}
+	
+	function destroy {
+		doc
+		/*
+		 * Ensure that the end of a given occurrence happens during a performance of this
+		 * function. The occurrence is also returned from the function.
+		 */
+
+		inout occ: Occurrence[0..1];
+		
+		private connector : HappensDuring from [0..1] occ.endShot to self;
+		
+		return : Occurrence[0..1] = occ;
+	}
+	
+	function addNew {
+		doc
+		/*
+		 * Add a newly created occurrence to the given group of occurrences and return the
+		 * new occurrence.
+		 */
+
+		inout group: Occurrence[0..*] nonunique;
+		inout occ: Occurrence[1];
+		
+		private composite step : add {
+			inout seq1 = group;
+			in seq2 = create(occ);
+		}
+		
+		return : Occurrence[1] = occ;
+	}
+	
+	function addNewAt {
+		doc
+		/*
+		 * Add a newly created occurrence to the given ordered group of occurrences at the given
+		 * index and return the new occurrence.
+		 */
+
+		inout group: Occurrence[0..*] ordered nonunique;
+		inout occ: Occurrence[1];
+		in index: Positive[1];
+		
+		private composite step : addAt {
+			inout seq = group;
+			in values = create(occ);
+			in startIndex = index;
+		}
+		
+		return : Occurrence[1] = occ;
+	}
+	
+	behavior removeOld {
+		doc
+		/*
+		 * Remove a given occurrence from a group of occurrences and destroy it.
+		 */
+
+		inout group: Occurrence[0..*] nonunique;
+		inout occ: Occurrence[0..1];
+		
+		private composite step removeStep : remove {
+			inout seq = group;
+			in values = occ;
+		}
+		private succession removeStep then destroyStep;
+		private composite step destroyStep : destroy {
+			inout occ = removeOld::occ;
+		}
+		
+	}
+	
+	behavior removeOldAt {
+		doc
+		/*
+		 * Removes the occurrence at a given index in an ordered group of occurrences 
+		 * and destroy it.
+		 */
+		inout group: Occurrence[0..*] ordered nonunique;
+		in index: Positive[1];
+		
+		private feature oldOcc = group#(index);
+		
+		private composite step removeStep : remove {
+			inout seq = group;
+			in index = removeOldAt::index;
+		}
+		private succession removeStep then destroyStep;
+		private composite step destroyStep : destroy {
+			inout occ = oldOcc;
+		}
+		
+	}
+}