| //------------------------------------------------------------------------------ |
| // Copyright (c) 2005, 2006 IBM Corporation and others. |
| // All rights reserved. This program and the accompanying materials |
| // are made available under the terms of the Eclipse Public License v1.0 |
| // which accompanies this distribution, and is available at |
| // http://www.eclipse.org/legal/epl-v10.html |
| // |
| // Contributors: |
| // IBM Corporation - initial implementation |
| //------------------------------------------------------------------------------ |
| package org.eclipse.epf.library.configuration; |
| |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.eclipse.emf.common.util.EList; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.util.EcoreUtil; |
| import org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider; |
| import org.eclipse.epf.library.IConfigurationClosure; |
| import org.eclipse.epf.library.IConfigurationManager; |
| import org.eclipse.epf.library.LibraryPlugin; |
| import org.eclipse.epf.library.LibraryResources; |
| import org.eclipse.epf.library.LibraryService; |
| import org.eclipse.epf.library.edit.util.TngUtil; |
| import org.eclipse.epf.library.services.DependencyManager; |
| import org.eclipse.epf.library.services.ElementDependency; |
| import org.eclipse.epf.library.services.ElementReference; |
| import org.eclipse.epf.library.services.PackageReference; |
| import org.eclipse.epf.library.util.LibraryUtil; |
| import org.eclipse.epf.uma.Activity; |
| import org.eclipse.epf.uma.BreakdownElement; |
| import org.eclipse.epf.uma.MethodConfiguration; |
| import org.eclipse.epf.uma.MethodElement; |
| import org.eclipse.epf.uma.MethodLibrary; |
| import org.eclipse.epf.uma.MethodPackage; |
| import org.eclipse.epf.uma.MethodPlugin; |
| import org.eclipse.epf.uma.ProcessComponent; |
| import org.eclipse.ui.views.properties.IPropertyDescriptor; |
| import org.eclipse.ui.views.properties.IPropertySource; |
| |
| /** |
| * A method configuration closure. |
| * |
| * @author Jinhua Xi |
| * @author Kelvin Low |
| * @since 1.0 |
| */ |
| public class ConfigurationClosure implements IConfigurationClosure { |
| |
| // If true, generate debug traces. |
| protected static boolean debug = LibraryPlugin.getDefault().isDebugging(); |
| |
| protected MethodConfiguration config = null; |
| |
| protected MethodLibrary library = null; |
| |
| protected IConfigurationManager configManager = null; |
| |
| protected DependencyManager dependencyManager = null; |
| |
| // Node change information. The object are the model objects |
| // check the linked objects in needed |
| protected List selected = new ArrayList(); |
| |
| // A map of invalid nodes to ElementDependencyError objects. |
| protected Map invalidNodesMap = new HashMap(); |
| |
| protected List changedNodes = new ArrayList(); |
| |
| /** |
| * Creates a new instance. |
| * |
| * @param config |
| * A method configuration. |
| */ |
| public ConfigurationClosure(MethodConfiguration config) { |
| this.config = config; |
| |
| configManager = LibraryService.getInstance().getConfigurationManager( |
| config); |
| if (configManager != null) { |
| library = configManager.getMethodLibrary(); |
| dependencyManager = configManager.getDependencyManager(); |
| } |
| |
| // cleanup the old status and rebuild the list |
| selected.clear(); |
| changedNodes.clear(); |
| invalidNodesMap.clear(); |
| |
| // configuration changed, re-build the selection list |
| try { |
| buildList(library); |
| } catch (Exception ex) { |
| ex.printStackTrace(); |
| } |
| } |
| |
| /** |
| * Returns the method configuration manager. |
| * |
| * @return A <code>ConfigurationManager</code>. |
| */ |
| public IConfigurationManager getConfigurationManager() { |
| return configManager; |
| } |
| |
| /** |
| * Returns the method configuration. |
| * |
| * @return A <code>MethodConfiguration</code>. |
| */ |
| public MethodConfiguration getConfiguration() { |
| return config; |
| } |
| |
| /** |
| * Returns the containining method library. |
| * |
| * @return A <code>MethodConfiguration</code>. |
| */ |
| public MethodLibrary getLibrary() { |
| return library; |
| } |
| |
| /** |
| * Builds the selection list based on the method configuration. |
| * |
| * @param input |
| */ |
| private void buildList(EObject input) { |
| // Validate the method configuration. |
| LibraryUtil.validateMethodConfiguration(config); |
| |
| selected.addAll(config.getMethodPluginSelection()); |
| selected.addAll(config.getMethodPackageSelection()); |
| |
| // Re-build the selections to auto add the process packages. |
| setSelections(selected.toArray()); |
| } |
| |
| /** |
| * Sets the method plug-ins and packages selection. |
| * |
| * @param elements |
| * An array of method plug-ins and packages. |
| */ |
| public void setSelections(Object[] elements) { |
| if (elements == null) { |
| return; |
| } |
| |
| // Cleanup the old status and rebuild the list. |
| selected.clear(); |
| changedNodes.clear(); |
| invalidNodesMap.clear(); |
| beginUpdate(); |
| |
| for (int i = 0; i < elements.length; i++) { |
| Object e = elements[i]; |
| if (!selected.contains(e)) { |
| if ((e instanceof EObject)) { |
| add((EObject) e, false); |
| |
| // If the selected element is a process component, |
| // select all the process packages that contains the |
| // activities. |
| if (e instanceof ProcessComponent) { |
| selectProcessPackages(((ProcessComponent) e) |
| .getProcess()); |
| } |
| } else { |
| // The selected element is a UI folder. |
| selected.add(e); |
| } |
| } |
| } |
| |
| endUpdate(); |
| } |
| |
| private void selectProcessPackages(Activity a) { |
| if (a == null) { |
| return; |
| } |
| |
| for (Iterator it = a.getBreakdownElements().iterator(); it.hasNext();) { |
| BreakdownElement e = (BreakdownElement) it.next(); |
| Object pkg = e.eContainer(); |
| if (!selected.contains(pkg)) { |
| selected.add(pkg); |
| changedNodes.add(pkg); |
| } |
| |
| if (e instanceof Activity) { |
| selectProcessPackages((Activity) e); |
| } |
| } |
| } |
| |
| /** |
| * Adds a method plug-in or package to the closure. |
| * |
| * @param element |
| * A method element. |
| * @param addChildren |
| * if <code>true</code>, add all child method elements. |
| */ |
| private void add(EObject element, boolean addChildren) { |
| if (!LibraryUtil.selectable(element)) { |
| return; |
| } |
| |
| if (!selected.contains(element)) { |
| selected.add(element); |
| |
| // Save the changed nodes so that we can update the status later. |
| addChanged(element); |
| |
| if (element instanceof MethodPlugin) { |
| selectSystemPackages((MethodPlugin) element); |
| } |
| } |
| |
| // Add the parent method element as well. |
| EObject parent = element.eContainer(); |
| if ((parent != null) && !selected.contains(parent)) { |
| add(parent, false); |
| } |
| |
| // Add children as needed. |
| if (addChildren) { |
| EList elements = element.eContents(); |
| if (elements != null) { |
| for (Iterator it = elements.iterator(); it.hasNext();) { |
| EObject child = (EObject) it.next(); |
| add(child, true); |
| } |
| } |
| } |
| } |
| |
| private void addChanged(Object element) { |
| if (!changedNodes.contains(element)) { |
| changedNodes.add(element); |
| } |
| } |
| |
| private void selectSystemPackages(MethodPlugin plugin) { |
| List pkgs = TngUtil.getAllSystemPackages(plugin); |
| for (Iterator it = pkgs.iterator(); it.hasNext();) { |
| EObject pkg = (EObject) it.next(); |
| add(pkg, false); |
| } |
| } |
| |
| /** |
| * Checks whether a method plug-in or package is selected. |
| * |
| * @return <code>true</code> if the given element is selected. |
| */ |
| public boolean isSelected(Object input) { |
| if ((input instanceof MethodLibrary) || input == config |
| || selected.contains(input)) { |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * Gets the element dependency error for a method element. |
| * |
| * @element A method element. |
| * |
| * @return An <code>ElementDependencyError</code>. |
| */ |
| public ElementDependencyError getError(Object element) { |
| return getError(element, false); |
| } |
| |
| private ElementDependencyError getError(Object element, boolean create) { |
| ElementDependencyError error = (ElementDependencyError) invalidNodesMap |
| .get(element); |
| if (error == null && create) { |
| error = new ElementDependencyError(element); |
| invalidNodesMap.put(element, error); |
| } |
| return error; |
| } |
| |
| /** |
| * check if there is error in this configuration closure |
| * |
| * @return boolean |
| */ |
| public boolean hasError() { |
| for (Iterator it = invalidNodesMap.values().iterator(); it.hasNext();) { |
| ElementDependencyError error = (ElementDependencyError) it.next(); |
| if (error.isError()) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * check if there is any problem (error/warning) with this configuration closure. |
| * @return boolean |
| */ |
| public boolean hasProblem() { |
| return invalidNodesMap.size() > 0; |
| } |
| |
| /** |
| * Returns all the errors. |
| * |
| * @return A a list of <code>ErrorInfo</code>. |
| */ |
| public List getAllErrors() { |
| List errors = new ArrayList(); |
| for (Iterator it = invalidNodesMap.values().iterator(); it.hasNext();) { |
| ElementDependencyError error = (ElementDependencyError) it.next(); |
| errors.addAll(error.getAll()); |
| } |
| return errors; |
| } |
| |
| /** |
| * Returns all the dependency errors. |
| * |
| * @return An array of <code>ElementDependencyError</code> |
| */ |
| public Object[] getDependencyErrors() { |
| return invalidNodesMap.values().toArray(); |
| } |
| |
| /** |
| * Returns all the invalid elements. |
| * |
| * @return A list of invalid elements. |
| */ |
| public List getInvalidElements() { |
| return new ArrayList(invalidNodesMap.keySet()); |
| } |
| |
| private void removeError(Object element) { |
| if (invalidNodesMap.containsKey(element)) { |
| invalidNodesMap.remove(element); |
| |
| // Error status changed, add it to the changed list. |
| if (!changedNodes.contains(element)) { |
| changedNodes.add(element); |
| } |
| } |
| } |
| |
| /** |
| * Returns all the changed elements. These are elements whose check states |
| * have changed or whose image have changed due to error. |
| * |
| * @return A list of changed method elements. |
| */ |
| public List getChangedElements() { |
| List items = new ArrayList(changedNodes); |
| for (Iterator it = invalidNodesMap.keySet().iterator(); it.hasNext();) { |
| Object item = it.next(); |
| if (!items.contains(item)) { |
| items.add(item); |
| } |
| } |
| return items; |
| } |
| |
| /** |
| * Returns the method plug-ins and packages selection. |
| * |
| * @return An array of method plug-ins and packages. |
| */ |
| public Object[] getSelection() { |
| return selected.toArray(); |
| } |
| |
| /** |
| * begin the closure update. |
| * |
| */ |
| public void beginUpdate() { |
| changedNodes.clear(); |
| } |
| |
| /** |
| * end the closure update. |
| * |
| */ |
| public void endUpdate() { |
| // Process the changed elements. |
| // Note: additional elements may be added to the changesNodes due to |
| // error status change but only the original changed elements need to be |
| // processed. |
| for (Iterator it = new ArrayList(changedNodes).iterator(); it.hasNext();) { |
| Object changedElement = it.next(); |
| ElementDependency dependency = dependencyManager |
| .getDependency((MethodElement) changedElement); |
| if (dependency == null) { |
| continue; |
| } |
| |
| if (isSelected(changedElement)) { |
| validateSelected(dependency); |
| } else { |
| validateUnSelected(dependency); |
| } |
| } |
| |
| if (debug) { |
| System.out |
| .println("There are (" + invalidNodesMap.size() + ") errors"); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| } |
| |
| /** |
| * Validates the element dependency when the element is selected. When the |
| * element is selected, we need to do the following: 1. Check error for |
| * references 2. Remove error for dependents associated with element 3. |
| * Update parents: if the selection is valid, remove all errors from parents |
| * associated with this element if the selection is invalid, set error to |
| * all parents. |
| * |
| * @param dependency |
| * ElementDependency |
| */ |
| private void validateSelected(ElementDependency dependency) { |
| Object changedElement = dependency.getElement(); |
| |
| // Since this element is selected, remove all previous errors. |
| removeError(changedElement); |
| |
| if (changedElement instanceof MethodLibrary) { |
| return; |
| } |
| |
| // Since this element is selected, remove all dependency errors in the |
| // dependent elements. |
| List dependents = dependency.getDependents(); |
| if (dependents != null && dependents.size() > 0) { |
| Object element; |
| for (Iterator itr = dependents.iterator(); itr.hasNext();) { |
| element = itr.next(); |
| |
| ElementDependencyError error = getError(element, false); |
| if (error != null) { |
| error.removeError(changedElement); |
| if (error.size() == 0) { |
| removeError(element); |
| |
| // Clear the parent error introduced by this element. |
| updateParentsForErrors((EObject) element); |
| |
| } |
| } |
| } |
| } |
| |
| // If an element is checked, check the element it depends on, |
| // which should be checked as well. |
| List refs = dependency.getReferences(); |
| if (refs != null && refs.size() > 0) { |
| PackageReference ref; |
| Object element; |
| for (Iterator itr = refs.iterator(); itr.hasNext();) { |
| ref = (PackageReference) itr.next(); |
| element = ref.getRefElement(); |
| |
| if (element instanceof MethodLibrary) { |
| continue; |
| } |
| |
| // Don't warn on optional inputs not being |
| // present, so added the canIgnore() method |
| if (!isSelected(element) && !canIgnore(ref)) { |
| String message; |
| int errorType = 0; |
| if (ref.hasBaseReference()) { |
| errorType = ErrorInfo.ERROR; |
| message = LibraryResources.configClosureWarning_msg2; |
| } else { |
| errorType = ErrorInfo.WARNING; |
| message = LibraryResources.configClosureWarning_msg3; |
| } |
| |
| ElementDependencyError error = getError(changedElement, |
| true); |
| error.addError(new ErrorInfo(errorType, message, |
| changedElement, element, ErrorInfo.REFERENCE_TO)); |
| } else { |
| ElementDependencyError error = getError(changedElement, |
| false); |
| if (error != null) { |
| error.removeError(element); |
| } |
| } |
| } |
| } |
| |
| // Finally, update the parents. |
| updateParentsForErrors((EObject) changedElement); |
| } |
| |
| /** |
| * Validates the ElementDependency when the element is unselected. When the |
| * element is unselected, we need to do the following: 1. check error for |
| * dependencts 2. remove error for references associated with element, in |
| * case of any added when the element was check 3. update parents: if the |
| * selection is valid, remove all errors from parents associated with this |
| * element if the selection is invalid, set error to all parents. |
| * |
| * @param dependency |
| * A <code>ElementDependency</code> object. |
| */ |
| private void validateUnSelected(ElementDependency dependency) { |
| Object changedElement = dependency.getElement(); |
| |
| // Since this element is un-selected, remove all previous errors. |
| removeError(changedElement); |
| |
| if (changedElement instanceof MethodLibrary) { |
| return; |
| } |
| |
| // Since this element is un-selected, remove all errors in the |
| // referenced elements. |
| List refs = dependency.getReferences(); |
| if (refs != null && refs.size() > 0) { |
| ElementReference ref; |
| Object element; |
| for (Iterator itr = refs.iterator(); itr.hasNext();) { |
| ref = (ElementReference) itr.next(); |
| element = ref.getRefElement(); |
| |
| ElementDependencyError error = getError(element, false); |
| if (error != null) { |
| error.removeError(changedElement); |
| if (error.size() == 0) { |
| removeError(element); |
| |
| // Clear the parent error introduced by this element. |
| updateParentsForErrors((EObject) element); |
| |
| } |
| } |
| } |
| } |
| |
| // If an element is unchecked, check the dependent elements. |
| // If there are check elements depending on it, the element can't be |
| // unchecked. |
| List dependents = dependency.getDependents(); |
| if (dependents != null && dependents.size() > 0) { |
| Object element; |
| for (Iterator itr = dependents.iterator(); itr.hasNext();) { |
| element = itr.next(); |
| |
| if (element instanceof MethodLibrary) { |
| continue; |
| } |
| |
| if (isSelected(element)) { |
| // Determine the type of dependency. |
| ElementDependency childDep = dependencyManager |
| .getDependency((MethodElement) element); |
| |
| validateSelected(childDep); |
| } else { |
| removeError(changedElement); |
| } |
| } |
| } |
| |
| // finally, update the parents |
| updateParentsForErrors((EObject) changedElement); |
| } |
| |
| private void updateParentError(EObject parent, EObject element, |
| int errorType) { |
| if (parent == null || (parent instanceof MethodLibrary)) { |
| return; |
| } |
| |
| if ((parent instanceof MethodPackage) |
| && ConfigurationHelper.isGlobalPackage((MethodPackage) parent)) { |
| updateParentError(parent.eContainer(), element, errorType); |
| return; |
| } |
| |
| // Remove the error associated with this element from all parents. |
| ElementDependencyError error = getError(parent, false); |
| if (error != null && error.size() > 0) { |
| error.removeError(element); |
| } |
| |
| if (errorType != ErrorInfo.NONE) { |
| // Propegate the error to all parents. |
| error = getError(parent, true); |
| String message = LibraryResources.configClosureWarning_msg1; |
| error.addError(new ErrorInfo(errorType, message, parent, element, |
| ErrorInfo.NONE)); |
| } else if ((error != null) && (error.size() == 0)) { |
| removeError(parent); |
| } |
| |
| updateParentError(parent.eContainer(), element, errorType); |
| } |
| |
| private void updateParentsForErrors(EObject element) { |
| int errorType = ErrorInfo.NONE; |
| |
| ElementDependencyError error = getError(element); |
| if (error != null && error.size() > 0) { |
| if (error.isError() || error.isChildError()) { |
| errorType = ErrorInfo.CHILD_ERROR; |
| } else if (error.isWarning() || error.isChildWarning()) { |
| errorType = ErrorInfo.CHILD_WARNING; |
| } |
| } |
| |
| updateParentError(element.eContainer(), element, errorType); |
| } |
| |
| /** |
| * accept the cutrrent selection and ignore any warning message. make the |
| * configuration. |
| * |
| */ |
| public void makeClosure() { |
| // If no error. update the method configuration. |
| while (hasError()) { |
| fixProblems(true); |
| } |
| } |
| |
| /** |
| * fix all error(s) and warnign(s) |
| * |
| */ |
| public void fixProblems() { |
| // If no error, update the method configuration. |
| while (hasProblem()) { |
| fixProblems(false); |
| } |
| } |
| |
| private void fixProblems(boolean errorOnly) { |
| // Note: make closure will select elements as needed. |
| // so we need to make a copy of the current selcted ones |
| // in order to trace the status |
| List currentSelected = new ArrayList(selected); |
| |
| // beginUpdate(); |
| |
| // list of errorInfo objects |
| List errors = getAllErrors(); |
| if (errors.size() > 0) { |
| invalidNodesMap.clear(); |
| ErrorInfo error; |
| EObject ownerElement, causeElement; |
| boolean ownerSelected, causeSelected; |
| for (Iterator it = errors.iterator(); it.hasNext();) { |
| error = (ErrorInfo) it.next(); |
| |
| ownerElement = (EObject) error.getOwnerElement(); |
| causeElement = (EObject) error.getCauseElement(); |
| addChanged(ownerElement); |
| addChanged(causeElement); |
| if (error.isChildError() || error.isChildWarning()) { |
| continue; |
| } |
| |
| if (error.isWarning() && errorOnly) { |
| continue; |
| } |
| |
| ownerSelected = currentSelected.contains(ownerElement); |
| causeSelected = currentSelected.contains(causeElement); |
| |
| // If the owner element is not selected |
| // the error is caused by un-selecting this element, |
| // select it will fix the error |
| |
| // If the owner element is selected, the error is caused by |
| // un-selected references. |
| // select those cause elements will fix the error |
| if (!ownerSelected) { |
| selectErrorElement(ownerElement); |
| } else if (!causeSelected) { |
| selectErrorElement(causeElement); |
| } |
| } |
| } |
| |
| endUpdate(); |
| } |
| |
| private void selectErrorElement(EObject element) { |
| // The selection is based on a package level. When a non-package element |
| // is selected, all it's non-package siblings must be selected as well. |
| if (LibraryUtil.selectable(element)) { |
| add(element, true); |
| } |
| } |
| |
| /** |
| * update the method configuration in the library with the current selections |
| */ |
| public void saveMethodConfiguration() { |
| List plugins = config.getMethodPluginSelection(); |
| List packages = config.getMethodPackageSelection(); |
| |
| plugins.clear(); |
| packages.clear(); |
| |
| EObject element; |
| for (Iterator it = selected.iterator(); it.hasNext();) { |
| element = (EObject) it.next(); |
| if (element instanceof MethodPlugin) { |
| if (!plugins.contains(element)) { |
| plugins.add(element); |
| } |
| } else if ((element instanceof MethodPackage) |
| && !ConfigurationHelper |
| .isGlobalPackage((MethodPackage) element)) { |
| if (!packages.contains(element)) { |
| packages.add(element); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Packages the library based on the selection. |
| * <p> |
| * Note: This will change the current library. Before calling this method, a |
| * copy of the current library should be created with the following steps: |
| * 1. Create a new <code>ConfigurationManager</code> with a copy of the |
| * original library, 2. Rebuild the dependency, 3. Create a |
| * <code>ConfigurationClosure</code> with the current configuration. |
| * |
| * @return A <code>MethodLibrary</code>. |
| */ |
| public MethodLibrary packageLibrary(boolean removeBrokenReferences) { |
| processSelection(library, removeBrokenReferences); |
| |
| // Remove the configurations except for the current one. |
| List configs = library.getPredefinedConfigurations(); |
| configs.clear(); |
| configs.add(config); |
| |
| return library; |
| } |
| |
| /** |
| * process the selected package by removeing all unselected elements and any |
| * missing references |
| * |
| * @param element |
| */ |
| private void processSelection(EObject element, |
| boolean removeBrokenReferences) { |
| if (removeBrokenReferences) { |
| // Iterator the references and remove broken references. |
| EList references = element.eCrossReferences(); |
| if (references != null) { |
| for (Iterator it = new ArrayList(references).iterator(); it |
| .hasNext();) { |
| EObject ref = (EObject) it.next(); |
| EObject pkgRef = LibraryUtil.getSelectable(ref); |
| if (pkgRef != null && !isSelected(pkgRef)) { |
| removeReference(element, ref); |
| } |
| } |
| } |
| } |
| |
| EList elements = element.eContents(); |
| if (elements != null) { |
| for (Iterator it = new ArrayList(elements).iterator(); it.hasNext();) { |
| EObject child = (EObject) it.next(); |
| |
| // If the child element is selectable but it is not in the |
| // configuration, remove it. |
| if (LibraryUtil.selectable(child) && !isSelected(child)) { |
| EcoreUtil.remove(child); |
| } else { |
| processSelection(child, removeBrokenReferences); |
| } |
| } |
| } |
| } |
| |
| private void removeReference(EObject ownerElement, EObject refElement) { |
| AdapterFactoryContentProvider provider = configManager |
| .getContentProvider(); |
| IPropertySource ps = provider.getPropertySource(ownerElement); |
| IPropertyDescriptor[] pds = ps.getPropertyDescriptors(); |
| if (pds != null && pds.length > 0) { |
| for (int i = 0; i < pds.length; i++) { |
| IPropertyDescriptor descriptor = (IPropertyDescriptor) pds[i]; |
| Object id = descriptor.getId(); |
| Object value = ps.getPropertyValue(id); |
| |
| // Check whether the value needs to be converted to an editable |
| // value. |
| IPropertySource source = provider.getPropertySource(value); |
| if (source != null) { |
| value = source.getEditableValue(); |
| } |
| if (value instanceof EList) { |
| EList refList = (EList) value; |
| if (refList.contains(refElement)) { |
| if (debug) { |
| System.out |
| .println("Reference [" + LibraryUtil.getName(refElement) //$NON-NLS-1$ |
| + "] removed from [" //$NON-NLS-1$ |
| + LibraryUtil.getName(ownerElement) |
| + "]'s reference list"); //$NON-NLS-1$ |
| } |
| refList.remove(refElement); |
| ps.setPropertyValue(id, refList); |
| } |
| } else if (value instanceof MethodElement) { |
| if (debug) { |
| System.out |
| .println("Reference [" + LibraryUtil.getName(refElement) //$NON-NLS-1$ |
| + "] removed from [" //$NON-NLS-1$ |
| + LibraryUtil.getName(ownerElement) |
| + "]"); //$NON-NLS-1$ |
| } |
| ps.setPropertyValue(id, null); |
| } |
| |
| } |
| } |
| } |
| |
| /** |
| * Disposes resources allocated by this closure. |
| */ |
| public void dispose() { |
| configManager = null; |
| config = null; |
| library = null; |
| dependencyManager = null; |
| selected.clear(); |
| changedNodes.clear(); |
| invalidNodesMap.clear(); |
| } |
| |
| private boolean canIgnore(PackageReference pkgRef) { |
| return pkgRef.canIgnore(); |
| } |
| |
| } |