11.9 预定义迭代器表达式的映射规则

本节包含集合类型的操作和良构规则。

11.9.1 Collection

any

返回source集合中对于body计算为真的任一元素。如果对于任意元素body计算都为invalid的话，那么返回invalid，否则只要有1个或多个元素被body计算为真，那么就会返回其中的一个，否则结果是invalid。

source->any(iterator | body) = source->select(iterator | body)->asSequence()->first()

any最多可以有一个迭代器变量。

closure

source元素和所有通过应用body传递而得到的每个不同元素的闭包。

source->closure(iterator | body) = anonRecurse(source, Result{})

其中anonRecurse是一个调用特定的助手函数，由在如下的iterator, body, add, Result的词法替换而合成：

context OclAny
def: anonRecurse(anonSources : Collection(T), anonInit : Result(T)) : Result(T) =
    anonSources->iterate(iterator : T; anonAcc : Result(T) = anonInit |
        if anonAcc->includes(iterator)
        then anonAcc
        else let anonBody : OclAny = body in
            let anonResults : Result(T) = anonAcc->add(iterator) in
                if anonBody.oclIsKindOf(CollectionType)
                then anonRecurse(anonBody.oclAsType(Collection(T)), anonResults)
                else anonRecurse(anonBody.oclAsType(T)->asSet(), anonResults)
                endif
        endif)

其中，T是source集合的元素类型。如果source集合是有序，Result是‘OrderedSet’，否则是‘Set’。如果source集合是有序的，add是‘append’，否则是‘including’。

匿名变量‘annoRecurse’，‘anonAcc’，‘anonInit’，‘anonResult’和‘anonSources’被命名是为了解释说明；它们并不构成body计算的环境。

collect

应用body到source集合的每个元素所产生的元素Collection。结果是展开的。这基于collectNested，根据source的类型，这可以是不同的类型。collectNested对于CollectionType的每个子类都单独进行了定义。

source->collect (iterator | body) = source->collectNested (iterator | body)->flatten()

collect最多只能有一个迭代器变量。

collectNested

对source集合的每个元素应用body所产生的元素Bag。集合特定的细节在相应的集合类型部分中描述。

collectNested最多只能有一个迭代器变量。

exists

如果body在source集合的任一元素上计算为真，则结果为真，否则如果body在source集合的任一元素上计算为invalid，则结果为invalid，否则如果body在source集合的任一元素上计算为null，则结果为null，否则结果为假。

source->exists(iterators | body) =
                source->iterate(iterators; result : Boolean = false | result or body)

forAll

如果body在source集合的任一元素上计算为假，则结果为假，否则如果body在source集合的任一元素上计算为invalid，则结果为invalid，否则如果body在source集合的任一元素上计算为null，则结果为null，否则结果为真。

source->forAll(iterators | body ) =
        source->iterate(iterators; result : Boolean = true | result and body)

isUnique

如果body在source集合的任一元素上计算为invalid，则结果为invalid，否则如果body在source集合的每个元素都计算为一个不同的值（可能是null），则结果为真，否则结果为假。

source->isUnique (iterator | body) =
        source->collect (iterator | Tuple{iter = Tuple{iterator}, value = body})
                ->forAll (x, y | (x.iter <> y.iter) implies (x.value <> y.value))

isUnique最多只能有一个迭代器变量。

one

如果body在source集合的任一元素上计算为invalid，则结果为invalid，否则如果body在source集合中恰有一个元素计算为真，则结果为真，否则结果为假。

source->one(iterator | body) = source->select(iterator | body)->size() = 1

one最多只能有一个迭代器变量。

reject

source集合中对于body计算为假的元素组成的子集合。集合特定的细节在相应的集合类型部分描述。

reject最多只能有一个迭代器变量。

select

source集合中对于body计算为真的元素组成的子集合。集合特定的细节在相应的集合类型部分描述。

select最多只能有一个迭代器变量。

sortedBy

从对source集合的所有元素进行body计算所产生的值进行排序产生的集合。集合特定的细节在响应的集合类型部门描述。

sortedBy最多只能有一个迭代器变量。