Attachment #10314 for bug #59258

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




package org.eclipse.jdt.core;

import java.io.File;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;

import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IMarkerDelta;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceChangeEvent;
import org.eclipse.core.resources.IResourceChangeListener;
import org.eclipse.core.resources.ISavedState;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.IWorkspaceRunnable;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Plugin;
import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.core.runtime.preferences.DefaultScope;
import org.eclipse.core.runtime.preferences.IEclipsePreferences;
import org.eclipse.core.runtime.preferences.IPreferencesService;
import org.eclipse.core.runtime.preferences.InstanceScope;
import org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.compiler.util.SuffixConstants;
import org.eclipse.jdt.internal.core.Assert;
import org.eclipse.jdt.internal.core.BatchOperation;
import org.eclipse.jdt.internal.core.BufferFactoryWrapper;
import org.eclipse.jdt.internal.core.BufferManager;
import org.eclipse.jdt.internal.core.ClasspathEntry;
import org.eclipse.jdt.internal.core.DefaultWorkingCopyOwner;
import org.eclipse.jdt.internal.core.JavaModel;
import org.eclipse.jdt.internal.core.JavaModelManager;
import org.eclipse.jdt.internal.core.JavaProject;
import org.eclipse.jdt.internal.core.Region;
import org.eclipse.jdt.internal.core.SetClasspathOperation;
import org.eclipse.jdt.internal.core.UserLibraryManager;
import org.eclipse.jdt.internal.core.search.processing.IJob;
import org.eclipse.jdt.internal.core.util.MementoTokenizer;
import org.eclipse.jdt.internal.core.util.Util;
import org.osgi.framework.BundleContext;
import org.osgi.service.prefs.BackingStoreException;

/**
 * The plug-in runtime class for the Java model plug-in containing the core

	public static final String PRIVATE = "private"; //$NON-NLS-1$
	
	/**
	 * New Preferences API
	 * @since 3.1
	 */
	public static final IEclipsePreferences[] preferencesLookup = new IEclipsePreferences[2];
	static final int PREF_INSTANCE = 0;
	static final int PREF_DEFAULT = 1;

	/**
	 * Creates the Java core plug-in.
	 * <p>
	 * The plug-in instance is created automatically by the 

	 * </p>
	 * 
	 * @param listener the listener
	 * @see #removePreProcessingResourceChangedListener(IResourceChangeListener)
	 * @since 3.0
	 */
	public static void addPreProcessingResourceChangedListener(IResourceChangeListener listener) {

		Hashtable defaultOptions = new Hashtable(10);

		// see #initializeDefaultPluginPreferences() for changing default settings
		IEclipsePreferences defaultPreferences = getDefaultPreferences();
		HashSet optionNames = JavaModelManager.getJavaModelManager().optionNames;
		
		// initialize preferences to their default
		Iterator iterator = optionNames.iterator();
		while (iterator.hasNext()) {
		    String propertyName = (String) iterator.next();
		    String value = defaultPreferences.get(propertyName, null);
		    if (value != null) defaultOptions.put(propertyName, value);
		}
		// get encoding through resource plugin
		defaultOptions.put(CORE_ENCODING, getEncoding());

		
		return defaultOptions;
	}
 
	/**
	 * @since 3.1
	 */
	public static IEclipsePreferences getInstancePreferences() {
		if (preferencesLookup[PREF_INSTANCE] == null) {
			preferencesLookup[PREF_INSTANCE] = new InstanceScope().getNode(PLUGIN_ID);
		}
		return preferencesLookup[PREF_INSTANCE];
	}
 
	/**
	 * @since 3.1
	 */
	public static IEclipsePreferences getDefaultPreferences() {
		if (preferencesLookup[PREF_DEFAULT] == null) {
			preferencesLookup[PREF_DEFAULT] = new DefaultScope().getNode(PLUGIN_ID);
		}
		return preferencesLookup[PREF_DEFAULT];
	}

	/**
	 * Returns the workspace root default charset encoding.

	 * @since 3.0
	 */
	public static String getEncoding() {
		// Verify that workspace is not shutting down (see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=60687)
		IWorkspace workspace = ResourcesPlugin.getWorkspace();
		if (workspace != null) {
			try {
				return workspace.getRoot().getDefaultCharset();
			} catch (CoreException e) {
				// fails silently and return plugin global encoding if core exception occurs
			}
		}
		return ResourcesPlugin.getEncoding();
	}


	 * @param optionName the name of an option
	 * @return the String value of a given option
	 * @see JavaCore#getDefaultOptions()
	 * @see #initializeDefaultPreferences() for changing default settings
	 * @since 2.0
	 */
	public static String getOption(String optionName) {

		}
		String propertyName = optionName;
		if (JavaModelManager.getJavaModelManager().optionNames.contains(propertyName)){
			IPreferencesService service = Platform.getPreferencesService();
			String value =  service.get(optionName, null, preferencesLookup);
			return value==null ? null : value.trim();
		}
		return null;
	}

	 * 
	 * @return table of current settings of all options 
	 *   (key type: <code>String</code>; value type: <code>String</code>)
	 * @see #getDefaultOptions()
	 * @see #initializeDefaultPreferences() for changing default settings
	 */
	public static Hashtable getOptions() {

		// init
		Hashtable options = new Hashtable(10);
		HashSet optionNames = JavaModelManager.getJavaModelManager().optionNames;
		IPreferencesService service = Platform.getPreferencesService();

		// set options using preferences service lookup
		Iterator iterator = optionNames.iterator();
		while (iterator.hasNext()) {
		    String propertyName = (String) iterator.next();
		    String propertyValue = service.get(propertyName, null, preferencesLookup);
		    if (propertyValue != null) {
			    options.put(propertyName, propertyValue);
		    }
			while (iterator.hasNext()) {
			    String propertyName = (String) iterator.next();
			    options.put(propertyName, preferences.getDefaultString(propertyName));
			}
			// get preferences not set to their default
			String[] propertyNames = preferences.propertyNames();
			for (int i = 0; i < propertyNames.length; i++){
				String propertyName = propertyNames[i];
				String value = preferences.getString(propertyName).trim();
				if (optionNames.contains(propertyName)){
					options.put(propertyName, value);
				}
			}
			// get encoding through resource plugin
			options.put(CORE_ENCODING, getEncoding()); 
			// backward compatibility
			options.put(COMPILER_PB_INVALID_IMPORT, ERROR);
			options.put(COMPILER_PB_UNREACHABLE_CODE, ERROR);
		}

		// get encoding through resource plugin
		options.put(CORE_ENCODING, getEncoding()); 

		// backward compatibility
		options.put(COMPILER_PB_INVALID_IMPORT, ERROR);
		options.put(COMPILER_PB_UNREACHABLE_CODE, ERROR);

		// return built map
		return options;
	}


		if (result == null) return JavaModelManager.NO_WORKING_COPY;
		return result;
	}

	/*
	 * Initializes the default preferences settings for this plug-in.
	 */
	protected void initializeDefaultPreferences() {
		
		// Init and store default and instance preferences
		IEclipsePreferences defaultPreferences = getDefaultPreferences();
		
		Preferences preferences = getPluginPreferences();
		HashSet optionNames = JavaModelManager.getJavaModelManager().optionNames;
		
		// Compiler settings

		for (Iterator iter = compilerOptionsMap.entrySet().iterator(); iter.hasNext();) {
			Map.Entry entry = (Map.Entry) iter.next();
			String optionName = (String) entry.getKey();
			defaultPreferences.put(optionName, (String)entry.getValue());
			optionNames.add(optionName);
		}
		// override some compiler defaults
		defaultPreferences.put(COMPILER_LOCAL_VARIABLE_ATTR, GENERATE);
		defaultPreferences.put(COMPILER_CODEGEN_UNUSED_LOCAL, PRESERVE);
		defaultPreferences.put(COMPILER_TASK_TAGS, DEFAULT_TASK_TAGS);
		defaultPreferences.put(COMPILER_TASK_PRIORITIES, DEFAULT_TASK_PRIORITIES);
		defaultPreferences.put(COMPILER_TASK_CASE_SENSITIVE, ENABLED);
		defaultPreferences.put(COMPILER_DOC_COMMENT_SUPPORT, ENABLED);

		// Builder settings
		defaultPreferences.put(CORE_JAVA_BUILD_RESOURCE_COPY_FILTER, ""); //$NON-NLS-1$
		optionNames.add(CORE_JAVA_BUILD_RESOURCE_COPY_FILTER);

		defaultPreferences.put(CORE_JAVA_BUILD_INVALID_CLASSPATH, ABORT); 
		optionNames.add(CORE_JAVA_BUILD_INVALID_CLASSPATH);
	
		defaultPreferences.put(CORE_JAVA_BUILD_DUPLICATE_RESOURCE, WARNING); 
		optionNames.add(CORE_JAVA_BUILD_DUPLICATE_RESOURCE);
		
		defaultPreferences.put(CORE_JAVA_BUILD_CLEAN_OUTPUT_FOLDER, CLEAN); 
		optionNames.add(CORE_JAVA_BUILD_CLEAN_OUTPUT_FOLDER);

		// JavaCore settings
		defaultPreferences.put(CORE_JAVA_BUILD_ORDER, IGNORE); 
		optionNames.add(CORE_JAVA_BUILD_ORDER);
	
		defaultPreferences.put(CORE_INCOMPLETE_CLASSPATH, ERROR); 
		optionNames.add(CORE_INCOMPLETE_CLASSPATH);
		
		defaultPreferences.put(CORE_CIRCULAR_CLASSPATH, ERROR); 
		optionNames.add(CORE_CIRCULAR_CLASSPATH);
		
		defaultPreferences.put(CORE_INCOMPATIBLE_JDK_LEVEL, IGNORE); 
		optionNames.add(CORE_INCOMPATIBLE_JDK_LEVEL);
		
		defaultPreferences.put(CORE_ENABLE_CLASSPATH_EXCLUSION_PATTERNS, ENABLED); 
		optionNames.add(CORE_ENABLE_CLASSPATH_EXCLUSION_PATTERNS);

		defaultPreferences.put(CORE_ENABLE_CLASSPATH_MULTIPLE_OUTPUT_LOCATIONS, ENABLED); 
		optionNames.add(CORE_ENABLE_CLASSPATH_MULTIPLE_OUTPUT_LOCATIONS);

		// encoding setting comes from resource plug-in

		for (Iterator iter = codeFormatterOptionsMap.entrySet().iterator(); iter.hasNext();) {
			Map.Entry entry = (Map.Entry) iter.next();
			String optionName = (String) entry.getKey();
			defaultPreferences.put(optionName, (String)entry.getValue());
			optionNames.add(optionName);
		}		
		defaultPreferences.put(FORMATTER_NEWLINE_OPENING_BRACE, DO_NOT_INSERT); 
		optionNames.add(FORMATTER_NEWLINE_OPENING_BRACE);

		defaultPreferences.put(FORMATTER_NEWLINE_CONTROL, DO_NOT_INSERT);
		optionNames.add(FORMATTER_NEWLINE_CONTROL);

		defaultPreferences.put(FORMATTER_CLEAR_BLANK_LINES, PRESERVE_ONE); 
		optionNames.add(FORMATTER_CLEAR_BLANK_LINES);

		defaultPreferences.put(FORMATTER_NEWLINE_ELSE_IF, DO_NOT_INSERT);
		optionNames.add(FORMATTER_NEWLINE_ELSE_IF);

		defaultPreferences.put(FORMATTER_NEWLINE_EMPTY_BLOCK, INSERT); 
		optionNames.add(FORMATTER_NEWLINE_EMPTY_BLOCK);

		defaultPreferences.put(FORMATTER_LINE_SPLIT, "80"); //$NON-NLS-1$
		optionNames.add(FORMATTER_LINE_SPLIT);

		defaultPreferences.put(FORMATTER_COMPACT_ASSIGNMENT, NORMAL); 
		optionNames.add(FORMATTER_COMPACT_ASSIGNMENT);

		defaultPreferences.put(FORMATTER_TAB_CHAR, TAB); 
		optionNames.add(FORMATTER_TAB_CHAR);

		defaultPreferences.put(FORMATTER_TAB_SIZE, "4"); //$NON-NLS-1$ 
		optionNames.add(FORMATTER_TAB_SIZE);
		
		defaultPreferences.put(FORMATTER_SPACE_CASTEXPRESSION, INSERT); //$NON-NLS-1$ 
		optionNames.add(FORMATTER_SPACE_CASTEXPRESSION);

		// CodeAssist settings
		defaultPreferences.put(CODEASSIST_VISIBILITY_CHECK, DISABLED); //$NON-NLS-1$
		optionNames.add(CODEASSIST_VISIBILITY_CHECK);

		defaultPreferences.put(CODEASSIST_IMPLICIT_QUALIFICATION, DISABLED); //$NON-NLS-1$
		optionNames.add(CODEASSIST_IMPLICIT_QUALIFICATION);
		
		defaultPreferences.put(CODEASSIST_FIELD_PREFIXES, ""); //$NON-NLS-1$
		optionNames.add(CODEASSIST_FIELD_PREFIXES);
		
		defaultPreferences.put(CODEASSIST_STATIC_FIELD_PREFIXES, ""); //$NON-NLS-1$
		optionNames.add(CODEASSIST_STATIC_FIELD_PREFIXES);
		
		defaultPreferences.put(CODEASSIST_LOCAL_PREFIXES, ""); //$NON-NLS-1$
		optionNames.add(CODEASSIST_LOCAL_PREFIXES);
		
		defaultPreferences.put(CODEASSIST_ARGUMENT_PREFIXES, ""); //$NON-NLS-1$
		optionNames.add(CODEASSIST_ARGUMENT_PREFIXES);
		
		defaultPreferences.put(CODEASSIST_FIELD_SUFFIXES, ""); //$NON-NLS-1$
		optionNames.add(CODEASSIST_FIELD_SUFFIXES);
		
		defaultPreferences.put(CODEASSIST_STATIC_FIELD_SUFFIXES, ""); //$NON-NLS-1$
		optionNames.add(CODEASSIST_STATIC_FIELD_SUFFIXES);
		
		defaultPreferences.put(CODEASSIST_LOCAL_SUFFIXES, ""); //$NON-NLS-1$
		optionNames.add(CODEASSIST_LOCAL_SUFFIXES);
		
		defaultPreferences.put(CODEASSIST_ARGUMENT_SUFFIXES, ""); //$NON-NLS-1$
		optionNames.add(CODEASSIST_ARGUMENT_SUFFIXES);
	}
	

	 * @param newOptions the new options (key type: <code>String</code>; value type: <code>String</code>),
	 *   or <code>null</code> to reset all options to their default values
	 * @see JavaCore#getDefaultOptions()
	 * @see #initializeDefaultPreferences() for changing default settings
	 */
	public static void setOptions(Hashtable newOptions) {
		
		try {
			IEclipsePreferences defaultPreferences = getDefaultPreferences();
			IEclipsePreferences instancePreferences = getInstancePreferences();

			if (newOptions == null){
				instancePreferences.clear();
			} else {
				Enumeration keys = newOptions.keys();
				while (keys.hasMoreElements()){
					String key = (String)keys.nextElement();
					if (!JavaModelManager.getJavaModelManager().optionNames.contains(key)) continue; // unrecognized option
					if (key.equals(CORE_ENCODING)) continue; // skipped, contributed by resource prefs
					String value = (String)newOptions.get(key);
					String defaultValue = defaultPreferences.get(key, null);
					if (defaultValue != null && defaultValue.equals(value)) {
						instancePreferences.remove(key);
					} else {
						instancePreferences.put(key, value);
					}
				}
			}

			// persist options
			instancePreferences.flush();
		} catch (BackingStoreException e) {
			// fails silently
		}
	}

	/* (non-Javadoc)

	public void start(BundleContext context) throws Exception {
		super.start(context);
		
		// init preferences
		initializeDefaultPreferences();

		final JavaModelManager manager = JavaModelManager.getJavaModelManager();
		try {
			manager.configurePluginDebugOptions();

			JavaCore.getPlugin().getStateLocation();

			// retrieve variable values
			getInstancePreferences().addPreferenceChangeListener(new JavaModelManager.EclipsePreferencesListener());
			manager.loadVariablesAndContainers();

			final IWorkspace workspace = ResourcesPlugin.getWorkspace();




import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.Preferences;
import org.eclipse.jdt.core.*;
import org.eclipse.jdt.core.ElementChangedEvent;
import org.eclipse.jdt.core.IClasspathEntry;

			}
			this.removeFromParentInfo(javaProject);

			// remove preferences from per project info
			this.manager.resetProjectPreferences(javaProject);	
		} catch (JavaModelException e) {
			// java project doesn't exist: ignore
		}

				}
		}
	}
	/*
	 * Update the JavaModel according to a .jprefs file change. The file can have changed as a result of a previous
	 * call to JavaProject#setOptions or as a result of some user update (through repository)
	 * Unused until preference file get shared (.jpref)
	 */
	void reconcilePreferenceFileUpdate(IResourceDelta delta, IFile file, JavaProject project) {
			
		switch (delta.getKind()) {
			case IResourceDelta.REMOVED : // flush project custom settings
				project.setOptions(null);
				return;
			case IResourceDelta.CHANGED :
				if ((delta.getFlags() & IResourceDelta.CONTENT) == 0  // only consider content change
						&& (delta.getFlags() & IResourceDelta.MOVED_FROM) == 0) // and also move and overide scenario
					break;
				identityCheck : { // check if any actual difference
					// force to (re)read the property file
					Preferences filePreferences = project.loadPreferences();
					if (filePreferences == null){ 
						project.setOptions(null); // should have got removed delta.
						return;
					}
					Preferences projectPreferences = project.getPreferences();
					if (projectPreferences == null) return; // not a Java project
						
					// compare preferences set to their default
					String[] defaultProjectPropertyNames = projectPreferences.defaultPropertyNames();
					String[] defaultFilePropertyNames = filePreferences.defaultPropertyNames();
					if (defaultProjectPropertyNames.length == defaultFilePropertyNames.length) {
						for (int i = 0; i < defaultProjectPropertyNames.length; i++){
							String propertyName = defaultProjectPropertyNames[i];
							if (!projectPreferences.getString(propertyName).trim().equals(filePreferences.getString(propertyName).trim())){
								break identityCheck;
							}
						}		
					} else break identityCheck;

					// compare custom preferences not set to their default
					String[] projectPropertyNames = projectPreferences.propertyNames();
					String[] filePropertyNames = filePreferences.propertyNames();
					if (projectPropertyNames.length == filePropertyNames.length) {
						for (int i = 0; i < projectPropertyNames.length; i++){
						String propertyName = projectPropertyNames[i];
							if (!projectPreferences.getString(propertyName).trim().equals(filePreferences.getString(propertyName).trim())){
								break identityCheck;
							}
						}		
					} else break identityCheck;
					
					// identical - do nothing
					return;
				}
			case IResourceDelta.ADDED :
				// not identical, create delta and reset cached preferences
				project.setPreferences(null);
				// create delta
				//fCurrentDelta.changed(project, IJavaElementDelta.F_OPTIONS_CHANGED);				
		}
	}
	/*
	 * Traverse the set of projects which have changed namespace, and reset their 
	 * caches and their dependents




 *******************************************************************************/
package org.eclipse.jdt.internal.core;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.StringReader;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.WeakHashMap;
import java.util.zip.ZipFile;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ISaveContext;
import org.eclipse.core.resources.ISaveParticipant;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceDescription;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Plugin;
import org.eclipse.core.runtime.QualifiedName;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.preferences.IEclipsePreferences;
import org.eclipse.jdt.core.IClassFile;
import org.eclipse.jdt.core.IClasspathContainer;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.IParent;
import org.eclipse.jdt.core.IProblemRequestor;
import org.eclipse.jdt.core.JavaConventions;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.WorkingCopyOwner;
import org.eclipse.jdt.core.compiler.IProblem;
import org.eclipse.jdt.core.search.SearchEngine;
import org.eclipse.jdt.internal.codeassist.CompletionEngine;

import org.eclipse.jdt.internal.core.search.indexing.IndexManager;
import org.eclipse.jdt.internal.core.search.processing.JobManager;
import org.eclipse.jdt.internal.core.util.Util;
import org.osgi.service.prefs.BackingStoreException;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

		public IClasspathEntry[] resolvedClasspath;
		public Map resolvedPathToRawEntries; // reverse map from resolved path to raw entries
		public IPath outputLocation;
		public IEclipsePreferences preferences;
		
		public PerProjectInfo(IProject project) {


		public String toString() {
			StringBuffer buffer = new StringBuffer();
			buffer.append("Info for "); //$NON-NLS-1$
			buffer.append(((JavaElement)this.workingCopy).toStringWithAncestors());
			buffer.append("\nUse count = "); //$NON-NLS-1$
			buffer.append(this.useCount);
			buffer.append("\nProblem requestor:\n  "); //$NON-NLS-1$

	/**
	 * Update the classpath variable cache
	 */
	public static class EclipsePreferencesListener implements IEclipsePreferences.IPreferenceChangeListener {
		/**
		 * @see org.eclipse.core.runtime.preferences.IEclipsePreferences.IPreferenceChangeListener#preferenceChange(org.eclipse.core.runtime.preferences.IEclipsePreferences.PreferenceChangeEvent)
		 */
		public void preferenceChange(IEclipsePreferences.PreferenceChangeEvent event) {
			String propertyName = event.getKey();
			String propertyName = event.getProperty();
			if (propertyName.startsWith(CP_VARIABLE_PREFERENCES_PREFIX)) {
				String varName = propertyName.substring(CP_VARIABLE_PREFERENCES_PREFIX.length());
				String newValue = (String)event.getNewValue();

	 * Returns the new use count (or -1 if it didn't exist).
	 */
	public synchronized int discardPerWorkingCopyInfo(CompilationUnit workingCopy) throws JavaModelException {
		synchronized(this.perWorkingCopyInfos) {
			WorkingCopyOwner owner = workingCopy.owner;
			Map workingCopyToInfos = (Map)this.perWorkingCopyInfos.get(owner);
			if (workingCopyToInfos == null) return -1;

	 * Returns the handle to the active Java Model.
	 */
	public final JavaModel getJavaModel() {
		return this.javaModel;
	}

	/**

	 * Returns the per-project info for the given project. If specified, create the info if the info doesn't exist.
	 */
	public PerProjectInfo getPerProjectInfo(IProject project, boolean create) {
		synchronized(this.perProjectInfos) { // use the perProjectInfo collection as its own lock
			PerProjectInfo info= (PerProjectInfo) this.perProjectInfos.get(project);
			if (info == null && create) {
				info= new PerProjectInfo(project);
				this.perProjectInfos.put(project, info);
			}
			return info;
		}

	 * Returns null if it doesn't exist and not create.
	 */
	public PerWorkingCopyInfo getPerWorkingCopyInfo(CompilationUnit workingCopy,boolean create, boolean recordUsage, IProblemRequestor problemRequestor) {
		synchronized(this.perWorkingCopyInfos) { // use the perWorkingCopyInfo collection as its own lock
			WorkingCopyOwner owner = workingCopy.owner;
			Map workingCopyToInfos = (Map)this.perWorkingCopyInfos.get(owner);
			if (workingCopyToInfos == null && create) {

	 * Returns null if it has none.
	 */
	public ICompilationUnit[] getWorkingCopies(WorkingCopyOwner owner, boolean addPrimary) {
		synchronized(this.perWorkingCopyInfos) {
			ICompilationUnit[] primaryWCs = addPrimary && owner != DefaultWorkingCopyOwner.PRIMARY 
				? getWorkingCopies(DefaultWorkingCopyOwner.PRIMARY, false) 
				: null;
			Map workingCopyToInfos = (Map)this.perWorkingCopyInfos.get(owner);
			if (workingCopyToInfos == null) return primaryWCs;
			int primaryLength = primaryWCs == null ? 0 : primaryWCs.length;
			int size = workingCopyToInfos.size(); // note size is > 0 otherwise pathToPerWorkingCopyInfos would be null

		}
		
		// load variables and containers from preferences into cache
		IEclipsePreferences preferences = JavaCore.getInstancePreferences();

		// only get variable from preferences not set to their default
		try {
			String[] propertyNames = preferences.keys();
			int variablePrefixLength = CP_VARIABLE_PREFERENCES_PREFIX.length();
			for (int i = 0; i < propertyNames.length; i++){
				String propertyName = propertyNames[i];
				if (propertyName.startsWith(CP_VARIABLE_PREFERENCES_PREFIX)){
					String varName = propertyName.substring(variablePrefixLength);
					String propertyValue = preferences.get(propertyName, null);
					if (propertyValue != null) {
						IPath varPath = new Path(propertyValue.trim());
						this.variables.put(varName, varPath); 
						this.previousSessionVariables.put(varName, varPath);
					}
				}
				if (propertyName.startsWith(CP_CONTAINER_PREFERENCES_PREFIX)){
					String propertyValue = preferences.get(propertyName, null);
					if (propertyValue != null)
						recreatePersistedContainer(propertyName, propertyValue, true/*add to container values*/);
				}
			}
		} catch (BackingStoreException e1) {
			// TODO (frederic) see if it's necessary to report this failure...
		}
		// override persisted values for variables which have a registered initializer
		String[] registeredVariables = getRegisteredVariableNames();

	}	

	public void removePerProjectInfo(JavaProject javaProject) {
		synchronized(this.perProjectInfos) { // use the perProjectInfo collection as its own lock
			IProject project = javaProject.getProject();
			PerProjectInfo info= (PerProjectInfo) this.perProjectInfos.get(project);
			if (info != null) {
				this.perProjectInfos.remove(project);
			}
		}
	}

	/*
	 * Reset project preferences stored in info cache.
	 */
	public void resetProjectPreferences(JavaProject javaProject) {
		synchronized(this.perProjectInfos) { // use the perProjectInfo collection as its own lock
			IProject project = javaProject.getProject();
			PerProjectInfo info= (PerProjectInfo) this.perProjectInfos.get(project);
			if (info != null) {
				info.preferences = null;
			}
		}
	}

	public void saving(ISaveContext context) throws CoreException {
		
	    // save container values on snapshot/full save
		Preferences preferences = JavaCore.getPlugin().getPluginPreferences();
		IJavaProject[] projects = getJavaModel().getJavaProjects();
		for (int i = 0, length = projects.length; i < length; i++) {
		    IJavaProject project = projects[i];

				} catch(JavaModelException e){
					// could not encode entry: leave it as CP_ENTRY_IGNORE
				}
				JavaCore.getDefaultPreferences().put(containerKey, CP_ENTRY_IGNORE); // TODO (frederic) verify if this is really necessary...
				JavaCore.getInstancePreferences().put(containerKey, containerString);
			}
		}
		try {
			JavaCore.getInstancePreferences().flush();
		} catch (BackingStoreException e) {
			// TODO (frederic) see if it's necessary to report this exception
			// IStatus status = new Status(IStatus.ERROR, JavaCore.PLUGIN_ID, IStatus.ERROR, "Problems while saving context", e); //$NON-NLS-1$
			// throw new CoreException(status);
		}
		
		if (context.getKind() == ISaveContext.FULL_SAVE) {
			// will need delta since this save (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=38658)

		}

		ArrayList vStats= null; // lazy initialized
		for (Iterator iter =  this.perProjectInfos.values().iterator(); iter.hasNext();) {
			try {
				PerProjectInfo info = (PerProjectInfo) iter.next();
				saveState(info, context);

			}
		}

		Preferences preferences = JavaCore.getPlugin().getPluginPreferences();
		String variableKey = CP_VARIABLE_PREFERENCES_PREFIX+variableName;
		String variableString = variablePath == null ? CP_ENTRY_IGNORE : variablePath.toString();
		JavaCore.getDefaultPreferences().put(variableKey, CP_ENTRY_IGNORE); // TODO (frederic) verify if this is really necessary...
		JavaCore.getInstancePreferences().put(variableKey, variableString);
		try {
			JavaCore.getInstancePreferences().flush();
		} catch (BackingStoreException e) {
			// TODO (frederic) see if it's necessary to report this exception
//			IStatus status = new Status(IStatus.ERROR, Platform.PI_RUNTIME, IStatus.ERROR, "Problems while saving context", e); //$NON-NLS-1$
//			throw new CoreException(status);
		}
	}
}




package org.eclipse.jdt.internal.core;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.StringReader;
import java.util.ArrayList;

import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.eclipse.core.resources.ICommand;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;

import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ProjectScope;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Preferences;
import org.eclipse.core.runtime.QualifiedName;
import org.eclipse.core.runtime.preferences.IEclipsePreferences;
import org.eclipse.core.runtime.preferences.IPreferencesService;
import org.eclipse.core.runtime.preferences.IScopeContext;
import org.eclipse.jdt.core.IClasspathContainer;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.ICompilationUnit;

import org.eclipse.jdt.internal.core.util.MementoTokenizer;
import org.eclipse.jdt.internal.core.util.Util;
import org.eclipse.jdt.internal.eval.EvaluationContext;
import org.osgi.service.prefs.BackingStoreException;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;


	/**
	 * Name of file containing custom project preferences
	 * @deprecated WARNING Visibility will be reduce to private before M9
	 * 	If you use this variable, change your implementation to avoid future comilation error...
	 * @see <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=59258">bug 59258</a>
	 * TODO (frederic) set visibility from public to private
	 */
	public static final String PREF_FILENAME = ".jprefs";  //$NON-NLS-1$
	

	 * Value of the project's raw classpath if the .classpath file contains invalid entries.
	 */
	public static final IClasspathEntry[] INVALID_CLASSPATH = new IClasspathEntry[0];

	private static final String CUSTOM_DEFAULT_OPTION_VALUE = "#\r\n\r#custom-non-empty-default-value#\r\n\r#"; //$NON-NLS-1$
	
	/**
	 * Returns a canonicalized path from the given external path.

		
		String propertyName = optionName;
		if (JavaModelManager.getJavaModelManager().optionNames.contains(propertyName)){
			IEclipsePreferences preferences = getEclipsePreferences();
			String javaCoreDefault = inheritJavaCoreOptions ? JavaCore.getOption(propertyName) : null;
			if (preferences == null) return javaCoreDefault;
			String value = preferences.get(propertyName, javaCoreDefault);
			return value == null ? null : value.trim();
		}
		return null;
	}

		// initialize to the defaults from JavaCore options pool
		Map options = inheritJavaCoreOptions ? JavaCore.getOptions() : new Hashtable(5);

		IEclipsePreferences preferences = getEclipsePreferences();
		if (preferences == null) return options; // cannot do better (non-Java project)
		HashSet optionNames = JavaModelManager.getJavaModelManager().optionNames;
		
		// project cannot hold custom preferences set to their default, as it uses CUSTOM_DEFAULT_OPTION_VALUE

		// get custom preferences not set to their default
		try {
			String[] propertyNames = preferences.keys();
			for (int i = 0; i < propertyNames.length; i++){
				String propertyName = propertyNames[i];
				String value = preferences.get(propertyName, null);
				if (value != null && optionNames.contains(propertyName)){
					options.put(propertyName, value.trim());
				}
			}		
		} catch (BackingStoreException e) {
			// nothing to do
		}

		return options;
	}

	public JavaModelManager.PerProjectInfo getPerProjectInfo() throws JavaModelException {
		return JavaModelManager.getJavaModelManager().getPerProjectInfoCheckExistence(this.project);
	}

	/**
	 * @see IJavaProject#getProject()
	 */

	/**
	 * Returns the project custom preference pool.
	 * Project preferences may include custom encoding.
	 * @return IEclipsePreferences
	 */	
	public IEclipsePreferences getEclipsePreferences(){
		if (!JavaProject.hasJavaNature(this.project)) return null;
		JavaModelManager.PerProjectInfo perProjectInfo = JavaModelManager.getJavaModelManager().getPerProjectInfo(this.project, true);
		IEclipsePreferences eclipsePreferences =  perProjectInfo.preferences;
		if (eclipsePreferences != null) return eclipsePreferences;
		IScopeContext context = new ProjectScope(getProject());
		eclipsePreferences = context.getNode(JavaCore.PLUGIN_ID);
		updatePreferences(eclipsePreferences);
		perProjectInfo.preferences = eclipsePreferences;
		return eclipsePreferences;
	}

	/**
	 * Returns the project custom preference pool.
	 * Project preferences may include custom encoding.
	 * @return Preferences
	 * @deprecated WARNING:  this method do nothing from now and will be removed soon!
	 * 	If you use it, switch as soon as possible to new preferences API by using 
	 * 	{@link #getEclipsePreferences()} to avoid future compilation error...
	 * @see <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=59258">bug 59258</a>
	 * TODO (frederic) remove for 3.1...
	 */
	public Preferences getPreferences(){
		/*
		if (!JavaProject.hasJavaNature(this.project)) return null;
		JavaModelManager.PerProjectInfo perProjectInfo = JavaModelManager.getJavaModelManager().getPerProjectInfo(this.project, true);
		Preferences preferences =  perProjectInfo.preferences;

		if (preferences == null) preferences = new Preferences();
		perProjectInfo.preferences = preferences;
		return preferences;
		*/
		return new Preferences();
	}

	/**

	}	

	/*
	 * Update eclipse preferences from old preferences.
	 */
	 private void updatePreferences(IEclipsePreferences preferences) {
	 	
	 	Preferences oldPreferences = loadPreferences();
	 	IPreferencesService service = Platform.getPreferencesService();
	 	if (oldPreferences != null) {
	 		String[] propertyNames = oldPreferences.propertyNames();
			for (int i = 0; i < propertyNames.length; i++){
				String propertyName = propertyNames[i];
			    String propertyValue = oldPreferences.getString(propertyName);
				String defaultValue = service.get(propertyName, null, JavaCore.preferencesLookup);
			    if (!"".equals(propertyValue) && (defaultValue == null || !propertyValue.equals(defaultValue))) { //$NON-NLS-1$
				    preferences.put(propertyName, propertyValue);
			    }
			}
			try {
				// save immediately old preferences
				preferences.flush();
			} catch (BackingStoreException e) {
				// fails silently
			}
		}
	 }

	/**
	 * load preferences from a shareable format (VCM-wise)
	 * @deprecated WARNING, visibility of this method will be decreased soon
	 * 	to private and won't be usable in the future.
	 * @see <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=59258">bug 59258</a>
	 * TODO (frederic) set visibility from public to private
	 */
	 public Preferences loadPreferences() {
	 	
	 	Preferences preferences = new Preferences();
	 	IPath projectMetaLocation = getPluginWorkingLocation();
//		File prefFile = this.project.getLocation().append(PREF_FILENAME).toFile();
		IPath projectMetaLocation = getPluginWorkingLocation();
		if (projectMetaLocation != null) {
			File prefFile = projectMetaLocation.append(PREF_FILENAME).toFile();
			if (prefFile.exists()) { // load preferences from file

				try {
					in = new BufferedInputStream(new FileInputStream(prefFile));
					preferences.load(in);
					return preferences;
				} catch (IOException e) { // problems loading preference store - quietly ignore
				} finally {
					if (in != null) {

						}
					}
				}
				// one shot read, delete old preferences
				prefFile.delete();
				return preferences;
			}
		}
		return null;
	 }

	/**
	 * @see IJavaProject#newEvaluationContext()
	 */

			throw new JavaModelException(e);
		}
	}
	/**
	 * Save project custom preferences to shareable file (.jprefs)
	 */
	private void savePreferences(Preferences preferences) {
		
		if (!JavaProject.hasJavaNature(this.project)) return; // ignore
		
		if (preferences == null || (!preferences.needsSaving() && preferences.propertyNames().length != 0)) {
			// nothing to save
			return;
		}
	
		// preferences need to be saved
		// the preferences file is located in the plug-in's state area
		// at a well-known name (.jprefs)
//		File prefFile = this.project.getLocation().append(PREF_FILENAME).toFile();
		File prefFile = getPluginWorkingLocation().append(PREF_FILENAME).toFile();
		if (preferences.propertyNames().length == 0) {
			// there are no preference settings
			// rather than write an empty file, just delete any existing file
			if (prefFile.exists()) {
				prefFile.delete(); // don't worry if delete unsuccessful
			}
			return;
		}
		
		// write file, overwriting an existing one
		OutputStream out = null;
		try {
			// do it as carefully as we know how so that we don't lose/mangle
			// the setting in times of stress
			out = new BufferedOutputStream(new FileOutputStream(prefFile));
			preferences.store(out, null);
		} catch (IOException e) { // problems saving preference store - quietly ignore
		} finally {
			if (out != null) {
				try {
					out.close();
				} catch (IOException e) { // ignore problems with close
				}
			}
		}
	}

	/**
	 * Update the Java command in the build spec (replace existing one if present,

	 */
	public void setOption(String optionName, String optionValue) {
		if (!JavaModelManager.getJavaModelManager().optionNames.contains(optionName)) return; // unrecognized option
		IEclipsePreferences projectPreferences = getEclipsePreferences();
		String defaultValue = JavaCore.getOption(optionName);
		if (defaultValue == null || !defaultValue.equals(optionValue)) {
			projectPreferences.put(optionName, optionValue);
			try {
				projectPreferences.flush();
			} catch (BackingStoreException e) {
				// problem with pref store - quietly ignore
			}
		}
	}

	/**

	 */
	public void setOptions(Map newOptions) {

		IEclipsePreferences projectPreferences = getEclipsePreferences();
		try {
			if (newOptions == null){
				projectPreferences.clear();
			} else {
				Iterator keys = newOptions.keySet().iterator();
				while (keys.hasNext()){
					String key = (String)keys.next();
					if (!JavaModelManager.getJavaModelManager().optionNames.contains(key)) continue; // unrecognized option
					// no filtering for encoding (custom encoding for project is allowed)
					String value = (String)newOptions.get(key);
					projectPreferences.put(key, value);
				}
				
				// reset to default all options not in new map
				// @see https://bugs.eclipse.org/bugs/show_bug.cgi?id=26255
				// @see https://bugs.eclipse.org/bugs/show_bug.cgi?id=49691
				String[] pNames = projectPreferences.keys();
				int ln = pNames.length;
				for (int i=0; i<ln; i++) {
					String key = pNames[i];
					if (!newOptions.containsKey(key)) {
						projectPreferences.remove(key); // old preferences => remove from preferences table
					}
				}
			}
		}

			// persist options
			projectPreferences.flush();
		} catch (BackingStoreException e) {
			// problem with pref store - quietly ignore
		}
	}

	/**

			return;
		}
		this.setRawClasspath(SetClasspathOperation.ReuseClasspath, path, monitor);
	}

	/*
	 * Set cached preferences, no preference file is saved, only info is updated
	 */
	public void setPreferences(Preferences preferences) {
		if (!JavaProject.hasJavaNature(this.project)) return; // ignore
		JavaModelManager.PerProjectInfo perProjectInfo = JavaModelManager.getJavaModelManager().getPerProjectInfo(this.project, true);
		perProjectInfo.preferences = preferences;
	}

	/**




import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Preferences;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.core.runtime.preferences.IEclipsePreferences;
import org.eclipse.core.runtime.Preferences.PropertyChangeEvent;
import org.eclipse.jdt.core.IClasspathContainer;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.internal.core.util.Util;
import org.osgi.service.prefs.BackingStoreException;

/**
 *


	private static Map userLibraries;
	private static final boolean logProblems= false;
	private static IEclipsePreferences.IPreferenceChangeListener listener= new IEclipsePreferences.IPreferenceChangeListener() {

		public void preferenceChange(IEclipsePreferences.PreferenceChangeEvent event) {
			String key= event.getKey();
			if (key.startsWith(CP_USERLIBRARY_PREFERENCES_PREFIX)) {
				try {
					recreatePersistedUserLibraryEntry(key, (String) event.getNewValue(), false, true);

				}
			}
		}
		
	};
	
	private UserLibraryManager() {

		if (userLibraries == null) {
			userLibraries= new HashMap();
			// load variables and containers from preferences into cache
			IEclipsePreferences instancePreferences = JavaCore.getInstancePreferences();
			instancePreferences.addPreferenceChangeListener(listener);

			// only get variable from preferences not set to their default
			try {
				String[] propertyNames = instancePreferences.keys();
				for (int i = 0; i < propertyNames.length; i++) {
					String propertyName = propertyNames[i];
					if (propertyName.startsWith(CP_USERLIBRARY_PREFERENCES_PREFIX)) {
						try {
							String propertyValue = instancePreferences.get(propertyName, null);
							if (propertyValue != null)
								recreatePersistedUserLibraryEntry(propertyName,propertyValue, false, false);
						} catch (JavaModelException e) {
							// won't happen: no rebinding
						}
					}
				}
			} catch (BackingStoreException e) {
				// TODO (frederic) see if it's necessary to report this exception
			}
		}
		return userLibraries;

			}
		}
		
		IEclipsePreferences instancePreferences = JavaCore.getInstancePreferences();
		String containerKey = CP_USERLIBRARY_PREFERENCES_PREFIX+name;
		String containerString = CP_ENTRY_IGNORE;
		if (library != null) {

				// could not encode entry: leave it as CP_ENTRY_IGNORE
			}
		}
		instancePreferences.removePreferenceChangeListener(listener);
		try {
			JavaCore.getDefaultPreferences().put(containerKey, CP_ENTRY_IGNORE); // TODO (frederic) verify if this is really necessary...
			instancePreferences.put(containerKey, containerString);
			if (save) {
				try {
					instancePreferences.flush();
				} catch (BackingStoreException e) {
					// TODO (frederic) see if it's necessary to report this exception
				}
			}
			if (rebind) {
				rebindClasspathEntries(name, monitor);
			}
			
		} finally {
			instancePreferences.addPreferenceChangeListener(listener);
		}
	}


Return to bug 59258

Lines 31-37 Link Here

(-)model/org/eclipse/jdt/internal/core/DeltaProcessor.java (-59 / +2 lines)
31	import org.eclipse.core.runtime.CoreException;	31	import org.eclipse.core.runtime.CoreException;
32	import org.eclipse.core.runtime.IPath;	32	import org.eclipse.core.runtime.IPath;
33	import org.eclipse.core.runtime.IProgressMonitor;	33	import org.eclipse.core.runtime.IProgressMonitor;
34	import org.eclipse.core.runtime.Preferences;
35	import org.eclipse.jdt.core.*;	34	import org.eclipse.jdt.core.*;
36	import org.eclipse.jdt.core.ElementChangedEvent;	35	import org.eclipse.jdt.core.ElementChangedEvent;
37	import org.eclipse.jdt.core.IClasspathEntry;	36	import org.eclipse.jdt.core.IClasspathEntry;
Lines 912-917 Link Here
912	}	911	}
913	this.removeFromParentInfo(javaProject);	912	this.removeFromParentInfo(javaProject);
914		913
		914	// remove preferences from per project info
		915	this.manager.resetProjectPreferences(javaProject);
915	} catch (JavaModelException e) {	916	} catch (JavaModelException e) {
916	// java project doesn't exist: ignore	917	// java project doesn't exist: ignore
917	}	918	}
Lines 1719-1783 Link Here
1719	}	1720	}
1720	}	1721	}
1721	}	1722	}
1722	/*
1723	* Update the JavaModel according to a .jprefs file change. The file can have changed as a result of a previous
1724	* call to JavaProject#setOptions or as a result of some user update (through repository)
1725	* Unused until preference file get shared (.jpref)
1726	*/
1727	void reconcilePreferenceFileUpdate(IResourceDelta delta, IFile file, JavaProject project) {
1728
1729	switch (delta.getKind()) {
1730	case IResourceDelta.REMOVED : // flush project custom settings
1731	project.setOptions(null);
1732	return;
1733	case IResourceDelta.CHANGED :
1734	if ((delta.getFlags() & IResourceDelta.CONTENT) == 0 // only consider content change
1735	&& (delta.getFlags() & IResourceDelta.MOVED_FROM) == 0) // and also move and overide scenario
1736	break;
1737	identityCheck : { // check if any actual difference
1738	// force to (re)read the property file
1739	Preferences filePreferences = project.loadPreferences();
1740	if (filePreferences == null){
1741	project.setOptions(null); // should have got removed delta.
1742	return;
1743	}
1744	Preferences projectPreferences = project.getPreferences();
1745	if (projectPreferences == null) return; // not a Java project
1746
1747	// compare preferences set to their default
1748	String[] defaultProjectPropertyNames = projectPreferences.defaultPropertyNames();
1749	String[] defaultFilePropertyNames = filePreferences.defaultPropertyNames();
1750	if (defaultProjectPropertyNames.length == defaultFilePropertyNames.length) {
1751	for (int i = 0; i < defaultProjectPropertyNames.length; i++){
1752	String propertyName = defaultProjectPropertyNames[i];
1753	if (!projectPreferences.getString(propertyName).trim().equals(filePreferences.getString(propertyName).trim())){
1754	break identityCheck;
1755	}
1756	}
1757	} else break identityCheck;
1758		1723
1759	// compare custom preferences not set to their default
1760	String[] projectPropertyNames = projectPreferences.propertyNames();
1761	String[] filePropertyNames = filePreferences.propertyNames();
1762	if (projectPropertyNames.length == filePropertyNames.length) {
1763	for (int i = 0; i < projectPropertyNames.length; i++){
1764	String propertyName = projectPropertyNames[i];
1765	if (!projectPreferences.getString(propertyName).trim().equals(filePreferences.getString(propertyName).trim())){
1766	break identityCheck;
1767	}
1768	}
1769	} else break identityCheck;
1770
1771	// identical - do nothing
1772	return;
1773	}
1774	case IResourceDelta.ADDED :
1775	// not identical, create delta and reset cached preferences
1776	project.setPreferences(null);
1777	// create delta
1778	//fCurrentDelta.changed(project, IJavaElementDelta.F_OPTIONS_CHANGED);
1779	}
1780	}
1781	/*	1724	/*
1782	* Traverse the set of projects which have changed namespace, and reset their	1725	* Traverse the set of projects which have changed namespace, and reset their
1783	* caches and their dependents	1726	* caches and their dependents

Lines 22-37 Link Here

(-)model/org/eclipse/jdt/internal/core/UserLibraryManager.java (-23 / +31 lines)
22	import org.eclipse.core.runtime.IProgressMonitor;	22	import org.eclipse.core.runtime.IProgressMonitor;
23	import org.eclipse.core.runtime.NullProgressMonitor;	23	import org.eclipse.core.runtime.NullProgressMonitor;
24	import org.eclipse.core.runtime.Path;	24	import org.eclipse.core.runtime.Path;
25	import org.eclipse.core.runtime.Preferences;
26	import org.eclipse.core.runtime.SubProgressMonitor;	25	import org.eclipse.core.runtime.SubProgressMonitor;
27	import org.eclipse.core.runtime.Preferences.IPropertyChangeListener;	26	import org.eclipse.core.runtime.preferences.IEclipsePreferences;
28	import org.eclipse.core.runtime.Preferences.PropertyChangeEvent;
29	import org.eclipse.jdt.core.IClasspathContainer;	27	import org.eclipse.jdt.core.IClasspathContainer;
30	import org.eclipse.jdt.core.IClasspathEntry;	28	import org.eclipse.jdt.core.IClasspathEntry;
31	import org.eclipse.jdt.core.IJavaProject;	29	import org.eclipse.jdt.core.IJavaProject;
32	import org.eclipse.jdt.core.JavaCore;	30	import org.eclipse.jdt.core.JavaCore;
33	import org.eclipse.jdt.core.JavaModelException;	31	import org.eclipse.jdt.core.JavaModelException;
34	import org.eclipse.jdt.internal.core.util.Util;	32	import org.eclipse.jdt.internal.core.util.Util;
		33	import org.osgi.service.prefs.BackingStoreException;
35		34
36	/**	35	/**
37	*	36	*
Lines 43-52 Link Here
43		42
44	private static Map userLibraries;	43	private static Map userLibraries;
45	private static final boolean logProblems= false;	44	private static final boolean logProblems= false;
46	private static IPropertyChangeListener listener= new IPropertyChangeListener() {	45	private static IEclipsePreferences.IPreferenceChangeListener listener= new IEclipsePreferences.IPreferenceChangeListener() {
47		46
48	public void propertyChange(PropertyChangeEvent event) {	47	public void preferenceChange(IEclipsePreferences.PreferenceChangeEvent event) {
49	String key= event.getProperty();	48	String key= event.getKey();
50	if (key.startsWith(CP_USERLIBRARY_PREFERENCES_PREFIX)) {	49	if (key.startsWith(CP_USERLIBRARY_PREFERENCES_PREFIX)) {
51	try {	50	try {
52	recreatePersistedUserLibraryEntry(key, (String) event.getNewValue(), false, true);	51	recreatePersistedUserLibraryEntry(key, (String) event.getNewValue(), false, true);
Lines 58-64 Link Here
58	}	57	}
59	}	58	}
60	}	59	}
61
62	};	60	};
63		61
64	private UserLibraryManager() {	62	private UserLibraryManager() {
Lines 126-145 Link Here
126	if (userLibraries == null) {	124	if (userLibraries == null) {
127	userLibraries= new HashMap();	125	userLibraries= new HashMap();
128	// load variables and containers from preferences into cache	126	// load variables and containers from preferences into cache
129	Preferences preferences = JavaCore.getPlugin().getPluginPreferences();	127	IEclipsePreferences instancePreferences = JavaCore.getInstancePreferences();
130	preferences.addPropertyChangeListener(listener);	128	instancePreferences.addPreferenceChangeListener(listener);
131		129
132	// only get variable from preferences not set to their default	130	// only get variable from preferences not set to their default
133	String[] propertyNames = preferences.propertyNames();	131	try {
134	for (int i = 0; i < propertyNames.length; i++) {	132	String[] propertyNames = instancePreferences.keys();
135	String propertyName = propertyNames[i];	133	for (int i = 0; i < propertyNames.length; i++) {
136	if (propertyName.startsWith(CP_USERLIBRARY_PREFERENCES_PREFIX)) {	134	String propertyName = propertyNames[i];
137	try {	135	if (propertyName.startsWith(CP_USERLIBRARY_PREFERENCES_PREFIX)) {
138	recreatePersistedUserLibraryEntry(propertyName, preferences.getString(propertyName), false, false);	136	try {
139	} catch (JavaModelException e) {	137	String propertyValue = instancePreferences.get(propertyName, null);
140	// won't happen: no rebinding	138	if (propertyValue != null)
		139	recreatePersistedUserLibraryEntry(propertyName,propertyValue, false, false);
		140	} catch (JavaModelException e) {
		141	// won't happen: no rebinding
		142	}
141	}	143	}
142	}	144	}
		145	} catch (BackingStoreException e) {
		146	// TODO (frederic) see if it's necessary to report this exception
143	}	147	}
144	}	148	}
145	return userLibraries;	149	return userLibraries;
Lines 178-184 Link Here
178	}	182	}
179	}	183	}
180		184
181	Preferences preferences = JavaCore.getPlugin().getPluginPreferences();	185	IEclipsePreferences instancePreferences = JavaCore.getInstancePreferences();
182	String containerKey = CP_USERLIBRARY_PREFERENCES_PREFIX+name;	186	String containerKey = CP_USERLIBRARY_PREFERENCES_PREFIX+name;
183	String containerString = CP_ENTRY_IGNORE;	187	String containerString = CP_ENTRY_IGNORE;
184	if (library != null) {	188	if (library != null) {
Lines 188-206 Link Here
188	// could not encode entry: leave it as CP_ENTRY_IGNORE	192	// could not encode entry: leave it as CP_ENTRY_IGNORE
189	}	193	}
190	}	194	}
191	preferences.removePropertyChangeListener(listener);	195	instancePreferences.removePreferenceChangeListener(listener);
192	try {	196	try {
193	preferences.setDefault(containerKey, CP_ENTRY_IGNORE); // use this default to get rid of removed ones	197	JavaCore.getDefaultPreferences().put(containerKey, CP_ENTRY_IGNORE); // TODO (frederic) verify if this is really necessary...
194	preferences.setValue(containerKey, containerString);	198	instancePreferences.put(containerKey, containerString);
195	if (save) {	199	if (save) {
196	JavaCore.getPlugin().savePluginPreferences();	200	try {
		201	instancePreferences.flush();
		202	} catch (BackingStoreException e) {
		203	// TODO (frederic) see if it's necessary to report this exception
		204	}
197	}	205	}
198	if (rebind) {	206	if (rebind) {
199	rebindClasspathEntries(name, monitor);	207	rebindClasspathEntries(name, monitor);
200	}	208	}
201		209
202	} finally {	210	} finally {
203	preferences.addPropertyChangeListener(listener);	211	instancePreferences.addPreferenceChangeListener(listener);
204	}	212	}
205	}	213	}
206		214

Lines 10-27 Link Here

(-)model/org/eclipse/jdt/internal/core/JavaModelManager.java (-48 / +125 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.jdt.internal.core;	11	package org.eclipse.jdt.internal.core;
12		12
13	import java.io.*;	13	import java.io.BufferedInputStream;
		14	import java.io.BufferedOutputStream;
		15	import java.io.DataInputStream;
		16	import java.io.DataOutputStream;
		17	import java.io.File;
		18	import java.io.FileInputStream;
		19	import java.io.FileOutputStream;
		20	import java.io.IOException;
		21	import java.io.StringReader;
14	import java.text.NumberFormat;	22	import java.text.NumberFormat;
15	import java.util.*;	23	import java.util.ArrayList;
		24	import java.util.HashMap;
		25	import java.util.HashSet;
		26	import java.util.Iterator;
		27	import java.util.Map;
		28	import java.util.WeakHashMap;
16	import java.util.zip.ZipFile;	29	import java.util.zip.ZipFile;
17
18	import javax.xml.parsers.DocumentBuilder;	30	import javax.xml.parsers.DocumentBuilder;
19	import javax.xml.parsers.DocumentBuilderFactory;	31	import javax.xml.parsers.DocumentBuilderFactory;
20	import javax.xml.parsers.ParserConfigurationException;	32	import javax.xml.parsers.ParserConfigurationException;
21		33	import org.eclipse.core.resources.IFile;
22	import org.eclipse.core.resources.*;	34	import org.eclipse.core.resources.IFolder;
23	import org.eclipse.core.runtime.*;	35	import org.eclipse.core.resources.IProject;
24	import org.eclipse.jdt.core.*;	36	import org.eclipse.core.resources.IResource;
		37	import org.eclipse.core.resources.ISaveContext;
		38	import org.eclipse.core.resources.ISaveParticipant;
		39	import org.eclipse.core.resources.IWorkspace;
		40	import org.eclipse.core.resources.IWorkspaceDescription;
		41	import org.eclipse.core.resources.IWorkspaceRoot;
		42	import org.eclipse.core.resources.ResourcesPlugin;
		43	import org.eclipse.core.runtime.CoreException;
		44	import org.eclipse.core.runtime.IConfigurationElement;
		45	import org.eclipse.core.runtime.IExtension;
		46	import org.eclipse.core.runtime.IExtensionPoint;
		47	import org.eclipse.core.runtime.IPath;
		48	import org.eclipse.core.runtime.IProgressMonitor;
		49	import org.eclipse.core.runtime.IStatus;
		50	import org.eclipse.core.runtime.MultiStatus;
		51	import org.eclipse.core.runtime.Path;
		52	import org.eclipse.core.runtime.Platform;
		53	import org.eclipse.core.runtime.Plugin;
		54	import org.eclipse.core.runtime.QualifiedName;
		55	import org.eclipse.core.runtime.Status;
		56	import org.eclipse.core.runtime.preferences.IEclipsePreferences;
		57	import org.eclipse.jdt.core.IClassFile;
		58	import org.eclipse.jdt.core.IClasspathContainer;
		59	import org.eclipse.jdt.core.IClasspathEntry;
		60	import org.eclipse.jdt.core.ICompilationUnit;
		61	import org.eclipse.jdt.core.IJavaElement;
		62	import org.eclipse.jdt.core.IJavaProject;
		63	import org.eclipse.jdt.core.IPackageFragment;
		64	import org.eclipse.jdt.core.IPackageFragmentRoot;
		65	import org.eclipse.jdt.core.IParent;
		66	import org.eclipse.jdt.core.IProblemRequestor;
		67	import org.eclipse.jdt.core.JavaConventions;
		68	import org.eclipse.jdt.core.JavaCore;
		69	import org.eclipse.jdt.core.JavaModelException;
		70	import org.eclipse.jdt.core.WorkingCopyOwner;
25	import org.eclipse.jdt.core.compiler.IProblem;	71	import org.eclipse.jdt.core.compiler.IProblem;
26	import org.eclipse.jdt.core.search.SearchEngine;	72	import org.eclipse.jdt.core.search.SearchEngine;
27	import org.eclipse.jdt.internal.codeassist.CompletionEngine;	73	import org.eclipse.jdt.internal.codeassist.CompletionEngine;
Lines 33-38 Link Here
33	import org.eclipse.jdt.internal.core.search.indexing.IndexManager;	79	import org.eclipse.jdt.internal.core.search.indexing.IndexManager;
34	import org.eclipse.jdt.internal.core.search.processing.JobManager;	80	import org.eclipse.jdt.internal.core.search.processing.JobManager;
35	import org.eclipse.jdt.internal.core.util.Util;	81	import org.eclipse.jdt.internal.core.util.Util;
		82	import org.osgi.service.prefs.BackingStoreException;
36	import org.w3c.dom.Element;	83	import org.w3c.dom.Element;
37	import org.w3c.dom.Node;	84	import org.w3c.dom.Node;
38	import org.w3c.dom.NodeList;	85	import org.w3c.dom.NodeList;
Lines 497-503 Link Here
497	public IClasspathEntry[] resolvedClasspath;	544	public IClasspathEntry[] resolvedClasspath;
498	public Map resolvedPathToRawEntries; // reverse map from resolved path to raw entries	545	public Map resolvedPathToRawEntries; // reverse map from resolved path to raw entries
499	public IPath outputLocation;	546	public IPath outputLocation;
500	public Preferences preferences;	547	public IEclipsePreferences preferences;
501		548
502	public PerProjectInfo(IProject project) {	549	public PerProjectInfo(IProject project) {
503		550
Lines 576-582 Link Here
576	public String toString() {	623	public String toString() {
577	StringBuffer buffer = new StringBuffer();	624	StringBuffer buffer = new StringBuffer();
578	buffer.append("Info for "); //$NON-NLS-1$	625	buffer.append("Info for "); //$NON-NLS-1$
579	buffer.append(((JavaElement)workingCopy).toStringWithAncestors());	626	buffer.append(((JavaElement)this.workingCopy).toStringWithAncestors());
580	buffer.append("\nUse count = "); //$NON-NLS-1$	627	buffer.append("\nUse count = "); //$NON-NLS-1$
581	buffer.append(this.useCount);	628	buffer.append(this.useCount);
582	buffer.append("\nProblem requestor:\n "); //$NON-NLS-1$	629	buffer.append("\nProblem requestor:\n "); //$NON-NLS-1$
Lines 599-611 Link Here
599	/**	646	/**
600	* Update the classpath variable cache	647	* Update the classpath variable cache
601	*/	648	*/
602	public static class PluginPreferencesListener implements Preferences.IPropertyChangeListener {	649	public static class EclipsePreferencesListener implements IEclipsePreferences.IPreferenceChangeListener {
603	/**	650	/**
604	* @see org.eclipse.core.runtime.Preferences.IPropertyChangeListener#propertyChange(PropertyChangeEvent)	651	* @see org.eclipse.core.runtime.preferences.IEclipsePreferences.IPreferenceChangeListener#preferenceChange(org.eclipse.core.runtime.preferences.IEclipsePreferences.PreferenceChangeEvent)
605	*/	652	*/
606	public void propertyChange(Preferences.PropertyChangeEvent event) {	653	public void preferenceChange(IEclipsePreferences.PreferenceChangeEvent event) {
607		654	String propertyName = event.getKey();
608	String propertyName = event.getProperty();
609	if (propertyName.startsWith(CP_VARIABLE_PREFERENCES_PREFIX)) {	655	if (propertyName.startsWith(CP_VARIABLE_PREFERENCES_PREFIX)) {
610	String varName = propertyName.substring(CP_VARIABLE_PREFERENCES_PREFIX.length());	656	String varName = propertyName.substring(CP_VARIABLE_PREFERENCES_PREFIX.length());
611	String newValue = (String)event.getNewValue();	657	String newValue = (String)event.getNewValue();
Lines 711-717 Link Here
711	* Returns the new use count (or -1 if it didn't exist).	757	* Returns the new use count (or -1 if it didn't exist).
712	*/	758	*/
713	public synchronized int discardPerWorkingCopyInfo(CompilationUnit workingCopy) throws JavaModelException {	759	public synchronized int discardPerWorkingCopyInfo(CompilationUnit workingCopy) throws JavaModelException {
714	synchronized(perWorkingCopyInfos) {	760	synchronized(this.perWorkingCopyInfos) {
715	WorkingCopyOwner owner = workingCopy.owner;	761	WorkingCopyOwner owner = workingCopy.owner;
716	Map workingCopyToInfos = (Map)this.perWorkingCopyInfos.get(owner);	762	Map workingCopyToInfos = (Map)this.perWorkingCopyInfos.get(owner);
717	if (workingCopyToInfos == null) return -1;	763	if (workingCopyToInfos == null) return -1;
Lines 811-817 Link Here
811	* Returns the handle to the active Java Model.	857	* Returns the handle to the active Java Model.
812	*/	858	*/
813	public final JavaModel getJavaModel() {	859	public final JavaModel getJavaModel() {
814	return javaModel;	860	return this.javaModel;
815	}	861	}
816		862
817	/**	863	/**
Lines 847-857 Link Here
847	* Returns the per-project info for the given project. If specified, create the info if the info doesn't exist.	893	* Returns the per-project info for the given project. If specified, create the info if the info doesn't exist.
848	*/	894	*/
849	public PerProjectInfo getPerProjectInfo(IProject project, boolean create) {	895	public PerProjectInfo getPerProjectInfo(IProject project, boolean create) {
850	synchronized(perProjectInfos) { // use the perProjectInfo collection as its own lock	896	synchronized(this.perProjectInfos) { // use the perProjectInfo collection as its own lock
851	PerProjectInfo info= (PerProjectInfo) perProjectInfos.get(project);	897	PerProjectInfo info= (PerProjectInfo) this.perProjectInfos.get(project);
852	if (info == null && create) {	898	if (info == null && create) {
853	info= new PerProjectInfo(project);	899	info= new PerProjectInfo(project);
854	perProjectInfos.put(project, info);	900	this.perProjectInfos.put(project, info);
855	}	901	}
856	return info;	902	return info;
857	}	903	}
Lines 880-886 Link Here
880	* Returns null if it doesn't exist and not create.	926	* Returns null if it doesn't exist and not create.
881	*/	927	*/
882	public PerWorkingCopyInfo getPerWorkingCopyInfo(CompilationUnit workingCopy,boolean create, boolean recordUsage, IProblemRequestor problemRequestor) {	928	public PerWorkingCopyInfo getPerWorkingCopyInfo(CompilationUnit workingCopy,boolean create, boolean recordUsage, IProblemRequestor problemRequestor) {
883	synchronized(perWorkingCopyInfos) { // use the perWorkingCopyInfo collection as its own lock	929	synchronized(this.perWorkingCopyInfos) { // use the perWorkingCopyInfo collection as its own lock
884	WorkingCopyOwner owner = workingCopy.owner;	930	WorkingCopyOwner owner = workingCopy.owner;
885	Map workingCopyToInfos = (Map)this.perWorkingCopyInfos.get(owner);	931	Map workingCopyToInfos = (Map)this.perWorkingCopyInfos.get(owner);
886	if (workingCopyToInfos == null && create) {	932	if (workingCopyToInfos == null && create) {
Lines 976-986 Link Here
976	* Returns null if it has none.	1022	* Returns null if it has none.
977	*/	1023	*/
978	public ICompilationUnit[] getWorkingCopies(WorkingCopyOwner owner, boolean addPrimary) {	1024	public ICompilationUnit[] getWorkingCopies(WorkingCopyOwner owner, boolean addPrimary) {
979	synchronized(perWorkingCopyInfos) {	1025	synchronized(this.perWorkingCopyInfos) {
980	ICompilationUnit[] primaryWCs = addPrimary && owner != DefaultWorkingCopyOwner.PRIMARY	1026	ICompilationUnit[] primaryWCs = addPrimary && owner != DefaultWorkingCopyOwner.PRIMARY
981	? getWorkingCopies(DefaultWorkingCopyOwner.PRIMARY, false)	1027	? getWorkingCopies(DefaultWorkingCopyOwner.PRIMARY, false)
982	: null;	1028	: null;
983	Map workingCopyToInfos = (Map)perWorkingCopyInfos.get(owner);	1029	Map workingCopyToInfos = (Map)this.perWorkingCopyInfos.get(owner);
984	if (workingCopyToInfos == null) return primaryWCs;	1030	if (workingCopyToInfos == null) return primaryWCs;
985	int primaryLength = primaryWCs == null ? 0 : primaryWCs.length;	1031	int primaryLength = primaryWCs == null ? 0 : primaryWCs.length;
986	int size = workingCopyToInfos.size(); // note size is > 0 otherwise pathToPerWorkingCopyInfos would be null	1032	int size = workingCopyToInfos.size(); // note size is > 0 otherwise pathToPerWorkingCopyInfos would be null
Lines 1099-1121 Link Here
1099	}	1145	}
1100		1146
1101	// load variables and containers from preferences into cache	1147	// load variables and containers from preferences into cache
1102	Preferences preferences = JavaCore.getPlugin().getPluginPreferences();	1148	IEclipsePreferences preferences = JavaCore.getInstancePreferences();
1103		1149
1104	// only get variable from preferences not set to their default	1150	// only get variable from preferences not set to their default
1105	String[] propertyNames = preferences.propertyNames();	1151	try {
1106	int variablePrefixLength = CP_VARIABLE_PREFERENCES_PREFIX.length();	1152	String[] propertyNames = preferences.keys();
1107	for (int i = 0; i < propertyNames.length; i++){	1153	int variablePrefixLength = CP_VARIABLE_PREFERENCES_PREFIX.length();
1108	String propertyName = propertyNames[i];	1154	for (int i = 0; i < propertyNames.length; i++){
1109	if (propertyName.startsWith(CP_VARIABLE_PREFERENCES_PREFIX)){	1155	String propertyName = propertyNames[i];
1110	String varName = propertyName.substring(variablePrefixLength);	1156	if (propertyName.startsWith(CP_VARIABLE_PREFERENCES_PREFIX)){
1111	IPath varPath = new Path(preferences.getString(propertyName).trim());	1157	String varName = propertyName.substring(variablePrefixLength);
1112		1158	String propertyValue = preferences.get(propertyName, null);
1113	this.variables.put(varName, varPath);	1159	if (propertyValue != null) {
1114	this.previousSessionVariables.put(varName, varPath);	1160	IPath varPath = new Path(propertyValue.trim());
1115	}	1161	this.variables.put(varName, varPath);
1116	if (propertyName.startsWith(CP_CONTAINER_PREFERENCES_PREFIX)){	1162	this.previousSessionVariables.put(varName, varPath);
1117	recreatePersistedContainer(propertyName, preferences.getString(propertyName), true/add to container values/);	1163	}
		1164	}
		1165	if (propertyName.startsWith(CP_CONTAINER_PREFERENCES_PREFIX)){
		1166	String propertyValue = preferences.get(propertyName, null);
		1167	if (propertyValue != null)
		1168	recreatePersistedContainer(propertyName, propertyValue, true/add to container values/);
		1169	}
1118	}	1170	}
		1171	} catch (BackingStoreException e1) {
		1172	// TODO (frederic) see if it's necessary to report this failure...
1119	}	1173	}
1120	// override persisted values for variables which have a registered initializer	1174	// override persisted values for variables which have a registered initializer
1121	String[] registeredVariables = getRegisteredVariableNames();	1175	String[] registeredVariables = getRegisteredVariableNames();
Lines 1313-1323 Link Here
1313	}	1367	}
1314		1368
1315	public void removePerProjectInfo(JavaProject javaProject) {	1369	public void removePerProjectInfo(JavaProject javaProject) {
1316	synchronized(perProjectInfos) { // use the perProjectInfo collection as its own lock	1370	synchronized(this.perProjectInfos) { // use the perProjectInfo collection as its own lock
		1371	IProject project = javaProject.getProject();
		1372	PerProjectInfo info= (PerProjectInfo) this.perProjectInfos.get(project);
		1373	if (info != null) {
		1374	this.perProjectInfos.remove(project);
		1375	}
		1376	}
		1377	}
		1378
		1379	/*
		1380	* Reset project preferences stored in info cache.
		1381	*/
		1382	public void resetProjectPreferences(JavaProject javaProject) {
		1383	synchronized(this.perProjectInfos) { // use the perProjectInfo collection as its own lock
1317	IProject project = javaProject.getProject();	1384	IProject project = javaProject.getProject();
1318	PerProjectInfo info= (PerProjectInfo) perProjectInfos.get(project);	1385	PerProjectInfo info= (PerProjectInfo) this.perProjectInfos.get(project);
1319	if (info != null) {	1386	if (info != null) {
1320	perProjectInfos.remove(project);	1387	info.preferences = null;
1321	}	1388	}
1322	}	1389	}
1323	}	1390	}
Lines 1399-1405 Link Here
1399	public void saving(ISaveContext context) throws CoreException {	1466	public void saving(ISaveContext context) throws CoreException {
1400		1467
1401	// save container values on snapshot/full save	1468	// save container values on snapshot/full save
1402	Preferences preferences = JavaCore.getPlugin().getPluginPreferences();
1403	IJavaProject[] projects = getJavaModel().getJavaProjects();	1469	IJavaProject[] projects = getJavaModel().getJavaProjects();
1404	for (int i = 0, length = projects.length; i < length; i++) {	1470	for (int i = 0, length = projects.length; i < length; i++) {
1405	IJavaProject project = projects[i];	1471	IJavaProject project = projects[i];
Lines 1417-1427 Link Here
1417	} catch(JavaModelException e){	1483	} catch(JavaModelException e){
1418	// could not encode entry: leave it as CP_ENTRY_IGNORE	1484	// could not encode entry: leave it as CP_ENTRY_IGNORE
1419	}	1485	}
1420	preferences.setDefault(containerKey, CP_ENTRY_IGNORE); // use this default to get rid of removed ones	1486	JavaCore.getDefaultPreferences().put(containerKey, CP_ENTRY_IGNORE); // TODO (frederic) verify if this is really necessary...
1421	preferences.setValue(containerKey, containerString);	1487	JavaCore.getInstancePreferences().put(containerKey, containerString);
1422	}	1488	}
1423	}	1489	}
1424	JavaCore.getPlugin().savePluginPreferences();	1490	try {
		1491	JavaCore.getInstancePreferences().flush();
		1492	} catch (BackingStoreException e) {
		1493	// TODO (frederic) see if it's necessary to report this exception
		1494	// IStatus status = new Status(IStatus.ERROR, JavaCore.PLUGIN_ID, IStatus.ERROR, "Problems while saving context", e); //$NON-NLS-1$
		1495	// throw new CoreException(status);
		1496	}
1425		1497
1426	if (context.getKind() == ISaveContext.FULL_SAVE) {	1498	if (context.getKind() == ISaveContext.FULL_SAVE) {
1427	// will need delta since this save (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=38658)	1499	// will need delta since this save (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=38658)
Lines 1444-1450 Link Here
1444	}	1516	}
1445		1517
1446	ArrayList vStats= null; // lazy initialized	1518	ArrayList vStats= null; // lazy initialized
1447	for (Iterator iter = perProjectInfos.values().iterator(); iter.hasNext();) {	1519	for (Iterator iter = this.perProjectInfos.values().iterator(); iter.hasNext();) {
1448	try {	1520	try {
1449	PerProjectInfo info = (PerProjectInfo) iter.next();	1521	PerProjectInfo info = (PerProjectInfo) iter.next();
1450	saveState(info, context);	1522	saveState(info, context);
Lines 1597-1607 Link Here
1597	}	1669	}
1598	}	1670	}
1599		1671
1600	Preferences preferences = JavaCore.getPlugin().getPluginPreferences();
1601	String variableKey = CP_VARIABLE_PREFERENCES_PREFIX+variableName;	1672	String variableKey = CP_VARIABLE_PREFERENCES_PREFIX+variableName;
1602	String variableString = variablePath == null ? CP_ENTRY_IGNORE : variablePath.toString();	1673	String variableString = variablePath == null ? CP_ENTRY_IGNORE : variablePath.toString();
1603	preferences.setDefault(variableKey, CP_ENTRY_IGNORE); // use this default to get rid of removed ones	1674	JavaCore.getDefaultPreferences().put(variableKey, CP_ENTRY_IGNORE); // TODO (frederic) verify if this is really necessary...
1604	preferences.setValue(variableKey, variableString);	1675	JavaCore.getInstancePreferences().put(variableKey, variableString);
1605	JavaCore.getPlugin().savePluginPreferences();	1676	try {
		1677	JavaCore.getInstancePreferences().flush();
		1678	} catch (BackingStoreException e) {
		1679	// TODO (frederic) see if it's necessary to report this exception
		1680	// IStatus status = new Status(IStatus.ERROR, Platform.PI_RUNTIME, IStatus.ERROR, "Problems while saving context", e); //$NON-NLS-1$
		1681	// throw new CoreException(status);
		1682	}
1606	}	1683	}
1607	}	1684	}