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.helper	Definition of the OCL Helper API for syntax completion support and a simplified parsing model for embedded OCL constraints and expressions.
org.eclipse.ocl.options
org.eclipse.ocl.parser
org.eclipse.ocl.parser.backtracking
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

Subinterfaces of Environment in org.eclipse.ocl
`static interface`	`Environment.Internal<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E>` An interface that merges the `Environment` and `BasicEnviroment` interfaces that define the behaviour realised in abstract form by `AbstractEnviroment`.

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.

protected Environment<?,C,O,P,?,PM,?,?,?,?,?,?> AbstractTypeChecker.getEnvironment()
Obtains my OCL parsing environment.

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.

Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> EnvironmentFactory.Lookup.tryCreatePackageContext(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.

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.
`AbstractTypeChecker(Environment<?,C,O,P,?,PM,?,?,?,?,?,?> env)` Initializes me with my environment.
`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`.
`EvaluationVisitorImpl(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)` Constructor
`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.helper

Methods in org.eclipse.ocl.helper that return Environment
`Environment<?,C,O,P,?,?,?,?,?,CT,?,?>`	`OCLHelper.getEnvironment()` Obtains the environment defining my current classifier, operation, or attribute context.

Uses of Environment in org.eclipse.ocl.options

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

static



<T> T

ParsingOptions.getValue(Environment<?,?,?,?,?,?,?,?,?,?,?,?> env,
         Option<T> option)

Obtains the value of the specified option's setting in the the given environment's options map, adapting the environment as necessary to the Customizable API.

static



<C> Option<C>

ParsingOptions.implicitRootClass(Environment<?,C,?,?,?,?,?,?,?,?,?,?> env)
A parsing option specifying a class that's assumed to be the implicit root of the subject model's class hierarchy.

static



<T> void

ParsingOptions.setOption(Environment<?,?,?,?,?,?,?,?,?,?,?,?> env,
          Option<T> option,
          T value)

Add an option to apply to the specified environment, adapting it as necessary to the Customizable API.

Uses of Environment in org.eclipse.ocl.parser

Methods in org.eclipse.ocl.parser that return Environment
`protected Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E>`	`AbstractOCLAnalyzer.classifierContextDeclCS(ClassifierContextDeclCS classifierContextDeclCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, List<CT> constraints)` ClassifierContextDeclCS
`protected Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E>`	`AbstractOCLAnalyzer.createClassifierContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, ClassifierContextDeclCS classifierContextDeclCS, C classifier)`
`protected Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E>`	`AbstractOCLAnalyzer.createOperationContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, OperationContextDeclCS operationContextCS, O operation)`
`protected Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E>`	`AbstractOCLAnalyzer.createPackageContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent, List<String> packageName)`
`protected Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E>`	`AbstractOCLAnalyzer.createPropertyContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, PropertyContextCS propertyContextCS, P property)`
`Environment<?,?,?,?,?,?,?,?,?,?,?,?>`	`OCLParser.getOCLEnvironment()`
`Environment<?,?,?,?,?,?,?,?,?,?,?,?>`	`OCLLexer.getOCLEnvironment()`
`Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E>`	`AbstractOCLAnalyzer.getOCLEnvironment()`
`protected Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E>`	`AbstractOCLAnalyzer.operationCS(OperationCS operationCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` OperationCS

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

protected BooleanLiteralExp<C> AbstractOCLAnalyzer.booleanLiteralExpCS(BooleanLiteralExpCS booleanLiteralExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
BooleanLiteralExpCS

protected void AbstractOCLAnalyzer.checkNotReflexive(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, String rule, AssociationClassCallExp<C,P> acc)
Asserts that the specified association class is not a reflexive association.

protected Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> AbstractOCLAnalyzer.classifierContextDeclCS(ClassifierContextDeclCS classifierContextDeclCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, List<CT> constraints)
ClassifierContextDeclCS

protected CollectionLiteralExp<C> AbstractOCLAnalyzer.collectionLiteralExpCS(CollectionLiteralExpCS collectionLiteralExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
CollectionLiteralExpCS

protected CollectionLiteralPart<C> AbstractOCLAnalyzer.collectionLiteralPartCS(CollectionLiteralPartCS collectionLiteralPartCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
CollectionLiteralPartCS

protected C AbstractOCLAnalyzer.collectionTypeCS(CollectionTypeCS collectionTypeCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
CollectionTypeCS

protected void AbstractOCLAnalyzer.contextDeclCS(ContextDeclCS contextDeclCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, List<CT> constraints)
ContextDeclCS

protected Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> AbstractOCLAnalyzer.createClassifierContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, ClassifierContextDeclCS classifierContextDeclCS, C classifier)

protected InvalidLiteralExp<C> AbstractOCLAnalyzer.createDummyInvalidLiteralExp(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, CSTNode cstNode)
Creates a dummy expression of invalid-literal type to be a placeholder for a (sub)expression that could not be parsed.

protected C AbstractOCLAnalyzer.createDummyInvalidType(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, CSTNode cstNode, String message)
Return the type used to terminate the AST reference from cstNode that failed to be resolved due to message.

protected Object AbstractOCLAnalyzer.createDummyPackage(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, PackageDeclarationCS packageDeclarationCS)
Return the package used to terminate the AST reference from an implicit PackageDeclarationCS.

protected IteratorExp<C,PM> AbstractOCLAnalyzer.createImplicitCollect(OCLExpression<C> source, FeatureCallExp<C> propertyCall, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, CSTNode cstNode)
Creates an implicit collect iterator expression for a property call on a collection-type source expression.

protected OCLFactory OCLAnalyzer.createOCLFactory(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

protected OCLFactory AbstractOCLAnalyzer.createOCLFactory(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
Creates/obtains the OCLFactory that I use to create OCL AST elements.

protected Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> AbstractOCLAnalyzer.createOperationContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, OperationContextDeclCS operationContextCS, O operation)

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

protected Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> AbstractOCLAnalyzer.createPropertyContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, PropertyContextCS propertyContextCS, P property)

protected VariableExp<C,PM> AbstractOCLAnalyzer.createVariableExp(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, CSTNode cst, Variable<C,PM> var)
Creates a variable expression with the variable that it references.

protected CT AbstractOCLAnalyzer.defCS(DefCS defCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
DefCS

protected OCLExpression<C> AbstractOCLAnalyzer.enumLiteralExpCS(EnumLiteralExpCS enumLiteralExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
EnumLiteralExpCS

protected OperationCallExp<C,O> AbstractOCLAnalyzer.genOperationCallExp(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, OperationCallExpCS operationCallExpCS, String rule, String operName, OCLExpression<C> source, C ownerType, List<OCLExpression<C>> args)
Generate an OperationCallExp node. operName is the input name of the operation, which must be matched against the datatype of the operation source.

protected Variable<C,PM> AbstractOCLAnalyzer.genVariableDeclaration(CSTNode cstNode, String rule, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, String name, C type, OCLExpression<C> initExp, boolean explicitFlag, boolean addToEnvironment, boolean isSelf)
Generate a VariableDeclaration AST node, and add it to the environment.

protected C AbstractOCLAnalyzer.getBagType(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C elementType)

protected OCLExpression<C> AbstractOCLAnalyzer.getCollectionSourceExpression(OCLExpressionCS oclExpressionCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
OCLExpressionCS

protected C AbstractOCLAnalyzer.getCollectionType(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, CollectionKind kind, C elementType)
Obtains the current environment's representation of the collection type of the specified kind on the given element type.

protected C AbstractOCLAnalyzer.getCollectionType(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, CollectionKind kind, C elementType)
Deprecated. Since 1.3, use the AbstractOCLAnalyzer.getCollectionType(CSTNode, Environment, CollectionKind, Object) method, instead.

protected C AbstractOCLAnalyzer.getCommonSuperType(CSTNode cstNode, String rule, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C type1, C type2)

static



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


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

ValidationVisitor.getInstance(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> environment)
Obtains an instance of the validation visitor that validates against the specified environment, which presumably was used in parsing the OCL in the first place.

protected C AbstractOCLAnalyzer.getOCLType(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, Object metaElement)

protected C AbstractOCLAnalyzer.getOperationMessageType(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, O operation)

protected C AbstractOCLAnalyzer.getOrderedSetType(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C elementType)

protected C AbstractOCLAnalyzer.getPropertyType(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C owner, P property)
Obtains the type, in the current environment, of the specified property.

protected C AbstractOCLAnalyzer.getSequenceType(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C elementType)

protected C AbstractOCLAnalyzer.getSetType(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C elementType)

protected C AbstractOCLAnalyzer.getSignalMessageType(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C signal)

protected C AbstractOCLAnalyzer.getTupleType(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, EList<? extends TypedElement<C>> parts)

protected C AbstractOCLAnalyzer.getTypeType(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C type)

protected IfExp<C> AbstractOCLAnalyzer.ifExpCS(IfExpCS ifExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
IfExpCS

protected void AbstractOCLAnalyzer.initASTMapping(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, Object astNode, CSTNode cstNode)
Initialize the symmetric mapping of an object (typically an astNode) to its originating cstNode, so that AST-based analysis may report error messages exploiting the CST context, or to support incremental AST/CST update.

protected void AbstractOCLAnalyzer.initASTMapping(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, Object fromAstNode, CSTNode cstNode, Object toAstNode)
Initialize the asymmetric mapping of an object (typically an astNode) to its originating cstNode, and of a cstNode to its consequent object (typically an astNode) so that AST-based analysis may report error messages exploiting the CST context, or to support incremental AST/CST update.

protected CT AbstractOCLAnalyzer.initOrDerValueCS(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, InitOrDerValueCS initOrDerValueCS)
InitOrDerValueCS

protected IntegerLiteralExp<C> AbstractOCLAnalyzer.integerLiteralExpCS(IntegerLiteralExpCS integerLiteralExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
IntegerLiteralExpCS

protected InvalidLiteralExp<C> AbstractOCLAnalyzer.invalidLiteralExpCS(InvalidLiteralExpCS invalidLiteralExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
InvalidLiteralExpCS

protected CT AbstractOCLAnalyzer.invCS(InvCS invCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
InvCS

protected CT AbstractOCLAnalyzer.invOrDefCS(InvOrDefCS invOrDefCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
InvOrDefCS

protected IterateExp<C,PM> AbstractOCLAnalyzer.iterateExpCS(IterateExpCS iterateExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
IterateExpCS

protected IteratorExp<C,PM> AbstractOCLAnalyzer.iteratorExpCS(IteratorExpCS iteratorExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
IteratorExpCS

protected OCLExpression<C> AbstractOCLAnalyzer.letExp(LetExpCS letExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
LetExpCS

protected LetExp<C,PM> AbstractOCLAnalyzer.letExpCS(LetExpCS letExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
Deprecated. Since 1.3, use AbstractOCLAnalyzer.letExp(LetExpCS, Environment), instead.

protected OCLExpression<C> AbstractOCLAnalyzer.letExpCSRecursive(LetExpCS letExpCS, int index, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
Constructs the LetExp

protected OCLExpression<C> AbstractOCLAnalyzer.literalExpCS(LiteralExpCS literalExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
LiteralExpCS

protected C AbstractOCLAnalyzer.lookupAssociationClassReference(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C owner, String name)

protected C AbstractOCLAnalyzer.lookupClassifier(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, List<String> className)

protected Variable<C,PM> AbstractOCLAnalyzer.lookupImplicitSourceForOperation(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, List<OCLExpression<C>> args, String operationName)

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

protected P AbstractOCLAnalyzer.lookupProperty(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C owner, String name)

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

protected S AbstractOCLAnalyzer.lookupState(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C sourceType, List<String> statePath)

protected LoopExp<C,PM> AbstractOCLAnalyzer.loopExpCS(LoopExpCS loopExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
LoopExpCS

protected OCLExpression<C> AbstractOCLAnalyzer.messageExpCS(MessageExpCS messageExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
MessageExpCS

protected OCLExpression<C> AbstractOCLAnalyzer.modelPropertyCallExpCS(FeatureCallExpCS modelPropertyCallExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
ModelPropertyCallExpCS

protected NullLiteralExp<C> AbstractOCLAnalyzer.nullLiteralExpCS(NullLiteralExpCS nullLiteralExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
NullLiteralExpCS

protected OCLExpression<C> AbstractOCLAnalyzer.oclExpressionCS(OCLExpressionCS oclExpressionCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
OCLExpressionCS

protected OCLExpression<C> AbstractOCLAnalyzer.operationCallExpCS(OperationCallExpCS operationCallExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
OperationCallExpCS

protected void AbstractOCLAnalyzer.operationContextDeclCS(OperationContextDeclCS operationContextDeclCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, List<CT> constraints)
OperationContextDeclCS

protected Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> AbstractOCLAnalyzer.operationCS(OperationCS operationCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
OperationCS

protected String AbstractOCLAnalyzer.operationString(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, String operName, List<? extends TypedElement<C>> args)
Constructs the string representation of an operation call.

protected void AbstractOCLAnalyzer.packageDeclarationCS(PackageDeclarationCS packageDeclarationCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, List<CT> constraints)
Analyzes a package declaration in the context of the environment created for an OCLDocumentCS.

protected List<Variable<C,PM>> AbstractOCLAnalyzer.parametersCS(List<VariableCS> parameters, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
ParametersCS

protected CT AbstractOCLAnalyzer.prePostOrBodyDeclCS(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, PrePostOrBodyDeclCS prePostOrBodyDeclCS)
PrePostOrBodyDeclCS

protected LiteralExp<C> AbstractOCLAnalyzer.primitiveLiteralExpCS(PrimitiveLiteralExpCS primitiveLiteralExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
PrimitiveLiteralExpCS

protected C AbstractOCLAnalyzer.primitiveTypeCS(SimpleTypeEnum simpleType, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
PrimitiveTypeCS

protected OCLExpression<C> AbstractOCLAnalyzer.propertyCallExpCS(CallExpCS propertyCallExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
PropertyCallExpCS

protected P AbstractOCLAnalyzer.propertyContextCS(PropertyContextCS propertyContextCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, List<CT> constraints)
PropertyContextCS

protected List<OCLExpression<C>> AbstractOCLAnalyzer.qualifiersCS(List<OCLExpressionCS> arguments, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, OCLExpression<C> navigation)
QualifiersCS

protected RealLiteralExp<C> AbstractOCLAnalyzer.realLiteralExpCS(RealLiteralExpCS realLiteralExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
RealLiteralExpCS

protected void AbstractOCLAnalyzer.resolveIteratorOperation(SimpleNameCS simpleNameCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
Ovverridden by subclasses to assign the AST Operation target for an iterator reference from the CST.

protected void AbstractOCLAnalyzer.setQualifiers(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, String rule, NavigationCallExp<C,P> nc, List<OCLExpression<C>> qualifiers)
Sets the specified navigation call's qualifiers, if they are compatible with the navigated association end or association class.

protected AssociationClassCallExp<C,P> AbstractOCLAnalyzer.simpleAssociationClassName(SimpleNameCS simpleNameCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, OCLExpression<C> source, C owner, String simpleName)
Attempts to parse a simpleNameCS as an association-class call expression.

protected OCLExpression<C> AbstractOCLAnalyzer.simpleNameCS(SimpleNameCS simpleNameCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, OCLExpression<C> source)
Parses a simpleNameCS token.

protected PropertyCallExp<C,P> AbstractOCLAnalyzer.simplePropertyName(SimpleNameCS simpleNameCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, OCLExpression<C> source, C owner, String simpleName)
Attempts to parse a simpleNameCS as a property call expression.

protected TypeExp<C> AbstractOCLAnalyzer.simpleTypeName(SimpleNameCS simpleNameCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, OCLExpression<C> source, C classifier, String simpleName)
Attempts to parse a simpleNameCS as a type expression.

protected OCLExpression<C> AbstractOCLAnalyzer.simpleUndefinedName(SimpleNameCS simpleNameCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, OCLExpression<C> source, String simpleName)
The error case for simpleNameCS, which is called when the name cannot be resolved to any suitable expression.

protected VariableExp<C,PM> AbstractOCLAnalyzer.simpleVariableName(SimpleNameCS simpleNameCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, OCLExpression<C> source, String simpleName)
Attempts to parse a simpleNameCS as a variable expression.

protected StateExp<C,S> AbstractOCLAnalyzer.stateExpCS(OCLExpression<C> source, StateExpCS stateExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
stateExpCS

protected StringLiteralExp<C> AbstractOCLAnalyzer.stringLiteralExpCS(StringLiteralExpCS stringLiteralExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
StringLiteralExpCS

protected TupleLiteralExp<C,P> AbstractOCLAnalyzer.tupleLiteralExpCS(TupleLiteralExpCS tupleLiteralExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
TupleLiteralExpCS

protected TupleLiteralPart<C,P> AbstractOCLAnalyzer.tupleLiteralPartCS(VariableCS variableDeclarationCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
tupleLiteralPartCS

protected EList<TupleLiteralPart<C,P>> AbstractOCLAnalyzer.tupleLiteralPartListCS(List<VariableCS> variableDeclarations, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
tupleLiteralPartListCS

protected C AbstractOCLAnalyzer.tupleTypeCS(TupleTypeCS tupleTypeCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
TupleTypeCS

protected TypeExp<C> AbstractOCLAnalyzer.typeCS(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C type)

protected C AbstractOCLAnalyzer.typeCS(TypeCS typeCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
TypeCS

protected UnlimitedNaturalLiteralExp<C> AbstractOCLAnalyzer.unlimitedNaturalLiteralExpCS(UnlimitedNaturalLiteralExpCS unlimitedNaturalLiteralExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
UnlimitedNaturalLiteralExpCS

protected Variable<C,PM> AbstractOCLAnalyzer.variableDeclarationCS(VariableCS variableDeclarationCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, boolean addToEnvironment)
VariableDeclarationCS

protected List<Variable<C,PM>> AbstractOCLAnalyzer.variableDeclarationListCS(List<VariableCS> variableDeclarationCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, boolean addToEnvironment)
VariableDeclarationListCS

protected OCLExpression<C> AbstractOCLAnalyzer.variableExpCS(VariableExpCS variableExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
VariableExpCS

Constructors in org.eclipse.ocl.parser with parameters of type Environment
`OCLAnalyzer(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> environment)` Construct an OCL semantic analyzer with default syntactic and lexical parsers all operating within a given environment.
`OCLAnalyzer(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> environment, String text)` Construct an OCL semantic analyzer with default syntactic and lexical parsers all operating within a given environment.
`OCLLexer(Environment<?,?,?,?,?,?,?,?,?,?,?,?> environment)`
`OCLLexer(Environment<?,?,?,?,?,?,?,?,?,?,?,?> environment, char[] chars)`
`OCLLexer(Environment<?,?,?,?,?,?,?,?,?,?,?,?> environment, char[] input_chars, String filename, int tab)`
`ValidationVisitor(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> environment)` Initializes me to validate expressions in the specified environment.

Uses of Environment in org.eclipse.ocl.parser.backtracking

Methods in org.eclipse.ocl.parser.backtracking that return Environment
`Environment<?,?,?,?,?,?,?,?,?,?,?,?>`	`OCLBacktrackingParser.getOCLEnvironment()`
`Environment<?,?,?,?,?,?,?,?,?,?,?,?>`	`OCLBacktrackingLexer.getOCLEnvironment()`

Constructors in org.eclipse.ocl.parser.backtracking with parameters of type Environment
`OCLBacktrackingLexer(Environment<?,?,?,?,?,?,?,?,?,?,?,?> environment)`
`OCLBacktrackingLexer(Environment<?,?,?,?,?,?,?,?,?,?,?,?> environment, char[] chars)`
`OCLBacktrackingLexer(Environment<?,?,?,?,?,?,?,?,?,?,?,?> environment, char[] input_chars, String filename, int tab)`

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 that return Environment

static



<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>

OCLUtil.getValidationEnvironment(Object target,
                         Map<Object,Object> context)

Attempts to get an environment instance that is appropriate for introspection of the specified validation target.

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

static Diagnostic OCLUtil.checkForErrors(Environment<?,?,?,?,?,?,?,?,?,?,?,?> env)
Checks whether the specified environment's problem handler has any diagnostics of error severity or worse and, if so, throws a semantic exception encapsulating these diagnostics.

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)

Deprecated. Use the TypeUtil.checkMutuallyComparable(Object, Environment, Object, Object, int) method, instead

static



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


boolean

TypeUtil.checkMutuallyComparable(Object problemObject,
                        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 of = 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)

Deprecated. Use the TypeUtil.commonSuperType(Object, Environment, Object, Object) method, instead.

static



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


C

TypeUtil.commonSuperType(Object problemObject,
                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,S,COA,SSA,CT,CLS,E> 


boolean

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

Compare 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> 


boolean

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

Compare two types.

static



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


P

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

Finds the most specific (re)definition of an attribute in the specified classifier.

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 the most specific (re)definition of 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



<T> T

OCLUtil.getAdapter(Environment<?,?,?,?,?,?,?,?,?,?,?,?> env,
           Class<T> adapterType)

Obtains an adapter for the specified interface type.

static



<C> Collection<C>

OCLStandardLibraryUtil.getAllSupertypes(Environment<?,C,?,?,?,?,?,?,?,?,?,?> env,
                 PredefinedType<?> type)

Queries all of the supertypes of a pre-defined type.

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)

Deprecated. Use the TypeUtil.getResultType(Object, Environment, Object, Object) method, instead

static



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


C

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

Deprecated. Use the #getResultTypeObject, Environment, Object, Object, List method, instead, which resolves generic operation signatures against actual arguments

static



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


C

TypeUtil.getResultType(Object problemObject,
              Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
              C owner,
              O operation,
              List<? extends TypedElement<C>> args)

Obtains the effective result type of the specified operation, which may or may not have parameters type by generic type variables.

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)

Deprecated. Use the OCLStandardLibraryUtil.getResultTypeOf(Object, Environment, Object, int, List) method, instead, which doesn't fail on the first problem

static



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


C

OCLStandardLibraryUtil.getResultTypeOf(Object problemObject,
                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



<C> boolean

TypeUtil.isStandardLibraryFeature(Environment<?,C,?,?,?,?,?,?,?,?,?,?> env,
                         C owner,
                         Object feature)

Queries whether the specified feature (operation or attribute), as applied to a particular owner classifier, is defined by the standard library or not (in which case it would, presumably, be user-defined).

static



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


boolean

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

Compares an actual argument list against the signature of an operation or a signal.

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 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> 


boolean

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

Deprecated. Use the TypeUtil.compatibleTypeMatch(Environment, Object, Object) method, instead, to check whether the cast is acceptable

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)

Deprecated. Use the TypeUtil.getRelationship(Environment, Object, Object) method, instead.

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.