/** * Creates/obtains the {@link OCLFactory} that I use to create OCL AST * elements. * * @param env * my OCL environment * * @return an appropriate factory */ protected OCLFactory createOCLFactory( Environment<PK, C, O, P, EL, PM, S, COA, SSA, CT, CLS, E> env) { return env.getOCLFactory(); }
/** * Creates/obtains the {@link OCLFactory} that I use to create OCL AST * elements. * * @param env * my OCL environment * * @return an appropriate factory */ protected OCLFactory createOCLFactory( Environment<PK, C, O, P, EL, PM, S, COA, SSA, CT, CLS, E> env) { return env.getOCLFactory(); }
/** * @since 3.1 */ public OCLFactoryWithHistory createOCLFactoryWithHistory( Environment<EPackage, EClassifier, EOperation, EStructuralFeature, EEnumLiteral, EParameter, EObject, CallOperationAction, SendSignalAction, Constraint, EClass, EObject> env) { return new OCLFactoryWithHistory(env.getOCLFactory()); }
/** * @since 3.1 */ public OCLFactoryWithHistory createOCLFactoryWithHistory( Environment<PK, C, O, P, EL, PM, S, COA, SSA, CT, CLS, E> env) { return new OCLFactoryWithHistory(env.getOCLFactory()); }
/** * @since 3.1 */ public OCLFactoryWithHistory createOCLFactoryWithHistory( Environment<PK, C, O, P, EL, PM, S, COA, SSA, CT, CLS, E> env) { return new OCLFactoryWithHistory(env.getOCLFactory()); }
/** * Initializes me with a resource in which I will persist the model-based * types that I generate in my associated {@link Environment}. * * @param env my environment * @param resource my resource */ public AbstractTypeResolver( Environment<PK, C, O, P, ?, PM, ?, ?, ?, ?, ?, ?> env, Resource resource) { this.env = env; this.resource = resource; oclFactory = env.getOCLFactory(); uml = env.getUMLReflection(); }
/** * Initializes me with a resource in which I will persist the model-based * types that I generate in my associated {@link Environment}. * * @param env my environment * @param resource my resource */ public AbstractTypeResolver( Environment<PK, C, O, P, ?, PM, ?, ?, ?, ?, ?, ?> env, Resource resource) { this.env = env; this.resource = resource; oclFactory = env.getOCLFactory(); uml = env.getUMLReflection(); }
/** * Initializes me with my environment. * * @param env * my environment */ public AbstractTypeChecker( Environment<?, C, O, P, ?, PM, ?, ?, ?, ?, ?, ?> env) { super(); this.env = env; uml = env.getUMLReflection(); oclFactory = env.getOCLFactory(); stdlib = env.getOCLStandardLibrary(); }
/** * Helper for the {@link #getResultTypeOf(Environment, Object, int, List)} * dealing with the {@link TypeType}s. */ private static <PK, C, O, P, EL, PM, ST, COA, SSA, CT, CLS, E> C getTypeTypeResultTypeOf( Object problemObject, Environment<PK, C, O, P, EL, PM, ST, COA, SSA, CT, CLS, E> env, TypeType<C, O> typeType, int opcode, List<? extends TypedElement<C>> args) { switch (opcode) { case ALL_INSTANCES : return getSetType(env, env.getOCLFactory(), typeType .getReferredType()); } @SuppressWarnings("unchecked") C sourceType = (C) typeType; return getAnyTypeResultTypeOf(problemObject, env, sourceType, opcode, args); }
/** * Helper for the {@link #getResultTypeOf(Environment, Object, int, List)} * dealing with the {@link TypeType}s. */ private static <PK, C, O, P, EL, PM, ST, COA, SSA, CT, CLS, E> C getTypeTypeResultTypeOf( Object problemObject, Environment<PK, C, O, P, EL, PM, ST, COA, SSA, CT, CLS, E> env, TypeType<C, O> typeType, int opcode, List<? extends TypedElement<C>> args) { switch (opcode) { case ALL_INSTANCES : return getSetType(env, env.getOCLFactory(), typeType .getReferredType()); } @SuppressWarnings("unchecked") C sourceType = (C) typeType; return getAnyTypeResultTypeOf(problemObject, env, sourceType, opcode, args); }
/** * Initializes me with my environment. * * @param ocl the OCL environment */ OCLHelperImpl(OCL<PK, C, O, P, EL, PM, S, COA, SSA, CT, CLS, E> ocl) { this.ocl = ocl; uml = ocl.getEnvironment().getUMLReflection(); oclFactory = ocl.getEnvironment().getOCLFactory(); environmentFactory = ocl.getEnvironment().getFactory(); }
/** * Initializes me with my environment. * * @param ocl the OCL environment */ OCLHelperImpl(OCL<PK, C, O, P, EL, PM, S, COA, SSA, CT, CLS, E> ocl) { this.ocl = ocl; uml = ocl.getEnvironment().getUMLReflection(); oclFactory = ocl.getEnvironment().getOCLFactory(); environmentFactory = ocl.getEnvironment().getFactory(); }
private static <PK, C, O, P, EL, PM, ST, COA, SSA, CT, CLS, E> EList<Variable<C, PM>> createTupleParts( Environment<PK, C, O, P, EL, PM, ST, COA, SSA, CT, CLS, E> env, C firstType, C secondType) { EList<Variable<C, PM>> result = new BasicEList<Variable<C, PM>>(); UMLReflection<PK, C, O, P, EL, PM, ?, COA, SSA, CT> uml = env .getUMLReflection(); OCLFactory oclFactory = env.getOCLFactory(); Variable<C, PM> var = oclFactory.createVariable(); uml.setName(var, PRODUCT_FIRST); uml.setType(var, firstType); result.add(var); var = oclFactory.createVariable(); uml.setName(var, PRODUCT_SECOND); uml.setType(var, secondType); result.add(var); return result; }
private static <PK, C, O, P, EL, PM, ST, COA, SSA, CT, CLS, E> EList<Variable<C, PM>> createTupleParts( Environment<PK, C, O, P, EL, PM, ST, COA, SSA, CT, CLS, E> env, C firstType, C secondType) { EList<Variable<C, PM>> result = new BasicEList<Variable<C, PM>>(); UMLReflection<PK, C, O, P, EL, PM, ?, COA, SSA, CT> uml = env .getUMLReflection(); OCLFactory oclFactory = env.getOCLFactory(); Variable<C, PM> var = oclFactory.createVariable(); uml.setName(var, PRODUCT_FIRST); uml.setType(var, firstType); result.add(var); var = oclFactory.createVariable(); uml.setName(var, PRODUCT_SECOND); uml.setType(var, secondType); result.add(var); return result; }
/** * Initializes me with my environment. * * @param env * my environment */ public AbstractTypeChecker( Environment<?, C, O, P, ?, PM, ?, ?, ?, ?, ?, ?> env) { super(); this.env = env; uml = env.getUMLReflection(); oclFactory = env.getOCLFactory(); stdlib = env.getOCLStandardLibrary(); C optionValue = ParsingOptions.getValue(env, ParsingOptions.implicitRootClass(env)); // check that, if there is a value for this option, it is a class if ((optionValue != null) && !uml.isClass(optionValue)) { implicitRootClass = null; } else { implicitRootClass = optionValue; } }
private static <PK, C, O, P, EL, PM, ST, COA, SSA, CT, CLS, E> List<O> createAnyOperations( Environment<PK, C, O, P, EL, PM, ST, COA, SSA, CT, CLS, E> env) { List<O> result = new java.util.ArrayList<O>(ANY_OPERATION_COUNT); OCLStandardLibrary<C> stdlib = env.getOCLStandardLibrary(); UMLReflection<PK, C, O, P, EL, PM, ?, COA, SSA, CT> uml = env .getUMLReflection(); result.add(createBinaryOperation(uml, stdlib.getBoolean(), EQUAL_NAME, stdlib.getOclAny(), "object")); //$NON-NLS-1$ result.add(createBinaryOperation(uml, stdlib.getBoolean(), NOT_EQUAL_NAME, stdlib.getOclAny(), "object")); //$NON-NLS-1$ result.add(createBinaryOperation(uml, stdlib.getT(), OCL_AS_TYPE_NAME, stdlib.getOclType(), "typespec")); //$NON-NLS-1$ result.add(createBinaryOperation(uml, stdlib.getBoolean(), OCL_IS_KIND_OF_NAME, stdlib.getOclType(), "typespec"));//$NON-NLS-1$ result.add(createBinaryOperation(uml, stdlib.getBoolean(), OCL_IS_TYPE_OF_NAME, stdlib.getOclType(), "typespec"));//$NON-NLS-1$ result.add(createUnaryOperation(uml, stdlib.getBoolean(), OCL_IS_UNDEFINED_NAME)); result.add(createUnaryOperation(uml, stdlib.getBoolean(), OCL_IS_INVALID_NAME)); result.add(createUnaryOperation(uml, stdlib.getBoolean(), OCL_IS_NEW_NAME)); result.add(createBinaryOperation(uml, stdlib.getBoolean(), OCL_IS_IN_STATE_NAME, stdlib.getState(), "statespec")); //$NON-NLS-1$ result.add(createUnaryOperation(uml, stdlib.getString(), TO_STRING_NAME)); OCLFactory oclFactory = env.getOCLFactory(); result.add(createUnaryOperation(uml, getSetType(env, oclFactory, stdlib.getT()), OCL_AS_SET_NAME)); return result; }
public Environment<PK, C, O, P, EL, PM, S, COA, SSA, CT, CLS, E> 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> result = createEnvironment(parent); // in case it corresponds to an OCL primitive type UMLReflection<PK, C, O, P, EL, PM, S, COA, SSA, CT> uml = parent.getUMLReflection(); context = uml.asOCLType(context); Variable<C, PM> self = parent.getOCLFactory().createVariable(); uml.setName(self, Environment.SELF_VARIABLE_NAME); uml.setType(self, context); result.addElement(self.getName(), self, true); result.setSelfVariable(self); return result; }
public Environment<PK, C, O, P, EL, PM, S, COA, SSA, CT, CLS, E> 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> result = createEnvironment(parent); // in case it corresponds to an OCL primitive type UMLReflection<PK, C, O, P, EL, PM, S, COA, SSA, CT> uml = parent.getUMLReflection(); context = uml.asOCLType(context); Variable<C, PM> self = parent.getOCLFactory().createVariable(); uml.setName(self, Environment.SELF_VARIABLE_NAME); uml.setType(self, context); result.addElement(self.getName(), self, true); result.setSelfVariable(self); return result; }
public Environment<PK, C, O, P, EL, PM, S, COA, SSA, CT, CLS, E> 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> result = createEnvironment(parent); if (result instanceof AbstractEnvironment<?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?>) { ((AbstractEnvironment<PK, C, O, P, EL, PM, S, COA, SSA, CT, CLS, E>) result) .setContextOperation(operation); } UMLReflection<PK, C, O, P, EL, PM, S, COA, SSA, CT> uml = parent.getUMLReflection(); OCLFactory oclFactory = parent.getOCLFactory(); for (PM next : parent.getUMLReflection().getParameters(operation)) { // ensure that we use the OCL primitive types wherever possible Variable<C, PM> var = oclFactory.createVariable(); uml.setName(var, uml.getName(next)); uml.setType(var, TypeUtil.resolveType(result, uml.getOCLType(next))); var.setRepresentedParameter(next); result.addElement(var.getName(), var, true); } return result; }
public Environment<PK, C, O, P, EL, PM, S, COA, SSA, CT, CLS, E> 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> result = createEnvironment(parent); if (result instanceof AbstractEnvironment<?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?>) { ((AbstractEnvironment<PK, C, O, P, EL, PM, S, COA, SSA, CT, CLS, E>) result) .setContextOperation(operation); } UMLReflection<PK, C, O, P, EL, PM, S, COA, SSA, CT> uml = parent.getUMLReflection(); OCLFactory oclFactory = parent.getOCLFactory(); for (PM next : parent.getUMLReflection().getParameters(operation)) { // ensure that we use the OCL primitive types wherever possible Variable<C, PM> var = oclFactory.createVariable(); uml.setName(var, uml.getName(next)); uml.setType(var, TypeUtil.resolveType(result, uml.getOCLType(next))); var.setRepresentedParameter(next); result.addElement(var.getName(), var, true); } return result; }