8.2.1 类型一致性

完整而严谨的类型一致性规则在本规范的语义部分介绍。单为了让建模者能够使用这些规则，我们在此用OCL来规定它们。为此，在Classifier上定义了一个额外的操作conformsTo (c: Classifier): Boolean。如果self的分类符符合实参 c，那么该操作计算为真。如下的OCL语句定义了各自类型的类型一致性。

BagType

[1] 不同的包类型彼此符合当且仅当它们的元素类型彼此符合。

context BagType
inv: BagType.allInstances()->forAll(b |
        self.elementType.conformsTo(b.elementType) implies self.conformsTo(b))

Classifier

[1] 一致性是一个传递关系。

context Classifier
inv Transitivity: Classifier.allInstances()->forAll(x | Classifier.allInstances()->forAll(y |
                                (self.conformsTo(x) and x.conformsTo(y)) implies self.comformsTo(y)))

[2] 类符合它的超类和它所实现的接口。

context Class
inv: self.generalization.general->forAll(p | 
        (p.oclIsKindOf(Class) or p.oclIsKindOf(Interface)) implies
                        self.conformsTo(p.oclAsType(Classifier)))

[3] 接口符合其超类（接口）

context Interface
inv: self.generalization.general->forAll(p |
        p.oclIsKindOf(Interface) implies self.conformsTo(p.oclAsType(Interface)))

[4] 类型直接的符合操作是自省的，分类符总是符合自身。

context Classifier
inv: self.conformsTo(self)

[5] 类型直接的符合操作是非对称的。

context Classifier
inv: Classifier.allInstances()->forAll(t1, t2 |
        (t1.conformsTo(t2) and t2.conformsTo(t1)) implies t1=t2)

CollectionType

[1] 特定的集合类型符合Collection类型。

context CollectionType
inv: --如果元素类型符合的话，所有SetType、SequenceType、BagType的实例都符合CollectionType
    CollectionType.allInstances()->forAll(c | c.oclIsKindOf(CollectionType) and 
                    self.elementType.conformsTo(c.elementType) implies self.conformstTo(c))

[2] 集合不符合任意基本类型。

context CollectionType
inv: PrimitiveType.allInstances()->forAll(p | not self.conformsTo(p))

[3] 元素类型符合的集合不符合。

context CollectionType
inv: CollectionType.allInstances()->forAll(c |
        (not self.elementType.conformsTo(c.elementType)) implies (not self.conformsTo(c)))

InvalidType

[1] OclInvalid符合所有其它类型。

context InvalidType
inv: Classifier.allInstances()->forAll(c | self.conformsTo(c))

OrderedSetType

[1] 如果元素类型彼此符合，那么不懂的有序集合类型也彼此符合。

context OrderedSetType
inv: OrderedSetType.allInstances()->forAll(s |
        self.elementType.conformsTo(s.elementType) implies self.conformsTo(s))

PrimitiveType

[1] Integer 符合 Real

context PrimitiveType
inv: (self.name='Integer') implies PrimitiveType.allInstances()->forAll(p |
        (p.name='Real') implies (self.conformsTo(p)))

[2] UnlimitedNatural 符合 Integer

context PrimitiveType
inv: (self.name='UnlimitedNatural') implies PrimitiveTypes.allInstances()->forAll(p |
        (p.name='Integer') implies (self.conformsTo(p)))

注意，* 不是一个有效的整型因此将 * 类型转化为整型将产生 InvalidType。

SequenceType

[1] 如果元素类型彼此符合，那么不同的序列类型也彼此符合。

context SequenceType
inv: SequenceType.allInstances()->forAll(s |
        self.elementType.conformsTo(s.elementType) implies self.conformsTo(s))

SetType

[1] 如果元素类型彼此符合，那么不同的set类型也彼此符合。

context SetType
inv: SetType.allInstances()->forAll(s |
        self.elementType.conformsTo(s.elementType) implies self.conformsTo(s))

TupleType

[1] 如果组成元组的各部分名称和类型彼此符合，那么元组类型彼此符合。注意，UML中元组上有一个额外的allProperties操作。

context TupleType
inv: TupleType.allInstances()->forAll(t |
        (t.allProperties()->forAll(tp |
          --确保至少有一个同名的元组成员（元组成员名称的唯一性将确保在一个元组中不会出现两个同名的成员）
          self.allProperties()->exists(stp | stp.name = tp.name) and
          --确保具有相同名称的成员类型符合
          self.allProperties()->forAll(stp | (stp.name=tp.name) implies stp.type.conformsTo(tp.type))
         )
         implies
           self.conformsTo(t)
      )

VoidType

[1] OclVoid符合除OclInvalid之外的所有类型。

context VoidType
inv: Classifier.allInstances()->forAll (c | not c.oclIsTypeOf(OclInvalid) implies self.conformsTo (c))