versión 1.1 1 de Septiembre de 1997 DE MATERIAS Y LIBROS/LIBROS... · Especificación del Lenguaje de Restricciones para Objetos, v 1.1 1 1. NOTA PRELIMINAR Este documento introduce

ad/97-08-08

versión 1.1 1 de Septiembre de 1997

Rational Software Microsoft Hewlett-Packard Oracle

Sterling Software MCI Systemhouse Unisys ICON Computing IntelliCorp i-Logix IBM ObjecTime Platinum Technology Ptech

Taskon Reich Technologies Softeam

Traducción al Español : Baufest Software

ii Especificación del Lenguaje de Restricciones para Objetos, v 1.1

Copyright © 1997 IBM Corporation. Copyright © 1997 Rational Software Corporation. Copyright © 1997 Microsoft Corporation. Copyright © 1997 Hewlett-Packard Company. Copyright © 1997 Oracle Corporation. Copyright © 1997 Sterling Software. Copyright © 1997 MCI Systemhouse Corporation. Copyright © 1997 Unisys Corporation. Copyright © 1997 ICON Computing. Copyright © 1997 IntelliCorp. Copyright © 1997 i-Logix. Copyright © 1997 ObjecTime Limited. Copyright © 1997 Platinum Technology Inc. Copyright © 1997 Ptech Inc. Copyright © 1997 Taskon A/S. Copyright © 1997 Reich Technologies. Copyright © 1997 Softeam. Copyright © 1998 de la traducción al Español Baufest Software.

Está permitido fotocopiar, distribuir electrónicamente, o traducir a otros idiomas este documento, si es reproducido en su totalidad y acompañado con esta nota completa, incluida la siguiente frase:

Las actualizaciones más recientes del Lenguaje Unificado para Modelado están disponibles vía Internet, en Inglés en el sitio: http://www.rational.com/uml y en Español en el sitio: http://www.baufest.com/uml.

Un programa analizador (parser) gratuito de OCL y la información más reciente sobre el Lenguaje de Restricciones para Objetos está disponible vía Internet en el sitio: http://www.software.ibm.com/ad/ocl.

El logo de UML es una marca registrada de Rational Software Corp.

Especificación del Lenguaje de Restricciones para Objetos, v 1.1 iii

Contenido 1. NOTA PRELIMINAR 1

1.1 Porqué OCL? ............................................................................................................................................... 1 1.2 Dónde Usar el OCL ..................................................................................................................................... 2

2. INTRODUCCION 2 2.1 Leyenda ....................................................................................................................................................... 2 2.2 Diagrama de Clases Ejemplo ....................................................................................................................... 3

3. CONEXION CON EL METAMODELO DEL UML 3 3.1 Instancia (Self) ............................................................................................................................................ 3 3.2 Invariantes ................................................................................................................................................... 4 3.3 Pre y Post-condiciones ................................................................................................................................. 4 3.4 Guardas ........................................................................................................................................................ 4 3.5 Expresiones Generales ................................................................................................................................. 5

4. VALORES Y TIPOS BASICOS 5 4.1 Tipos Provenientes del Modelo UML ......................................................................................................... 5 4.2 Tipos Enumeración ...................................................................................................................................... 5 4.3 Concordancia de Tipos ................................................................................................................................ 6 4.4 Transformación de Tipo (Casting) ............................................................................................................... 6 4.5 Reglas de Precedencia ................................................................................................................................. 7 4.6 Comentarios ................................................................................................................................................. 7 4.7 Valores Indefinidos ...................................................................................................................................... 7

5. OBJETOS Y PROPIEDADES 8 5.1 Propiedades .................................................................................................................................................. 8 5.2 Propiedades: Atributos ................................................................................................................................ 8 5.3 Propiedades: Operaciones ............................................................................................................................ 8 5.4 Propiedades: Extremo de Asociación y Navegación ................................................................................... 9 5.5 Navegación hacia Tipos Asociación .......................................................................................................... 11 5.6 Navegación desde Clases Asociación ........................................................................................................ 11 5.7 Navegación a través de Asociaciones Cualificadas ................................................................................... 11 5.8 Utilización de Caminos para Paquetes y Propiedades ............................................................................... 11 5.9 Características Predefinidas para todos los Objetos .................................................................................. 12 5.10 Características propias de los Tipos........................................................................................................... 13 5.11 Colecciones ................................................................................................................................................ 13 5.12 Colecciones de Colecciones ...................................................................................................................... 14 5.13 Jerarquía de Tipos de las Colecciones y Reglas de Concordancia de Tipo ............................................... 14 5.14 Valor Previo en las Post-condiciones ........................................................................................................ 15

6. OPERACIONES DE LAS COLECCIONES 16 6.1 Operaciones Seleccionar y Descartar (Select, Reject) ............................................................................... 16 6.2 Operación Recolectar (Collect) ................................................................................................................. 17 6.3 Operación ParaTodos (ForAll) .................................................................................................................. 18 6.4 Operación Existe (Exists) ........................................................................................................................... 19 6.5 Operación Iterar (Iterate) .......................................................................................................................... 19

7. TIPOS PREDEFINIDOS DEL OCL 20 7.1 Tipos Básicos ............................................................................................................................................. 20 7.2 Tipos de Colecciones ................................................................................................................................. 26

8. GRAMATICA DEL OCL 32

Especificación del Lenguaje de Restricciones para Objetos, v 1.1 1

1. NOTA PRELIMINAR Este documento introduce y define el Lenguaje de Restricciones para Objetos (Object Constraint Language, OCL), un lenguaje formal para expresar restricciones libres de efectos colaterales. Los usuarios del Lenguaje Unificado para Modelado (UML) y de otros lenguajes, pueden usar el OCL para especificar restricciones y otras expresiones incluidas en sus modelos.

El OCL fue usado en el documento Semántica del UML para especificar las reglas bien formadas del meta-modelo del UML. Dentro del documento Semántica del UML, en las secciones donde se define la semántica estática, cada regla bien formada contiene una expresión OCL que es una invariante para cada clase en cuestión. La gramática del OCL está especificada al final de este documento. Un programa analizador (parser) generado a partir de esta gramática analizó correctamente todas las restricciones contenidas en el documento Semántica del UML, proceso que ayudó a mejorar la correcta especificación del OCL y del UML.

1.1 PORQUÉ OCL? En el modelado orientado a objetos, un modelo gráfico como el de clases no es suficiente para lograr una especificación precisa y no ambigua. Existe la necesidad de describir restricciones adicionales sobre los objetos del modelo. Muchas veces estas restricciones se describen en lenguaje natural. La práctica ha revelado que muy frecuentemente esto produce ambigüedades. Para escribir restricciones no ambiguas se han desarrollado los lenguajes formales. La desventaja de los lenguajes formales tradicionales es que son adecuados para personas con una fuerte formación matemática, pero difíciles para el modelador de negocios o de sistemas promedio.

El OCL ha sido desarrollado para cubrir esa brecha. Es un lenguaje formal, fácil de leer y escribir. Ha sido desarrollado como un lenguaje de modelado para negocios dentro de la división Seguros de IBM, y tiene sus raíces en el método Syntropy.

El OCL es un lenguaje de expresiones puro. Por lo tanto, garantiza que una expresión OCL no tendrá efectos colaterales; no puede cambiar nada en el modelo. Esto significa que el estado del sistema no cambiará nunca como consecuencia de una expresión OCL, aun cuando una expresión OCL puede usarse para especificar un cambio de estado, por ejemplo, en una post-condición. Todos los valores, de todos los objetos, incluyendo todos los links, no cambiarán. Cuando una expresión OCL es evaluada, simplemente devuelve un valor.

El OCL no es un lenguaje de programación, por lo tanto no es posible escribir lógica de programas o flujo de control en OCL. No es posible invocar procesos o activar operaciones que no sean consultas en OCL. Dado que el OCL es un lenguaje de modelado en primer lugar, es posible que haya cosas en él que no sean directamente ejecutables.

OCL es un lenguaje tipado, por lo tanto cada expresión OCL tiene un tipo. En una expresión OCL correcta todos los tipos deben concordar. Por ejemplo, no es posible comparar Enteros con Literales (Strings). Cualquier Clasificador dentro del UML puede ser un tipo en OCL.

Como es un lenguaje de modelado, toda consideración de implementación está fuera de su alcance, y no puede ser expresada en OCL. Conceptualmente, cada expresión OCL es atómica. El estado de los objetos en el sistema no puede variar durante la evaluación.

2 Especificación del Lenguaje de Restricciones para Objetos, v 1.1

1.2 DÓNDE USAR EL OCL El OCL puede ser usado con distintos propósitos:

• Para especificar invariantes sobre clases y tipos en un modelo de clases. • Para especificar invariantes de tipo para Estereotipos. • Para especificar pre y post-condiciones sobre Operaciones y Métodos. • Para describir Guardas. • Como lenguaje de navegación. • Para especificar restricciones sobre operaciones: operación = expresión

Donde operación es el nombre de la operación y expresión es la restricción. Dado que las operaciones pueden tener parámetros, la restricción también puede tener uno o más parámetros, por ejemplo:

operación(a, b) = expresión operación(a : Tipo1, b : Tipo2) = expresión

Los parámetros de la operación, a y b, pueden ser usados en la expresión que va del lado derecho del signo igual. Las operaciones pueden ser descriptas mediante expresiones recursivas. Es tarea del modelador asegurarse que la recursión esté bien definida. Una restricción sobre una operación puede ser leída como su definición, donde el lado derecho del signo igual determina el valor que devolverá la operación.

Dentro del documento Semántica del UML, el OCL es usado en las reglas bien formadas, como invariantes sobre las meta-clases en la sintaxis abstracta. En varios lugares también es usado para definir operaciones ‘adicionales’, que son usadas luego en las reglas bien formadas.

2. INTRODUCCION

2.1 LEYENDA Los textos escritos con el tipo de letra Courier, como el que figura abajo, son expresiones OCL:

'Esta es una expresión OCL'

La frase subrayada que precede a una expresión OCL determina su contexto: NombreDeTipo 'esta es una expresión OCL que está en el contexto de NombreDeTipo'

Dentro de este documento, las palabras reservadas del OCL están escritas en negritas. Las negritas no tienen un significado formal, son usadas en este documento para que las expresiones sean mas legibles. Las expresiones OCL se escriben usando solo caracteres ASCII.

Las palabras en cursiva dentro del texto principal se refieren a partes de expresiones OCL.


2.2 DIAGRAMA DE CLASES EJEMPLO En este documento se usará como ejemplo el diagrama que sigue.

Trabajocargo : LiteralfechaDeInicio : Fechasalario : EnteroMatrimonio

lugar : Literalfecha : Fecha

cliente

0..1

númeroDeCuenta : Entero

Banco

gerente

compañíasGerenciadas

0..* Compañíanombre : LiteralcantidadDeEmpleados : Entero

valorAcción()empleado empleador

0..* 0..*

PersonaesCasado : BooleanoesDesocupado : BooleanofechaDeNacimiento : Fechaedad : Enteronombre : Literalapellido : Literalsexo : enum{ masculino, femenino }

ingresos(Fecha) : Entero

númeroDeCuenta : Entero

0..1

0..*

0..* 0..*

0..1

0..1

esposa

esposo

0..1

0..1

3. CONEXION CON EL METAMODELO DEL UML

3.1 INSTANCIA (SELF) * Cada expresión OCL está escrita en el contexto de una instancia de un tipo en particular. En una expresión OCL el nombre instancia (self) es usado para referirse a dicha instancia.

* N. T. : Si bien síMismo, propio o mismo (entre otras posibles) hubiesen sido traducciones más literales de la palabra inglesa self, elegimos la palabra instancia porque en su aplicación práctica en las expresiones OCL da una idea más precisa del sentido buscado. Nos parece más adecuado escribir : instancia.númeroDeEmpleados que síMismo.númeroDeEmpleados


3.2 INVARIANTES Una expresión OCL puede ser parte de una Invariante, que es una Restricción estereotipada con «invariante». Cuando una Invariante está asociada a un Clasificador, la expresión es una invariante del tipo, y debe ser verdadera para todas las instancias de ese tipo, en todo momento. Si el contexto es Compañía, entonces instancia se refiere a una instancia de Compañía. En la expresión

instancia.númeroDeEmpleados

instancia es una instancia de Compañía. Podemos ver a instancia como el objeto desde el cual comenzamos la expresión.

En este documento, el tipo de la instancia que da contexto a la expresión OCL parte de una Invariante, es escrita con el nombre subrayado como sigue:

Compañía instancia.númeroDeEmpleados

Muchos veces instancia puede omitirse, porque el contexto es claro, como en el ejemplo de arriba.

Como alternativa a instancia, puede definirse otro nombre para que haga el papel de instancia: c : Compañía c.númeroDeEmpleados

Este ejemplo es idéntico al previo que usaba instancia.

3.3 PRE Y POST-CONDICIONES Las expresiones OCL pueden ser parte de pre-condiciones o post-condiciones, que son Restricciones estereotipadas con «pre-condición» y «post-condición» respectivamente. Las pre-condiciones o post-condiciones se aplican tanto a Métodos como a Operaciones. En este caso la instancia que da contexto es del tipo al que pertenece la operación. La notación usada en este documento es subrayar el tipo y la declaración de la operación, y poner la frase ‘pre:’ y ‘post:’ antes de las pre-condiciones y post-condiciones.

nombreDeTipo::nombreDeOperación(parametro1 : Tipo1, ... ): TipoDevolución pre : parametero1 > … post: resultado = ...

El nombre instancia puede ser usado en la expresión para referirse al objeto en el cual la operación fue llamada, y el nombre resultado se usa para nombrar al objeto resultante, si es que lo hay. Los nombres de los parámetros (parámetro1, ) pueden ser combinados en la expresión OCL. En el diagrama de ejemplo podemos escribir:

Persona::ingreso(f : Fecha) : Entero post: resultado = ...alguna función de instancia y f ...

3.4 GUARDAS Una expresión OCL puede ser parte de una Guarda. En este caso instancia se refiere al Clasificador que contiene la Guarda. Este documento no contiene ejemplos de guardas.


3.5 EXPRESIONES GENERALES Cualquier expresión OCL puede ser usada como valor para un atributo de la clase Expresión de UML o sus subtipos. En este caso, el documento Semántica del UML describe el significado de la expresión.

4. VALORES Y TIPOS BASICOS Existen una serie de tipos básicos predefinidos en OCL que están disponibles en todo momento para ser usados por el modelador. Estos tipos de valores predefinidos son parte de la definición del OCL, e independientes de cualquier modelo de objetos.

El valor más básico en OCL es un valor de uno de los tipos básicos. Algunos de los tipos básicos usados en los ejemplos de este documento, con sus correspondientes ejemplos, son :

Tipo Valores Booleano Verdadero, falso Entero 1, 2, 34, 26524, ...Real 1.5, 3.14, ... Literal 'Ladran, Sancho...'

El OCL define ciertas operaciones sobre los tipos predefinidos. La tabla siguiente brinda algunos ejemplos. En la sección 7 se ofrece la lista completa de operaciones.

Tipo Operaciones Entero *, +, -, /, abs Real *, +, -, /, base Booleano y, o, xo, no, implica, si-entonces-sino-finsi Literal EnMayúsculas, concat

Al final del documento está la lista completa de operaciones de cada tipo. Colección, Conjunto, Bolsa y Secuencia también son tipos básicos. Serán descriptos en las próximas secciones.

4.1 TIPOS PROVENIENTES DEL MODELO UML Cada expresión OCL está escrita en el contexto de: un modelo UML, una cantidad de tipos/clases, sus características y asociaciones, y sus generalizaciones. Todos los tipos/clases del modelo UML son tipos en OCL.

4.2 TIPOS ENUMERACIÓN Como muestra el diagrama ejemplo, nuevos tipos enumeración pueden ser definidos usando:

enum{ valor1, valor2, valor3 }

Los valores de la enumeración (valor1, ...) pueden ser usados dentro de las expresiones.

Como puede darse un conflicto de nombres entre atributos y valores de una enumeración, sintácticamente el uso de un valor de una enumeración es expresado agregando el símbolo # delante:


#valor1

El tipo de un atributo definido mediante una enumeración es Enumeración, con restricciones en los valores que puede tomar el atributo.

4.3 CONCORDANCIA DE TIPOS OCL es un lenguaje tipado y los tipos básicos de valores están organizados en una jerarquía de tipos. Esta jerarquía determina la concordancia de los diferentes tipos entre sí. No es posible, por ejemplo, comparar Enteros con Booleanos, o con literales.

Una expresión OCL en la que todos los tipos concuerdan, es una expresión válida. Una expresión OCL en la que los tipos no concuerdan, no es una expresión válida. Contiene un error de concordancia de tipos. Un tipo tipo1 concuerda con un tipo tipo2 cuando una instancia del tipo1 puede ser sustituida en todos los lugares donde se espera una instancia del tipo2. Las reglas de concordancia de tipos en un diagrama de clases son simples :

• Cada tipo concuerda con su supertipo • La concordancia de tipos es transitiva: si el tipo1 concuerda con el tipo2, y el

tipo2 concuerda con el tipo3, entonces el tipo1 concuerda con el tipo3.

El efecto es que un tipo concuerda con su supertipo, y con todos los supertipos superiores.

Las reglas de concordancia de tipos para los tipos de valores son:

Tipo Concuerda con/ Es subtipo de

Conjunto Colección Secuencia Colección Bolsa Colección Entero Real

La relación de concordancia ente tipos de colecciones sólo vale si son colecciones de elementos cuyos tipos concuerdan entre sí. Ver 5.13 para reglas más completas de concordancia entre colecciones.

En la tabla siguiente se muestran algunos ejemplos de expresiones válidas e inválidas:

Expresión OCL Válida? Error 1 + 2 * 34 Si 1 + 'motocicleta' No El tipo Entero no concuerda con el tipo

literal. 23 * falso No El tipo Entero no concuerda con el tipo

Booleano. 12 + 13.5 Si

4.4 TRANSFORMACIÓN DE TIPO (CASTING) En algunas circunstancias, es deseable usar propiedades de un objeto que está definido como un subtipo del tipo que se conoce del objeto. Como la propiedad no está definida en el tipo que actualmente se conoce del objeto, esto resulta en un error de concordancia de tipos.


Cuando en realidad el tipo del objeto en cuestión es el subtipo, puede transformarse de tipo usando la operación oclComoTipo( OclTipo ). Esta operación resulta en el mismo objeto, pero el tipo conocido del objeto es OclTipo. Cuando un objeto objeto es del tipo Tipo1 y Tipo2 es otro tipo, está permitido escribir :

objeto.oclComoTipo(Tipo2) --- el resultado es un objeto del tipo Tipo2

Un objeto puede ser transformado únicamente a uno de sus subtipos; por lo tanto, en el ejemplo, Tipo2 debe ser un subtipo de Tipo1.

Si el tipo del objeto no es igual al tipo hacia el que es transformado, la expresión es indefinida (ver 4.7).

4.5 REGLAS DE PRECEDENCIA La precedencia de operaciones en OCL es la siguiente :

• El punto y la flecha tienen la más alta precedencia • ‘no’ unario y ‘-‘ unario • ‘*’ y ‘/’ • ‘+’ y ‘-’ binario • ‘y’, ‘o’ y ‘xo’ • ‘implica’ • ‘si-entonces-sino-finsi’ • ‘<’, ‘>’, ‘<=’, ‘>=’ y ‘=’

Los paréntesis ‘(’ y ‘)’ pueden ser usados para cambiar la precedencia.

4.6 COMENTARIOS Los comentarios en OCL se escriben luego de dos guiones. Todo lo que esté después de los dos guiones, hasta e incluyendo el fin de línea, es un comentario. Por ejemplo:

-- esto es un comentario

4.7 VALORES INDEFINIDOS Cuando una expresión OCL es evaluada, existe la posibilidad de que una o más de las consultas en la expresión sean indefinidas. Si éste es el caso, entonces la expresión completa es indefinida.

Hay dos excepciones para los operadores booleanos:

• Verdadero O cualquier cosa es Verdadero • Falso Y cualquier cosa es Falso

Las dos reglas son válidas independientemente del orden de los términos y aún si el valor de la otra sub-expresión es conocido.


5. OBJETOS Y PROPIEDADES Las expresiones OCL pueden referirse a tipos, clases, interfaces, asociaciones (actuando como tipos) y tipos de datos. También todos los atributos, extremos de asociación, métodos y operaciones que no tengan efectos colaterales y estén definidos en esos tipos pueden ser usados. En un modelo de clases, una operación o método no tiene efectos colaterales si el atributo esConsulta de la operación es verdadero. Dentro de este documento, vamos a referirnos a los atributos, extremos de asociación, métodos y operaciones libres de efectos colaterales como propiedades. Por consiguiente una propiedad es una de las siguientes cosas:

• un Atributo, • un Extremo de Asociación, • una Operación con esConsulta en verdadero, • un Método con esConsulta en verdadero

5.1 PROPIEDADES El valor de una propiedad para un objeto que está definido en un diagrama de clases se especifica con un punto seguido del nombre de la propiedad:

UnTipo instancia.propiedad

Si instancia es una referencia a un objeto, entonces instancia.propiedad es el valor de la propiedad propiedad para instancia.

5.2 PROPIEDADES: ATRIBUTOS Por ejemplo, la edad de una Persona se escribe como

Persona instancia.edad

El valor de esta expresión es el valor del atributo edad para la Persona instancia. El tipo de esta expresión es el tipo del atributo edad, que es del tipo básico Entero.

Utilizando atributos y operaciones definidas en los tipos de datos básicos podemos expresar cálculos sobre el modelo de clases. Por ejemplo, una regla del negocio podría ser “la edad de una Persona es siempre mayor o igual a cero”. Esta puede ser especificada como una invariante :

Persona instancia.edad >= 0

5.3 PROPIEDADES: OPERACIONES Las operaciones pueden tener parámetros. Por ejemplo, en el diagrama ejemplo mostrado anteriormente, un objeto Persona tiene un ingreso expresado como una función de una fecha. Esta operación puede ser expresada como sigue, para una Persona unaPersona y una fecha unaFecha :

unaPersona.ingreso(unaFecha)

La operación en sí misma puede ser definida como una post-condición. Esta es una restricción que es estereotipada como «post-condición». Podemos referirnos al objeto devuelto por la operación como el resultado. Toma la siguiente forma:

Persona::ingreso (f: Fecha) : Entero


post: resultado = -- alguna función de f y de otras propiedades de persona

El lado derecho de esta definición puede referirse a la operación que está siendo definida; por ejemplo, la definición de la operación puede ser recursiva, en la medida que la recursión esté bien definida. El tipo del resultado en el tipo que devuelve la operación, Entero en este ejemplo.

Los paréntesis con una lista vacía de argumentos se usan para referirse a una operación o método que no lleva parámetros :

Compañía instancia.precioDeAcción()

5.4 PROPIEDADES: EXTREMO DE ASOCIACIÓN Y NAVEGACIÓN Comenzando desde un objeto en particular, podemos navegar una asociación en un diagrama de clases para referirnos a otro objeto y a sus propiedades. Para hacerlo, navegamos la asociación usando su extremo opuesto :

objeto.nombreDeRol

El valor de esta expresión es el conjunto de objetos que están del otro lado de la asociación nombreDeRol. Si la multiplicidad del extremo de la asociación tiene un máximo de uno (“0..1” o “1”), entonces el valor de la expresión es un objeto. En el diagrama de clases ejemplo, si empezamos en el contexto de Compañía (por ejemplo, instancia es una instancia de Compañía), podemos escribir :

Compañía instancia.gerente -- es de tipo Persona instancia.empleado -- es de tipo Conjunto(Persona)

La evaluación de la primer expresión resultará en un objeto del tipo Persona, porque la multiplicidad de la asociación es uno. La evaluación de la segunda expresión resultará en un Conjunto de Personas. Por defecto, la navegación resultará en un Conjunto. Cuando la asociación, en el diagrama de clases, está adornada por {ordenada}, la navegación resultará en una Secuencia.

Las Colecciones, así como los Conjuntos, las Bolsas y las Secuencias, son tipos predefinidos en OCL. Tienen un gran número de operaciones predefinidas. Una propiedad de la colección en sí es accedida utilizando la flecha ‘->’ seguida del nombre de la propiedad. El siguiente ejemplo es en el contexto de Persona:

Persona instancia.empleador->tamaño

El ejemplo aplica la propiedad tamaño al Conjunto instancia.empleador, que da como resultado el número de empleadores de la Persona instancia.

Persona instancia.empleador->esVacio

Este ejemplo aplica la propiedad esVacio al Conjunto instancia.empleador. El resultado es verdadero si el conjunto de empleadores es vacío, y falso si no lo es.

5.4.1 Nombres de Rol Faltantes Cuando un nombre de rol no está presente en uno de los extremos de una asociación, se utiliza el nombre del tipo que está en ese extremo, comenzando con minúscula. Si existiese una ambigüedad, el nombre de rol es obligatorio. Éste es el caso de las asociaciones reflexivas. Si el nombre de rol es ambiguo, entonces no puede ser utilizado en OCL.


5.4.2 Navegación a través de Asociaciones con Multiplicidad Cero o Uno

Dado que la multiplicidad del rol gerente es uno, instancia.gerente es un objeto del tipo Persona. Ese objeto puede ser utilizado también como un Conjunto. En ese caso se comporta como un Conjunto conteniendo un único objeto. El uso como conjunto se hace mediante una flecha, seguida de la propiedad del Conjunto. El siguiente ejemplo lo ilustra :

Compañía instancia.gerente->tamaño -- ‘instancia.gerente’ es usado como un -- Conjunto porque la flecha es usada para -- acceder a la propiedad ‘tamaño’ -- Esta expresión resulta en 1. instancia.gerente->foo -- ‘instancia.gerente’ es usado como un -- Conjunto porque la flecha es usada para -- acceder a la propiedad ‘foo’ -- Esta expresión es incorrecta ya que ‘foo’ -- no es una propiedad de Conjunto instancia.gerente.edad -- ‘instancia.gerente’ es usado como una -- Persona porque se utiliza el punto. -- Es usada para acceder a la propiedad -- ‘edad’

Si la asociación es opcional (multiplicidad 0..1), la siguiente expresión es útil para verificar si existe un objeto o no cuando se navega la asociación :

Persona instancia.esposa->noVacía implica instancia.esposa.sexo = femenino

5.4.3 Combinación de Propiedades Las propiedades pueden ser combinadas para formar expresiones más complejas. Una regla importante es que una expresión OCL siempre da como resultado un objeto específico, de un tipo específico. Sobre este resultado, uno puede siempre aplicar otra propiedad. Por lo tanto, cada expresión OCL puede ser leída y evaluada de izquierda a derecha.

A continuación se presentan algunas invariantes que usan propiedades combinadas en el diagrama de clases ejemplo :

[1] La edad de las personas casadas es >= 18 instancia.esposa->noVacía implica instancia.esposa.edad >= 18 y instancia.esposo->noVacío implica instancia.esposo.edad >= 18

[2] Una compañía tiene como máximo 50 empleados instancia.empleado->tamaño <= 50

[3] Un matrimonio es entre una mujer (esposa) y un varón (esposo) instancia.esposa.sexo = #femenino y instancia.esposo.sexo = #masculino

[4] Una persona no puede tener esposa y esposo a la vez no ((instancia.esposa->tamaño = 1) y (instancia.esposo->tamaño = 1))


5.5 NAVEGACIÓN HACIA TIPOS ASOCIACIÓN Para especificar navegación a clases asociación (Trabajo y Matrimonio en el ejemplo), OCL usa el punto y el nombre de la clase asociación comenzando con minúscula :

Persona instancia.trabajo

El resultado de esta expresión es el Conjunto de todos los trabajos que una persona tiene con las compañías que son sus empleadores. Las clases asociación no tienen un nombre de rol específico en el diagrama de clases. El nombre trabajo usado en esta navegación es el nombre de la clase asociación comenzando con minúscula, similar al la manera descripta en la sección “Nombre de Rol Faltante” más arriba.

5.6 NAVEGACIÓN DESDE CLASES ASOCIACIÓN Podemos navegar desde la clases asociación hacia el objeto que participa en la asociación. Esto se hace utilizando el punto y el nombre de rol del extremo de la asociación.

Trabajo instancia.empleado instancia.empleador

La navegación desde una clase asociación a uno de los objetos de la asociación siempre entregará exactamente un objeto. Este es el resultado de la definición de una ClaseAsociación. Por lo tanto el resultado de esta navegación es exactamente un objeto, aunque también puede usarse como un Conjunto utilizando la flecha (->).

5.7 NAVEGACIÓN A TRAVÉS DE ASOCIACIONES CUALIFICADAS Las asociaciones cualificadas usan uno o más atributos cualificadores para seleccionar el objeto del otro extremo de la asociación. Para navegarlos, podemos agregar el valor del cualificador a la navegación. Esto se hace utilizando corchetes a continuación del nombre de rol. Es permitido dejar de lado los valores de los cualificadores, en cuyo caso el resultado será todos los objetos del otro extremo de la asociación.

Banco instancia.cliente -- resulta en un Conjunto(Persona) conteniendo -- todos los clientes del Banco instancia.cliente[8764423] -- resulta en una Persona, cuyo numero de -- cuenta es 8764423

Si hay más de un atributo cualificador, los valores se separan con comas. No está permitido especificar parcialmente los valores del atributo cualificador.

5.8 UTILIZACIÓN DE CAMINOS PARA PAQUETES Y PROPIEDADES Dentro del UML, los tipos se organizan en paquetes. OCL provee una forma de referirse explícitamente a tipos de otros paquetes utilizando un camino como prefijo del paquete. La sintaxis es un nombre de paquete seguido de dos puntos dobles:

NombreDePaquete::NombreDeTipo

Este uso de los caminos es transitivo y también puede ser usado para paquetes anidados: NombreDePaquete1::NombreDePaquete2::NombreDeTipo


Cuando se definen propiedades dentro de un tipo, la propiedad del supertipo puede ser accedida usando la misma sintaxis. Cuando tenemos una clase B, como un subtipo de la clase A, y una propiedad p1 de ambas A y B. Podemos escribir:

B instancia.A::p1 -- accede a la propiedad p1 definida en A instancia.B::p1 -- accede a la propiedad p1 definida en B

El siguiente ejemplo muestra cuando ese camino es necesario:

....

Dependencia

destino

fuente*

*

ElementoDelModelo

Notavalor: NoInterprestado

En este fragmento de modelo existe una ambigüedad en la expresión OCL sobre Dependencia: Dependencia instancia.fuente

Puede referirse tanto a una navegación normal a través de la asociación, que es heredada de ElementoDelModelo, o a una navegación a través de la línea punteada como clase asociación. Ambas navegaciones posibles usan el mismo nombre de rol, por lo tanto siempre existe la ambigüedad. Usando los caminos podemos distinguir entre ambos de esta forma:

Dependencia instancia.Dependencia::fuente instancia.ElementoDelModelo::fuente

5.9 CARACTERÍSTICAS PREDEFINIDAS PARA TODOS LOS OBJETOS Existen una serie de características que se aplican a todos los objetos, y que están predefinidas en OCL. Estas son:

oclTipo : OclTipo oclEsDeTipo(t : OclTipo) : booleano oclEsCompatibleCon(t : OclTipo) : booleano

oclTipo resulta en el tipo del objeto. Por ejemplo, la expresión Persona instancia.oclTipo

resulta en Persona. El tipo de este resultado es OclTipo, un tipo predefinido en OCL (no Persona, que es el tipo de instancia).

La operación esDeTipo resulta en verdadero si el tipo de instancia y el de t son el mismo. Por ejemplo:

Persona


instancia.oclEsDeTipo( Persona ) -- es verdadero instancia.oclEsDeTipo( Compañía ) -- es falso

Esta característica está referida al tipo directo del objeto. La operación oclEsCompatibleCon determina si t es el tipo o uno de los supertipos del tipo.

5.10 CARACTERÍSTICAS PROPIAS DE LOS TIPOS Las propiedades discutidas hasta ahora en OCL son propiedades de las instancias de las clases. Los tipos pueden estar predefinidos en OCL o ser definidos en el modelo de clases. En OCL, es posible usar características definidas en los tipos/clases en sí. Existen, por ejemplo, las características definidas en el modelo de clases cuyo alcance es la clase. También ciertas características están predefinidas para cada tipo.

La característica predefinida más importante para cada tipo es todasLasInstancias, que resulta en el Conjunto de todos las instancias del tipo. Si queremos asegurarnos que todas las instancias de Persona tienen un único nombre podemos escribir:

Persona.todasLasInstancias->paraTodos(p1, p2 | p1 <> p2 implica p1.nombre <> p2.nombre)

El conjunto Persona.todasLasInstancias contiene todas las personas y es del tipo Conjunto(Persona).

5.11 COLECCIONES Frecuentemente una navegación da como resultado una colección; por lo tanto el tipo colección juega un rol importante en las expresiones OCL.

El tipo Colección está predefinido en OCL. El tipo Colección contiene un gran número de operaciones predefinidas para permitir al autor de expresiones OCL (el modelador) manipular colecciones. Consistente con la definición del OCL como lenguaje de expresiones, las operaciones de las colecciones nunca cambian la colección; esConsulta es siempre verdadero. Pueden resultar en una colección, pero en vez de cambiar la colección original, proyectan el resultado en una nueva colección.

Colección es un tipo abstracto, con subtipos concretos. OCL distingue tres tipos diferentes de colecciones: Conjunto, Secuencia y Bolsa. Un Conjunto es un conjunto matemático. No contiene elementos duplicados. Una Bolsa es como un Conjunto, pero puede contener elementos duplicados, por ejemplo, el mismo elemento puede estar en la Bolsa dos o más veces. Una Secuencia es como una Bolsa, en la cual los elementos están ordenados. Tanto los Conjuntos como las Bolsas no tienen un orden definido. Los Conjuntos, Secuencias y Bolsas pueden ser especificados mediante un literal en OCL. Los elementos de la colección se escriben separados por comas y entre llaves. El tipo de la colección se escribe antes de la llave:

Conjunto { 1 , 2 , 5 , 88 } Conjunto { 'manzana' , 'naranja', 'pera' }

Una Secuencia: Secuencia { 1, 3, 45, 2, 3 } Secuencia { 'botella', 'vaso' }

Una Bolsa: Bolsa {1 , 3 , 4, 3, 5 }


Dada la utilidad de las secuencias de Enteros consecutivos, hay un literal especial para crearlas. Los elementos dentro de las llaves pueden ser especificados usando intervalos, que consisten en dos expresiones de tipo Entero, Ent-expr1 y Ent-expr2, separadas por ‘..’. Esta denota todos los enteros entre el valor de Ent-expr1 y Ent-expr2, incluyendo los valores de Ent-expr1 y Ent-expr2:

Secuencia{ 1..(6 + 4) } Secuencia{ 1..10 } -- son ambas idénticas a Secuencia{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }

La lista completa de las operaciones de Colección se describen al final de este documento.

Las colecciones pueden ser especificadas por medio de literales, como se describe arriba. La única manera alternativa de obtener colecciones es mediante una navegación. Para ser más precisos, la única manera de obtener un Conjunto, Secuencia o Bolsa es :

• Un literal: Conjunto {1 , 2, 3 , 5 , 7 , 11, 13, 17 } Secuencia {1 , 2, 3 , 5 , 7 , 11, 13, 17 } Bolsa {1, 2, 3, 2, 1}

• Una navegación comenzando desde un objeto simple: Compañía instancia.empleado

• Operaciones sobre colecciones: colección1->unión(colección2)

5.12 COLECCIONES DE COLECCIONES En OCL, todas las colecciones de colecciones son automáticamente aplanadas. Por lo tanto estas dos expresiones tienen el mismo valor:

Conjunto{ Conjunto{1, 2}, Conjunto{3, 4}, Conjunto{5, 6} } Conjunto{ 1, 2, 3, 4, 5, 6 }

5.13 JERARQUÍA DE TIPOS DE LAS COLECCIONES Y REGLAS DE CONCORDANCIA DE TIPO

Además de las reglas de concordancia de tipos de la sección 4.3, las siguientes reglas valen para todos los tipos, incluyendo las colecciones:

• Cada tipo Colección (X) es subtipo de OclCualquiera. Los tipos Conjunto (X), Bolsa (X) y Secuencia(X) son todos subtipos de Colección (X).

Las reglas de concordancia de tipos son las siguientes para los tipo colección:

• Tipo1 conforma con Tipo2 cuando son idénticos (regla común para todos los tipos). • Tipo1 conforma con Tipo2 cuando es un subtipo de Tipo2 (regla común para todos los

tipos). • Colección (Tipo1) conforma con Colección(Tipo2), cuando Tipo1 conforma con Tipo2. • La concordancia de tipos es transitiva: si Tipo1 conforma con Tipo2, y Tipo2 conforma con

Tipo3, entonces Tipo1 conforma con Tipo3 (regla común para todos los tipos).

Por ejemplo, si Bicicleta y Auto son dos tipos separados, subtipos de Transporte:


Conjunto(Bicicleta) conforma con Conjunto(Transporte) Conjunto(Bicicleta) conforma con Colección(Bicicleta) Conjunto(Bicicleta) conforma con Colección(Transporte)

Note que Conjunto(Bicicleta) no conforma con Bolsa(Bicicleta), ni tampoco a la inversa. Ambos son subtipos de Colección(Bicicleta) al mismo nivel en la jerarquía.

5.14 VALOR PREVIO EN LAS POST-CONDICIONES Como se dijo en la sección 3.3, OCL puede ser usado para especificar pre y post-condiciones sobre Operaciones y Métodos en UML. En una post-condición, la expresión puede referirse a dos conjuntos de valores para cada propiedad de un objeto:

• El valor de la propiedad al comienzo de la operación o método • El valor de la propiedad luego de la culminación de la operación o método

El valor de una propiedad en una post-condición es el valor luego de la conclusión de la operación. Para referirse al valor de la propiedad al comienzo de la operación, se usa el nombre de la propiedad seguida del signo ‘@’ y la palabra ‘pre’.

Persona::cumplióAños() post: edad = edad@pre + 1

La propiedad edad se refiere a la propiedad de la instancia de Persona en la que se ejecuta la operación. La propiedad edad@pre se refiere al valor de la propiedad edad de la Persona en la que se ejecuta la operación, al comienzo de la misma.

Si una propiedad tiene parámetros, el ‘@pre’ va entre el nombre de la propiedad y los parámetros. Compañía::contratarEmpleado(p : Persona) post: empleado = empleado@pre->incluye(p) y valorDeAcción() = valorDeAcción@pre() + 10

La expresión anterior puede ser especificada por una pre y post-condición : Compañía::contratarEmpleado(p : Persona) pre : no empleado->incluye(p) post: empleado->include(p)

Cuando el valor anterior de una propiedad es un objeto, todas las propiedades de este objeto accedidas devuelven los valores nuevos (luego de la finalización de la operación).

[email protected] -- toma el valor anterior de la propiedad b de a, digamos x, -- y luego el nuevo valor de la propiedad c de x. [email protected]@pre -- toma el valor anterior de la propiedad b de a, digamos x, -- y luego el valor anterior de la propiedad c de x.

El sufijo ‘@pre’ es permitido sólo en expresiones OCL que son parte de post-condiciones. Preguntar por el valor actual de un objeto que ha sido destruído durante la ejecución de la operación da Indefinido como resultado. Así también, preguntar por el valor anterior de un objeto que ha sido creado durante la ejecución de una operación da Indefinido.


6. OPERACIONES DE LAS COLECCIONES El OCL define muchas operaciones sobre los tipos colección. Estas operaciones están pensadas especialmente para permitir proyectar nuevas colecciones a partir de existentes, de una forma flexible y poderosa. Las diferentes operaciones se describen en las secciones que siguen.

6.1 OPERACIONES SELECCIONAR Y DESCARTAR (SELECT, REJECT) En ocasiones, una expresión que utiliza operaciones y navegación produce una colección, cuando en realidad estamos interesados en un subconjunto especial de dicha colección. OCL provee construcciones para especificar una selección sobre ella: las operaciones seleccionar y descartar. La selección especifica un subconjunto de la colección. Seleccionar es una operación de una colección y es especificada utilizando la flecha:

colección->seleccionar( ... )

El parámetro de la selección tiene una sintaxis especial que le permite a uno especificar qué elementos de la colección queremos seleccionar. Existen tres formas diferentes, de las cuales la más simple es la siguiente :

colección->seleccionar( expresión-booleana )

La expresión da como resultado una colección que contiene todos los elementos de la colección para los cuales la expresión-booleana es verdadera. Para encontrar el resultado de esta expresión, para cada elemento de la colección, se evalúa la expresión-booleana. Si el resultado es verdadero, el elemento es incluido en la colección resultante, si no, no. A manera de ejemplo, la siguiente expresión OCL especifica todos los empleados mayores de 50 años:

Compañía instancia.empleado->seleccionar(edad > 50)

instancia.empleado es del tipo Conjunto(Persona). La operación seleccionar toma cada persona de instancia.empleado y evalúa edad > 50 para esa persona. Si el resultado es verdadero, la persona es incluida en el Conjunto resultante.

Como se muestra en el ejemplo previo, el contexto de la expresión que hace de argumento es el elemento de la colección sobre la que se invoca el seleccionar. Por lo tanto la propiedad edad se evaluará en el contexto de persona.

En el ejemplo anterior, es imposible referirse explícitamente a cada persona en sí; sólo puede hacerse referencia a sus propiedades. Para permitir hacer referencia a la persona en sí, existe una sintaxis más general para la expresión de selección:

colección->seleccionar( v | expresión-booleana-con-v )

La variable v es llamada iterador. Cuando el seleccionar es evaluado, v itera sobre la colección y la expresión-booleana-con-v es evaluada para cada objeto. El v es una referencia al objeto en sí y puede ser usada para referirse a los objetos que componen la colección. Los dos ejemplos que siguen son idénticos:

Compañía instancia.empleado->seleccionar(edad > 50) Compañía instancia.empleado->seleccionar( p | p.edad > 50)


El resultado del seleccionar es la colección de personas p para las cuales p.edad > 50 es Verdadero. Esto es un subconjunto de instancia.empleado.

Como extensión final de la sintaxis de la selección, puede declararse el tipo esperado de la variable v. En ese caso la selección se escribe:

colección->seleccionar( v : Tipo | expresión-booleana-con-v )

El significado es que los objetos de la colección deben ser del tipo Tipo. El ejemplo siguiente es idéntico a los previos:

Compañía instancia.empleado->seleccionar( p : Persona | p.edad > 50)

Entonces, la sintaxis del seleccionar es una de estas: colección->seleccionar( v : Tipo | expresión-booleana-con-v ) colección->seleccionar( v | expresión-booleana-con-v ) colección->seleccionar( expresión-booleana )

La operación Descartar es idéntica a la operación seleccionar, pero con descartar obtenemos todos los elementos de la colección para los cuales la expresión es Falsa. La sintaxis de descartar es idéntica de la de seleccionar:

colección->descartar( v : Tipo | expresión-booleana-con-v ) colección->descartar( v | expresión-booleana-con-v ) colección->descartar( expresión-booleana )

Para dar un ejemplo, especifiquemos todos los empleados que no son casados: Compañía instancia.empleado->descartar( esCasado )

La operación descartar está incluida en el OCL por conveniencia, porque puede ser re-escrita como un seleccionar con la expresión negada. Las dos expresiones que siguen son idénticas:

colección->descartar( v : Tipo | expresión-booleana-con-v ) colección->seleccionar( v : Tipo | no (expresión-booleana-con-v) )

6.2 OPERACIÓN RECOLECTAR (COLLECT) Como se mostró en la sección anterior, las operaciones seleccionar y descartar siempre dan como resultado una sub-colección de la colección original. Cuando queremos especificar una colección que es derivada de otra colección, pero que contiene distintos elementos que la colección original, podemos usa la operación recolectar. La operación recolectar lleva la misma sintaxis que seleccionar y descartar:

colección->recolectar( v : Tipo | expresión-con-v ) colección->recolectar( v | expresión-con-v ) colección->recolectar( expresión )

El valor de la operación recolectar es la colección de los resultados de todas las evaluaciones de la expresión-con-v.

El ejemplo especifica la colección de las fechaDeNacimiento de todos los empleados en el contexto de una compañía:

Compañía instancia.empleado->recolectar( fechaDeNacimiento ) instancia.empleado->recolectar( persona | persona.fechaDeNacimiento ) instancia.empleado->recolectar( persona : Persona | persona.fechaDeNacimiento )


Un aspecto importante es que la colección resultante no es un Conjunto, sino una Bolsa. Cuando más de un empleado tiene la misma fechaDeNacimiento, este será un elemento de la Bolsa resultante más de una vez. La Bolsa resultante de la operación recolectar siempre tiene el mismo tamaño que la colección original.

Es posible hacer un Conjunto a partir de una Bolsa utilizando la propiedad de Bolsa comoConjunto. La siguiente expresión especifica el Conjunto de las diferentes fechaDeNacimiento de todos los empleados de la Compañía:

Compañía instancia.empleado->recolectar( fechaDeNacimiento )->comoConjunto

6.2.1 Forma abreviada para Recolectar Dado que navegar a través de muchos objetos es muy común, existe una notación abreviada para recolectar que hace las expresiones OCL más legibles. En vez de:

instancia.empleado->recolectar(fechaDeNacimiento)

podemos escribir: instancia.empleado.fechaDeNacimiento

En general, cuando queremos aplicar una propiedad a una Colección de Objetos, automáticamente será interpretada como un recolectar sobre los miembros de la Colección, con la propiedad especificada.

Por lo tanto, para cada nombreDePropiedad que está definida como una propiedad de los objetos de una colección, las dos expresiones que siguen son idénticas:

colección.nombreDePropiedad colección->recolectar(nombreDePropiedad)

y lo mismo sucede para las propiedades que llevan parámetros: colección.nombreDePropiedad( par1, par2, ...) colección->recolectar(nombreDePropiedad( par1, par2, ...))

6.3 OPERACIÓN PARATODOS (FORALL) Muchas veces una restriccion es necesaria para todos los elementos de una colección. La operación paraTodos en OCL permite especificar expresiones Booleanas, que deben cumplirse para todos los elementos de la colección:

colección->paraTodos( v : Tipo | expresión-booleana-con-v ) colección->paraTodos( v | expresión-booleana-con-v ) colección->paraTodos( expresión-booleana )

Esta expresión paraTodos tiene un resultado Booleano. El resultado es verdadero si la expresión-booleana-con-v es verdadera para todos los elementos de la colección. Si la expresión-booleana-con-v es falsa para uno o más v en la colección, entonces toda la expresión es falsa. Por ejemplo, en el contexto de Compañía:

Compañía instancia.empleado->paraTodos( primerNombre = 'Juan' ) instancia.empleado->paraTodos( p | p.primerNombre = 'Juan' ) instancia.empleado->paraTodos( p: Persona | p.primerNombre = 'Juan' )

Esta expresión es verdadera si la propiedad primerNombre de cada empleado es igual a ‘Juan’.


La operación paraTodos tiene una variante extendida en la que se usa más de un iterador. Ambos iteradores iterarán sobre la colección completa. Efectivamente es un paraTodos sobre el producto cartesiano de la colección con sí misma.

Compañía instancia.empleado->paraTodos( e1, e2 | e1 <> e2 implica e1.primerNombre <> e2.primerNombre) instancia.empleado->paraTodos(e1, e2 : Persona | e1 <> e2 implica e1.primerNombre <> e2.primerNombre)

Esta expresión es verdadera si el primerNombre de todos los empleados es distinto.

Es semánticamente equivalente a: Compañía instancia.empleado->paraTodos(e1 | instancia.empleado->paraTodos (e2 | e1 <> e2 implica e1.primerNombre <> e2.primerNombre)))

6.4 OPERACIÓN EXISTE (EXISTS) Muchas veces uno necesita saber si en una colección hay al menos un elemento que cumple cierta condición. La operación existe permite especificar una expresión booleana que debe cumplir al menos un objeto de la colección:

colección->existe( v : Tipo | expresión-booleana-con-v ) colección->existe( v | expresión-booleana-con-v ) colección->existe( expresión-booleana )

La operación existe tiene un resultado Booleano. El resultado es verdadero si la expresión-booleana-con-v es verdadera para, por lo menos, un elemento de la colección. Si la expresión-booleana-con-v es falsa para todos los v de la colección, entonces la expresión completa es falsa. Por ejemplo, en el contexto de una Compañía:

Compañía instancia.empleado->existe( primerNombre = 'Juan' ) instancia.empleado->existe( p | p.primerNombre = 'Juan' ) instancia.empleado->existe( p : Persona | p.primerNombre = 'Juan' )

Esta expresión será verdadera si la propiedad primerNombre es igual a ‘Juan’ para por lo menos un empleado.

6.5 OPERACIÓN ITERAR (ITERATE) La operación iterar es ligeramente más complicada, pero muy genérica. Las operaciones descartar, seleccionar, paraTodos, existe y recolectar pueden ser descriptas en términos de iterar.

Una acumulación construye un valor iterando sobre una colección. colección->iterar( elem : Tipo; acu : Tipo = <expresión> | expresión-con-elem-y-acu )

La variable elem es el iterador como fue definido en seleccionar, paraTodos, etc. La variable acu es el acumulador. El acumulador tiene un valor inicial <expresión>.

Cuando el iterar es evaluado, elem itera sobre la colección y la expresión-con-elem-y-acu es evaluada para cada elem. Luego de cada evaluación de expresión-con-elem-y-acu, su valor es


asignado a acu. De esta forma el valor de acu es construido durante la iteración de la colección. La operación recolectar, escrita en términos de iterar es como sigue:

colección->recolectar(x : T | x.propiedad) -- es idéntica a: colección->iterar(x : T; acu : T2 = Bolsa{} | acu->incluir(x.propiedad))

O escrito en pseudo-código similar a Java, el resultado de iterar puede calcularse como: iterar(elem : T; acu : T2 = valor) { acu = valor; for(Enumeración e = colección.elementos() ; e.tieneMásElementos(); ){ elem = e.próximoElemento(); acu = <expresión-con-elem-y-acu> } }

7. TIPOS PREDEFINIDOS DEL OCL Esta sección contiene todos los tipos estándar definidos en OCL, incluyendo todas las características definidas para esos tipos. La signatura y una descripción de su semántica definen cada característica. Dentro de la descripción, el nombre ‘resultado’ se usa para referirse al valor que da como resultado la evaluación de la característica. En algunos lugares se usan post-condiciones para describir las propiedades del resultado. Cuando hay más de una post-condición, todas las post-condiciones tienen que ser verdaderas.

7.1 TIPOS BÁSICOS Los tipos básicos usados son Entero, Real, Literal, y Booleano. Son suplementados con OclExpresión, OclTipo y OclCualquiera.

7.1.1 OclTipo Todos los tipos definidos en un modelo UML, o predefinidos dentro del OCL tienen un tipo. Este tipo es una instancia del tipo OCL llamado OclTipo. El acceso a este tipo le permite al modelador acceder al meta-nivel del modelo. Esto puede ser útil para modeladores avanzados.

Características de OclTipo, una instancia de OclTipo es llamada tipo.

tipo.nombre : Literal

El nombre del tipo.

tipo.atributos : Conjunto(Literal)

El conjunto de nombres de los atributos de tipo, tal como están definidos en el modelo.

tipo.extremosDeAsociación : Conjunto(Literal)

El conjunto de nombres del los extremosDeAsociación navegables de tipo, tal como están definidos en el modelo.

tipo.operaciones : Conjunto(Literal)


El conjunto de nombres de las operaciones de tipo, tal como están definidas en el modelo.

tipo.superTipos : Conjunto(OclTipo)

El conjunto de todos los supertipos directos de tipo. post: tipo.todosLosSupertipos->incluyeTodos(resultado)

tipo.todosLosSupertipos : Conjunto(OclTipo)

La clausura transitiva del conjunto de todos los supertipos de tipo.

tipo.todasLasInstancias : Conjunto(Tipo)

El conjunto de todas las instancias de tipo y todos sus subtipos.

7.1.2 OclCualquiera En el contexto del OCL, el tipo OclCualquiera es el supertipo de todos los tipos del modelo. Las características de OclCualquiera están disponibles para cada objeto en todas las expresiones OCL.

Todas las clases en un modelo UML heredan todas las características definidas para OclCualquiera. Para evitar conflictos de nombres entre características del modelo y características heredadas de OclCualquiera, todos los nombres de las características de OclCualquiera comienzan con ‘ocl’. De todas maneras, teóricamente aún podrían existir conflictos de nombres, pero pueden evitarse usando las construcciones con caminos para referirse explícitamente a las propiedades de OclCualquiera.

Características de OclCualquiera, una instancia de OclCualquiera es llamada objeto.

objeto = (objeto2 : OclCualquiera) : Booleano

Verdadero si objeto es el mismo objeto que objeto2.

objeto <> (objeto2 : OclCualquiera) : Booleano

Verdadero si objeto es un objeto diferente de objeto2. post: resultado = no (objeto = objeto2)

objeto.oclTipo : OclTipo

El tipo del objeto

objeto.oclEsCompatibleCon(tipo : OclTipo) : Booleano

Verdadero si tipo es un supertipo (transitivo) del tipo de objeto. post: resultado = tipo.todosLosSuperTipos->incluye(objeto.oclTipo) o

tipo = objeto->oclTipo

objeto.oclEsDelTipo(tipo : OclTipo) : Booleano

Verdadero si tipo es igual al tipo de objeto. post: resultado = (objeto.oclTipo = tipo)

objeto.oclComoTipo(tipo : OclTipo) : tipo

Da como resultado objeto, pero conociendo que su tipo es tipo. El resultado es Indefinido si el tipo real del objeto no es tipo o alguno de sus subtipos

pre : objeto.oclEsCompatibleCon(tipo) post: resultado = objeto


post: resultado.oclEsCompatibleCon(tipo)

7.1.3 OclExpresión Cada expresión OCL en sí es un objeto en el contexto del OCL, el tipo de la expresión es OclExpresión. Este tipo y sus características se usan para definir la semántica de aquellas características que toma una expresión como uno de sus parámetros: seleccionar, recolectar, paraTodos, etc.

Una OclExpresión opcionalmente incluye la variable iterador y tipo, y opcionalmente la variable acumulador y tipo.

Características de OclExpresión, una instancia de OclExpresión es llamada expresión.

expresión.tipoEvaluación : OclTipo

El tipo del objeto que resulta de evaluar la expresión.

7.1.4 Real En OCL el tipo Real representa el concepto matemático de Real. Tome en cuenta que Entero es subclase de Real, por lo tanto en cada parámetro de tipo Real, puede usar un Entero.

Características de Real, una instancia de Real es llamada r.

r = (r2 : Real) : Booleano

Verdadero si r es igual a r2.

r + (r1 : Real) : Real

El valor de sumar r y r1.

r - (r1 : Real) : Real

El valor de restar r1 a r.

r * (r1 : Real) : Real

El valor de multiplicar r y r1.

r / (r1 : Real) : Real

El valor de r divido r1.

r.abs : Real

El valor absoluto de r post: si r < 0 entonces resultado = - r sino resultado = r finSi

r.piso : Entero

El mayor entero que es menor o igual a r. post: (resultado <= r) y (resultado + 1 > r)

r.max(r2 : Real) : Real

El máximo entre r y r2.


post: si r >= r2 entonces resultado = r sino resultado = r2 finSi

r.min(r2 : Real) : Real

El mínimo entre r y r2. post: si r <= r2 entonces resultado = r sino resultado = r2 finSi

r < (r2 : Real) : Booleano

Verdadero si r es menor que r2.

r > (r2 : Real) : Booleano

Verdadero si r es mayor que r2. post: resultado = no (r <= r2)

r <= (r2 : Real) : Booleano

Verdadero si r es menor o igual a r2. post: resultado = (r = r2) o (r < r2)

r >= (r2 : Real) : Booleano

Verdadero si r1 es mayor o igual a r2. post: resultado = (r = r2) o (r > r2)

7.1.5 Entero El tipo Entero del OCL representa el concepto matemático de entero.

Características de Entero, una instancia de Entero es llamada i.

i = (i2 : Entero) : Booleano

Verdadero si i es igual a i2.

i + (i2 : Entero) : Entero

El valor de sumar i e i2.

i + (r1 : Real) : Real

El valor de sumar i y r1.

i - (i2 : Entero) : Entero

El valor de restar i2 de i.

i - (r1 : Real) : Real

El valor de restar r1 de i.

i * (i2 : Entero) : Entero

El valor de multiplicar i e i2.

i * (r1 : Real) : Real

El valor de multiplicar i y r1.

i / (i2 : Entero) : Real


El valor de i dividido i2.

i / (r1 : Real) : Real

El valor de i dividido r1.

i.abs : Entero

El valor absoluto de i post: si i < 0 entonces resultado = - i sino resultado = i finSi

i.div( i2 : Entero) : Entero

La cantidad de veces que i2 entra completamente dentro de i. post: resultado * i2 <= i post: resultado * (i2 + 1) > i

i.mod( i2 : Entero) : Entero

El resultado es i módulo i2. post: resultado = i - (i.div(i2) * i2)

i.max(i2 : Entero) : Entero

El máximo ente i e i2. post: si i >= i2 entonces resultado = i sino resultado = i2 finSi

i.min(i2 : Entero) : Entero

El mínimo entre i e i2. post: si i <= i2 entonces resultado = i sino resultado = i2 finSi

7.1.6 Literal (String) El tipo Literal de OCL representa a los literales ASCII.

Características de Literal, una instancia de Literal es llamada literal.

literal = (literal2 : Literal) : Booleano

Verdadero si literal y literal2 contienen los mismos caracteres, en el mismo orden.

literal.tamaño : Entero

El número de caracteres que contiene literal.

literal.concat(literal2 : Literal) : Literal

La concatenación de literal y literal2. post: resultado.tamaño = literal.tamaño + literal2.tamaño post: resultado.subliteral(1, literal.tamaño) = literal post: resultado.subliteral(literal.tamaño + 1, literal2.tamaño) =

literal2

literal.enMayúscula : Literal

El valor de literal con todas sus minúsculas convertidas a mayúsculas. post: resultado.tamaño = literal.tamaño

literal.enMinúscula : Literal

El valor de literal con todas sus mayúsculas convertidas a minúsculas.


post: resultado.tamaño = literal.tamaño

literal.subliteral(inferior : Entero, superior : Entero) : Literal

El subliteral de literal que comienza en la letra número inferior, hasta la letra número superior inclusive.

7.1.7 Booleano El tipo Booleano del OCL representa los valores verdadero/falso.

Características de Booleano, una instancia de Booleano es llamada b.

b = (b2 : Booleano) : Booleano

Verdadero si b es el mismo que b2.

b o (b2 : Booleano) : Booleano

Verdadero si o b o b2 son verdaderos.

b xo (b2 : Booleano) : Booleano

Verdadero si o b o b2 son verdaderos, pero no los dos. post: (b o b2) y no (b = b2)

b y (b2 : Booleano) : Booleano

Verdadero si ambos, b1 y b2, son verdaderos.

no b : Booleano

Verdadero si b es falso post: si b entonces resultado = falso sino resultado = verdadero finSi

b implica (b2 : Booleano) : Booleano

Verdadero si b es falso, o si b es verdadero y b2 es verdadero. post: (no b) o (b y b2)

si b entonces (expresión1 : OclExpresión)

sino (expresión2 : OclExpresión) finSi : expresión1.tipoEvaluado

Si b es verdadero el resultado es el valor de evaluar expresión1, sino el resultado es el valor de evaluar expresión2.

7.1.8 Enumeración El tipo Enumeración del OCL representa las enumeraciones definidas en un modelo UML.

Características de Enumeración, una instancia de Enumeración es llamada enumeración.

enumeración = (enumeración2 : Booleano) : Booleano

Igual si enumeración es la misma que enumeración2.

enumeración <> (enumeración2 : Booleano) : Booleano


Igual si enumeración no es la misma que enumeración2. post: resultado = no ( enumeración = enumeración2)

7.2 TIPOS DE COLECCIONES Las siguientes secciones definen las características de las colecciones. Estas características están disponibles en los Conjuntos, Bolsas y Secuencias. Cada colección, como se define en esta sección, es en realidad un marco (template) con un parámetro. ’T’ denota ese parámetro. Una colección real se crea sustituyendo un tipo por la T. Por lo tanto, Conjunto(Entero) y Bolsa(Persona) son tipos colección.

7.2.1 Colección En OCL, colección es le supertipo abstracto de todas las colecciones. Cada ocurrencia de un objeto en una colección es llamada elemento. Si un objeto ocurre dos veces en una colección, hay dos elementos. En esta sección las operaciones sobre colecciones están definidas de manera que tienen una semántica idéntica para cada subtipo. Algunas operaciones pueden estar definidas también en un subtipo, lo que resulta en post-condiciones adicionales y valores resultantes más especializados.

La definición de varias operaciones comunes es diferente para cada subtipo. Estas operaciones no están mencionadas en esta sección.

Características de Colección, una instancia de Colección es llamada colección.

colección->tamaño : Entero

El número de elementos en la colección colección post: resultado = colección->iterar(elem; acu : Entero = 0 | acu + 1)

colección->incluye(objeto : OclCualquiera) : Booleano

Verdadero si objeto es un elemento de colección, falso si no. post: resultado = (colección->contar(objeto) > 0)

colección->contar(objeto : OclCualquiera) : Entero

El número de veces que objeto ocurre en la colección post: resultado = colección->iterar( elem; acu : Entero = 0 |

si elem = objeto entonces acu + 1 sino acu finSi)

colección->incluyeTodos(c2 : Colección(T)) : Booleano

¿La colección contiene todos los elementos de c2 ? post: resultado = c2->paraTodos(elem | colección->incluye(elem))

colección->estáVacía : Booleano

¿La colección es la colección vacía ? post: resultado = ( colección->tamaño = 0 )

colección->noEstáVacía : Booleano

¿La colección, no es la colección vacía ? post: resultado = ( colección->tamaño <> 0 )


colección->sum : T

La suma de todos los elementos de colección. Los elementos deben ser de un tipo que soporte la suma (Entero y Real) post: resultado = colección->iterar( elem; acu : T = 0 |

acu + elem )

colección->existe(expr : OclExpresión) : Booleano

Es verdadero si expr evalúa en verdadero para al menos un elemento de la colección. post: resultado = colección->iterar(elem; acu : Booleano = falso |

acu o expr)

colección->paraTodos(expr : OclExpresión) : Booleano

Es verdadero si expr evalúa en verdadero para cada elemento de la colección. Si no es así el resultado es falso. post: resultado = colección->iterar(elem; acu : Booleano = Verdadero |

acu y expr)

colección->iterar(expr : OclExpresión) : expr.tipoEvaluación

Itera sobre la colección. Ver sección 6.5 para una descripción completa. Esta es la operación básica de las colecciones a partir de la que las demás pueden describirse.

7.2.2 Conjunto El Conjunto representa el conjunto matemático. Contiene elemento no duplicados.

Características de Conjunto, una instancia de Conjunto es llamada conjunto.

conjunto->unión(conjunto2 : Conjunto(T)) : Conjunto(T)

La unión de conjunto y conjunto2 post: T.todasLasInstancias->paraTodos(elem |

resultado->incluye(elem) = conjunto->incluye(elem) o conjunto2->incluye(elem))

conjunto->unión(bolsa : Bolsa(T)) : Bolsa(T)

La unión de conjunto y bolsa. post: T.todasLasInstancias->paraTodos(elem |

resultado->contar(elem) = conjunto->contar(elem) + bolsa->contar(elem))

conjunto = (conjunto2 : Conjunto) : Booleano

Verdadero si conjunto y conjunto2 contienen los mismos elementos. post: resultado = T.todasLasInstancias->paraTodos(elem |

conjunto->incluye(elem) = conjunto2->incluye(elem))

conjunto->intersección(conjunto2 : Conjunto(T)) : Conjunto(T)

La intersección de conjunto y conjunto2. O sea, el conjunto de todos los elementos comunes de conjunto y conjunto2. post: T.todasLasInstancias->paraTodos(elem |

resultado->incluye(elem) = conjunto->incluye(elem) y conjunto2->incluye(elem))

conjunto->intersección(bolsa : Bolsa(T)) : Conjunto(T)


La intersección de conjunto y bolsa post: resultado = conjunto->intersección( bolsa->comoConjunto )

conjunto – (conjunto2 : Conjunto(T)) : Conjunto(T)

Los elementos de conjunto, que no están en conjunto2 post: T.todasLasInstancias->paraTodos(elem |

resultado->incluye(elem) = conjunto->incluye(elem) y no conjunto2->incluye(elem))

conjunto->incluir(objeto : T) : Conjunto(T)

El conjunto que contienen todos los elementos de conjunto más objeto post: T.todasLasInstancias->paraTodos(elem |

resultado->incluye(elem) = conjunto->incluye(elem) o (elem = objeto))

conjunto->excluir(objeto : T) : Conjunto(T)

El conjunto que contiene todos los elementos de conjunto sin objeto post: T.todasLasInstancias->paraTodos(elem |

resultado->incluye(elem) = conjunto->incluye(elem) y no(elem = objeto))

conjunto->diferenciaSimétrica (conjunto2 : Conjunto(T)) : Conjunto(T)

El conjunto que contiene todos los elementos que están en conjunto o en conjunto2, pero no en ambos. post: T.todasLasInstancias->paraTodos(elem |

resultado->incluye(elem) = conjunto->incluye(elem) xo conjunto2->incluye(elem))

conjunto->seleccionar(expr : OclExpresión) : Conjunto(expr.tipo)

El subconjunto de conjunto para el que expr es verdadera. post: resultado = conjunto->iterar(elem; acu : Conjunto(T) =Conjunto{} |

si expr entonces acu->incluir(elem) sino acu finSi)

conjunto->descartar(expr : OclExpresión) : Conjunto(expr.tipo)

El subconjunto de conjunto para el que expr es falso post: resultado = conjunto->seleccionar(no expr)

conjunto->recolectar(expresión : OclExpresión) :Bolsa(expresión.oclTipo)

La Bolsa de elementos resultantes de aplicar expr a cada elemento de conjunto post: resultado = conjunto->iterar(elem; acu : Bolsa(T) = Bolsa{} |

acu->incluir(expr) )

conjunto->contar(objeto : T) : Entero

El número de ocurrencias de objeto en el conjunto post: resultado <= 1

conjunto->comoSecuencia : Secuencia(T)

La Secuencia que contiene todos los elementos del conjunto, en orden aleatorio. post: T.todasLasInstancias->paraTodos(elem |

resultado->contar(elem) = conjunto->contar(elem))

conjunto->comoBolsa : Bolsa(T)

La Bolsa que contiene todos los elementos de conjunto. post: T.todasLasInstancias->paraTodos(elem |


resultado->contar(elem) = conjunto->contar(elem))

7.2.3 Bolsa (Bag) Una bolsa es una colección en la que los duplicados están permitidos. Esto es, un objeto puede ser un elemento de una bolsa muchas veces. No hay un orden preestablecido para los elementos de una bolsa.

Características de Bolsa, una instancia de Bolsa es llamada bolsa.

bolsa = (bolsa2 : Bolsa) : Booleano

Verdadero si bolsa y bolsa2 contienen los mismos elementos, la misma cantidad de veces. post: resultado = T.todasLasInstancias->paraTodos(elem |

bolsa->contar(elem) = bolsa2->contar(elem))

bolsa->unión(bolsa2 : Bolsa) : Bolsa(T)

La unión de bolsa y bolsa2 post: T.todasLasInstancias->paraTodos(elem |

resultado->contar(elem) = bolsa->contar(elem) + bolsa2->contar(elem))

bolsa->unión(conjunto : Conjunto) : Bolsa(T)

La unión de bolsa y conjunto post: T.todasLasInstancias->paraTodos(elem |

resultado->contar(elem) = bolsa->contar(elem) + conjunto->contar(elem))

bolsa->intersección(bolsa2 : Bolsa) : Bolsa(T)

La intersección de bolsa y bolsa2 post: T.todasLasInstancias->paraTodos(elem |

resultado->contar(elem) = bolsa->contar(elem).min(bolsa2->contar(elem)) )

bolsa->intersección(conjunto : Conjunto) : Conjunto(T)

La intersección de bolsa y conjunto post: T.todasLasInstancias->paraTodos(elem |

resultado->contar(elem) = bolsa->contar(elem).min(conjunto->contar(elem)) )

bolsa->incluir(objeto : T) : Bolsa(T)

La bolsa que contiene todos los elementos de bolsa más objeto post: T.todasLasInstancias->paraTodos(elem |

si elem = objeto entonces resultado->contar(elem) = bolsa->contar(elem) + 1 sino resultado->contar(elem) = bolsa->contar(elem) finSi)

bolsa->excluir(objeto : T) : Bolsa(T)

La bolsa que contiene todos los elementos de bolsa salvo todas las ocurrencias de objeto post: T.todasLasInstancias->paraTodos(elem |

si elem = objeto entonces resultado->contar(elem) = 0 sino


resultado->contar(elem) = bolsa->contar(elem) finSi)

bolsa->seleccionar(expresión : OclExpresión) : Bolsa(T)

La sub-bolsa de bolsa para la que expresión es verdadera post: resultado = bolsa->iterar(elem; acu : Bolsa(T) = Bolsa{} |

si expr entonces acu->incluir(elem) sino acu finSi)

bolsa->descartar(expresión : OclExpresión) : Bolsa(T)

La sub-bolsa de bolsa para la que expresión es falso post: resultado = bolsa->seleccionar(no expr)

bolsa->recolectar(expresión: OclExpresión) : Bolsa(expresión.oclTipo)

La Bolsa de elementos resultantes de aplicar expresión a cada miembro de bolsa post: resultado = bolsa->iterar(elem; acu : Bolsa(T) = Bolsa{} |

acu->incluir(expr) )

bolsa->contar(objeto : T) : Entero

La cantidad de ocurrencias de objeto en bolsa

bolsa->comoSecuencia : Secuencia(T)

Una Secuencia que contiene todos los elementos de bolsa, en orden aleatorio. post: T.todasLasInstancias->paraTodos(elem |

bolsa->contar(elem) = resultado->contar(elem))

bolsa->comoConjunto : Conjunto(T)

El Conjunto que contiene todos los elementos de bolsa, sin duplicados. post: T.todasLasInstancias(elem |

bolsa->incluye(elem) = resultado->incluye(elem))

7.2.4 Secuencia Una secuencia es una colección donde los elementos están ordenados. Un elemento puede ser parte de una secuencia más de una vez.

Características de Secuencia(T), una instancia de Secuencia es llamada secuencia.

secuencia->contar(objeto : T) : Entero

El número de ocurrencias de objeto en la secuencia

secuencia = (secuencia2 : Secuencia(T)) : Booleano

Verdadero si secuencia contiene los mismos elementos de secuencia2 en el mismo orden. post: resultado = Secuencia{1..secuencia->tamaño}->paraTodos(índice :

Entero | secuencia->en(índice) = secuencia2->en(índice)) y secuencia->tamaño = secuencia2->tamaño

secuencia->unión (secuencia2 : Secuencia(T)) : Secuencia(T)

La secuencia que consiste en todos los elementos de secuencia, seguidos de todos los elementos de secuencia2


post: resultado->tamaño = secuencia->tamaño + secuencia2->tamaño post: Secuencia{1..secuencia->tamaño}->paraTodos(índice : Entero |

secuencia->en(índice) = resultado->en(índice)) post: Secuencia{1..secuencia2->tamaño}->paraTodos(índice : Entero |

secuencia2->en(índice) = resultado->en(índice + secuencia->tamaño)))

secuencia->agregar (objeto: T) : Secuencia(T)

La secuencia de elementos, que consiste en todos los elementos de secuencia, seguidos de objeto. post: resultado->tamaño = secuencia->tamaño + 1 post: resultado->en(resultado->tamaño) = objeto post: Secuencia{1..secuencia->tamaño}->paraTodos(índice : Entero |

resultado->en(índice) = secuencia ->en(índice))

secuencia->preagregar(objeto : T) : Secuencia(T)

La secuencia que consiste en todos los elementos de secuencia, precedidos por objeto post: resultado->tamaño = secuencia->tamaño + 1 post: resultado->en(1) = objeto post: Secuencia{1..secuencia->tamaño}->paraTodos(índice : Entero |

secuencia->en(índice) = resultado->en(índice + 1))

secuencia->subSequencia(inicial : Entero, final : Entero) : Secuencia(T)

La sub-secuencia de secuencia desde el elemento número inicial, hasta el elemento número final inclusive. post: si secuencia->tamaño < final entonces

resultado = Indefinido sino resultado->tamaño = final - inicial + 1 y Secuencia{inicial..final}->paraTodos( índice | resultado->en(índice - inicial + 1) = secuencia->en(inicial + índice - 1)) finSi

secuencia->en(i : Entero) : T

El i-ésimo elemento de secuencia. post: i <= 0 o secuencia->tamaño < i implica resultado = Indefinido

secuencia->primero : T

El primer elemento de secuencia post: resultado = secuencia->en(1)

secuencia->último : T

El último elemento de secuencia post: resultado = secuencia->en(secuencia->tamaño)

secuencia->incluir(objeto : T) : Secuencia(T)

La secuencia que contiene todos los elementos de secuencia más objeto agregado como último elemento post: resultado = secuencia.agregar(objeto)

secuencia->excluir(objeto : T) : Secuencia(T)

La secuencia que contiene todos los elementos de secuencia excepto todas las ocurrencias de objeto.


El orden no es alterado. post: resultado->incluye(objeto) = falso post: resultado->tamaño = secuencia->tamaño - secuencia->contar(objeto) post: resultado = secuencia->iterar(elem; acu : Secuencia(T) =

Secuencia{}| si elem = objeto entonces acu sino acu->agregar(elem) finSi )

secuencia->seleccionar(expresión : OclExpresión) : Secuencia(T)

La subsecuencia de secuencia para la que expresión es verdadera post: resultado = secuencia->iterar(elem; acu : Secuencia(T) =

Secuencia{} | si expr entonces acu->incluir(elem) sino acu finSi)

secuencia->descartar(expresión : OclExpresión) : Secuencia(T)

La subsecuencia de secuencia para la que expresión es falso post: resultado = secuencia->seleccionar(no expr)

secuencia->recolectar(expresión : OclExpresión) :

Secuencia(expresión.oclTipo)

La secuencia de elementos resultantes de aplicar expresión a cada miembro de secuencia

secuencia->iterar(expr : OclExpresión) : expr.TipoEvaluación

Itera sobre la secuencia. La iteración respeta el orden de la secuencia.

secuencia->comoBolsa() : Bolsa(T)

La Bolsa conteniendo todos los elementos de secuencia, incluyendo duplicados post: T.todasLasInstancias->paraTodos(elem |

resultado->contar(elem) = secuencia->contar(elem))

secuencia->comoConjunto() : Conjunto(T)

El Conjunto conteniendo todos los elementos de secuencia, sin duplicados post: T.todasLasInstancias->paraTodos(elem |

resultado->incluye(elem) = secuencia->incluye(elem))

8. GRAMATICA DEL OCL Esta sección describe la gramática de las expresiones OCL. Una versión LL(1) ejecutable de esta gramática está disponible en el sitio OCL mencionado al principio del documento.

La gramática descripta usa la sintaxis EBNF, donde "|" significa elección, "?" opcional y "*" cero o más veces. En descripción de nombre, nombreDeTipo y literal se usa la sintaxis del JavaCC. Ver http://www.suntest.com/JavaCC.

expresión := expresiónLógica expresiónCondicional := "si" expresión "entonces" expresión "sino" expresión "finSi" expresiónLógica := expresiónRelacional ( operadorLógico expresiónRelacional )* expresiónRelacional := expresiónAditiva ( operadorRelacional expresiónAditiva )? expresiónAditiva := expresiónMultiplicativa ( operadorAditivo expresiónMultiplicativa )*


expresiónMultiplicativa := expresiónUnitaria ( operadorMultiplicativo expresiónUnitaria )* expresiónUnitaria := ( operadorUnitario expresiónPostfijo ) | expresiónPostfijo expresiónSufijo := expresiónPrimaria ( ("." | "->") llamadoACaracterística )* expresiónPrimaria := colecciónDeLiterales | literal | camino expresiónTemporal? cualificador? parámetroDeLlamadoACaracterísticas? | "(" expresión ")" | expresiónCondicional parámetroDeLlamadoACaracterísticas := "(" ( declarador )? ( listaRealDeParámetros )? ")" literal := <LITERAL> | <número> | "#" <nombre> tipoEnumeración := "enum" "{" "#" <nombre> ( "," "#" <nombre> )* "}" especificadorSimpleDeTipo := caminoDeTipo | tipoEnumeración colecciónDeLiterales := claseDeColección "{" expresiónListaORango? "}" expresiónListaORango := expresión ( ( "," expresión )+ | ( ".." expresión ) )? llamadoACaracterística := camino expresiónTemporal? cualificadores? parámetroDeLlamadoACaracterísticas? cualificadores := "[" listaRealDeParámetros "]" declarador := <nombre> ( "," <nombre> )* ( ":" especificadorSimpleDeTipo )? "|" caminoDeTipo := <nombreDeTipo> ( "::" <nombreDeTipo> )* camino := ( <nombreDeTipo> | <nombre> ) ( "::" ( <nombreDeTipo> | <nombre> ) )* expresiónTemporal := "@" <nombre> listaRealDeParámetros := expresión ( "," expresión )* operadorLógico := "y" | "o" | "xo" | "implica" claseDeColección := "Conjunto" | "Bolsa" | "Secuencia" | "Colección" operadorRelacional := "=" | ">" | "<" | ">=" | "<=" | "<>" operadorAditivo := "+" | "-" operadorMultiplicativo := "*" | "/" operadorUnitario := "-" | "no" nombreDeTipo := "A"-"Z" ( "a"-"z" | "0"-"9" | "A"-"Z" | "_")* nombre := "a"-"z" ( "a"-"z" | "0"-"9" | "A"-"Z" | "_")* número := "0"-"9" ("0"-"9")* literal := "'" ( (~["'","\\","\n","\r"]) | ("\\" ( ["n","t","b","r","f","\\","'","\""] | ["0"-"7"] ( ["0"-"7"] )? | ["0"-"3"] ["0"-"7"] ["0"-"7"] ) ) )* "'"

Documents

versión 1.1 1 de Septiembre de 1997 DE MATERIAS Y LIBROS/LIBROS... · Especificación del Lenguaje de Restricciones para Objetos, v 1.1 1 1. NOTA PRELIMINAR Este documento introduce