Ограничение (constraint) - это условие, накладываемое на значения одного или нескольких элементов модели. Ограничение не является инструкцией или командой, которую следует выполнить, оно формулируется как утверждение, которое должно быть истинным. Под элементом модели здесь имеется в виду объект, или класс, или пакет, или подсистема, или атрибут, или операция, или связь.
|
|
Диаграмма содержит большое количество связей (ассоциаций и обобщений) необходимых для указания, что тип самолета должен соответствовать типу рейса, т. е. что пассажиров нельзя перевозить грузовым самолетом. Это ограничение можно зафиксировать иначе, упростить диаграмму, сделать ее более наглядной:
Ограничение, записанное на естественном языке, неформально, его можно
неправильно трактовать (например, что чартерные рейсы должны выполняться старыми самолетами, а регулярные - новыми). Поэтому имеет смысл использовать для записи формальный язык, который не
допускает произвольных толкований и имеет стандартный синтаксис и семантику. Таковым является объектный язык ограничений OCL (Object Constraint Language), являющийся одним из расширений UML.
С использованием OCL ограничение может быть записано так:
contextРейс
inv: тип=Тип::грузовой implies Самолет.тип= Тип::грузовой
inv: тип=Тип::пассажирский impliesСамолет.тип= Тип::пассажирский
Слово implies означает логическую операцию импликации (a → b, читается так: из a следует b, это выражение ложно лишь при a - истина и b - ложь, в остальных случаях оно истинно). Вообще говоря, для записи ограничений можно использовать и другие формальные языки, например, языки программирования. Основное неудобство при этом - ограничение, записанное на языке программирования, похоже на часть программы, что придает ограничению посторонний смысл (может сложиться впечатление, что происходят какие-либо манипуляции над элементами модели, а это противоречит определению понятия ограничения).
Классификация ограничений:
В примере мы описали инварианты класса Рейс.
Характеристики OCL:
Никакое ограничение OCLне меняет состояния элементов модели (у него нет побочных эффектов). OCL может быть использован для формулирования запросов, возвращающих целое значение, вещественное, строку, объект, коолекцию и т. п.. При этом, вообще говоря, не определяется способ вычисления этого запроса.
Синтаксис OCL-выражения
<OCL-выражение> ::=
<указание контекста>
[(inv | pre | post | body | init | derive | def) : <тело выражения>]
В записи использованы символы языка БНФ: <> выделяют нетерминалы, ( | ) -вхождение одной из указанных альтернатив, [] вхождение 1 или более раз, {} - вхождение 0 или более раз. Терминалы записаны жирным шрифтом.
Контекст. В любом OCL-выражении указывается определенный контекст. Как правило, контекстом является элемент модели (пакет, класс, атрибут, операция), с которым связано ограничение.
<указание контекста> ::= context <имя элемента модели>
В примере контекстом является класс Рейс.
Для того чтобы сослаться на контекст в теле выражения используется слово self. Чтобы много раз не писать self, оно часто опускается. По смыслу self аналогично this в C++. В примере тип - сокращенная запись self.тип.
В теле выражения используются
Логический тип OCL почти таков как в языках программирования. Есть дополнительные операции xor и implies. Приоритет логических операций (кроме not) меньше арифметических и операций сравнения - так проще записывать сложные логические выражения. Целый и вещественный типы также стандартны. Имеются дополнительные операции a.max(b) и a.min(b), возвращающие максимум и минимум из двух чисел. Строки также похожи на строки языков программирования, только их нельзя сравнивать в лексикографическом порядке.
Примеры использования простых типов:
context Airline inv: name.toLowerCase() = 'klm' - здесь 'klm' - строка, toLowerCase() - стандартная операция над строкой, дающая как результат строку в нижнем регистре. Смысл ограничения: у любого экземпляра класса Airline значение атрибута name, записанное строчным буквами совпадает со строкой 'klm'.
context Passenger inv: age >= ((9.6 - 3.5)* 3.1).floor() implies mature = true - здесь floor() - «округление вниз». Смысл ограничения: у любого экземпляра класса Passenger значения атрибутов age и mature таковы, что если age > 18, то mature = true.
|
В OCL употребляются условные выражения:
<условное выражение> ::=
if <логическое выражение> then <выражение>
else <выражение>
endif
Пример: if (x >= 0) then x else - x endif возвращает модуль x или x.abs().
В телах OCL-выражений используются типы и имена (классов, атрибутов, операций) из модели. Далее в примерах мы будем рассматривать модель авиаперевозок:
|
Для указания атрибута или операции используется выражение с точкой:
<выражение>.<имя>
context Flight inv: self.maxNrPassengers <= 1000 - в любом рейсе максимальное количество пассажиров не превышает 1000 (использован атрибут объекта - экземпляра класса Flight).
context Flight:maxNrPassengers:Integer init: 1000 - в любом рейсе максимальное количество пассажиров по умолчанию = 1000.
context Passenger inv: self.age >= Passenger::minAge- у любого пассажира возраст больше минимального (использован атрибут age экземпляра класса Passenger и атрибут того же класса minAge).
Примеры с производными атрибутами:
context Flight def: arrivalTime:Time = departTime.plus(duration)
или
context Flight:arrivalTime derive: departTime.plus(duration)
По смыслу ограничения совпадают, но в первом определяется дополнительное OCL-выражение, которого не было в модели, но которое можно рассматривать как производный атрибут, во втором определяется правило вывода для атрибута в составе модели. В примерах использован класс Time.
Пример определения операции:
context Interval::equals(i:Interval):Boolean body:
(self.nrOfDays*60+self.nrOfHours)*60+self.nrOfMins =
(i.nrOfDays*60+i.nrOfHours)*60+i.nrOfMins
Заметим, что данное ограничение не описывает, вообще говоря, как именно проверяются интервалы на совпадение, допускается любой способ, который дает результат, совпадающий со значением из ограничения.
Поскольку ограничения часто накладываются не только на объекты классов, но и на связанные с ними объекты других классов, каждая ассоциация рассматривается как путь навигации. Контекст выражения является стартовой точкой. Имя роли определяет, по какой ассоциации осуществляется навигация (если их несколько), если ассоциация одна, то используется имя класса на другом конце ассоциации. Пример:
context Flight
inv: self.origin <> self.destination
inv: self.origin.name = 'Amsterdam' - у любого рейса аэропорт назначения и аэропорт вылета не совпадают, а также аэропорт вылета называется 'Amsterdam'.
Если есть класс ассоциаций, то используется его имя. Если ассоциация квалифицированная, то после имени роли в квадратных скобках указывают значения квалификаторов.
|
context Person inv:
if employer.name = 'OAO MMM' then
Job.type = #trainer
else
Job.type = #programmer
endif
Смысл ограничения: у любой персоны, занятой в 'OAO MMM', тип работы trainer, у остальных тип работы programmer. То же самое по смыслу ограничение можно записать, используя в качестве контекста класс ассоциаций:
context Job inv:
if employer.name = 'OAO MMM' then
self.type = #trainer
else
self.type = #programmer
endif
При навигации по связям, если на другом конце указана мощность связи *, от одного объекта мы приходим к нескольким связанным с ним (например, один аэропорт является аэропортом вылета для нескольких рейсов), поэтому в OCL введено понятие коллекции. Вообще говоря, коллекции могут состоять либо из объектов, либо из элементов простых типов, либо из элементов типов, определенных в модели, либо из коллекций. Виды коллекций:
В OCL имеется большое количество предопределенных операций над коллекциями (isEmpty, size, includes, union …). Синтаксис: <коллекция> -> <операция>
Операция collect() возвращает коллекцию значений, полученных при вычислениях выражения для всех элементов коллекции. Запись: <коллекция>->collect(<выражение>) - здесь и далее круглые скобки и | - символы OCL, а не языка БНФ. Сокращенная запись: <коллекция>.<выражение>
Пример: context Airport inv: self.arrivingFlights-> collect(airLine) -> notEmpty() - для любого аэропорта множество авиакомпаний, выполняющих прибывающие рейсы, не пусто. Приведена сокращенная запись. Полная (только правая часть):
->collect(e:Flight| e.AirLine)->notEmpty()
Операция select() возвращает совокупность тех элементов коллекции, для которых <выражение> истинно. Запись: <коллекция>->select(<выражение>)
Пример: context Airport inv: self.departingFlights->select(duration<4)->notEmpty() - для любого аэропорта есть хоть один отправляющийся рейс длительностью менее 4 часов. Приведена сокращенная запись. Полная (только правая часть):
->select(e:Flight| e.duration < 4)->notEmpty()
Операция forAll() возвращает true если <выражение> истинно для всех элементов коллекции, в остальных случаях возвращается false. Запись:
<коллекция>->forAll(<выражение>)
Пример: context Airport inv: self.departingFlights->forAll(maxNrPassengers< 1000) - для любого аэропорта справедливо, что у любого отправляющегося рейса максимальное количество пассажиров < 1000. Приведена сокращенная запись. Полная (только правая часть): ->forAll(e:Flight| e.maxNrPassengers< 1000)
Другой пример, когда внутри forAll производится проверка условия относительно всех пар объектов коллекции:
context AirLine inv:
AirLine.allInstances()->forAll( e1, e2 : AirLine | e1 <> e2 implies e1.name <> e2.name)
Ограничение указывает, что для любых двух разных авиакомпаний имена не совпадают. Операция allInstances() может применяться к любому классу (но не объекту! self.allInstances() - ошибка), чтобы получить коллекцию всех экземпляров класса.
Можно задать то же самое ограничение с помощью вложенного forAll:
context AirLine inv: AirLine.allInstances() ->forAll(e1:AirLine | AirLine.allInstances()
->forAll(e2: AirLine | e1 <> e2 implies e1.name <> e2.name))
Операция exists() возвращает true если хотя бы для одного элемента коллекции <выражение> истинно, в остальных случаях возвращается false. Запись:
<коллекция>->exists(<выражение>)
context Airport inv:
self.departingFlights->exists(departTime.hour<6)
Приведена сокращенная запись. Полная (только правая часть):
->exists(e:Flight| e. < departTime.hour<6)
Другие операции над коллекциями:
Операции для упорядоченных коллекций:
Коллекции можно сравнивать на = и <>. Преобразование коллекций к другому виду осуществляется при помощи операций asSet(), asBag(), asOrderedSet(), asSequence(). Преобразование типов осуществляется с помощью операции oclAsType(type). Коллекцию коллекций можно сделать «плоской» с помощью операции flatten(). Примеры ее работы:
Set { Set { 1, 2 }, Set { 2, 3 }, Set { 4, 5, 6 } } à flatten à Set { 1, 2, 3, 4, 5, 6 }
Bag { Set { 1, 2 }, Set { 1, 2 }, Set { 4, 5, 6 } } àflatten à Bag { 1, 1, 2, 2, 4, 5, 6 }
Sequence { Set { 1, 2 }, Set { 2, 3 }, Set { 4, 5, 6 } }àflatten àSequence { 2, 1, 2, 3, 5, 6, 4 }
Операция closure(), примененная к коллекции вычисляет замыкание.
Например:
context Person::posterity: Set( Person ) def:
self->AsSet()->closure( children )
Результат вычисления posterity - все потомки некоторой персоны, представленной объектом, для которого вычисляется выражение. Ниже определено замыкание над множеством родителей - множество всех предков персоны.
context Person:: forefathers: Set( Person ) def:
self->AsSet()->closure( parents )
Дополнительные возможности OCL:
С помощью result в постусловии можно указать, что операция возвращает в качестве результата:
context Airline::servedAirports() : Set(Airport)
pre : --none
post: result = flights.destination->asSet
@pre в постусловии дает возможность использовать значения атрибутов, какими они были в начале выполнения операции
context Passenger::Book(f:Flight)
pre : Flight.nrPassengers < Flight.maxNrPassengers
post: Flight.nrPassengers = Flight.nrPassengers@pre + 1
Конструкция let определяет локальную переменную. Запись:
let <name> : <type> = <expression1> in <expression2>
Пример: context Airport inv: let supportedAirlines : Set(Airline) = self.arrivingFlights ->collect(airLine) in (supportedAirlines ->notEmpty) and (supportedAirlines ->size < 500) - здесь для упрощения логического выражения определена локальная переменная supportedAirlines, представляющая собой коллекцию авиалиний, обслуживающих, прибывающие в аэропорт рейсы. Указано, что для любого аэропорта таких авиалиний должно быть больше нуля, но меньше 500.
Конструкция iterate позволяет описывать нестандартные операции над коллекциями. Запись: <коллекция>->
iterate(<переменная1> : <тип>; <переменная2> : <тип> [= <нач. значение>] | <тело>)
где <переменная1> - параметр итератора, <переменная2> - результат итератора, <тело> - OCL-выражение с <переменная1> и <переменная2>.
Например, ограничение:
context Airline inv: self.flights->select(maxNrPassengers > 150)->notEmpty
идентично:
context Airline inv: self.flights->iterate (f : Flight; answer : Set(Flight) = Set{ } |
if f.maxNrPassengers > 150 then answer->including(f) else answer endif )->notEmpty
Поясним второе OCL-выражение. Для авиалинии будет собрана коллекция всех ее рейсов и на этой коллекции будет запущен итератор. В начале работы результат итератора инициализируется пустым множеством. Затем для каждого рейса f из коллекции, одного за другим, будет вычислено условное выражение, которое добавит в результат лишь те рейсы, maxNrPassengers которых больше 150.
N-ки - это составные значения, содержащие несколько более простых значений. Например:
Tuple{name: String= 'John,' age: Integer= 10} - n-ка из двух значений: строки по имени name и целого по имени age. Для выделения одного значения в составе n-ки используется точка и имя значения:
Tuple {a: Collection(Integer) = Set{1, 3, 4}, b: String = 'foo,'}.a = Set{1, 3, 4}
Порядок записи значений в составе n-ки не играет ни какой роли, т. е. выполняется тождество:
Tuple {name = 'John,' age = 10} = Tuple {age = 10, name = 'John'}
Ниже определено выражение, собирающее коллекцию n-ок со статистическими сведениями о компаниях, в которых работает некая персона. Каждый элемент коллекции содержит экземпляр класса Company, количество занятых в компании работников и суммарный оклад работников в компании.
context Person def:
attr statistics : Set(Tuple(company: Company, numEmployees: Integer, totalSalary: Integer)) =
Companies->collect(c | Tuple { company: Company = c,
numEmployees: Integer = c.employee->size(),
totalSalary: Integer = c.Job.salary->sum()}
Обратите внимание на конструкцию Tuple(…), которая использована для конструирования типа n-ок в возвращаемой коллекции. Значения n-ок описываются конструкцией Tuple{…}.
Есть стандартная операция с коллекциями, возвращающая коллекцию n-ок - декартово произведение: product(coll). Ниже дано её явное определение с помощью итератора:
self->iterate (e1; acc: Set(Tuple(first: T, second: T2)) = Set{} |
c2->iterate (e2; acc2: Set(Tuple(first: T, second: T2))
= acc | acc2->including (Tuple{first = e1, second = e2}) ) )
Пример: Set {1, 2}produce(Set{'a', 'b', 'c'}) = Set{Tuple{first= 1, second='a'}, Tuple{first= 1, second='b'}, Tuple{first= 1, second='c'}, Tuple{first= 2, second='a'}, Tuple{first= 2, second='b'}, Tuple{first= 2, second='c'}}.
Операция
oclInState() возвращает истину, если объект
находится в определенном состоянии. Пример:
context Bottle inv:
self.oclInState(closed) implies filled = #full
Ограничение описывает, что все закрытые бутылки должны быть полны (состояние открытых не определяется).
При наследовании ограничений работает принцип подстановки Лисковой (Liskov's Substitution Principle): «Где может находиться экземпляр суперкласса, туда всегда может быть подставлен экземпляр его любого подкласса.» Это означает, что:
Если в ограничении требуется проверить, конкретный тип экземпляра, то используют стандартную операцию ocllsTypeOf(<тип>). Вспоминая пример, приведенный в начале лекции, мы можем описать следующие ограничения:
context ГрузовойСамолет inv:
Рейс->forAll(r | r.oclIsTypeOf(ГрузовойРейс))
context ПассажирскийСамолет inv:
Рейс->forAll(r | r.oclIsTypeOf(ПассажирскийРейс))
Если необходимо определить может ли объект рассматриваться как экземпляр какого-либо класса (например, объект подкласса - как экземпляр суперкласса), используется операция OclIsKindOf(Type). Так для объекта класса Пассажирский самолет истина будет получена если Type=Самолет или Type=Пассажирский самолет, в то время как выражение ocllsTypeOf(Type) истинно, только если Type - непосредственный тип объекта, т. е. Type=Пассажирский самолет. Для приведения типов используется операция OclAsType(<тип>).
Мы рассмотрели OCL применительно к моделям (диаграммам) классов. Он также может использоваться на других диаграммах. На диаграммах взаимодействия OCL применяют для записи сторожевых условий (которые встречаются в блоках). На диаграммах деятельности OCL применяют для описания деятельностей, узлов принятия решения, сторожевых условий на потоках. На диаграммах состояний OCL используется для описания состояний и сторожевых условий на переходах между состояниями.
Подведем итоги.