File size: 5,466 Bytes
5070096 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 |
standard library package Requirements {
doc
/*
* This package defines the base types for requirements and related elements in the SysML language.
*/
private import Base::Anything;
private import ScalarValues::String;
private import ControlFunctions::allTrue;
private import Constraints::constraintChecks;
private import Constraints::assertedConstraintChecks;
private import Constraints::negatedConstraintChecks;
private import Parts::Part;
private import Parts::parts;
private import Actions::Action;
private import Interfaces::Interface;
private import Attributes::AttributeValue;
private abstract constraint def RequirementConstraintCheck {
doc
/*
* RequirementConstraintCheck is the base ConstraintCheck for RequirementCheck, defining the
* separate assumptions and required constraints such that, if all the assumptions are true,
* then all the required constraints must be true.
*/
constraint assumptions[0..*] :> constraintChecks, subperformances {
doc
/*
* Assumptions that must hold for the required constraints to apply.
*/
}
constraint constraints[0..*] :> constraintChecks, subperformances {
doc
/*
* The required constraints that are to be checked.
*/
}
return result = allTrue(assumptions()) implies allTrue(constraints()) {
doc
/*
* If all the assumptions are true, then all the required constraints must hold.
*/
}
}
abstract requirement def RequirementCheck :> RequirementConstraintCheck {
doc
/*
* RequirementCheck is the most general class for requirements checking. RequirementsCheck is the base
* type of all requirement definitions.
*/
ref requirement :>> self: RequirementCheck;
subject subj : Anything[1] {
doc
/*
* The entity that is being checked for satisfaction of the required constraints.
*/
}
ref part actors : Part[0..*] {
doc
/*
* The Parts that fill the role of actors for this RequirementCheck.
* (Note: This is not itself an actor parameter, because specific actor
* parameters will be added for specific RequirementChecks.)
*/
}
ref part stakeholders : Part[0..*] {
doc
/*
* The Parts that represent stakeholders interested in the concern being checked.
* (Note: This is not itself a stakeholder parameter, because specific stakeholder
* parameters will be added for specific RequirementChecks.)
*/
}
/*
* Note: assumptions and constraints are redefined here solely to simplify the
* resolution of their qualified names as library elements.
*/
constraint assumptions :>> RequirementConstraintCheck::assumptions;
constraint constraints :>> RequirementConstraintCheck::constraints;
abstract requirement subrequirements[0..*] :> requirementChecks, constraints {
doc
/*
* Nested requirements, which are also required constraints.
*/
}
abstract concern concerns[0..*] :> concernChecks, subrequirements {
doc
/*
* The checks of any concerns being addressed (as required constraints).
*/
}
}
requirement def FunctionalRequirementCheck :> RequirementCheck {
doc
/*
* A functional requirement specifies an action that a system, or part of a system, must perform.
*/
subject: Action;
}
requirement def InterfaceRequirementCheck :> RequirementCheck {
doc
/*
* An interface requirement specifies an interface for connecting systems and system parts, which
* optionally may include item flows across the interface and/or interface constraints.
*/
subject: Interface;
}
requirement def PerformanceRequirementCheck :> RequirementCheck {
doc
/*
* A performance requirement quantitavely measures the extent to which a system, or a system part,
* satisfies a required capability or condition.
*/
subject: AttributeValue;
}
requirement def PhysicalRequirementCheck :> RequirementCheck {
doc
/*
* A physical requirement specifies physical characteristics and/or physical constraints of the
* system, or a system part.
*/
subject: Part;
}
requirement def DesignConstraintCheck :> RequirementCheck {
doc
/*
* A design constraint specifies a constraint on the implementation of the system or system part,
* such as the system must use a commercial off the shelf component.
*/
subject: Part;
}
concern def ConcernCheck :> RequirementCheck {
doc
/*
* ConcernCheck is the most general class for concern checking. ConcernCheck is the base type of
* all ConcernDefinitions.
*/
ref concern :>> self: ConcernCheck;
}
abstract requirement requirementChecks: RequirementCheck[0..*] nonunique :> constraintChecks {
doc
/*
* requirementChecks is the base feature of all requirement usages.
*/
}
abstract requirement satisfiedRequirementChecks :> requirementChecks, assertedConstraintChecks {
doc
/*
* satisfiedRequirementChecks is the subset of requirementChecks for Requirements asserted to be satisfied.
*/
}
abstract requirement notSatisfiedRequirementChecks: RequirementCheck[0..*] :> requirementChecks, negatedConstraintChecks {
doc
/*
* notSatisfiedRequirementChecks is the subset of requirementChecks for Requirements asserted to be not satisfied.
*/
}
abstract concern concernChecks: ConcernCheck[0..*] nonunique :> requirementChecks {
doc
/*
* concernChecks is the base feature of all ConcernUsages.
*/
}
} |