11.7.5 Sequence

count(object : T) : Integer

object在self中出现的次数。

= (s : Sequence(T)) : Boolean

如果self和s包含相同的元素且元素次序相同，则为真。

post: result = Sequence{1..self->size()}->forAll(index : Integer | self->at(index) = s->at(index))
                and
               self->size() = s->size()

union(s : Sequence(T)) : Sequence(T)

结果序列包含self的所有元素，后面跟s的所有元素。

post: result->size() = self->size() + s->size()
post: Sequence{1..self->size()}->forAll(index : Integer | self->at(index) = result->at(index))
post: Sequence{1..s->size()}->forAll(index : Integer | s->at(index) = result->at(index + self->size())))

flatten() : Sequence(T2)

重定义Collection的操作。如果元素类型不是一个集合类型，那么结果是一个与self相同的序列。如果元素类型是一个集合类型，结果是包含所有self的元素递归展开后的元素的序列。元素次序是偏序的。

post: result = if self.oclType().elementType.oclIsKindOf(CollectionType) then
                   self->iterate(c; acc : Sequence(T2) = Sequence{} | acc->union(c->flatten()->asSequence()))
               else
                   self
               endif

append (object: T) : Sequence(T)

包含self的所有元素、后面跟object的序列。

post: result->size() = self->size() + 1
post: result->at(result->size() ) = object
post: Sequence{1..self->size() }->forAll(index : Integer | result->at(index) = self ->at(index))

prepend(object : T) : Sequence(T)

以object开头，后面跟self的所有元素的序列。

post: result->size = self->size() + 1
post: result->at(1) = object
post: Sequence{1..self->size()}->forAll(index : Integer | self->at(index) = result->at(index + 1))

insertAt(index : Integer, object : T) : Sequence(T)

包含self的所有元素，并将object在指定的index位置插入后的序列。

post: result->size = self->size() + 1
post: result->at(index) = object
post: Sequence{1..(index - 1)}->forAll(i : Integer | self->at(i) = result->at(i))
post: Sequence{(index + 1)..self->size()}->forAll(i : Integer | self->at(i) = result->at(i + 1))

subSequence(lower : Integer, upper : Integer) : Sequence(T)

从self的lower起始，到upper结束的所有元素序列。

pre : 1 <= lower
pre : lower <= upper
pre : upper <= self->size()
post: result->size() = upper -lower + 1
post: Sequence{lower..upper}->forAll( index | result->at(index - lower + 1) = self->at(index))

at(i : Integer) : T

self的第i个元素。

pre : i >= 1 and i <= self->size()

indexOf(obj : T) : Integer

obj在self中索引。

pre : self->includes(obj)
post : self->at(i) = obj

first() : T

self的第一个元素。

post: result = self->at(1)

last() : T

self的最后一个元素。

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

including(object : T) : Sequence(T)

包含self的所有元素以及将object做为最后一个元素的序列。

post: result = self.append(object)

excluding(object : T) : Sequence(T)

包含去除所有object外self的所有元素的序列，其余元素的前后关系未变。

post:result->includes(object) = false
post: result->size() = self->size() - self->count(object)
post: result = self->iterate(elem; acc : Sequence(T) = Sequence{}|
                                if elem = object then acc else acc->append(elem) endif )

reverse() : Sequence(T)

self逆序排列后的序列。

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

sum() : T

重定义Collection的操作以去掉要求+操作满足结合律和/或交换律的需求，因为计算顺序已经由集合的元素次序和迭代操作所定义。

selectByKind(type : Classifier) : Sequence(T)

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

selectByType(type : Classifier) : Sequence(T)

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

asBag() : Bag(T)

重定义Collection的操作。从self获得一个包含所有元素的Bag，包括重复元素。

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

asSequence() : Sequence(T)

重定义Collection的操作。从self获得一个与自身相同的Sequence。该操作存在是出于方便的原因。

post: result = self

asSet() : Set(T)

重定义Collection的操作，从self获得一个包含self所有元素的Set，重复元素去除。

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

asOrderedSet() : OrderedSet(T)

重定义Collection的操作。从self获得一个与自身元素相同且次序也相同的OrderedSet，重复元素去除。

post: result->forAll(elem | self ->includes(elem))
post: self ->forAll(elem | result->includes(elem))
post: self ->forAll(elem | result->count(elem) = 1)
post: self ->forAll(elem1, elem2 | self->indexOf(elem1) < self->indexOf(elem2)
                implies result->indexOf(elem1) < result->indexOf(elem2) )