## org.eclipse.ocl
Interface TypeResolver<C,O,P>

All Known Implementing Classes:
  AbstractTypeResolver, CompatibilityTypeResolver, TypeResolverImpl

    public interface TypeResolver<C,O,P>

Definition of a resolver for the dynamically-generated OCL types based on the types in the user model. It is expected that an implementation of this interface will cache types for the duration of the associated `Environment` and, if serialization of `OCLExpression`s is required, persist them in a `Resource`.

This interface is not intended to be implemented directly by clients; use or extend the `AbstractTypeResolver` class, instead.

See the `Environment` class for a description of the generic type parameters of this class.

Method Summary
`List<P>` `getAdditionalAttributes(C owner)` Obtains the additional attributes defined (via OCL) in the specified classifier context.
`List<O>` `getAdditionalOperations(C owner)` Obtains the additional operations defined (via OCL) in the specified classifier context.
`Resource` `getResource()` Obtains the resource in which the types that I generate are stored for persistence.
`C` `resolve(C type)` Resolves the specified `type`, returning my own persistent type instance representing the same OCL type.
`P` `resolveAdditionalAttribute(C owner, P property)` Resolves the specified "additional attribute" defined by the OCL client on the specified `owner` type.
`O` `resolveAdditionalOperation(C owner, O operation)` Resolves the specified "additional operation" defined by the OCL client on the specified `owner` type.
`CollectionType<C,O>` `resolveCollectionType(CollectionKind kind, C elementType)` Resolves the collection type of the specified `kind` and element type, either created anew or previously created.
`MessageType<C,O,P>` `resolveOperationMessageType(O operation)` Resolves the type for a message expression referencing the specified `operation`.
`MessageType<C,O,P>` `resolveSignalMessageType(C signal)` Resolves the type for a message expression referencing the specified `signal`.
`TupleType<O,P>` `resolveTupleType(EList<? extends TypedElement<C>> parts)` Resolves the tuple type consisting of the specified `parts`, in no particular order, either created anew or previously created.
`TypeType<C,O>` `resolveTypeType(C type)` Resolves the type for a type expression referencing the specified `type`.

Method Detail

### getResource

    Resource getResource()

  Obtains the resource in which the types that I generate are stored for persistence.

  Returns:
    my resource

### resolve

    C resolve(C type)

  Resolves the specified `type`, returning my own persistent type instance representing the same OCL type.

  The `type` may have been newly created by the parser and be a duplicate of a type previously resolved, or it may actually be a type that was previously resolved. In the latter case, the `type` is returned as is. The `null` type is considered to be resolved (i.e., the result is also `null`).

  Usually, this method will delegate to one of the `resolveXyzType()` methods defined by this interface.

  Parameters:
    `type` - a type to resolve
  Returns:
    the resolved type, or `type` if it is already resolved

### resolveCollectionType

    CollectionType<C,O> resolveCollectionType(CollectionKind kind,
                                              C elementType)

  Resolves the collection type of the specified `kind` and element type, either created anew or previously created.

  Parameters:
    `kind` - the kind of collection type to create
    `elementType` - the element type
  Returns:
    the new or existing collection type

### resolveTupleType

    TupleType<O,P> resolveTupleType(EList<? extends TypedElement<C>> parts)

  Resolves the tuple type consisting of the specified `parts`, in no particular order, either created anew or previously created. The resulting type is uniquely defined by the names and types of its parts, and twp tuple types are considered equal if they have the same number of parts and their parts correspond one-for-one in name and type (order is not significant).

  Parameters:
    `parts` - a list of `TypedElement`s defining the name and type of each tuple part. The part names are unique
  Returns:
    the new or existing tuple type

### resolveTypeType

    TypeType<C,O> resolveTypeType(C type)

  Resolves the type for a type expression referencing the specified `type`. This is, effectively, the OCL metatype counterpart for the specified model type.

  Parameters:
    `type` - a model type
  Returns:
    the new or existing type type

### resolveOperationMessageType

    MessageType<C,O,P> resolveOperationMessageType(O operation)

  Resolves the type for a message expression referencing the specified `operation`.

  Parameters:
    `operation` - the operation call that the message represents
  Returns:
    the new or existing message type

### resolveSignalMessageType

    MessageType<C,O,P> resolveSignalMessageType(C signal)

  Resolves the type for a message expression referencing the specified `signal`.

  Parameters:
    `signal` - the signal send that the message represents
  Returns:
    the new or existing message type

### resolveAdditionalOperation

    O resolveAdditionalOperation(C owner,
                                 O operation)

  Resolves the specified "additional operation" defined by the OCL client on the specified `owner` type.

  Parameters:
    `owner` - the type on which the additional operation is defined
    `operation` - the additional operation
  Returns:
    the persistent operation

### getAdditionalOperations

    List<O> getAdditionalOperations(C owner)

  Obtains the additional operations defined (via OCL) in the specified classifier context.

  Parameters:
    `owner` - the context classifier
  Returns:
    its additional operations, or an empty list if none

### resolveAdditionalAttribute

    P resolveAdditionalAttribute(C owner,
                                 P property)

  Resolves the specified "additional attribute" defined by the OCL client on the specified `owner` type.

  Parameters:
    `owner` - the type on which the additional attribute is defined
    `property` - the additional attribute
  Returns:
    the persistent attribute

### getAdditionalAttributes

    List<P> getAdditionalAttributes(C owner)

  Obtains the additional attributes defined (via OCL) in the specified classifier context.

  Parameters:
    `owner` - the context classifier
  Returns:
    its additional attributes, or an empty list if none

Copyright 2002, 2007 IBM Corporation and others. All Rights Reserved.