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

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

AbstractTypeResolver(Environment<PK,C,O,P,?,PM,?,?,?,?,?,?> env)
Initializes me with an environment.

AbstractTypeResolver(Environment<PK,C,O,P,?,PM,?,?,?,?,?,?> env, Resource resource)
Initializes me with a resource in which I will persist the model-based types that I generate in my associated Environment.

OCL(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
Initializes me with a root environment.

OCL(EnvironmentFactory<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> envFactory, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> rootEnv)
Initializes me with my environment factory and root environment.

Uses of Environment in org.eclipse.ocl.ecore

Classes in org.eclipse.ocl.ecore that implement Environment

class

EcoreEnvironment Implementation of the Environment for parsing OCL expressions on Ecore models.

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

Environment<EPackage,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint,EClass,EObject>	EcoreEnvironmentFactory.createEnvironment()
Environment<EPackage,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint,EClass,EObject>	EcoreEnvironmentFactory.createEnvironment(Environment<EPackage,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint,EClass,EObject> parent)
Environment<EPackage,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint,EClass,EObject>	EcoreEnvironmentFactory.loadEnvironment(Resource resource)

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

Environment<EPackage,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint,EClass,EObject>	EcoreEnvironmentFactory.createEnvironment(Environment<EPackage,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint,EClass,EObject> parent)
static OCL	OCL.newInstance(Environment<EPackage,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint,EClass,EObject> env) Creates a new OCL using the specified initial Ecore environment.
void	EcoreEnvironment.setParent(Environment<EPackage,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint,EClass,EObject> env)

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

EcoreEnvironment(Environment<EPackage,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint,EClass,EObject> parent)
Initializes me with a parent environment, from which I inherit such things as a package registry and a resource.

OCL(Environment<EPackage,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint,EClass,EObject> env)
Initializes me with an initial environment for the Ecore metamodel.

Uses of Environment in org.eclipse.ocl.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 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 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.
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(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, CollectionKind kind, C elementType)
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.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 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 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 LetExp<C,PM>	AbstractOCLAnalyzer.letExpCS(LetExpCS letExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env) LetExpCS
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 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.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 OCLExpression<C>	AbstractOCLAnalyzer.simpleNameCS(SimpleNameCS simpleNameCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, OCLExpression<C> source) SimpleNameCS
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.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> O	TypeUtil.findOperationMatching(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C owner, String name, List<? extends TypedElement<C>> args) Finds an operation by signature in the specified classifier.
static <PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> C	TypeUtil.findSignalMatching(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C receiver, List<C> signals, String name, List<? extends TypedElement<C>> args) Find a matching signal in the specified list.
static <T> T	OCLUtil.getAdapter(Environment<?,?,?,?,?,?,?,?,?,?,?,?> env, Class<T> adapterType) Obtains an adapter for the specified interface 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) Obtains the result type of the specified operation, which in the case of collection operations sometimes depends on the element type of the source collection.
static <PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> C	OCLStandardLibraryUtil.getResultTypeOf(Environment<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> env, C sourceType, int opcode, List<? extends TypedElement<C>> args) 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 <PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> Set<Tuple<O,P>>	CollectionUtil.product(EvaluationEnvironment<C,O,P,CLS,E> evalEnv, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, Collection<?> self, Collection<?> c, C tupleType) Implementation of the OCL Collection::product(c : Collection(T2)) : Set(Tuple(first : T, second : T2)) operations.
static <PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> C	TypeUtil.resolveBagType(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C elementType) Resolves a Bag type against the baf types previously generated and persisted in the environment.
static <PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> C	TypeUtil.resolveCollectionType(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, CollectionKind kind, C elementType) Resolves a collection type against the collection types previously generated and persisted in the environment.
static <PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> O	TypeUtil.resolveGenericSignature(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C owner, O oper) Resolves the signature of a generic operation (where it has parameters of type and/or T or T2) against the source type of the operation, as appropriate.
static <PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> C	TypeUtil.resolveOperationMessageType(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, O operation) Resolves an operation message type against the message types previously generated and persisted in the environment.
static <PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> C	TypeUtil.resolveOrderedSetType(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C elementType) Resolves a OrderedSet type against the types previously generated and persisted in the environment.
static <PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> C	TypeUtil.resolveSequenceType(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C elementType) Resolves a Sequence type against the sequence types previously generated and persisted in the environment.
static <PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> C	TypeUtil.resolveSetType(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C elementType) Resolves a Set type against the set types previously generated and persisted in the environment.
static <PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> C	TypeUtil.resolveSignalMessageType(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C signal) Resolves a signal message type against the message types previously generated and persisted in the environment.
static <PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> C	TypeUtil.resolveTupleType(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, EList<? extends TypedElement<C>> parts) Resolves a tuple type against the tuple types previously generated and persisted in the environment.
static <PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> C	TypeUtil.resolveType(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C type) Resolves the specified type against the model-based types defined by the specified environment's type resolver, for consistency with the environment (especially for persistence).
static <PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> C	TypeUtil.resolveTypeType(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C type) Resolves a tupe-type against the tupe-types previously generated and persisted in the environment.
static <PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> boolean	TypeUtil.type1AsType2(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C type1, C type2) 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.