public static List<EClass> filterByContainmentFeature( Collection<EClass> eClasses, MappingEntry mappingEntry) { EClass superType = null; if (mappingEntry instanceof NodeMapping) { NodeReference nodeReference = (NodeReference) mappingEntry.eContainer(); if (nodeReference != null) { EReference modelReference = nodeReference.getChildrenFeature() != null ? nodeReference.getChildrenFeature() : nodeReference.getContainmentFeature(); if (modelReference != null) { superType = modelReference.getEReferenceType(); } } } else if (mappingEntry instanceof LinkMapping) { if (((LinkMapping) mappingEntry).getContainmentFeature() != null) { superType = ((LinkMapping) mappingEntry).getContainmentFeature().getEReferenceType(); } } return sort( getConcreteEClasses( getSubtypesOf( filterValidEObjectsFrom(eClasses, mappingEntry.eResource().getResourceSet()), superType))); }
@Override protected IScope getGlobalScope(final Resource context, final EReference reference) { IScope globalScope = super.getGlobalScope(context, reference, null); return SelectableBasedScope.createScope( globalScope, getAllDescriptions(context), reference.getEReferenceType(), isIgnoreCase(reference)); }
private EObject getOrCreateProxyReference( EReference reference, JsonNode root, JsonNode node, Resource resource) { EObject obj = findEObject(resource, node); if (obj == null) { EClass refClass = findEClass(reference.getEReferenceType(), node, root, resource); obj = createProxy(resource, refClass, node); } return obj; }
private void update( EReference ref, EObject eParentObj, EObject eObj, EObject eRef, EObject eDef) { if (eObj != null && eObj instanceof DataPointComponent) { eDef = ChartDefaultValueUtil.getPercentileDataPointDefObj( (DataPointComponent) eObj, (DataPointComponent) eDef); } update(ref.getEReferenceType(), ref.getName(), eParentObj, eObj, eRef, eDef); }
private EObject createContainedObject( EReference reference, JsonNode root, JsonNode node, Resource resource) { EClass refClass = findEClass(reference.getEReferenceType(), node, root, resource); EObject obj; if (isRefNode(node)) { obj = createProxy(resource, refClass, node); } else { obj = createEObject(resource, refClass, node); } return obj; }
@Override public void initialize(IInitializationParticipantContext context, Object facet) { if (!(facet instanceof EReference)) return; final EReference ref = (EReference) facet; if (!ref.isRequired() || ref.isContainer()) return; final EObject object = context.getObject(); if (ref.getUpperBound() != 1) { /* * A list */ @SuppressWarnings("unchecked") final EList<? extends EObject> l = (EList<? extends EObject>) context.getStructuralFeature(ref); int missing = ref.getLowerBound() - l.size(); if (missing < 0) return; final List<EObject> newChildren = new ArrayList<EObject>(missing); for (; missing > 0; missing--) { final EObject newChild = EcoreUtil.create(ref.getEReferenceType()); context.addCommand( IManager.Factory.getManager() .initializeObject(context.getEditingDomain(), object, ref, newChild, false)); } context.addCommand(AddCommand.create(context.getEditingDomain(), object, ref, newChildren)); } else { /* * Simple object */ final Object o = context.getStructuralFeature(ref); if (o != null) return; final EObject newChild = EcoreUtil.create(ref.getEReferenceType()); context.addCommand( IManager.Factory.getManager() .initializeObject(context.getEditingDomain(), object, ref, newChild, true)); } }
public static Collection<EReference> getEReferencesOfType( Collection<EReference> references, EClass referenceType) { Collection<EReference> result = getValidEStructuralFeatures(references); if (referenceType == null) { return result; } for (Iterator<EReference> it = result.iterator(); it.hasNext(); ) { EReference nextFeature = it.next(); if (nextFeature != null && !nextFeature.getEReferenceType().isSuperTypeOf(referenceType)) { it.remove(); } } return result; }
/** * Retrieves all EClasses from <code>allEClasses</code> that can possibly be referenced by <code> * reference</code> and returns them as a list. * * @param reference the EReference to get EClasses for * @param allEClasses set of all possible EClasses * @return list of all EClasses that can be referenced by <code>reference</code> */ public static Set<EClass> getReferenceClasses(EReference reference, Set<EClass> allEClasses) { Set<EClass> result = new LinkedHashSet<EClass>(); EClass referenceType = reference.getEReferenceType(); // 'referenceType: EObject' allows all kinds of EObjects if (referenceType.equals(EcorePackage.eINSTANCE.getEObject())) { return allEClasses; } for (EClass eClass : allEClasses) { // can eClass be referenced by reference if (referenceType.equals(eClass) || referenceType.isSuperTypeOf(eClass)) { result.add(eClass); } } return result; }
protected void computeReferencedJvmTypeHighlighting( IHighlightedPositionAcceptor acceptor, EObject referencer, CancelIndicator cancelIndicator) { for (EReference reference : referencer.eClass().getEAllReferences()) { EClass referencedType = reference.getEReferenceType(); if (EcoreUtil2.isAssignableFrom(TypesPackage.Literals.JVM_TYPE, referencedType)) { List<EObject> referencedObjects = EcoreUtil2.getAllReferencedObjects(referencer, reference); if (referencedObjects.size() > 0) operationCanceledManager.checkCanceled(cancelIndicator); for (EObject referencedObject : referencedObjects) { EObject resolvedReferencedObject = EcoreUtil.resolve(referencedObject, referencer); if (resolvedReferencedObject != null && !resolvedReferencedObject.eIsProxy()) { highlightReferenceJvmType(acceptor, referencer, reference, resolvedReferencedObject); } } } } }
private boolean isAssociatorOrDissociatorFor( Method method, EReference eReference, final String prefix) { if (method.getParameterTypes().length != 1) { return false; } Class paramType = method.getParameterTypes()[0]; Class referencedType = eReference.getEReferenceType().getInstanceClass(); if (!paramType.equals(referencedType)) { return false; } String referenceName = eReference.getName(); String associatorMethodName = prefix + new MethodNameHelper().titleCase(referenceName); if (!method.getName().equals(associatorMethodName)) { return false; } return true; }
protected IScope getResourceScope( IScope globalScope, @SuppressWarnings("unused") Resource res, EReference reference) { IScope result = globalScope; ISelectable globalScopeSelectable = new ScopeBasedSelectable(result); // implicit imports (i.e. java.lang.*) List<ImportNormalizer> normalizers = getImplicitImports(isIgnoreCase(reference)); if (!normalizers.isEmpty()) { result = createImportScope( result, normalizers, globalScopeSelectable, reference.getEReferenceType(), isIgnoreCase(reference)); } return result; }
/** * This standard implementation searches the tree for objects of the correct type with a name * attribute matching the identifier. */ protected void resolve( String identifier, ContainerType container, org.eclipse.emf.ecore.EReference reference, int position, boolean resolveFuzzy, ssl.resource.ssl.ISslReferenceResolveResult<ReferenceType> result) { try { org.eclipse.emf.ecore.EClass type = reference.getEReferenceType(); org.eclipse.emf.ecore.EObject root = ssl.resource.ssl.util.SslEObjectUtil.findRootContainer(container); // first check whether the root element matches boolean continueSearch = checkElement(root, type, identifier, resolveFuzzy, true, result); if (!continueSearch) { return; } // then check the contents for (java.util.Iterator<org.eclipse.emf.ecore.EObject> iterator = root.eAllContents(); iterator.hasNext(); ) { org.eclipse.emf.ecore.EObject element = iterator.next(); continueSearch = checkElement(element, type, identifier, resolveFuzzy, true, result); if (!continueSearch) { return; } } org.eclipse.emf.ecore.resource.Resource resource = container.eResource(); if (resource != null) { org.eclipse.emf.common.util.URI uri = getURI(identifier, resource.getURI()); if (uri != null) { org.eclipse.emf.ecore.EObject element = loadResource(container.eResource().getResourceSet(), uri); if (element == null) { return; } checkElement(element, type, identifier, resolveFuzzy, false, result); } } } catch (java.lang.RuntimeException rte) { // catch exception here to prevent EMF proxy resolution from swallowing it rte.printStackTrace(); } }
@Override public boolean isValidValue(Object value) { Object adaptedValue = getAdaptedValue(value); if (adaptedValue instanceof EObject) { // We cannot create objects in a read-only object if (EMFHelper.isReadOnly((EObject) adaptedValue)) { return false; } // We need at least one valid containment reference to store this // type of object for (EReference reference : ((EObject) adaptedValue).eClass().getEAllReferences()) { if (reference.isContainment() && EMFHelper.isSubclass(this.type, reference.getEReferenceType())) { return true; } } } return false; }
/** * Returns all containing references where <code>parentClass</code> is the container and <code> * childClass</code> the containment. * * @param childClass the EClass which shall be contained * @param parentClass the EClass to get containment references from * @return all possible container-references as a set */ public static Set<EReference> getAllPossibleContainingReferences( EClass childClass, EClass parentClass) { List<EReference> allReferences = parentClass.getEAllContainments(); Set<EReference> result = new LinkedHashSet<EReference>(); for (EReference reference : allReferences) { EClass referenceType = reference.getEReferenceType(); if (referenceType == null) { continue; } // is the reference type a perfect match? if (referenceType.equals(childClass)) { result.add(reference); // is the reference type either EObject or a super type? } else if (referenceType.equals(EcorePackage.eINSTANCE.getEObject()) || referenceType.isSuperTypeOf(childClass)) { result.add(reference); } } return result; }
/** * Get a collection from a target object by collection feature., use the * last occurrence in the collection, to get an attribute value. return the * attribute value incremented by 1. * <p> * If this is the first occurence the name will be. * * <pre> * <new [target Object name] 1> * </pre> * * </p> * @param targetParentObject * @param collectionFeature * @param identityFeature * An identity attribute which should be of type String. * @return A String incremented by 1. */ public String nextSequenceNumber(EditingDomain domain, EObject targetParentObject, EReference collectionFeature, EAttribute identityFeature) { int maxSequence = -1; String highestIdentity = null; if (collectionFeature.isMany()) { final List<?> collection = (List<?>) targetParentObject .eGet(collectionFeature); for (Object child : collection) { if (((EObject) child).eIsSet(identityFeature)) { final String currentIdentity = (String) ((EObject) child) .eGet(identityFeature); int currentSequence = currentSequenceNumber(currentIdentity); if (currentSequence > maxSequence) { maxSequence = currentSequence; highestIdentity = currentIdentity; } } } if (maxSequence != -1 && highestIdentity != null) { return nextIdentity(highestIdentity); } else { // Note if we can't get a sequence number from the collection, // get the last entry and use this... if (!collection.isEmpty()) { Object object = collection.get(collection.size() - 1); final String lastIdentityInSequence = (String) ((EObject) object) .eGet(identityFeature); return lastIdentityInSequence != null ? lastIdentityInSequence + " 1" : "1"; } } } return "<new " + typeName(domain, targetParentObject, collectionFeature.getEReferenceType()) + " 1>"; }
@Override public IScope getScope(EObject context, EReference reference) { if (context == null) { return IScope.NULLSCOPE; } Resource csResource = context.eResource(); if (csResource == null) { return IScope.NULLSCOPE; } EClass eReferenceType = reference.getEReferenceType(); if (eReferenceType == OCLstdlibCSPackage.Literals.JAVA_CLASS_CS) { if (csResource instanceof BaseCSResource) { AbstractJavaClassScope adapter = JavaClassScope.findAdapter((BaseCSResource) csResource); if (adapter == null) { EnvironmentFactoryAdapter environmentFactoryAdapter = EnvironmentFactoryAdapter.find(csResource); if (environmentFactoryAdapter == null) { ResourceSet csResourceSet = csResource.getResourceSet(); if (csResourceSet != null) { environmentFactoryAdapter = EnvironmentFactoryAdapter.find(csResourceSet); } } List<@NonNull ClassLoader> classLoaders; if (environmentFactoryAdapter != null) { classLoaders = environmentFactoryAdapter .getMetamodelManager() .getImplementationManager() .getClassLoaders(); } else { classLoaders = Collections.emptyList(); } adapter = JavaClassScope.getAdapter((BaseCSResource) csResource, classLoaders); } return adapter; } return IScope.NULLSCOPE; } return super.getScope(context, reference); }
public String getClassAssociations(EClass eClass) { // if associations exist if (eClass.getEReferences().size() > 0) { StringBuilder sb = new StringBuilder(); sb.append("\\subsubsection*{Associations}\n"); sb.append("\\begin{itemize}\n"); for (EReference eReference : eClass.getEReferences()) { sb.append("\\item "); // Name sb.append(eReference.getName()).append(": "); // Type // Works only for internal sb.append("\\nameref{").append(eReference.getEReferenceType().getName()).append("} "); // Mult sb.append(getMultiplicity(eReference)).append(" "); // Containement if (eReference.isContainment()) { sb.append("(containment) "); } // Description if (getLatexDocAnnotation( eReference, prefs.getPreferenceString(PreferenceConstants.P_DESCRIPTION_KEY)) != null) { sb.append("\\newline\n") .append( getLatexDocAnnotation( eReference, prefs.getPreferenceString(PreferenceConstants.P_DESCRIPTION_KEY))); } sb.append("\n"); } sb.append("\\end{itemize}"); return sb.toString(); } return "\\subsubsection*{Associations} ~\\\\ No additional associations"; }
/** * Returns all possible EClasses, excluding abstract classes and interfaces, that can be contained * when using <code>reference</code>. * * @param reference the EReference to get containable EClasses for * @return a set of all EClasses that can be contained when using <code>reference</code> */ public static List<EClass> getAllEContainments(EReference reference) { if (allEContainments.containsKey(reference)) { return allEContainments.get(reference); } if (reference == null) { allEContainments.put(reference, new LinkedList<EClass>()); return allEContainments.get(reference); } List<EClass> result = new LinkedList<EClass>(); EClass referenceType = reference.getEReferenceType(); // no abstracts or interfaces if (canHaveInstance(referenceType)) { result.add(referenceType); } // 'referenceType: EObject' allows all kinds of EObjects if (EcorePackage.eINSTANCE.getEObject().equals(referenceType)) { return getAllEClasses(); } // all sub EClasses can be referenced as well result.addAll(getAllSubEClasses(referenceType)); // save the result for upcoming method calls allEContainments.put(reference, result); return result; }
/** * Returns {@link IChildCreationSpecification} for children of the specified list. * * @param l the list * @param sibling a possible sibling, if non-<code>null</code> * @return the possible top-level children */ public static List<IChildCreationSpecification> getPossibleTopLevelChildObjects( IObservableList l, EObject sibling) { final List<IChildCreationSpecification> specs = new ArrayList<IChildCreationSpecification>(); /* * Figure out the EReference of the elements */ EObject parent = null; EReference ref = null; if (l instanceof EObjectEList<?>) { final EObjectEList<?> el = (EObjectEList<?>) l; final EStructuralFeature sf = el.getEStructuralFeature(); if (sf instanceof EReference) { parent = (EObject) el.getNotifier(); ref = (EReference) sf; } } if (ref == null && l instanceof MyDetailObservableList) { parent = (EObject) ((MyDetailObservableList) l).getObserved(); ref = (EReference) ((MyDetailObservableList) l).getElementType(); } if (ref == null && l instanceof EObjectObservableList) { parent = (EObject) ((EObjectObservableList) l).getObserved(); ref = (EReference) ((EObjectObservableList) l).getElementType(); } if (ref == null) return specs; final EClass childType = ref.getEReferenceType(); int index = -1; if (sibling != null) { index = l.indexOf(sibling); if (index == -1) return specs; } UIBindingsUtils.addToChildCreationSpecification(specs, parent, ref, childType, index); return specs; }
protected boolean isTypeScope(EReference reference) { return TypesPackage.Literals.JVM_TYPE.isSuperTypeOf(reference.getEReferenceType()); }
protected boolean isConstructorCallScope(EReference reference) { return reference.getEReferenceType() == TypesPackage.Literals.JVM_CONSTRUCTOR; }
// TODO ! need new presentation of set-text-selection command or hide args protected void convertSimple(Command command, ICommandFormatter formatter, boolean hasInput) { String commandName = CoreUtils.getScriptletNameByClass(command.eClass()); formatter.addCommandName(commandName); Map<EStructuralFeature, Command> bindingMap = new HashMap<EStructuralFeature, Command>(); for (Binding b : command.getBindings()) { bindingMap.put(b.getFeature(), b.getCommand()); } List<EStructuralFeature> attributes = CoreUtils.getFeatures(command.eClass()); boolean forced = false; boolean bigTextCommand = commandName.equals("upload-file") || commandName.equals("match-binary"); for (EStructuralFeature feature : attributes) { if (feature.getEAnnotation(CoreUtils.INTERNAL_ANN) != null) continue; if (feature.getEAnnotation(CoreUtils.INPUT_ANN) != null && hasInput) continue; String name = feature.getName(); if (isForced(commandName, name)) forced = true; Object val = command.eGet(feature); boolean skippped = true; Object defaultValue = feature.getDefaultValue(); boolean isDefault = val == null || val.equals(defaultValue); if (!isDefault) { if (feature instanceof EAttribute) { EAttribute attr = (EAttribute) feature; String type = attr.getEAttributeType().getInstanceTypeName(); if (val instanceof List<?>) { List<?> list = (List<?>) val; for (Object o : list) { String value = convertValue(o, type); if (value != null) { formatter.addAttrName(name, forced); formatter.addAttrValue(value); skippped = false; } } } else { if (val.equals(true)) { forced = true; formatter.addAttrName(name, forced); } else { String value = convertValue(val, type); if (value != null) { formatter.addAttrName(name, forced); if (bigTextCommand) formatter.addAttrValueWithLineBreak(value); else formatter.addAttrValue(value); skippped = false; } } } } else { EReference ref = (EReference) feature; EClass eclass = ref.getEReferenceType(); if (eclass.getEPackage() == CorePackage.eINSTANCE && eclass.getClassifierID() == CorePackage.COMMAND) { boolean singleLine = !(val instanceof Sequence); formatter.addAttrName(name, forced); formatter.openGroup(singleLine); doConvert((Command) val, formatter, true); formatter.closeGroup(singleLine); skippped = false; } else { IParamConverter<?> converter = ParamConverterManager.getInstance().getConverter(eclass.getInstanceClass()); if (converter != null) { try { String strVal = String.format("\"%s\"", converter.convertToCode(val)); formatter.addAttrValue(strVal); } catch (CoreException e) { CorePlugin.log(e.getStatus()); } } } } } else { Command c = bindingMap.get(feature); if (c != null) { formatter.addAttrName(name, forced); formatter.openExec(); doConvert(c, formatter, hasInput); formatter.closeExec(); skippped = false; } } if (skippped) forced = true; } }
protected IScope getLocalElementsScope( IScope parent, IScope globalScope, EObject context, EReference reference) { IScope result = parent; QualifiedName name = getQualifiedNameOfLocalElement(context); boolean ignoreCase = isIgnoreCase(reference); ISelectable resourceOnlySelectable = getAllDescriptions(context.eResource()); ISelectable globalScopeSelectable = new ScopeBasedSelectable(globalScope); // imports List<ImportNormalizer> explicitImports = getImportedNamespaceResolvers(context, ignoreCase); if (!explicitImports.isEmpty()) { result = createImportScope( result, explicitImports, globalScopeSelectable, reference.getEReferenceType(), ignoreCase); } // local element if (name != null) { ImportNormalizer localNormalizer = doCreateImportNormalizer(name, true, ignoreCase); result = createImportScope( result, singletonList(localNormalizer), resourceOnlySelectable, reference.getEReferenceType(), ignoreCase); } // scope for jvm elements Set<EObject> elements = associations.getJvmElements(context); for (EObject derivedJvmElement : elements) { // scope for JvmDeclaredTypes if (derivedJvmElement instanceof JvmDeclaredType) { JvmDeclaredType declaredType = (JvmDeclaredType) derivedJvmElement; QualifiedName jvmTypeName = getQualifiedNameOfLocalElement(declaredType); if (declaredType.getDeclaringType() == null && !Strings.isEmpty(declaredType.getPackageName())) { QualifiedName packageName = this.qualifiedNameConverter.toQualifiedName(declaredType.getPackageName()); ImportNormalizer normalizer = doCreateImportNormalizer(packageName, true, ignoreCase); result = createImportScope( result, singletonList(normalizer), globalScopeSelectable, reference.getEReferenceType(), ignoreCase); } if (jvmTypeName != null && !jvmTypeName.equals(name)) { ImportNormalizer localNormalizer = doCreateImportNormalizer(jvmTypeName, true, ignoreCase); result = createImportScope( result, singletonList(localNormalizer), resourceOnlySelectable, reference.getEReferenceType(), ignoreCase); } } // scope for JvmTypeParameterDeclarator if (derivedJvmElement instanceof JvmTypeParameterDeclarator) { JvmTypeParameterDeclarator parameterDeclarator = (JvmTypeParameterDeclarator) derivedJvmElement; List<IEObjectDescription> descriptions = null; for (JvmTypeParameter param : parameterDeclarator.getTypeParameters()) { if (param.getSimpleName() != null) { if (descriptions == null) descriptions = Lists.newArrayList(); QualifiedName paramName = QualifiedName.create(param.getSimpleName()); descriptions.add(EObjectDescription.create(paramName, param)); } } if (descriptions != null && !descriptions.isEmpty()) result = MapBasedScope.createScope(result, descriptions); } } return result; }
/** * Converts the value of an EReference with isMany==true, the values of the collection are * converted to EObjects and added to the list in the correct feature in the eObject. * * @param modelObject the modelObject from which the value is retrieved. * @param eObject the eObject in which the value is set (after it has been converted) * @param eReference the eReference which is converted */ protected void convertManyEReference( final ModelObject<?> modelObject, final EObject eObject, final EReference eReference) { // container feature is always set from the other side, the containment // side if (eReference.isContainer()) { return; } final Object manyValue = modelObject.eGet(eReference); final Collection<EObject> newValues = new ArrayList<EObject>(); boolean isMap = Map.class.isAssignableFrom(manyValue.getClass()); EStructuralFeature valueFeature = null; EStructuralFeature keyFeature = null; if (isMap) { final EClass mapEClass = eReference.getEReferenceType(); valueFeature = mapEClass.getEStructuralFeature("value"); // $NON-NLS-1$ keyFeature = mapEClass.getEStructuralFeature("key"); // $NON-NLS-1$ Check.isTrue( ModelUtils.isEMap(eReference), "Expected emap EReference, but th// case for EReference " //$NON-NLS-1$ + eReference); final Map<?, ?> map = (Map<?, ?>) manyValue; for (final Object key : map.keySet()) { final Object value = map.get(key); final EObject mapEntryEObject = EcoreUtil.create(mapEClass); // key and value maybe primitive types but can also be // references to model objects. if (valueFeature instanceof EReference) { mapEntryEObject.eSet(valueFeature, createTarget(value)); } else { mapEntryEObject.eSet(valueFeature, value); } if (keyFeature instanceof EReference) { mapEntryEObject.eSet(keyFeature, createTarget(key)); } else { mapEntryEObject.eSet(keyFeature, key); } newValues.add(mapEntryEObject); } } else { // a many to many if (eReference.getEOpposite() != null && eReference.getEOpposite().isMany()) { final ManyToMany mtm = new ManyToMany(); mtm.setOwner(modelObject); mtm.setEReference(eReference); toRepairManyToMany.add(mtm); } @SuppressWarnings("unchecked") final Collection<Object> values = (Collection<Object>) manyValue; for (final Object value : values) { if (value == null) { newValues.add(null); } else { final InternalEObject eValue = (InternalEObject) createTarget(value); if (!newValues.contains(eValue)) { newValues.add(eValue); } } } } @SuppressWarnings("unchecked") final Collection<EObject> eValues = (Collection<EObject>) eObject.eGet(eReference); boolean updateList = false; if (newValues.size() == eValues.size()) { final Iterator<?> it = eValues.iterator(); for (Object newValue : newValues) { final Object oldValue = it.next(); if (isMap) { final EObject oldMapEntry = (EObject) oldValue; final EObject newMapEntry = (EObject) newValue; final Object oldMapValue = oldMapEntry.eGet(valueFeature); final Object oldMapKey = oldMapEntry.eGet(keyFeature); final Object newMapValue = newMapEntry.eGet(valueFeature); final Object newMapKey = newMapEntry.eGet(keyFeature); if (valueFeature instanceof EReference) { updateList = oldMapValue == newMapValue; } else { updateList = oldMapValue != null ? !oldMapValue.equals(newMapValue) : newMapValue != null ? !newMapValue.equals(oldMapValue) : false; } if (keyFeature instanceof EReference) { updateList = updateList || oldMapKey == newMapKey; } else { updateList = updateList || (oldMapKey != null ? !oldMapKey.equals(newMapKey) : newMapKey != null ? !newMapKey.equals(oldMapKey) : false); } } else { updateList = oldValue != newValue; } if (updateList) { break; } } } else { updateList = true; } if (updateList) { // clear the evalues so that an empty tag is created in the xml eValues.clear(); eValues.addAll(newValues); } }