Uses of Interface org.eclipse.ocl.Environment (OCL Javadoc)

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV NEXT

FRAMES NO FRAMES

Uses of Interface
org.eclipse.ocl.Environment

Packages that use Environment
org.eclipse.ocl	Definition of the extensible environment API for OCL parsing and evaluation.
org.eclipse.ocl.ecore	Implementation of an OCL binding for the `Ecore` metamodel.
org.eclipse.ocl.uml	Implementation of an OCL binding for the `UML` metamodel.
org.eclipse.ocl.util	Miscellaneous utilities in support of the OCL parser and environment implementations.

Uses of Environment in org.eclipse.ocl

Classes in org.eclipse.ocl that implement Environment
`class`	`AbstractEnvironment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E>` A partial implementation of the `Environment` interface providing some useful common behavior for providers of metamodel bindings.

Methods in org.eclipse.ocl that return Environment

Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> EnvironmentFactory.createAttributeContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent, P property)
Creates an environment suitable for parsing OCL expressions on the specified property, which is some attribute in the client's metamodel.

Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> AbstractEnvironmentFactory.createAttributeContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent, P property)

Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> EnvironmentFactory.createClassifierContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent, C context)
Creates an environment suitable for parsing OCL expressions in the specified context, which is some classifier in the client's model.

Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> AbstractEnvironmentFactory.createClassifierContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent, C context)

Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> EnvironmentFactory.createEnvironment()
Creates a root environment, in which package contexts and/or classifier contexts will be created as nested environments.

Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> EnvironmentFactory.createEnvironment(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent)
Creates a child environment of a specified parent, for definition of nested scopes.

Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> EnvironmentFactory.createInstanceContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent, Object context)
Creates an environment suitable for parsing OCL expressions on the specified context object, which is an instance of some classifier in the client's model.

Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> AbstractEnvironmentFactory.createInstanceContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent, Object context)

Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> EnvironmentFactory.createOperationContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent, O operation)
Creates an environment suitable for parsing OCL expressions on the specified operation, which is some operation in the client's metamodel.

Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> AbstractEnvironmentFactory.createOperationContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent, O operation)

Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> EnvironmentFactory.createPackageContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent, List<String> pathname)
Creates an environment suitable for parsing OCL expressions in the specified package context.

Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> AbstractEnvironmentFactory.createPackageContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent, List<String> pathname)

protected Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> AbstractEnvironmentFactory.createPackageContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent, PK context)
Creates an environment for the specified package context.

Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> OCL.getEnvironment()
Obtains the OCL parsing environment.

Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> EvaluationVisitorDecorator.getEnvironment()
Obtains my delegate's environment.

Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> EvaluationVisitor.getEnvironment()
Obtains the environment that provides the metamodel semantics for the expression to be evaluated.

protected Environment<PK,C,O,P,?,PM,?,?,?,?,?,?> AbstractTypeResolver.getEnvironment()
Obtains the environment that I persist.

Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> AbstractEvaluationVisitor.getEnvironment()





<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> 


Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E>

Environment.Registry.getEnvironmentFor(Object abstractSyntaxElement)
Obtains a suitable environment for introspection of the specified model element, type (such as a collection type), or other abstract syntax element (e.g., a variable).





<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> 


Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E>

Environment.Registry.getEnvironmentFor(OCLExpression<C> expression)
Obtains a suitable environment for introspection of the specified expression.

Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> Environment.getParent()
Obtains my parent environment, if I have one.

Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> EnvironmentFactory.loadEnvironment(Resource resource)
Loads an environment from the specified resource.

Methods in org.eclipse.ocl with parameters of type Environment

Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> AbstractEnvironmentFactory.createAttributeContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent, P property)

Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> AbstractEnvironmentFactory.createClassifierContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent, C context)

EvaluationVisitor<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> EnvironmentFactory.createEvaluationVisitor(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, EvaluationEnvironment<C,O,P,CLS,E> evalEnv, Map<? extends CLS,? extends Set<? extends E>> extentMap)
Creates a new evaluation visitor, for the evaluation of OCL expressions.

EvaluationVisitor<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> AbstractEnvironmentFactory.createEvaluationVisitor(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, EvaluationEnvironment<C,O,P,CLS,E> evalEnv, Map<? extends CLS,? extends Set<? extends E>> extentMap)

Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> AbstractEnvironmentFactory.createInstanceContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent, Object context)

Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> AbstractEnvironmentFactory.createOperationContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent, O operation)

Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> AbstractEnvironmentFactory.createPackageContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent, List<String> pathname)

void Environment.Registry.deregisterEnvironment(Environment<?,?,?,?,?,?,?,?,?,?,?,?> environment)
Removes the specified environment from the registry.

static



<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> 


OCL<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E>

OCL.newInstance(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
Creates a new OCL on the specified root environment.

void Environment.Registry.registerEnvironment(Environment<?,?,?,?,?,?,?,?,?,?,?,?> environment)
Adds the specified environment to the registry.

void Environment.setParent(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
Sets my parent environment.

Constructors in org.eclipse.ocl with parameters of type Environment
`AbstractEvaluationVisitor(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, EvaluationEnvironment<C,O,P,CLS,E> evalEnv, Map<? extends CLS,? extends Set<? extends E>> extentMap)` Initializes me.
`AbstractTypeResolver(Environment<PK,C,O,P,?,PM,?,?,?,?,?,?> env)` Initializes me with an environment.
`AbstractTypeResolver(Environment<PK,C,O,P,?,PM,?,?,?,?,?,?> env, Resource resource)` Initializes me with a resource in which I will persist the model-based types that I generate in my associated `Environment`.
`OCL(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` Initializes me with a root environment.
`OCL(EnvironmentFactory<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> envFactory, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> rootEnv)` Initializes me with my environment factory and root environment.

Uses of Environment in org.eclipse.ocl.ecore

Classes in org.eclipse.ocl.ecore that implement Environment
`class`	`EcoreEnvironment` Implementation of the `Environment` for parsing OCL expressions on Ecore models.

Methods in org.eclipse.ocl.ecore that return Environment
`Environment<EPackage,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint,EClass,EObject>`	`EcoreEnvironmentFactory.createEnvironment()`
`Environment<EPackage,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint,EClass,EObject>`	`EcoreEnvironmentFactory.createEnvironment(Environment<EPackage,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint,EClass,EObject> parent)`
`Environment<EPackage,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint,EClass,EObject>`	`EcoreEnvironmentFactory.loadEnvironment(Resource resource)`

Methods in org.eclipse.ocl.ecore with parameters of type Environment
`Environment<EPackage,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint,EClass,EObject>`	`EcoreEnvironmentFactory.createEnvironment(Environment<EPackage,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint,EClass,EObject> parent)`
`static OCL`	`OCL.newInstance(Environment<EPackage,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint,EClass,EObject> env)` Creates a new `OCL` using the specified initial Ecore environment.
`void`	`EcoreEnvironment.setParent(Environment<EPackage,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint,EClass,EObject> env)`

Constructors in org.eclipse.ocl.ecore with parameters of type Environment
`EcoreEnvironment(Environment<EPackage,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint,EClass,EObject> parent)` Initializes me with a parent environment, from which I inherit such things as a package registry and a resource.
`OCL(Environment<EPackage,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint,EClass,EObject> env)` Initializes me with an initial environment for the Ecore metamodel.

Uses of Environment in org.eclipse.ocl.uml

Classes in org.eclipse.ocl.uml that implement Environment
`class`	`UMLEnvironment` Implementation of the `Environment` for parsing OCL expressions on UML models.

Methods in org.eclipse.ocl.uml that return Environment
`Environment<Package,Classifier,Operation,Property,EnumerationLiteral,Parameter,State,CallOperationAction,SendSignalAction,Constraint,Class,EObject>`	`UMLEnvironmentFactory.createEnvironment(Environment<Package,Classifier,Operation,Property,EnumerationLiteral,Parameter,State,CallOperationAction,SendSignalAction,Constraint,Class,EObject> parent)`
`Environment<Package,Classifier,Operation,Property,EnumerationLiteral,Parameter,State,CallOperationAction,SendSignalAction,Constraint,Class,EObject>`	`UMLEnvironmentFactory.loadEnvironment(Resource resource)`

Methods in org.eclipse.ocl.uml with parameters of type Environment
`Environment<Package,Classifier,Operation,Property,EnumerationLiteral,Parameter,State,CallOperationAction,SendSignalAction,Constraint,Class,EObject>`	`UMLEnvironmentFactory.createEnvironment(Environment<Package,Classifier,Operation,Property,EnumerationLiteral,Parameter,State,CallOperationAction,SendSignalAction,Constraint,Class,EObject> parent)`
`static OCL`	`OCL.newInstance(Environment<Package,Classifier,Operation,Property,EnumerationLiteral,Parameter,State,CallOperationAction,SendSignalAction,Constraint,Class,EObject> env)` Creates a new `OCL` using the specified initial UML environment.
`void`	`UMLEnvironment.setParent(Environment<Package,Classifier,Operation,Property,EnumerationLiteral,Parameter,State,CallOperationAction,SendSignalAction,Constraint,Class,EObject> env)`

Constructors in org.eclipse.ocl.uml with parameters of type Environment
`OCL(Environment<Package,Classifier,Operation,Property,EnumerationLiteral,Parameter,State,CallOperationAction,SendSignalAction,Constraint,Class,EObject> env)` Initializes me with an initial environment for the UML metamodel.
`UMLEnvironment(Environment<Package,Classifier,Operation,Property,EnumerationLiteral,Parameter,State,CallOperationAction,SendSignalAction,Constraint,Class,EObject> parent)` Initializes me with a parent environment.

Uses of Environment in org.eclipse.ocl.util

Methods in org.eclipse.ocl.util with parameters of type Environment

static



<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> 


void

TypeUtil.checkMutuallyComparable(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                        C type1,
                        C type2,
                        int opcode)

Checks whether two types are mutually comparable in the determination of the applicability = and <> operations.

static



<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> 


C

TypeUtil.commonSuperType(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                C type1,
                C type2)

Get the common supertype of two types.

static



<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> 


List<O>

OCLStandardLibraryUtil.createAnyTypeOperations(Environment<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> env)
Utility method creating the operations of the OclAny type of the OCL Standard library.

static



<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> 


List<O>

OCLStandardLibraryUtil.createBagIterators(Environment<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> env)
Utility method creating the pre-defined iterators of the Bag(T) type of the OCL Standard library.

static



<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> 


List<O>

OCLStandardLibraryUtil.createBagOperations(Environment<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> env)
Utility method creating the operations of the Bag(T) type of the OCL Standard library.

static



<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> 


List<O>

OCLStandardLibraryUtil.createBooleanOperations(Environment<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> env)
Utility method creating the operations of the Boolean type of the OCL Standard library.

static



<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> 


List<O>

OCLStandardLibraryUtil.createCollectionIterators(Environment<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> env)
Utility method creating the pre-defined iterators of the Collection(T) type of the OCL Standard library.

static



<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> 


List<O>

OCLStandardLibraryUtil.createCollectionOperations(Environment<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> env)
Utility method creating the operations of the Collection(T) type of the OCL Standard library.

static



<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> 


List<O>

OCLStandardLibraryUtil.createIntegerOperations(Environment<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> env)
Utility method creating the operations of the Integer type of the OCL Standard library.

static



<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> 


List<O>

OCLStandardLibraryUtil.createMessageTypeOperations(Environment<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> env)
Utility method creating the operations of the OclMessage type of the OCL Standard library.

static



<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> 


List<O>

OCLStandardLibraryUtil.createOrderedSetIterators(Environment<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> env)
Utility method creating the pre-defined iterators of the OrderedSet(T) type of the OCL Standard library.

static



<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> 


List<O>

OCLStandardLibraryUtil.createOrderedSetOperations(Environment<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> env)
Utility method creating the operations of the OrderedSet(T) type of the OCL Standard library.

static



<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> 


List<O>

OCLStandardLibraryUtil.createRealOperations(Environment<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> env)
Utility method creating the operations of the Real type of the OCL Standard library.

static



<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> 


List<O>

OCLStandardLibraryUtil.createSequenceIterators(Environment<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> env)
Utility method creating the pre-defined iterators of the Sequence(T) type of the OCL Standard library.

static



<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> 


List<O>

OCLStandardLibraryUtil.createSequenceOperations(Environment<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> env)
Utility method creating the operations of the Sequence(T) type of the OCL Standard library.

static



<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> 


List<O>

OCLStandardLibraryUtil.createSetIterators(Environment<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> env)
Utility method creating the pre-defined iterators of the Set(T) type of the OCL Standard library.

static



<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> 


List<O>

OCLStandardLibraryUtil.createSetOperations(Environment<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> env)
Utility method creating the operations of the Set(T) type of the OCL Standard library.

static



<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> 


List<O>

OCLStandardLibraryUtil.createStringOperations(Environment<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> env)
Utility method creating the operations of the String type of the OCL Standard library.

static



<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> 


List<O>

OCLStandardLibraryUtil.createTypeTypeOperations(Environment<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> env)
Utility method creating the operations of the OclType type of the OCL Standard library.

static



<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> 


List<O>

OCLStandardLibraryUtil.createUnlimitedNaturalOperations(Environment<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> env)
Utility method creating the operations of the UnlimitedNatural type of the OCL Standard library.

static



<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> 


O

TypeUtil.findOperationMatching(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                      C owner,
                      String name,
                      List<? extends TypedElement<C>> args)

Finds an operation by signature in the specified classifier.

static



<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> 


C

TypeUtil.findSignalMatching(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                   C receiver,
                   List<C> signals,
                   String name,
                   List<? extends TypedElement<C>> args)

Find a matching signal in the specified list.

static



<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> 


List<P>

TypeUtil.getAttributes(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
              C owner)

Obtains all of the OCL attributes applicable to the specified owner type, including any that were defined in the OCL environment as additional attributes.

static



<C,O,P,EL,PM,S,COA,SSA,CT> 


ToStringVisitor<C,O,P,EL,PM,S,COA,SSA,CT>

ToStringVisitor.getInstance(Environment<?,C,O,P,EL,PM,S,COA,SSA,CT,?,?> env)
Obtains an instance of the toString() visitor for the specified environment.

static



<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> 


List<O>

TypeUtil.getOperations(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
              C owner)

Obtains all of the OCL operations applicable to the specified owner type, including any that were defined in the OCL environment as additional operations.

static



<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> 


C

TypeUtil.getPropertyType(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                C owner,
                P property)

Gets the type of a property, accounting for the fact that we may be navigating to it from an association class (in which the member ends of an association always have multiplicity 1) or not.

static



<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> 


int

TypeUtil.getRelationship(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                C type1,
                C type2)

Queries the relationship, according to generalizations, of two types.

static



<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> 


C

TypeUtil.getResultType(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
              C owner,
              O oper)

Obtains the result type of the specified operation, which in the case of collection operations sometimes depends on the element type of the source collection.

static



<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> 


C

OCLStandardLibraryUtil.getResultTypeOf(Environment<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> env,
                C sourceType,
                int opcode,
                List<? extends TypedElement<C>> args)

Obtains the result type of the specified operation from the OCL Standard Library.

static



<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> 


boolean

TypeUtil.isOclAnyOperation(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                  O operation)

Queries whether an operation is defined by the OclAny type.

static



<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> 


Set<Tuple<O,P>>

CollectionUtil.product(EvaluationEnvironment<C,O,P,CLS,E> evalEnv,
        Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
        Collection<?> self,
        Collection<?> c,
        C tupleType)

Implementation of the OCL Collection::product(c : Collection(T2)) : Set(Tuple(first : T, second : T2)) operations.

static



<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> 


C

TypeUtil.resolveBagType(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
               C elementType)

Resolves a Bag type against the baf types previously generated and persisted in the environment.

static



<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> 


C

TypeUtil.resolveCollectionType(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                      CollectionKind kind,
                      C elementType)

Resolves a collection type against the collection types previously generated and persisted in the environment.

static



<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> 


O

TypeUtil.resolveGenericSignature(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                        C owner,
                        O oper)

Resolves the signature of a generic operation (where it has parameters of type and/or T or T2) against the source type of the operation, as appropriate.

static



<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> 


C

TypeUtil.resolveOperationMessageType(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                            O operation)

Resolves an operation message type against the message types previously generated and persisted in the environment.

static



<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> 


C

TypeUtil.resolveOrderedSetType(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                      C elementType)

Resolves a OrderedSet type against the types previously generated and persisted in the environment.

static



<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> 


C

TypeUtil.resolveSequenceType(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                    C elementType)

Resolves a Sequence type against the sequence types previously generated and persisted in the environment.

static



<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> 


C

TypeUtil.resolveSetType(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
               C elementType)

Resolves a Set type against the set types previously generated and persisted in the environment.

static



<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> 


C

TypeUtil.resolveSignalMessageType(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                         C signal)

Resolves a signal message type against the message types previously generated and persisted in the environment.

static



<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> 


C

TypeUtil.resolveTupleType(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                 EList<? extends TypedElement<C>> parts)

Resolves a tuple type against the tuple types previously generated and persisted in the environment.

static



<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> 


C

TypeUtil.resolveType(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
            C type)

Resolves the specified type against the model-based types defined by the specified environment's type resolver, for consistency with the environment (especially for persistence).

static



<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> 


C

TypeUtil.resolveTypeType(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                C type)

Resolves a tupe-type against the tupe-types previously generated and persisted in the environment.

static



<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> 


boolean

TypeUtil.type1AsType2(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
             C type1,
             C type2)

Casts a value of one type as another type, if compatible.

static



<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> 


int

TypeUtil.typeCompare(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
            C type1,
            C type2)

Compare two types.

Constructors in org.eclipse.ocl.util with parameters of type Environment
`ToStringVisitor(Environment<?,C,O,P,EL,PM,S,COA,SSA,CT,?,?> env)` Initializes me with my environment.