private String getClassName(Classifier clazz) { String className = clazz.getName(); return className; }
/** * Get full package name. * * @param clazz * UML2 classifier * @param sourceDirectoryPackageName * from the stereotype * @return full package name */ public String getFullPackageName(Classifier clazz, String sourceDirectoryPackageName) { // Get package until the beginning of SourceDirectory logger.log(Level.FINE, "Qualified name: " + clazz.getQualifiedName()); // Remove the sourceDirectoryPackageName String toBeDeleted = sourceDirectoryPackageName + "::"; String fullPackageName = clazz.getQualifiedName().replaceFirst( toBeDeleted, ""); // Remove class name toBeDeleted = "::" + clazz.getName(); fullPackageName = fullPackageName.replaceFirst(toBeDeleted, ""); // Change :: to . fullPackageName = fullPackageName.replaceAll("::", "."); logger.log(Level.FINE, "Real package name: " + fullPackageName); return fullPackageName; }
/** * @see org.andromda.metafacades.uml.GeneralizableElementFacade#getGeneralizationLinks() */ @Override protected Collection<Generalization> handleGetGeneralizationLinks() { return ((Classifier)this.metaObject).getGeneralizations(); }
protected void mergeClassifier_IsAbstract( Classifier receivingClassifier, Classifier mergedClassifier) { receivingClassifier.setIsAbstract(receivingClassifier.isAbstract() && mergedClassifier.isAbstract()); }
/** * <!-- begin-user-doc --> * <!-- end-user-doc --> * <!-- begin-model-doc --> * The query isTemplate() returns whether this templateable element is actually a template. * result = oclAsType(TemplatableElement).isTemplate() or general->exists(g | g.isTemplate()) * @param classifier The receiving '<em><b>Classifier</b></em>' model object. * <!-- end-model-doc --> * @generated NOT */ public static boolean isTemplate(Classifier classifier) { if (classifier.getOwnedTemplateSignature() == null) { for (Classifier parent : classifier.allParents()) { if (parent.getOwnedTemplateSignature() != null) { return true; } } return false; } return true; }
public static void getAllAssociationsFromGenerals(Classifier classifier, Set<Association> result) { result.addAll(classifier.getAssociations()); for (Classifier general : classifier.getGenerals()) { getAllAssociationsFromGenerals(general, result); } }
private List<String> convertClassifierHierarchy(List<Classifier> generals) { List<String> result = new ArrayList<String>(); for (Classifier c : generals) { String qualifiedName = c.getQualifiedName(); int indexOfModel = qualifiedName.indexOf("::"); qualifiedName = qualifiedName.substring(indexOfModel + 2); result.add(qualifiedName); } return result; }
EList<Property> constructorProperties = clazz.getAttributes(); for (Property constructorProperty : constructorProperties) { Type constructorType = constructorProperty.getType(); "Class: " + clazz.getName() + " - " + "Constructor property: " + constructorProperty.getName() + " - "
/** * Generate the inheritance for the Interface "extends". * * @param clazz * the UML class * @param ast * the JDT Java AST * @param td * TypeDeclaration JDT */ @SuppressWarnings("unchecked") private void generateClassInheritance(Classifier clazz, AST ast, TypeDeclaration td) { EList<Generalization> generalizations = clazz.getGeneralizations(); if (generalizations != null) { for (Generalization generalization : generalizations) { Classifier interfaceClassifier = generalization.getGeneral(); String fullQualifiedInterfaceName = interfaceClassifier .getQualifiedName(); Name name = jdtHelper.createFullQualifiedTypeAsName(ast, fullQualifiedInterfaceName, sourceDirectoryPackageName); SimpleType simpleType = ast.newSimpleType(name); td.superInterfaceTypes().add(simpleType); } } }
for (Classifier parent : classifier.getGenerals()) LOGGER.debug("isAssociationEndAttachedToType " + classifier.getQualifiedName() + ' ' + property + ' ' + property.getQualifiedName() + ' ' + property.getAssociation() + ' ' + property.getAssociationEnd() + ' ' + attachedToType);
&& (classifier.getQualifiedName().equals(UmlgRestletGenerationUtil.rootQueryQualifiedName))) { tryStatement.getTryPart().addToStatements("json.append(\", \\\"oclExecuteUri\\\": \\\"/" + classifier.getModel().getName() + "/oclExecuteQuery\\\"\")");
private static void getGeneralizationHierarchy(List<Classifier> hierarchy, Classifier clazz) { List<Classifier> generals = clazz.getGenerals(); if (generals.size() > 1) { throw new IllegalStateException( String.format("Multiple inheritance is not supported! Class %s has more than on generalization.", clazz.getName())); } if (!generals.isEmpty()) { hierarchy.add(generals.get(0)); getGeneralizationHierarchy(hierarchy, generals.get(0)); } } }
@Override public Object caseClassifier(Classifier classifier) { setName(eNamedElement, packages.contains(classifier .getPackage()) ? classifier.getName() : getQualifiedName(classifier, "_"), true); //$NON-NLS-1$ return classifier; }
/** * @see org.andromda.metafacades.emf.uml22.ModelElementFacadeLogicImpl#handleIsTemplateParametersPresent() */ protected boolean handleIsTemplateParametersPresent() { if (this.metaObject.getOwnedTemplateSignature()==null || this.metaObject.getOwnedTemplateSignature().getOwnedParameters()==null) { return false; } return !this.metaObject.getOwnedTemplateSignature().getOwnedParameters().isEmpty(); }
/** * <p> * Indicates if this classifier is 'abstract'. * </p> * @see org.andromda.metafacades.uml.ClassifierFacade#isAbstract() */ @Override protected boolean handleIsAbstract() { return this.metaObject.isAbstract(); }
Classifier classifier = (Classifier) resultingEObject; EList<Generalization> generalizations = classifier .getGeneralizations(); .allParents();
@Override @VisitSubclasses({Interface.class, Class.class, AssociationClass.class}) public void visitBefore(Classifier classifier) { if (classifier instanceof Interface || classifier instanceof org.eclipse.uml2.uml.Class) { OJPackage ojPackage = new OJPackage(Namer.name(classifier.getNearestPackage())); OJAnnotatedClass annotatedClass = new OJAnnotatedClass(getServerResourceImplName(classifier)); annotatedClass.setSuperclass(UmlgRestletGenerationUtil.ServerResource); annotatedClass.setMyPackage(ojPackage); annotatedClass.setVisibility(UmlgClassOperations.getVisibility(classifier.getVisibility())); addToSource(annotatedClass); addDefaultConstructor(annotatedClass); //Interfaces and abstract classes can not have a get put or delete if (!(classifier instanceof Interface) && !classifier.isAbstract()) { addPrivateIdVariable(classifier, annotatedClass); addGetRepresentation((Class) classifier, annotatedClass); addPutRepresentation((Class) classifier, annotatedClass); addDeleteRepresentation((Class) classifier, annotatedClass); } //OPTIONS apply to abstract classes and interfaces addOptionsRepresentation(classifier, annotatedClass); addToRouterEnum(classifier, annotatedClass); } }
protected static Collection<Property> findValidSubsets( Collection<Property> subsettedProperties, Property subsettingProperty, final String name, Classifier subsettingContext) { Property subsettedProperty = (Property) findEObject(subsettingContext .getAttributes(), new EClassMatcher(subsettingProperty) { @Override public boolean matches(EObject otherEObject) { if (super.matches(otherEObject)) { Property otherProperty = (Property) otherEObject; return eObject != otherProperty && safeEquals(otherProperty.getName(), name) && isSubsetValid((Property) eObject, otherProperty); } return false; } }); if (subsettedProperty == null) { for (Classifier general : subsettingContext.getGenerals()) { findValidSubsets(subsettedProperties, subsettingProperty, name, general); } } else { subsettedProperties.add(subsettedProperty); } return subsettedProperties; }
public static Set<Property> getAllOwnedPropertiesIncludingRefinedAssociationMemberEnds(org.eclipse.uml2.uml.Classifier clazz) { Set<Property> result = new HashSet<>(clazz.getAttributes()); List<Association> associations = clazz.getAssociations(); for (Association association : associations) { List<Property> memberEnds = association.getMemberEnds(); //For the case of an association to itself both ends are owned. //In particular to generate the collection initialization if (memberEnds.get(0).getType().equals(clazz) && memberEnds.get(1).getType().equals(clazz)) { result.addAll(memberEnds); } else { for (Property property : memberEnds) { if (property.getType() != clazz) { result.add(property); } } } } if (clazz instanceof Class) { result.addAll(getPropertiesOnRealizedInterfaces((Class)clazz)); } return result; }
/** * Generate the attributes. * * @param clazz * UML2 class * @param ast * JDT AST * @param ed * EnumerationDeclaration */ @SuppressWarnings("unchecked") public void generateAttributes(Classifier clazz, AST ast, EnumDeclaration ed) { EList<Property> properties = clazz.getAttributes(); for (Property property : properties) { ed.bodyDeclarations().add(generateAttribute(clazz, ast, property)); } }