Package | Description |
---|---|
org.eclipse.ocl |
Definition of the extensible environment API for OCL parsing and evaluation.
|
org.eclipse.ocl.ecore |
Implementation of an OCL binding for the Ecore metamodel.
|
org.eclipse.ocl.ecore.internal.helper | |
org.eclipse.ocl.ecore.parser | |
org.eclipse.ocl.helper |
Definition of the OCL Helper API for syntax completion support and a simplified
parsing model for embedded OCL constraints and expressions.
|
org.eclipse.ocl.internal | |
org.eclipse.ocl.internal.evaluation | |
org.eclipse.ocl.internal.helper | |
org.eclipse.ocl.options | |
org.eclipse.ocl.parser | |
org.eclipse.ocl.parser.backtracking | |
org.eclipse.ocl.uml |
Implementation of an OCL binding for the UML metamodel.
|
org.eclipse.ocl.uml.internal | |
org.eclipse.ocl.util |
Miscellaneous utilities in support of the OCL parser and environment
implementations.
|
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> |
EnvironmentFactory.createAttributeContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent,
P property)
Creates an environment suitable for parsing OCL expressions on the
specified
property , which is some attribute
in the client's metamodel. |
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
AbstractEnvironmentFactory.createAttributeContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent,
P property) |
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
EnvironmentFactory.createClassifierContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent,
C context)
Creates an environment suitable for parsing OCL expressions in the
specified
context , which is some classifier
in the client's model. |
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
AbstractEnvironmentFactory.createClassifierContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent,
C context) |
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
EnvironmentFactory.createEnvironment()
Creates a root environment, in which package contexts and/or classifier
contexts will be created as nested environments.
|
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
EnvironmentFactory.createEnvironment(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent)
Creates a child environment of a specified
parent , for
definition of nested scopes. |
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
EnvironmentFactory.createInstanceContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent,
Object context)
Creates an environment suitable for parsing OCL expressions on the
specified
context object, which is an instance of some
classifier in the client's model. |
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
AbstractEnvironmentFactory.createInstanceContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent,
Object context) |
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
EnvironmentFactory.createOperationContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent,
O operation)
Creates an environment suitable for parsing OCL expressions on the
specified
operation , which is some operation
in the client's metamodel. |
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
AbstractEnvironmentFactory.createOperationContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent,
O operation) |
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
EnvironmentFactory.createPackageContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent,
List<String> pathname)
Creates an environment suitable for parsing OCL expressions in the
specified package context.
|
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
AbstractEnvironmentFactory.createPackageContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent,
List<String> pathname) |
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
AbstractEvaluationVisitor.getEnvironment() |
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
OCL.getEnvironment()
Obtains the OCL parsing environment.
|
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
EvaluationVisitorDecorator.getEnvironment()
Obtains my delegate's environment.
|
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
EvaluationVisitor.getEnvironment()
Obtains the environment that provides the metamodel semantics for the
expression to be evaluated.
|
<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
Environment.Registry.getEnvironmentFor(Object abstractSyntaxElement)
Obtains a suitable environment for introspection of the specified
model element, type (such as a collection type), or other abstract
syntax element (e.g., a variable).
|
<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
Environment.Registry.getEnvironmentFor(OCLExpression<C> expression)
Obtains a suitable environment for introspection of the specified
expression.
|
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
Environment.getParent()
Obtains my parent environment, if I have one.
|
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
EnvironmentFactory.loadEnvironment(Resource resource)
Loads an environment from the specified resource.
|
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
EnvironmentFactory.Lookup.tryCreatePackageContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent,
List<String> pathname)
Creates an environment suitable for parsing OCL expressions in the
specified package context.
|
Modifier and Type | Method and Description |
---|---|
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
EnvironmentFactory.createAttributeContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent,
P property)
Creates an environment suitable for parsing OCL expressions on the
specified
property , which is some attribute
in the client's metamodel. |
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
AbstractEnvironmentFactory.createAttributeContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent,
P property) |
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
EnvironmentFactory.createClassifierContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent,
C context)
Creates an environment suitable for parsing OCL expressions in the
specified
context , which is some classifier
in the client's model. |
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
AbstractEnvironmentFactory.createClassifierContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent,
C context) |
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
EnvironmentFactory.createEnvironment(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent)
Creates a child environment of a specified
parent , for
definition of nested scopes. |
EvaluationVisitor<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
EnvironmentFactory.createEvaluationVisitor(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
EvaluationEnvironment<C,O,P,CLS,E> evalEnv,
Map<? extends CLS,? extends Set<? extends E>> extentMap)
Creates a new evaluation visitor, for the evaluation of OCL expressions.
|
EvaluationVisitor<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
AbstractEnvironmentFactory.createEvaluationVisitor(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
EvaluationEnvironment<C,O,P,CLS,E> evalEnv,
Map<? extends CLS,? extends Set<? extends E>> extentMap) |
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
EnvironmentFactory.createInstanceContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent,
Object context)
Creates an environment suitable for parsing OCL expressions on the
specified
context object, which is an instance of some
classifier in the client's model. |
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
AbstractEnvironmentFactory.createInstanceContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent,
Object context) |
OCLAnalyzer<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
EnvironmentFactory.createOCLAnalyzer(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> environment,
String input)
Creates an instance of the OCLAnalyzer that analyzes the
given input on behalf of this environment.
|
OCLAnalyzer<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
AbstractEnvironmentFactory.createOCLAnalyzer(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
String input) |
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.
|
OCLFactoryWithHistory |
AbstractEnvironmentFactory.createOCLFactoryWithHistory(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.
|
OCLSyntaxHelper |
AbstractEnvironmentFactory.createOCLSyntaxHelper(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env) |
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
EnvironmentFactory.createOperationContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent,
O operation)
Creates an environment suitable for parsing OCL expressions on the
specified
operation , which is some operation
in the client's metamodel. |
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
AbstractEnvironmentFactory.createOperationContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent,
O operation) |
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
EnvironmentFactory.createPackageContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent,
List<String> pathname)
Creates an environment suitable for parsing OCL expressions in the
specified package context.
|
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
AbstractEnvironmentFactory.createPackageContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent,
List<String> pathname) |
Visitor<Boolean,C,O,P,EL,PM,S,COA,SSA,CT> |
EnvironmentFactory.createValidationVisitor(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> environment)
Obtains an instance of the validation visitor that validates against the
specified environment, which presumably was used in parsing the OCL in
the first place.
|
Visitor<Boolean,C,O,P,EL,PM,S,COA,SSA,CT> |
AbstractEnvironmentFactory.createValidationVisitor(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env) |
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,
List<String> pathname)
Creates an environment suitable for parsing OCL expressions in the
specified package context.
|
Constructor and Description |
---|
AbstractTypeChecker(Environment<?,C,O,P,?,PM,?,?,?,?,?,?> env)
Initializes me with my environment.
|
AbstractTypeResolver(Environment<PK,C,O,P,?,PM,?,?,?,?,?,?> env)
Initializes me with an environment.
|
AbstractTypeResolver(Environment<PK,C,O,P,?,PM,?,?,?,?,?,?> env,
Resource resource)
Initializes me with a resource in which I will persist the model-based
types that I generate in my associated
Environment . |
EvaluationVisitorImpl(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
EvaluationEnvironment<C,O,P,CLS,E> evalEnv,
Map<? extends CLS,? extends Set<? extends E>> extentMap)
Constructor
|
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<EPackage,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint,EClass,EObject> |
EcoreEnvironmentFactory.createEnvironment() |
Environment<EPackage,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint,EClass,EObject> |
EcoreEnvironmentFactory.createEnvironment(Environment<EPackage,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint,EClass,EObject> parent) |
Environment<EPackage,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint,EClass,EObject> |
EcoreEnvironmentFactory.loadEnvironment(Resource resource) |
Modifier and Type | Method and Description |
---|---|
Environment<EPackage,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint,EClass,EObject> |
EcoreEnvironmentFactory.createEnvironment(Environment<EPackage,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint,EClass,EObject> parent) |
EvaluationVisitor<EPackage,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint,EClass,EObject> |
EcoreEnvironmentFactory.createEvaluationVisitor(Environment<EPackage,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint,EClass,EObject> env,
EvaluationEnvironment<EClassifier,EOperation,EStructuralFeature,EClass,EObject> evalEnv,
Map<? extends EClass,? extends Set<? extends EObject>> extentMap) |
OCLAnalyzer |
EcoreEnvironmentFactory.createOCLAnalyzer(Environment<EPackage,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint,EClass,EObject> env,
String input) |
OCLFactoryWithHistory |
EcoreEnvironmentFactory.createOCLFactoryWithHistory(Environment<EPackage,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint,EClass,EObject> env) |
OCLSyntaxHelper |
EcoreEnvironmentFactory.createOCLSyntaxHelper(Environment<EPackage,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint,EClass,EObject> env) |
Visitor<Boolean,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint> |
EcoreEnvironmentFactory.createValidationVisitor(Environment<EPackage,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint,EClass,EObject> env) |
static OCL |
OCL.newInstance(Environment<EPackage,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint,EClass,EObject> env)
Creates a new
OCL using the specified initial Ecore
environment. |
void |
EcoreEnvironment.setParent(Environment<EPackage,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint,EClass,EObject> env) |
Constructor and Description |
---|
EvaluationVisitorImpl(Environment<EPackage,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint,EClass,EObject> env,
EvaluationEnvironment<EClassifier,EOperation,EStructuralFeature,EClass,EObject> evalEnv,
Map<? extends EClass,? extends Set<? extends EObject>> extentMap) |
Constructor and Description |
---|
OCLSyntaxHelper(Environment<EPackage,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint,EClass,EObject> env) |
Constructor and Description |
---|
OCLAnalyzer(Environment<EPackage,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint,EClass,EObject> rootEnvironment,
String input) |
ValidationVisitor(Environment<EPackage,EClassifier,EOperation,EStructuralFeature,EEnumLiteral,EParameter,EObject,CallOperationAction,SendSignalAction,Constraint,EClass,EObject> environment) |
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(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,
Map<CLS,? extends Set<? extends E>> extentMap) |
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,
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 | Method and Description |
---|---|
Environment<?,?,?,?,?,?,?,?,?,?,?,?> |
OCLParser.getOCLEnvironment() |
Environment<?,?,?,?,?,?,?,?,?,?,?,?> |
OCLLexer.getOCLEnvironment() |
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
AbstractOCLAnalyzer.getOCLEnvironment() |
Modifier and Type | Method and Description |
---|---|
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.
|
Constructor and Description |
---|
OCLAnalyzer(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> environment)
Construct an OCL semantic analyzer with default syntactic and lexical
parsers all operating within a given environment.
|
OCLAnalyzer(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> environment,
String text)
Construct an OCL semantic analyzer with default syntactic and lexical
parsers all operating within a given environment.
|
OCLLexer(Environment<?,?,?,?,?,?,?,?,?,?,?,?> environment) |
OCLLexer(Environment<?,?,?,?,?,?,?,?,?,?,?,?> environment,
char[] chars) |
OCLLexer(Environment<?,?,?,?,?,?,?,?,?,?,?,?> environment,
char[] input_chars,
String filename,
int tab) |
OCLLexer(Environment<?,?,?,?,?,?,?,?,?,?,?,?> environment,
Reader reader,
String filename) |
ValidationVisitor(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> environment)
Initializes me to validate expressions in the specified environment.
|
Modifier and Type | Method and Description |
---|---|
Environment<?,?,?,?,?,?,?,?,?,?,?,?> |
OCLBacktrackingParser.getOCLEnvironment() |
Environment<?,?,?,?,?,?,?,?,?,?,?,?> |
OCLBacktrackingLexer.getOCLEnvironment() |
Constructor and Description |
---|
OCLBacktrackingLexer(Environment<?,?,?,?,?,?,?,?,?,?,?,?> environment) |
OCLBacktrackingLexer(Environment<?,?,?,?,?,?,?,?,?,?,?,?> environment,
char[] chars) |
OCLBacktrackingLexer(Environment<?,?,?,?,?,?,?,?,?,?,?,?> environment,
char[] input_chars,
String filename,
int tab) |
OCLBacktrackingLexer(Environment<?,?,?,?,?,?,?,?,?,?,?,?> environment,
Reader reader,
String filename) |
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<Package,Classifier,Operation,Property,EnumerationLiteral,Parameter,State,CallOperationAction,SendSignalAction,Constraint,Class,EObject> |
UMLEnvironmentFactory.createEnvironment(Environment<Package,Classifier,Operation,Property,EnumerationLiteral,Parameter,State,CallOperationAction,SendSignalAction,Constraint,Class,EObject> parent) |
Environment<Package,Classifier,Operation,Property,EnumerationLiteral,Parameter,State,CallOperationAction,SendSignalAction,Constraint,Class,EObject> |
UMLEnvironmentFactory.loadEnvironment(Resource resource) |
Modifier and Type | Method and Description |
---|---|
Environment<Package,Classifier,Operation,Property,EnumerationLiteral,Parameter,State,CallOperationAction,SendSignalAction,Constraint,Class,EObject> |
UMLEnvironmentFactory.createEnvironment(Environment<Package,Classifier,Operation,Property,EnumerationLiteral,Parameter,State,CallOperationAction,SendSignalAction,Constraint,Class,EObject> parent) |
static OCL |
OCL.newInstance(Environment<Package,Classifier,Operation,Property,EnumerationLiteral,Parameter,State,CallOperationAction,SendSignalAction,Constraint,Class,EObject> env)
Creates a new
OCL using the specified initial UML
environment. |
void |
UMLEnvironment.setParent(Environment<Package,Classifier,Operation,Property,EnumerationLiteral,Parameter,State,CallOperationAction,SendSignalAction,Constraint,Class,EObject> env) |
Modifier and Type | Method and Description |
---|---|
static Collection<Operation> |
OCLStandardLibraryImpl.createCollectionTypeOperations(Environment<?,Classifier,Operation,?,?,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(Object target,
Map<Object,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 Diagnostic |
OCLUtil.checkForErrors(Environment<?,?,?,?,?,?,?,?,?,?,?,?> env)
Checks whether the specified environment's problem handler has any
diagnostics of error severity or worse and, if so, throws a semantic
exception encapsulating these diagnostics.
|
static Diagnostic |
OCLUtil.checkForErrorsOrWarnings(Environment<?,?,?,?,?,?,?,?,?,?,?,?> env)
Checks whether the specified environment's problem handler has any
diagnostics of warnings severity or worse and, if so, throws a semantic
exception encapsulating these diagnostics.
|
static <PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
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(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(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,
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,
String name,
List<? extends TypedElement<C>> args)
Finds the most specific (re)definition of an operation by signature in the
specified classifier.
|
static <PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
TypeUtil.findSignalMatching(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
C receiver,
List<C> signals,
String name,
List<? extends TypedElement<C>> args)
Find a matching signal in the specified list.
|
static <T> T |
OCLUtil.getAdapter(Environment<?,?,?,?,?,?,?,?,?,?,?,?> env,
Class<T> adapterType)
Obtains an adapter for the specified interface type.
|
static <C> Collection<C> |
OCLStandardLibraryUtil.getAllSupertypes(Environment<?,C,?,?,?,?,?,?,?,?,?,?> env,
PredefinedType<?> type)
Queries all of the supertypes of a pre-defined type.
|
static <PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
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(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(Object problemObject,
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
C owner,
O operation,
List<? extends TypedElement<C>> args)
Obtains the effective result type of the specified operation, which may
or may not have parameters type by generic type variables.
|
static <PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> |
OCLStandardLibraryUtil.getResultTypeOf(Environment<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> env,
C sourceType,
int opcode,
List<? extends TypedElement<C>> args)
Deprecated.
Use the
OCLStandardLibraryUtil.getResultTypeOf(Object, Environment, Object, int, List)
method, instead, which doesn't fail on the first problem |
static <PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> |
OCLStandardLibraryUtil.getResultTypeOf(Object problemObject,
Environment<PK,C,O,P,EL,PM,ST,COA,SSA,CT,CLS,E> env,
C sourceType,
int opcode,
List<? extends TypedElement<C>> args)
Obtains the result type of the specified operation from the OCL Standard
Library.
|
static <PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
TypeUtil.isOclAnyOperation(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
O operation)
Queries whether an operation is defined by the OclAny type.
|
static <C> boolean |
TypeUtil.isStandardLibraryFeature(Environment<?,C,?,?,?,?,?,?,?,?,?,?> env,
C owner,
Object feature)
Queries whether the specified feature (operation or attribute), as
applied to a particular owner classifier, is defined by the
standard library or not (in which case it would, presumably, be
user-defined).
|
static <PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
TypeUtil.matchArgs(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
C owner,
List<?> paramsOrProperties,
List<? extends TypedElement<C>> args)
Compares an actual argument list against the signature of an operation
or a signal.
|
static <PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
CollectionUtil.product(EvaluationEnvironment<C,O,P,CLS,E> evalEnv,
Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
Collection<?> self,
Collection<?> c,
C tupleType)
Implementation of the OCL
Collection::product(c : Collection(T2)) : Set(Tuple(first : T, second : T2))
operations.
|
static <PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
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,
<any> parts)
Resolves a tuple type against the tuple types previously generated
and persisted in the environment.
|
static <PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> |
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. |
Copyright © 2005, 2018 IBM Corporation and others. All Rights Reserved.