sysml-validate 0.11.0 → 0.14.2

package/resources/sysml.library/Systems Library/Flows.sysml

@@ -1,126 +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;
-    }
+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/resources/sysml.library/Systems Library/Interfaces.sysml

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