Ingeniería de Software I

Transcripción

1 Ingeniería de Software I El lenguaje de especificación OCL 2 cuatrimestre 2005

2 Limitaciones del diagrama de clases Es sabido que dentro de la metodología UML el diagrama de clases es una poderosa herramienta de modelización de la naturaleza propia de la información. En este diagrama se estructura la información especificando la naturaleza central de los tipos de objetos referidos (clases) con sus referencias inter-clases (asociaciones, clases de asociación junto con sus correspondientes multiplicidades), además de las relaciones jerárquicas entre clases (herencia, especialización, generalización). El objetivo del uso de esta herramienta es establecer una abstracción respecto a todos los casos particulares posibles, ofreciendo un marco sintáctico para definir la realidad del modelo, separando aquellos casos particulares correctos (los contemplados dentro del diagrama de clases, que es una abstracción de todos ellos), de los que no. A esta separación que provee el diagrama entre los casos particulares correctos y los incorrectos, lo vamos a llamar el invariante inherente al diagrama, que representa las restricciones propias que debe cumplir el modelo. Sin embargo, estas restricciones provistas por el diagrama terminan siendo puramente sintácticas. Pero seguramente existen otro tipo de restricciones que pueden presentarse, que son condiciones que se deben aplicar a los objetos representados, y que se deben cumplir. Estas restricciones son realmente semánticas (de significado), y se diferencian de las inherentes al diagrama, que son puramente sintácticas. Para poder expresar estar restricciones semánticas debemos poder expresar las condiciones propias de estas restricciones semánticas, que no pueden ser representadas con el diagrama de clases. Para esto es necesario poseer un lenguaje para poder escribir estas condiciones. Para ello, dentro del contexto de UML y asociado al diagrama de clases, deberían estar anexadas las condiciones escritas en un lenguaje que expresen todas aquellas restricciones semánticas y otras características que no se pueden reflejar en el diagrama y que se pueden reflejar con este mismo lenguaje. OCL (Object Constraint Language) El lenguaje de especifición OCL aparece en el documento Semántica de UML como lenguaje propuesto para especificar las restricciones semánticas del diagrama de clases, junto a otro tipo de definiciones. OCL se puede utilizar en cualquier contexto en que se use el diagrama de clases al que esté asociado (como por ejemplo, en el modelo conceptual o en el diseño). OCL es un lenguaje híbrido orientado a objetos-funcional, y es tipificado, porque usa el concepto de tipos de datos. Estos tipos de datos se encuentran jerarquizados a través de relaciones de inclusión. También existen varios tipos básicos predefinidos (similares a los de cualquier lenguaje), y unos pocos tipos paramétricos (o estructurados) predefinidos. Los tipos no predefinidos van a estar asociados a las clases del diagrama de clases. El componente central construído por este lenguaje es la expresión, que se manipula a través de operaciones que garantizan la transparencia referencial y la falta de efectos colaterales. Estas son características compartidas con los lenguajes funcionales, que son declarativos. Toda expresión válida para el lenguaje OCL debe tener asociado un tipo de datos. Las expresiones se pueden mapear fácilmente al concepto de objetos, ya que cada

3 tipo básico no predefinido se puede vincular a una clase del diagrama, y algunas de las operaciones de un tipo básico no predefinido se modelan como atributos y métodos/responsabilidades de la clase original. Las asociaciones entre clases también se modelan en OCL usando los roles de ambas clases participantes en la asociación, que deben estar rotulados (en ambos extremos). El rol de una clase en una asociación con una segunda clase, expresa que ese rol es un pseudoatributo del tipo de dato vinculado a esa segunda clase. Todos estos componentes asociados a las clases, también se ven reflejados en los tipos de OCL. Las expresiones del lenguaje OCL se estructuran hasta llegar a su punto más alto, que es el de formar parte de una definición. En cada definición de OCL se describe cada restricción semántica del diagrama de clases, junto a otras propiedades también descriptas con expresiones. Cada definición en OCL se aplica a lo que se llama un contexto, que representa el destinatario del diagrama de clases sobre quien se aplica esa definición. Entre estos contextos se encuentran: - Una clase (se aplica a todas expresiones-objetos cuyo tipo de datos asociado es el vinculado a esta clase). - Un método/responsabilidad de una clase. - Un atributo derivado de una clase. - Un método/responsabilidad derivado (también llamado query) de una clase. Tipos de definiciones 1) Invariantes context id clase inv: [[Descripción del invariante]] exp Bool Representa una condición (restricción semántica) que deben cumplir todas las expresiones-objetos pertenecientes al tipo de datos vinculados a la clase id clase. La condición a cumplirse se expresa en la expresión exp Bool que es de tipo Boolean (lógico). La expresión booleana debe evaluar en verdadero si se aplica a expresiones-objetos perteneciente al tipo de la clase en cuestión que son válidos bajo este invariante. Para el resto de las expresiones-objetos (que son inválidas según este invariante), la expresión debe evaluar en falso. Estos invariantes pueden tener una descripción optativa (que se escribe entre corchetes). 2) Invariantes de método/responsabilidad context id clase ::id metodo (par 1 :T 1,,par n :T n )[:T res ] pre: [[Descripción precondición]] exp Bool post: [[Descripción postcondición]] exp Bool

4 Define la aplicabilidad de un método/responsabilidad (de nombre id metodo, existente dentro de la clase id clase con parámetros formales par 1 a par n de tipo T 1 a T n, y con imagen de tipo T res -sólo en el caso que retorne una expresión-). La cláusula pre refleja la precondición de este método/responsabilidad, expresada en la primera expresión booleana exp Bool, que deberá retornar verdadero sólo para aquellas expresiones-objetos para la cual este método sea aplicable. La cláusula post refleja la postcondición de este método/responsabilidad, expresada en la segunda expresión booleana exp Bool, que deberá retornar verdadero sólo cuando el estado final de la expresión-objeto al que se le aplicó este método/responsabilidad es consistente con el accionar del mismo. No existirían problemas si el método/responsabilidad retorna una expresión y no modifica el estado interno de la expresión-objeto original, ya que la postcondición sólo verificaría el resultado que retorna. Pero si no retorna un valor (porque en realidad modifica el estado interno de la expresión-objeto original), la naturaleza de la postcondición es distinta que la anterior, ya que existe un efecto colateral de por medio. En este último caso no se especifica cómo se actualiza el estado interno de la expresión-objeto original (ya que esto no sería declarativo), sino la condición en que debe quedar la expresión-objeto original luego de aplicarle este método/responsabilidad. Este invariante terminaría reflejando en forma declarativa su definición en sí misma. 3) Definición de atributos derivados context id clase ::id atributo :T derive: exp T Define un atributo derivado de nombre id atributo existente en la clase id clase, y que retornará una expresión de tipo T. La expresión retornada por este atributo derivado, al aplicarla sobre una expresión-objeto de la clase en cuestión, retornará la expresión exp T, que también deberá ser de tipo T. 4) Definición de métodos/responsabilidades derivados (queries): context id clase ::id metodo (par 1 :T 1,,par n :T n ):T [pre: [[Descripción precondición]] exp Bool ] body: exp T Define un método/responsabilidad derivado Como es un método/responsabilidad, el contexto es idéntico al de un método/responsabilidad común, con la diferencia que siempre retornará una expresión (que deberá ser de tipo T) y no provocará efectos colateriales. La cláusula pre optativa determina si es aplicable o no (según el resultado de exp Bool ) a cada expresión-objeto de la clase. En forma análoga a los atributos derivados, en la cláusula body se especifica cuál será el valor retornado para cada expresión-objeto de la clase que sea aplicable, a través de la expresión exp T, que será de tipo T. Tipos de datos

5 1) Predefinidos a) Básicos - Boolean (valores lógicos) - Integer (valores enteros) - Real (valores reales) - String (valores de cadenas de caracteres) - OCLAny (el tipo supremo jerárquico de todos los tipos no estructurados) - OCLType (el tipo asociado a los metatipos -todo tipo puede verse como una expresión de tipo OCLType) b) Estructurados - Collection(T) - Set(T) - Bag(T) - OrderedSet(T) - Sequence(T) - Tuple{id 1 :T 1,..., id n :T n } El tipo Set(T) corresponde a los conjuntos de expresiones de tipo T, que no contienen repeticiones y sus expresiones contenidas no poseen un orden posicional. El tipo Bag(T) corresponde a los bags de expresiones de tipo T, que permiten contener repeticiones y donde sus expresiones contenidas no poseen un orden posicional. El tipo OrderedSet(T) corresponde a los conjuntos ordenados de expresiones de tipo T, que no contienen repeticiones y sus expresiones contenidas poseen un orden posicional. El tipo Sequence(T) corresponde a las secuencias (listas) de expresiones de tipo T, que permiten contener repeticiones y donde sus expresiones poseen un orden posicional. El tipo Collection(T) corresponde a las colecciones de expresiones de tipo T. Es un tipo que es abstracto y superior jerárquico de los cuatro anteriores. El tipo Tuple{id 1 :T 1,..., id n :T n } (con n>0) corresponde a las tuplas (registros/records) con campos de nombre id 1 a id n, donde cada uno de ellos debe tener asociada una expresión de tipo T 1 a T n respectivamente. 2) No predefinidos Corresponden a cada clase y enumerado del diagrama de clases. Toda clase o enumerado C se mapeará al tipo asociado T C de OCL. Sin embargo, como abuso de notación es normal referirse al tipo como C (el mismo nombre de la clase), aunque no lo haremos en el resto de este apunte. Aquí expresamos al tipo de la clase C como T C sólo a los efectos de distinguir la diferencia de conceptos entre clase y tipo.

6 En OCL cada atributo de una clase, al aplicarse a una expresión del tipo asociado a la clase, retorna una expresión que también tendrá un tipo asociado. Con esto, decimos, que todo atributo tiene también un tipo asociado. Esto ya se dijo en la definición de atributos derivados, cuando se expresó que éstos retornan una expresión de un tipo resultante especificado. Con esto, decimos que todo atributo atrib tiene asociado en OCL el tipo de dato T atrib. Este tipo no es necesariamente nuevo (como en el caso de los provenientes de clases o enumerados). Al no definir un tipo necesariamente nuevo, en este apunte diremos que el tipo retornado es T. Si utilizamos el diagrama de clases dentro del contexto del diseño, seguramente cada atributo de cada clase tendrá su tipo de datos asociado en forma explícita en la misma clase del diagrama, y con esto se puede mapear al tipo correspondiente de OCL. El problema que existe en el diagrama de clases del modelo conceptual es que en las clases conceptuales no se especifican tipos de datos. Esto sugiere la idea de existencia de dominios -como abstracciones respecto a los tipos- (los atributos de las clases conceptuales retornan un objeto de un dominio, en lugar de una expresión-objeto de un tipo de datos). En este caso hay que realizar un mapeo implícito de los dominios de los atributos a tipos básicos de OCL para poder expresar condiciones en OCL que se apliquen sobre los valores retornados por estos atributos. Constantes 1) Tipos predefinidos a) Tipos básicos - De tipo Boolean: true, false - De tipo Integer: constantes enteras (Ej: 5, 8, -76,...) - De tipo Real: constantes reales (Ej: -7.5, 5.9, 0.0,...) - De tipo String: constantes string entre caracteres y (Ej: Hola,, 7*,...) b) Tipos estructurados - De tipo Collection(T): no posee constantes porque es abstracto. - De tipo Set(T): constantes de la forma Set {exp 1, exp 2,..., exp n }, con n 0, y donde las expresiones exp 1 a exp n son todas de tipo T. - De tipo Bag(T): constantes de la forma Bag {exp 1, exp 2,..., exp n }, con n 0, y donde las expresiones exp 1 a exp n son todas de tipo T. - De tipo OrderedSet(T): constantes de la forma OrderedSet {exp 1, exp 2,..., exp n }, con n 0, y donde las expresiones exp 1 a exp n son todas de tipo T. - De tipo Sequence(T): constantes de la forma Sequence {exp 1, exp 2,..., exp n }, con n 0, y donde las expresiones exp 1 a exp n son todas de tipo T. - De tipo Tuple{id 1 :T 1,..., id n :T n }: constantes de la forma Tuple {id 1 :T 1 = exp 1,..., id n :T n = exp n }, donde las expresiones exp 1 a exp n son todas de tipo T 1

7 2) No predefinidos a T n respectivamente. En general, los tipos de los campos en las expresiones de tipo tupla pueden omitirse. Sólo los tipos asociados a los enumerados del diagrama de clases poseen constantes. Si c fuera un valor dentro del enumerado E del diagrama de clases, entonces la expresión T E ::c es de tipo T E. 3) Constantes especiales self: representa a cada expresión-objeto de una clase a las que se le quiere verificar una propiedad o aplicar un atributo derivado o un método/responsabilidad (derivado o no). Es reconocida únicamente en las cláusulas inv, pre, post, derive y body. result: representa al valor retornado por un método/responsabilidad común que retorna una expresión. Es reconocida únicamente en las cláusulas post. 4) Parámetros Los parámetros de métodos/responsabilidades (comunes o derivados) se pueden utilizar en aquellas cláusulas pre, post, y body de aquellas definiciones donde aparecieron en la cláusula context. Operaciones centrales sobre tipos no predefinidos 1) Atributos (comunes o derivados) Si atrib es un atributo de la clase C que retorna una expresión de tipo T, y x es una expresión de tipo T C, entonces x.atrib es una expresión de tipo T, que retorna el valor del atributo atrib asociado a la expresión x. Se considera dentro de las posibilidades, que un atributo pueda retornar una expresión de un tipo estructurado (como por ejemplo, un conjunto). 2) Pseudoatributos de multiplicidad 1 (simple) Si psatrib es un pseudoatributo de la clase C que la asocia a la clase D, y x es una expresión de tipo T C, entonces x.psatrib es una expresión de tipo T D. Retorna la expresión del tipo T D que se asocia vía el rol psatrib a la expresión x. 3) Pseudoatributos de multiplicidad 0..1, 0..*, 1..* (múltiple) Si psatrib es un pseudoatributo de la clase C que la asocia a la clase D, y x es una expresión de tipo T C, entonces x.psatrib es una expresión de tipo Set(T D ). Retorna las expresiones del tipo T D que se asocian vía el rol psatrib a la

8 expresión x. Las retorna como un set (conjunto) porque no pueden existir elementos repetidos, y no existe un orden de aparición en la colección retornada. 4) Pseudoatributos de multiplicidad 0..1, 0..*, 1..* con label {ordered} Si psatrib es un pseudoatributo de la clase C que la asocia a la clase D, y x es una expresión de tipo T C, entonces x.psatrib es una expresión de tipo OrderedSet(T D ). Es similar al caso anterior, y retorna a las expresiones resultantes como un orderedset (conjunto con orden posicional) porque no pueden existir elementos repetidos, y existe un orden de aparición en la colección retornada (indicado por la etiqueta {ordered}). 5) Métodos/responsabilidades (comunes o derivados) que retornan un valor Si met es un método/responsabilidad de la clase C que recibe n parámetros de tipo T 1 a T n, y retorna una expresión de tipo T, y existen expresiones exp 1 a exp n que son de tipo T 1 a T n respectivamente, y x es una expresión de tipo T C, entonces x.met(exp 1,...,exp n ) es una expresión de tipo T. Retorna el resultado de la aplicación del método/responsabilidad met a la expresión x, usando como parámetros a las expresiones exp 1 a exp n. 6) Métodos/responsabilidades de clase (sólo para contados casos) Si met es un método/responsabilidad de clase de la clase C que recibe n parámetros de tipo T 1 a T n, y retorna una expresión de tipo T, y existen expresiones exp 1 a exp n que son de tipo T 1 a T n respectivamente, entonces T c.met(exp 1,...,exp n ) es una expresión de tipo T. Retorna el resultado de la aplicación del método/responsabilidad met a la clase C, usando como parámetros a las expresiones exp 1 a exp n. Todas estas oparaciones se pueden componer sucesivamente utilizando esta notación. El significado de la operación de aplicación de atributo es obtener la expresión asociada al atributo de una expresión dada. Además de existir expresiones de la forma x.atrib, también existen otras de la forma x.atrib@pre (sólo dentro de las cláusulas post) que representan el valor retornado por el atributo atrib aplicado a la expresión x en el momento de la evaluación de la precondición (el mismo valor que retornaría la expresión x.atrib dentro de la cláusula pre correspondiente). Esto último también se puede utilizar para pseudoatributos de multiplicidad 1. El significado de la operación de aplicación de pseudoatributo es obtener la o las expresiones-objeto asociadas a una expresión dada en función de la asociación con la clase de las expresiones-objeto obtenidas. Esto permite pasar de una clase a otra. A la composición de pseudoatributos se la suele llamar informalmente navegación por el diagrama de clases.

9 El significado de la operación de aplicación de método/responsabilidad es obtener la expresión-objeto asociada a la aplicación de este método/responsabilidad. Operaciones asociadas a los tipos básicos predefinidos Algunas de estas operaciones binarias se escriben sintácticamente como funciones infijas (que se escriben entre sus dos argumentos), o con la notación postfija característica de la orientación a objetos, que se aplica al primero de sus dos argumentos, y el segundo argumento se pasa como su único parámetro. Lo mismo ocurre con las operaciones unarias, de las que algunas se escriben con la notación prefija funcional, y otras con la notación postfija que se aplica a su único argumento y no posee parámetros. 1) De tipo Boolean (exp 1 : Boolean and exp 2 : Boolean): Boolean (exp 1 : Boolean or exp 2 : Boolean): Boolean not(exp: Boolean): Boolean (exp 1 : Boolean xor exp 2 : Boolean): Boolean (exp 1 : Boolean implies exp 2 : Boolean): Boolean Representan la conjunción (and), disyunción (or), negación (not), disyunción exclusiva (xor) e implicación material (implies). (if (exp: Boolean) then (exp true : T) else (exp false : T) endif): T Representa el if función, infijo de tres argumentos. (exp 1 : T = exp 2 : T): Boolean (exp 1 : T <> exp 2 : T): Boolean (exp 1 : T < exp 2 : T): Boolean (exp 1 : T <= exp 2 : T): Boolean (exp 1 : T > exp 2 : T): Boolean (exp 1 : T >= exp 2 : T): Boolean Representan los operadores relacionales. El tipo T no puede ser cualquiera, sino un tipo que tenga definido estos operadores. 2) De tipo Integer (exp 1 : Integer + exp 2 : Integer): Integer (exp 1 : Integer - exp 2 : Integer): Integer (exp 1 : Integer * exp 2 : Integer): Integer (exp 1 : Integer / exp 2 : Integer): Integer

10 Integer.abs(): Integer Integer.div(exp: Integer): Integer Integer.mod(exp: Integer): Integer Integer.min(exp: Integer): Integer Integer.max(exp: Integer): Integer Representan las operaciones de suma (+), resta (-), producto (*), cociente (/, div), valor absoluto (abs), resto (mod), mínimo (min) y máximo (max). 3) De tipo Real (exp 1 : Real + exp 2 : Real): Real (exp 1 : Real - exp 2 : Real): Real (exp 1 : Real * exp 2 : Real): Real (exp 1 : Real / exp 2 : Real): Real Real.floor(): Real Real.round(exp: Integer): Real Representan las operaciones de suma (+), resta (-), producto (*), cociente (/), parte entera -o mayor número entero devuelto como número real que es menor o igual al número real dado- (floor) y valor redondeado a una cantidad de decimales dada (round). 4) De tipo String String.size(): Integer String.concat(exp: String): String String.substring(exp 1, exp 2 : Integer): String String.toUpper(): String String.toLower(): String String.toInteger(): Integer String.toReal(): Real Representan las operaciones de cantidad de caracteres -longitud- (size), concatenación de dos cadenas (concat), obtención de una subcadena de una cadena dada desde una determinada posición tomando una cierta cantidad de caracteres a partir de allí (substring), la conversión a mayúsculas (toupper), a minúsculas (tolower), a entero (tointeger) y a real (toreal). Operaciones asociadas a los tipos de Colección Las operaciones de colección se aplican siempre sobre una expresión de tipo Collection (o de alguno de sus cuatro subtipos concretos), y pueden o no tener parámetros. La expresión de tipo colección que es receptora de esta operación se escribe antes de la

11 operación. Entre la colección receptora y la operación debe ir el símbolo -> (que reemplazaría en este caso al caracter. tradicional). El operador ->, como el., también se puede componer sucesivamente. Como siempre, las aplicaciones de estas operaciones no provocan efectos colaterales. Esta es la lista de operaciones existentes: Collection(T)->size(): Integer Retorna la cantidad de elementos que posee la colección. Collection(T)->empty(): Boolean Retorna si la colección está vacía (no contiene elementos). Collection(T)->notEmpty(): Boolean Retorna si la colección no está vacía (contiene algún elemento). Collection(T)->includes(exp: T): Boolean Retorna si la expresión pasada como parámetro pertenece a la colección. El tipo T debe poseer la igualdad y la desigualdad. Collection(T)->excludes(exp: T): Boolean Retorna si la expresión pasada como parámetro no pertenece a la colección. El tipo T debe poseer la igualdad y la desigualdad. Collection(T)->includesAll(exp: Collection(T)): Boolean Retorna si la expresión-colección pasada como parámetro está incluída en la colección original. El tipo T debe poseer la igualdad y la desigualdad. Collection(T)->excludesAll(exp: Collection(T)): Boolean Retorna si la expresión-colección pasada como parámetro es disjunta respecto a la colección original. El tipo T debe poseer la igualdad y la desigualdad. Collection(T)->sum(): Integer Retorna si la suma de los elementos que componen la colección. El tipo T debe poseer la operación de suma. Set(T)->including(exp: T): Set(T) Bag(T)->including(exp: T): Bag(T)

12 OrderedSet(T)->including(exp: T): OrderedSet(T) Sequence(T)->including(exp: T): Sequence(T) Retorna una colección que es la misma que la original, con el agregado de un nuevo elemento, indicado por la expresión dada. El tipo de la colección retornada es el mismo que el de la original. Set(T)->union(exp: Set(T)): Set(T) Set(T)->union(exp: Bag(T)): Bag(T) Bag(T)->union(exp: Set(T)): Bag(T) Bag(T)->union(exp: Bag(T)): Bag(T) OrderedSet(T)->union(exp: OrderedSet(T)): OrderedSet(T) OrderedSet(T)->union(exp: Sequence(T)): Sequence(T) Sequence(T)->union(exp: OrderedSet(T)): Sequence(T) Sequence(T)->union(exp: Sequence(T)): Sequence(T) Retorna la unión de dos colecciones. Se asume que si alguna de las dos es de un tipo que admite repeticiones, entonces la colección retornada podrá contener repeticiones. Set(T)->intersection(exp: Set(T)): Set(T) Set(T)->intersection(exp: Bag(T)): Set (T) Bag(T)->intersection(exp: Set(T)): Set (T) Bag(T)->intersection(exp: Bag(T)): Bag(T) OrderedSet(T)->intersection(exp: OrderedSet(T)): OrderedSet(T) OrderedSet(T)->intersection(exp: Sequence(T)): OrderedSet(T) Sequence(T)->intersection(exp: OrderedSet(T)): OrderedSet(T) Sequence(T)->intersection(exp: Sequence(T)): Sequence(T) Retorna la intersección de dos colecciones. Se asume que si alguna de las dos es de un tipo que no admite repeticiones, entonces la colección retornada no podrá contener repeticiones. Set(Collection(T))->flatten(): Set(T) Bag(Collection(T))->flatten(): Bag(T) OrderedSet(Collection(T))->flatten(): OrderedSet(T) Sequence(Collection(T))->flatten():Sequence(T) Retorna el aplanado de una colección de colecciones, eliminando un nivel de colecciones. Dicho de otra forma, retorna la concatenación de todos los elementos de la colección de colecciones original (que son colecciones). El tipo mandatorio de la colección resultante es el más "externo". Las siguientes operaciones son de orden superior, ya que como parámetro de estas operaciones se especifican funciones implícitas representadas por una variable ligada

13 (bounded variable) y una expresión-cuerpo que admite apariciones libres de la variable ligada especificada (y que hace referencia a ella misma). Collection(T)->forAll(var exp: Boolean): Boolean Retorna si todos los elementos de la colección original cumplen con la condición dada. La condición se expresa en el parámetro de esta operación, usando una variable ligada (var) que se instancia con cada elemento de la colección, y la condición a testear sobre cada una de ellos (expresión lógica exp). Esta expresión admite apariciones libres de la variable var. Collection(T)->forAll(var 1, var 2 exp: Boolean): Boolean Retorna lo mismo que la siguiente expresión (suponiendo que c es una expresión de tipo Collection(T)): c->forall(var 1 c->forall(var 2 exp)) Set(T)->select(var exp: Boolean): Set(T) Bag(T)->select(var exp: Boolean): Bag(T) OrderedSet(T)->select(var exp: Boolean): OrderedSet(T) Sequence(T)->select(var exp: Boolean): Sequence(T) Retorna a todos los elementos de la colección original que cumplen con la condición dada en el parámetro. La variable ligada se vincula a cada elemento de la condición, y la expresión lógica retorna si el elemento dado queda o no en la colección resultante. La colección resultante será del mismo tipo que la original. Set(T)->reject(var exp: Boolean): Set(T) Bag(T)->reject(var exp: Boolean): Bag(T) OrderedSet(T)->reject(var exp: Boolean): OrderedSet(T) Sequence(T)->reject(var exp: Boolean): Sequence(T) Retorna a todos los elementos de la colección original que no cumplen con la condición dada en el parámetro. Set(T 1 )->collect(var exp: T 2 ): Bag(T 2 ) Bag(T 1 )->collect(var exp: T 2 ): Bag(T 2 ) OrderedSet(T 1 )->collect(var exp: T 2 ): Sequence(T 2 ) Sequence(T 1 )->collect(var exp: T 2 ): Sequence(T 2 ) Retorna un mapeo de todos los elementos de la colección orginal a una colección resultante de la misma cantidad de elementos, donde cada elemento de la colección resultante es el mapeado de la misma posición en la colección original (si posee orden posicional). La función de mapeo se expresa con la variable ligada (que se sustituye por cada elemento de la colección original) y la expresión-cuerpo que indica el valor a retornar

14 en la colección resultante para la expresión original dada. El tipo de la expresión-cuerpo será el mismo que el de los elementos de la colección resultante. Como luego de la aplicación de esta operación se pueden generar elementos repetidos en la colección resultante que provienen de elementos distintos de la colección original, se asume que la colección resultante debe admitir repetidos (de ahí que no se retornan conjuntos), para lograr mantener la misma cantidad de elementos respecto a la cantidad de elementos de la colección original. Collection(T 1 )->isunique(var exp: T 2 ): Boolean Retorna si todos los elementos de la colección, al mapearse cada uno de ellos al mapeo propuesto (análogo a la operación collect) da como resultado una colección con todos valores distintos (dos a dos). El tipo T 2 debe poseer la igualdad y desigualdad. Collection(T)->iterate(var 1 ; var 2 : T 2 = exp inicial exp: T 2 ): T 2 Retorna la aplicación sucesiva de la función binaria de variables ligadas (var 1,var 2 ) y cuerpo exp, iterando por cada uno de los valores de la colección original -que son los valores usados en la sustitución de la variable var 1 - y donde cada resultado parcial - indicado en la expresión exp- se usa como parámetro-acumulador del paso siguiente -en la variable var 2 -. El valor resultado original será dado en la expresión exp inicial. El tipo T 2 que se escribe luego de la variable var 2 debe ser obligatorio. Más fácilmente, el resultado de esta operación se ve reflejado por el siguiente pseudoalgoritmo (donde la colección original está indicada por la variable c): res := exp inicial paracada i indice de c res := ((var 1,var 2 ) exp) (c[i],res) fin-paracada retornar res la expresión de la parte derecha de la asignación del renglón 3 significa la aplicación de una función de dos parámetros. Esta operación es análoga a la función foldl del lenguaje funcional Haskell. Todos los métodos de colección que reciben parámetros de la forma (var exp) (como por ejemplo select, reject o collect) pueden ser escritos con otra sintaxis, a saber: Collection(T)->operacion(var exp) Collection(T)->operacion(var: T exp) Collection(T)->operacion(exp) El segundo caso es análogo al primero, con la diferencia de que se puede realizar un typecast sobre el tipo de los elementos de la colección por un subtipo de éste (similar al uso de la operación OCLasType que se comentará después). Los vínculos de variables

15 reconocidos en la expresión exp son los reconocidos por el contexto de la expresión general más la variable var. En el tercer caso, la variable var no aparece, y no puede aparecer libre como subexpresión de la expresión exp. En exp todos los métodos/responsabilidades, atributos y pseudoatributos aplicados a un receptor no especificado, son asumidos que se aplican en primera instancia a cada elemento de la colección, y en segunda instancia, a self. Si hubiera algún problema de ambigüedad, no se puede elegir esta opción de sintaxis, y se debe optar por alguna de las dos primeras. Lo más común para este caso es que exp sea un atributo o pseudoatributo y la operación en cuestión sea collect. Como caso aparte, en la operación forall con el iterador sobre pares de elementos de la colección dada, la expresión booleana del cuerpo del método puede contener apariciones libres de estas dos variables ligadoras, y que se ligarían a éstas. Notación de punto aplicada a colecciones: Existe la notación de aplicaciones de atributos y pseudoatributos a colecciones con la notación del punto (aplicados como si no fueran colecciones). La definición es la siguiente: Si c es una expresión de tipo Collection(T) y psatrib es un pseudoatributo (o atributo) sobre el tipo T, se define lo siguiente: { c->collect(psatrib) c.psatrib c->collect(psatrib)->flatten() (si psatrib no es PAM) (si psatrib es PAM) PAM es el resumido de pseudoatributo múltiple. Operaciones asociadas a colecciones específicas (exp 1 : Set(T) - exp 2 : Set(T)): Set(T) Retorna la diferencia entre dos conjuntos. Set(T)->symmetricDifference(exp: Set(T)): Set(T) Retorna la diferencia simétrica entre dos conjuntos. Bag(T)->count(exp: T): Integer Sequence(T)->count(exp: T): Integer

16 Retorna la cantidad de apariciones de la expresión dada en la colección. El tipo T debe tener definida la operación de igualdad. Bag(T)->asSet(): Set(T) OrderedSet(T)->asSet(): Set(T) Sequence(T)->asSet(): Set(T) Retorna la conversión de la colección dada en un Set. En el Set resultante el orden posicional y la cantidad de apariciones se pierden. Set(T)->asBag(): Bag(T) OrderedSet(T)->asBag(): Bag(T) Sequence(T)->asBag(): Bag(T) Retorna la conversión de la colección dada en un Bag. En el Bag resultante el orden posicional se pierde, y la cantidad de apariciones resultantes de los elementos si la colección original es un conjunto es 1 para todos. Set(T)->asOrderedSet(): OrderedSet(T) Bag(T)->asOrderedSet(): OrderedSet(T) Sequence(T)->asOrderedSet(): OrderedSet(T) Retorna la conversión de la colección dada en un OrderedSet. En el OrderedSet resultante la cantidad de apariciones se pierden, y el orden posicional de los elementos si la colección original no tiene orden se crea con el orden natural sobre el tipo T (el tipo T debe tener definida la operación menor o igual). Set(T)->asSequence():Sequence(T) Bag(T)->asSequence(): Sequencet(T) OrderedSet(T)->asSequence(): Sequence(T) Retorna la conversión de la colección dada en una Sequence. Sobre la Sequence resultante se crea el orden posicional con el orden natural sobre el tipo T si la colección original no era ordenada, y crea la cantidad de apariciones de los elementos en 1 si la colección original era un conjunto. OrderedSet(T)->first(): T Sequence(T)->first(): T Retorna el primer elemento de la colección con orden posicional (si es que existe). OrderedSet(T)->last(): T Sequence(T)->last(): T Retorna el último elemento de la colección con orden posicional (si es que existe).

17 OrderedSet(T)->at(exp: Integer): T Sequence(T)->at(exp: Integer): T Retorna el elemento de la posición exp dada de la colección con orden posicional (si es que existe). Sequence(T)->append(exp: Sequence(T)): Sequence(T) Retorna la concatenación de la secuencia exp luego de la secuencia original. Sequence(T)->prepend(exp: Sequence(T)): Sequence(T) Retorna la concatenación de la secuencia exp antes de la secuencia original. Sequence(T)->subSequence(exp 1, exp 2 : Integer): Sequence(T) Retorna la subsecuencia de la secuencia original que comienza en la posición exp 1, y posee exp 2 cantidad de elementos a partir de allí. Jerarquía de tipos Los tipos de datos se encuentran jerarquizados a través del concepto de inclusión. Los tipos incluídos heredan todas las propiedades (atributos, peudoatributos y métodos/responsabilidades) de sus tipos superiores (los que lo incluyen). La relación de inclusión estricta este tipos se refleja con el siguiente operador: T 1 < T 2 si y sólo si T 1 es un subtipo estricto de T 2 Las reglas propias del operador < de inclusión de tipos son las siguientes: - Si A es una clase y B es una subclase de A en el diagrama de clases, entonces T B < T A - T < OCLAny (para todo tipo T no estructurado) - T 1 < T 2 Set(T 1 ) < Set(T 2 ) - T 1 < T 2 Bag(T 1 ) < Bag(T 2 ) - T 1 < T 2 OrderedSet(T 1 ) < OrderedSet(T 2 ) - T 1 < T 2 Sequence(T 1 ) < Sequence(T 2 ) - Set(T) < Collection(T) - Bag(T) < Collection(T) - OrderedSet(T) < Collection(T) - Sequence(T) < Collection(T) - Integer < Real - T : OCLType

18 - T 1 < T 2 y T 2 < T 3 T 1 < T 3 Se aceptan múltiples jerarquías asociadas a una misma clase, al igual que la existencia de herencia múltiple (ya que estas dos características son aceptadas en el diagrama de clases). Operación de tuplas Las campos de una tupla se comportan como si fueran atributos. Estos campos se utilizan sobre una tupla para proyectar sus valores. O sea que vale lo siguiente: Si x es una expresión de tipo Tuple{id 1 :T 1,..., id n :T n }, entonces x.id i es una expresión de tipo T i. Operaciones de clase Dada una clase C del diagrama de clases, se le puede aplicar la siguiente operación de clase: T C.allInstances(): Set(T C ) Retorna el conjunto de todas las expresiones-objeto de la clase C. Existen otras operaciones que se aplican a cualquier clase, relacionadas con metainformación. Estas se aplican en realidad sobre las expresiones-objeto del tipo de las clases del modelo, que son las expresiones del tipo OCLType. Estas son las operaciones: OCLType.name(): String Retorna el nombre de la clase. OCLType.attributes(): Set(String) Retorna el conjunto de los nombres de todos los atributos de la clase. OCLType.associationEnds(): Set(String) Retorna el conjunto de los nombres de todos los pseudoatributos (roles) de la clase. OCLType.operations(): Set(String) Retorna el conjunto de los nombres de todas las operaciones (métodos/responsabilidades).

19 OCLType.supertypes(): Set(OCLType) Retorna el conjunto de los tipos inmediatamente superiores a la clase. OCLType.allSupertypes(): Set(OCLType) Retorna el conjunto de los tipos superiores a la clase (los inmediatamente superiores y sus antipos ancestros). Expresiones LET Existe otro tipo de expresiones, muy utilizada para no repetir o simplificar evaluaciones. Son las expresiones LET, que son expresiones con la siguiente sintaxis: let var: T = exp 1 in exp 2 La evaluación de esta expresión let consta de la evaluación de la expresión exp 2, reemplazando antes todas las apariciones libres de la variable var (que dentro de exp 2 es usada como expresión) por la expresión exp 1. El tipo de var (T) debe especificarse, y debe coincidir con el tipo del la expresión exp 1. Dentro de la expresión exp 2 se reconocen como expresiones a las vinculaciones a variables reconocidas en el contexto de la expresión let, y a esta nueva variable var (que sólo es local a la expresión let). En relación a la creación de expresiones-objetos de una clase La creación de objetos de una clase es una operación de naturaleza destructiva. Es por eso que éstas no se modelan con OCL, que es declarativo. Lo que sí se puede hacer con OCL es verificar o establecer características de los objetos en función de su creación. Para ello se puede utilizar la siguiente operación: OCLAny.OCLisNew(): Boolean Este método (que se puede utilizar únicamente en la cláusula post de la especificación de un método/resposabilidad), retorna si la expresión-objeto receptora del mensaje fue recientemente creada (durante la ejecución del mismo método -que no es especificado en OCL-). Relacionado con esto, en OCL se permite especificar el valor que tendrá un atributo o pseudoatributo de un objeto inmediatamente después del momento de su creación. Esto se hace con una nueva cláusula init, donde se especifican los valores iniciales de atributos y pseudoatributos de objetos recientemente creados. El contexto utilizado es un atributo o

20 pseudoatributo propio de una clase, característico de todas las instancias de esa misma clase. Esta es su sintaxis: context id clase ::id atributo :T init: exp T Con esto se especificará que el valor inicial que tendrá el atributo o pseudoatributo id atributo (de tipo T) para objetos recientemente creados pertenecientes a la clase dada, será la expresión exp T (que también debe ser de tipo T). Como está permitido especificar valores iniciales también para los pseudoatributos, se podrán retornar expresiones de un tipo estructurado de alguna colección. También se pueden especificar valores iniciales de algún tipo de tupla. Dentro de la expresión exp T se puede utilizar la expresión self (hacer una referencia al objeto recientemente creado), siempre y cuando de él se obtengan valores de atributos o pseudoatributos, para los cuales su valor inicial haya sido especificado en una cláusula init anterior. Sobre el uso de las clases de asociación del diagrama de clases Sean A y B clases, y C una clase de asociación entre A y B (vamos a llamar también T A, T B y T C a los tipos asociados a las clases A, B y C respectivamente). Sean exp A, exp B y exp C expresiones de tipos T A, T B y T C respectivamente, y dado el siguiente diagrama: Valen las siguientes expresiones (ya vistas desde el comienzo): exp A.rol 2 retorna una expresión de tipo Set(T B ). exp B.rol 1 retorna una expresión de tipo T A. Además de este caso, dentro del contexto de dos clases que se encuentran asociadas (A y B en este caso), se puede usar el nombre de la clase de asociación como pseudoatributo de los tipos de las dos clases asociadas por esa asociación. Lo retornado en este último caso son aquel o aquellas instancias de la asociación (como si fueran pares) que poseen el valor

21 de la expresión del tipo de la clase origen, pero vistas como expresiones-objeto pertenecientes al tipo de la clase de asociación (T C ). La multiplicidad de este pseudoatributo-clase de asociación es la misma que la multiplicidad del rol destino de la misma asociación. O sea que también vale lo siguiente: exp A.C retorna una expresión de tipo Set(T C ). exp B.C retorna una expresión de tipo T C. Por otro lado, dentro del contexto de un tipo-clase de asociación, para toda expresiónobjeto de ese tipo, se puede obtener con qué expresiones de los dos tipos asociados se asocia (siempre será de multiplicidad 1). Para esto se utiliza como pseudoatributo los nombres de los roles de la relación original. O sea que vale: exp C.rol 1 retorna una expresión de tipo T A. exp C.rol 2 retorna una expresión de tipo T B. Existe un caso que vale la pena distinguirlo, que es cuando la asociación se presenta entre una clase A y sí misma (no existiría una clase B). Este sería el caso: El problema ocurre con las referencias al pseudoatributo-clase de asociación C dentro del contexto de la clase A, ya que habría que hacer explícito el rol origen de las expresiones-objeto del tipo de la clase A a las que se refiere. Esto se hace escribiendo entre corchetes el rol dentro de la asociación: exp A.rol 2 retorna una expresión de tipo Set(T A ). exp A.rol 1 retorna una expresión de tipo T A. exp A [rol 1 ].C retorna una expresión de tipo Set(T C )(toma a exp A desde rol 1 ). exp A [rol 2 ].C retorna una expresión de tipo T C (toma a exp A desde rol 2 ). Sobre el uso de la herencia Como OCL es tipado y existe una jerarquía de tipos (basado en herencia múltiple, que es la del diagrama de clases), entonces se aplican las reglas de covarianza y contravarianza presente en los chequeos de tipos de los lenguajes de programación orientados a objetos (Eiffel, Java, Object Pascal, etc).

22 Al tener como una de las vetas principales a la orientación a objetos, se aceptan las reglas de herencia (todas los tipos heredan los atributos, métodos y pseudoatributos de sus supertipos). También se aceptan las reglas de sobrecarga de métodos en subtipos. Esto último no es definitorio de la orientación a objetos, pero se usa en todos los conceptos relacionados con la orientación a objetos. Existen varias operaciones aplicables a cualquier tipo de expresión muy relacionadas con el concepto de herencia y con la idea de tratar a los tipos de datos como datos propiamente dichos (ya se mencionó antes de OCLType, que es el metatipo), como por ejemplo, expresar expresiones lógicas de la forma el tipo de la expresión var45 es Set(Integer). Esto se relaciona con la idea de que una expresión es de un tipo, pero también es de todos los supertipos de ése (por el polimorfismo de inclusión propio de la herencia). Estas operaciones son: OCLAny.OCLisKindOf(exp: OCLType): Boolean Retorna si el tipo de la expresión receptora (de tipo OCLAny) es exp o subtipo de exp. OCLAny.OCLisTypeOf(exp: OCLType): Boolean Retorna si el tipo de la expresión receptora (de tipo OCLAny) es idéntico a exp. T 1.OCLasType(T 2 : OCLType): T 2 Retorna la misma expresión recibida (de tipo T 1 ), aunque se asume que el tipo de esta expresión retornada es de tipo T 2. Representa el typecast elegante de la orientación a objetos, donde debe ocurrir que T 2 < T 1. El objetivo del uso de esta operación es poder aplicar algún atributo, pseudoatributo o método/responsabilidad de un subtipo del tipo de la expresión si se sabe con seguridad que también pertenece a ese subtipo. Sobre la recursión y los valores indefinidos En OCL se permite utilizar recursión en todos las definiciones que se necesiten. Dependiendo de la semántica de los métodos/responsabilidades, la aplicación de éstos a expresiones pueden retornar valores indefinidos. Todos los métodos/responsabilidades, atributos y pseudoatributos se consideran estrictos, con lo que si uno de sus parámetros (o la expresión-objeto receptora) es indefinida (<undefined>), su resultado también será indefinido. Existen muy pocos casos donde no existe estrictez, y está relacionado a operaciones sobre los valores lógicos, a saber: if true then r else <undefined> endif = r if false then <undefined> else r endif = r

23 true or <undefined> = true false and <undefined> = false false implies <undefined> = true Relacionado con este tema, se puede utilizar la siguiente operación: OCLAny.OCLisUndefined(): Boolean Retorna si la expresión receptora (de tipo OCLAny) es indefinida. Se usa básicamente para la captura de errores. Bibliografía - UML 2.0 OCL Specification (documento de la OMG publicado en Internet en ). - Object Constraint Language Specification (documento de Internet ubicado en ). - Muchos otros documentos extraídos de Internet.