Modifier and Type | Interface and Description |
---|---|
static interface |
Environment.Internal<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E>
An interface that merges the
Environment and
BasicEnvironment interfaces that define the
behaviour realised in abstract form by AbstractEnvironment . |
Modifier and Type | Class and Description |
---|---|
class |
AbstractEnvironment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E>
A partial implementation of the
Environment interface providing
some useful common behavior for providers of metamodel bindings. |
Modifier and Type | Method and Description |
---|---|
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
AbstractEnvironmentFactory.createAttributeContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent,
P property) |
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
EnvironmentFactory.createAttributeContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent,
P property)
Creates an environment suitable for parsing OCL expressions on the
specified
property , which is some attribute
in the client's metamodel. |
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
AbstractEnvironmentFactory.createClassifierContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent,
C context) |
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
EnvironmentFactory.createClassifierContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent,
C context)
Creates an environment suitable for parsing OCL expressions in the
specified
context , which is some classifier
in the client's model. |
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
EnvironmentFactory.createEnvironment()
Creates a root environment, in which package contexts and/or classifier
contexts will be created as nested environments.
|
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
EnvironmentFactory.createEnvironment(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent)
Creates a child environment of a specified
parent , for
definition of nested scopes. |
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
AbstractEnvironmentFactory.createInstanceContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent,
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.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.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.
|
Modifier and Type | Method and Description |
---|---|
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
AbstractEnvironmentFactory.createAttributeContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent,
P property) |
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
EnvironmentFactory.createAttributeContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent,
P property)
Creates an environment suitable for parsing OCL expressions on the
specified
property , which is some attribute
in the client's metamodel. |
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
AbstractEnvironmentFactory.createClassifierContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent,
C context) |
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
EnvironmentFactory.createClassifierContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent,
C context)
Creates an environment suitable for parsing OCL expressions in the
specified
context , which is some classifier
in the client's model. |
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
EnvironmentFactory.createEnvironment(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent)
Creates a child environment of a specified
parent , for
definition of nested scopes. |
EvaluationVisitor<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
AbstractEnvironmentFactory.createEvaluationVisitor(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
EvaluationEnvironment<C,O,P,CLS,E> evalEnv,
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.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.
|
Constructor and Description |
---|
AbstractEvaluationVisitor(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
EvaluationEnvironment<C,O,P,CLS,E> evalEnv,
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.
|
Modifier and Type | Interface and Description |
---|---|
interface |
EnvironmentWithHiddenOpposites
Adds methods regarding lookup and navigation of "hidden" opposite properties
to
Environment and is implemented by AbstractEnvironment . |
Modifier and Type | Class and Description |
---|---|
class |
EcoreEnvironment
Implementation of the
Environment for parsing OCL expressions on
Ecore models. |
Modifier and Type | Method and Description |
---|---|
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) |
Modifier and Type | Method and Description |
---|---|
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) |
Constructor and Description |
---|
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.
|
Constructor and Description |
---|
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) |
Modifier and Type | Method and Description |
---|---|
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.
|
Constructor and Description |
---|
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) |
Constructor and Description |
---|
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) |
Modifier and Type | Method and Description |
---|---|
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.
|
Constructor and Description |
---|
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) |
Modifier and Type | Method and Description |
---|---|
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.
|
Constructor and Description |
---|
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) |
Constructor and Description |
---|
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) |
Modifier and Type | Method and Description |
---|---|
Environment<?,C,O,P,?,?,?,?,?,CT,?,?> |
OCLHelper.getEnvironment()
|
Modifier and Type | Method and Description |
---|---|
<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> |
EnvironmentRegistryImpl.getEnvironmentFor(OCLExpression<C> expression) |
Modifier and Type | Method and Description |
---|---|
void |
EnvironmentRegistryImpl.deregisterEnvironment(Environment<?,?,?,?,?,?,?,?,?,?,?,?> environment) |
void |
EnvironmentRegistryImpl.registerEnvironment(Environment<?,?,?,?,?,?,?,?,?,?,?,?> environment) |
Constructor and Description |
---|
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) |
Modifier and Type | Method and Description |
---|---|
protected Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
OCLSyntaxHelper.getEnvironment() |
Modifier and Type | Method and Description |
---|---|
static <PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
HelperUtil.getConstraintContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
java.lang.Object element,
OCLExpression<C> expr) |
Constructor and Description |
---|
OCLSyntaxHelper(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env) |
Modifier and Type | Method and Description |
---|---|
static <T> T |
ParsingOptions.getValue(Environment<?,?,?,?,?,?,?,?,?,?,?,?> env,
Option<T> option)
Obtains the value of the specified option's setting in the the given
environment's options map, adapting the environment as necessary to the
Customizable API. |
static <C> Option<C> |
ParsingOptions.implicitRootClass(Environment<?,C,?,?,?,?,?,?,?,?,?,?> env)
A parsing option specifying a class that's assumed to be the implicit
root of the subject model's class hierarchy.
|
static <T> void |
ParsingOptions.setOption(Environment<?,?,?,?,?,?,?,?,?,?,?,?> env,
Option<T> option,
T value)
Add an option to apply to the specified environment, adapting it as
necessary to the
Customizable API. |
Modifier and Type | Field and Description |
---|---|
protected Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
ValidationVisitor.env |
Modifier and Type | Method and Description |
---|---|
protected Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
AbstractOCLAnalyzer.classifierContextDeclCS(ClassifierContextDeclCS classifierContextDeclCS,
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
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
|
Modifier and Type | Method and Description |
---|---|
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> |
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 enumLiteralExpCS,
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
|
Constructor and Description |
---|
OCLAnalyzer(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> environment)
Construct an OCL semantic analyzer with default syntactic and lexical
parsers all operating within a given environment.
|
OCLAnalyzer(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> environment,
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.
|
Modifier and Type | Method and Description |
---|---|
Environment<?,?,?,?,?,?,?,?,?,?,?,?> |
OCLBacktrackingLexer.getOCLEnvironment() |
Environment<?,?,?,?,?,?,?,?,?,?,?,?> |
OCLBacktrackingParser.getOCLEnvironment() |
Constructor and Description |
---|
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) |
Modifier and Type | Class and Description |
---|---|
class |
UMLEnvironment
Implementation of the
Environment for parsing OCL expressions on UML
models. |
Modifier and Type | Method and Description |
---|---|
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) |
Modifier and Type | Method and Description |
---|---|
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) |
Constructor and Description |
---|
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.
|
Modifier and Type | Method and Description |
---|---|
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) |
Modifier and Type | Method and Description |
---|---|
static <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.
|
Modifier and Type | Method and Description |
---|---|
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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.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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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. |
Constructor and Description |
---|
ToStringVisitor(Environment<?,C,O,P,EL,PM,S,COA,SSA,CT,?,?> env)
Initializes me with my environment.
|