|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
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. |
|
|
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). |
|
|
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
|
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 | ||
---|---|---|
|
EnvironmentRegistryImpl.getEnvironmentFor(java.lang.Object abstractSyntaxElement)
|
|
|
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 | |
---|---|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
TypeUtil.compatibleTypeMatch(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
C type1,
C type2)
Compare two types. |
|
static
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
TypeUtil.exactTypeMatch(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
C type1,
C type2)
Compare two types. |
|
static
|
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
|
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
|
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
|
OCLUtil.getAdapter(Environment<?,?,?,?,?,?,?,?,?,?,?,?> env,
java.lang.Class<T> adapterType)
Obtains an adapter for the specified interface type. |
|
static
|
OCLStandardLibraryUtil.getAllSupertypes(Environment<?,C,?,?,?,?,?,?,?,?,?,?> env,
PredefinedType<?> type)
Queries all of the supertypes of a pre-defined type. |
|
static
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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. |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |