protected Classifier createGenericType(EModelElement eModelElement, EGenericType eGenericType, EClassifier eClassifier) { Classifier genericType = eClassifier instanceof EDataType ? UMLFactory.eINSTANCE.createPrimitiveType() : UMLFactory.eINSTANCE.createClass(); for (EGenericType eTypeArgument : eGenericType.getETypeArguments()) { ETypeParameter eTypeParameter = eTypeArgument .getETypeParameter(); if (eTypeParameter != null) { eModelElement = eTypeParameter; break; } } getOwnedTypes(eModelElement).add(genericType); genericType.setName(getGenericTypeName(eGenericType)); if (options != null && !OPTION__IGNORE.equals(options .get(OPTION__ECORE_TAGGED_VALUES))) { processEcoreTaggedValues(genericType, eGenericType, options, diagnostics, context); } return genericType; }
@Override public CollectionType<Classifier, Operation> resolveCollectionType( CollectionKind kind, Classifier elementType) { CollectionType<Classifier, Operation> result = super.resolveCollectionType( kind, elementType); // ensure that the collection type's operations are correctly defined DataType umlResult = (DataType) result; Collection<Operation> ownedOperations = umlResult.getOwnedOperations(); if (ownedOperations.isEmpty()) { // first, add a token operation to ensure that the list is not // empty, avoiding unbounded recursion Operation token = UMLFactory.eINSTANCE.createOperation(); ownedOperations.add(token); try { ownedOperations.addAll(OCLStandardLibraryImpl.createCollectionTypeOperations( getEnvironment(), kind)); } finally { ownedOperations.remove(token); // remove the token } } return result; } }
@Override public Object caseEPackage(EPackage ePackage) { org.eclipse.uml2.uml.Package package_ = ePackage.getESuperPackage() == null ? UMLFactory.eINSTANCE.createModel() : UMLFactory.eINSTANCE.createPackage(); eModelElementToElementMap.put(ePackage, package_); if (!ePackages.contains(ePackage)) { EPackage eSuperPackage = ePackage.getESuperPackage(); if (eSuperPackage != null) { ((org.eclipse.uml2.uml.Package) doSwitch(eSuperPackage)) .getNestedPackages().add(package_); } } package_.setName(ePackage.getName()); defaultCase(ePackage); return package_; }
? (Classifier) UMLFactory.eINSTANCE.createInterface() : (ExtendedMetaData.INSTANCE.getSimpleFeature(eClass) == null ? (Classifier) UMLFactory.eINSTANCE.createClass() : (Classifier) UMLFactory.eINSTANCE.createDataType()); eModelElementToElementMap.put(eClass, classifier);
public Operation defineOperation(Classifier owner, String name, Classifier type, List<Variable<Classifier, Parameter>> params, Constraint constraint) { resetTypeCaches(); Operation result = UMLFactory.eINSTANCE.createOperation(); result.addKeyword(UMLReflection.OCL_HELPER); result.setName(name); result.setType(type == null ? getOCLStandardLibrary().getOclVoid() : type); result.setIsQuery(true); // OCL can only define queries for (Variable<Classifier, Parameter> next : params) { Parameter param = UMLFactory.eINSTANCE.createParameter(); param.setName(next.getName()); param.setType(next.getType() == null ? getOCLStandardLibrary() .getOclVoid() : next.getType()); param.setDirection(ParameterDirectionKind.IN_LITERAL); param.setEffect(ParameterEffectKind.READ_LITERAL); result.getOwnedParameters().add(param); } annotate(result, constraint); addHelperOperation(owner, result); return result; }
public Property createProperty(String name, Classifier resultType) { Property result = UMLFactory.eINSTANCE.createProperty(); result.setName(name); result.setType(resultType); return result; }
@Override protected Package createPackage(String name) { Package result = UMLFactory.eINSTANCE.createPackage(); result.setName(name); getResource().getContents().add(result); return result; }
@Override protected Class createShadowClass(Classifier type) { // the additional features may have invalid characters in their names Class result = UMLFactory.eINSTANCE.createClass(); result.setName(type.getName() + "_Class"); //$NON-NLS-1$ result.createSubstitution("realOwner", type); //$NON-NLS-1$ return result; }
@Override public Object caseEParameter(EParameter eParameter) { EOperation eOperation = eParameter.getEOperation(); if (eOperation != null) { Parameter parameter = UMLFactory.eINSTANCE.createParameter(); eModelElementToElementMap.put(eParameter, parameter); Operation operation = (Operation) doSwitch(eOperation); operation.getOwnedParameters().add(parameter); parameter.setName(eParameter.getName()); caseETypedElement(eParameter); defaultCase(eParameter); return parameter; } return super.caseEParameter(eParameter); }
public Constraint createConstraint() { return UMLFactory.eINSTANCE.createConstraint(); }
public CallOperationAction createCallOperationAction(Operation operation) { CallOperationAction result = UMLFactory.eINSTANCE.createCallOperationAction(); result.setOperation(operation); return result; }
association = UMLFactory.eINSTANCE.createAssociation();
.createClassifierTemplateParameter(); org.eclipse.uml2.uml.Class parameterableElement = (org.eclipse.uml2.uml.Class) templateParameter .createOwnedParameteredElement(UMLPackage.Literals.CLASS);
@Override public Object caseEAttribute(EAttribute eAttribute) { EClass eContainingClass = eAttribute.getEContainingClass(); if (eContainingClass != null) { Property property = UMLFactory.eINSTANCE.createProperty(); eModelElementToElementMap.put(eAttribute, property); Classifier classifier = (Classifier) doSwitch(eContainingClass); getOwnedAttributes(classifier).add(property); property.setName(eAttribute.getName()); property.setIsReadOnly(!eAttribute.isChangeable()); property.setIsDerived(eAttribute.isDerived()); property.setVisibility(VisibilityKind.PUBLIC_LITERAL); caseETypedElement(eAttribute); defaultCase(eAttribute); return property; } return super.caseEAttribute(eAttribute); }
stdlibPackage = org.eclipse.uml2.uml.UMLFactory.eINSTANCE.createPackage(); stdlibPackage.setName("oclstdlib"); //$NON-NLS-1$
public Property defineAttribute(Classifier owner, Variable<Classifier, Parameter> variable, Constraint constraint) { resetTypeCaches(); Property result; String name = variable.getName(); Classifier type = variable.getType(); result = UMLFactory.eINSTANCE.createProperty(); result.addKeyword(UMLReflection.OCL_HELPER); result.setName(name); result.setType(type); annotate(result, constraint); addHelperProperty(owner, result); return result; }
public Operation createOperation(String name, Classifier resultType, List<String> paramNames, List<Classifier> paramTypes) { Operation result = UMLFactory.eINSTANCE.createOperation(); result.setName(name); // OCL can only define query operations result.setIsQuery(true); if (resultType != null) { result.setType(resultType); } int i = 0; for (String pname : paramNames) { result.createOwnedParameter(pname, paramTypes.get(i++)); } return result; }
Property property = UMLFactory.eINSTANCE.createProperty(); eModelElementToElementMap.put(eReference, property);
Operation operation = UMLFactory.eINSTANCE.createOperation(); eModelElementToElementMap.put(eOperation, operation);