protected void log(Object obj, int level, StringBuffer log) { EObject object = (EObject) obj; List properties = object.eClass().getEAllStructuralFeatures(); for (Iterator p = properties.iterator(); p.hasNext(); ) { EStructuralFeature property = (EStructuralFeature) p.next(); Object value = object.eGet(property); // skip empty properties if (value == null || (value instanceof Collection && ((Collection) value).isEmpty()) || (value instanceof Map && ((Map) value).isEmpty())) { continue; } log.append("\n"); for (int i = 0; i < level; i++) log.append(" "); if (value instanceof EObject && (level < 3)) { log.append(property.getName()); log.append(":"); log((EObject) value, level + 1, log); } else if (value instanceof Collection) { log(property.getName(), (Collection) value, level + 1, log); } else { log.append(property.getName()); log.append(" = " + value); } } }
/** * Gets the property of an eobject. * * @param eobject The object. * @param property The property to get. * @return The value of the property. */ public static Object get(EObject eobject, String property) { EStructuralFeature feature = feature(eobject, property); return eobject.eGet(feature); }
/** * Obtains the values of a particular property on each {@link EObject} in a list. * * @param objects A list of {@link EObject}. * @param property The property to obtain. * @return The list of values. */ public static List get(List objects, String property) { List values = new ArrayList(); for (int i = 0; i < objects.size(); i++) { EObject eobject = (EObject) objects.get(i); EStructuralFeature feature = feature(eobject, property); values.add(eobject.eGet(feature)); } return values; }
/** * Copies all the properties from one object to anoter. * * @param source The object to copy from. * @param target The object to copy to. */ public static void copy(EObject source, EObject target) { for (Iterator i = source.eClass().getEStructuralFeatures().iterator(); i.hasNext(); ) { EStructuralFeature feature = (EStructuralFeature) i.next(); target.eSet(feature, source.eGet(feature)); } } }
/** * <!-- begin-user-doc --> * <!-- end-user-doc --> * @generated */ @SuppressWarnings("unchecked") public EMap<String, Object> getEMap() { EObject container = eContainer(); return container == null ? null : (EMap<String, Object>)container.eGet(eContainmentFeature()); }
/** * Determines if a feature of an eobject is a collection. * * @return <code>true</code> if the feature is a collection, otherwise <code>false</code> */ public static boolean isCollection(EObject eobject, EStructuralFeature feature) { Object o = eobject.eGet(feature); if (o != null) { return o instanceof Collection; } if (Collection.class.isAssignableFrom(feature.getEType().getInstanceClass())) { return true; } return false; }
/** * Clones an eobject, with the option of performing a deep clone in which referenced eobjects * are also cloned. * * @param prototype The object to be cloned from. * @param factory The factory used to create the clone. * @param deepFlag indicating wether to perform a deep clone. * @return THe cloned object, with all properties the same to the original. */ public static EObject clone(EObject prototype, EFactory factory, boolean deep) { EObject clone = factory.create(prototype.eClass()); for (Iterator i = clone.eClass().getEStructuralFeatures().iterator(); i.hasNext(); ) { EStructuralFeature feature = (EStructuralFeature) i.next(); Object value = prototype.eGet(feature); if (deep && value instanceof EObject) { EObject evalue = (EObject) value; // recursively call // TODO:handle cycles in reference graph value = clone(evalue, evalue.eClass().getEPackage().getEFactoryInstance(), deep); } clone.eSet(feature, value); } return clone; }
out.println("<tr>"); out.println("<td>" + eStructuralFeature.getName() + "</td>"); Object eGet = eObject.eGet(eStructuralFeature); if (eStructuralFeature instanceof EAttribute) { if (eStructuralFeature.getUpperBound() == 1) { EObject value = (EObject) eGet; if (value != null) { out.println("<td>" + value.eGet(value.eClass().getEStructuralFeature("wrappedValue")) + "</td>"); out.println("<td>"); for (EObject object : list) { out.println("<td>" + object.eGet(object.eClass().getEStructuralFeature("wrappedValue")) + "</td>");
System.out.println("#" + key + " " + object.eClass().getName()); for (EAttribute attribute : object.eClass().getEAllAttributes()) { System.out.println("\t" + attribute.getName() + "(" + attribute.getEType().getName() + "): " + object.eGet(attribute)); if (object.eGet(reference) instanceof EObjectResolvingEList) { EObjectResolvingEList<EObject> referencedObjectList = (EObjectResolvingEList<EObject>)object.eGet(reference); if (referencedObjectList != null && referencedObjectList.size() > 0) { if (reference.getEReferenceType().getEStructuralFeature("wrappedValue") != null) { for (Object obj : referencedObjectList) { Object wrappedValue = ((EObject)obj).eGet(reference.getEReferenceType().getEStructuralFeature("wrappedValue")); System.out.println(wrappedValue.toString()); if (referencedObjectList.get(referencedObjectList.size()-1) != obj) { if (object.eGet(reference) != null) { System.out.println("=>"); } else {
/** * Adds a value to a multi-valued propert of an eobject. * * <p>The <param>feature</param> must map to a multi-valued property of the eobject. The {@link * #isCollection(EStructuralFeature)} method can be used to test this. * * @param eobject The object. * @param feature The multi-valued feature. * @param value The value to add. */ public static void add(EObject eobject, EStructuralFeature feature, Object value) { if (isCollection(eobject, feature)) { Collection collection = (Collection) eobject.eGet(feature); if (collection == null) { // most likely not an ECollection collection = createEmptyCollection(feature); eobject.eSet(feature, collection); } Collection addCollection = collection(value); collection.addAll(addCollection); } }
Object reference = basePath.getLastObject().eGet(eReference); if (reference != null) { if (eReference.isMany()) {
EMap<String, Object> unmatched = (EMap<String, Object>) eObj.eGet(feature); for (Map.Entry<String, Object> entry : unmatched.entrySet()) { jg.writeObjectField(entry.getKey(), entry.getValue()); EDataType dataType = (EDataType) feature.getEType(); if (feature.isMany()) { List<Object> childObjs = (List<Object>) eObj.eGet(feature); jg.writeFieldName(jsonKey); jg.writeStartArray(); Object value = eObj.eGet(feature); if (value != null) { writeValueField(jg, jsonKey, dataType, value); List<EObject> childObjs = (List<EObject>) eObj.eGet(feature); jg.writeFieldName(jsonKey); jg.writeStartArray(); EObject childObj = (EObject) eObj.eGet(feature); if (childObj != null) { jg.writeFieldName(jsonKey);
@SuppressWarnings({ "unchecked", "rawtypes" }) public static void fillDataObject(BiMap<? extends Long, ? extends EObject> mapResult, EObject eObject, DataObject dataObject) { for (EStructuralFeature eStructuralFeature : eObject.eClass().getEAllStructuralFeatures()) { Object eGet = eObject.eGet(eStructuralFeature); if (eStructuralFeature.getEAnnotation("hidden") == null && !eStructuralFeature.isDerived()) { if (eStructuralFeature instanceof EAttribute) { if (eStructuralFeature.getEType() == EcorePackage.eINSTANCE.getEDoubleObject() || eStructuralFeature.getEType() == EcorePackage.eINSTANCE.getEDouble()) { EStructuralFeature asStringFeature = eObject.eClass().getEStructuralFeature(eStructuralFeature.getName() + "AsString"); List list = (List) eObject.eGet(asStringFeature); for (Object o : list) { SimpleDataValue dataValue = StoreFactory.eINSTANCE.createSimpleDataValue(); if (eStructuralFeature.isMany()) { if (eStructuralFeature.getEType() == EcorePackage.eINSTANCE.getEDouble() || eStructuralFeature.getEType() == EcorePackage.eINSTANCE.getEDoubleObject()) { List list = (List)eObject.eGet(eObject.eClass().getEStructuralFeature(eStructuralFeature.getName() + "AsString")); ListDataValue dataValue = StoreFactory.eINSTANCE.createListDataValue(); dataValue.setFieldName(eStructuralFeature.getName()); EObject referenceEObject = item; SimpleDataValue simpleDataValue = StoreFactory.eINSTANCE.createSimpleDataValue(); simpleDataValue.setStringValue(referenceEObject.eGet(referenceEObject.eClass().getEStructuralFeature("wrappedValue")).toString()); dataValue.getValues().add(simpleDataValue); } else { SimpleDataValue e = StoreFactory.eINSTANCE.createSimpleDataValue(); EStructuralFeature wrappedValueFeature = referenceEObject.eClass().getEStructuralFeature("wrappedValue"); Object eGet2 = referenceEObject.eGet(wrappedValueFeature);
for (WaitingObject waitingObject : waitingObjects.get(expressId)) { if (waitingObject.getEReference().isMany()) { AbstractEList<EObject> list = (AbstractEList<EObject>) waitingObject.getObject().eGet(waitingObject.getEReference()); if (waitingObject instanceof SingleWaitingObject) { list.addUnique(eObject);
@SuppressWarnings("unchecked") public static List<EObject> getAllReferencedObjects(EObject referer, EReference reference) { if (reference.getUpperBound() == 1) { EObject eObject = (EObject) referer.eGet(reference); if (null != eObject) return Collections.singletonList(eObject); return Collections.<EObject> emptyList(); } return (List<EObject>) referer.eGet(reference); }
public static String getLocalizedFeature(EStructuralFeature feature, MApplicationElement element) { Object o = ((EObject) element).eGet(feature); if (o instanceof String) { return getLocalized((String) o, element); } return null; }
private String getEName(final EObject eo) { EStructuralFeature f = eo.eClass().getEStructuralFeature("name"); if (f == null) { return null; } Object nameValue = eo.eGet(f); if (nameValue instanceof String) return (String) nameValue; return null; }
protected String getFullyQualifiedName(EObject eobj) { EStructuralFeature feature = eobj.eClass().getEStructuralFeature("textContent"); if (feature != null) { return (String)eobj.eGet(feature); } return null; }
protected void checkNoJavaKeyword(EObject obj, EAttribute attribute) { Object name = obj.eGet(attribute); if (name != null) { if (javaUtils.isJavaKeyword(name.toString())) error("'"+name+"' is not a valid identifier.", obj, attribute, -1, INVALID_IDENTIFIER); } }
protected boolean enumValueChanged(EObject anObject, EStructuralFeature aFeature, Object aValue) { if (!anObject.eIsSet(aFeature)) return true; Enumerator existingEnumerator = (Enumerator) anObject.eGet(aFeature); Enumerator newEnumerator = getEnumerator(aFeature, aValue); return existingEnumerator != newEnumerator; }