@Override public EClass eClass() { if (eClass == null) { ePackage = EcoreFactory.eINSTANCE.createEPackage(); eClass = EcoreFactory.eINSTANCE.createEClass(); ePackage.getEClassifiers().add(eClass); eClass.setName("StringWrapper"); // $NON-NLS-1$ eClass.getESuperTypes().add(XMLTypePackage.eINSTANCE.getAnyType()); ExtendedMetaData.INSTANCE.setName(eClass, ""); // $NON-NLS-1$ eClass.setInstanceClass(AnyType.class); EAttribute eAttribute = EcoreFactory.eINSTANCE.createEAttribute(); eAttribute.setName("value"); // $NON-NLS-1$ eAttribute.setChangeable(true); eAttribute.setUnsettable(true); eAttribute.setEType(EcorePackage.eINSTANCE.getEClassifier("EString")); // $NON-NLS-1$ eClass.getEStructuralFeatures().add(eAttribute); // ExtendedMetaData.INSTANCE.setNamespace(eAttribute, ePackage.getNsURI()); ExtendedMetaData.INSTANCE.setFeatureKind(eAttribute, ExtendedMetaData.ATTRIBUTE_FEATURE); ExtendedMetaData.INSTANCE.setName(eAttribute, "value"); // $NON-NLS-1$ } return eClass; }
@Override public FeatureId getIdentifier() { // // Create id? // if (eID == null) { // // Get EMF id attribute // EAttribute eIDAttribute = eStructure().eIDAttribute(); // // Get feature id as string // String fid = (eIDAttribute == null || !eFeature().eIsSet(eIDAttribute) ? null : EcoreUtil.convertToString( eIDAttribute.getEAttributeType(), eFeature().eGet(eIDAttribute))); // // Create feature id instance // eID = new FeatureIdImpl(fid); } // // Finished // return eID; }
private void fillEAttribute(EObject container, JsonNode root) { final EClass eClass = container.eClass(); // Iterates over all key values of the JSON Object, // if the value is not an object then // if the key corresponds to an EAttribute, fill it // if not and the EClass contains a MapEntry, fill it with the key, value. for (Iterator<Entry<String, JsonNode>> it = root.getFields(); it.hasNext(); ) { Entry<String, JsonNode> field = it.next(); String key = field.getKey(); JsonNode value = field.getValue(); if (value.isObject()) // not an attribute continue; EAttribute attribute = getEAttribute(eClass, key); if (attribute != null && !attribute.isTransient() && !attribute.isDerived()) { if (value.isArray()) { for (Iterator<JsonNode> itValue = value.getElements(); itValue.hasNext(); ) { setEAttributeValue(container, attribute, itValue.next()); } } else { setEAttributeValue(container, attribute, value); } } else { EStructuralFeature eFeature = getDynamicMapEntryFeature(eClass); if (eFeature != null) { @SuppressWarnings("unchecked") EList<EObject> values = (EList<EObject>) container.eGet(eFeature); values.add(createEntry(key, value)); } } } }
@Override protected void bindAttribute( Composite parent, EObject object, EAttribute attribute, String label) { if ("independent".equals(attribute.getName())) { independentEditor = new BooleanObjectEditor(this, object, attribute); independentCheckbox = (Button) independentEditor.createControl(parent, label); if (waitForCompletionCheckbox != null && waitForCompletionCheckbox.getSelection() == false) { independentCheckbox.setEnabled(false); } } else if ("waitForCompletion".equals(attribute.getName())) { ObjectEditor editor = new BooleanObjectEditor(this, object, attribute); waitForCompletionCheckbox = (Button) editor.createControl(parent, label); waitForCompletionCheckbox.addSelectionListener( new SelectionListener() { @Override public void widgetSelected(SelectionEvent e) { boolean checked = waitForCompletionCheckbox.getSelection(); if (!checked) { independentCheckbox.setEnabled(false); independentEditor.setValue(Boolean.TRUE); } else { independentCheckbox.setEnabled(true); } } @Override public void widgetDefaultSelected(SelectionEvent e) {} }); if (waitForCompletionCheckbox.getSelection() == false) { if (independentCheckbox != null) independentCheckbox.setEnabled(false); } } else super.bindAttribute(parent, object, attribute, label); }
/** * Create an OCL condition from the given {@link Object} of type {@link EAttribute}.<br> * Subclasses may use information from the <code>eAttribute</code> to refine the condition. * * <p>Example:<br> * A String attribute called <code>foo</code> containing the value <code>"bar"</code> results in * the condition <code>self.foo = 'bar'</code> . * * @param eAttribute The type of the object. * @param obj The object for which the condition should be created. * @return An ocl condition which describes this object. */ protected String eAttributeToCondition(EAttribute eAttribute, Object obj) { final String prefix = ""; // "self."; if (obj instanceof List<?>) { // recursive call for lists :-) return prefix + eAttribute.getName() + "->asSequence() = " + listAttributeToString((List<?>) obj); } else if (obj instanceof Enum) { final Class<?> declaringClass = ((Enum<?>) obj).getDeclaringClass(); /* * the quotes " are required to escape keywords, e.g. VisibilityKind::"package". * if the quotes are missing, then the visibility 'package' collides with the ocl keyword 'package'. */ return prefix + eAttribute.getName() + " = " + declaringClass.getSimpleName() + "::\"" + ((Enum<?>) obj).toString() + "\""; } else if (obj == null) { // FIXME: unfortunately, the OCL implementation does not work with // OclVoid as null! workaround: create set and check if it is empty :o) return prefix + eAttribute.getName() + "->asSet()->isEmpty()"; } else { // handle primitive types return prefix + eAttribute.getName() + " = " + primitiveAttributeToString(obj); } }
@Override protected Object doExecute() throws Exception { final Map<String, SysConfig> sysConfigMap = appCtx.getBean("sysConfigMap", Map.class); if (sysConfigMap.isEmpty()) { System.err.println("No tenant SysConfigs found"); return null; } System.out.print(ansi().render("@|negative_on %3s|%-15s|@", "â„–", "Tenant ID")); final SysConfig first = sysConfigMap.values().iterator().next(); final List<EAttribute> attrs = new ArrayList<>(); for (EAttribute attr : first.eClass().getEAttributes()) { attrs.add(attr); System.out.print(ansi().render("@|negative_on |%-25s|@", attr.getName())); } System.out.println(); int i = 0; for (final Entry<String, SysConfig> entry : sysConfigMap.entrySet()) { SysConfig sysConfig = entry.getValue(); System.out.print(ansi().render("@|bold,black %3d||@%-15s", ++i, entry.getKey())); for (EAttribute attr : attrs) { System.out.print(ansi().render("@|bold,black ||@%-25s", sysConfig.eGet(attr))); } System.out.println(); } System.out.println(ansi().render("@|bold %d|@ tenant SysConfigs", i)); return null; }
@Override public void load() { Object value = getElementText(node); if (feature instanceof EAttribute) { EAttribute ea = (EAttribute) feature; value = EcoreUtil.createFromString(ea.getEAttributeType(), value.toString()); } modelObject.eSet(feature, value); }
@Override public Object caseEAttribute(EAttribute object) { Attribute attrib = new Attribute(object.getName()); attrib.type = getType(object.getEType()); attrib.setBounds(object.getLowerBound(), object.getUpperBound()); attrib.setStatic(false); attrib.setScope(Scope.PUBLIC); return attrib; }
protected void handleNotificationEvent(Notification event) { Object feature = event.getFeature(); if (feature instanceof EAttribute) { EAttribute attr = (EAttribute) feature; if ("name".equals(attr.getName())) { ((DisplayOutTypeFigure) this.getConnectionFigure()).refresh(); } } super.handleNotificationEvent(event); }
/** * This defines which attributes are used for building the OCL condition. The default * implementation uses only the primitive types contained in {@link * ElementSetReferenceCreator#PRIMITIVE_TYPES} and enumeration types. * * <p>Furthermore, all derived attributes are ignored. This is due to an issue with UML models. * * <p>Subclasses may override this to refine the set of types. * * @param eAttribute An {@link EAttribute} in the transformation. * @return <code>true</code>, if the attribute should be part of the condition; <code>false</code> * otherwise. */ protected boolean isRelevantAttribute(EAttribute eAttribute) { // is it an enumeration? if (eAttribute.getEType() instanceof EEnum) { return true; } // is it one of the supported primitive types? return PRIMITIVE_TYPES.contains(eAttribute.getEType().getInstanceClassName()) && !eAttribute.isDerived(); }
private static void checkObject( EObject expected, EObject actual, Set<EStructuralFeature> excludeFeatures, Set<EObject> visited) { if (expected == null) { assertThat(actual, is(nullValue())); return; } if (visited.contains(expected)) return; visited.add(expected); assertThat( "Actual instance for type '" + expected.eClass().getName() + "' must not be null", actual, is(notNullValue())); for (EAttribute attribute : expected.eClass().getEAllAttributes()) { if (!excludeFeatures.contains(attribute)) assertThat( "Attribute '" + attribute.getName() + "' on class '" + expected.eClass().getName() + "' did not match", actual.eGet(attribute), is(expected.eGet(attribute))); } for (EReference reference : expected.eClass().getEAllReferences()) { if (excludeFeatures.contains(reference)) continue; if (reference.isMany()) { @SuppressWarnings("unchecked") EList<EObject> expectedObjects = (EList<EObject>) expected.eGet(reference); @SuppressWarnings("unchecked") EList<EObject> actualObjects = (EList<EObject>) actual.eGet(reference); assertThat( "Reference size for '" + reference.getName() + "' does not match", actualObjects.size(), is(expectedObjects.size())); for (int i = 0; i < expectedObjects.size(); i++) checkObject(expectedObjects.get(i), actualObjects.get(i), excludeFeatures, visited); } else checkObject( (EObject) expected.eGet(reference), (EObject) actual.eGet(reference), excludeFeatures, visited); } }
public Object[] getDefaultValues(org.eclipse.emf.ecore.EAttribute attribute) { String typeName = attribute.getEType().getName(); if ("EString".equals(typeName)) { return new Object[] { "some" + ASPMM.resource.ASPMM.util.ASPMMStringUtil.capitalize(attribute.getName()) }; } if ("EBoolean".equals(typeName)) { return new Object[] {Boolean.TRUE, Boolean.FALSE}; } return new Object[] {attribute.getDefaultValue()}; }
/** * {@inheritDoc} * * @see org.eclipse.emf.compare.diff.merge.api.AbstractMerger#applyInOrigin() */ @Override public void applyInOrigin() { final AttributeChangeLeftTarget theDiff = (AttributeChangeLeftTarget) this.diff; final EObject origin = theDiff.getLeftElement(); final Object value = theDiff.getLeftTarget(); final EAttribute attr = theDiff.getAttribute(); try { EFactory.eRemove(origin, attr.getName(), value); } catch (FactoryException e) { EMFComparePlugin.log(e, true); } super.applyInOrigin(); }
/** * Returns true if we can set the given attribute with a "name" feature of an * instanciationInstruction. * * @param attribute the attribute to inspect * @return true if the given attribute is of type EString and is named 'name' or is an ID * attribute */ private static boolean isConcernedByNameAttribute(EAttribute attribute) { // Case 1 : true if the attribute is defined as ID and is of type EString boolean isConcernedByNameAttribute = attribute.isID() && ("EString".equals(attribute.getEAttributeType().getName())); // Case 2 : true if the attribute's name is "name" and is of type EString isConcernedByNameAttribute = isConcernedByNameAttribute || ("name".equals(attribute.getName()) && ("EString".equals(attribute.getEAttributeType().getName()))); return isConcernedByNameAttribute; }
public java.lang.Object[] getDefaultValues(org.eclipse.emf.ecore.EAttribute attribute) { String typeName = attribute.getEType().getName(); if ("EString".equals(typeName)) { return new java.lang.Object[] { "some" + west.twouse.language.sparqlas.resource.sparqlas.util.SparqlasStringUtil.capitalize( attribute.getName()) }; } if ("EBoolean".equals(typeName)) { return new java.lang.Object[] {Boolean.TRUE, Boolean.FALSE}; } return new java.lang.Object[] {attribute.getDefaultValue()}; }
public static void printAttributeValues(EObject object) { EClass eClass = object.eClass(); System.out.println(eClass.getName()); for (Iterator iter = eClass.getEAllAttributes().iterator(); iter.hasNext(); ) { EAttribute attribute = (EAttribute) iter.next(); Object value = object.eGet(attribute); System.out.print(" " + attribute.getName() + ": " + value); if (object.eIsSet(attribute)) { System.out.println(); // attribute is set } else { System.out.println(" (default)"); // attribute is not set } } } // printAttributeValues
public Object[] getDefaultValues(EAttribute attribute) { String typeName = attribute.getEType().getName(); if ("EString".equals(typeName)) { return new Object[] { "some" + org.dresdenocl.language.ocl.resource.ocl.util.OclStringUtil.capitalize( attribute.getName()) }; } if ("EBoolean".equals(typeName)) { return new Object[] {Boolean.TRUE, Boolean.FALSE}; } return new Object[] {attribute.getDefaultValue()}; }
private String matches( org.eclipse.emf.ecore.EObject element, String identifier, boolean matchFuzzy) { // first check for attributes that have set the ID flag to true java.util.List<org.eclipse.emf.ecore.EStructuralFeature> features = element.eClass().getEStructuralFeatures(); for (org.eclipse.emf.ecore.EStructuralFeature feature : features) { if (feature instanceof org.eclipse.emf.ecore.EAttribute) { org.eclipse.emf.ecore.EAttribute attribute = (org.eclipse.emf.ecore.EAttribute) feature; if (attribute.isID()) { Object attributeValue = element.eGet(attribute); String match = matches(identifier, attributeValue, matchFuzzy); if (match != null) { return match; } } } } // then check for an attribute that is called 'name' org.eclipse.emf.ecore.EStructuralFeature nameAttr = element.eClass().getEStructuralFeature(NAME_FEATURE); if (nameAttr instanceof org.eclipse.emf.ecore.EAttribute) { Object attributeValue = element.eGet(nameAttr); return matches(identifier, attributeValue, matchFuzzy); } else { // try any other string attribute found for (org.eclipse.emf.ecore.EAttribute stringAttribute : element.eClass().getEAllAttributes()) { if ("java.lang.String".equals(stringAttribute.getEType().getInstanceClassName())) { Object attributeValue = element.eGet(stringAttribute); String match = matches(identifier, attributeValue, matchFuzzy); if (match != null) { return match; } } } for (org.eclipse.emf.ecore.EOperation o : element.eClass().getEAllOperations()) { if (o.getName().toLowerCase().endsWith(NAME_FEATURE) && o.getEParameters().size() == 0) { String result = (String) ssl.resource.ssl.util.SslEObjectUtil.invokeOperation(element, o); String match = matches(identifier, result, matchFuzzy); if (match != null) { return match; } } } } return null; }
public void testErrorMessage_04() { EClass eClass = createEClass(); eClass.setName("EClassName"); EAttribute attribute = EcoreFactory.eINSTANCE.createEAttribute(); attribute.setName("Attribute"); eClass.getEStructuralFeatures().add(attribute); IEObjectDescription description = EObjectDescription.create(QualifiedName.create(attribute.getName()), attribute); String errorMessage = helper.getDuplicateNameErrorMessage( description, EcorePackage.Literals.EATTRIBUTE, EcorePackage.Literals.ENAMED_ELEMENT__NAME); assertEquals("Duplicate EAttribute 'Attribute' in EClass 'EClassName'", errorMessage); }
/** * Returns a list of potential identifiers that may be used to reference the given element. This * method can be overridden to customize the identification of elements. */ public List<String> getNames(EObject element) { List<String> names = new ArrayList<String>(); // first check for attributes that have set the ID flag to true List<EAttribute> attributes = element.eClass().getEAllAttributes(); for (EAttribute attribute : attributes) { if (attribute.isID()) { Object attributeValue = element.eGet(attribute); if (attributeValue != null) { names.add(attributeValue.toString()); } } } // then check for an attribute that is called 'name' EStructuralFeature nameAttr = element.eClass().getEStructuralFeature(NAME_FEATURE); if (nameAttr instanceof EAttribute) { Object attributeValue = element.eGet(nameAttr); if (attributeValue != null) { names.add(attributeValue.toString()); } } else { // try any other string attribute found for (EAttribute attribute : attributes) { if ("java.lang.String".equals(attribute.getEType().getInstanceClassName())) { Object attributeValue = element.eGet(attribute); if (attributeValue != null) { names.add(attributeValue.toString()); } } } // try operations without arguments that return strings and which have a name that // ends with 'name' for (EOperation operation : element.eClass().getEAllOperations()) { if (operation.getName().toLowerCase().endsWith(NAME_FEATURE) && operation.getEParameters().size() == 0) { Object result = org.emftext.sdk.concretesyntax.resource.cs.util.CsEObjectUtil.invokeOperation( element, operation); if (result != null) { names.add(result.toString()); } } } } return names; }
public void testCustomDefaultLiteral() throws CommitException { // valid default literal att.setDefaultValueLiteral("1;2"); EObject obj = EcoreUtil.create(cls); obj.eUnset(att); { CDOSession session = openSession(); session.getPackageRegistry().putEPackage(pkg); CDOTransaction tx = session.openTransaction(); CDOResource res = tx.createResource(getResourcePath("/test")); res.getContents().add(obj); tx.commit(); tx.close(); session.close(); } clearCache(getRepository().getRevisionManager()); { CDOSession session = openSession(); session.getPackageRegistry().putEPackage(pkg); CDOView v = session.openView(); CDOResource res = v.getResource(getResourcePath("/test")); EObject persistent = res.getContents().get(0); CustomType pCustom = (CustomType) persistent.eGet(att); assertEquals(1, pCustom.getA()); assertEquals(2, pCustom.getB()); v.close(); session.close(); } }
public static String getName(EObject obj) { if (obj == null) return null; if (obj instanceof ENamedElement) return ((ENamedElement) obj).getName(); List allAtts = obj.eClass().getEAllAttributes(); int size = allAtts.size(); EAttribute att, nameAttribute = null; for (int i = 0; i < size; i++) { att = (EAttribute) allAtts.get(i); if (NAME_ATTRIBUTE_STRING.equals(att.getName())) { nameAttribute = att; break; } } if (nameAttribute != null) return (String) obj.eGet(nameAttribute); return null; }
private void setEnabledAll(boolean enabled) { for (EClass e : elementSet) { prefs.putBoolean(e.getName(), enabled); for (EAttribute a : e.getEAllAttributes()) { prefs.putBoolean(e.getName() + "." + a.getName(), enabled); } for (EReference a : e.getEAllContainments()) { prefs.putBoolean(e.getName() + "." + a.getName(), enabled); } for (EReference a : e.getEAllReferences()) { prefs.putBoolean(e.getName() + "." + a.getName(), enabled); } } }
@Test public void cast() { final EClassifier[] types = new EClassifier[] { EcorePackage.eINSTANCE.getEInt(), EcorePackage.eINSTANCE.getEFloat(), EcorePackage.eINSTANCE.getEDouble() }; final Object[] values = new Object[] {1, 1F, 1D}; for (int i = 0; i < types.length; i++) { EClassifier classifier = types[i]; EAttribute attribute = FACTORY.createEAttribute(); attribute.setEType(classifier); eClass0.getEStructuralFeatures().add(attribute); assertEquals(values[i], EMFUtils.cast(values[(i + 1) % values.length], attribute)); } }
/** * Converts the value of an EAttribute with isMany==false, the value is converted ( {@link * #convertEAttributeValue(Object, EDataType)}) and set in the correct feature in the {@link * ModelObject}. * * @param eObject the eObject from which the value is read * @param modelObject the @[link ModelObject} in which the value is to be set * @param eAttribute the EAttribute which is converted * @see #convertEAttributeValue(Object, EDataType) */ protected void convertSingleEAttribute( final EObject eObject, final ModelObject<?> modelObject, final EAttribute eAttribute) { if (!eObject.eIsSet(eAttribute)) { return; } final Object eValue = eObject.eGet(eAttribute); modelObject.eSet(eAttribute, convertEAttributeValue(eValue, eAttribute.getEAttributeType())); }
@SuppressWarnings({"unchecked", "rawtypes"}) private void updateAttrs( EClass eClass, EObject eParentObj, EObject eObj, EObject eRef, EObject eDef) { List<EAttribute> listMany = new LinkedList<EAttribute>(); List<EAttribute> list = new LinkedList<EAttribute>(); for (EAttribute eAttr : eClass.getEAllAttributes()) { if (eAttr.isMany()) { listMany.add(eAttr); } else { list.add(eAttr); } } for (EAttribute eAttr : listMany) { List<?> vList = (List<?>) eObj.eGet(eAttr); if (vList.size() == 0) { if (eRef != null && ((List<?>) eRef.eGet(eAttr)).size() > 0) { vList.addAll((List) eRef.eGet(eAttr)); } else if (eDef != null) { vList.addAll((List) eDef.eGet(eAttr)); } } } for (EAttribute eAttr : list) { Object val = eObj.eGet(eAttr); if (eAttr.isUnsettable()) { if (!eObj.eIsSet(eAttr)) { if (eRef != null && eRef.eIsSet(eAttr)) { eObj.eSet(eAttr, eRef.eGet(eAttr)); } else if (eDef != null && eDef.eIsSet(eAttr)) { eObj.eSet(eAttr, eDef.eGet(eAttr)); } } } else if (val == null) { if (eRef != null && eRef.eGet(eAttr) != null) { eObj.eSet(eAttr, eRef.eGet(eAttr)); } else if (eDef != null) { eObj.eSet(eAttr, eDef.eGet(eAttr)); } } } }
@Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((fE == null) ? 0 : fE.hashCode()); result = prime * result + ((fAttr == null) ? 0 : fAttr.hashCode()); result = prime * result + ((fType == null) ? 0 : fType.hashCode()); return result; }
/** @generated */ protected Object getValue(EObject element, EAttribute feature) { Object value = element.eGet(feature); Class iClass = feature.getEAttributeType().getInstanceClass(); if (String.class.equals(iClass)) { if (value == null) { value = ""; // $NON-NLS-1$ } } return value; }
/** * @param feature * @param target */ private void storeSingleValue(EAttribute feature, Object target) { // store current value if (feature.isChangeable()) { if (target instanceof EObject) { currentValue = EcoreUtil.copy((EObject) target); } } else { currentValue = target; } }
public CharSequence idAssignment(final EClass it) { CharSequence _xblockexpression = null; { final EAttribute idAttr = Ecore2XtextExtensions.idAttribute(it); CharSequence _xifexpression = null; boolean _notEquals = (!Objects.equal(idAttr, null)); if (_notEquals) { StringConcatenation _builder = new StringConcatenation(); String _name = idAttr.getName(); _builder.append(_name, ""); _builder.append("="); String _assignedRuleCall = Ecore2XtextExtensions.assignedRuleCall(idAttr); _builder.append(_assignedRuleCall, ""); _xifexpression = _builder; } _xblockexpression = (_xifexpression); } return _xblockexpression; }