Descargar la presentación
La descarga está en progreso. Por favor, espere
Publicada porMario Bernardino Modificado hace 9 años
1
Arquitectura de software dirigida por modelos (Model-Driven Architecture)
Liliana Favre UNCPBA 2006
2
(OBJECT CONSTRAINT LANGUAGE)
EL LENGUAJE OCL (OBJECT CONSTRAINT LANGUAGE)
3
OCL OCL fue desarrollado por IBM como lenguaje de modelado de negocio. Surgió a partir del método Syntropy. Permite describir expresiones y restricciones en modelos y artefactos orientados a objetos Fue la contribución más importante de IBM a UML 1.1 Lenguaje de especificación “cuasi-formal” que combina cálculo de predicados y teoría de conjuntos. No tiene una semántica formal. El contexto sintáctico está determinado gráficamente. Su sintaxis es simple y está influenciada por la de los lenguajes orientados a objetos. Por ser un lenguaje de especificación no tiene efectos colaterales Es un lenguaje tipado
4
OCL En UML 1.1, OCL era un lenguaje de constraints
Un constraint es una restricción sobre uno o más valores (o partes) de un modelo orientado a objetos. En UML 2.0, OCL puede ser usado para escribir cualquier expresión sobre los elementos en el diagrama. Cada expresión indica un valor o un objeto en el sistema un integer, una referencia a un objeto, una colección de Valores, una colección de referencias a objetos, un mensaje en un diagrama de interacción, un objeto específico en un diagrama de objetos, etc
5
OCL OCL puede ser usado en modelos UML y metamodelos
con diferentes propósitos: Como lenguaje de navegación Para especificar invariantes sobre clases y tipos en modelos de clase Para especificar guardas en diagramas de estado Para describir precondiciones y postcondiciones sobre operaciones y métodos Para especificar invariantes en estereotipos … OCL ha sido usado para definir la semántica de UML
6
OCL Ejemplo context Flight
inv: passengers->size() <=plane.numberOfSeats context Flight::availableSeats(): Integer body: plane.numberOfSeats – passengers->size()
7
Ejemplo de diagrama de clase
8
Especificaciones en OCL
Las expresiones OCL se escriben en el contexto de una instancia de un tipo específico. Una declaración de contexto precede a la expresión OCL context Company La palabra reservada self se refiere a la instancia contextual
9
Objetos y propiedades Todos los clasificadores de los diagramas UML (interfaces, tipos de datos, componentes, nodos, casos de uso y subsistemas) son tipos válidos en las expresiones OCL y tienen asociadas propiedades. Las propiedades pueden ser atributos, association-ends, métodos y operaciones sin efectos colaterales (el atributo isQuery es True). El valor de una propiedad de un objeto definido en el diagrama de clases se especifica por un punto seguido por el nombre de la propiedad. self.numberOfEmployees > 50 self.age > 0
10
Invariantes Un invariante es un constraint con el estereotipo <<invariant>>. Se escribe en una declaración de contexto siguiendo al rótulo inv: context Company inv: self.numberOfEmployees > 50 La palabra reservada self puede omitirse. Un invariante puede referenciarse por un nombre escrito tras el rótulo inv: inv: enoughEmployees : numberOfEmployees > 50
11
Especificación de operaciones y métodos
context nombreTipo:: nombreOperacion (param1:Tipo1,…): TipoR pre: … post: …. body: ….
12
Precondiciones y postcondiciones
Las precondiciones y postcondiciones son constraints con el estereotipo <<precondition>> y <<postcondition>> respectivamente. Se escriben en una declaración de contexto siguiendo a los rótulos pre y post: context Typename::operationName(Param1:Type1,...):ReturnType pre:[ parameterOk:] --expresión OCL de self y parámetros post: [resultOk:] result = ... body:--alguna expresión OCL
13
Precondiciones-Postcondiciones-Invariantes
La notación package Package :: SubPackage context X inv: context X:: OperationName (...) endpackage permite expresar a que Package pertenecen precondiciones, postcondiciones e invariantes
14
Operaciones y métodos La notación utilizada para operaciones aplicadas a una instancia es nombreInstancia. nombreOperacion ( [argumentos]) context Company self. NumberOfEmployees ( ) denota la aplicación de la operación NumberOfEmployees a la instancia contextual self.
15
Contratos OCL Un contrato en OCL se define por precondiciones y
postcondiciones que pueden referirse a dos conjuntos de valores para cada propiedad de un objeto: el valor de la propiedad al comienzo de la operación y el valor de la propiedad después de completada la operación El valor de la propiedad nombre antes de la ejecución se denota por context Company:: HireEmployee ( p: Person) pre: not employee -> includes ( p) post: employee = -> including ( p)
16
Navegación y asociaciones
Se puede navegar una asociación a partir de un objeto específico para acceder a otros objetos conectados por la asociación o a sus propiedades mediante la sintaxis objecto. rol context Person self. employer Si el rol no figura en el diagrama por convención se le asocia el nombre de la clase con letras minúsculas. self. manager es la instancia de Person asociada a la instancia contextual self dado que la multiplicidad es 1. self. managedCompany evalúa a un conjunto de instancias de Company dado que la multiplicidad es 0..*. Si la asociación sobre el diagrama de clases está adornada por {ordered} la navegación retorna una secuencia. OCL provee a los tipos Set, Bag y Sequence como tipos predefinidos.
17
Navegación y asociaciones
El acceso a una propiedad de la colección se denota por coleccion->nombrePropiedad context Person inv: self.employer->size ( ) < 3 self.manager.age > 40 self.manager -> size( ) =1 La multiplicidad de manager es 1, self.manager puede usarse como Person o como Set(Person). En self. manager. age > 40 la subexpresión self. manager es usada como Person porque el punto indica el acceso a la propiedad age de Person. En self. manager -> size()=1 , la expresión self.manager es usada como Set(Person) y la -> accede a la propiedad size sobre conjuntos.
18
Navegación y asociaciones
La navegación desde una Association Class a uno de los objetos de la asociación siempre entrega un objeto. Las asociaciones calificadas usan uno o más atributos calificadores para seleccionar objetos object.navigation[qualifierValue, ...] context Bank self.customer –Set[Person] todos los clientes del banco self.customer [ ] —la persona con cuenta
19
Herencia y propiedades
Pueden heredarse diferentes propiedades con nombres idénticos desde diferentes superclases. Esta ambigüedad puede resolverse en OCL precediendo a una propiedad por el camino de herencia. self.A:: p --accede a la propiedad p de A self.B:: p --accede a la propiedad p de B
20
Propiedades predefinidas sobre objetos
OclIsTypeOf (t : Ocltype ): Boolean --Evalúa True si self y t son del mismo tipo OclIsKindOf (t : OclType): Boolean --Evalúa True si t es del tipo o supertipo de un objeto OclIsNew ( ): Boolean --Evalúa True si al ser usado en una postcondición el objeto es creado durante la ejecución de la operación OclAsType ( t : OclType ) : instance of OclType --Evalúa al objeto como del tipo OclType
21
Propiedades predefinidas sobre objetos
OclIsTypeOf (t : Ocltype ): Boolean --Evalúa True si self y t son del mismo tipo context Person inv:self.oclIsTypeOf(Person) – verdadero self. oclIsTypeOf (Company) -- falso OclIsKindOf (t : OclType): Boolean --Evalúa True si t es del tipo o supertipo de un objeto context Set inv: self.oclIsKindOf(Collection) - - Verdadero
22
Propiedades predefinidas sobre clases
allInstances --Es el conjunto de todas las instancias del tipo en el momento en que la expresión es evaluada Person.allInstances() es del tipo Set(Person) y es el conjunto de todas las personas que existen en el sistema cuando la expresión es evaluada
23
Tipos OCL Tipos predefinidos Tipos definidos por el usuario
Básicos (Integer, Real, String, Boolean y Enumerate) Colecciones (Collection, Set, Ordered-Set, Bag, Sequence) Tipos definidos por el usuario Jerarquía de tipos Un tipo t conforma a otro t1 cuando una instancia de tipo t puede ser sustituida por una de tipo t1: -Cada tipo conforma a sus supertipos. -Si t1 conforma a t2, y t2 conforma a t3, luego t1 conforma a t3.
24
Tipos predefinidos- Boolean
b = (b2:Boolean) : Boolean b or (b2 : Boolean) : Boolean b xor (b2: Boolean) : Boolean post: (b or b2) and not (b = b2) b and ( b2: Boolean) : Boolean not b : Boolean post: if b then result = false else result = true endif b implies ( b2: Boolean) : Boolean post: (not b) or ( b and b2) = if b then (expression1:OclExpression) else (expression2 :OclExpression):expression1. evaluationType
25
Tipos predefinidos- Boolean
b = (b2:Boolean) : Boolean b or (b2 : Boolean) : Boolean b xor (b2: Boolean) : Boolean post: (b or b2) and not (b = b2) b and ( b2: Boolean) : Boolean not b : Boolean post: if b then result = false else result = true endif b implies ( b2: Boolean) : Boolean post: (not b) or ( b and b2) = if b then (expression1:OclExpression) else (expression2 :OclExpression):expression1. evaluationType
26
Tipos predefinidos- Real
r = (r2 :Real) : Boolean r < > (r2 :Real) : Boolean r + (r1: Real) : Real r – (r1 :Real) : Real r * (r1 :Real) :Real r / (r1:Real) : Real r. abs : Real post: if r < 0 then result = -r else result = r endif r. floor : Integer post: (result <= r) and result + 1 > r endif
27
Tipos predefinidos- Real
r.max (r2:Real) : Real post: if r >= r2 then result = r else result = r2 endif r.min (r2: Real ) : Real post: if r <= r2 then result = r else result = r2 endif r < ( r2:Real) : Boolean r > ( r2:Real) : Boolean post: result = not (r <= r2) r <= ( r2:Real) : Boolean post: result = (r = r2) or (r < r2) r >= ( r2:Real) : Boolean post: result = (r =r2) or ( r > r2)
28
Tipos predefinidos- Integer
i = (i2 : Integer) : Boolean i + (i2: Integer) : Integer i – ( i2: Integer) : Integer i * (i2: Integer) : Integer i / (i2:Integer) : Real i.abs : Integer i.div (i2: Integer) : Integer i.mod (i2 : Integer) : Integer i.max ( i2 : Integer) : Integer i.min ( i2: Integer) : Integer
29
Tipos predefinidos- String
string = (string2 : String) : Boolean string.size : Integer string.concat (string2: String): String string.toUpper : String string.toLower : String string.substring (lower: Integer, upper: Integer) : String
30
Tipos predefinidos Enumeration
enumeration = ( enumeration2 : boolean ) : Boolean enumeration <> (enumeration2 : Boolean) : Boolean post: result = not (enumeration = enumeration2) context Person inv: gender = Gender::male
31
Tipos predefinidos Collection
Set Sequence Bag OrderedSet
32
Tipos predefinidos Collection
Las operaciones sobre colecciones se denotan por expresiones OCL usando la siguiente notación: <collection> <operation> Operaciones que permiten iterar sobre sus elementos: select, reject, collect, iterate, forAll y exists. Estas operaciones toman cada elemento de la secuencia y evalúan una expresión sobre ellos.
33
Collection La operación select
Sintaxis collection select(element:Type|<boolean-exp-with-element>) collectionselect(element|<boolean-exp-with-element>) collectionselect(<boolean- expr-with-element>) context Company self.employee->select(p:Person| p.age>50)->notEmpty() self.employee->select(p | p.age>50)->notEmpty() self.employee->select(age>50)->notEmpty()
34
Collection La operación reject
Sintaxis collection reject(element:Type|<boolean-exp-with-element>) collectionreject(element|<boolean-exp-with-element>) collectionreject(<boolean- expr-with-element>) context Company self.employee->reject(p:Person| p.isMarried)->notEmpty() self.employee->reject(p | p.isMarried)->notEmpty() self.employee->reject(isMarried)->notEmpty()
35
Collection La operación Collect
La operación collect itera sobre una colección, calcula un valor para cada elemento de la colección, y retorna una colección cuyos elementos son los valores evaluados. El tipo de los elementos en la colección resultante es usualmente diferente del tipo de elementos en la colección original. El resultado sobre un conjunto o un bag es un bag y sobre secuencias una secuencia.
36
Collection La operación Collect
Sintaxis collection collect(element:Type|<boolean-exp-with-element>) collectioncollect(element|<boolean-exp-with-element>) collectioncollect (<boolean- expr-with-element>) context Company self.employee->collect(p:Person| p.birthDate) self.employee->collect(p | p.birthDate) self.employee->collect(birthDate)
37
Collection La operación Collect
Notación concisa collection.propertyname es a equivalente a collection collect(propertyname) self.employee.birthDate
38
Collection La operación forAll
Sintaxis collection forAll(element:Type|<boolean-exp-with-element>) collectionforAll(element|<boolean-exp-with-element>) collectionforAll(<boolean- expr-element>) self.employee forAll(age > 18) self.employee forAll (p | p.age > 18) self.employee forAll (person p | p.age > 18)
39
Collection La operación exists
Sintaxis collection exits(element:Type|<boolean-exp-with-elem>) collectionexists(element|<boolean-exp-with-elem>) collectionexists(<boolean- expr>) self.employee exists(forename = “john”) self.employee exists (p | p.forename = ”john”) self.employee exists (person p | p.forename =”John”)
40
Collection La operación iterate
Sintaxis collection iterate (elem:Type1; result: Type2= <expression> | expr-with-elem-and–result>) result podría ser calculado mediante result = <expression>; while (collection.notEmpty ()) do elem =collection.nextElement(); result = <expression-with-elem-and-result>; endwhile return result;
41
Collection La operación iterate
collection size : Integer --The number of elements in the collection collection. post: result = collection iterate (elem; acc: Integer = 0| acc+1 ) collection collect ( x: T | x.property) collection iterate(elem:T;result:T2=Bag{})|resultincluding(x.property)) self.employee->collect(p:Person| p.birthDate) es equivalente a self.employee-> iterate(p:Person;result= Bag{} | resultincluding(p.birthDate))
42
Collection collection size : Integer
--The number of elements in the collection collection post: result = collection iterate (elem; acc: Integer = 0 | acc+1 ) collection includes (object: OclAny ) : Boolean --True if object is an element of collection, false otherwise post: result = (collection count (object) > 0) collection -> excludes ( object : OclAny ) : Boolean --True if object is not an element of collection, false otherwise post: result = (collection -> count ( object) = 0)
43
Collection collection isEmpty : Boolean
--Is collection the empty collection? post: result = (collection size=0) collection notEmpty :Boolean --Is collection not the empty collection? post: result =(collection size <> 0) collection -> sum ( ) : T --The addition of all elements in collection. Elements must be of a --type supporting the + operation, associative and commutative. post : result = collection -> iterate ( elem; acc: T = 0 | acc + elem)
44
Collection collection forAll (expr:OclExpression) :Boolean
--Results in true if expr evaluates to true for each element in collection; otherwise , result is false. post: result= collection iterate (elem; acc:Boolean = true acc and exp) collection exists (expr:OclExpression) :Boolean --Results in true if expr evaluates to true for at least one element in collection; otherwise, result is false. post: result = collection iterate (elem; acc: Boolean = false acc or exp) collection iterate (expr: OclExpression) : expr.evaluationType( ) --Iterate over the collection.
45
Collection collection -> any ( expr :OclExpression) : T
--Returns any element in the collection for which expr evaluates to true. If there is more than one element for which expression is true, one of them is returned. pre: collection -> exists ( expr) post : collection -> select ( expr) -> includes ( result) collection -> one ( expr : OclExpression ) : Boolean --Results in true if there is exactly one element in the collection for which expr is true. post: collection - > select ( expr) -> size ( ) = 1 collection -> isUnique ( expr : OclExpression ) : Boolean --Results in true if expr evaluates to a differente value for each element in collection; otherwise results is false. post: let values = collection -> collect ( expr) in result = res -> forAll ( e | values -> count ( e) = 1)
46
Collection collectioncount (object: OclAny):Integer
--The number of times that object occurs in collection post: result= collection iterate( elem; acc:Integer=0 | if elem =object then acc+1 else acc endif) collection includesAll (c2:Collection(T)) :Boolean --Does collection contain all the elements of c2? post: result= (c2 forAll (elemcollectionincludes(elem)) collection excludesAll (c2:Collection(T)) : Boolean --Does collection contain none of the elements of c2? post:result=(c2 forAll (elemcollection-> excludes (elem))
47
Set set count (object:T) : Integer
--The number of occurrences of object in set. post: result < = 1 set union (set2: Set(T)) : Set (T) --The union of set and set2. post: result -> forAll ( elem | set -> includes ( elem) or set2 -> includes ( elem)) post: set -> forAll ( elem | result -> includes ( elem)) post: set2 -> forAll ( elem | result -> includes ( elem)) set union (bag: Bag(T)) : Bag (T) post: result -> forAll ( elem | result -> count (elem) = set -> count (elem) + bag -> count (elem)) post: set -> forAll ( elem | result -> includes (elem)) post: bag -> forAll (elem | result -> includes (elem)) set = (set2: Set): Boolean post: result = (set forAll (elem | set2 includes(elem) and set2 forAll ( elem | set -> includes(elem
48
Set set intersection (set2: Set(T)): Set(T)
post: result -> forAll ( elem | set -> includes (elem) and set2 -> includes ( elem)) post: set -> forAll ( elem | set2 -> includes ( elem) = result -> includes (elem)) post: set2 -> forAll ( elem | set -> includes ( elem0 = result -> includes ( elem)) set intersection (bag: Bag(T)): Set(T) post: result = set intersection (bag asSet) set - (set2: Set(T)): Set(T) post: result -> forAll (elem | set -> includes (elem) and set2 -> excludes (elem)) post: set -> forAll (elem | result -> includes (elem) = set2 -> excludes (elem)) set including (object: T) : Set(T) --The set containing all elements of set plus object. post: result -> forAll (elem | set -> includes (elem) or (elem = object)) post: set -> forAll (elem | result -> includes (elem)) post: result -> includes (object)
49
Set set excluding (object: T) : Set(T)
--The set containing all elements of set without object. post: result -> forAll (elem | set -> includes (elem) and (elem <> object) post : set -> forAll (elem | result -> includes (elem)= object < > elem))) post : result -> excludes (object) set symmetricDifference (set2: Set(T)): Set(T) post: result -> forAll ( elem | set -> includes (elem) xor set2 -> includes (elem)) post: set -> forAll (elem | result -> includes (elem) = set2 -> excludes (elem)) post: set2 -> forAll (elem | result -> includes (elem) = set -> excludes (elem)) set select (expression: OclExpression) : Set(exp.type) post: result = set iterate (elem; acc: Set(T) = Set{} if expression then acc including (elem) else acc endif ) set reject (expression: OclExpression) : Set (exp.type) post: result = set select (not expression)
50
Set set collect (expression: OclExpression) :
Bag(expression.OclType) --The Bag that results from applying expr to every member of set. post: result=set iterate (elem; acc:Bag (T) = Bag{} acc including (expression)) set asSequence ( ) : Sequence (T) --A Sequence that contains all the elements from set, in undefined order. post: result -> forAll (elem | set -> includes(elem)) post: set -> forAll (elem | result -> count (elem) =1) set asBag ( ) : Bag (T) --The Bag that contains all the elements from set post: result -> forAll (elem | set -> includes (elem)) post: set -> forAll (elem | result -> count (elem) = 1)
51
Bag bag = (bag2: Bag(T)) : Boolean
post: result = (bag -> forAll (elem | bag -> count (elem) = bag2 -> count (elem)) and bag2 -> forAll (elem | bag2 -> count (elem) = bag-> count(elem))) bag union (bag2: Bag(T)) : Bag (T) --The union of bag and bag2 post: result -> forAll (elem | result -> count (elem) = bag-> count (elem) + bag2 -> count (elem)) post: bag -> forAll ( elem | result -> count (elem) = bag -> count (elem) + bag2 ->count (elem)) post: bag2 -> forAll (elem | result -> count (elem) = bag -> count(elem) + bag2 -> count(elem))
52
Bag bag union (set: Set) : Bag (T)
post: result -> forAll (elem | result -> count (elem) = bag -> count (elem) + set -> count (elem)) post: bag -> forAll (elem | result -> count (elem) = bag -> count (elem) + set -> count (elem)) post: set -> forAll (elem | result -> count (elem) = bag -> bag intersection (bag2: Bag(T)): Bag(T) post: result -> forAll (elem | result -> count (elem) = bag -> count (elem). min (bag2 -> count (elem))) post: bag -> forAll (elem | result -> count (elem) = bag -> count (elem). min (bag2 -> count (elem))) post: bag2 -> forAll (elem | result -> count (elem) = bag -> count (elem). min (bag2-> count (elem))
53
Bag bag intersection (set: Set(T)): Set(T)
post: result -> forAll (elem | result -> count (elem) = bag -> count (elem). min (set -> count (elem))) post: bag -> forAll (elem | result -> count (elem) = bag -> count (elem). min (set -> count (elem))) post: set -> forAll (elem | result -> count (elem) = bag -> count (elem). min (set-> count (elem))) bag including (object: T) : Bag(T) --The bag containing all elements of bag plus object post: result -> forAll (elem | if elem = object then result -> count (elem) = bag -> count (elem) else result-> count (elem) = bag-> count (elem) endif) post: bag -> forAll (elem | if elem = object then result-> count (elem) = bag -> count (elem) else result -> count (elem) = bag -> count(elem) endif)
54
Bag bag excluding (object: T) : Bag(T)
--The bag containing all elements of bag apart from all ocurrences of object post: result -> forAll (elem | if elem =object then result -> count (elem) = 0 else result -> count(elem) = bag -> count(elem) endif) post: bag -> forAll (elem | if elem = object then result->count(elem) = 0 else result->count(elem) = bag->count(elem) endif)
55
Bag bag select (expr: OclExpression) : Bag(T)
--The sub-bag of bag for which expr is true. post: result =bag iterate(elem; acc: Bag (T)=Bag{} if expr then acc including (elem) else acc endi ) bag reject (expr: OclExpression) : Bag(T) --The sub-bag of bag for which expr is false. post: result = bag select (not expr) bag collect (expr: OclExpression) : Bag(expr.OclType) --The Bag of elements that results from applying expr to every member of bag. post: result =bag iterate(elem; acc: Bag(expr.evaluationType( )=T) = Bag{} acc including(exp))
56
Bag bag count (object:T) : Integer
--The number of ocurrences of object in bag. bag asSequence ( ) : Sequence (T) --A Sequence that contains all the elements from bag, in undefined order. post: result -> forAll (elem | bag -> count (elem) = result -> count (elem)) post: bag -> forAll (elem | bag -> count (elem) = bag asSet ( ) : Set (T) --The Set containing all the elements from bag, with duplicates removed. post: result -> forAll (elem | bag -> includes (elem)) post: bag -> forAll (elem | result -> includes (elem))
57
Sequence sequence = (sequence2: Sequence(T)) : Boolean
--True if sequence contains the same elements as sequence2 in the same order. post: result= Sequence{1..sequence2 size() } forAll(index: Integer | sequence size() = sequence2 size() ) and sequence at(index) = sequence2 at(index)) sequence union (sequence2: Sequence(T)) : Sequence (T) --The sequence consisting of all elements in sequence, followed by all elements --in sequence2. post: result size() = sequence size() + sequence2 size() post: Sequence{1..sequence size } forAll(index:Integer | sequence at(index) = result at(index)) post: Sequence{1..sequence2 size() } forAll (index:Integer | sequence2 at(index) = result at(index + sequence size() )
58
Sequence sequence append (object: T) : Sequence (T)
--The sequence of elements , consisting of all elements of sequence, followed object. post: result size() = sequence size() +1 post: result at(result size()) = object post: Sequence{1..sequence size() } forAll(index:Integer | result at(index) = sequence at(index)) sequence prepend (object: T) : Sequence (T) --The sequence consisting of object, followed by all elements in sequence. post: result at(1) = object post: Sequence{1..sequence size ( ) } forAll (index:Integer | sequence at(index) = result at (index+1))
59
Sequence sequence subSequence (lower:Integer, upper: Integer) : Sequence (T) --The sub-sequence of sequence starting at number lower, up to and including --element number upper. pre: 1 <= lower pre: lower <= upper pre: upper <= sequence-> size ( ) post: result -> size( ) = upper – lower + 1 post: Sequence{lower .. upper } forAll( index | result at (index – lower +1) = sequence at (index)) sequence at (i:Integer) : T --The i-th element off sequence pre: i>= 1 and i<= sequence->size ( ) bag count (object:T) : Integer --The number of ocurrences of object in bag.
60
Sequence bag asSequence ( ) : Sequence (T)
--A Sequence that contains all the elements from bag, in undefined order. post: result -> forAll (elem | bag -> count (elem) = result -> count (elem)) post: bag -> forAll (elem | bag -> count (elem) = result -> count (elem)) bag asSet ( ) : Set (T) --The Set containing all the elements from bag, with duplicates removed. post: result -> forAll (elem | bag -> includes (elem)) post: bag -> forAll (elem | result -> includes (elem)) sequence first : T --The first element in sequence post: result = sequence at (1)
61
Sequence sequence last : T --The last element in sequence
post: result = sequence at (sequence size ( ) ) sequence including (object: T) : Sequence(T) --The sequence containing all elements of sequence plus object added as the last element post: result = sequence.append(object) sequence excluding (object: T) : Sequence(T) --The sequence containing all elements of sequence apart from all ocurrences of object. --The order of the remaining elements is not changed. post: result -> includes (object ) = false post: result -> size ( ) = sequence -> size ( ) – sequence -> count (object) post: result = sequence iterate(elem; acc: Sequence(T) = Sequence {} | if elem = object then acc else acc append (elem) endif )
62
Sequence sequence select (expr: OclExpression) : Sequence(T)
--The subsequence of sequence for which expr is true. post: result = sequence iterate (elem; acc: Sequence(T) =Sequence {} | if expr then acc including (elem) else acc endif ) sequence reject (expr: OclExpression) : Sequence(T) --The subsequence of sequence for which expr is false. post: result = sequence select (not expr) sequence collect (expr: OclExpression) : Sequence(expr.OclType) --The Sequence of elements that results from applying expr to every member of sequence.
63
Sequence sequence select (expr: OclExpression) : Sequence(T)
--The subsequence of sequence for which expr is true. post: result = sequence iterate (elem; acc: Sequence(T) =Sequence {} | if expr then acc including (elem) else acc endif ) sequence reject (expr: OclExpression) : Sequence(T) --The subsequence of sequence for which expr is false. post: result = sequence select (not expr) sequence collect (expr: OclExpression) : Sequence(expr.OclType) --The Sequence of elements that results from applying expr to every member of sequence.
64
Sequence sequence collect (expr: OclExpression) : expr.OclType
--Iterates over the sequence. Iteration will be done from element at position 1 --up until the element at the last position following the order of the sequence. sequence asSet ( ) : Set (T) --The Set containing all the elements from sequence, including duplicates. post: result -> forAll (elem | sequence -> includes (elem)) post: sequence -> forAll (elem | result -> includes (elem)) sequence asBag ( ) : Bag (T) --The Bag containing all the elements from sequence, including duplicates. post: result -> forAll (elem | sequence -> count(elem) = result -> count(elem)) post: sequence -> forAll (elem | sequence -> count (elem) =
65
Reglas de subtyping- Collection
Reglas estándar Type1 conforma a Type2 cuando son idénticos Type1 conforma a Type2 cuando Type1 es subtipo de Type2 Si Type1 conforma a Type2, y Type2 conforma a Type3, luego Type1 conforma a Type3 + Los tipos Set(x), Bag(x) y Sequence(x) son subtipos de Collection Collection(Type1) conforma a Collection(Type2) cuando Type1 conforma a Type2. Esto vale para Set(Type1)/ Set(Type2), Bag(Type1)/ Bag(Type2) y Sequence(Type1)/ Sequence(Type2)
66
Tipos predefinidos Tuplas
Tuple {name:String =´John´, age:Integer = 10} Tuple{a:Collection (Integer) = Set {1,2,3}, b:String = ´foo´, c:Strinh = ´bar´} Los tipos son opcionales y no importa el orden. Los valores de las partes pueden ser expresiones OCL arbitrarias Las partes se acceden por su nombre: Tuple{x:Integer = 5, y:String =´li´}.x = 5
67
Ejemplo- “Mortgage System”
68
Ejemplo “Mortgage System”
context Mortgage --Una persona pude tener una hipoteca sobre una casa si es el propietario inv: security.owner = borrower inv: startDate < endDate context Person --socSecNr debe ser único inv: Person::allInstances () ->isUnique(socSecNr)
69
Ejemplo “Mortgage System”
context Person::getMortage(sum:Money, security: House) --será permitida una nueva hipoteca si los ingresos son suficientes pre: self.mortgages.monthlyPayment->sum()<= self.salary * 0.30 context Person::getMortgage (sum:money, security: House) --Se admite un nuevo crédito sólo si el valor de la casa es suficiente pre:security.value >= security.mortgages.principal->sum()
70
Ejemplo “Mortgage System”
Ciclos en el diagrama de clases context Person inv: self.mortgages.security.owner -> forAll (owner:Person | owner = self)
71
Elementos derivados en UML/OCL
Un elemento derivado en UML se distingue añadiendo un símbolo ¨/¨ delante de su nombre. Por ejemplo, se puede indicar que un atributo es derivado, es decir que se puede calcular su valor en un cierto objeto si se conoce el valor de los atributos normales del objeto y se tiene acceso a otros objetos que conoce.
72
Asociaciones derivadas
73
Valores derivados e iniciales
74
Ejemplo “Royal and Loyal System”
75
Valores derivados “Royal and Loyal System”
context TransactionReportLine::partnerName :String derive:transaction.generatedBy.partner.name context TransactionReportLine::serviceDesc:String derive:transaction.generatedBy.description context TransactionReportLine::points: Integer context TransactionReportLine:: amount : Real derive: transaction.amount context TransactionReportLine::date : Date derive:transaction.date
76
Valores derivados “Royal and Loyal System”
context TransactionReport::totalEarned : Integer derive: lines.transaction->select(oclIsTypeOf (Earning)). points->sum() context TransactionReport::totalBurned: Integer lines.transaction-> select (oclIsTypeOf (Burning)).Points ->sum()
77
Valores iniciales “Royal and Loyal System”
context Typename::attributeName: Type init:-- una expresión que representa el valor inicial context LoyaltyAccount::points init: 0 context CustomerCard::valid init: true
78
Definiciones de atributos y operaciones
context Customer def: wellUsedCards : Set( CustomerCard ) = cards->select( transactions.points->sum() > 10,000 ) def: loyalToCompanies : Bag( ProgramPartner ) = programs.partners def: cardsForProgram(p: LoyaltyProgram) : Set(Cards) =p.Membership.card
79
Multiplicidad opcional
La multiplicidad de una asociación es opcional si el límite inferior es 0. Cuando un objeto asociado puede o debe estar presente depende del estado de los objetos involucrados context Person inv optionality: mortgages ->notEmpty() implies houses ->notEmpty()
80
Constraints y asociaciones
81
Constraints y asociaciones
context Person inv: wife.employers-> intersection(self.employers)->isEmpty() and husband.employer>intersection(self.employers>isEmpty() context Company inv: employees.wife-> intersection(self.employees)->isEmpty()
82
Constraints y asociaciones OR
Sólo una de las potenciales asociaciones puede ser instanciada para un simple objeto context Person Inv: managedProject->isEmpty() or performedProject->isEmpty() context Project inv: projectLeader->isEmpty() or projectMember ->isEmpty()
83
Constraints y asociaciones Subset
84
Constraints y asociaciones Subset
context Flight inv: self.crew->includes(self.pilot) inv: self.crew>includesAll(self.flightAttendants) context Person inv: self.flights->includes(self.captainOn) inv: self.flights->includesAll(self.attendedOn)
85
Mensajes en postcondiciones
Operador hasSent ('^') context Subject::hasChanged() post: observer^update(12, 14) observer^update(12, 14) es True si el mensaje update con argumentos 12 y 14 fue enviado a un objeto observer durante la ejecución de la operación hasChanged().
86
Expresión LET Posibilita definir una variable que puede ser usada
en lugar de una subexpresión context CustomerCard inv: let correctDate: Boolean = self.validFrom.IsBefore (Date::now) and self.goodThru.isAfter (Date::now) in if valid then correctDate = true else correctDate = false endif
87
Bibliografía OCL: OCL Specification. Version 2.0. Formal
document: ptc/ Klasse Objecten Website: Warmer, J., Kleppe, A. The Object-Constraint Language. (Second Edition). Addison Wesley (2003)
Presentaciones similares
© 2024 SlidePlayer.es Inc.
All rights reserved.