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.ecore.internal.helper   
org.eclipse.ocl.ecore.parser   
org.eclipse.ocl.ecore.utilities   
org.eclipse.ocl.examples.impactanalyzer.deltaPropagation   
org.eclipse.ocl.examples.impactanalyzer.instanceScope.unusedEvaluation   
org.eclipse.ocl.examples.impactanalyzer.util   
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.uml Implementation of an OCL binding for the UML metamodel. 
org.eclipse.ocl.uml.internal   
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 BasicEnvironment interfaces that define the behaviour realised in abstract form by AbstractEnvironment.
 

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> 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, java.lang.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, java.lang.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, java.util.List<java.lang.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, java.util.List<java.lang.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(java.lang.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(org.eclipse.emf.ecore.resource.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, java.util.List<java.lang.String> pathname)
          Creates an environment suitable for parsing OCL expressions in the specified package context.
 

Methods in org.eclipse.ocl with parameters of type Environment
 Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> AbstractEnvironmentFactory.createAttributeContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent, P property)
           
 Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> 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, java.util.Map<? extends CLS,? extends java.util.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, java.util.Map<? extends CLS,? extends java.util.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, java.lang.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, java.lang.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, java.lang.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, java.lang.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, java.util.List<java.lang.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, java.util.List<java.lang.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<java.lang.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<java.lang.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, java.util.List<java.lang.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, java.util.Map<? extends CLS,? extends java.util.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, org.eclipse.emf.ecore.resource.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, java.util.Map<? extends CLS,? extends java.util.Set<? extends E>> extentMap)
          Constructor
OCL(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
          Initializes me with a root environment.
OCL(EnvironmentFactory<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> envFactory, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> rootEnv)
          Initializes me with my environment factory and root environment.
 

Uses of Environment in org.eclipse.ocl.ecore
 

Subinterfaces of Environment in org.eclipse.ocl.ecore
 interface EnvironmentWithHiddenOpposites
          Adds methods regarding lookup and navigation of "hidden" opposite properties to Environment and is implemented by AbstractEnvironment.
 

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<org.eclipse.emf.ecore.EPackage,org.eclipse.emf.ecore.EClassifier,org.eclipse.emf.ecore.EOperation,org.eclipse.emf.ecore.EStructuralFeature,org.eclipse.emf.ecore.EEnumLiteral,org.eclipse.emf.ecore.EParameter,org.eclipse.emf.ecore.EObject,CallOperationAction,SendSignalAction,Constraint,org.eclipse.emf.ecore.EClass,org.eclipse.emf.ecore.EObject> EcoreEnvironmentFactory.createEnvironment()
           
 Environment<org.eclipse.emf.ecore.EPackage,org.eclipse.emf.ecore.EClassifier,org.eclipse.emf.ecore.EOperation,org.eclipse.emf.ecore.EStructuralFeature,org.eclipse.emf.ecore.EEnumLiteral,org.eclipse.emf.ecore.EParameter,org.eclipse.emf.ecore.EObject,CallOperationAction,SendSignalAction,Constraint,org.eclipse.emf.ecore.EClass,org.eclipse.emf.ecore.EObject> EcoreEnvironmentFactory.createEnvironment(Environment<org.eclipse.emf.ecore.EPackage,org.eclipse.emf.ecore.EClassifier,org.eclipse.emf.ecore.EOperation,org.eclipse.emf.ecore.EStructuralFeature,org.eclipse.emf.ecore.EEnumLiteral,org.eclipse.emf.ecore.EParameter,org.eclipse.emf.ecore.EObject,CallOperationAction,SendSignalAction,Constraint,org.eclipse.emf.ecore.EClass,org.eclipse.emf.ecore.EObject> parent)
           
 Environment<org.eclipse.emf.ecore.EPackage,org.eclipse.emf.ecore.EClassifier,org.eclipse.emf.ecore.EOperation,org.eclipse.emf.ecore.EStructuralFeature,org.eclipse.emf.ecore.EEnumLiteral,org.eclipse.emf.ecore.EParameter,org.eclipse.emf.ecore.EObject,CallOperationAction,SendSignalAction,Constraint,org.eclipse.emf.ecore.EClass,org.eclipse.emf.ecore.EObject> EcoreEnvironmentFactory.loadEnvironment(org.eclipse.emf.ecore.resource.Resource resource)
           
 

Methods in org.eclipse.ocl.ecore with parameters of type Environment
 Environment<org.eclipse.emf.ecore.EPackage,org.eclipse.emf.ecore.EClassifier,org.eclipse.emf.ecore.EOperation,org.eclipse.emf.ecore.EStructuralFeature,org.eclipse.emf.ecore.EEnumLiteral,org.eclipse.emf.ecore.EParameter,org.eclipse.emf.ecore.EObject,CallOperationAction,SendSignalAction,Constraint,org.eclipse.emf.ecore.EClass,org.eclipse.emf.ecore.EObject> EcoreEnvironmentFactory.createEnvironment(Environment<org.eclipse.emf.ecore.EPackage,org.eclipse.emf.ecore.EClassifier,org.eclipse.emf.ecore.EOperation,org.eclipse.emf.ecore.EStructuralFeature,org.eclipse.emf.ecore.EEnumLiteral,org.eclipse.emf.ecore.EParameter,org.eclipse.emf.ecore.EObject,CallOperationAction,SendSignalAction,Constraint,org.eclipse.emf.ecore.EClass,org.eclipse.emf.ecore.EObject> parent)
           
 EvaluationVisitor<org.eclipse.emf.ecore.EPackage,org.eclipse.emf.ecore.EClassifier,org.eclipse.emf.ecore.EOperation,org.eclipse.emf.ecore.EStructuralFeature,org.eclipse.emf.ecore.EEnumLiteral,org.eclipse.emf.ecore.EParameter,org.eclipse.emf.ecore.EObject,CallOperationAction,SendSignalAction,Constraint,org.eclipse.emf.ecore.EClass,org.eclipse.emf.ecore.EObject> EcoreEnvironmentFactory.createEvaluationVisitor(Environment<org.eclipse.emf.ecore.EPackage,org.eclipse.emf.ecore.EClassifier,org.eclipse.emf.ecore.EOperation,org.eclipse.emf.ecore.EStructuralFeature,org.eclipse.emf.ecore.EEnumLiteral,org.eclipse.emf.ecore.EParameter,org.eclipse.emf.ecore.EObject,CallOperationAction,SendSignalAction,Constraint,org.eclipse.emf.ecore.EClass,org.eclipse.emf.ecore.EObject> env, EvaluationEnvironment<org.eclipse.emf.ecore.EClassifier,org.eclipse.emf.ecore.EOperation,org.eclipse.emf.ecore.EStructuralFeature,org.eclipse.emf.ecore.EClass,org.eclipse.emf.ecore.EObject> evalEnv, java.util.Map<? extends org.eclipse.emf.ecore.EClass,? extends java.util.Set<? extends org.eclipse.emf.ecore.EObject>> extentMap)
           
 OCLAnalyzer EcoreEnvironmentFactory.createOCLAnalyzer(Environment<org.eclipse.emf.ecore.EPackage,org.eclipse.emf.ecore.EClassifier,org.eclipse.emf.ecore.EOperation,org.eclipse.emf.ecore.EStructuralFeature,org.eclipse.emf.ecore.EEnumLiteral,org.eclipse.emf.ecore.EParameter,org.eclipse.emf.ecore.EObject,CallOperationAction,SendSignalAction,Constraint,org.eclipse.emf.ecore.EClass,org.eclipse.emf.ecore.EObject> env, java.lang.String input)
           
 OCLFactoryWithHistory EcoreEnvironmentFactory.createOCLFactoryWithHistory(Environment<org.eclipse.emf.ecore.EPackage,org.eclipse.emf.ecore.EClassifier,org.eclipse.emf.ecore.EOperation,org.eclipse.emf.ecore.EStructuralFeature,org.eclipse.emf.ecore.EEnumLiteral,org.eclipse.emf.ecore.EParameter,org.eclipse.emf.ecore.EObject,CallOperationAction,SendSignalAction,Constraint,org.eclipse.emf.ecore.EClass,org.eclipse.emf.ecore.EObject> env)
           
 OCLSyntaxHelper EcoreEnvironmentFactory.createOCLSyntaxHelper(Environment<org.eclipse.emf.ecore.EPackage,org.eclipse.emf.ecore.EClassifier,org.eclipse.emf.ecore.EOperation,org.eclipse.emf.ecore.EStructuralFeature,org.eclipse.emf.ecore.EEnumLiteral,org.eclipse.emf.ecore.EParameter,org.eclipse.emf.ecore.EObject,CallOperationAction,SendSignalAction,Constraint,org.eclipse.emf.ecore.EClass,org.eclipse.emf.ecore.EObject> env)
           
 Visitor<java.lang.Boolean,org.eclipse.emf.ecore.EClassifier,org.eclipse.emf.ecore.EOperation,org.eclipse.emf.ecore.EStructuralFeature,org.eclipse.emf.ecore.EEnumLiteral,org.eclipse.emf.ecore.EParameter,org.eclipse.emf.ecore.EObject,CallOperationAction,SendSignalAction,Constraint> EcoreEnvironmentFactory.createValidationVisitor(Environment<org.eclipse.emf.ecore.EPackage,org.eclipse.emf.ecore.EClassifier,org.eclipse.emf.ecore.EOperation,org.eclipse.emf.ecore.EStructuralFeature,org.eclipse.emf.ecore.EEnumLiteral,org.eclipse.emf.ecore.EParameter,org.eclipse.emf.ecore.EObject,CallOperationAction,SendSignalAction,Constraint,org.eclipse.emf.ecore.EClass,org.eclipse.emf.ecore.EObject> env)
           
static OCL OCL.newInstance(Environment<org.eclipse.emf.ecore.EPackage,org.eclipse.emf.ecore.EClassifier,org.eclipse.emf.ecore.EOperation,org.eclipse.emf.ecore.EStructuralFeature,org.eclipse.emf.ecore.EEnumLiteral,org.eclipse.emf.ecore.EParameter,org.eclipse.emf.ecore.EObject,CallOperationAction,SendSignalAction,Constraint,org.eclipse.emf.ecore.EClass,org.eclipse.emf.ecore.EObject> env)
          Creates a new OCL using the specified initial Ecore environment.
 void EcoreEnvironment.setParent(Environment<org.eclipse.emf.ecore.EPackage,org.eclipse.emf.ecore.EClassifier,org.eclipse.emf.ecore.EOperation,org.eclipse.emf.ecore.EStructuralFeature,org.eclipse.emf.ecore.EEnumLiteral,org.eclipse.emf.ecore.EParameter,org.eclipse.emf.ecore.EObject,CallOperationAction,SendSignalAction,Constraint,org.eclipse.emf.ecore.EClass,org.eclipse.emf.ecore.EObject> env)
           
 

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

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

Constructors in org.eclipse.ocl.ecore.internal.helper with parameters of type Environment
OCLSyntaxHelper(Environment<org.eclipse.emf.ecore.EPackage,org.eclipse.emf.ecore.EClassifier,org.eclipse.emf.ecore.EOperation,org.eclipse.emf.ecore.EStructuralFeature,org.eclipse.emf.ecore.EEnumLiteral,org.eclipse.emf.ecore.EParameter,org.eclipse.emf.ecore.EObject,CallOperationAction,SendSignalAction,Constraint,org.eclipse.emf.ecore.EClass,org.eclipse.emf.ecore.EObject> env)
           
 

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

Methods in org.eclipse.ocl.ecore.parser with parameters of type Environment
protected  NavigationCallExp<org.eclipse.emf.ecore.EClassifier,org.eclipse.emf.ecore.EStructuralFeature> OCLAnalyzer.simpleNavigationName(SimpleNameCS simpleNameCS, Environment<org.eclipse.emf.ecore.EPackage,org.eclipse.emf.ecore.EClassifier,org.eclipse.emf.ecore.EOperation,org.eclipse.emf.ecore.EStructuralFeature,org.eclipse.emf.ecore.EEnumLiteral,org.eclipse.emf.ecore.EParameter,org.eclipse.emf.ecore.EObject,CallOperationAction,SendSignalAction,Constraint,org.eclipse.emf.ecore.EClass,org.eclipse.emf.ecore.EObject> env, OCLExpression<org.eclipse.emf.ecore.EClassifier> source, org.eclipse.emf.ecore.EClassifier owner, java.lang.String simpleName)
          Attempts to parse a simpleNameCS as a property call expression.
 

Constructors in org.eclipse.ocl.ecore.parser with parameters of type Environment
OCLAnalyzer(Environment<org.eclipse.emf.ecore.EPackage,org.eclipse.emf.ecore.EClassifier,org.eclipse.emf.ecore.EOperation,org.eclipse.emf.ecore.EStructuralFeature,org.eclipse.emf.ecore.EEnumLiteral,org.eclipse.emf.ecore.EParameter,org.eclipse.emf.ecore.EObject,CallOperationAction,SendSignalAction,Constraint,org.eclipse.emf.ecore.EClass,org.eclipse.emf.ecore.EObject> rootEnvironment, java.lang.String input)
           
ValidationVisitor(Environment<org.eclipse.emf.ecore.EPackage,org.eclipse.emf.ecore.EClassifier,org.eclipse.emf.ecore.EOperation,org.eclipse.emf.ecore.EStructuralFeature,org.eclipse.emf.ecore.EEnumLiteral,org.eclipse.emf.ecore.EParameter,org.eclipse.emf.ecore.EObject,CallOperationAction,SendSignalAction,Constraint,org.eclipse.emf.ecore.EClass,org.eclipse.emf.ecore.EObject> environment)
           
 

Uses of Environment in org.eclipse.ocl.ecore.utilities
 

Constructors in org.eclipse.ocl.ecore.utilities with parameters of type Environment
ToStringVisitor(Environment<?,org.eclipse.emf.ecore.EClassifier,org.eclipse.emf.ecore.EOperation,org.eclipse.emf.ecore.EStructuralFeature,org.eclipse.emf.ecore.EEnumLiteral,org.eclipse.emf.ecore.EParameter,org.eclipse.emf.ecore.EObject,CallOperationAction,SendSignalAction,Constraint,?,?> env)
           
 

Uses of Environment in org.eclipse.ocl.examples.impactanalyzer.deltaPropagation
 

Methods in org.eclipse.ocl.examples.impactanalyzer.deltaPropagation with parameters of type Environment
 EvaluationVisitor<org.eclipse.emf.ecore.EPackage,org.eclipse.emf.ecore.EClassifier,org.eclipse.emf.ecore.EOperation,org.eclipse.emf.ecore.EStructuralFeature,org.eclipse.emf.ecore.EEnumLiteral,org.eclipse.emf.ecore.EParameter,org.eclipse.emf.ecore.EObject,CallOperationAction,SendSignalAction,Constraint,org.eclipse.emf.ecore.EClass,org.eclipse.emf.ecore.EObject> PartialEcoreEnvironmentFactory.createEvaluationVisitor(Environment<org.eclipse.emf.ecore.EPackage,org.eclipse.emf.ecore.EClassifier,org.eclipse.emf.ecore.EOperation,org.eclipse.emf.ecore.EStructuralFeature,org.eclipse.emf.ecore.EEnumLiteral,org.eclipse.emf.ecore.EParameter,org.eclipse.emf.ecore.EObject,CallOperationAction,SendSignalAction,Constraint,org.eclipse.emf.ecore.EClass,org.eclipse.emf.ecore.EObject> env, EvaluationEnvironment<org.eclipse.emf.ecore.EClassifier,org.eclipse.emf.ecore.EOperation,org.eclipse.emf.ecore.EStructuralFeature,org.eclipse.emf.ecore.EClass,org.eclipse.emf.ecore.EObject> evalEnv, java.util.Map<? extends org.eclipse.emf.ecore.EClass,? extends java.util.Set<? extends org.eclipse.emf.ecore.EObject>> extentMap)
          Creates a visitor.
 

Constructors in org.eclipse.ocl.examples.impactanalyzer.deltaPropagation with parameters of type Environment
PartialEvaluationVisitorImpl(Environment<org.eclipse.emf.ecore.EPackage,org.eclipse.emf.ecore.EClassifier,org.eclipse.emf.ecore.EOperation,org.eclipse.emf.ecore.EStructuralFeature,org.eclipse.emf.ecore.EEnumLiteral,org.eclipse.emf.ecore.EParameter,org.eclipse.emf.ecore.EObject,CallOperationAction,SendSignalAction,Constraint,org.eclipse.emf.ecore.EClass,org.eclipse.emf.ecore.EObject> env, EvaluationEnvironment<org.eclipse.emf.ecore.EClassifier,org.eclipse.emf.ecore.EOperation,org.eclipse.emf.ecore.EStructuralFeature,org.eclipse.emf.ecore.EClass,org.eclipse.emf.ecore.EObject> evalEnv, java.util.Map<? extends org.eclipse.emf.ecore.EClass,? extends java.util.Set<? extends org.eclipse.emf.ecore.EObject>> extentMap, OCLExpression sourceExpression, java.lang.Object valueOfSourceExpression, org.eclipse.emf.common.notify.Notification atPre)
           
 

Uses of Environment in org.eclipse.ocl.examples.impactanalyzer.instanceScope.unusedEvaluation
 

Methods in org.eclipse.ocl.examples.impactanalyzer.instanceScope.unusedEvaluation with parameters of type Environment
 PartialEvaluationVisitorImplNoAllInstances PartialEcoreEnvironmentFactoryNoAllInstances.createEvaluationVisitor(Environment<org.eclipse.emf.ecore.EPackage,org.eclipse.emf.ecore.EClassifier,org.eclipse.emf.ecore.EOperation,org.eclipse.emf.ecore.EStructuralFeature,org.eclipse.emf.ecore.EEnumLiteral,org.eclipse.emf.ecore.EParameter,org.eclipse.emf.ecore.EObject,CallOperationAction,SendSignalAction,Constraint,org.eclipse.emf.ecore.EClass,org.eclipse.emf.ecore.EObject> env, EvaluationEnvironment<org.eclipse.emf.ecore.EClassifier,org.eclipse.emf.ecore.EOperation,org.eclipse.emf.ecore.EStructuralFeature,org.eclipse.emf.ecore.EClass,org.eclipse.emf.ecore.EObject> evalEnv, java.util.Map<? extends org.eclipse.emf.ecore.EClass,? extends java.util.Set<? extends org.eclipse.emf.ecore.EObject>> extentMap)
          Creates a visitor.
 

Constructors in org.eclipse.ocl.examples.impactanalyzer.instanceScope.unusedEvaluation with parameters of type Environment
PartialEvaluationVisitorImplNoAllInstances(Environment<org.eclipse.emf.ecore.EPackage,org.eclipse.emf.ecore.EClassifier,org.eclipse.emf.ecore.EOperation,org.eclipse.emf.ecore.EStructuralFeature,org.eclipse.emf.ecore.EEnumLiteral,org.eclipse.emf.ecore.EParameter,org.eclipse.emf.ecore.EObject,CallOperationAction,SendSignalAction,Constraint,org.eclipse.emf.ecore.EClass,org.eclipse.emf.ecore.EObject> env, EvaluationEnvironment<org.eclipse.emf.ecore.EClassifier,org.eclipse.emf.ecore.EOperation,org.eclipse.emf.ecore.EStructuralFeature,org.eclipse.emf.ecore.EClass,org.eclipse.emf.ecore.EObject> evalEnv, java.util.Map<? extends org.eclipse.emf.ecore.EClass,? extends java.util.Set<? extends org.eclipse.emf.ecore.EObject>> extentMap, OCLExpression sourceExpression, java.lang.Object valueOfSourceExpression, org.eclipse.emf.common.notify.Notification atPre)
           
 

Uses of Environment in org.eclipse.ocl.examples.impactanalyzer.util
 

Constructors in org.eclipse.ocl.examples.impactanalyzer.util with parameters of type Environment
HighlightingToStringVisitor(Environment<org.eclipse.emf.ecore.EPackage,org.eclipse.emf.ecore.EClassifier,org.eclipse.emf.ecore.EOperation,org.eclipse.emf.ecore.EStructuralFeature,org.eclipse.emf.ecore.EEnumLiteral,org.eclipse.emf.ecore.EParameter,org.eclipse.emf.ecore.EObject,CallOperationAction,SendSignalAction,Constraint,org.eclipse.emf.ecore.EClass,org.eclipse.emf.ecore.EObject> env, OCLExpression expressionToHighlight)
           
 

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

Methods in org.eclipse.ocl.internal that return 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>
EnvironmentRegistryImpl.getEnvironmentFor(java.lang.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
 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
BasicTypeChecker(Environment<?,C,O,P,?,PM,?,?,?,?,?,?> env)
           
CachedTypeChecker(Environment<?,C,O,P,?,PM,?,?,?,?,?,?> environment)
           
QueryImpl(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> environment, OCLExpression<C> expr, java.util.Map<CLS,? extends java.util.Set<? extends E>> extentMap)
           
 

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

Methods in org.eclipse.ocl.internal.helper that return Environment
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
static
<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E>
java.lang.Object
HelperUtil.getConstraintContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, java.lang.Object element, OCLExpression<C> expr)
           
 

Constructors in org.eclipse.ocl.internal.helper with parameters of type Environment
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
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
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
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, java.util.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, java.util.List<java.lang.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
protected  java.util.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, java.lang.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, java.util.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, java.util.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, java.lang.String message)
          Return the type used to terminate the AST reference from cstNode that failed to be resolved due to message.
protected  java.lang.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, java.util.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, java.util.List<java.lang.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, java.lang.String rule, java.lang.String operName, OCLExpression<C> source, C ownerType, java.util.List<OCLExpression<C>> args)
          Generate an OperationCallExp node.
protected  Variable<C,PM> AbstractOCLAnalyzer.genVariableDeclaration(CSTNode cstNode, java.lang.String rule, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, java.lang.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, java.lang.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<java.lang.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, java.lang.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, org.eclipse.emf.common.util.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, java.lang.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, java.lang.Object fromAstNode, CSTNode cstNode, java.lang.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, java.lang.String name)
           
protected  C AbstractOCLAnalyzer.lookupClassifier(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, java.util.List<java.lang.String> className)
           
protected  Variable<C,PM> AbstractOCLAnalyzer.lookupImplicitSourceForOperation(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, java.util.List<OCLExpression<C>> args, java.lang.String operationName)
           
protected  O AbstractOCLAnalyzer.lookupOperation(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C owner, java.lang.String name, java.util.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, java.lang.String name)
           
protected  C AbstractOCLAnalyzer.lookupSignal(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C owner, java.lang.String name, java.util.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, java.util.List<java.lang.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, java.util.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  java.lang.String AbstractOCLAnalyzer.operationString(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, java.lang.String operName, java.util.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, java.util.List<CT> constraints)
          Analyzes a package declaration in the context of the environment created for an OCLDocumentCS.
protected  java.util.List<Variable<C,PM>> AbstractOCLAnalyzer.parametersCS(java.util.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, java.util.List<CT> constraints)
          PropertyContextCS
protected  java.util.List<OCLExpression<C>> AbstractOCLAnalyzer.qualifiersCS(java.util.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, java.lang.String rule, NavigationCallExp<C,P> nc, java.util.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, java.lang.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, java.lang.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, java.lang.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, java.lang.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, java.lang.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, java.lang.String simpleName)
          Attempts to parse a simpleNameCS as a variable expression.
protected  StateExp<C,S> AbstractOCLAnalyzer.stateExpCS(OCLExpression<C> source, CSTNode stateExpCS, org.eclipse.emf.common.util.EList<java.lang.String> 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  org.eclipse.emf.common.util.EList<TupleLiteralPart<C,P>> AbstractOCLAnalyzer.tupleLiteralPartListCS(java.util.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  java.util.List<Variable<C,PM>> AbstractOCLAnalyzer.variableDeclarationListCS(java.util.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, java.lang.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, java.lang.String filename, int tab)
           
OCLLexer(Environment<?,?,?,?,?,?,?,?,?,?,?,?> environment, java.io.Reader reader, java.lang.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
 Environment<?,?,?,?,?,?,?,?,?,?,?,?> OCLBacktrackingLexer.getOCLEnvironment()
           
 Environment<?,?,?,?,?,?,?,?,?,?,?,?> OCLBacktrackingParser.getOCLEnvironment()
           
 

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

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<org.eclipse.uml2.uml.Package,org.eclipse.uml2.uml.Classifier,org.eclipse.uml2.uml.Operation,org.eclipse.uml2.uml.Property,org.eclipse.uml2.uml.EnumerationLiteral,org.eclipse.uml2.uml.Parameter,org.eclipse.uml2.uml.State,org.eclipse.uml2.uml.CallOperationAction,org.eclipse.uml2.uml.SendSignalAction,org.eclipse.uml2.uml.Constraint,org.eclipse.uml2.uml.Class,org.eclipse.emf.ecore.EObject> UMLEnvironmentFactory.createEnvironment(Environment<org.eclipse.uml2.uml.Package,org.eclipse.uml2.uml.Classifier,org.eclipse.uml2.uml.Operation,org.eclipse.uml2.uml.Property,org.eclipse.uml2.uml.EnumerationLiteral,org.eclipse.uml2.uml.Parameter,org.eclipse.uml2.uml.State,org.eclipse.uml2.uml.CallOperationAction,org.eclipse.uml2.uml.SendSignalAction,org.eclipse.uml2.uml.Constraint,org.eclipse.uml2.uml.Class,org.eclipse.emf.ecore.EObject> parent)
           
 Environment<org.eclipse.uml2.uml.Package,org.eclipse.uml2.uml.Classifier,org.eclipse.uml2.uml.Operation,org.eclipse.uml2.uml.Property,org.eclipse.uml2.uml.EnumerationLiteral,org.eclipse.uml2.uml.Parameter,org.eclipse.uml2.uml.State,org.eclipse.uml2.uml.CallOperationAction,org.eclipse.uml2.uml.SendSignalAction,org.eclipse.uml2.uml.Constraint,org.eclipse.uml2.uml.Class,org.eclipse.emf.ecore.EObject> UMLEnvironmentFactory.loadEnvironment(org.eclipse.emf.ecore.resource.Resource resource)
           
 

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

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

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

Methods in org.eclipse.ocl.uml.internal with parameters of type Environment
static java.util.Collection<org.eclipse.uml2.uml.Operation> OCLStandardLibraryImpl.createCollectionTypeOperations(Environment<?,org.eclipse.uml2.uml.Classifier,org.eclipse.uml2.uml.Operation,?,?,org.eclipse.uml2.uml.Parameter,?,?,?,?,?,?> env, CollectionKind kind)
           
 

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(java.lang.Object target, java.util.Map<java.lang.Object,java.lang.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 org.eclipse.emf.common.util.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 org.eclipse.emf.common.util.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(java.lang.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(java.lang.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>
java.util.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>
java.util.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>
java.util.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>
java.util.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>
java.util.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>
java.util.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>
java.util.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>
java.util.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>
java.util.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>
java.util.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>
java.util.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>
java.util.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>
java.util.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>
java.util.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>
java.util.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>
java.util.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>
java.util.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>
java.util.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, java.lang.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, java.lang.String name, java.util.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, java.util.List<C> signals, java.lang.String name, java.util.List<? extends TypedElement<C>> args)
          Find a matching signal in the specified list.
static
<T> T
OCLUtil.getAdapter(Environment<?,?,?,?,?,?,?,?,?,?,?,?> env, java.lang.Class<T> adapterType)
          Obtains an adapter for the specified interface type.
static
<C> java.util.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>
java.util.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>
java.util.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(java.lang.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(java.lang.Object problemObject, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C owner, O operation, java.util.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, java.util.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(java.lang.Object problemObject, Environment<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> env, C sourceType, int opcode, java.util.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, java.lang.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, java.util.List<?> paramsOrProperties, java.util.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>
java.util.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, java.util.Collection<?> self, java.util.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, org.eclipse.emf.common.util.EList<? extends TypedElement<C>> parts)
          Resolves a tuple type against the tuple types previously generated and persisted in the environment.
static
<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E>
C
TypeUtil.resolveType(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C type)
          Resolves the specified type against the model-based types defined by the specified environment's type resolver, for consistency with the environment (especially for persistence).
static
<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E>
C
TypeUtil.resolveTypeType(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C type)
          Resolves a tuple-type against the tuple-types previously generated and persisted in the environment.
static
<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E>
boolean
TypeUtil.type1AsType2(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C type1, C type2)
          Deprecated. Use the TypeUtil.compatibleTypeMatch(Environment, Object, Object) method, instead, to check whether the cast is acceptable
static
<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E>
int
TypeUtil.typeCompare(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C type1, C type2)
          Deprecated. Use the TypeUtil.getRelationship(Environment, Object, Object) method, instead.
 

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