Uses of Interface
org.eclipse.ocl.Environment

Packages that use Environment

Package	Description
org.eclipse.ocl	Definition of the extensible environment API for OCL parsing and evaluation.
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.internal
org.eclipse.ocl.internal.evaluation
org.eclipse.ocl.internal.helper
org.eclipse.ocl.options
org.eclipse.ocl.parser
org.eclipse.ocl.parser.backtracking
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

Modifier and Type	Interface and Description
static interface	Environment.Internal<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> An interface that merges the Environment and BasicEnvironment interfaces that define the behaviour realised in abstract form by AbstractEnvironment.

Classes in org.eclipse.ocl that implement Environment

Modifier and Type	Class and Description
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

Modifier and Type	Method and Description
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.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.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.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>	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>	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.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.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.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.createPackageContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent, List<String> pathname)
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.
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>	AbstractEvaluationVisitor.getEnvironment()
protected Environment<?,C,O,P,?,PM,?,?,?,?,?,?>	AbstractTypeChecker.getEnvironment() Obtains my OCL parsing environment.
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>	EvaluationVisitor.getEnvironment() Obtains the environment that provides the metamodel semantics for the expression to be evaluated.
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>	OCL.getEnvironment() Obtains the OCL parsing environment.
<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

Modifier and Type	Method and Description
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.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.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.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>	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.
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)
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.
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.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.
OCLAnalyzer<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E>	AbstractEnvironmentFactory.createOCLAnalyzer(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, String input)
OCLAnalyzer<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E>	EnvironmentFactory.createOCLAnalyzer(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> environment, String input) Creates an instance of the OCLAnalyzer that analyzes the given input on behalf of this environment.
OCLFactoryWithHistory	AbstractEnvironmentFactory.createOCLFactoryWithHistory(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
OCLFactoryWithHistory	EnvironmentFactory.createOCLFactoryWithHistory(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env) Creates an instance of the OCLFactoryWithHistory object for this environment.
OCLSyntaxHelper	AbstractEnvironmentFactory.createOCLSyntaxHelper(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
OCLSyntaxHelper	EnvironmentFactory.createOCLSyntaxHelper(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> environment) Creates an instance of the OCLSyntaxHelper object for this environment.
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.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.createPackageContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent, List<String> pathname)
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.
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.
Visitor<Boolean,C,O,P,EL,PM,S,COA,SSA,CT>	AbstractEnvironmentFactory.createValidationVisitor(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
Visitor<Boolean,C,O,P,EL,PM,S,COA,SSA,CT>	EnvironmentFactory.createValidationVisitor(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.
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.
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.

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

Constructor and Description
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.

Uses of Environment in org.eclipse.ocl.helper

Methods in org.eclipse.ocl.helper that return Environment

Modifier and Type	Method and Description
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.internal

Methods in org.eclipse.ocl.internal that return Environment

Modifier and Type	Method and Description
<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>	EnvironmentRegistryImpl.getEnvironmentFor(Object abstractSyntaxElement)
<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>	EnvironmentRegistryImpl.getEnvironmentFor(OCLExpression<C> expression)

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

Modifier and Type	Method and Description
void	EnvironmentRegistryImpl.deregisterEnvironment(Environment<?,?,?,?,?,?,?,?,?,?,?,?> environment)
void	EnvironmentRegistryImpl.registerEnvironment(Environment<?,?,?,?,?,?,?,?,?,?,?,?> environment)

Uses of Environment in org.eclipse.ocl.internal.evaluation

Constructors in org.eclipse.ocl.internal.evaluation with parameters of type Environment

Constructor and Description
QueryImpl(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> environment, OCLExpression<C> expr, Map<CLS,? extends Set<? extends E>> extentMap)

Uses of Environment in org.eclipse.ocl.internal.helper

Methods in org.eclipse.ocl.internal.helper that return Environment

Modifier and Type	Method and Description
protected Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E>	OCLSyntaxHelper.getEnvironment()

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

Modifier and Type	Method and Description
static <PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> Object	HelperUtil.getConstraintContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, Object element, OCLExpression<C> expr)

Constructors in org.eclipse.ocl.internal.helper with parameters of type Environment

Constructor and Description
OCLSyntaxHelper(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

Uses of Environment in org.eclipse.ocl.options

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

Modifier and Type	Method and Description
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

Fields in org.eclipse.ocl.parser declared as Environment

Modifier and Type	Field and Description
protected Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E>	ValidationVisitor.env

Methods in org.eclipse.ocl.parser that return Environment

Modifier and Type	Method and Description
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<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E>	AbstractOCLAnalyzer.getOCLEnvironment()
Environment<?,?,?,?,?,?,?,?,?,?,?,?>	OCLLexer.getOCLEnvironment()
Environment<?,?,?,?,?,?,?,?,?,?,?,?>	OCLParser.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

Modifier and Type	Method and Description
protected List<OCLExpression<C>>	AbstractOCLAnalyzer.argumentsCS(OperationCallExpCS operationCallExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
protected OCLExpression<C>	AbstractOCLAnalyzer.arrowOperationCallExpCS(OperationCallExpCS operationCallExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env) OperationCallExpCS for an ->
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 OCLExpression<C>	AbstractOCLAnalyzer.createImplicitSource(OperationCallExpCS operationCallExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, List<OCLExpression<C>> args)
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 OCLFactory	OCLAnalyzer.createOCLFactory(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
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 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.
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, <any> 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.oclIsInStateOperationCallExpCS(OperationCallExpCS operationCallExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env) OperationCallExpCS for oclIsInState
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 NavigationCallExp<C,P>	AbstractOCLAnalyzer.simpleNavigationName(SimpleNameCS simpleNameCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, OCLExpression<C> source, C owner, String simpleName) Allows subclasses to return calls that are not necessarily a PropertyCallExp but some other NavigationCallExp.
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, CSTNode stateExpCS, <any> statePath, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env) stateExpCS
protected OCLExpression<C>	AbstractOCLAnalyzer.staticOperationCallExpCS(OperationCallExpCS operationCallExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
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 <any>	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) EnumLiteralExpCS
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

Constructor and Description
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)
OCLLexer(Environment<?,?,?,?,?,?,?,?,?,?,?,?> environment, Reader reader, String filename)
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

Modifier and Type	Method and Description
Environment<?,?,?,?,?,?,?,?,?,?,?,?>	OCLBacktrackingLexer.getOCLEnvironment()
Environment<?,?,?,?,?,?,?,?,?,?,?,?>	OCLBacktrackingParser.getOCLEnvironment()

Constructors in org.eclipse.ocl.parser.backtracking with parameters of type Environment

Constructor and Description
OCLBacktrackingLexer(Environment<?,?,?,?,?,?,?,?,?,?,?,?> environment)
OCLBacktrackingLexer(Environment<?,?,?,?,?,?,?,?,?,?,?,?> environment, char[] chars)
OCLBacktrackingLexer(Environment<?,?,?,?,?,?,?,?,?,?,?,?> environment, char[] input_chars, String filename, int tab)
OCLBacktrackingLexer(Environment<?,?,?,?,?,?,?,?,?,?,?,?> environment, Reader reader, String filename)

Uses of Environment in org.eclipse.ocl.util

Methods in org.eclipse.ocl.util that return Environment

Modifier and Type	Method and Description
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

Modifier and Type	Method and Description
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 Diagnostic	OCLUtil.checkForErrorsOrWarnings(Environment<?,?,?,?,?,?,?,?,?,?,?,?> env) Checks whether the specified environment's problem handler has any diagnostics of warnings 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 TypeUtil.getResultType(Object, 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, <any> 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

Constructor and Description
ToStringVisitor(Environment<?,C,O,P,EL,PM,S,COA,SSA,CT,?,?> env) Initializes me with my environment.