Arquitectura de software dirigida por modelos Model-Driven Architecture

Arquitectura de software dirigida por modelos (Model-Driven Architecture) Liliana Favre UNCPBA 2006

EL LENGUAJE OCL (OBJECT CONSTRAINT LANGUAGE)

OCL n n n n 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

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

OCL puede ser usado en modelos UML y metamodelos con diferentes propósitos: n Como lenguaje de navegación n Para especificar invariantes sobre clases y tipos en modelos de clase n Para especificar guardas en diagramas de estado n Para describir precondiciones y postcondiciones sobre operaciones y métodos n Para especificar invariantes en estereotipos n … OCL ha sido usado para definir la semántica de UML

OCL Ejemplo context Flight inv: passengers->size() <=plane. number. Of. Seats context Flight: : available. Seats(): Integer body: plane. number. Of. Seats – passengers->size()

Ejemplo de diagrama de clase

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

Objetos y propiedades n n 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 is. Query 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. number. Of. Employees > 50 self. age > 0

Invariantes Un invariante es un constraint con el estereotipo <>. Se escribe en una declaración de contexto siguiendo al rótulo inv: context Company inv: self. number. Of. Employees > 50 La palabra reservada self puede omitirse. Un invariante puede referenciarse por un nombre escrito tras el rótulo inv: context Company inv: enough. Employees : number. Of. Employees > 50

Especificación de operaciones y métodos context nombre. Tipo: : nombre. Operacion (param 1: Tipo 1, …): Tipo. R pre: … post: …. body: ….

Precondiciones y postcondiciones Las precondiciones y postcondiciones son constraints con el estereotipo <> y <> respectivamente. Se escriben en una declaración de contexto siguiendo a los rótulos pre y post: context Typename: : operation. Name(Param 1: Type 1, . . . ): Return. Type pre: [ parameter. Ok: ] --expresión OCL de self y parámetros post: [result. Ok: ] result =. . . body: --alguna expresión OCL

Precondiciones-Postcondiciones. Invariantes La notación package Package : : Sub. Package context X inv: context X: : Operation. Name (. . . ) endpackage permite expresar a que Package pertenecen precondiciones, postcondiciones e invariantes

Operaciones y métodos La notación utilizada para operaciones aplicadas a una instancia es nombre. Instancia. nombre. Operacion ( [argumentos]) context Company self. Number. Of. Employees ( ) denota la aplicación de la operación Number. Of. Employees a la instancia contextual self.

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: n n el valor de la propiedad al comienzo de la operación el valor de la propiedad después de completada la operación y El valor de la propiedad nombre antes de la ejecución se denota por nombre@pre context Company: : Hire. Employee ( p: Person) pre: not employee -> includes ( p) post: employee = employee@pre -> including ( p)

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. managed. Company 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.

Navegación y asociaciones El acceso a una propiedad de la colección se denota por coleccion->nombre. Propiedad 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). n 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. n En self. manager -> size()=1 , la expresión self. manager es usada como Set(Person) y la -> accede a la propiedad size sobre conjuntos.

Navegación y asociaciones La navegación desde una Association Class a uno de los objetos de la asociación siempre entrega un objeto. n Las asociaciones calificadas usan uno o más atributos calificadores para seleccionar objetos object. navigation[qualifier. Value, . . . ] n context Bank self. customer –Set[Person] todos los clientes del banco self. customer [99564242] —la persona con cuenta 99564242

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

Propiedades predefinidas sobre objetos Ocl. Is. Type. Of (t : Ocltype ): Boolean --Evalúa True si self y t son del mismo tipo n Ocl. Is. Kind. Of (t : Ocl. Type): Boolean --Evalúa True si t es del tipo o supertipo de un objeto n Ocl. Is. New ( ): Boolean --Evalúa True si al ser usado en una postcondición el objeto es creado durante la ejecución de la operación n Ocl. As. Type ( t : Ocl. Type ) : instance of Ocl. Type --Evalúa al objeto como del tipo Ocl. Type n

Propiedades predefinidas sobre objetos Ocl. Is. Type. Of (t : Ocltype ): Boolean --Evalúa True si self y t son del mismo tipo context Person inv: self. ocl. Is. Type. Of(Person) – verdadero self. ocl. Is. Type. Of (Company) -- falso n Ocl. Is. Kind. Of (t : Ocl. Type): Boolean --Evalúa True si t es del tipo o supertipo de un objeto n context Set inv: self. ocl. Is. Kind. Of(Collection) - - Verdadero

Propiedades predefinidas sobre clases all. Instances --Es el conjunto de todas las instancias del tipo en el momento en que la expresión es evaluada Person. all. Instances() es del tipo Set(Person) y es el conjunto de todas las personas que existen en el sistema cuando la expresión es evaluada n

Tipos OCL n Tipos predefinidos n Básicos (Integer, Real, String, Boolean y Enumerate) n Colecciones (Collection, Set, Ordered-Set, Bag, Sequence) Tipos definidos por el usuario n Jerarquía de tipos Un tipo t conforma a otro t 1 cuando una instancia de tipo t puede ser sustituida por una de tipo t 1: -Cada tipo conforma a sus supertipos. -Si t 1 conforma a t 2, y t 2 conforma a t 3, luego t 1 conforma a t 3. n

Tipos predefinidos. Boolean b = (b 2: Boolean) : Boolean b or (b 2 : Boolean) : Boolean b xor (b 2: Boolean) : Boolean post: (b or b 2) and not (b = b 2) b and ( b 2: Boolean) : Boolean not b : Boolean post: if b then result = false else result = true endif b implies ( b 2: Boolean) : Boolean post: (not b) or ( b and b 2) = if b then (expression 1: Ocl. Expression) else (expression 2 : Ocl. Expression): expression 1. evaluation. Type

Tipos predefinidos. Boolean b = (b 2: Boolean) : Boolean b or (b 2 : Boolean) : Boolean b xor (b 2: Boolean) : Boolean post: (b or b 2) and not (b = b 2) b and ( b 2: Boolean) : Boolean not b : Boolean post: if b then result = false else result = true endif b implies ( b 2: Boolean) : Boolean post: (not b) or ( b and b 2) = if b then (expression 1: Ocl. Expression) else (expression 2 : Ocl. Expression): expression 1. evaluation. Type

Tipos predefinidos. Real r = (r 2 : Real) : Boolean r < > (r 2 : Real) : Boolean r + (r 1: Real) : Real r – (r 1 : Real) : Real r * (r 1 : Real) : Real r / (r 1: 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

Tipos predefinidos. Real r. max (r 2: Real) : Real post: if r >= r 2 then result = r else result = r 2 endif r. min (r 2: Real ) : Real post: if r <= r 2 then result = r else result = r 2 endif r < ( r 2: Real) : Boolean r > ( r 2: Real) : Boolean post: result = not (r <= r 2) r <= ( r 2: Real) : Boolean post: result = (r = r 2) or (r < r 2) r >= ( r 2: Real) : Boolean post: result = (r =r 2) or ( r > r 2)

Tipos predefinidos. Integer i = (i 2 : Integer) : Boolean i + (i 2: Integer) : Integer i – ( i 2: Integer) : Integer i * (i 2: Integer) : Integer i / (i 2: Integer) : Real i. abs : Integer i. div (i 2: Integer) : Integer i. mod (i 2 : Integer) : Integer i. max ( i 2 : Integer) : Integer i. min ( i 2: Integer) : Integer

Tipos predefinidos. String string = (string 2 : String) : Boolean string. size : Integer string. concat (string 2: String): String string. to. Upper : String string. to. Lower : String string. substring (lower: Integer, upper: Integer) : String

Tipos predefinidos Enumeration enumeration = ( enumeration 2 : boolean ) : Boolean enumeration <> (enumeration 2 : Boolean) : Boolean post: result = not (enumeration = enumeration 2) context Person inv: gender = Gender: : male

Tipos predefinidos Collection Set Ordered. Set Bag Sequence

Tipos predefinidos Collection Las operaciones sobre colecciones se denotan por expresiones OCL usando la siguiente notación: Operaciones que permiten iterar sobre sus elementos: select, reject, collect, iterate, for. All y exists. Estas operaciones toman cada elemento de la secuencia y evalúan una expresión sobre ellos.

Collection La operación select Sintaxis collection select(element: Type|) collection select(element|) collection select() context Company self. employee->select(p: Person| p. age>50)->not. Empty() self. employee->select(p | p. age>50)->not. Empty() p. self. employee->select(age>50)->not. Empty()

Collection La operación reject Sintaxis collection reject(element: Type|) collection reject(element|) collection reject() context Company self. employee->reject(p: Person| p. is. Married)->not. Empty() self. employee->reject(p | p. is. Married)->not. Empty() self. employee->reject(is. Married)->not. Empty()

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.

Collection La operación Collect Sintaxis collection collect(element: Type|) collection collect(element|) collection collect () context Company self. employee->collect(p: Person| p. birth. Date) self. employee->collect(p | p. birth. Date) self. employee->collect(birth. Date)

Collection La operación Collect Notación concisa collection. propertyname es a equivalente a collection collect(propertyname) self. employee. birth. Date

Collection La operación for. All Sintaxis collection for. All(element: Type|) collection for. All(element|) collection for. All() self. employee for. All(age > 18) self. employee for. All (p | p. age > 18) self. employee for. All (person p | p. age > 18)

Collection La operación exists Sintaxis collection exits(element: Type|) collection exists(element|) collection exists() self. employee exists(forename = “john”) self. employee exists (p | p. forename = ”john”) self. employee exists (person p | p. forename =”John”)

Collection La operación iterate Sintaxis collection iterate (elem: Type 1; result: Type 2= | expr-with-elem-and–result>) result podría ser calculado mediante result = ; while collection. not. Empty ()) do ( elem =collection. next. Element(); result = ; endwhile returnresult;

Collection La operación iterate collection size : Integer --The number of elements in the collection. post: result = collection iterate (elem; acc: Integer = 0| acc+1 ) collection collect ( x: T | x. property) collection iterate(elem: T; result: T 2=Bag{})|result including(x. property)) self. employee->collect(p: Person| p. birth. Date) es equivalente a self. employee-> iterate(p: Person; result= Bag{} | result including(p. birth. Date))

Collection collection size : Integer --The number of elements in the collection post: result = collection iterate (elem; acc: Integer = 0 | acc+1 ) collection includes (object: Ocl. Any ) : Boolean --True if object is an element of collection, false otherwise post: result = (collection count (object) > 0) collection -> excludes ( object : Ocl. Any ) : Boolean --True if object is not an element of collection, false otherwise post: result = (collection -> count ( object) = 0)

Collection collection is. Empty : Boolean --Is collection the empty collection? post: result = (collection size=0) collection not. Empty : 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)

Collection collection for. All (expr: Ocl. Expression) : 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: Ocl. Expression) : 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: Ocl. Expression) : expr. evaluation. Type( ) --Iterate over the collection.

Collection collection -> any ( expr : Ocl. Expression) : 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 : Ocl. Expression ) : 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 -> is. Unique ( expr : Ocl. Expression ) : 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 -> for. All ( e | values -> count ( e) = 1)

Collection count (object: Ocl. Any): 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 includes. All (c 2: Collection(T)) : Boolean --Does collection contain all the elements of c 2? post: result= (c 2 for. All (elem collection includes(elem)) collection excludes. All (c 2: Collection(T)) : Boolean --Does collection contain none of the elements of c 2? post: result=(c 2 for. All (elem collection-> excludes (elem))

Set set count (object: T) : Integer --The number of occurrences of object in set. post: result < = 1 set union (set 2: Set(T)) : Set (T) --The union of set and set 2. post: result -> for. All ( elem | set -> includes ( elem) or set 2 -> includes ( elem)) post: set -> for. All ( elem | result -> includes ( elem)) post: set 2 -> for. All ( elem | result -> includes ( elem)) set union (bag: Bag(T)) : Bag (T) post: result -> for. All ( elem | result -> count (elem) = set -> count (elem) + bag -> count (elem)) post: set -> for. All ( elem | result -> includes (elem)) post: bag -> for. All (elem | result -> includes (elem)) set = (set 2: Set): Boolean post: result = (set for. All (elem | set 2 includes(elem) and set 2 for. All ( elem | set -> includes(elem

Set set intersection (set 2: Set(T)): Set(T) post: result -> for. All ( elem | set -> includes (elem) and set 2 -> includes ( elem)) post: set -> for. All ( elem | set 2 -> includes ( elem) = result -> includes (elem)) post: set 2 -> for. All ( elem | set -> includes ( elem 0 = result -> includes ( elem)) set intersection (bag: Bag(T)): Set(T) post: result = set intersection (bag as. Set) set - (set 2: Set(T)): Set(T) post: result -> for. All (elem | set -> includes (elem) and set 2 -> excludes (elem)) post: set -> for. All (elem | result -> includes (elem) = set 2 -> excludes (elem)) set including (object: T) : Set(T) --The set containing all elements of set plus object. post: result -> for. All (elem | set -> includes (elem) or (elem = object)) post: set -> for. All (elem | result -> includes (elem)) post: result -> includes (object)

Set set excluding (object: T) : Set(T) --The set containing all elements of set without object. post: result -> for. All (elem | set -> includes (elem) and (elem <> object) post : set -> for. All (elem | result -> includes (elem)= object < > elem))) post : result -> excludes (object) set symmetric. Difference (set 2: Set(T)): Set(T) post: result -> for. All ( elem | set -> includes (elem) xor set 2 -> includes (elem)) post: set -> for. All (elem | result -> includes (elem) = set 2 -> excludes (elem)) post: set 2 -> for. All (elem | result -> includes (elem) = set -> excludes (elem)) set select (expression: Ocl. Expression) : Set(exp. type) post: result = set iterate (elem; acc: Set(T) = Set{} if expression then acc including (elem) else acc endif ) set reject (expression: Ocl. Expression) : Set (exp. type) post: result = set select (not expression)

Set set collect (expression: Ocl. Expression) : Bag(expression. Ocl. Type) --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 as. Sequence ( ) : Sequence (T) --A Sequence that contains all the elements from set, in undefined order. post: result -> for. All (elem | set -> includes(elem)) post: set -> for. All (elem | result -> count (elem) =1) set as. Bag ( ) : Bag (T) --The Bag that contains all the elements from set post: result -> for. All (elem | set -> includes (elem)) post: set -> for. All (elem | result -> count (elem) = 1)

Bag bag = (bag 2: Bag(T)) : Boolean post: result = (bag -> for. All (elem | bag -> count (elem) = bag 2 -> count (elem)) and bag 2 -> for. All (elem | bag 2 -> count (elem) = bag-> count(elem))) bag union (bag 2: Bag(T)) : Bag (T) --The union of bag and bag 2 post: result -> for. All (elem | result -> count (elem) = bag-> count (elem) + bag 2 -> count (elem)) post: bag -> for. All ( elem | result -> count (elem) = bag -> count (elem) + bag 2 ->count (elem)) post: bag 2 -> for. All (elem | result -> count (elem) = bag -> count(elem) + bag 2 -> count(elem))

Bag bag union (set: Set) : Bag (T) post: result -> for. All (elem | result -> count (elem) = bag -> count (elem) + set -> count (elem)) post: bag -> for. All (elem | result -> count (elem) = bag -> count (elem) + set -> count (elem)) post: set -> for. All (elem | result -> count (elem) = bag -> count (elem) + set -> count (elem)) bag intersection (bag 2: Bag(T)): Bag(T) post: result -> for. All (elem | result -> count (elem) = bag -> count (elem). min (bag 2 -> count (elem))) post: bag 2 -> for. All (elem | result -> count (elem) = bag -> count (elem). min (bag 2 -> count (elem))

Bag bag intersection (set: Set(T)): Set(T) post: result -> for. All (elem | result -> count (elem) = bag -> count (elem). min (set -> count (elem))) post: bag -> for. All (elem | result -> count (elem) = bag -> count (elem). min (set -> count (elem))) post: set -> for. All (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 -> for. All (elem | if elem = object then result -> count (elem) = bag -> count (elem) +1 else result-> count (elem) = bag-> count (elem) endif) post: bag -> for. All (elem | if elem = object then result-> count (elem) = bag -> count (elem) + 1 else result -> count (elem) = bag -> count(elem) endif)

Bag bag excluding (object: T) : Bag(T) --The bag containing all elements of bag apart from all ocurrences of object post: result -> for. All (elem | if elem =object then result -> count (elem) = 0 else result -> count(elem) = bag -> count(elem) endif) post: bag -> for. All (elem | if elem = object then result->count(elem) = 0 else result->count(elem) = bag->count(elem) endif)

Bag bag select (expr: Ocl. Expression) : 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: Ocl. Expression) : Bag(T) --The sub-bag of bag for which expr is false. post: result = bag select (not expr) bag collect (expr: Ocl. Expression) : Bag(expr. Ocl. Type) --The Bag of elements that results from applying expr to every member of bag. post: result =bag iterate(elem; acc: Bag(expr. evaluation. Type( )=T) = Bag{} acc including(exp))

Bag bag count (object: T) : Integer --The number of ocurrences of object in bag as. Sequence ( ) : Sequence (T) --A Sequence that contains all the elements from bag, in undefined order. post: result -> for. All (elem | bag -> count (elem) = result -> count (elem)) post: bag -> for. All (elem | bag -> count (elem) = result -> count (elem)) bag as. Set ( ) : Set (T) --The Set containing all the elements from bag, with duplicates removed. post: result -> for. All (elem | bag -> includes (elem)) post: bag -> for. All (elem | result -> includes (elem))

Sequence sequence = (sequence 2: Sequence(T)) : Boolean --True if sequence contains the same elements as sequence 2 in the same order. post: result= Sequence{1. . sequence 2 size() } for. All(index: Integer | sequence size() = sequence 2 size() ) and sequence at(index) = sequence 2 at(index)) sequence union (sequence 2: Sequence(T)) : Sequence (T) --The sequence consisting of all elements in sequence, followed by all elements --in sequence 2. post: result size() = sequence size() + sequence 2 size() post: Sequence{1. . sequence size } for. All(index: Integer | sequence at(index) = result at(index)) post: Sequence{1. . sequence 2 size() } for. All (index: Integer | sequence 2 at(index) = result at(index + sequence size() )

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() } for. All(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 size() = sequence size() +1 post: result at(1) = object post: Sequence{1. . sequence size ( ) } for. All (index: Integer | sequence at(index) = result at (index+1))

Sequence sequence sub. Sequence (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 } for. All( 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.

Sequence bag as. Sequence ( ) : Sequence (T) --A Sequence that contains all the elements from bag, in undefined order. post: result -> for. All (elem | bag -> count (elem) = result -> count (elem)) post: bag -> for. All (elem | bag -> count (elem) = result -> count (elem)) bag as. Set ( ) : Set (T) --The Set containing all the elements from bag, with duplicates removed. post: result -> for. All (elem | bag -> includes (elem)) post: bag -> for. All (elem | result -> includes (elem)) sequence first : T --The first element in sequence post: result = sequence at (1)

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 )

Sequence sequence select (expr: Ocl. Expression) : 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: Ocl. Expression) : Sequence(T) --The subsequence of sequence for which expr is false. post: result = sequence select (not expr) sequence collect (expr: Ocl. Expression) : Sequence(expr. Ocl. Type) --The Sequence of elements that results from applying expr to every member of sequence.

Sequence sequence select (expr: Ocl. Expression) : 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: Ocl. Expression) : Sequence(T) --The subsequence of sequence for which expr is false. post: result = sequence select (not expr) sequence collect (expr: Ocl. Expression) : Sequence(expr. Ocl. Type) --The Sequence of elements that results from applying expr to every member of sequence.

Sequence sequence collect (expr: Ocl. Expression) : expr. Ocl. Type --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 as. Set ( ) : Set (T) --The Set containing all the elements from sequence, including duplicates. post: result -> for. All (elem | sequence -> includes (elem)) post: sequence -> for. All (elem | result -> includes (elem)) sequence as. Bag ( ) : Bag (T) --The Bag containing all the elements from sequence, including duplicates. post: result -> for. All (elem | sequence -> count(elem) = result -> count(elem)) post: sequence -> for. All (elem | sequence -> count (elem) = result -> count(elem))

Reglas de subtyping- Collection Reglas estándar n Type 1 conforma a Type 2 cuando son idénticos n Type 1 conforma a Type 2 cuando Type 1 es subtipo de Type 2 n Si Type 1 conforma a Type 2, y Type 2 conforma a Type 3, luego Type 1 conforma a Type 3 + n Los tipos Set(x), Bag(x) y Sequence(x) son subtipos de Collection n Collection(Type 1) conforma a Collection(Type 2) cuando Type 1 conforma a Type 2. Esto vale para Set(Type 1)/ Set(Type 2), Bag(Type 1)/ Bag(Type 2) y Sequence(Type 1)/ Sequence(Type 2)

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

Ejemplo“Mortgage System”

Ejemplo “Mortgage System” context Mortgage --Una persona pude tener una hipoteca sobre una casa si es el propietario inv: security. owner = borrower context Mortgage inv: start. Date < end. Date context Person --soc. Sec. Nr debe ser único inv: Person: : all. Instances () ->is. Unique(soc. Sec. Nr)

Ejemplo “Mortgage System” context Person: : get. Mortage(sum: Money, security: House) --será permitida una nueva hipoteca si los ingresos son suficientes pre: self. mortgages. monthly. Payment->sum()<= self. salary * 0. 30 context Person: : get. Mortgage (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()

Ejemplo “Mortgage System” Ciclos en el diagrama de clases context Person inv: self. mortgages. security. owner -> for. All (owner: Person | owner = self)

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.

Asociaciones derivadas

Valores derivados e iniciales

Ejemplo “Royal and Loyal System”

Valores derivados “Royal and Loyal System” context Transaction. Report. Line: : partner. Name : String derive: transaction. generated. By. partner. name context Transaction. Report. Line: : service. Desc: String derive: transaction. generated. By. description context Transaction. Report. Line: : points: Integer derive: transaction. generated. By. partner. name context Transaction. Report. Line: : amount : Real derive: transaction. amount context Transaction. Report. Line: : date : Date derive: transaction. date

Valores derivados “Royal and Loyal System” context Transaction. Report: : total. Earned : Integer derive: lines. transaction->select(ocl. Is. Type. Of (Earning)). points->sum() context Transaction. Report: : total. Burned: Integer derive: lines. transaction-> select (ocl. Is. Type. Of (Burning)). Points ->sum()

Valores iniciales “Royal and Loyal System” context Typename: : attribute. Name: Type init: -- una expresión que representa el valor inicial context Loyalty. Account: : points init: 0 context Customer. Card: : valid init: true

Definiciones de atributos y operaciones context Customer def: well. Used. Cards : Set( Customer. Card ) = cards->select( transactions. points->sum() > 10, 000 ) def: loyal. To. Companies : Bag( Program. Partner ) = programs. partners def: cards. For. Program(p: Loyalty. Program) : Set(Cards) =p. Membership. card

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 ->not. Empty() implies houses ->not. Empty()

Constraints y asociaciones

Constraints y asociaciones context Person inv: wife. employers-> intersection(self. employers)->is. Empty() and husband. employer>intersection(self. employers>is. Empty() context Company inv: employees. wife-> intersection(self. employees)->is. Empty()

Constraints y asociaciones OR Sólo una de las potenciales asociaciones puede ser instanciada para un simple objeto context Person Inv: managed. Project->is. Empty() or performed. Project->is. Empty() context Project inv: project. Leader->is. Empty() or project. Member ->is. Empty()

Constraints y asociaciones Subset

Constraints y asociaciones Subset context Flight inv: self. crew->includes(self. pilot) inv: self. crew>includes. All(self. flight. Attendants) context Person inv: self. flights->includes(self. captain. On) inv: self. flights->includes. All(self. attended. On)

Mensajes en postcondiciones Operador has. Sent ('^') context Subject: : has. Changed() post: 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 has. Changed().

Expresión LET Posibilita definir una variable que puede ser usada en lugar de una subexpresión context Customer. Card inv: let correct. Date: Boolean = self. valid. From. Is. Before (Date: : now) and self. good. Thru. is. After (Date: : now) in if valid then correct. Date = true else correct. Date = false endif

Bibliografía OCL: OCL Specification. Version 2. 0. Formal document: ptc/03 -10 -14 www. omg. org Klasse Objecten Website: www. klasse. nl/ocl Warmer, J. , Kleppe, A. The Object-Constraint Language. (Second Edition). Addison Wesley (2003)