11.7 操作和良构规则

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

11.7.1 Collection

= (c : Collection(T)) : Boolean

如果c和self是相同种类的集合，并且包含相同数量的元素，而且如果是有序集合类型的话，元素的次序还要一致，结果才是真。

<> (c : Collection(T)) : Boolean

如果c不等同self，则为真。

post: result = not (self = c)

size() : Integer

集合self中元素的个数。

post: result = self->iterate(elem; acc : Integer = 0 | acc + 1)

includes(object : T) : Boolean

如果object是self的一个元素，则为真，否则为假。

post: result = (self->count(object) > 0)

excludes(object : T) : Boolean

如果object不是self的一个元素，则为真，否则为假。

post: result = (self->count(object) ＝ 0)

count(object : T) : Integer

object在集合self中出现的次数。

post: result = self->iterate( elem; acc : Integer = 0 |
        if elem = object then acc + 1 else acc endif)

includesAll(c2 : Collection(T)) : Boolean

判断self是否包含c2的所有元素

post: result = c2->forAll(elem | self->includes(elem))

excludesAll(c2 : Collection(T)) : Boolean

判断self是否不包含c2的任意元素

post: result = c2->forAll(elem | self->excludes(elem))

isEmpty() : Boolean

self是否为空集合

post: result = ( self->size() = 0 )

注意，因为null可以隐式的转换为Bag{}，所以null->isEmpty()返回‘true’。

notEmpty() : Boolean

self是否不空

post: result = ( self->size() <> 0 )

因为null可以隐式的转换为Bag{}，所以null->isEmpty()返回‘false’。

max() : T

self中所有元素的最大值。元素类型必须支持max操作。元素所支持的max操作必须有一个类型为T的参数且满足结合律和交换律。UnlimitedNatural，Integer和Real都满足这些条件。

post: result = self->iterate( elem; acc : T = self->any(true) | acc.max(elem) )

min() : T

self中所有元素的最小值。元素类型必须支持min操作。元素所支持的min操作必须有一个类型为T的参数且满足结合律和交换律。UnlimitedNatural，Integer和Real都满足这些条件。

post: result = self->iterate( elem; acc : T = self->any(true) | acc.min(elem) )

sum() : T

self中所有元素相加。元素必须是可以支持+操作的类型。+操作有一个类型为T的参数，并且满足结合律和交换律。UnlimitedNatural，Integer和Real都满足这些条件。

post: result = self->iterate( elem; acc : T = 0 | acc + elem )

如果+操作不能既满足结合律有满足交换律，那么求和表达式不是良构的，这将导致在计算过程中结果的不确定性。如果一个实现可以检测到不支持结合律或交换律，那么该实现就可以掠过计算直接返回一个invalid结果。

product(c2: Collection(T2)) : Set( Tuple( first: T, second: T2) )

self和c2的笛卡尔乘积。

post: result = 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}) ) )

selectByKind(type : Classifier) : Collection(T)

返回self中所有类型是type或其子类的元素集合。返回集合的元素类型T是给定的type。

post: result = self ->collect(if oclIsKindOf(type) then oclAsType(type) else null endif) ->excluding(null)

selectByType(type : Classifier) : Collection(T)

返回self中所有类型是type而非其子类的元素集合。返回集合的元素类型T是给定的type。

post: result = self ->collect(if oclIsTypeOf(type) then oclAsType(type) else null endif) ->excluding(null)

asSet() : Set(T)

从self获得一个包含所有元素的Set，重复的去掉。

post: result->forAll(elem | self ->includes(elem))
post: self ->forAll(elem | result->includes(elem))

asOrderedSet() : OrderedSet(T)

从self获得一个包含所有元素的OrderedSet，重复的去掉。元素次序依赖于特定的具体集合类型。

post: result->forAll(elem | self->includes(elem))
post: self ->forAll(elem | result->includes(elem))

asSequence() : Sequence(T)

从self获得一个包含所有元素的Sequence，元素次序依赖于特定的具体集合类型。

post: result->forAll(elem | self->includes(elem))
post: self ->forAll(elem | result->includes(elem))

asBag() : Bag(T)

从self获得一个包含所有元素的Bag。

post: result->forAll(elem | self->includes(elem))
post: self ->forAll(elem | result->includes(elem))

flatten() : Collection(T2)

如果元素类型不是一个集合类型，那么结果是与self相同的集合。如果元素类型是一个集合类型，那么结果是self的所有元素递归展开后的集合。

良构规则：

[1] 集合不能包含invalid值。

context Collection
inv: self->forAll(not oclIsInvalid())