Attachment #63824 for bug #170932

View | Details | Raw Unified | Return to bug 170932
Collapse All | Expand All

Lines 16-21 Link Here

(-)src/org/eclipse/rse/internal/core/filters/SystemFilterPoolReferenceManager.java (-8 / +17 lines)
16		16
17	package org.eclipse.rse.internal.core.filters;	17	package org.eclipse.rse.internal.core.filters;
18		18
		19	import java.util.ArrayList;
		20	import java.util.List;
19	import java.util.Vector;	21	import java.util.Vector;
20		22
21	import org.eclipse.core.resources.IFile;	23	import org.eclipse.core.resources.IFile;
Lines 384-392 Link Here
384	* Create a filter pool reference. This creates an unresolved raw reference that	386	* Create a filter pool reference. This creates an unresolved raw reference that
385	* must be added to the managed lists by the caller.	387	* must be added to the managed lists by the caller.
386	* That will be attempted to be resolved on first use.	388	* That will be attempted to be resolved on first use.
		389	* @param filterPoolName the fully qualified filter pool name
387	*/	390	*/
388	private ISystemFilterPoolReference createSystemFilterPoolReference(ISystemFilterPoolManager filterPoolManager, String filterPoolName) {	391	private ISystemFilterPoolReference createSystemFilterPoolReference(String filterPoolName) {
389	ISystemFilterPoolReference filterPoolReference = new SystemFilterPoolReference(filterPoolManager, filterPoolName);	392	ISystemFilterPoolReference filterPoolReference = new SystemFilterPoolReference(filterPoolName);
390	invalidateFilterPoolReferencesCache();	393	invalidateFilterPoolReferencesCache();
391	return filterPoolReference;	394	return filterPoolReference;
392	}	395	}
Lines 503-512 Link Here
503	*/	506	*/
504	public ISystemFilterPool[] getReferencedSystemFilterPools() {	507	public ISystemFilterPool[] getReferencedSystemFilterPools() {
505	ISystemFilterPoolReference[] refs = getSystemFilterPoolReferences();	508	ISystemFilterPoolReference[] refs = getSystemFilterPoolReferences();
506	ISystemFilterPool[] pools = new ISystemFilterPool[refs.length];	509	List pools = new ArrayList(refs.length);
507	for (int idx = 0; idx < pools.length; idx++)	510	for (int idx = 0; idx < refs.length; idx++) {
508	pools[idx] = refs[idx].getReferencedFilterPool();	511	ISystemFilterPool pool = refs[idx].getReferencedFilterPool();
509	return pools;	512	if (pool != null) {
		513	pools.add(pool);
		514	}
		515	}
		516	ISystemFilterPool[] result = new ISystemFilterPool[pools.size()];
		517	pools.toArray(result);
		518	return result;
510	}	519	}
511		520
512	/**	521	/**
Lines 542-549 Link Here
542	/* (non-Javadoc)	551	/* (non-Javadoc)
543	* @see org.eclipse.rse.filters.ISystemFilterPoolReferenceManager#addReferenceToSystemFilterPool(org.eclipse.rse.filters.ISystemFilterPoolManager, java.lang.String)	552	* @see org.eclipse.rse.filters.ISystemFilterPoolReferenceManager#addReferenceToSystemFilterPool(org.eclipse.rse.filters.ISystemFilterPoolManager, java.lang.String)
544	*/	553	*/
545	public ISystemFilterPoolReference addReferenceToSystemFilterPool(ISystemFilterPoolManager filterPoolManager, String filterPoolName) {	554	public ISystemFilterPoolReference addReferenceToSystemFilterPool(String filterPoolName) {
546	ISystemFilterPoolReference filterPoolReference = createSystemFilterPoolReference(filterPoolManager, filterPoolName);	555	ISystemFilterPoolReference filterPoolReference = createSystemFilterPoolReference(filterPoolName);
547	addReferencingObject(filterPoolReference);	556	addReferencingObject(filterPoolReference);
548	filterPoolReference.setParentReferenceManager(this);	557	filterPoolReference.setParentReferenceManager(this);
549	invalidateFilterPoolReferencesCache();	558	invalidateFilterPoolReferencesCache();





package org.eclipse.rse.internal.core.filters;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.Platform;
import org.eclipse.rse.core.RSECorePlugin;

import org.eclipse.rse.core.model.ISystemProfile;
import org.eclipse.rse.core.model.ISystemRegistry;
import org.eclipse.rse.core.subsystems.ISubSystem;
import org.eclipse.rse.core.subsystems.ISubSystemConfiguration;
import org.eclipse.rse.internal.references.SystemPersistableReferencingObject;

/**

	
	/**
	 * Constructs a new filter pool reference. This is an unresolved reference.
	 * It is resolved on first use by using the supplied filterPoolManager.
	 * @param filterPoolManager the manager used to resolve the reference.
	 * @param filterPoolName the name of the filter pool.
	 */
	public SystemFilterPoolReference(String filterPoolName) {
		this();
		this.filterPoolManager = filterPoolManager;
		setReferencedObjectName(filterPoolName);
	}


	 * @see org.eclipse.rse.core.filters.ISystemFilterPoolReference#getReferencedFilterPoolName()
	 */
	public String getReferencedFilterPoolName() {
		/*
		 * A filter pool reference stores the name of the filter pool it references in the form managerName___filterPoolName.
		 * or in the unqualified form of filterPoolName which references a locally defined filter pool.
		 * ___ is the delimiter. Absence of the delimiter indicates an unqualified name.
		 * The filter pool manager name is the same as its owning profile.
		 */
		String savedName = getReferencedObjectName();
		String[] parts = savedName.split(DELIMITER, 2);
		String result = parts[0];
		if (parts.length == 2) {
			result = parts[1];
		}
		return result;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.rse.core.filters.ISystemFilterPoolReference#getReferencedFilterPoolManagerName()
	 */
	public String getReferencedFilterPoolManagerName() {
		/*
		 * A filter pool reference stores the name of the filter pool it references in the form managerName___filterPoolName.
		 * or in the unqualified form of filterPoolName which references a locally defined filter pool.
		 * ___ is the delimiter. Absence of the delimiter indicates an unqualified name.
		 * The filter pool manager name is the same as its owning profile.
		 */
		String result = null;
		String savedName = getReferencedObjectName();
		String[] parts = savedName.split(DELIMITER, 2);
		if (parts.length == 2) {
			result = parts[0];
		} else {
			ISystemFilterPoolReferenceManagerProvider provider = getProvider();
			if (provider instanceof ISubSystem) {
				ISubSystem subsystem = (ISubSystem) provider;
				ISystemProfile profile = subsystem.getSystemProfile();
				result = profile.getName();
			}
		}
		if (result == null) {
			RSECorePlugin.getDefault().getLogger().logWarning("Unexpected condition: filter pool manager name not found.", null); //$NON-NLS-1$
		}
		return result;
	}

	/* (non-Javadoc)

		ISystemFilterPool filterPool = (ISystemFilterPool) getReferencedObject();
		if (filterPool == null) {
			String filterPoolName = getReferencedFilterPoolName();
			String profileName = getReferencedFilterPoolManagerName();
			ISystemRegistry registry = RSECorePlugin.getDefault().getSystemRegistry();
			ISystemProfile profile = registry.getSystemProfile(profileName);
			ISubSystem subsystem = (ISubSystem) getProvider();
			ISubSystemConfiguration config = subsystem.getSubSystemConfiguration();
			filterPoolManager = config.getFilterPoolManager(profile);
			filterPool = filterPoolManager.getSystemFilterPool(filterPoolName);
			if (filterPool == null) {
				Pattern p = Pattern.compile("(^.*):"); //$NON-NLS-1$
				Matcher m = p.matcher(filterPoolName);
				if (m.find()) {
					String profileName = m.group(1);
					ISystemRegistry registry = RSECorePlugin.getDefault().getSystemRegistry();
					ISystemProfile profile = registry.getSystemProfile(profileName);
					if (profile != null) {
						ISystemFilterPool[] pools = profile.getFilterPools();
						for (int i = 0; i < pools.length && filterPool == null; i++) {
							ISystemFilterPool pool = pools[i];
							if (filterPoolName.equals(pool.getName())) filterPool = pool;
						}
					}
				}
			}
			if (filterPool != null) {
				setReferenceToFilterPool(filterPool);
			}
		}
		if (filterPool != null) {
			setReferenceToFilterPool(filterPool);
			setReferenceBroken(false);
		} else {
			setReferenceBroken(true);
		}
		return filterPool;
	}


	 * @see org.eclipse.rse.core.filters.ISystemFilterPoolReference#getFullName()
	 */
	public String getFullName() {
		return getReferencedObjectName();
	}

	/* (non-Javadoc)




	 * @generated This field/method will be replaced during code generation.
	 */
	protected java.util.List filters = null;

	/**
	 * Default constructor
	 */
	public SystemFilterPool(String poolName, boolean allowNestedFilters, boolean isDeletable) 
	{
		super();
		helpers = new SystemFilterContainerCommonMethods();
	   	setRelease(RSECorePlugin.CURRENT_RELEASE);
		if (!initialized) {
			initialize(poolName, savePolicy, namingPolicy);
	{
		if (_instance == null)
		{
			_instance = new SystemFilterPool();
		}
		return _instance;
	}
	
	/**
	 * Static factory method for creating a new filter pool. Will
	 * first try to restore it, and if that fails will create a new instance and
	 * return it.
	 * <p>
	 * Use this method only if you are not using a SystemFilterPoolManager, else
	 *  use the createSystemFilterPool method in that class.
	 * 
     *   This folder will be created if it does not already exist.
     * @param name the name of the filter pool. Typically this is also the name
     *   of the given folder, but this is not required. For the save policy of one file
     *   per pool, the name of the file is derived from this.
     * @param allowNestedFilters true if filters inside this filter pool are
     *   to allow nested filters. 
     * @param isDeletable true if this filter pool is allowed to be deleted by users.
     * @param tryToRestore true to attempt a restore first, false if a pure create operation.
	 */
	public ISystemFilterPool createSystemFilterPool(
	                                                      String name,
	                                                      boolean allowNestedFilters, 
	                                                      boolean isDeletable,
	                                                      boolean tryToRestore)
	{    	  
     	  
     	  
    	SystemFilterPool pool = null;
    	if (tryToRestore)
    	{
    	  try
    	  {
             pool = (SystemFilterPool)RSECorePlugin.getThePersistenceManager().restoreFilterPool(name);
    	  }
    	  catch (Exception exc) // real error trying to restore, versus simply not found.
    	  {
    	     // todo: something? Log the exception somewhere?
    	  }
    	}
        if (pool == null) // not found or some serious error.
        {
    	  pool = createPool();    	
        }
    	if (pool != null)
    	{    	   
    	  pool.initialize(name, allowNestedFilters, isDeletable);
    	}
    	return pool;
	}
	
	// temporary!
	//public boolean isSharable() {return isSharable; }
	//public void setIsSharable(boolean is) { isSharable = is; }

    /*
     * Private helper method.
     * Uses MOF to create an instance of this class.
     */
    protected static SystemFilterPool createPool()
    {
    	ISystemFilterPool pool = new SystemFilterPool();
    		// FIXME SystemFilterImpl.initMOF().createSystemFilterPool();
    	pool.setRelease(RSECorePlugin.CURRENT_RELEASE);
    	return (SystemFilterPool)pool;    	
    }

    /*
     * Private helper method to initialize attributes
     */
	protected void initialize(String name,
	                          boolean allowNestedFilters, 
	                          boolean isDeletable)
	{
		if (!initialized)
		  initialize(name, savePolicy, namingPolicy);
        setDeletable(isDeletable); // mof attribute
		//System.out.println("In initialize() for filter pool " + getName() + ". isDeletable= " + isDeletable);        
        setSupportsNestedFilters(allowNestedFilters); // cascades to each filter
 	}
	
    /*
     * Private helper method to core initialization, from either createXXX or restore.
     */

Lines 18-24 Link Here

(-)src/org/eclipse/rse/internal/core/filters/SystemFilterString.java (-1 lines)
18		18
19	import org.eclipse.core.runtime.IAdaptable;	19	import org.eclipse.core.runtime.IAdaptable;
20	import org.eclipse.core.runtime.Platform;	20	import org.eclipse.core.runtime.Platform;
21	import org.eclipse.rse.core.RSECorePlugin;
22	import org.eclipse.rse.core.filters.ISystemFilter;	21	import org.eclipse.rse.core.filters.ISystemFilter;
23	import org.eclipse.rse.core.filters.ISystemFilterPoolManager;	22	import org.eclipse.rse.core.filters.ISystemFilterPoolManager;
24	import org.eclipse.rse.core.filters.ISystemFilterPoolManagerProvider;	23	import org.eclipse.rse.core.filters.ISystemFilterPoolManagerProvider;




package org.eclipse.rse.core.model;


public abstract class RSEPersistableObject implements IRSEPersistableContainer {

	private boolean _isDirty = false;
	private boolean _wasRestored = false;
	private boolean _isTainted = false;
	private boolean _restoring = false;

	public RSEPersistableObject() {
		super();

	}

	public final void setDirty(boolean flag) {
		_isDirty = flag;
		setTainted(flag);
			if (flag) {
				setTainted(true);
			}
		}
	}

	public final void beginRestore() {
		_restoring = true;
	}

	public final void endRestore() {
		_restoring = false;
		setWasRestored(true);
	}

	public final boolean wasRestored() {

	}

	public final void setTainted(boolean flag) {
		boolean taintParent = flag && !_isTainted;
		_isTainted = flag;
		if (taintParent) {
			IRSEPersistableContainer parent = getPersistableParent();
			if (parent != null) {
				parent.setTainted(true);
				}
			} else {
				IRSEPersistableContainer[] children = getPersistableChildren();
				for (int i = 0; i < children.length; i++) {
					IRSEPersistableContainer child = children[i];
					child.setTainted(false);
				}
			}
		}
	}

Lines 22-28 Link Here

(-)src/org/eclipse/rse/core/model/ISystemRegistry.java (-3 lines)
22	import org.eclipse.core.runtime.IProgressMonitor;	22	import org.eclipse.core.runtime.IProgressMonitor;
23	import org.eclipse.core.runtime.jobs.ISchedulingRule;	23	import org.eclipse.core.runtime.jobs.ISchedulingRule;
24	import org.eclipse.rse.core.IRSESystemType;	24	import org.eclipse.rse.core.IRSESystemType;
25	import org.eclipse.rse.core.filters.ISystemFilterPool;
26	import org.eclipse.rse.core.filters.ISystemFilterStartHere;	25	import org.eclipse.rse.core.filters.ISystemFilterStartHere;
27	import org.eclipse.rse.core.subsystems.IConnectorService;	26	import org.eclipse.rse.core.subsystems.IConnectorService;
28	import org.eclipse.rse.core.subsystems.ISubSystem;	27	import org.eclipse.rse.core.subsystems.ISubSystem;
Lines 44-51 Link Here
44		43
45	public ISystemFilterStartHere getSystemFilterStartHere();	44	public ISystemFilterStartHere getSystemFilterStartHere();
46		45
47	public ISystemFilterPool getSystemFilterPool();
48
49	// ----------------------------------	46	// ----------------------------------
50	// UI METHODS...	47	// UI METHODS...
51	// ----------------------------------	48	// ----------------------------------

Lines 16-21 Link Here

(-)src/org/eclipse/rse/core/model/ISystemProfileManager.java (-2 / +11 lines)
16		16
17	package org.eclipse.rse.core.model;	17	package org.eclipse.rse.core.model;
18		18
		19	import java.util.List;
19	import java.util.Vector;	20	import java.util.Vector;
20		21
21	/**	22	/**
Lines 44-54 Link Here
44	public void makeSystemProfileActive(ISystemProfile profile, boolean makeActive);	45	public void makeSystemProfileActive(ISystemProfile profile, boolean makeActive);
45		46
46	/**	47	/**
47	* @return an array of all existing profiles.	48	* @return an array of all existing profiles. This is guaranteed to contain the
		49	* default private profile.
48	*/	50	*/
49	public ISystemProfile[] getSystemProfiles();	51	public ISystemProfile[] getSystemProfiles();
50		52
51	/**	53	/**
		54	* @return the number of profiles known to this manager.
		55	*/
		56	public int getSize();
		57
		58	/**
52	* @return an array of all existing profile names.	59	* @return an array of all existing profile names.
53	*/	60	*/
54	public String[] getSystemProfileNames();	61	public String[] getSystemProfileNames();
Lines 129-135 Link Here
129	* @return The list of profiles known to this manager. This list is generated	136	* @return The list of profiles known to this manager. This list is generated
130	* at the point of this call and may thus be manipulated by the caller.	137	* at the point of this call and may thus be manipulated by the caller.
131	*/	138	*/
132	java.util.List getProfiles();	139	public List getProfiles();
		140
		141	public void addSystemProfile(ISystemProfile profile);
133		142
134	// /**	143	// /**
135	// * Reusable method to return a name validator for renaming a profile.	144	// * Reusable method to return a name validator for renaming a profile.

Lines 74-83 Link Here

(-)src/org/eclipse/rse/core/model/RSEModelOperation.java (-3 / +1 lines)
74	* Ends a transaction. Schedules all changed profiles for save.	74	* Ends a transaction. Schedules all changed profiles for save.
75	*/	75	*/
76	private static void endTransaction() {	76	private static void endTransaction() {
77	ISystemRegistry registry = RSECorePlugin.getDefault().getSystemRegistry();
78	ISystemProfileManager profileManager = registry.getSystemProfileManager();
79	IRSEPersistenceManager persistenceManager = RSECorePlugin.getDefault().getPersistenceManager();	77	IRSEPersistenceManager persistenceManager = RSECorePlugin.getDefault().getPersistenceManager();
80	persistenceManager.commit(profileManager);	78	persistenceManager.commitProfiles();
81	}	79	}
82		80
83	/**	81	/**




	 * @param flag true if the object was restored.
	 */
	public void setWasRestored(boolean flag);
		
	/**
	 * Notifies the object that it is being restored. Typically this will
	 * suppress any marking of the object as dirty and related objects as 
	 * tainted while the restore is taking place. Should be used only by
	 * persistence providers.
	 */
	public void beginRestore();
	
	/**
	 * Notifies the object that it is has been restored. This will
	 * enable the object to be marked as dirty if subsequent changes
	 * are made to it. Should be used only by persistence providers.
	 */
	public void endRestore();
	
	/**
	 * An object is dirty if a change has been made to it that requires
	 * it to be persisted.

	 * Sets the tainted attribute for this object. This should set to 
	 * true only by child objects when they have been marked dirty or tainted.
	 * Setting this to true will cause all parent objects in the containment
	 * hierarchy to be marked tainted.
	 * children to be marked as not tainted.
	 * It should be set to false only by a persistence manager when the
	 * object has been committed.
	 * @param flag the tainted state of the object.





import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Vector;

import org.eclipse.core.resources.IFile;

import org.eclipse.rse.core.RSECorePlugin;
import org.eclipse.rse.core.model.IRSEPersistableContainer;
import org.eclipse.rse.core.model.ISystemProfile;
import org.eclipse.rse.core.model.ISystemRegistry;
import org.eclipse.rse.core.model.RSEPersistableObject;
import org.eclipse.rse.core.references.IRSEBaseReferencingObject;
import org.eclipse.rse.internal.core.filters.ISystemFilterConstants;
import org.eclipse.rse.internal.core.filters.SystemFilterPool;
import org.eclipse.rse.logging.Logger;
import org.eclipse.rse.persistence.IRSEPersistenceManager;

//
//

/**
 * A filter pool manager manages filter pools.

	 */
	protected boolean singleFilterStringOnly = SINGLE_FILTER_STRING_ONLY_EDEFAULT;

	protected List pools = null;
	 * @generated This field/method will be replaced during code generation.
	 */
	protected java.util.List pools = null;

	/**
	 * Constructor

	 *   individual filter pool level.
	 * @param savePolicy The save policy for the filter pools and filters. One of the
	 *   following constants from the 
	 *   {@link ISystemFilterConstants} interface:
	 *   <ul>
	 *     <li>SAVE_POLICY_NONE - no files, all save/restore handled elsewhere
	 *     <li>SAVE_POLICY_ONE_FILE_PER_MANAGER - one file: mgrName.xmi

	public static ISystemFilterPoolManager createSystemFilterPoolManager(ISystemProfile profile, Logger logger, 
			ISystemFilterPoolManagerProvider caller, String name, boolean allowNestedFilters,
			int savePolicy, IRSEFilterNamingPolicy namingPolicy) {
		SystemFilterPoolManager mgr = SystemFilterPoolManager.createManager(profile);
		mgr.initialize(logger, caller, name, allowNestedFilters);
		if (namingPolicy == null) namingPolicy = SystemFilterNamingPolicy.getNamingPolicy();
		try {
			mgr = (SystemFilterPoolManager) RSECorePlugin.getThePersistenceManager().restoreFilterPoolManager(profile, logger, caller, name);
			/*
			 if (savePolicy != SystemFilterConstants.SAVE_POLICY_NONE)
			 mgr = (SystemFilterPoolManagerImpl)restore(;
			 */
		} catch (Exception exc) // real error trying to restore, versus simply not found.
		{
			// todo: something. Log the exception somewhere?
		}
		if (mgr == null) // not found or some serious error.
		{
			mgr = createManager(profile);
		}
		if (mgr != null) {
			mgr.initialize(logger, caller, name, allowNestedFilters);
		}
		return mgr;
	}


	 * Private helper method to initialize state
	 */
	public void initialize(Logger logger, ISystemFilterPoolManagerProvider caller, String name, boolean allowNestedFilters) {
		if (!initialized) {
			initialize(logger, caller, name); // core data
		{
			java.util.List pools = getPools();
			ISystemFilterPool pool = null;
			Vector poolNames = getSystemFilterPoolNamesVector();
			for (int idx = 0; idx < poolNames.size(); idx++) {
				String poolName = (String) poolNames.elementAt(idx);
				pool = RSECorePlugin.getThePersistenceManager().restoreFilterPool(poolName);
				pool.setSystemFilterPoolManager(this);
				pools.add(pool);

				/** FIXME test
				 if (pool.specialCaseNoDataRestored)
				 {
				 pool.setDeletable(true); // what else to do?
				 //pool.setSupportsNestedFilters(allowNestedFilters); will be cascaded down anyway
				 }
				 */
			}

		}
		setSupportsNestedFilters(allowNestedFilters); // cascade it down    	
		invalidatePoolCache();
//		List pools = getPools();
//		ISystemFilterPool pool = null;
//		Vector poolNames = getSystemFilterPoolNamesVector();
//		for (int idx = 0; idx < poolNames.size(); idx++) {
//			String poolName = (String) poolNames.elementAt(idx);
////			pool = RSECorePlugin.getThePersistenceManager().restoreFilterPool(poolName);
//			pool = null; // that's what the above returned
//			pool.setSystemFilterPoolManager(this);
//			pools.add(pool);
//
//			/** FIXME test
//			 if (pool.specialCaseNoDataRestored)
//			 {
//			 pool.setDeletable(true); // what else to do?
//			 //pool.setSupportsNestedFilters(allowNestedFilters); will be cascaded down anyway
//			 }
//			 */
//		}
	}

	/*

	public void initialize(Logger logger, ISystemFilterPoolManagerProvider caller, String name) {
		this.logger = logger;
		setProvider(caller);
		setName(name);
		setFilterPoolManager(); // cascade it down
		initialized = true;
	}


	/**
	 * Set the name of this manager.
	 * Intercepted so the file get be renamed for SAVE_POLICY_ONE_FILE_PER_MANAGER.
	 */
	public void setName(String newName) {
		if ((name == null && newName != null) || !name.equals(newName)) {
			this.name = newName;
			setDirty(true);
				this.name = name;
			}
		}
	}


	public ISystemFilterPool[] getSystemFilterPools() {
		//System.out.println("Inside getSFPools for mgr "+getName()+". poolArray null? "+(poolArray==null));
		if ((poolArray == null) || (getPools().size() != poolArray.length)) {
			List pools = getPools();
			poolArray = new ISystemFilterPool[pools.size()];
			Iterator i = pools.iterator();
			int idx = 0;

	 * Get list of filter pool names currently existing.
	 */
	public Vector getSystemFilterPoolNamesVector() {
		List pools = getPools();
		if ((poolNames == null) || (poolNames.size() != pools.size())) // been invalidated?
		{
			poolNames = new Vector();

	 * Calls back to inform provider of this event
	 */
	public ISystemFilterPool createSystemFilterPool(String poolName, boolean isDeletable) throws Exception {
		// always trim the pool name, MOF does not handle trailing or preceding spaces
		poolName = poolName.trim();

		if (getSystemFilterPool(poolName) != null) return null;

		ISystemFilterPool pool = null;
		poolName = poolName.trim();
		if (getSystemFilterPool(poolName) == null) {
			pool = new SystemFilterPool(poolName, supportsNestedFilters(), isDeletable);
		pool = filterPool.createSystemFilterPool(poolName, supportsNestedFilters(), isDeletable, ISystemFilterConstants.TRY_TO_RESTORE_NO);

		if (pool != null) {
			pool.setSystemFilterPoolManager(this);
			pool.setStringsCaseSensitive(areStringsCaseSensitive());
			pool.setSupportsDuplicateFilterStrings(isSetSupportsDuplicateFilterStrings() && supportsDuplicateFilterStrings());
			List pools = getPools();
			java.util.List pools = getPools();
			pools.add(pool);
			//System.out.println("Inside createSFPool for mgr "+getName()+". Pool "+name+" added");
			invalidatePoolCache();
			// save to disk...
			commit(pool);
			if ((caller != null) && !suspendCallbacks) {
				caller.filterEventFilterPoolCreated(pool);
			}
		}
		return pool;
	}

		// DWD removing a pool should mark its parent profile as dirty and cause a save to be "scheduled"

		// remove from model
		List pools = getPools();
		pools.remove(pool);
		invalidatePoolCache();

		/* FIXME
		 // now in EMF, the pools are "owned" by the Resource, and only referenced by this pool manager,

		/* FIXME
		 String fileName = getRootSaveFileName(namingPolicy, name);
		 
		 List ext = getMOFHelpers(logger).restore(mgrFolder,fileName);
		 
		 SystemFilterPoolManager mgr = null;


	/**
	 * @generated This field/method will be replaced during code generation 
	 */
	public List getPools() {
		if (pools == null) {
			pools = new ArrayList();
			//FIXME new EObjectResolvingeList(SystemFilterPool.class, this, FiltersPackage.SYSTEM_FILTER_POOL_MANAGER__POOLS);
		}
		return pools;
	}

	/**
	 * @generated This field/method will be replaced during code generation.
	 */
	public void setNameGen(String newName) {
		String oldName = name;
		if (oldName != newName) {
			name = newName;
			setDirty(true);
		}
	}

	/**
	 * @generated This field/method will be replaced during code generation.
	 */
	public void setSupportsNestedFiltersGen(boolean newSupportsNestedFilters) {
		supportsNestedFilters = newSupportsNestedFilters;
	}

	 * Uses the save policy specified in this manager's factory method.
	 */
	public boolean commit() {
		ISystemProfile profile = getSystemProfile();
		boolean result = profile.commit();
		return result;
	}

	/**

Lines 337-342 Link Here

(-)src/org/eclipse/rse/core/filters/ISystemFilterPool.java (-2 / +1 lines)
337	* @generated	337	* @generated
338	*/	338	*/
339	void setNonRenamable(boolean value);	339	void setNonRenamable(boolean value);
340		340
341	public ISystemFilterPool createSystemFilterPool(String name, boolean allowNestedFilters, boolean isDeletable, boolean tryToRestore);
342	}	341	}

Lines 201-211 Link Here

(-)src/org/eclipse/rse/core/filters/ISystemFilterPoolReferenceManager.java (-2 / +1 lines)
201	* Given a filter pool name, create a referencing object and add it to the list.	201	* Given a filter pool name, create a referencing object and add it to the list.
202	* This creates an unresolved reference to that filter pool. It will be resolved on first use.	202	* This creates an unresolved reference to that filter pool. It will be resolved on first use.
203	* <p> Calls back to inform provider	203	* <p> Calls back to inform provider
204	* @param filterPoolManager the manager that can be used to resolve the reference.
205	* @param filterPoolName the name of the filter pool being referenced.	204	* @param filterPoolName the name of the filter pool being referenced.
206	* @return new filter pool reference	205	* @return new filter pool reference
207	*/	206	*/
208	public ISystemFilterPoolReference addReferenceToSystemFilterPool(ISystemFilterPoolManager filterPoolManager, String filterPoolName);	207	public ISystemFilterPoolReference addReferenceToSystemFilterPool(String filterPoolName);
209		208
210	/**	209	/**
211	* Given a filter pool, locate the referencing object for it and remove it from the list.	210	* Given a filter pool, locate the referencing object for it and remove it from the list.




import java.util.List;

public class RSEDOMNode implements Serializable {

	private static final long serialVersionUID = 1L; // This should be updated if there is a schema change.
	 */
	private static final long serialVersionUID = 1L;
	protected String _type;
	protected String _name;
	protected RSEDOMNode _parent;

	public void setRestoring(boolean restoring) {
		this.restoring = restoring;
	}
	
	public void setName(String name) {
		_name = name;
	}
	
	public void setType(String type) {
		_type = type;
	}

}




import org.eclipse.rse.core.model.IPropertyType;
import org.eclipse.rse.core.model.IRSEModelObject;
import org.eclipse.rse.core.model.ISystemProfile;
import org.eclipse.rse.core.model.ISystemRegistry;
import org.eclipse.rse.core.subsystems.IConnectorService;
import org.eclipse.rse.core.subsystems.IDelegatingConnectorService;
import org.eclipse.rse.core.subsystems.IServerLauncherProperties;

import org.eclipse.rse.persistence.dom.RSEDOMNode;

public class RSEDOMExporter implements IRSEDOMExporter {
	
	private static RSEDOMExporter _instance = new RSEDOMExporter();
	private Map _domMap;

	//	private ISystemRegistry _registry;

	/**
	 * Constructor to create a new DOM exporter.
	 */

		_domMap = new HashMap();
	}

	public void setSystemRegistry(ISystemRegistry registry) {
		//		_registry = registry;
	}

	/**
	 * @return the singleton instance of this exporter
	 */

	 */
	public RSEDOMNode createNode(RSEDOMNode parent, ISystemFilterPoolReference filterPoolReference, boolean clean) {
		RSEDOMNode node = findOrCreateNode(parent, IRSEDOMConstants.TYPE_FILTER_POOL_REFERENCE, filterPoolReference, clean);
		String name = filterPoolReference.getFullName();
		node.setName(name); // filter pool references must write out the fully qualified name of their referenced filter pool
		if (clean || node.isDirty()) {
			ISystemFilterPool filterPool = filterPoolReference.getReferencedFilterPool();
			String refId = (filterPool != null) ? filterPool.getId() : "unknown"; //$NON-NLS-1$
			node.addAttribute(IRSEDOMConstants.ATTRIBUTE_REF_ID, refId);
		}

		createPropertySetNodes(node, filterPoolReference, clean);
		node.setDirty(false);
		return node;

				node.setDirty(true);
			}
		}
		if (node == null) {
		if (newNode) {
			node = new RSEDOMNode(parent, type, name);
		}
		return node;




import org.eclipse.rse.core.model.IPropertyType;
import org.eclipse.rse.core.model.IRSEModelObject;
import org.eclipse.rse.core.model.ISystemProfile;
import org.eclipse.rse.core.model.ISystemProfileManager;
import org.eclipse.rse.core.model.ISystemRegistry;
import org.eclipse.rse.core.model.PropertyType;
import org.eclipse.rse.core.subsystems.IConnectorService;

import org.eclipse.rse.core.subsystems.ISubSystem;
import org.eclipse.rse.core.subsystems.ISubSystemConfiguration;
import org.eclipse.rse.core.subsystems.SubSystemFilterNamingPolicy;
import org.eclipse.rse.internal.core.model.SystemProfile;
import org.eclipse.rse.internal.core.model.SystemProfileManager;
import org.eclipse.rse.persistence.dom.IRSEDOMConstants;
import org.eclipse.rse.persistence.dom.RSEDOM;
import org.eclipse.rse.persistence.dom.RSEDOMNode;
import org.eclipse.rse.persistence.dom.RSEDOMNodeAttribute;

public class RSEDOMImporter {
	private static RSEDOMImporter _instance = new RSEDOMImporter();
	private ISystemRegistry _registry;



	/**
	 * Restores the profile represented by dom
	 * @param profileManager
	 * @param dom
	 * @return the restored profile
	 */
	public ISystemProfile restoreProfile(RSEDOM dom) {
		// create the profile
		String profileName = dom.getName();
		boolean defaultPrivate = getBooleanValue(dom.getAttribute(IRSEDOMConstants.ATTRIBUTE_DEFAULT_PRIVATE).getValue());
		boolean isActive = getBooleanValue(dom.getAttribute(IRSEDOMConstants.ATTRIBUTE_IS_ACTIVE).getValue());
		ISystemProfile profile = new SystemProfile(profileName, isActive);

		if (profile != null) {
			profile.setDefaultPrivate(defaultPrivate);
			SystemProfileManager.getDefault().addSystemProfile(profile);
			// restore the children for the profile
			RSEDOMNode[] children = dom.getChildren();
			for (int i = 0; i < children.length; i++) {

				restorePropertySet(host, child);
			}
		}
		
		return host;
	}


	}

	public IServerLauncherProperties restoreServerLauncher(IConnectorService service, RSEDOMNode serverLauncherNode, IServerLauncherProperties sl) {
		// restore all property sets
		RSEDOMNode[] psChildren = serverLauncherNode.getChildren(IRSEDOMConstants.TYPE_PROPERTY_SET);
		for (int p = 0; p < psChildren.length; p++) {
			RSEDOMNode psChild = psChildren[p];

					subSystem = existingSubSystems[0];
				}
			}
			
			if (subSystem == null) {
				// subSystem = factory.createSubSystemInternal(host);
				ISubSystem[] createdSystems = _registry.createSubSystems(host, new ISubSystemConfiguration[]{factory});

			subSystem.setSubSystemConfiguration(factory);
			subSystem.setName(factory.getName());
			subSystem.setConfigurationId(factory.getId());
			subSystem.setWasRestored(true);

			if (factory.supportsFilters()) {
				ISystemFilterStartHere startHere = _registry.getSystemFilterStartHere();

				restorePropertySet(subSystem, psChild);
			}
		}
		subSystem.wasRestored();
		return subSystem;
	}



		// create the filter
		ISystemFilter filter = filterPool.createSystemFilter(name, filterStrings);

		filter.setWasRestored(true);

		// set filter attributes
		filter.setSupportsNestedFilters(supportsNestedFilters);
		filter.setRelativeOrder(relativeOrder);
		filter.setDefault(isDefault);

					filterPool = mgr.getSystemFilterPool(name);
				}
				if (filterPool == null) {
					filterPool = mgr.createSystemFilterPool(name, isDeletable);
//					filterPool = new SystemFilterPool(name, supportsNestedFilters, isDeletable);
//					filterPool.setSystemFilterPoolManager(mgr);
//					mgr.getPools().add(filterPool);
						// add to model
						mgr.getPools().add(filterPool);
					}
				}
				if (filterPool != null) {
					filterPool.setType(type);
					filterPool.setDefault(isDefault);
					filterPool.setSupportsNestedFilters(supportsNestedFilters);
					filterPool.setStringsCaseSensitive(isSetStringsCaseSensitive);
					filterPool.setSupportsDuplicateFilterStrings(isSetSupportsDuplicateFilterStrings);
					filterPool.setRelease(release);
					filterPool.setSingleFilterStringOnly(isSetSingleFilterStringOnly);
					filterPool.setOwningParentName(owningParentName);
					filterPool.setNonRenamable(isNonRenamable);
					filterPool.setWasRestored(true);
				}
				filterPool.setType(type);
				filterPool.setDefault(isDefault);
				filterPool.setSupportsNestedFilters(supportsNestedFilters);
				filterPool.setStringsCaseSensitive(isSetStringsCaseSensitive);
				filterPool.setSupportsDuplicateFilterStrings(isSetSupportsDuplicateFilterStrings);
				filterPool.setRelease(release);
				filterPool.setSingleFilterStringOnly(isSetSingleFilterStringOnly);
				filterPool.setOwningParentName(owningParentName);
				filterPool.setNonRenamable(isNonRenamable);
//				filterPool.wasRestored();
			}
		} catch (Exception e) {
			e.printStackTrace();

	 */
	public ISystemFilterPoolReference restoreFilterPoolReference(ISubSystem subsystem, RSEDOMNode node) {
		ISystemFilterPoolReference filterPoolReference = null;
		String subsystemName = node.getAttribute(IRSEDOMConstants.ATTRIBUTE_REF_ID).getValue();
		String filterPoolName = node.getName();
		String[] part = filterPoolName.split("___", 2); //$NON-NLS-1$
		if (part.length == 1) { // name is unqualified and refers to a filter pool in the current profile, ensure it is qualified
			ISystemProfile profile = subsystem.getSystemProfile();
			String profileName = profile.getName();
			filterPoolName = profileName + "___" + filterPoolName; //$NON-NLS-1$
			ISystemFilterPoolReferenceManager referenceManager = subsystem.getFilterPoolReferenceManager();
			/*
			 * DWD filterpool can be null when restoring since there can be forward references. 
			 * A profile may be being restored that has references to a filter pool in a profile that doesn't yet exist. 
			 * Need to create an "unresolved" reference instead of a null object and then patch them up on first access.
			 */
			// create reference to the filterpool
			if (filterPool != null) {
				filterPoolReference = referenceManager.addReferenceToSystemFilterPool(filterPool);
			} else {
				filterPoolReference = referenceManager.addReferenceToSystemFilterPool(filterPoolManager, filterPoolName);
			}
		}
		ISystemFilterPoolReferenceManager referenceManager = subsystem.getFilterPoolReferenceManager();
		filterPoolReference = referenceManager.addReferenceToSystemFilterPool(filterPoolName);
		return filterPoolReference;
	}






package org.eclipse.rse.internal.persistence;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtensionRegistry;

import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Preferences;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.core.runtime.preferences.IPreferencesService;
import org.eclipse.rse.core.IRSEPreferenceNames;
import org.eclipse.rse.core.RSECorePlugin;
import org.eclipse.rse.core.SystemResourceManager;
import org.eclipse.rse.core.model.IRSEPersistableContainer;
import org.eclipse.rse.core.filters.ISystemFilterPoolManager;
import org.eclipse.rse.core.filters.ISystemFilterPoolManagerProvider;
import org.eclipse.rse.core.filters.SystemFilterPoolManager;
import org.eclipse.rse.core.model.IHost;
import org.eclipse.rse.core.model.ISystemHostPool;
import org.eclipse.rse.core.model.ISystemProfile;
import org.eclipse.rse.core.model.ISystemProfileManager;
import org.eclipse.rse.core.model.ISystemRegistry;
import org.eclipse.rse.internal.core.model.SystemProfileManager;
import org.eclipse.rse.internal.persistence.dom.RSEDOMExporter;
import org.eclipse.rse.internal.persistence.dom.RSEDOMImporter;
import org.eclipse.rse.logging.Logger;

public class RSEPersistenceManager implements IRSEPersistenceManager {

	private static final int STATE_NONE = 0;
	private static final int STATE_LOADING = 1;
	private static final int STATE_SAVING = 2;

	private static IProject remoteSystemsProject = null;

	/**
	 * Get the default remote systems project.
	 * @return IProject handle of the project.
	 */
	public static IProject getRemoteSystemsProject() {
		if (remoteSystemsProject == null) 
		{
			remoteSystemsProject = SystemResourceManager.getRemoteSystemsProject();
		}

		return remoteSystemsProject;
	}
	private Map loadedProviders = new HashMap(10);

	private Map knownProviders = new HashMap(10);
	private int _currentState = STATE_NONE;
	private RSEDOMExporter _exporter;

	private RSEDOMImporter _importer;

	public RSEPersistenceManager(ISystemRegistry registry) {
		//		_registry = registry;
		_exporter = RSEDOMExporter.getInstance();
		_exporter.setSystemRegistry(registry);
		_importer = RSEDOMImporter.getInstance();
		_importer.setSystemRegistry(registry);
		getProviderExtensions();
	}

	public boolean isExporting() {
		return _currentState == STATE_SAVING;
	}

	public boolean isImporting() {
		return _currentState == STATE_LOADING;
	}

	public void registerPersistenceProvider(String id, IRSEPersistenceProvider provider) {
		knownProviders.put(id, provider);
			commit(connectionPool.getSystemProfile());
			connectionPool.setDirty(false);
		}
		/*
		 Host[] connections = connectionPool.getHosts();
		 for (int idx = 0; idx < connections.length; idx++)
		 {
		 if (!saveHost(connectionPool, connections[idx]))
		 {
		 return false;
		 }
		 }
		 return true;
		 */
		return false; // all persistence should be at profile level
	}

	/**
	 * Attempt to save single profile to disk.
	 */
	public boolean commitProfile(ISystemProfile profile) {
		boolean result = false;
		if (profile != null) {
			result = save(profile, false);
		}
		return result;
	}

	public boolean commitProfiles() {
		boolean ok = true;
		ISystemProfile[] profiles = RSECorePlugin.getDefault().getSystemRegistry().getAllSystemProfiles();
		for (int idx = 0; idx < profiles.length && ok; idx++) {

		ISystemProfile[] profiles = profileManager.getSystemProfiles();
		for (int idx = 0; idx < profiles.length; idx++) {
			try {
				ok = commitProfile(profiles[idx]);
			} catch (Exception exc) {
				Logger logger = RSECorePlugin.getDefault().getLogger();
				String profileName = profiles[idx].getName();
				String message = "Error saving profile " + profileName; //$NON-NLS-1$
				logger.logError(message, exc);
				ok = false;
			}
		}
		return ok;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.rse.persistence.IRSEPersistenceManager#migrateProfile(org.eclipse.rse.core.model.ISystemProfile, org.eclipse.rse.persistence.IRSEPersistenceProvider)
	 */
	public void migrateProfile(ISystemProfile profile, IRSEPersistenceProvider persistenceProvider) {
		IRSEPersistenceProvider oldProvider = profile.getPersistenceProvider();
		oldProvider = (oldProvider == null) ? getDefaultPersistenceProvider() : oldProvider;
		IRSEPersistenceProvider newProvider = persistenceProvider;
		newProvider = (newProvider == null) ? getDefaultPersistenceProvider() : newProvider;
		if (oldProvider != newProvider) {
			profile.setPersistenceProvider(newProvider);
			profile.commit();
			deleteProfile(oldProvider, profile.getName());
		}
	}

	/* (non-Javadoc)
	 * @see org.eclipse.rse.persistence.IRSEPersistenceManager#deleteProfile(java.lang.String)
	 */
	public void deleteProfile(final IRSEPersistenceProvider persistenceProvider, final String profileName) {
		Job job = new Job(Messages.RSEPersistenceManager_DeleteProfileJobName) {
			protected IStatus run(IProgressMonitor monitor) {
				IRSEPersistenceProvider p = persistenceProvider != null ? persistenceProvider : getDefaultPersistenceProvider();
				IStatus result = p.deleteProfile(profileName, monitor);
				return result;
			}
		};
		job.schedule();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.rse.persistence.IRSEPersistenceManager#restoreProfiles()
	 */
	public ISystemProfile[] restoreProfiles() {
		List profiles = loadProfiles();
		ISystemProfile[] result = new ISystemProfile[profiles.size()];
		profiles.toArray(result);
		return result;
	}
	
	public ISystemProfile restoreProfile(IRSEPersistenceProvider provider, String profileName) {
		ISystemProfile result = load(provider, profileName);
		return result;
	}

	/**
	 * Returns the persistence provider denoted by the id. Only one instance of this 
	 * persistence provider is created.
	 * @param id The id of the persistence provider, as denoted by the id attribute on its declaration.
	 * @return an IRSEPersistenceProvider which may be null if this id is not found.
	 */
	public IRSEPersistenceProvider getPersistenceProvider(String id) {
		IRSEPersistenceProvider provider = null;
		Object providerCandidate = knownProviders.get(id);
		if (providerCandidate instanceof IConfigurationElement) {
			IConfigurationElement element = (IConfigurationElement) providerCandidate;
			try {
				provider = (IRSEPersistenceProvider) element.createExecutableExtension("class"); //$NON-NLS-1$
			} catch (CoreException e) {
				Logger logger = RSECorePlugin.getDefault().getLogger();
				logger.logError("Exception loading persistence provider", e); //$NON-NLS-1$
			}
			if (provider != null) {
				knownProviders.put(id, provider);
			}
		} else if (providerCandidate instanceof IRSEPersistenceProvider) {
			provider = (IRSEPersistenceProvider) providerCandidate;
		}
		return provider;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.rse.persistence.IRSEPersistenceManager#getPersistenceProviderIds()
	 */
	public String[] getPersistenceProviderIds() {
		Set ids = knownProviders.keySet();
		String[] result = new String[ids.size()];
		ids.toArray(result);
		return result;
	}
	
	/**
	 * Retrieves the default persistence provider for this workbench configuration.
	 * Several persistence providers may be registered, but the default one is used for all
	 * profiles that do not have one explicitly specified.
	 * This persistence provider's identifier is specified in the org.eclipse.rse.core/DEFAULT_PERSISTENCE_PROVIDER
	 * preference and can be specified a product's plugin_customization.ini file.
	 * @see IRSEPreferenceNames
	 * @return the default IRSEPersistenceProvider for this installation.
	 */
	private IRSEPersistenceProvider getDefaultPersistenceProvider() {
		Preferences preferences = RSECorePlugin.getDefault().getPluginPreferences();
		String providerId = preferences.getString(IRSEPreferenceNames.DEFAULT_PERSISTENCE_PROVIDER);
		IRSEPersistenceProvider provider = getPersistenceProvider(providerId);
		return provider;
	}

	/**
	 * Loads the map of known providers from the extensions made by all the plugins. 
	 * This is done once at initialization of the manager. As these ids are resolved to 
	 * their providers as needed, the configuration elements are replaced in the map
	 * by the persistence providers they reference.
	 */
	private void getProviderExtensions() {
		Logger logger = RSECorePlugin.getDefault().getLogger();
		IExtensionRegistry registry = Platform.getExtensionRegistry();
		IConfigurationElement[] providerCandidates = registry.getConfigurationElementsFor("org.eclipse.rse.core", "persistenceProviders"); //$NON-NLS-1$ //$NON-NLS-2$
		for (int j = 0; j < providerCandidates.length; j++) {
			IConfigurationElement configurationElement = providerCandidates[j];
			if (configurationElement.getName().equals("persistenceProvider")) { //$NON-NLS-1$
				String candidateId = configurationElement.getAttribute("id"); //$NON-NLS-1$
				if (candidateId != null) {
					knownProviders.put(candidateId, configurationElement);
					if (candidateId != null) {
						if (candidateId.equals(id)) {
							try {
								provider = (IRSEPersistenceProvider) providerCandidate.createExecutableExtension("class"); //$NON-NLS-1$
							} catch (CoreException e) {
								logger.logError("Exception loading persistence provider", e); //$NON-NLS-1$
							}
						}
					} else {
						logger.logError("Missing id attribute in persistenceProvider element", null); //$NON-NLS-1$
					}
				} else {
					logger.logError("Missing id attribute in persistenceProvider element", null); //$NON-NLS-1$
				}
			} else {
				logger.logError("Invalid element in persistenceProviders extension point", null); //$NON-NLS-1$
			}
			if (provider == null) {
				logger.logError("Persistence provider not found.", null); //$NON-NLS-1$
			}
			loadedProviders.put(id, provider); // even if provider is null
		}
		return provider;
	}

	private List loadProfiles() {
		List profiles = new ArrayList(10);
		String[] ids = getPersistenceProviderIds();
		for (int i = 0; i < ids.length; i++) {
			String id = ids[i];
			IRSEPersistenceProvider provider = getPersistenceProvider(id);
			if (provider != null) {
				profiles.addAll(loadProfiles(provider));
			}
		}
		return profiles;
	}

	private List loadProfiles(IRSEPersistenceProvider persistenceProvider) {
		List profiles = new ArrayList(10);
		String[] profileNames = persistenceProvider.getSavedProfileNames();
		for (int i = 0; i < profileNames.length; i++) {
			String profileName = profileNames[i];
			ISystemProfile profile = load(persistenceProvider, profileName);
			profiles.add(profile);
		}
		return profiles;
	}

	/**
	 * Loads a profile of the given name using the given persistence provider. If the provider cannot 
	 * find a profile with that name, return null.
	 * @param provider the persistence provider that understands the name and can produce a profile.
	 * @param profileName the name of the profile to produce
	 * @return the profile or null
	 */
	private synchronized ISystemProfile load(IRSEPersistenceProvider provider, String profileName) {
		ISystemProfile profile = null;
		if (_currentState == STATE_NONE) {
			_currentState = STATE_LOADING;
			RSEDOM dom = provider.loadRSEDOM(profileName, null);
			if (dom != null) {
				SystemProfileManager.getDefault().setRestoring(true);
				profile = _importer.restoreProfile(dom);
				SystemProfileManager.getDefault().setRestoring(false);
				profile.setPersistenceProvider(provider);
				cleanTree(profile);
				IRSEPersistenceProvider persistenceProvider = getRSEPersistenceProvider();
				String[] profileNames = persistenceProvider.getSavedProfileNames();
				for (int i = 0; i < profileNames.length; i++) {
					String profileName = profileNames[i];
					RSEDOM dom = importRSEDOM(profileName);
					if (dom != null) {
						ISystemProfile restoredProfile = _importer.restoreProfile(profileManager, dom);
						if (restoredProfile == null) {
							successful = false;
						}
					} else {
						successful = false;
					}
				}
			} catch (Exception e) {
				e.printStackTrace();
				successful = false;
			} finally {
				setState(STATE_NONE);
			}
			_currentState = STATE_NONE;
		}
		return profile;
	}

	public void registerRSEPersistenceProvider(String id, IRSEPersistenceProvider provider) {
		loadedProviders.put(id, provider);
	}

	public boolean restore(ISystemFilterPool filterPool) {
		//System.out.println("restore filterpool");
		// DWD function Is this method really needed?
		return false;
	}
	
	public boolean restore(ISystemHostPool connectionPool) {
		return false;
	}

	public boolean restore(ISystemProfileManager profileManager) {
		return load(profileManager);
	}

	public ISystemFilterPool restoreFilterPool(String name) {
		//System.out.println("restore filter pool "+name);
		// DWD function is this method really needed?
		return null;
	}

	/**
	 * Creates a filter pool manager for a particular SubSystemConfiguration and SystemProfile. Called
	 * "restore" for historcal reasons.
	 * @param profile the profile that will own this ISystemFilterPoolManager. There is one of these per profile.
	 * @param logger the logging object for logging errors. Each ISystemFilterPoolManager has one of these.
	 * @param caller The creator/owner of this ISystemFilterPoolManager, this ends up being a SubSystemConfiguration. 
	 * @param name the name of the manager to restore. File name is derived from it when saving to one file.
	 * @return the "restored" manager.
	 */
	public ISystemFilterPoolManager restoreFilterPoolManager(ISystemProfile profile, Logger logger, ISystemFilterPoolManagerProvider caller, String name) {
		SystemFilterPoolManager mgr = SystemFilterPoolManager.createManager(profile);
		mgr.initialize(logger, caller, name); // core data
		mgr.setWasRestored(false); // managers are not "restored from disk" since they are not persistent of themselves
		return mgr;
	}

	/**
	 * Writes a profile to a DOM and schedules writing of that DOM to disk.
	 */
	protected IHost restoreHost(ISystemHostPool hostPool, String connectionName) throws Exception {
		/*
		 * FIXME //System.out.println("in SystemConnectionPoolImpl#restore for
		 * connection " + connectionName); String fileName =
		 * getRootSaveFileName(connectionName);
		 * //System.out.println(".......fileName = " + fileName);
		 * //System.out.println(".......folderName = " +
		 * getConnectionFolder(connectionName).getName()); java.util.List ext =
		 * getMOFHelpers().restore(getConnectionFolder(connectionName),fileName);
		 *  // should be exactly one profile... Iterator iList = ext.iterator();
		 * SystemConnection connection = (SystemConnection)iList.next(); if
		 * (connection != null) { if
		 * (!connection.getAliasName().equalsIgnoreCase(connectionName)) {
		 * RSEUIPlugin.logDebugMessage(this.getClass().getName(),"Incorrect
		 * alias name found in connections.xmi file for " + connectionName+".
		 * Name was reset"); connection.setAliasName(connectionName); // just in
		 * case! } internalAddConnection(connection); } return connection;
		 */
		return null;
	}

	/**
	 * Restore a profile of a given name from disk...
	 */
	protected ISystemProfile restoreProfile(ISystemProfileManager mgr, String name) throws Exception {
		/*
		 * FIXME String fileName = mgr.getRootSaveFileName(name); java.util.List
		 * ext = null;//FIXME
		 * getMOFHelpers().restore(SystemResourceManager.getProfileFolder(name),fileName);
		 *  // should be exactly one profile... Iterator iList = ext.iterator();
		 * SystemProfile profile = (SystemProfile)iList.next();
		 * mgr.initialize(profile, name); return profile;
		 */
		return null;
	}

	/**
	 * Writes the RSE model to a DOM and schedules writing of that DOM to disk.
	 * May, in fact, update an existing DOM instead of creating a new one.
	 * If in the process of importing, skip writing.
	 * @return true if the profile is written to a DOM
	 */
	private synchronized boolean save(ISystemProfile profile, boolean force) {
		if (_currentState == STATE_NONE) {
			_currentState = STATE_SAVING;
			IRSEPersistenceProvider provider = profile.getPersistenceProvider();
			if (provider == null) {
				provider = getDefaultPersistenceProvider();
				profile.setPersistenceProvider(provider);
			}
			RSEDOM dom = null; // DWD should do merge, but does not handle deletes properly yet
			dom = _exporter.createRSEDOM(profile, force);
			cleanTree(profile);
			if (dom.needsSave()) {
				Job job = dom.getSaveJob();
				if (job == null) {
					job = new SaveRSEDOMJob(dom, getDefaultPersistenceProvider());
					dom.setSaveJob(job);
						job = new SaveRSEDOMJob(dom, getRSEPersistenceProvider());
						dom.setSaveJob(job);
					}
					job.schedule(3000); // three second delay
				}
				job.schedule(3000); // three second delay
				setState(STATE_NONE);
			}
			_currentState = STATE_NONE;
		}
		return true;
	}
	
	private void cleanTree(IRSEPersistableContainer node) {
		node.setWasRestored(true);
		node.setTainted(false);
		node.setDirty(false);
		IRSEPersistableContainer[] children = node.getPersistableChildren();
		for (int i = 0; i < children.length; i++) {
			IRSEPersistableContainer child = children[i];
			cleanTree(child);
		}
	}

}




import java.util.Vector;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.rse.core.RSECorePlugin;
import org.eclipse.rse.core.model.IHost;
import org.eclipse.rse.core.model.IRSEPersistableContainer;
import org.eclipse.rse.core.model.RSEModelObject;

	
	public IRSEPersistableContainer[] getPersistableChildren() {
		List children = new ArrayList(20);
		IServerLauncherProperties launcherProperties = getRemoteServerLauncherProperties();
		if (launcherProperties != null) {
			children.add(getRemoteServerLauncherProperties());
		}
		children.addAll(_registeredSubSystems);
		IRSEPersistableContainer[] result = new IRSEPersistableContainer[children.size()];
		children.toArray(result);

Lines 18-24 Link Here

(-)src/org/eclipse/rse/core/subsystems/AbstractDelegatingConnectorService.java (-17 / +12 lines)
18	import org.eclipse.rse.core.model.IHost;	18	import org.eclipse.rse.core.model.IHost;
19	import org.eclipse.rse.core.model.IPropertySet;	19	import org.eclipse.rse.core.model.IPropertySet;
20	import org.eclipse.rse.core.model.IRSEPersistableContainer;	20	import org.eclipse.rse.core.model.IRSEPersistableContainer;
21	import org.eclipse.rse.core.model.RSEPersistableObject;
22		21
23	public abstract class AbstractDelegatingConnectorService implements IDelegatingConnectorService	22	public abstract class AbstractDelegatingConnectorService implements IDelegatingConnectorService
24	{	23	{
Lines 752-757 Link Here
752	return false;	751	return false;
753	}	752	}
754		753
		754	/* (non-Javadoc)
		755	* @see org.eclipse.rse.core.model.IRSEPersistableContainer#isTainted()
		756	*/
755	public boolean isTainted() {	757	public boolean isTainted() {
756	IConnectorService conServ = getRealConnectorService();	758	IConnectorService conServ = getRealConnectorService();
757	if (conServ != null)	759	if (conServ != null)
Lines 761-766 Link Here
761	return false;	763	return false;
762	}	764	}
763		765
		766	/* (non-Javadoc)
		767	* @see org.eclipse.rse.core.model.IRSEPersistableContainer#setTainted(boolean)
		768	*/
764	public void setTainted(boolean flag) {	769	public void setTainted(boolean flag) {
765	IConnectorService conServ = getRealConnectorService();	770	IConnectorService conServ = getRealConnectorService();
766	if (conServ != null)	771	if (conServ != null)
Lines 769-794 Link Here
769	}	774	}
770	}	775	}
771		776
		777	/* (non-Javadoc)
		778	* @see org.eclipse.rse.core.model.IRSEPersistableContainer#getPersistableParent()
		779	*/
772	public IRSEPersistableContainer getPersistableParent() {	780	public IRSEPersistableContainer getPersistableParent() {
773	return getHost();	781	return getHost();
774	}	782	}
775		783
776	public void beginRestore() {	784	/* (non-Javadoc)
777	IConnectorService conServ = getRealConnectorService();	785	* @see org.eclipse.rse.core.model.IRSEPersistableContainer#getPersistableChildren()
778	if (conServ != null)	786	*/
779	{
780	conServ.beginRestore();
781	}
782	}
783
784	public void endRestore() {
785	IConnectorService conServ = getRealConnectorService();
786	if (conServ != null)
787	{
788	conServ.endRestore();
789	}
790	}
791
792	public IRSEPersistableContainer[] getPersistableChildren() {	787	public IRSEPersistableContainer[] getPersistableChildren() {
793	IConnectorService conServ = getRealConnectorService();	788	IConnectorService conServ = getRealConnectorService();
794	if (conServ != null)	789	if (conServ != null)




    }
    */

    // -----------------------------------
    // GET A SPECIFIC PROFILE FOLDER...
    // -----------------------------------
    /**
     * Get profiles folder for a given profile
     */
    public static IFolder getProfileFolder(ISystemProfile profile)
    {
    	return getProfileFolder(profile.getName());
    }

    /**
     * Get profiles folder for a given profile name
     */

        return getResourceHelpers().getOrCreateFolder(getRemoteSystemsProject(),profileName);      	
    }


  
   
    /*
     * --------------------------------------------------------------------------------------------------------------------------------
     * USER ACTIONS SUBTREE FOLDER METHODS...





package org.eclipse.rse.persistence;

import org.eclipse.rse.core.filters.ISystemFilterPool;
import org.eclipse.rse.core.filters.ISystemFilterPoolManager;
import org.eclipse.rse.core.filters.ISystemFilterPoolManagerProvider;
import org.eclipse.rse.core.model.ISystemHostPool;
import org.eclipse.rse.core.model.ISystemProfile;
import org.eclipse.rse.core.model.ISystemProfileManager;
import org.eclipse.rse.logging.Logger;

public interface IRSEPersistenceManager {

	public boolean commit(ISystemFilterPoolManager filterPoolManager);

	/**
	 * Save a particular profile. If the profile has an existing persistence provider
	 * it is saved by that persistence provider. If the profile has no persistence provider
	 * then the default persistence provider is used.
	 * @param profile the profile to save
	 * @return true if successful
	 */
	public boolean commitProfile(ISystemProfile profile);

	/**
	 * Save all profiles.
	 * @param profile
	 * @return true if successful
	 */
	public boolean commitProfiles();

	/**
	 * Restore all profiles
	 * @return an array of restored profiles.
	 */
	public ISystemProfile[] restoreProfiles();

	/**
	 * Restore a profiles particular provider by name.
	 * @param provider a persistence provider
	 * @param profileName the name of the profile to restore
	 * @return the restored profile or null if no profile of that name is known to this provider.
	 */
	public ISystemProfile restoreProfile(IRSEPersistenceProvider provider, String profileName);

	/**
	 * Delete the persistent form of a profile.
	 * @param persistenceProvider the persistence provider to use to delete the profile.
	 * If this is null the default persistence provider is used.
	 * @param profileName The name of the profile to delete
	 */
	public void deleteProfile(IRSEPersistenceProvider persistenceProvider, String profileName);
	
	/**
	 * Migrates a profile to a new persistence provider. It will delete the persistent form known to its previous
	 * persistence provider. If the new provider and the previous provider are the same this does nothing.
	 * @param profile the system profile to be migrated
	 * @param persistenceProvider the persistence provider to which this profile will be migrated.
	 */
	public void migrateProfile(ISystemProfile profile, IRSEPersistenceProvider persistenceProvider);

	/**
	 * Register the persistence provider to be used when saving and restoring RSE doms.
	 * The provider is registered under the provided id.
	 * If the id has already been registered, this provider replaces the previous provider
	 * with that id.
	 * @param id the provider id.
	 * @param provider the provider.
	 */
	public void registerPersistenceProvider(String id, IRSEPersistenceProvider provider);
	
	/**
	 * @return an array of persistence provider ids known to this workbench. These may have been
	 * provided by extension point or by registering them using 
	 * {@link #registerPersistenceProvider(String, IRSEPersistenceProvider)}
	 */
	public String[] getPersistenceProviderIds();
	
	/**
	 * Retrieves the persistence provider named by a particular id. It can return null if there
	 * is no provider known by that id. This may have the effect of activating the plugin that 
	 * contains this provider.
	 * @param id the id of the persistence provider to locate
	 * @return the persistence provider or null
	 */
	public IRSEPersistenceProvider getPersistenceProvider(String id);

	/**
	 * @return true if this instance of the persistence manager is currently exporting a profile.
	 * @param profileManager
	 * @return true if successful
	 */
	public boolean isExporting();

	/**
	 * @return true if this instance of the persistence manager is currently importing a profile.
	 * @param name
	 * @return the filter pool if successful
	 */
	public boolean isImporting();

	public ISystemFilterPoolManager restoreFilterPoolManager(ISystemProfile profile, Logger logger, ISystemFilterPoolManagerProvider caller, String name);
}




/********************************************************************************
 * Copyright (c) 2006, 2007 IBM Corporation. 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
 * 
 * Initial Contributors:
 * The following IBM employees contributed to the Remote System Explorer
 * component that contains this file: David McKnight, Kushal Munir, 
 * Michael Berger, David Dykstal, Phil Coulthard, Don Yantzi, Eric Simpson, 
 * Emily Bruner, Mazen Faraj, Adrian Storisteanu, Li Ding, and Kent Hawley.
 * 
 * Contributors:
 * David Dykstal (IBM) - created and used RSEPreferencesManager
 *                     - moved SystemPreferencesManager to a new plugin
 ********************************************************************************/

package org.eclipse.rse.internal.core.model;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Vector;

import org.eclipse.rse.core.RSECorePlugin;
import org.eclipse.rse.core.RSEPreferencesManager;
import org.eclipse.rse.core.model.ISystemProfile;
import org.eclipse.rse.core.model.ISystemProfileManager;
import org.eclipse.rse.logging.Logger;
import org.eclipse.rse.persistence.IRSEPersistenceProvider;

/**
 * A class that manages a list of SystemProfile objects.
 * This should be used as a singleton.
 */
public class SystemProfileManager implements ISystemProfileManager {

	private List _profiles = new ArrayList(10);
//	private String[] profileNames = null;
//	private Vector profileNamesVector = null;
	private static SystemProfileManager singleton = null;
	private boolean restoring = false;

	/**
	 * Ordinarily there should be only one instance of a SystemProfileManager
	 * created on the system, so the static method {@link #getDefault()} is 
	 * preferred to using this.
	 */
	private SystemProfileManager() {
	}

	/**
	 * @return (and create if necessary) the singleton instance of this class.
	 */
	public static SystemProfileManager getDefault() {
		if (singleton == null) {
			singleton = new SystemProfileManager();
			RSECorePlugin.getThePersistenceManager().restoreProfiles();
		}
		return singleton;
	}

	/**
	 * Clear the default after a team sychronization say
	 */
	public static void clearDefault() {
		singleton = null;
	}

	/**
	 * Create a new profile with the given name, and add to the list.
	 * The name must be unique within the existing list.
	 * <p>
	 * The underlying folder is created in the file system.
	 * <p>
	 * @param name What to name this profile
	 * @param makeActive true if this profile is to be added to the active profile list.
	 * @return new profile, or null if name not unique.
	 * @see ISystemProfileManager#createSystemProfile(String, boolean)
	 */
	public ISystemProfile createSystemProfile(String name, boolean makeActive) {
		ISystemProfile existingProfile = getSystemProfile(name);
		if (existingProfile != null) {
			deleteSystemProfile(existingProfile, false); // replace the existing one with a new profile
		}
		ISystemProfile newProfile = internalCreateSystemProfile(name);
		if (makeActive) {
			RSEPreferencesManager.addActiveProfile(name);
			((SystemProfile) newProfile).setActive(makeActive);
		}
		newProfile.commit();
		return newProfile;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.rse.core.model.ISystemProfileManager#makeSystemProfileActive(org.eclipse.rse.core.model.ISystemProfile, boolean)
	 */
	public void makeSystemProfileActive(ISystemProfile profile, boolean makeActive) {
		boolean wasActive = isSystemProfileActive(profile.getName());
		if (wasActive && !makeActive)
			RSEPreferencesManager.deleteActiveProfile(profile.getName());
		else if (makeActive && !wasActive) RSEPreferencesManager.addActiveProfile(profile.getName());
		((SystemProfile) profile).setActive(makeActive);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.rse.core.model.ISystemProfileManager#getSystemProfiles()
	 */
	public ISystemProfile[] getSystemProfiles() {
		return getSystemProfiles(!restoring);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.rse.core.model.ISystemProfileManager#getSystemProfileNames()
	 */
	public String[] getSystemProfileNames() {
		ISystemProfile[] profiles = getSystemProfiles();
		String[] profileNames = new String[profiles.length];
		for (int i = 0; i < profiles.length; i++) {
			ISystemProfile profile = profiles[i];
			profileNames[i] = profile.getName();
		}
		return profileNames;
//		if (profileNames == null) {
//			ISystemProfile[] profiles = getSystemProfiles();
//			profileNames = new String[profiles.length];
//			for (int idx = 0; idx < profiles.length; idx++)
//				profileNames[idx] = profiles[idx].getName();
//		}
//		return profileNames;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.rse.core.model.ISystemProfileManager#getSystemProfileNamesVector()
	 */
	public Vector getSystemProfileNamesVector() {
		List names = Arrays.asList(getSystemProfileNames()); 
		Vector result = new Vector(names.size());
		result.addAll(names);
		return result;
//		if (profileNamesVector == null) {
//			ISystemProfile[] profiles = getSystemProfiles();
//			profileNamesVector = new Vector(profiles.length);
//			for (int idx = 0; idx < profiles.length; idx++)
//				profileNamesVector.addElement(profiles[idx].getName());
//		}
//		return profileNamesVector;
	}

//	/**
//	 * Something changed so invalide cache of profiles so it will be regenerated
//	 */
//	protected void invalidateCache() {
//		profileNames = null;
//		profileNamesVector = null;
//	}
//
	/* (non-Javadoc)
	 * @see org.eclipse.rse.core.model.ISystemProfileManager#getSystemProfile(java.lang.String)
	 */
	public ISystemProfile getSystemProfile(String name) {
		ISystemProfile[] profiles = getSystemProfiles();
		if ((profiles == null) || (profiles.length == 0)) return null;
		ISystemProfile match = null;
		for (int idx = 0; (match == null) && (idx < profiles.length); idx++)
			if (profiles[idx].getName().equals(name)) match = profiles[idx];
		return match;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.rse.core.model.ISystemProfileManager#renameSystemProfile(org.eclipse.rse.core.model.ISystemProfile, java.lang.String)
	 */
	public void renameSystemProfile(ISystemProfile profile, String newName) {
		boolean isActive = isSystemProfileActive(profile.getName());
		String oldName = profile.getName();
		profile.setName(newName);
		if (isActive) RSEPreferencesManager.renameActiveProfile(oldName, newName);
//		invalidateCache();
		// FIXME RSEUIPlugin.getThePersistenceManager().save(this);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.rse.core.model.ISystemProfileManager#deleteSystemProfile(org.eclipse.rse.core.model.ISystemProfile, boolean)
	 */
	public void deleteSystemProfile(ISystemProfile profile, boolean persist) {
		String oldName = profile.getName();
		boolean isActive = isSystemProfileActive(oldName);
		_profiles.remove(profile);
		/* FIXME in EMF the profiles are "owned" by the Resource, and only referenced by the profile manager,
		 * so just removing it from the manager is not enough, it must also be removed from its resource.
		 * No longer needed since EMF is not in use.
		 * Resource res = profile.eResource();
		 * if (res != null)
		 * res.getContents().remove(profile);
		 */
		if (isActive) RSEPreferencesManager.deleteActiveProfile(oldName);
//		invalidateCache();
		if (persist) {
			IRSEPersistenceProvider provider = profile.getPersistenceProvider();
			RSECorePlugin.getThePersistenceManager().deleteProfile(provider, oldName);
		}
	}

	/* (non-Javadoc)
	 * @see org.eclipse.rse.core.model.ISystemProfileManager#cloneSystemProfile(org.eclipse.rse.core.model.ISystemProfile, java.lang.String)
	 */
	public ISystemProfile cloneSystemProfile(ISystemProfile profile, String newName) {
		ISystemProfile newProfile = createSystemProfile(newName, false);
		return newProfile;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.rse.core.model.ISystemProfileManager#isSystemProfileActive(java.lang.String)
	 */
	public boolean isSystemProfileActive(String profileName) {
		String[] activeProfiles = getActiveSystemProfileNames();
		boolean match = false;
		for (int idx = 0; !match && (idx < activeProfiles.length); idx++) {
			if (activeProfiles[idx].equals(profileName)) match = true;
		}
		return match;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.rse.core.model.ISystemProfileManager#getActiveSystemProfiles()
	 */
	public ISystemProfile[] getActiveSystemProfiles() {
		String[] profileNames = getActiveSystemProfileNames();
		ISystemProfile[] profiles = new ISystemProfile[profileNames.length];
		for (int idx = 0; idx < profileNames.length; idx++) {
			profiles[idx] = getOrCreateSystemProfile(profileNames[idx]);
			((SystemProfile) profiles[idx]).setActive(true);
		}
		return profiles;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.rse.core.model.ISystemProfileManager#getActiveSystemProfileNames()
	 */
	public String[] getActiveSystemProfileNames() {
		String[] activeProfileNames = RSEPreferencesManager.getActiveProfiles();
		// dy: defect 48355, need to sync this with the actual profile list.  If the user
		// imports old preference settings or does a team sync and a profile is deleted then
		// it is possible an active profile no longer exists.
		// String[] systemProfileNames = getSystemProfileNames();
		ISystemProfile[] systemProfiles = getSystemProfiles();
		boolean found;
		boolean found_team = false;
		boolean found_private = false;
		boolean changed = false;
		String defaultProfileName = RSEPreferencesManager.getDefaultPrivateSystemProfileName();

		for (int activeIdx = 0; activeIdx < activeProfileNames.length; activeIdx++) {
			// skip Team and Private profiles
			String activeProfileName = activeProfileNames[activeIdx];
			if (activeProfileName.equals(defaultProfileName)) {
				found_private = true;
			} else if (activeProfileName.equals(RSEPreferencesManager.getDefaultTeamProfileName())) {
				found_team = true;
			} else {
				found = false;
				for (int systemIdx = 0; systemIdx < systemProfiles.length && !found; systemIdx++) {
					if (activeProfileNames[activeIdx].equals(systemProfiles[systemIdx].getName())) {
						found = true;
					}
				}

				if (!found) {
					// The active profile no longer exists so remove it from the active list
					RSEPreferencesManager.deleteActiveProfile(activeProfileNames[activeIdx]);
					changed = true;
				}
			}
		}

		for (int systemIdx = 0; systemIdx < systemProfiles.length && !changed; systemIdx++) {
			boolean matchesBoth = false;
			String name = systemProfiles[systemIdx].getName();

			for (int activeIdx = 0; activeIdx < activeProfileNames.length && !matchesBoth; activeIdx++) {
				String aname = activeProfileNames[activeIdx];
				if (name.equals(aname)) {
					matchesBoth = true;
				}

			}
			if (!matchesBoth && found_private) {
				if (systemProfiles[systemIdx].isActive() || systemProfiles[systemIdx].isDefaultPrivate()) {
					RSEPreferencesManager.addActiveProfile(name);
					RSEPreferencesManager.deleteActiveProfile(RSECorePlugin.getLocalMachineName());
					activeProfileNames = RSEPreferencesManager.getActiveProfiles();
				}
			}
		}

		// the active profiles list needed to be changed because of an external update, also
		// check if Default profile needs to be added back to the list
		if (changed || !found_team || !found_private) {
			if (systemProfiles.length == 0) {
				// First time user, make sure default is in the active list, the only time it wouldn't
				// be is if the pref_store.ini was modified (because the user imported old preferences)
				if (!found_team) {
					RSEPreferencesManager.addActiveProfile(RSEPreferencesManager.getDefaultTeamProfileName());
					changed = true;
				}

				if (!found_private) {
					RSEPreferencesManager.addActiveProfile(RSECorePlugin.getLocalMachineName());
					changed = true;
				}
			} else {
				ISystemProfile defaultProfile = getDefaultPrivateSystemProfile();
				if (defaultProfile != null && !found_private) {
					RSEPreferencesManager.addActiveProfile(defaultProfile.getName());
					changed = true;
				}
			}

			if (changed) {
				activeProfileNames = RSEPreferencesManager.getActiveProfiles();
			}
		}

		return activeProfileNames;
	}

	/**
	 * @return the profile names currently selected by the user as "active" profiles
	 */
	public Vector getActiveSystemProfileNamesVector() {
		String[] profileNames = RSEPreferencesManager.getActiveProfiles();
		Vector v = new Vector(profileNames.length);
		for (int idx = 0; idx < profileNames.length; idx++)
			v.addElement(profileNames[idx]);
		return v;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.rse.core.model.ISystemProfileManager#getActiveSystemProfilePosition(java.lang.String)
	 */
	public int getActiveSystemProfilePosition(String profileName) {
		String[] profiles = getActiveSystemProfileNames();
		int pos = -1;
		for (int idx = 0; (pos < 0) && (idx < profiles.length); idx++) {
			if (profiles[idx].equals(profileName)) pos = idx;
		}
		return pos;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.rse.core.model.ISystemProfileManager#getDefaultPrivateSystemProfile()
	 */
	public ISystemProfile getDefaultPrivateSystemProfile() {
		return getSystemProfile(RSEPreferencesManager.getDefaultPrivateSystemProfileName());
	}

	/* (non-Javadoc)
	 * @see org.eclipse.rse.core.model.ISystemProfileManager#getDefaultTeamSystemProfile()
	 */
	public ISystemProfile getDefaultTeamSystemProfile() {
		return getSystemProfile(RSEPreferencesManager.getDefaultTeamProfileName());
	}

	/* (non-Javadoc)
	 * @see org.eclipse.rse.core.model.ISystemProfileManager#getProfiles()
	 */
	public List getProfiles() {
		List result = new ArrayList(_profiles.size());
		result.addAll(_profiles);
		return result;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.rse.core.model.ISystemProfileManager#getSize()
	 */
	public int getSize() {
		return _profiles.size();
	}
	
	/**
	 * Adds a newly restored profile to this manager
	 * @param profile the profile to add
	 */
	public void addSystemProfile(ISystemProfile profile) {
		_profiles.add(profile);
		String name = profile.getName();
		if (profile.isActive()) {
			RSEPreferencesManager.addActiveProfile(name);
		}
		profile.setDefaultPrivate(name.equalsIgnoreCase(RSEPreferencesManager.getDefaultPrivateSystemProfileName()));
	}

	private ISystemProfile[] getSystemProfiles(boolean ensureDefaultPrivateProfileExists) {
		if (ensureDefaultPrivateProfileExists) {
			ensureDefaultPrivateProfile();
		}
		ISystemProfile[] result = new ISystemProfile[_profiles.size()];
		_profiles.toArray(result);
		return result;
	}

	public void setRestoring(boolean flag) {
		restoring = flag;
	}

	private ISystemProfile internalCreateSystemProfile(String name) {
			ISystemProfile newProfile = new SystemProfile();
			newProfile.setName(name);
			newProfile.setProfileManager(this);
			_profiles.add(newProfile);
	//		invalidateCache();
			newProfile.setDefaultPrivate(name.equalsIgnoreCase(RSEPreferencesManager.getDefaultPrivateSystemProfileName()));
			return newProfile;
		}

	private void ensureDefaultPrivateProfile() {
		// Ensure that one Profile is the default Profile - defect 48995 NH	
		boolean defaultProfileExists = false;
		for (Iterator z = _profiles.iterator(); z.hasNext() && !defaultProfileExists;) {
			ISystemProfile profile = (ISystemProfile) z.next();
			defaultProfileExists = profile.isDefaultPrivate();
		}
		if (!defaultProfileExists) {
			// find one with the right name
			String defaultPrivateProfileName = RSEPreferencesManager.getDefaultPrivateSystemProfileName();
			for (Iterator z = _profiles.iterator(); z.hasNext() && !defaultProfileExists;) {
				ISystemProfile profile = (ISystemProfile) z.next();
				if (profile.getName().equals(defaultPrivateProfileName)) {
					profile.setDefaultPrivate(true);
					defaultProfileExists = true;
				}
			}
		}
		if (!defaultProfileExists) {
			// Find the first profile that is not the Team profile and make it the default private profile 	
			String defaultTeamProfileName = RSEPreferencesManager.getDefaultTeamProfileName();
			for (Iterator z = _profiles.iterator(); z.hasNext() && !defaultProfileExists;) {
				ISystemProfile profile = (ISystemProfile) z.next();
				if (!profile.getName().equals(defaultTeamProfileName)) {
					profile.setDefaultPrivate(true);
					defaultProfileExists = true;
				}
			}
		}
		if (!defaultProfileExists) {
			// If Team is the only profile - then put a message in the log and create the default private profile
			Logger logger = RSECorePlugin.getDefault().getLogger();
			logger.logWarning("Only one Profile Team exists - there is no Default Profile"); //$NON-NLS-1$
			createDefaultPrivateProfile();
		}
	}

	private void createDefaultPrivateProfile() {
		ISystemProfile profile = new SystemProfile();
		String initProfileName = RSEPreferencesManager.getDefaultPrivateSystemProfileName();
		profile.setName(initProfileName);
		profile.setDefaultPrivate(true);
		_profiles = new ArrayList();
		_profiles.add(profile);
	}

	/**
	 * Instantiate a user profile given its name.
	 * @param userProfileName the name of the profile to find or create
	 * @return the profile that was found or created.
	 */
	private ISystemProfile getOrCreateSystemProfile(String userProfileName) {
		ISystemProfile userProfile = getSystemProfile(userProfileName);
		if (userProfile == null) {
			userProfile = internalCreateSystemProfile(userProfileName);
		}
		return userProfile;
	}

}




/********************************************************************************
 * Copyright (c) 2002, 2007 IBM Corporation. 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
 * 
 * Initial Contributors:
 * The following IBM employees contributed to the Remote System Explorer
 * component that contains this file: David McKnight, Kushal Munir, 
 * Michael Berger, David Dykstal, Phil Coulthard, Don Yantzi, Eric Simpson, 
 * Emily Bruner, Mazen Faraj, Adrian Storisteanu, Li Ding, and Kent Hawley.
 * 
 * Contributors:
 * David Dykstal (IBM) - 142806: refactoring persistence framework
 ********************************************************************************/

package org.eclipse.rse.internal.core.model;
import java.util.Vector;

import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.Platform;
import org.eclipse.rse.core.RSECorePlugin;
import org.eclipse.rse.core.filters.ISystemFilterPool;
import org.eclipse.rse.core.filters.ISystemFilterPoolManager;
import org.eclipse.rse.core.model.IHost;
import org.eclipse.rse.core.model.IRSEPersistableContainer;
import org.eclipse.rse.core.model.ISystemProfile;
import org.eclipse.rse.core.model.ISystemProfileManager;
import org.eclipse.rse.core.model.ISystemRegistry;
import org.eclipse.rse.core.model.RSEModelObject;
import org.eclipse.rse.core.subsystems.ISubSystemConfiguration;
import org.eclipse.rse.persistence.IRSEPersistenceProvider;

/**
 * A profile contains hosts and filter pools. It is the unit of save/restore for RSE model 
 * objects. All model objects are contained within a profile.
 */
public class SystemProfile extends RSEModelObject implements ISystemProfile, IAdaptable
{

	private ISystemProfileManager mgr = null;
	private IRSEPersistenceProvider provider = null;
	private boolean isActive = true;
	private String name = null;
	private boolean defaultPrivate = false;

	/**
	 * Default constructor
	 */
	protected SystemProfile() 
	{
		super();
	}
	
	public SystemProfile(String name, boolean isActive) {
		this.name = name;
		this.isActive = isActive;
	}

	/**
     * Set the in-memory pointer back to the parent system profile manager
     */
    public void setProfileManager(ISystemProfileManager mgr)
    {
    	this.mgr = mgr;
    }

    /**
     * Get the in-memory pointer back to the parent system profile manager
     */
    public ISystemProfileManager getProfileManager()
    {
    	return mgr;
    }
    
    /**
     * Convenience method for create a new connection within this profile.
     * Shortcut for {@link ISystemRegistry#createHost(String,String,String,String)}
     */
    public IHost createHost(String systemType, String connectionName, String hostName, String description) throws Exception
    {
		return RSECorePlugin.getDefault().getSystemRegistry().createHost(getName(), systemType, connectionName,  hostName, description);
    }
    
	/**
	 * Return all connections for this profile
	 */
	public IHost[] getHosts()
	{
		return RSECorePlugin.getDefault().getSystemRegistry().getHostsByProfile(this);
	}

	/**
	 * Return all filter pools for this profile
	 */
	public ISystemFilterPool[] getFilterPools()
	{
		ISubSystemConfiguration[] ssFactories = RSECorePlugin.getDefault().getSystemRegistry().getSubSystemConfigurations();
		Vector poolsVector = new Vector();
		for (int idx = 0; idx < ssFactories.length; idx++)
		{
			ISystemFilterPoolManager poolMgr = ssFactories[idx].getFilterPoolManager(this);
			ISystemFilterPool[] pools = poolMgr.getSystemFilterPools();
			for (int ydx=0; ydx<pools.length; ydx++)
			{
				poolsVector.add(pools[ydx]);
			}
		}
		ISystemFilterPool[] allPools = new ISystemFilterPool[poolsVector.size()];
		poolsVector.toArray(allPools);
		return allPools;
	}

	/**
	 * Return all filter pools for this profile, scoped by a given subsystem factory
	 */
	public ISystemFilterPool[] getFilterPools(ISubSystemConfiguration ssf)
	{
		ISystemFilterPoolManager poolMgr = ssf.getFilterPoolManager(this);
		return poolMgr.getSystemFilterPools();
	}

	/**
	 * Return true if this profile is currently active.
	 */
	public boolean isActive()
	{
		return isActive;
	}
	/**
	 * Reset whether this profile is currently active.
	 */
	public void setActive(boolean active)
	{
		this.isActive = active;
		setDirty(true);
	}

    /**
 	 * This is the method required by the IAdaptable interface.
	 * Given an adapter class type, return an object castable to the type, or
	 *  null if this is not possible.
	 */
    public Object getAdapter(Class adapterType)
    {
   	    return Platform.getAdapterManager().getAdapter(this, adapterType);	
    }   

    //For debugging
	public String toString() {
		String result = getName();
		if (result == null) {
			StringBuffer buf = new StringBuffer(super.toString());
			buf.append("Profile(name: "); //$NON-NLS-1$
			buf.append(name);
			buf.append(", defaultPrivate: "); //$NON-NLS-1$
			buf.append(defaultPrivate);
			buf.append(')');
			result = buf.toString();
		}
		return result;
	}

	/**
	 * @generated This field/method will be replaced during code generation 
	 */
	public String getName()
	{
		return name;
	}
	
	public String getDescription()
	{
		return RSEModelResources.RESID_MODELOBJECTS_PROFILE_DESCRIPTION;
	}

	/**
	 * @generated This field/method will be replaced during code generation.
	 */
	public void setName(String newName)
	{
		name = newName;
		setDirty(true);
	}

	/**
	 * @generated This field/method will be replaced during code generation 
	 * Is this profile created automatically, and is it the profile
	 * that is unique for this developer?
	 */
	public boolean isDefaultPrivate()
	{
		return defaultPrivate;
	}

	/**
	 * @generated This field/method will be replaced during code generation.
	 */
	public void setDefaultPrivate(boolean newDefaultPrivate)
	{
		defaultPrivate = newDefaultPrivate;
		setDirty(true);
	}
	
	public boolean commit() 
	{
		return RSECorePlugin.getThePersistenceManager().commitProfile(this);
	}
	
	/**
	 * The SystemProfile is the top of the persistence hierarchy.
	 * @return null
	 */
	public IRSEPersistableContainer getPersistableParent() {
		return null;
	}
	
	public IRSEPersistableContainer[] getPersistableChildren() {
		ISystemFilterPool[] pools = getFilterPools();
		IHost[] hosts = getHosts();
		IRSEPersistableContainer[] result = new IRSEPersistableContainer[pools.length + hosts.length];
		System.arraycopy(pools, 0, result, 0, pools.length);
		System.arraycopy(hosts, 0, result, pools.length, hosts.length);
		return result;	
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.rse.core.model.ISystemProfile#getPersistenceProvider()
	 */
	public IRSEPersistenceProvider getPersistenceProvider() {
		return provider;
	}
	
	public void setPersistenceProvider(IRSEPersistenceProvider provider) {
		this.provider = provider;
	}
	
	

}




	/**
	 * Reset the existing names list. 
	 */
	public void setExistingNamesList(Vector newList)
	{		
		if (newList == null)
		  existingList = null;
		else
		{
		  existingList = new String[newList.size()];
		  newList.toArray(existingList);
		  {
		     if (!caseSensitive)
		       newList[idx] = existingList.elementAt(idx).toString().toLowerCase();		
		     else
		       newList[idx] = existingList.elementAt(idx).toString(); 
		  }
		  init(newList, true); // don't redo the toLowerCase calls		
		}
	}
	/**

Lines 16-26 Link Here

(-)UI/org/eclipse/rse/internal/ui/view/team/SystemTeamViewProfileAdapter.java (-1 / +5 lines)
16		16
17	package org.eclipse.rse.internal.ui.view.team;	17	package org.eclipse.rse.internal.ui.view.team;
18	import java.util.Hashtable;	18	import java.util.Hashtable;
		19	import java.util.Vector;
19		20
20	import org.eclipse.core.runtime.IAdaptable;	21	import org.eclipse.core.runtime.IAdaptable;
21	import org.eclipse.core.runtime.IProgressMonitor;	22	import org.eclipse.core.runtime.IProgressMonitor;
22	import org.eclipse.jface.resource.ImageDescriptor;	23	import org.eclipse.jface.resource.ImageDescriptor;
23	import org.eclipse.jface.viewers.IStructuredSelection;	24	import org.eclipse.jface.viewers.IStructuredSelection;
		25	import org.eclipse.rse.core.RSECorePlugin;
24	import org.eclipse.rse.core.SystemResourceManager;	26	import org.eclipse.rse.core.SystemResourceManager;
25	import org.eclipse.rse.core.model.ISystemProfile;	27	import org.eclipse.rse.core.model.ISystemProfile;
26	import org.eclipse.rse.internal.ui.SystemResources;	28	import org.eclipse.rse.internal.ui.SystemResources;
Lines 371-377 Link Here
371	*/	373	*/
372	public ISystemValidator getNameValidator(Object element)	374	public ISystemValidator getNameValidator(Object element)
373	{	375	{
374	return new ValidatorProfileName(RSEUIPlugin.getTheSystemRegistry().getSystemProfileManager().getSystemProfileNamesVector());	376	Vector names = RSECorePlugin.getDefault().getSystemRegistry().getSystemProfileManager().getSystemProfileNamesVector();
		377	ISystemValidator validator = new ValidatorProfileName(names);
		378	return validator;
375	}	379	}
376	/**	380	/**
377	* Parent override.	381	* Parent override.




import org.eclipse.rse.core.references.IRSEBaseReferencingObject;
import org.eclipse.rse.internal.core.filters.SystemFilterPoolWrapperInformation;
import org.eclipse.rse.internal.core.filters.SystemFilterStartHere;
import org.eclipse.rse.internal.core.model.SystemProfileManager;
import org.eclipse.rse.internal.ui.SystemPropertyResources;
import org.eclipse.rse.internal.ui.SystemResources;
import org.eclipse.rse.internal.ui.subsystems.SubSystemConfigurationProxyAdapter;

	 */
	public ISystemProfile getSystemProfile(String name)
	{
		return SystemProfileManager.getDefault().getSystemProfile(name);
	}

	/**

		}
		if ((subsystems == null) || (subsystems.length != getSubSystemList().size()))
		{
			List alist = null;
			if (SystemProfileManager.getDefault().getSize() > 0) // 42913
				alist = getSubSystemList();
			if (alist == null)
				return new ISubSystem[0];

	 */
	protected boolean isUserPrivateProfile(ISystemFilterPoolManager mgr)
	{
		ISystemProfile profile = mgr.getSystemProfile();
		boolean result = profile.isDefaultPrivate() || mgr.getName().equalsIgnoreCase("private"); //$NON-NLS-1$
		return result;
		ISystemProfile profile = getSystemProfile(mgr);
		//System.out.println("Testing for user private profile for mgr " + mgr.getName() + ": " + profile.isDefaultPrivate());;
		return profile.isDefaultPrivate() || mgr.getName().equalsIgnoreCase("private"); //$NON-NLS-1$
	}

	/**

	public ISubSystem[] testForActiveReferences(ISystemProfile profile)
	{
		Vector v = new Vector();
		ISystemProfileManager profileMgr = SystemProfileManager.getDefault();
		ISystemFilterPoolManager sfpm = getFilterPoolManager(profile);
		String profileName = profile.getName();
		if (sfpm != null)

		if (filterPoolManagerList == null)
		{
			filterPoolManagerList = new ArrayList();
			//FIXMEnew EObjectContainmenteList(SystemFilterPoolManager.class, this, SubsystemsPackage.SUB_SYSTEM_FACTORY__FILTER_POOL_MANAGER_LIST);
		}
		return filterPoolManagerList;
	}

Lines 3249-3256 Link Here

(-)subsystems/org/eclipse/rse/core/subsystems/SubSystem.java (-1 / +6 lines)
3249	}	3249	}
3250		3250
3251	public IRSEPersistableContainer[] getPersistableChildren() {	3251	public IRSEPersistableContainer[] getPersistableChildren() {
		3252	IRSEPersistableContainer[] result = null;
3252	ISystemFilterPoolReferenceManager manager = getSystemFilterPoolReferenceManager();	3253	ISystemFilterPoolReferenceManager manager = getSystemFilterPoolReferenceManager();
3253	IRSEPersistableContainer[] result = manager.getReferencedSystemFilterPools();	3254	if (manager != null) {
		3255	result = manager.getReferencedSystemFilterPools();
		3256	} else {
		3257	result = new IRSEPersistableContainer[0];
		3258	}
3254	return result;	3259	return result;
3255	}	3260	}
3256		3261




package org.eclipse.rse.internal.ui;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.rse.core.model.ISystemProfile;
import org.eclipse.rse.internal.model.SystemProfileManager;
import org.eclipse.rse.services.clientserver.messages.SystemMessage;
import org.eclipse.rse.ui.RSEUIPlugin;
import org.eclipse.rse.ui.SystemWidgetHelpers;
import org.eclipse.rse.ui.dialogs.SystemPromptDialog;
import org.eclipse.rse.ui.messages.ISystemMessageLine;
import org.eclipse.rse.ui.validators.ISystemValidator;
import org.eclipse.rse.ui.validators.ValidatorFactory;
import org.eclipse.rse.ui.validators.ValidatorProfileName;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;

		this.showVerbiage = showVerbiage;
		callerInstanceOfWizardPage = (caller instanceof WizardPage);
		callerInstanceOfSystemPromptDialog = (caller instanceof SystemPromptDialog);	
		nameValidator = ValidatorFactory.getProfileNameValidator(profile.getName());
		// FIXME cast to SystemProfileManager is temporary to get at api - need to use an adapter for getting validators
		SystemProfileManager mgr = (SystemProfileManager)RSEUIPlugin.getTheSystemRegistry().getSystemProfileManager();
		nameValidator = mgr.getProfileNameValidator(profile);
	}
	
	/**




/********************************************************************************
 * Copyright (c) 2002, 2007 IBM Corporation. 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
 * 
 * Initial Contributors:
 * The following IBM employees contributed to the Remote System Explorer
 * component that contains this file: David McKnight, Kushal Munir, 
 * Michael Berger, David Dykstal, Phil Coulthard, Don Yantzi, Eric Simpson, 
 * Emily Bruner, Mazen Faraj, Adrian Storisteanu, Li Ding, and Kent Hawley.
 * 
 * Contributors:
 * David Dykstal (IBM) - 142806: refactoring persistence framework
 ********************************************************************************/

package org.eclipse.rse.internal.model;
import java.util.Vector;

import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.Platform;
import org.eclipse.rse.core.filters.ISystemFilterPool;
import org.eclipse.rse.core.filters.ISystemFilterPoolManager;
import org.eclipse.rse.core.model.IHost;
import org.eclipse.rse.core.model.IRSEPersistableContainer;
import org.eclipse.rse.core.model.ISystemProfile;
import org.eclipse.rse.core.model.ISystemProfileManager;
import org.eclipse.rse.core.model.ISystemRegistry;
import org.eclipse.rse.core.model.RSEModelObject;
import org.eclipse.rse.core.subsystems.ISubSystemConfiguration;
import org.eclipse.rse.internal.core.model.RSEModelResources;
import org.eclipse.rse.persistence.IRSEPersistenceProvider;
import org.eclipse.rse.ui.RSEUIPlugin;

/**
 * A profile contains hosts and filter pools. It is the unit of save/restore for RSE model 
 * objects. All model objects are contained within a profile.
 */
public class SystemProfile extends RSEModelObject implements ISystemProfile, IAdaptable
{

	private ISystemProfileManager mgr;
	private IRSEPersistenceProvider provider;
	private boolean active;
	private String name = null;
	private boolean defaultPrivate = false;

	/**
	 * Default constructor
	 */
	protected SystemProfile() 
	{
		super();
	}

	/**
     * Set the in-memory pointer back to the parent system profile manager
     */
    public void setProfileManager(ISystemProfileManager mgr)
    {
    	this.mgr = mgr;
    }

    /**
     * Get the in-memory pointer back to the parent system profile manager
     */
    public ISystemProfileManager getProfileManager()
    {
    	return mgr;
    }
    
    /**
     * Convenience method for create a new connection within this profile.
     * Shortcut for {@link ISystemRegistry#createHost(String,String,String,String)}
     */
    public IHost createHost(String systemType, String connectionName, String hostName, String description) throws Exception
    {
		return RSEUIPlugin.getTheSystemRegistry().createHost(getName(), systemType, connectionName,  hostName, description);
    }
    
	/**
	 * Return all connections for this profile
	 */
	public IHost[] getHosts()
	{
		return RSEUIPlugin.getTheSystemRegistry().getHostsByProfile(this);
	}

	/**
	 * Return all filter pools for this profile
	 */
	public ISystemFilterPool[] getFilterPools()
	{
		ISubSystemConfiguration[] ssFactories = RSEUIPlugin.getTheSystemRegistry().getSubSystemConfigurations();
		Vector poolsVector = new Vector();
		for (int idx = 0; idx < ssFactories.length; idx++)
		{
			ISystemFilterPoolManager poolMgr = ssFactories[idx].getFilterPoolManager(this);
			ISystemFilterPool[] pools = poolMgr.getSystemFilterPools();
			for (int ydx=0; ydx<pools.length; ydx++)
			{
				poolsVector.add(pools[ydx]);
			}
		}
		ISystemFilterPool[] allPools = new ISystemFilterPool[poolsVector.size()];
		poolsVector.toArray(allPools);
		return allPools;
	}

	/**
	 * Return all filter pools for this profile, scoped by a given subsystem factory
	 */
	public ISystemFilterPool[] getFilterPools(ISubSystemConfiguration ssf)
	{
		ISystemFilterPoolManager poolMgr = ssf.getFilterPoolManager(this);
		return poolMgr.getSystemFilterPools();
	}

	/**
	 * Return true if this profile is currently active.
	 */
	public boolean isActive()
	{
		return active;
	}
	/**
	 * Reset whether this profile is currently active.
	 */
	public void setActive(boolean active)
	{
		this.active = active;
	}

    /**
 	 * This is the method required by the IAdaptable interface.
	 * Given an adapter class type, return an object castable to the type, or
	 *  null if this is not possible.
	 */
    public Object getAdapter(Class adapterType)
    {
   	    return Platform.getAdapterManager().getAdapter(this, adapterType);	
    }   

    //For debugging
	public String toString() {
		String result = getName();
		if (result == null) {
			StringBuffer buf = new StringBuffer(super.toString());
			buf.append("Profile(name: "); //$NON-NLS-1$
			buf.append(name);
			buf.append(", defaultPrivate: "); //$NON-NLS-1$
			buf.append(defaultPrivate);
			buf.append(')');
			result = buf.toString();
		}
		return result;
	}

	/**
	 * @generated This field/method will be replaced during code generation 
	 */
	public String getName()
	{
		return name;
	}
	
	public String getDescription()
	{
		return RSEModelResources.RESID_MODELOBJECTS_PROFILE_DESCRIPTION;
	}

	/**
	 * @generated This field/method will be replaced during code generation.
	 */
	public void setName(String newName)
	{
		name = newName;
	}

	/**
	 * @generated This field/method will be replaced during code generation 
	 * Is this profile created automatically, and is it the profile
	 * that is unique for this developer?
	 */
	public boolean isDefaultPrivate()
	{
		return defaultPrivate;
	}

	/**
	 * @generated This field/method will be replaced during code generation.
	 */
	public void setDefaultPrivate(boolean newDefaultPrivate)
	{
		defaultPrivate = newDefaultPrivate;
	}
	
	public boolean commit() 
	{
		return RSEUIPlugin.getThePersistenceManager().commit(this);
	}
	
	/**
	 * The SystemProfile is the top of the persistence hierarchy.
	 * @return null
	 */
	public IRSEPersistableContainer getPersistableParent() {
		return null;
	}
	
	public IRSEPersistableContainer[] getPersistableChildren() {
		ISystemFilterPool[] pools = getFilterPools();
		IHost[] hosts = getHosts();
		IRSEPersistableContainer[] result = new IRSEPersistableContainer[pools.length + hosts.length];
		System.arraycopy(pools, 0, result, 0, pools.length);
		System.arraycopy(hosts, 0, result, pools.length, hosts.length);
		return result;	
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.rse.core.model.ISystemProfile#getPersistenceProvider()
	 */
	public IRSEPersistenceProvider getPersistenceProvider() {
		return provider;
	}
	
	public void setPersistenceProvider(IRSEPersistenceProvider provider) {
		this.provider = provider;
	}
	
	

}




import org.eclipse.rse.core.model.ISystemProfile;
import org.eclipse.rse.core.model.RSEModelObject;
import org.eclipse.rse.internal.core.model.RSEModelResources;
import org.eclipse.rse.internal.core.model.SystemProfileManager;
import org.eclipse.rse.ui.RSESystemTypeAdapter;



     */
    public ISystemProfile getSystemProfile()
    {
    	return SystemProfileManager.getDefault().getSystemProfile(getName());
    }	
	
	/**

    	conn.deletingHost(); // let connection do any necessary cleanup
        getHostList().remove(conn);
        setDirty(true);
        conn.getSystemProfile().commit();
    }

    /**

	 */
	public boolean commit()
	{
		ISystemProfile profile = getSystemProfile();
		boolean result = profile.commit();
		return result;
	}

	/**




/********************************************************************************
 * Copyright (c) 2006, 2007 IBM Corporation. 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
 * 
 * Initial Contributors:
 * The following IBM employees contributed to the Remote System Explorer
 * component that contains this file: David McKnight, Kushal Munir, 
 * Michael Berger, David Dykstal, Phil Coulthard, Don Yantzi, Eric Simpson, 
 * Emily Bruner, Mazen Faraj, Adrian Storisteanu, Li Ding, and Kent Hawley.
 * 
 * Contributors:
 * David Dykstal (IBM) - created and used RSEPreferencesManager
 *                     - moved SystemPreferencesManager to a new plugin
 ********************************************************************************/

package org.eclipse.rse.internal.model;

import java.util.ArrayList;
import java.util.List;
import java.util.Vector;

import org.eclipse.rse.core.RSECorePlugin;
import org.eclipse.rse.core.RSEPreferencesManager;
import org.eclipse.rse.core.SystemBasePlugin;
import org.eclipse.rse.core.model.ISystemProfile;
import org.eclipse.rse.core.model.ISystemProfileManager;
import org.eclipse.rse.model.SystemStartHere;
import org.eclipse.rse.ui.RSEUIPlugin;
import org.eclipse.rse.ui.validators.ISystemValidator;
import org.eclipse.rse.ui.validators.ValidatorProfileName;

/**
 * A class that manages a list of SystemProfile objects.
 * This should be used as a singleton.
 */
public class SystemProfileManager implements ISystemProfileManager {
	private List _profiles = null;
	private String[] profileNames = null;
	private Vector profileNamesVector = null;
	private static ISystemProfileManager singleton = null;
	private static final String PROFILE_FILE_NAME = "profile"; //$NON-NLS-1$

	/**
	 * Ordinarily there should be only one instance of a SystemProfileManager
	 * created on the system, so the static method {@link #getSystemProfileManager()} is 
	 * preferred to using this.
	 */
	private SystemProfileManager() {
		super();
	}

	/**
	 * @return (and create if necessary) the singleton instance of this class.
	 */
	public static ISystemProfileManager getSystemProfileManager() {
		if (singleton == null) {
			singleton = new SystemProfileManager();
			RSEUIPlugin.getThePersistenceManager().restore(singleton); // restores all of RSE
		}
		return singleton;
	}

	/**
	 * Clear the default after a team sychronization say
	 */
	public static void clearDefault() {
		singleton = null;
	}

	/**
	 * Create a new profile with the given name, and add to the list.
	 * The name must be unique within the existing list.
	 * <p>
	 * The underlying folder is created in the file system.
	 * <p>
	 * @param name What to name this profile
	 * @param makeActive true if this profile is to be added to the active profile list.
	 * @return new profile, or null if name not unique.
	 * @see ISystemProfileManager#createSystemProfile(String, boolean)
	 */
	public ISystemProfile createSystemProfile(String name, boolean makeActive) {
		// FIXME - used to use MOF
		ISystemProfile existingProfile = getSystemProfile(name);
		if (existingProfile != null) {
			deleteSystemProfile(existingProfile, false); // replace the existing one with a new profile
		}

		ISystemProfile newProfile = internalCreateSystemProfileAndFolder(name);
		if (makeActive) {
			RSEPreferencesManager.addActiveProfile(name);
			((SystemProfile) newProfile).setActive(makeActive);
		}
		RSEUIPlugin.getThePersistenceManager().commit(this);
		return newProfile;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.rse.core.model.ISystemProfileManager#makeSystemProfileActive(org.eclipse.rse.core.model.ISystemProfile, boolean)
	 */
	public void makeSystemProfileActive(ISystemProfile profile, boolean makeActive) {
		boolean wasActive = isSystemProfileActive(profile.getName());
		if (wasActive && !makeActive)
			RSEPreferencesManager.deleteActiveProfile(profile.getName());
		else if (makeActive && !wasActive) RSEPreferencesManager.addActiveProfile(profile.getName());
		((SystemProfile) profile).setActive(makeActive);
	}

	/*
	 * private version that avoids name collision check
	 */
	private ISystemProfile internalCreateSystemProfile(String name) {
		ISystemProfile profile = new SystemProfile();
		initialize(profile, name);
		profile.setDefaultPrivate(name.equalsIgnoreCase(RSEPreferencesManager.getDefaultPrivateSystemProfileName()));
		return profile;
	}

	/*
	 * private version that avoids name collision check
	 */
	private ISystemProfile internalCreateSystemProfileAndFolder(String name) {
		ISystemProfile profile = internalCreateSystemProfile(name);
		// FIXME This is where the old style folders get created for profiles.
		// This is no longer needed but 
		// SystemResourceManager.getProfileFolder(profile); // creates proj/profileName folder
		return profile;
	}

	/*
	 * private method to initialize state for new profile
	 */
	private void initialize(ISystemProfile profile, String name) {
		profile.setName(name);
		profile.setProfileManager(this);
		getProfiles().add(profile);
		invalidateCache();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.rse.core.model.ISystemProfileManager#getSystemProfiles()
	 */
	public ISystemProfile[] getSystemProfiles() {
		List profiles = getProfiles();

		// Ensure that one Profile is the default Profile - defect 48995 NH	
		boolean defaultProfileExist = false;
		for (int idx = 0; (!defaultProfileExist) && (idx < profiles.size()); idx++) {
			ISystemProfile profile = (ISystemProfile) profiles.get(idx);
			if (profile.isDefaultPrivate()) {
				defaultProfileExist = true;
			}
		}
		if (!defaultProfileExist) {
			// Check if the Profile exists with name same as the LocalMachine Name - this is the default we give
			// when creating connections. 	
			for (int idx = 0; (!defaultProfileExist) && (idx < profiles.size()); idx++) {
				ISystemProfile profile = (ISystemProfile) profiles.get(idx);
				String initProfileName = RSEPreferencesManager.getDefaultPrivateSystemProfileName();
				if (profile.getName().equalsIgnoreCase(initProfileName)) {
					profile.setDefaultPrivate(true);
					defaultProfileExist = true;
				}
			}

			// If did not find such a profile then the first profile found besides Team is set to be the default profile 	
			if (!defaultProfileExist) {
				for (int idx = 0; (!defaultProfileExist) && (idx < profiles.size()); idx++) {
					ISystemProfile profile = (ISystemProfile) profiles.get(idx);
					if (!profile.getName().equalsIgnoreCase(RSEPreferencesManager.getDefaultTeamProfileName())) {
						profile.setDefaultPrivate(true);

						RSEUIPlugin.getThePersistenceManager().commit(SystemStartHere.getSystemProfileManager());
						defaultProfileExist = true;
					}
				}
			}
			if (!defaultProfileExist) {
				// If Team is the only profile - then put a message in the log - do not make Team to be default
				if (profiles.size() == 1 && ((ISystemProfile) profiles.get(0)).getName().equalsIgnoreCase("Team")) //$NON-NLS-1$  
				{
					SystemBasePlugin.logWarning("Only one Profile Team exists - there is no Default Profile"); //$NON-NLS-1$
				} else {
					// sonething must have gone wrong - it should not come here
					SystemBasePlugin.logWarning("Something went wrong and the default profile is not set"); //$NON-NLS-1$
				}
			}
		}
		return (ISystemProfile[]) profiles.toArray(new ISystemProfile[profiles.size()]);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.rse.core.model.ISystemProfileManager#getSystemProfileNames()
	 */
	public String[] getSystemProfileNames() {
		if (profileNames == null) {
			ISystemProfile[] profiles = getSystemProfiles();
			profileNames = new String[profiles.length];
			for (int idx = 0; idx < profiles.length; idx++)
				profileNames[idx] = profiles[idx].getName();
		}
		return profileNames;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.rse.core.model.ISystemProfileManager#getSystemProfileNamesVector()
	 */
	public Vector getSystemProfileNamesVector() {
		if (profileNamesVector == null) {
			ISystemProfile[] profiles = getSystemProfiles();
			profileNamesVector = new Vector(profiles.length);
			for (int idx = 0; idx < profiles.length; idx++)
				profileNamesVector.addElement(profiles[idx].getName());
		}
		return profileNamesVector;
	}

	/**
	 * Something changed so invalide cache of profiles so it will be regenerated
	 */
	protected void invalidateCache() {
		//DY	profiles = null;
		profileNames = null;
		profileNamesVector = null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.rse.core.model.ISystemProfileManager#getSystemProfile(java.lang.String)
	 */
	public ISystemProfile getSystemProfile(String name) {
		ISystemProfile[] profiles = getSystemProfiles();
		if ((profiles == null) || (profiles.length == 0)) return null;
		ISystemProfile match = null;
		for (int idx = 0; (match == null) && (idx < profiles.length); idx++)
			if (profiles[idx].getName().equals(name)) match = profiles[idx];
		return match;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.rse.core.model.ISystemProfileManager#renameSystemProfile(org.eclipse.rse.core.model.ISystemProfile, java.lang.String)
	 */
	public void renameSystemProfile(ISystemProfile profile, String newName) {
		boolean isActive = isSystemProfileActive(profile.getName());
		String oldName = profile.getName();
		profile.setName(newName);
		if (isActive) RSEPreferencesManager.renameActiveProfile(oldName, newName);
		invalidateCache();
		// FIXME RSEUIPlugin.getThePersistenceManager().save(this);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.rse.core.model.ISystemProfileManager#deleteSystemProfile(org.eclipse.rse.core.model.ISystemProfile, boolean)
	 */
	public void deleteSystemProfile(ISystemProfile profile, boolean persist) {
		String oldName = profile.getName();
		boolean isActive = isSystemProfileActive(oldName);
		getProfiles().remove(profile);
		/* FIXME in EMF the profiles are "owned" by the Resource, and only referenced by the profile manager,
		 * so just removing it from the manager is not enough, it must also be removed from its resource.
		 * No longer needed since EMF is not in use.
		 * Resource res = profile.eResource();
		 * if (res != null)
		 * res.getContents().remove(profile);
		 */
		if (isActive) RSEPreferencesManager.deleteActiveProfile(oldName);
		invalidateCache();
		if (persist) {
			RSEUIPlugin.getThePersistenceManager().deleteProfile(oldName);
		}
	}

	/* (non-Javadoc)
	 * @see org.eclipse.rse.core.model.ISystemProfileManager#cloneSystemProfile(org.eclipse.rse.core.model.ISystemProfile, java.lang.String)
	 */
	public ISystemProfile cloneSystemProfile(ISystemProfile profile, String newName) {
		ISystemProfile newProfile = createSystemProfile(newName, false);
		return newProfile;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.rse.core.model.ISystemProfileManager#isSystemProfileActive(java.lang.String)
	 */
	public boolean isSystemProfileActive(String profileName) {
		String[] activeProfiles = getActiveSystemProfileNames();
		boolean match = false;
		for (int idx = 0; !match && (idx < activeProfiles.length); idx++) {
			if (activeProfiles[idx].equals(profileName)) match = true;
		}
		return match;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.rse.core.model.ISystemProfileManager#getActiveSystemProfiles()
	 */
	public ISystemProfile[] getActiveSystemProfiles() {
		String[] profileNames = getActiveSystemProfileNames();
		ISystemProfile[] profiles = new ISystemProfile[profileNames.length];
		for (int idx = 0; idx < profileNames.length; idx++) {
			profiles[idx] = getOrCreateSystemProfile(profileNames[idx]);
			((SystemProfile) profiles[idx]).setActive(true);
		}
		return profiles;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.rse.core.model.ISystemProfileManager#getActiveSystemProfileNames()
	 */
	public String[] getActiveSystemProfileNames() {
		String[] activeProfileNames = RSEPreferencesManager.getActiveProfiles();
		// dy: defect 48355, need to sync this with the actual profile list.  If the user
		// imports old preference settings or does a team sync and a profile is deleted then
		// it is possible an active profile no longer exists.
		// String[] systemProfileNames = getSystemProfileNames();
		ISystemProfile[] systemProfiles = getSystemProfiles();
		boolean found;
		boolean found_team = false;
		boolean found_private = false;
		boolean changed = false;
		String defaultProfileName = RSEPreferencesManager.getDefaultPrivateSystemProfileName();

		for (int activeIdx = 0; activeIdx < activeProfileNames.length; activeIdx++) {
			// skip Team and Private profiles
			String activeProfileName = activeProfileNames[activeIdx];
			if (activeProfileName.equals(defaultProfileName)) {
				found_private = true;
			} else if (activeProfileName.equals(RSEPreferencesManager.getDefaultTeamProfileName())) {
				found_team = true;
			} else {
				found = false;
				for (int systemIdx = 0; systemIdx < systemProfiles.length && !found; systemIdx++) {
					if (activeProfileNames[activeIdx].equals(systemProfiles[systemIdx].getName())) {
						found = true;
					}
				}

				if (!found) {
					// The active profile no longer exists so remove it from the active list
					RSEPreferencesManager.deleteActiveProfile(activeProfileNames[activeIdx]);
					changed = true;
				}
			}
		}

		for (int systemIdx = 0; systemIdx < systemProfiles.length && !changed; systemIdx++) {
			boolean matchesBoth = false;
			String name = systemProfiles[systemIdx].getName();

			for (int activeIdx = 0; activeIdx < activeProfileNames.length && !matchesBoth; activeIdx++) {
				String aname = activeProfileNames[activeIdx];
				if (name.equals(aname)) {
					matchesBoth = true;
				}

			}
			if (!matchesBoth && found_private) {
				if (systemProfiles[systemIdx].isActive() || systemProfiles[systemIdx].isDefaultPrivate()) {
					RSEPreferencesManager.addActiveProfile(name);
					RSEPreferencesManager.deleteActiveProfile(RSECorePlugin.getLocalMachineName());
					activeProfileNames = RSEPreferencesManager.getActiveProfiles();
				}
			}
		}

		// the active profiles list needed to be changed because of an external update, also
		// check if Default profile needs to be added back to the list
		if (changed || !found_team || !found_private) {
			if (systemProfiles.length == 0) {
				// First time user, make sure default is in the active list, the only time it wouldn't
				// be is if the pref_store.ini was modified (because the user imported old preferences)
				if (!found_team) {
					RSEPreferencesManager.addActiveProfile(RSEPreferencesManager.getDefaultTeamProfileName());
					changed = true;
				}

				if (!found_private) {
					RSEPreferencesManager.addActiveProfile(RSECorePlugin.getLocalMachineName());
					changed = true;
				}
			} else {
				ISystemProfile defaultProfile = getDefaultPrivateSystemProfile();
				if (defaultProfile != null && !found_private) {
					RSEPreferencesManager.addActiveProfile(defaultProfile.getName());
					changed = true;
				}
			}

			if (changed) {
				activeProfileNames = RSEPreferencesManager.getActiveProfiles();
			}
		}

		return activeProfileNames;
	}

	/**
	 * @return the profile names currently selected by the user as "active" profiles
	 */
	public Vector getActiveSystemProfileNamesVector() {
		String[] profileNames = RSEPreferencesManager.getActiveProfiles();
		Vector v = new Vector(profileNames.length);
		for (int idx = 0; idx < profileNames.length; idx++)
			v.addElement(profileNames[idx]);
		return v;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.rse.core.model.ISystemProfileManager#getActiveSystemProfilePosition(java.lang.String)
	 */
	public int getActiveSystemProfilePosition(String profileName) {
		String[] profiles = getActiveSystemProfileNames();
		int pos = -1;
		for (int idx = 0; (pos < 0) && (idx < profiles.length); idx++) {
			if (profiles[idx].equals(profileName)) pos = idx;
		}
		return pos;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.rse.core.model.ISystemProfileManager#getDefaultPrivateSystemProfile()
	 */
	public ISystemProfile getDefaultPrivateSystemProfile() {
		return getSystemProfile(RSEPreferencesManager.getDefaultPrivateSystemProfileName());
	}

	/* (non-Javadoc)
	 * @see org.eclipse.rse.core.model.ISystemProfileManager#getDefaultTeamSystemProfile()
	 */
	public ISystemProfile getDefaultTeamSystemProfile() {
		return getSystemProfile(RSEPreferencesManager.getDefaultTeamProfileName());
	}

	/**
	 * Instantiate a user profile given its name.
	 * @param userProfileName the name of the profile to find or create
	 * @return the profile that was found or created.
	 */
	protected ISystemProfile getOrCreateSystemProfile(String userProfileName) {
		ISystemProfile userProfile = getSystemProfile(userProfileName);
		if (userProfile == null) {
			userProfile = internalCreateSystemProfileAndFolder(userProfileName);
		}
		return userProfile;
	}

	/**
	 * No longer used.
	 * @param profileName the name of the profile from which to construct the name
	 * @return the unqualified save file name with the extension .xmi
	 */
	public static String getSaveFileName(String profileName) {
		return null;
		//FIXME SystemMOFHelpers.getSaveFileName(getRootSaveFileName(profileName)); no longer needed.
	}

	/**
	 * No longer used.
	 * @param profile the profile from which to construct the name 
	 * @return the unqualified save file name with the extension .xmi
	 */
	public static String getSaveFileName(ISystemProfile profile) {
		return null;
		//FIXME SystemMOFHelpers.getSaveFileName(getRootSaveFileName(profile)); no longer needed.
	}

	/**
	 * No longer used.
	 * @param profile the profile from which to retrieve the root.
	 * @return the root save file name without the extension .xmi
	 */
	protected static String getRootSaveFileName(ISystemProfile profile) {
		return getRootSaveFileName(profile.getName());
	}

	/**
	 * No longer used.
	 * @param profileName the name of the profile
	 * @return the root save file name without the extension .xmi
	 */
	protected static String getRootSaveFileName(String profileName) {
		//String fileName = profileName; // may be a bad idea to include manager name in it!
		String fileName = PROFILE_FILE_NAME;
		return fileName;
	}

	/**
	 * Reusable method to return a name validator for renaming a profile.
	 * @param profileName the current profile name on updates. Can be null for new profiles. Used
	 * to remove from the existing name list the current connection.
	 * @return the validator
	 */
	public ISystemValidator getProfileNameValidator(String profileName) {
		//Vector v = getActiveSystemProfileNamesVector();
		Vector v = getSystemProfileNamesVector();
		if (profileName != null) v.removeElement(profileName);
		ISystemValidator nameValidator = new ValidatorProfileName(v);
		return nameValidator;
	}

	/**
	 * Reusable method to return a name validator for renaming a profile.
	 * @param profile the current profile object on updates. Can be null for new profiles. Used
	 * to remove from the existing name list the current connection.
	 * @return the validator
	 */
	public ISystemValidator getProfileNameValidator(ISystemProfile profile) {
		if (profile != null)
			return getProfileNameValidator(profile.getName());
		else
			return getProfileNameValidator((String) null);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.rse.core.model.ISystemProfileManager#getProfiles()
	 */
	public List getProfiles() {
		if (_profiles == null) {
			ISystemProfile profile = new SystemProfile();
			String initProfileName = RSEPreferencesManager.getDefaultPrivateSystemProfileName();
			profile.setName(initProfileName);
			profile.setDefaultPrivate(true);
			_profiles = new ArrayList();
			_profiles.add(profile);
			//profiles = null;//FIXME new EObjectResolvingeList(SystemProfile.class, this, ModelPackage.SYSTEM_PROFILE_MANAGER__PROFILES);
		}
		return _profiles;
	}

}

Lines 18-24 Link Here

(-)UI/org/eclipse/rse/internal/ui/actions/SystemProfileNameSelectAction.java (-2 / +2 lines)
18	import org.eclipse.rse.core.model.ISystemProfile;	18	import org.eclipse.rse.core.model.ISystemProfile;
19	import org.eclipse.rse.core.model.ISystemProfileManager;	19	import org.eclipse.rse.core.model.ISystemProfileManager;
20	import org.eclipse.rse.core.model.ISystemRegistry;	20	import org.eclipse.rse.core.model.ISystemRegistry;
21	import org.eclipse.rse.internal.model.SystemProfileManager;	21	import org.eclipse.rse.internal.core.model.SystemProfileManager;
22	import org.eclipse.rse.ui.RSEUIPlugin;	22	import org.eclipse.rse.ui.RSEUIPlugin;
23	import org.eclipse.rse.ui.actions.SystemBaseAction;	23	import org.eclipse.rse.ui.actions.SystemBaseAction;
24	import org.eclipse.swt.widgets.Shell;	24	import org.eclipse.swt.widgets.Shell;
Lines 38-44 Link Here
38	{	38	{
39	super(profile.getName(),parent);	39	super(profile.getName(),parent);
40	this.profile = profile;	40	this.profile = profile;
41	ISystemProfileManager mgr = SystemProfileManager.getSystemProfileManager();	41	ISystemProfileManager mgr = SystemProfileManager.getDefault();
42	setChecked(mgr.isSystemProfileActive(profile.getName()));	42	setChecked(mgr.isSystemProfileActive(profile.getName()));
43	setSelectionSensitive(false);	43	setSelectionSensitive(false);
44		44




import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.rse.core.model.ISystemProfile;
import org.eclipse.rse.internal.model.SystemProfileManager;
import org.eclipse.rse.internal.ui.SystemResources;
import org.eclipse.rse.services.clientserver.messages.SystemMessage;
import org.eclipse.rse.ui.RSEUIPlugin;

import org.eclipse.rse.ui.dialogs.SystemSimpleContentElement;
import org.eclipse.rse.ui.messages.ISystemMessageLine;
import org.eclipse.rse.ui.validators.ISystemValidator;
import org.eclipse.rse.ui.validators.ValidatorFactory;
import org.eclipse.rse.ui.validators.ValidatorProfileName;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;

		{		
		   setInputObject(profile);
		}
		nameValidator = ValidatorFactory.getProfileNameValidator((String)null);		
		// FIXME cast to SystemProfileManager is temporary to get at api - need to use an adapter for getting validators
		SystemProfileManager mgr = (SystemProfileManager)RSEUIPlugin.getTheSystemRegistry().getSystemProfileManager();
		nameValidator = mgr.getProfileNameValidator((String)null);		
		//pack();
		setHelp(RSEUIPlugin.HELPPREFIX+"drnp0000"); //$NON-NLS-1$
	}




import org.eclipse.jface.viewers.Viewer;
import org.eclipse.rse.core.IRSESystemType;
import org.eclipse.rse.core.IRSEUserIdConstants;
import org.eclipse.rse.core.RSECorePlugin;
import org.eclipse.rse.core.SystemAdapterHelpers;
import org.eclipse.rse.core.SystemBasePlugin;
import org.eclipse.rse.core.filters.ISystemFilter;
import org.eclipse.rse.core.filters.ISystemFilterPool;
import org.eclipse.rse.core.filters.ISystemFilterPoolReferenceManager;
import org.eclipse.rse.core.filters.ISystemFilterReference;
import org.eclipse.rse.core.filters.ISystemFilterStartHere;

import org.eclipse.rse.core.subsystems.ISubSystemConfiguration;
import org.eclipse.rse.core.subsystems.ISubSystemConfigurationProxy;
import org.eclipse.rse.core.subsystems.util.ISubSystemConfigurationAdapter;
import org.eclipse.rse.internal.core.filters.SystemFilterPool;
import org.eclipse.rse.internal.core.filters.SystemFilterStartHere;
import org.eclipse.rse.internal.core.model.SystemProfileManager;
import org.eclipse.rse.internal.model.SystemHostPool;
import org.eclipse.rse.internal.model.SystemModelChangeEvent;
import org.eclipse.rse.internal.model.SystemModelChangeEventManager;
import org.eclipse.rse.internal.model.SystemPostableEventNotifier;
import org.eclipse.rse.internal.model.SystemPreferenceChangeManager;
import org.eclipse.rse.internal.model.SystemProfileManager;
import org.eclipse.rse.internal.model.SystemRemoteChangeEventManager;
import org.eclipse.rse.internal.model.SystemResourceChangeManager;
import org.eclipse.rse.internal.model.SystemScratchpad;

	 */
	public ISystemProfileManager getSystemProfileManager()
	{
		return SystemProfileManager.getDefault();
	}

	/**

	{
		return getSystemProfileManager().getSystemProfileNames();
	}

	/**
	 * Return all defined profile names as a vector
	 */
	public Vector getAllSystemProfileNamesVector()
	{
		Vector v = getSystemProfileManager().getSystemProfileNamesVector();
		return v;
	}

	/**

	public void disconnectAllSubSystems(IHost conn)
	{
		// FIXME - save profile
//		save();
		
		ISubSystem[] subsystems = getSubSystemsLazily(conn);
		if (subsystems == null)

	 */
	public boolean save()
	{
		return RSEUIPlugin.getThePersistenceManager().commitProfiles();
		return RSEUIPlugin.getThePersistenceManager().commit(profileManager);
	}

	/**

	 */
	public boolean saveHostPool(ISystemHostPool pool)
	{
		return pool.commit();
	}

	/**

		return SystemFilterStartHere.getDefault();
	} 
	
	public ISystemFilterPool getSystemFilterPool()
	{
		return SystemFilterPool.getDefault();
	}
	
}//SystemRegistryImpl

Lines 21-27 Link Here

(-)model/org/eclipse/rse/model/SystemStartHere.java (-2 / +2 lines)
21	import org.eclipse.rse.core.model.ISystemRegistry;	21	import org.eclipse.rse.core.model.ISystemRegistry;
22	import org.eclipse.rse.core.subsystems.ISubSystem;	22	import org.eclipse.rse.core.subsystems.ISubSystem;
23	import org.eclipse.rse.core.subsystems.ISubSystemConfiguration;	23	import org.eclipse.rse.core.subsystems.ISubSystemConfiguration;
24	import org.eclipse.rse.internal.model.SystemProfileManager;	24	import org.eclipse.rse.internal.core.model.SystemProfileManager;
25	import org.eclipse.rse.ui.RSEUIPlugin;	25	import org.eclipse.rse.ui.RSEUIPlugin;
26		26
27		27
Lines 161-167 Link Here
161	*/	161	*/
162	public static ISystemProfileManager getSystemProfileManager()	162	public static ISystemProfileManager getSystemProfileManager()
163	{	163	{
164	return SystemProfileManager.getSystemProfileManager();	164	return SystemProfileManager.getDefault();
165	}	165	}
166		166
167	/**	167	/**




import org.eclipse.rse.core.SystemAdapterHelpers;
import org.eclipse.rse.core.filters.ISystemFilterPool;
import org.eclipse.rse.core.filters.ISystemFilterPoolManager;
import org.eclipse.rse.core.filters.ISystemFilterPoolManagerProvider;
import org.eclipse.rse.core.filters.ISystemFilterPoolReference;
import org.eclipse.rse.core.filters.ISystemFilterPoolReferenceManagerProvider;
import org.eclipse.rse.core.subsystems.ISubSystem;

		  	 menu.add(menuGroup, action);
		  }   
		}    	  
		actions = adapter.getFilterPoolReferenceActions(menu, selection, shell, menuGroup, ssFactory, (ISystemFilterPoolReference)element);
		if (actions != null)
		{
		  //menu.addSeparator();

	 */ 	
	public ISubSystem getSubSystem(Object element)
	{
		ISystemFilterPoolReference ref = (ISystemFilterPoolReference)element;
		return (ISubSystem)ref.getProvider();
	}
	
	/**
	 * Returns an image descriptor for the image. More efficient than getting the image.
	 * @param element The element for which an image is desired
	 */
	public ImageDescriptor getImageDescriptor(Object element) {
		ImageDescriptor poolImage = null;
		ISystemFilterPool pool = getFilterPool(element);
		if (pool != null) {
			ISystemFilterPoolManagerProvider provider = pool.getProvider();
			if (provider != null) {
				ISubSystemConfigurationAdapter adapter = (ISubSystemConfigurationAdapter) provider.getAdapter(ISubSystemConfigurationAdapter.class);
				poolImage = adapter.getSystemFilterPoolImage(pool);
			}
		}
		if (poolImage == null) {
			poolImage = RSEUIPlugin.getDefault().getImageDescriptor(ISystemIconConstants.ICON_SYSTEM_FILTERPOOL_ID);
		}
		return poolImage;
	private ISystemFilterPoolReference getFilterPoolReference(Object element)
	{
		return (ISystemFilterPoolReference)element; // get referenced object
	}
	
	private ISystemFilterPool getFilterPool(Object element)
	{
		ISystemFilterPoolReference ref = (ISystemFilterPoolReference)element;
		ISystemFilterPool pool = ref.getReferencedFilterPool();
		return pool; // get master object
	}

	/**

	 * @return the label for this filter pool reference.
	 */
	public String getText(Object element) {
		ISystemFilterPoolReference reference = (ISystemFilterPoolReference) element;
		String result = reference.getName();
		ISystemFilterPool pool = getFilterPool(element);
		if (pool != null) {
			result = pool.getName();
// the following looks like it was copied from the host adapter and not really needed here.
//			boolean qualifyNames = RSEUIPlugin.getTheSystemRegistry().getQualifiedHostNames();
//			if (qualifyNames) {
//				String prefix = SubSystemHelpers.getParentSystemProfile(pool).getName();
//				result =  prefix + "." + result;
//			}
		}
		return result;
	}

	public String getAbsoluteName(Object element)
	{
		//TODO consider caching the absolute name in the FilterPoolReference to avoid unnecessary String operations - the name won't ever change 
		ISystemFilterPoolReference filterPoolRef = (ISystemFilterPoolReference)element;
		ISystemFilterPoolReferenceManagerProvider subSystem = filterPoolRef.getProvider();
		ISystemViewElementAdapter adapter = SystemAdapterHelpers.getViewAdapter(subSystem);
		String parentAbsoluteName = (adapter != null) ?	adapter.getAbsoluteName(subSystem) : ""; //$NON-NLS-1$
		String referenceName = filterPoolRef.getName();
		String managerName = filterPoolRef.getReferencedFilterPoolManagerName();
		String absoluteName = parentAbsoluteName + "." + managerName + "." +  referenceName; //$NON-NLS-1$ //$NON-NLS-2$
		return absoluteName;
	}
	
	/**

	 */
	public Object getParent(Object element)
	{
		ISystemFilterPoolReference fpr = (ISystemFilterPoolReference)element;
		return SubSystemHelpers.getParentSubSystem(fpr);
	}	
	

	 */
	public Object[] getChildren(IProgressMonitor monitor, IAdaptable element)
	{
		ISystemFilterPoolReference fpRef = (ISystemFilterPoolReference)element;
		ISubSystem ss = getSubSystem(element);
		return fpRef.getSystemFilterReferences(ss);
	}

	 */
	public boolean hasChildren(IAdaptable element) {
		int count = 0;
		ISystemFilterPoolReference fpRef = (ISystemFilterPoolReference)element;
		if (fpRef != null) {
			ISystemFilterPool filterPool = fpRef.getReferencedFilterPool();
			if (filterPool != null) {




import org.eclipse.rse.core.model.ISystemRegistry;
import org.eclipse.rse.core.subsystems.ISubSystemConfiguration;
import org.eclipse.rse.core.subsystems.ISubSystemConfigurationProxy;
import org.eclipse.rse.internal.core.model.SystemProfileManager;
import org.eclipse.rse.internal.core.subsystems.SubSystemConfigurationProxy;
import org.eclipse.rse.internal.core.subsystems.SubSystemConfigurationProxyComparator;
import org.eclipse.rse.internal.model.SystemProfileManager;
import org.eclipse.rse.internal.ui.RSESystemTypeAdapterFactory;
import org.eclipse.rse.internal.ui.SystemResources;
import org.eclipse.rse.internal.ui.actions.SystemDynamicPopupMenuExtensionManager;

					if (systemType != null) {
						RSESystemTypeAdapter adapter = (RSESystemTypeAdapter)(systemType.getAdapter(IRSESystemType.class));
						if (adapter != null && adapter.isEnabled(systemType)) {
							ISystemProfileManager profileManager = SystemProfileManager.getDefault();
							ISystemProfile profile = profileManager.getDefaultPrivateSystemProfile();
							String userName = System.getProperty("user.name"); //$NON-NLS-1$
							registry.createLocalHost(profile, SystemResources.TERM_LOCAL, userName);

	 */
	public static ISystemProfileManager getTheSystemProfileManager()
	{
		return SystemProfileManager.getDefault();
	}

    /**




package org.eclipse.rse.ui.validators;

import java.util.Vector;

import org.eclipse.rse.core.RSECorePlugin;
import org.eclipse.rse.core.model.ISystemProfileManager;

/**
 * This class constructs validators for various bits of the user interface.
 */
public class ValidatorFactory {

	/**
	 * Reusable method to return a name validator for renaming a profile.
	 * @param profileName the current profile name on updates. Can be null for new profiles. Used
	 * to remove from the existing name list the current connection.
	 * @return the validator
	 */
	public static ISystemValidator getProfileNameValidator(String profileName) {
		ISystemProfileManager manager = RSECorePlugin.getDefault().getSystemRegistry().getSystemProfileManager();
		Vector profileNames = manager.getSystemProfileNamesVector();
		if (profileName != null) profileNames.remove(profileName);
		ISystemValidator nameValidator = new ValidatorProfileName(profileNames);
		return nameValidator;
	}

}

Return to bug 170932

Lines 274-290 Link Here

(-)src/org/eclipse/rse/core/SystemResourceManager.java (-14 lines)
274	}	274	}
275	*/	275	*/
276		276
277	// -----------------------------------
278	// GET A SPECIFIC PROFILE FOLDER...
279	// -----------------------------------
280	/**
281	* Get profiles folder for a given profile
282	*/
283	public static IFolder getProfileFolder(ISystemProfile profile)
284	{
285	return getProfileFolder(profile.getName());
286	}
287
288	/**	277	/**
289	* Get profiles folder for a given profile name	278	* Get profiles folder for a given profile name
290	*/	279	*/
Lines 293-301 Link Here
293	return getResourceHelpers().getOrCreateFolder(getRemoteSystemsProject(),profileName);	282	return getResourceHelpers().getOrCreateFolder(getRemoteSystemsProject(),profileName);
294	}	283	}
295		284
296
297
298
299	/*	285	/*
300	* --------------------------------------------------------------------------------------------------------------------------------	286	* --------------------------------------------------------------------------------------------------------------------------------
301	* USER ACTIONS SUBTREE FOLDER METHODS...	287	* USER ACTIONS SUBTREE FOLDER METHODS...

Lines 34-39 Link Here

(-)model/org/eclipse/rse/internal/model/SystemHostPool.java (-3 / +6 lines)
34	import org.eclipse.rse.core.model.ISystemProfile;	34	import org.eclipse.rse.core.model.ISystemProfile;
35	import org.eclipse.rse.core.model.RSEModelObject;	35	import org.eclipse.rse.core.model.RSEModelObject;
36	import org.eclipse.rse.internal.core.model.RSEModelResources;	36	import org.eclipse.rse.internal.core.model.RSEModelResources;
		37	import org.eclipse.rse.internal.core.model.SystemProfileManager;
37	import org.eclipse.rse.ui.RSESystemTypeAdapter;	38	import org.eclipse.rse.ui.RSESystemTypeAdapter;
38		39
39		40
Lines 102-108 Link Here
102	*/	103	*/
103	public ISystemProfile getSystemProfile()	104	public ISystemProfile getSystemProfile()
104	{	105	{
105	return SystemProfileManager.getSystemProfileManager().getSystemProfile(getName());	106	return SystemProfileManager.getDefault().getSystemProfile(getName());
106	}	107	}
107		108
108	/**	109	/**
Lines 408-414 Link Here
408	conn.deletingHost(); // let connection do any necessary cleanup	409	conn.deletingHost(); // let connection do any necessary cleanup
409	getHostList().remove(conn);	410	getHostList().remove(conn);
410	setDirty(true);	411	setDirty(true);
411	RSECorePlugin.getThePersistenceManager().commit(conn.getSystemProfile());	412	conn.getSystemProfile().commit();
412	}	413	}
413		414
414	/**	415	/**
Lines 648-654 Link Here
648	*/	649	*/
649	public boolean commit()	650	public boolean commit()
650	{	651	{
651	return RSECorePlugin.getThePersistenceManager().commit(this);	652	ISystemProfile profile = getSystemProfile();
		653	boolean result = profile.commit();
		654	return result;
652	}	655	}
653		656
654	/**	657	/**

Lines 256-358 Link Here

(-)src/org/eclipse/rse/internal/core/filters/SystemFilterPool.java (-89 / +8 lines)
256	* @generated This field/method will be replaced during code generation.	256	* @generated This field/method will be replaced during code generation.
257	*/	257	*/
258	protected java.util.List filters = null;	258	protected java.util.List filters = null;
259	private static SystemFilterPool _instance;	259
260	/**	260	/**
261	* Default constructor	261	* Default constructor
262	*/	262	*/
263	protected SystemFilterPool()	263	public SystemFilterPool(String poolName, boolean allowNestedFilters, boolean isDeletable)
264	{	264	{
265	super();	265	super();
266	helpers = new SystemFilterContainerCommonMethods();	266	helpers = new SystemFilterContainerCommonMethods();
267	}	267	setRelease(RSECorePlugin.CURRENT_RELEASE);
268		268	if (!initialized) {
269	public static SystemFilterPool getDefault()	269	initialize(poolName, savePolicy, namingPolicy);
270	{
271	if (_instance == null)
272	{
273	_instance = new SystemFilterPool();
274	}	270	}
275	return _instance;
276	}
277
278	/**
279	* Static factory method for creating a new filter pool. Will
280	* first try to restore it, and if that fails will create a new instance and
281	* return it.
282	* <p>
283	* Use this method only if you are not using a SystemFilterPoolManager, else
284	* use the createSystemFilterPool method in that class.
285	*
286	* This folder will be created if it does not already exist.
287	* @param name the name of the filter pool. Typically this is also the name
288	* of the given folder, but this is not required. For the save policy of one file
289	* per pool, the name of the file is derived from this.
290	* @param allowNestedFilters true if filters inside this filter pool are
291	* to allow nested filters.
292	* @param isDeletable true if this filter pool is allowed to be deleted by users.
293	* @param tryToRestore true to attempt a restore first, false if a pure create operation.
294	*/
295	public ISystemFilterPool createSystemFilterPool(
296	String name,
297	boolean allowNestedFilters,
298	boolean isDeletable,
299	boolean tryToRestore)
300	{
301
302
303	SystemFilterPool pool = null;
304	if (tryToRestore)
305	{
306	try
307	{
308	pool = (SystemFilterPool)RSECorePlugin.getThePersistenceManager().restoreFilterPool(name);
309	}
310	catch (Exception exc) // real error trying to restore, versus simply not found.
311	{
312	// todo: something? Log the exception somewhere?
313	}
314	}
315	if (pool == null) // not found or some serious error.
316	{
317	pool = createPool();
318	}
319	if (pool != null)
320	{
321	pool.initialize(name, allowNestedFilters, isDeletable);
322	}
323	return pool;
324	}
325
326	// temporary!
327	//public boolean isSharable() {return isSharable; }
328	//public void setIsSharable(boolean is) { isSharable = is; }
329
330	/*
331	* Private helper method.
332	* Uses MOF to create an instance of this class.
333	*/
334	protected static SystemFilterPool createPool()
335	{
336	ISystemFilterPool pool = new SystemFilterPool();
337	// FIXME SystemFilterImpl.initMOF().createSystemFilterPool();
338	pool.setRelease(RSECorePlugin.CURRENT_RELEASE);
339	return (SystemFilterPool)pool;
340	}
341
342	/*
343	* Private helper method to initialize attributes
344	*/
345	protected void initialize(String name,
346	boolean allowNestedFilters,
347	boolean isDeletable)
348	{
349	if (!initialized)
350	initialize(name, savePolicy, namingPolicy);
351	setDeletable(isDeletable); // mof attribute	271	setDeletable(isDeletable); // mof attribute
352	//System.out.println("In initialize() for filter pool " + getName() + ". isDeletable= " + isDeletable);
353	setSupportsNestedFilters(allowNestedFilters); // cascades to each filter	272	setSupportsNestedFilters(allowNestedFilters); // cascades to each filter
354	}	273	}
355		274
356	/*	275	/*
357	* Private helper method to core initialization, from either createXXX or restore.	276	* Private helper method to core initialization, from either createXXX or restore.
358	*/	277	*/

Lines 1-11 Link Here

(-)src/org/eclipse/rse/core/model/RSEPersistableObject.java (-29 / +9 lines)
1	package org.eclipse.rse.core.model;	1	package org.eclipse.rse.core.model;
2		2
		3
3	public abstract class RSEPersistableObject implements IRSEPersistableContainer {	4	public abstract class RSEPersistableObject implements IRSEPersistableContainer {
4		5
5	private boolean _isDirty = false;	6	private boolean _isDirty = false;
6	private boolean _wasRestored = false;	7	private boolean _wasRestored = false;
7	private boolean _isTainted = false;	8	private boolean _isTainted = false;
8	private boolean _restoring = false;
9		9
10	public RSEPersistableObject() {	10	public RSEPersistableObject() {
11	super();	11	super();
Lines 16-36 Link Here
16	}	16	}
17		17
18	public final void setDirty(boolean flag) {	18	public final void setDirty(boolean flag) {
19	if (!_restoring) {	19	_isDirty = flag;
20	_isDirty = flag;	20	setTainted(flag);
21	if (flag) {
22	setTainted(true);
23	}
24	}
25	}
26
27	public final void beginRestore() {
28	_restoring = true;
29	}
30
31	public final void endRestore() {
32	_restoring = false;
33	setWasRestored(true);
34	}	21	}
35		22
36	public final boolean wasRestored() {	23	public final boolean wasRestored() {
Lines 46-64 Link Here
46	}	33	}
47		34
48	public final void setTainted(boolean flag) {	35	public final void setTainted(boolean flag) {
49	if (!_restoring) {	36	boolean taintParent = flag && !_isTainted;
50	_isTainted = flag;	37	_isTainted = flag;
51	if (_isTainted) {	38	if (taintParent) {
52	IRSEPersistableContainer parent = getPersistableParent();	39	IRSEPersistableContainer parent = getPersistableParent();
53	if (parent != null) {	40	if (parent != null) {
54	parent.setTainted(true);	41	parent.setTainted(true);
55	}
56	} else {
57	IRSEPersistableContainer[] children = getPersistableChildren();
58	for (int i = 0; i < children.length; i++) {
59	IRSEPersistableContainer child = children[i];
60	child.setTainted(false);
61	}
62	}	42	}
63	}	43	}
64	}	44	}

Lines 49-70 Link Here

(-)src/org/eclipse/rse/core/model/IRSEPersistableContainer.java (-18 / +2 lines)
49	* @param flag true if the object was restored.	49	* @param flag true if the object was restored.
50	*/	50	*/
51	public void setWasRestored(boolean flag);	51	public void setWasRestored(boolean flag);
52		52
53	/**
54	* Notifies the object that it is being restored. Typically this will
55	* suppress any marking of the object as dirty and related objects as
56	* tainted while the restore is taking place. Should be used only by
57	* persistence providers.
58	*/
59	public void beginRestore();
60
61	/**
62	* Notifies the object that it is has been restored. This will
63	* enable the object to be marked as dirty if subsequent changes
64	* are made to it. Should be used only by persistence providers.
65	*/
66	public void endRestore();
67
68	/**	53	/**
69	* An object is dirty if a change has been made to it that requires	54	* An object is dirty if a change has been made to it that requires
70	* it to be persisted.	55	* it to be persisted.
Lines 106-113 Link Here
106	* Sets the tainted attribute for this object. This should set to	91	* Sets the tainted attribute for this object. This should set to
107	* true only by child objects when they have been marked dirty or tainted.	92	* true only by child objects when they have been marked dirty or tainted.
108	* Setting this to true will cause all parent objects in the containment	93	* Setting this to true will cause all parent objects in the containment
109	* hierarchy to be marked tainted. Setting this to false will cause all	94	* hierarchy to be marked tainted.
110	* children to be marked as not tainted.
111	* It should be set to false only by a persistence manager when the	95	* It should be set to false only by a persistence manager when the
112	* object has been committed.	96	* object has been committed.
113	* @param flag the tainted state of the object.	97	* @param flag the tainted state of the object.

Lines 18-23 Link Here

(-)src/org/eclipse/rse/core/filters/SystemFilterPoolManager.java (-96 / +48 lines)
18		18
19	import java.util.ArrayList;	19	import java.util.ArrayList;
20	import java.util.Iterator;	20	import java.util.Iterator;
		21	import java.util.List;
21	import java.util.Vector;	22	import java.util.Vector;
22		23
23	import org.eclipse.core.resources.IFile;	24	import org.eclipse.core.resources.IFile;
Lines 25-39 Link Here
25	import org.eclipse.rse.core.RSECorePlugin;	26	import org.eclipse.rse.core.RSECorePlugin;
26	import org.eclipse.rse.core.model.IRSEPersistableContainer;	27	import org.eclipse.rse.core.model.IRSEPersistableContainer;
27	import org.eclipse.rse.core.model.ISystemProfile;	28	import org.eclipse.rse.core.model.ISystemProfile;
28	import org.eclipse.rse.core.model.ISystemRegistry;
29	import org.eclipse.rse.core.model.RSEPersistableObject;	29	import org.eclipse.rse.core.model.RSEPersistableObject;
30	import org.eclipse.rse.core.references.IRSEBaseReferencingObject;	30	import org.eclipse.rse.core.references.IRSEBaseReferencingObject;
31	import org.eclipse.rse.internal.core.filters.ISystemFilterConstants;	31	import org.eclipse.rse.internal.core.filters.ISystemFilterConstants;
		32	import org.eclipse.rse.internal.core.filters.SystemFilterPool;
32	import org.eclipse.rse.logging.Logger;	33	import org.eclipse.rse.logging.Logger;
33	import org.eclipse.rse.persistence.IRSEPersistenceManager;
34
35	//
36	//
37		34
38	/**	35	/**
39	* A filter pool manager manages filter pools.	36	* A filter pool manager manages filter pools.
Lines 190-199 Link Here
190	*/	187	*/
191	protected boolean singleFilterStringOnly = SINGLE_FILTER_STRING_ONLY_EDEFAULT;	188	protected boolean singleFilterStringOnly = SINGLE_FILTER_STRING_ONLY_EDEFAULT;
192		189
193	/**	190	protected List pools = null;
194	* @generated This field/method will be replaced during code generation.
195	*/
196	protected java.util.List pools = null;
197		191
198	/**	192	/**
199	* Constructor	193	* Constructor
Lines 224-230 Link Here
224	* individual filter pool level.	218	* individual filter pool level.
225	* @param savePolicy The save policy for the filter pools and filters. One of the	219	* @param savePolicy The save policy for the filter pools and filters. One of the
226	* following constants from the	220	* following constants from the
227	* {@link org.eclipse.rse.internal.core.filters.ISystemFilterConstants SystemFilterConstants} interface:	221	* {@link ISystemFilterConstants} interface:
228	* <ul>	222	* <ul>
229	* <li>SAVE_POLICY_NONE - no files, all save/restore handled elsewhere	223	* <li>SAVE_POLICY_NONE - no files, all save/restore handled elsewhere
230	* <li>SAVE_POLICY_ONE_FILE_PER_MANAGER - one file: mgrName.xmi	224	* <li>SAVE_POLICY_ONE_FILE_PER_MANAGER - one file: mgrName.xmi
Lines 238-263 Link Here
238	public static ISystemFilterPoolManager createSystemFilterPoolManager(ISystemProfile profile, Logger logger,	232	public static ISystemFilterPoolManager createSystemFilterPoolManager(ISystemProfile profile, Logger logger,
239	ISystemFilterPoolManagerProvider caller, String name, boolean allowNestedFilters,	233	ISystemFilterPoolManagerProvider caller, String name, boolean allowNestedFilters,
240	int savePolicy, IRSEFilterNamingPolicy namingPolicy) {	234	int savePolicy, IRSEFilterNamingPolicy namingPolicy) {
241		235	SystemFilterPoolManager mgr = SystemFilterPoolManager.createManager(profile);
242	SystemFilterPoolManager mgr = null;	236	mgr.initialize(logger, caller, name, allowNestedFilters);
243	if (namingPolicy == null) namingPolicy = SystemFilterNamingPolicy.getNamingPolicy();
244	try {
245	mgr = (SystemFilterPoolManager) RSECorePlugin.getThePersistenceManager().restoreFilterPoolManager(profile, logger, caller, name);
246	/*
247	if (savePolicy != SystemFilterConstants.SAVE_POLICY_NONE)
248	mgr = (SystemFilterPoolManagerImpl)restore(;
249	*/
250	} catch (Exception exc) // real error trying to restore, versus simply not found.
251	{
252	// todo: something. Log the exception somewhere?
253	}
254	if (mgr == null) // not found or some serious error.
255	{
256	mgr = createManager(profile);
257	}
258	if (mgr != null) {
259	mgr.initialize(logger, caller, name, allowNestedFilters);
260	}
261	return mgr;	237	return mgr;
262	}	238	}
263		239
Lines 276-305 Link Here
276	* Private helper method to initialize state	252	* Private helper method to initialize state
277	*/	253	*/
278	public void initialize(Logger logger, ISystemFilterPoolManagerProvider caller, String name, boolean allowNestedFilters) {	254	public void initialize(Logger logger, ISystemFilterPoolManagerProvider caller, String name, boolean allowNestedFilters) {
279	if (!initialized) initialize(logger, caller, name); // core data	255	if (!initialized) {
280		256	initialize(logger, caller, name); // core data
281	{
282	java.util.List pools = getPools();
283	ISystemFilterPool pool = null;
284	Vector poolNames = getSystemFilterPoolNamesVector();
285	for (int idx = 0; idx < poolNames.size(); idx++) {
286	String poolName = (String) poolNames.elementAt(idx);
287	pool = RSECorePlugin.getThePersistenceManager().restoreFilterPool(poolName);
288	pool.setSystemFilterPoolManager(this);
289	pools.add(pool);
290
291	/** FIXME test
292	if (pool.specialCaseNoDataRestored)
293	{
294	pool.setDeletable(true); // what else to do?
295	//pool.setSupportsNestedFilters(allowNestedFilters); will be cascaded down anyway
296	}
297	*/
298	}
299
300	}	257	}
301	setSupportsNestedFilters(allowNestedFilters); // cascade it down	258	setSupportsNestedFilters(allowNestedFilters); // cascade it down
302	invalidatePoolCache();	259	invalidatePoolCache();
		260	// List pools = getPools();
		261	// ISystemFilterPool pool = null;
		262	// Vector poolNames = getSystemFilterPoolNamesVector();
		263	// for (int idx = 0; idx < poolNames.size(); idx++) {
		264	// String poolName = (String) poolNames.elementAt(idx);
		265	//// pool = RSECorePlugin.getThePersistenceManager().restoreFilterPool(poolName);
		266	// pool = null; // that's what the above returned
		267	// pool.setSystemFilterPoolManager(this);
		268	// pools.add(pool);
		269	//
		270	// /** FIXME test
		271	// if (pool.specialCaseNoDataRestored)
		272	// {
		273	// pool.setDeletable(true); // what else to do?
		274	// //pool.setSupportsNestedFilters(allowNestedFilters); will be cascaded down anyway
		275	// }
		276	// */
		277	// }
303	}	278	}
304		279
305	/*	280	/*
Lines 309-315 Link Here
309	public void initialize(Logger logger, ISystemFilterPoolManagerProvider caller, String name) {	284	public void initialize(Logger logger, ISystemFilterPoolManagerProvider caller, String name) {
310	this.logger = logger;	285	this.logger = logger;
311	setProvider(caller);	286	setProvider(caller);
312	setNameGen(name);	287	setName(name);
313	setFilterPoolManager(); // cascade it down	288	setFilterPoolManager(); // cascade it down
314	initialized = true;	289	initialized = true;
315	}	290	}
Lines 331-344 Link Here
331		306
332	/**	307	/**
333	* Set the name of this manager.	308	* Set the name of this manager.
334	* Intercepted so the file get be renamed for SAVE_POLICY_ONE_FILE_PER_MANAGER.
335	*/	309	*/
336	public void setName(String name) {	310	public void setName(String newName) {
337	String oldName = getName();	311	if ((name == null && newName != null) \|\| !name.equals(newName)) {
338	if (oldName != null) {	312	this.name = newName;
339	if (!oldName.equals(name)) {	313	setDirty(true);
340	this.name = name;
341	}
342	}	314	}
343	}	315	}
344		316
Lines 473-479 Link Here
473	public ISystemFilterPool[] getSystemFilterPools() {	445	public ISystemFilterPool[] getSystemFilterPools() {
474	//System.out.println("Inside getSFPools for mgr "+getName()+". poolArray null? "+(poolArray==null));	446	//System.out.println("Inside getSFPools for mgr "+getName()+". poolArray null? "+(poolArray==null));
475	if ((poolArray == null) \|\| (getPools().size() != poolArray.length)) {	447	if ((poolArray == null) \|\| (getPools().size() != poolArray.length)) {
476	java.util.List pools = getPools();	448	List pools = getPools();
477	poolArray = new ISystemFilterPool[pools.size()];	449	poolArray = new ISystemFilterPool[pools.size()];
478	Iterator i = pools.iterator();	450	Iterator i = pools.iterator();
479	int idx = 0;	451	int idx = 0;
Lines 499-505 Link Here
499	* Get list of filter pool names currently existing.	471	* Get list of filter pool names currently existing.
500	*/	472	*/
501	public Vector getSystemFilterPoolNamesVector() {	473	public Vector getSystemFilterPoolNamesVector() {
502	java.util.List pools = getPools();	474	List pools = getPools();
503	if ((poolNames == null) \|\| (poolNames.size() != pools.size())) // been invalidated?	475	if ((poolNames == null) \|\| (poolNames.size() != pools.size())) // been invalidated?
504	{	476	{
505	poolNames = new Vector();	477	poolNames = new Vector();
Lines 540-569 Link Here
540	* Calls back to inform provider of this event	512	* Calls back to inform provider of this event
541	*/	513	*/
542	public ISystemFilterPool createSystemFilterPool(String poolName, boolean isDeletable) throws Exception {	514	public ISystemFilterPool createSystemFilterPool(String poolName, boolean isDeletable) throws Exception {
543	// always trim the pool name, MOF does not handle trailing or preceding spaces
544	poolName = poolName.trim();
545
546	if (getSystemFilterPool(poolName) != null) return null;
547
548	ISystemFilterPool pool = null;	515	ISystemFilterPool pool = null;
549		516	poolName = poolName.trim();
550	ISystemRegistry registry = RSECorePlugin.getDefault().getSystemRegistry();	517	if (getSystemFilterPool(poolName) == null) {
551	ISystemFilterPool filterPool = registry.getSystemFilterPool();	518	pool = new SystemFilterPool(poolName, supportsNestedFilters(), isDeletable);
552	pool = filterPool.createSystemFilterPool(poolName, supportsNestedFilters(), isDeletable, ISystemFilterConstants.TRY_TO_RESTORE_NO);
553
554	if (pool != null) {
555	pool.setSystemFilterPoolManager(this);	519	pool.setSystemFilterPoolManager(this);
556	pool.setStringsCaseSensitive(areStringsCaseSensitive());	520	pool.setStringsCaseSensitive(areStringsCaseSensitive());
557	if (isSetSupportsDuplicateFilterStrings()) pool.setSupportsDuplicateFilterStrings(supportsDuplicateFilterStrings());	521	pool.setSupportsDuplicateFilterStrings(isSetSupportsDuplicateFilterStrings() && supportsDuplicateFilterStrings());
558	// add to model	522	List pools = getPools();
559	java.util.List pools = getPools();
560	pools.add(pool);	523	pools.add(pool);
561	//System.out.println("Inside createSFPool for mgr "+getName()+". Pool "+name+" added");
562	invalidatePoolCache();	524	invalidatePoolCache();
563	// save to disk...
564	commit(pool);	525	commit(pool);
565	// if caller provider, callback to inform them of this event	526	if ((caller != null) && !suspendCallbacks) {
566	if ((caller != null) && !suspendCallbacks) caller.filterEventFilterPoolCreated(pool);	527	caller.filterEventFilterPoolCreated(pool);
		528	}
567	}	529	}
568	return pool;	530	return pool;
569	}	531	}
Lines 601-608 Link Here
601	// DWD removing a pool should mark its parent profile as dirty and cause a save to be "scheduled"	563	// DWD removing a pool should mark its parent profile as dirty and cause a save to be "scheduled"
602		564
603	// remove from model	565	// remove from model
604	java.util.List pools = getPools();	566	List pools = getPools();
605	pools.remove(pool);	567	pools.remove(pool);
		568	invalidatePoolCache();
606		569
607	/* FIXME	570	/* FIXME
608	// now in EMF, the pools are "owned" by the Resource, and only referenced by this pool manager,	571	// now in EMF, the pools are "owned" by the Resource, and only referenced by this pool manager,
Lines 1530-1536 Link Here
1530	/* FIXME	1493	/* FIXME
1531	String fileName = getRootSaveFileName(namingPolicy, name);	1494	String fileName = getRootSaveFileName(namingPolicy, name);
1532		1495
1533	java.util.List ext = getMOFHelpers(logger).restore(mgrFolder,fileName);	1496	List ext = getMOFHelpers(logger).restore(mgrFolder,fileName);
1534		1497
1535	SystemFilterPoolManager mgr = null;	1498	SystemFilterPoolManager mgr = null;
1536		1499
Lines 1652-1661 Link Here
1652	/**	1615	/**
1653	* @generated This field/method will be replaced during code generation	1616	* @generated This field/method will be replaced during code generation
1654	*/	1617	*/
1655	public java.util.List getPools() {	1618	public List getPools() {
1656	if (pools == null) {	1619	if (pools == null) {
1657	pools = new ArrayList();	1620	pools = new ArrayList();
1658	//FIXME new EObjectResolvingeList(SystemFilterPool.class, this, FiltersPackage.SYSTEM_FILTER_POOL_MANAGER__POOLS);
1659	}	1621	}
1660	return pools;	1622	return pools;
1661	}	1623	}
Lines 1663-1679 Link Here
1663	/**	1625	/**
1664	* @generated This field/method will be replaced during code generation.	1626	* @generated This field/method will be replaced during code generation.
1665	*/	1627	*/
1666	public void setNameGen(String newName) {
1667	String oldName = name;
1668	if (oldName != newName) {
1669	name = newName;
1670	setDirty(true);
1671	}
1672	}
1673
1674	/**
1675	* @generated This field/method will be replaced during code generation.
1676	*/
1677	public void setSupportsNestedFiltersGen(boolean newSupportsNestedFilters) {	1628	public void setSupportsNestedFiltersGen(boolean newSupportsNestedFilters) {
1678	supportsNestedFilters = newSupportsNestedFilters;	1629	supportsNestedFilters = newSupportsNestedFilters;
1679	}	1630	}
Lines 1727-1734 Link Here
1727	* Uses the save policy specified in this manager's factory method.	1678	* Uses the save policy specified in this manager's factory method.
1728	*/	1679	*/
1729	public boolean commit() {	1680	public boolean commit() {
1730	IRSEPersistenceManager mgr = RSECorePlugin.getThePersistenceManager();	1681	ISystemProfile profile = getSystemProfile();
1731	return mgr.commit(this);	1682	boolean result = profile.commit();
		1683	return result;
1732	}	1684	}
1733		1685
1734	/**	1686	/**

Lines 21-30 Link Here

(-)src/org/eclipse/rse/persistence/dom/RSEDOMNode.java (-4 / +10 lines)
21	import java.util.List;	21	import java.util.List;
22		22
23	public class RSEDOMNode implements Serializable {	23	public class RSEDOMNode implements Serializable {
24	/*	24
25	* Recommended for serializable objects. This should be updated if there is a schema change.	25	private static final long serialVersionUID = 1L; // This should be updated if there is a schema change.
26	*/
27	private static final long serialVersionUID = 1L;
28	protected String _type;	26	protected String _type;
29	protected String _name;	27	protected String _name;
30	protected RSEDOMNode _parent;	28	protected RSEDOMNode _parent;
Lines 219-223 Link Here
219	public void setRestoring(boolean restoring) {	217	public void setRestoring(boolean restoring) {
220	this.restoring = restoring;	218	this.restoring = restoring;
221	}	219	}
		220
		221	public void setName(String name) {
		222	_name = name;
		223	}
		224
		225	public void setType(String type) {
		226	_type = type;
		227	}
222		228
223	}	229	}

Lines 31-37 Link Here

(-)src/org/eclipse/rse/internal/persistence/dom/RSEDOMExporter.java (-11 / +4 lines)
31	import org.eclipse.rse.core.model.IPropertyType;	31	import org.eclipse.rse.core.model.IPropertyType;
32	import org.eclipse.rse.core.model.IRSEModelObject;	32	import org.eclipse.rse.core.model.IRSEModelObject;
33	import org.eclipse.rse.core.model.ISystemProfile;	33	import org.eclipse.rse.core.model.ISystemProfile;
34	import org.eclipse.rse.core.model.ISystemRegistry;
35	import org.eclipse.rse.core.subsystems.IConnectorService;	34	import org.eclipse.rse.core.subsystems.IConnectorService;
36	import org.eclipse.rse.core.subsystems.IDelegatingConnectorService;	35	import org.eclipse.rse.core.subsystems.IDelegatingConnectorService;
37	import org.eclipse.rse.core.subsystems.IServerLauncherProperties;	36	import org.eclipse.rse.core.subsystems.IServerLauncherProperties;
Lines 41-51 Link Here
41	import org.eclipse.rse.persistence.dom.RSEDOMNode;	40	import org.eclipse.rse.persistence.dom.RSEDOMNode;
42		41
43	public class RSEDOMExporter implements IRSEDOMExporter {	42	public class RSEDOMExporter implements IRSEDOMExporter {
		43
44	private static RSEDOMExporter _instance = new RSEDOMExporter();	44	private static RSEDOMExporter _instance = new RSEDOMExporter();
45	private Map _domMap;	45	private Map _domMap;
46		46
47	// private ISystemRegistry _registry;
48
49	/**	47	/**
50	* Constructor to create a new DOM exporter.	48	* Constructor to create a new DOM exporter.
51	*/	49	*/
Lines 53-62 Link Here
53	_domMap = new HashMap();	51	_domMap = new HashMap();
54	}	52	}
55		53
56	public void setSystemRegistry(ISystemRegistry registry) {
57	// _registry = registry;
58	}
59
60	/**	54	/**
61	* @return the singleton instance of this exporter	55	* @return the singleton instance of this exporter
62	*/	56	*/
Lines 401-413 Link Here
401	*/	395	*/
402	public RSEDOMNode createNode(RSEDOMNode parent, ISystemFilterPoolReference filterPoolReference, boolean clean) {	396	public RSEDOMNode createNode(RSEDOMNode parent, ISystemFilterPoolReference filterPoolReference, boolean clean) {
403	RSEDOMNode node = findOrCreateNode(parent, IRSEDOMConstants.TYPE_FILTER_POOL_REFERENCE, filterPoolReference, clean);	397	RSEDOMNode node = findOrCreateNode(parent, IRSEDOMConstants.TYPE_FILTER_POOL_REFERENCE, filterPoolReference, clean);
404		398	String name = filterPoolReference.getFullName();
		399	node.setName(name); // filter pool references must write out the fully qualified name of their referenced filter pool
405	if (clean \|\| node.isDirty()) {	400	if (clean \|\| node.isDirty()) {
406	ISystemFilterPool filterPool = filterPoolReference.getReferencedFilterPool();	401	ISystemFilterPool filterPool = filterPoolReference.getReferencedFilterPool();
407	String refId = (filterPool != null) ? filterPool.getId() : "unknown"; //$NON-NLS-1$	402	String refId = (filterPool != null) ? filterPool.getId() : "unknown"; //$NON-NLS-1$
408	node.addAttribute(IRSEDOMConstants.ATTRIBUTE_REF_ID, refId);	403	node.addAttribute(IRSEDOMConstants.ATTRIBUTE_REF_ID, refId);
409	}	404	}
410
411	createPropertySetNodes(node, filterPoolReference, clean);	405	createPropertySetNodes(node, filterPoolReference, clean);
412	node.setDirty(false);	406	node.setDirty(false);
413	return node;	407	return node;
Lines 430-437 Link Here
430	node.setDirty(true);	424	node.setDirty(true);
431	}	425	}
432	}	426	}
433	boolean newNode = (node == null);	427	if (node == null) {
434	if (newNode) {
435	node = new RSEDOMNode(parent, type, name);	428	node = new RSEDOMNode(parent, type, name);
436	}	429	}
437	return node;	430	return node;

Lines 16-99 Link Here

(-)src/org/eclipse/rse/persistence/IRSEPersistenceManager.java (-43 / +48 lines)
16		16
17	package org.eclipse.rse.persistence;	17	package org.eclipse.rse.persistence;
18		18
19	import org.eclipse.rse.core.filters.ISystemFilterPool;
20	import org.eclipse.rse.core.filters.ISystemFilterPoolManager;
21	import org.eclipse.rse.core.filters.ISystemFilterPoolManagerProvider;
22	import org.eclipse.rse.core.model.ISystemHostPool;
23	import org.eclipse.rse.core.model.ISystemProfile;	19	import org.eclipse.rse.core.model.ISystemProfile;
24	import org.eclipse.rse.core.model.ISystemProfileManager;
25	import org.eclipse.rse.logging.Logger;
26		20
27	public interface IRSEPersistenceManager {	21	public interface IRSEPersistenceManager {
28		22
29	public boolean commit(ISystemFilterPoolManager filterPoolManager);
30
31	/**	23	/**
32	* Save all connections in the connection pool	24	* Save a particular profile. If the profile has an existing persistence provider
33	* @param connectionPool	25	* it is saved by that persistence provider. If the profile has no persistence provider
		26	* then the default persistence provider is used.
		27	* @param profile the profile to save
34	* @return true if successful	28	* @return true if successful
35	*/	29	*/
36	public boolean commit(ISystemHostPool connectionPool);	30	public boolean commitProfile(ISystemProfile profile);
37		31
38	/**	32	/**
39	* Save this profile	33	* Save all profiles.
40	* @param profile
41	* @return true if successful	34	* @return true if successful
42	*/	35	*/
43	public boolean commit(ISystemProfile profile);	36	public boolean commitProfiles();
44		37
45	/**	38	/**
46	* Save all profiles	39	* Restore all profiles
47	* @param profileManager	40	* @return an array of restored profiles.
48	* @return true if successful	41	*/
		42	public ISystemProfile[] restoreProfiles();
		43
		44	/**
		45	* Restore a profiles particular provider by name.
		46	* @param provider a persistence provider
		47	* @param profileName the name of the profile to restore
		48	* @return the restored profile or null if no profile of that name is known to this provider.
49	*/	49	*/
50	public boolean commit(ISystemProfileManager profileManager);	50	public ISystemProfile restoreProfile(IRSEPersistenceProvider provider, String profileName);
51		51
52	/**	52	/**
53	* Delete the persistent form of a profile.	53	* Delete the persistent form of a profile.
		54	* @param persistenceProvider the persistence provider to use to delete the profile.
		55	* If this is null the default persistence provider is used.
54	* @param profileName The name of the profile to delete	56	* @param profileName The name of the profile to delete
55	*/	57	*/
56	public void deleteProfile(String profileName);	58	public void deleteProfile(IRSEPersistenceProvider persistenceProvider, String profileName);
57		59
58	public boolean isExporting();	60	/**
59		61	* Migrates a profile to a new persistence provider. It will delete the persistent form known to its previous
60	public boolean isImporting();	62	* persistence provider. If the new provider and the previous provider are the same this does nothing.
		63	* @param profile the system profile to be migrated
		64	* @param persistenceProvider the persistence provider to which this profile will be migrated.
		65	*/
		66	public void migrateProfile(ISystemProfile profile, IRSEPersistenceProvider persistenceProvider);
61		67
62	/**	68	/**
63	* Register the persistence provider to be used when saving and restoring RSE doms.	69	* Register the persistence provider to be used when saving and restoring RSE doms.
64	* The provider is registered under the provided id.	70	* The provider is registered under the provided id.
		71	* If the id has already been registered, this provider replaces the previous provider
		72	* with that id.
65	* @param id the provider id.	73	* @param id the provider id.
66	* @param provider the provider.	74	* @param provider the provider.
67	*/	75	*/
68	public void registerRSEPersistenceProvider(String id, IRSEPersistenceProvider provider);	76	public void registerPersistenceProvider(String id, IRSEPersistenceProvider provider);
69		77
70	/**	78	/**
71	* Restore all the filters for the filter pool	79	* @return an array of persistence provider ids known to this workbench. These may have been
72	* @param filterPool	80	* provided by extension point or by registering them using
73	* @return true if sucessful	81	* {@link #registerPersistenceProvider(String, IRSEPersistenceProvider)}
74	*/	82	*/
75	public boolean restore(ISystemFilterPool filterPool);	83	public String[] getPersistenceProviderIds();
76		84
77	/**	85	/**
78	* Restore all connections in the connection pool	86	* Retrieves the persistence provider named by a particular id. It can return null if there
79	* @param connectionPool	87	* is no provider known by that id. This may have the effect of activating the plugin that
80	* @return true if successful	88	* contains this provider.
		89	* @param id the id of the persistence provider to locate
		90	* @return the persistence provider or null
81	*/	91	*/
82	public boolean restore(ISystemHostPool connectionPool);	92	public IRSEPersistenceProvider getPersistenceProvider(String id);
83		93
84	/**	94	/**
85	* Restore all profiles	95	* @return true if this instance of the persistence manager is currently exporting a profile.
86	* @param profileManager
87	* @return true if successful
88	*/	96	*/
89	public boolean restore(ISystemProfileManager profileManager);	97	public boolean isExporting();
90		98
91	/**	99	/**
92	* Restore the filter pool	100	* @return true if this instance of the persistence manager is currently importing a profile.
93	* @param name
94	* @return the filter pool if successful
95	*/	101	*/
96	public ISystemFilterPool restoreFilterPool(String name);	102	public boolean isImporting();
97		103
98	public ISystemFilterPoolManager restoreFilterPoolManager(ISystemProfile profile, Logger logger, ISystemFilterPoolManagerProvider caller, String name);
99	}	104	}

Added Link Here

(-)src/org/eclipse/rse/internal/core/model/SystemProfileManager.java (+476 lines)
1	/********************************************************************************
2	* Copyright (c) 2006, 2007 IBM Corporation. All rights reserved.
3	* This program and the accompanying materials are made available under the terms
4	* of the Eclipse Public License v1.0 which accompanies this distribution, and is
5	* available at http://www.eclipse.org/legal/epl-v10.html
6	*
7	* Initial Contributors:
8	* The following IBM employees contributed to the Remote System Explorer
9	* component that contains this file: David McKnight, Kushal Munir,
10	* Michael Berger, David Dykstal, Phil Coulthard, Don Yantzi, Eric Simpson,
11	* Emily Bruner, Mazen Faraj, Adrian Storisteanu, Li Ding, and Kent Hawley.
12	*
13	* Contributors:
14	* David Dykstal (IBM) - created and used RSEPreferencesManager
15	* - moved SystemPreferencesManager to a new plugin
16	********************************************************************************/
17
18	package org.eclipse.rse.internal.core.model;
19
20	import java.util.ArrayList;
21	import java.util.Arrays;
22	import java.util.Iterator;
23	import java.util.List;
24	import java.util.Vector;
25
26	import org.eclipse.rse.core.RSECorePlugin;
27	import org.eclipse.rse.core.RSEPreferencesManager;
28	import org.eclipse.rse.core.model.ISystemProfile;
29	import org.eclipse.rse.core.model.ISystemProfileManager;
30	import org.eclipse.rse.logging.Logger;
31	import org.eclipse.rse.persistence.IRSEPersistenceProvider;
32
33	/**
34	* A class that manages a list of SystemProfile objects.
35	* This should be used as a singleton.
36	*/
37	public class SystemProfileManager implements ISystemProfileManager {
38
39	private List _profiles = new ArrayList(10);
40	// private String[] profileNames = null;
41	// private Vector profileNamesVector = null;
42	private static SystemProfileManager singleton = null;
43	private boolean restoring = false;
44
45	/**
46	* Ordinarily there should be only one instance of a SystemProfileManager
47	* created on the system, so the static method {@link #getDefault()} is
48	* preferred to using this.
49	*/
50	private SystemProfileManager() {
51	}
52
53	/**
54	* @return (and create if necessary) the singleton instance of this class.
55	*/
56	public static SystemProfileManager getDefault() {
57	if (singleton == null) {
58	singleton = new SystemProfileManager();
59	RSECorePlugin.getThePersistenceManager().restoreProfiles();
60	}
61	return singleton;
62	}
63
64	/**
65	* Clear the default after a team sychronization say
66	*/
67	public static void clearDefault() {
68	singleton = null;
69	}
70
71	/**
72	* Create a new profile with the given name, and add to the list.
73	* The name must be unique within the existing list.
74	* <p>
75	* The underlying folder is created in the file system.
76	* <p>
77	* @param name What to name this profile
78	* @param makeActive true if this profile is to be added to the active profile list.
79	* @return new profile, or null if name not unique.
80	* @see ISystemProfileManager#createSystemProfile(String, boolean)
81	*/
82	public ISystemProfile createSystemProfile(String name, boolean makeActive) {
83	ISystemProfile existingProfile = getSystemProfile(name);
84	if (existingProfile != null) {
85	deleteSystemProfile(existingProfile, false); // replace the existing one with a new profile
86	}
87	ISystemProfile newProfile = internalCreateSystemProfile(name);
88	if (makeActive) {
89	RSEPreferencesManager.addActiveProfile(name);
90	((SystemProfile) newProfile).setActive(makeActive);
91	}
92	newProfile.commit();
93	return newProfile;
94	}
95
96	/* (non-Javadoc)
97	* @see org.eclipse.rse.core.model.ISystemProfileManager#makeSystemProfileActive(org.eclipse.rse.core.model.ISystemProfile, boolean)
98	*/
99	public void makeSystemProfileActive(ISystemProfile profile, boolean makeActive) {
100	boolean wasActive = isSystemProfileActive(profile.getName());
101	if (wasActive && !makeActive)
102	RSEPreferencesManager.deleteActiveProfile(profile.getName());
103	else if (makeActive && !wasActive) RSEPreferencesManager.addActiveProfile(profile.getName());
104	((SystemProfile) profile).setActive(makeActive);
105	}
106
107	/* (non-Javadoc)
108	* @see org.eclipse.rse.core.model.ISystemProfileManager#getSystemProfiles()
109	*/
110	public ISystemProfile[] getSystemProfiles() {
111	return getSystemProfiles(!restoring);
112	}
113
114	/* (non-Javadoc)
115	* @see org.eclipse.rse.core.model.ISystemProfileManager#getSystemProfileNames()
116	*/
117	public String[] getSystemProfileNames() {
118	ISystemProfile[] profiles = getSystemProfiles();
119	String[] profileNames = new String[profiles.length];
120	for (int i = 0; i < profiles.length; i++) {
121	ISystemProfile profile = profiles[i];
122	profileNames[i] = profile.getName();
123	}
124	return profileNames;
125	// if (profileNames == null) {
126	// ISystemProfile[] profiles = getSystemProfiles();
127	// profileNames = new String[profiles.length];
128	// for (int idx = 0; idx < profiles.length; idx++)
129	// profileNames[idx] = profiles[idx].getName();
130	// }
131	// return profileNames;
132	}
133
134	/* (non-Javadoc)
135	* @see org.eclipse.rse.core.model.ISystemProfileManager#getSystemProfileNamesVector()
136	*/
137	public Vector getSystemProfileNamesVector() {
138	List names = Arrays.asList(getSystemProfileNames());
139	Vector result = new Vector(names.size());
140	result.addAll(names);
141	return result;
142	// if (profileNamesVector == null) {
143	// ISystemProfile[] profiles = getSystemProfiles();
144	// profileNamesVector = new Vector(profiles.length);
145	// for (int idx = 0; idx < profiles.length; idx++)
146	// profileNamesVector.addElement(profiles[idx].getName());
147	// }
148	// return profileNamesVector;
149	}
150
151	// /**
152	// * Something changed so invalide cache of profiles so it will be regenerated
153	// */
154	// protected void invalidateCache() {
155	// profileNames = null;
156	// profileNamesVector = null;
157	// }
158	//
159	/* (non-Javadoc)
160	* @see org.eclipse.rse.core.model.ISystemProfileManager#getSystemProfile(java.lang.String)
161	*/
162	public ISystemProfile getSystemProfile(String name) {
163	ISystemProfile[] profiles = getSystemProfiles();
164	if ((profiles == null) \|\| (profiles.length == 0)) return null;
165	ISystemProfile match = null;
166	for (int idx = 0; (match == null) && (idx < profiles.length); idx++)
167	if (profiles[idx].getName().equals(name)) match = profiles[idx];
168	return match;
169	}
170
171	/* (non-Javadoc)
172	* @see org.eclipse.rse.core.model.ISystemProfileManager#renameSystemProfile(org.eclipse.rse.core.model.ISystemProfile, java.lang.String)
173	*/
174	public void renameSystemProfile(ISystemProfile profile, String newName) {
175	boolean isActive = isSystemProfileActive(profile.getName());
176	String oldName = profile.getName();
177	profile.setName(newName);
178	if (isActive) RSEPreferencesManager.renameActiveProfile(oldName, newName);
179	// invalidateCache();
180	// FIXME RSEUIPlugin.getThePersistenceManager().save(this);
181	}
182
183	/* (non-Javadoc)
184	* @see org.eclipse.rse.core.model.ISystemProfileManager#deleteSystemProfile(org.eclipse.rse.core.model.ISystemProfile, boolean)
185	*/
186	public void deleteSystemProfile(ISystemProfile profile, boolean persist) {
187	String oldName = profile.getName();
188	boolean isActive = isSystemProfileActive(oldName);
189	_profiles.remove(profile);
190	/* FIXME in EMF the profiles are "owned" by the Resource, and only referenced by the profile manager,
191	* so just removing it from the manager is not enough, it must also be removed from its resource.
192	* No longer needed since EMF is not in use.
193	* Resource res = profile.eResource();
194	* if (res != null)
195	* res.getContents().remove(profile);
196	*/
197	if (isActive) RSEPreferencesManager.deleteActiveProfile(oldName);
198	// invalidateCache();
199	if (persist) {
200	IRSEPersistenceProvider provider = profile.getPersistenceProvider();
201	RSECorePlugin.getThePersistenceManager().deleteProfile(provider, oldName);
202	}
203	}
204
205	/* (non-Javadoc)
206	* @see org.eclipse.rse.core.model.ISystemProfileManager#cloneSystemProfile(org.eclipse.rse.core.model.ISystemProfile, java.lang.String)
207	*/
208	public ISystemProfile cloneSystemProfile(ISystemProfile profile, String newName) {
209	ISystemProfile newProfile = createSystemProfile(newName, false);
210	return newProfile;
211	}
212
213	/* (non-Javadoc)
214	* @see org.eclipse.rse.core.model.ISystemProfileManager#isSystemProfileActive(java.lang.String)
215	*/
216	public boolean isSystemProfileActive(String profileName) {
217	String[] activeProfiles = getActiveSystemProfileNames();
218	boolean match = false;
219	for (int idx = 0; !match && (idx < activeProfiles.length); idx++) {
220	if (activeProfiles[idx].equals(profileName)) match = true;
221	}
222	return match;
223	}
224
225	/* (non-Javadoc)
226	* @see org.eclipse.rse.core.model.ISystemProfileManager#getActiveSystemProfiles()
227	*/
228	public ISystemProfile[] getActiveSystemProfiles() {
229	String[] profileNames = getActiveSystemProfileNames();
230	ISystemProfile[] profiles = new ISystemProfile[profileNames.length];
231	for (int idx = 0; idx < profileNames.length; idx++) {
232	profiles[idx] = getOrCreateSystemProfile(profileNames[idx]);
233	((SystemProfile) profiles[idx]).setActive(true);
234	}
235	return profiles;
236	}
237
238	/* (non-Javadoc)
239	* @see org.eclipse.rse.core.model.ISystemProfileManager#getActiveSystemProfileNames()
240	*/
241	public String[] getActiveSystemProfileNames() {
242	String[] activeProfileNames = RSEPreferencesManager.getActiveProfiles();
243	// dy: defect 48355, need to sync this with the actual profile list. If the user
244	// imports old preference settings or does a team sync and a profile is deleted then
245	// it is possible an active profile no longer exists.
246	// String[] systemProfileNames = getSystemProfileNames();
247	ISystemProfile[] systemProfiles = getSystemProfiles();
248	boolean found;
249	boolean found_team = false;
250	boolean found_private = false;
251	boolean changed = false;
252	String defaultProfileName = RSEPreferencesManager.getDefaultPrivateSystemProfileName();
253
254	for (int activeIdx = 0; activeIdx < activeProfileNames.length; activeIdx++) {
255	// skip Team and Private profiles
256	String activeProfileName = activeProfileNames[activeIdx];
257	if (activeProfileName.equals(defaultProfileName)) {
258	found_private = true;
259	} else if (activeProfileName.equals(RSEPreferencesManager.getDefaultTeamProfileName())) {
260	found_team = true;
261	} else {
262	found = false;
263	for (int systemIdx = 0; systemIdx < systemProfiles.length && !found; systemIdx++) {
264	if (activeProfileNames[activeIdx].equals(systemProfiles[systemIdx].getName())) {
265	found = true;
266	}
267	}
268
269	if (!found) {
270	// The active profile no longer exists so remove it from the active list
271	RSEPreferencesManager.deleteActiveProfile(activeProfileNames[activeIdx]);
272	changed = true;
273	}
274	}
275	}
276
277	for (int systemIdx = 0; systemIdx < systemProfiles.length && !changed; systemIdx++) {
278	boolean matchesBoth = false;
279	String name = systemProfiles[systemIdx].getName();
280
281	for (int activeIdx = 0; activeIdx < activeProfileNames.length && !matchesBoth; activeIdx++) {
282	String aname = activeProfileNames[activeIdx];
283	if (name.equals(aname)) {
284	matchesBoth = true;
285	}
286
287	}
288	if (!matchesBoth && found_private) {
289	if (systemProfiles[systemIdx].isActive() \|\| systemProfiles[systemIdx].isDefaultPrivate()) {
290	RSEPreferencesManager.addActiveProfile(name);
291	RSEPreferencesManager.deleteActiveProfile(RSECorePlugin.getLocalMachineName());
292	activeProfileNames = RSEPreferencesManager.getActiveProfiles();
293	}
294	}
295	}
296
297	// the active profiles list needed to be changed because of an external update, also
298	// check if Default profile needs to be added back to the list
299	if (changed \|\| !found_team \|\| !found_private) {
300	if (systemProfiles.length == 0) {
301	// First time user, make sure default is in the active list, the only time it wouldn't
302	// be is if the pref_store.ini was modified (because the user imported old preferences)
303	if (!found_team) {
304	RSEPreferencesManager.addActiveProfile(RSEPreferencesManager.getDefaultTeamProfileName());
305	changed = true;
306	}
307
308	if (!found_private) {
309	RSEPreferencesManager.addActiveProfile(RSECorePlugin.getLocalMachineName());
310	changed = true;
311	}
312	} else {
313	ISystemProfile defaultProfile = getDefaultPrivateSystemProfile();
314	if (defaultProfile != null && !found_private) {
315	RSEPreferencesManager.addActiveProfile(defaultProfile.getName());
316	changed = true;
317	}
318	}
319
320	if (changed) {
321	activeProfileNames = RSEPreferencesManager.getActiveProfiles();
322	}
323	}
324
325	return activeProfileNames;
326	}
327
328	/**
329	* @return the profile names currently selected by the user as "active" profiles
330	*/
331	public Vector getActiveSystemProfileNamesVector() {
332	String[] profileNames = RSEPreferencesManager.getActiveProfiles();
333	Vector v = new Vector(profileNames.length);
334	for (int idx = 0; idx < profileNames.length; idx++)
335	v.addElement(profileNames[idx]);
336	return v;
337	}
338
339	/* (non-Javadoc)
340	* @see org.eclipse.rse.core.model.ISystemProfileManager#getActiveSystemProfilePosition(java.lang.String)
341	*/
342	public int getActiveSystemProfilePosition(String profileName) {
343	String[] profiles = getActiveSystemProfileNames();
344	int pos = -1;
345	for (int idx = 0; (pos < 0) && (idx < profiles.length); idx++) {
346	if (profiles[idx].equals(profileName)) pos = idx;
347	}
348	return pos;
349	}
350
351	/* (non-Javadoc)
352	* @see org.eclipse.rse.core.model.ISystemProfileManager#getDefaultPrivateSystemProfile()
353	*/
354	public ISystemProfile getDefaultPrivateSystemProfile() {
355	return getSystemProfile(RSEPreferencesManager.getDefaultPrivateSystemProfileName());
356	}
357
358	/* (non-Javadoc)
359	* @see org.eclipse.rse.core.model.ISystemProfileManager#getDefaultTeamSystemProfile()
360	*/
361	public ISystemProfile getDefaultTeamSystemProfile() {
362	return getSystemProfile(RSEPreferencesManager.getDefaultTeamProfileName());
363	}
364
365	/* (non-Javadoc)
366	* @see org.eclipse.rse.core.model.ISystemProfileManager#getProfiles()
367	*/
368	public List getProfiles() {
369	List result = new ArrayList(_profiles.size());
370	result.addAll(_profiles);
371	return result;
372	}
373
374	/* (non-Javadoc)
375	* @see org.eclipse.rse.core.model.ISystemProfileManager#getSize()
376	*/
377	public int getSize() {
378	return _profiles.size();
379	}
380
381	/**
382	* Adds a newly restored profile to this manager
383	* @param profile the profile to add
384	*/
385	public void addSystemProfile(ISystemProfile profile) {
386	_profiles.add(profile);
387	String name = profile.getName();
388	if (profile.isActive()) {
389	RSEPreferencesManager.addActiveProfile(name);
390	}
391	profile.setDefaultPrivate(name.equalsIgnoreCase(RSEPreferencesManager.getDefaultPrivateSystemProfileName()));
392	}
393
394	private ISystemProfile[] getSystemProfiles(boolean ensureDefaultPrivateProfileExists) {
395	if (ensureDefaultPrivateProfileExists) {
396	ensureDefaultPrivateProfile();
397	}
398	ISystemProfile[] result = new ISystemProfile[_profiles.size()];
399	_profiles.toArray(result);
400	return result;
401	}
402
403	public void setRestoring(boolean flag) {
404	restoring = flag;
405	}
406
407	private ISystemProfile internalCreateSystemProfile(String name) {
408	ISystemProfile newProfile = new SystemProfile();
409	newProfile.setName(name);
410	newProfile.setProfileManager(this);
411	_profiles.add(newProfile);
412	// invalidateCache();
413	newProfile.setDefaultPrivate(name.equalsIgnoreCase(RSEPreferencesManager.getDefaultPrivateSystemProfileName()));
414	return newProfile;
415	}
416
417	private void ensureDefaultPrivateProfile() {
418	// Ensure that one Profile is the default Profile - defect 48995 NH
419	boolean defaultProfileExists = false;
420	for (Iterator z = _profiles.iterator(); z.hasNext() && !defaultProfileExists;) {
421	ISystemProfile profile = (ISystemProfile) z.next();
422	defaultProfileExists = profile.isDefaultPrivate();
423	}
424	if (!defaultProfileExists) {
425	// find one with the right name
426	String defaultPrivateProfileName = RSEPreferencesManager.getDefaultPrivateSystemProfileName();
427	for (Iterator z = _profiles.iterator(); z.hasNext() && !defaultProfileExists;) {
428	ISystemProfile profile = (ISystemProfile) z.next();
429	if (profile.getName().equals(defaultPrivateProfileName)) {
430	profile.setDefaultPrivate(true);
431	defaultProfileExists = true;
432	}
433	}
434	}
435	if (!defaultProfileExists) {
436	// Find the first profile that is not the Team profile and make it the default private profile
437	String defaultTeamProfileName = RSEPreferencesManager.getDefaultTeamProfileName();
438	for (Iterator z = _profiles.iterator(); z.hasNext() && !defaultProfileExists;) {
439	ISystemProfile profile = (ISystemProfile) z.next();
440	if (!profile.getName().equals(defaultTeamProfileName)) {
441	profile.setDefaultPrivate(true);
442	defaultProfileExists = true;
443	}
444	}
445	}
446	if (!defaultProfileExists) {
447	// If Team is the only profile - then put a message in the log and create the default private profile
448	Logger logger = RSECorePlugin.getDefault().getLogger();
449	logger.logWarning("Only one Profile Team exists - there is no Default Profile"); //$NON-NLS-1$
450	createDefaultPrivateProfile();
451	}
452	}
453
454	private void createDefaultPrivateProfile() {
455	ISystemProfile profile = new SystemProfile();
456	String initProfileName = RSEPreferencesManager.getDefaultPrivateSystemProfileName();
457	profile.setName(initProfileName);
458	profile.setDefaultPrivate(true);
459	_profiles = new ArrayList();
460	_profiles.add(profile);
461	}
462
463	/**
464	* Instantiate a user profile given its name.
465	* @param userProfileName the name of the profile to find or create
466	* @return the profile that was found or created.
467	*/
468	private ISystemProfile getOrCreateSystemProfile(String userProfileName) {
469	ISystemProfile userProfile = getSystemProfile(userProfileName);
470	if (userProfile == null) {
471	userProfile = internalCreateSystemProfile(userProfileName);
472	}
473	return userProfile;
474	}
475
476	}

Added Link Here

(-)src/org/eclipse/rse/internal/core/model/SystemProfile.java (+240 lines)
1	/********************************************************************************
2	* Copyright (c) 2002, 2007 IBM Corporation. All rights reserved.
3	* This program and the accompanying materials are made available under the terms
4	* of the Eclipse Public License v1.0 which accompanies this distribution, and is
5	* available at http://www.eclipse.org/legal/epl-v10.html
6	*
7	* Initial Contributors:
8	* The following IBM employees contributed to the Remote System Explorer
9	* component that contains this file: David McKnight, Kushal Munir,
10	* Michael Berger, David Dykstal, Phil Coulthard, Don Yantzi, Eric Simpson,
11	* Emily Bruner, Mazen Faraj, Adrian Storisteanu, Li Ding, and Kent Hawley.
12	*
13	* Contributors:
14	* David Dykstal (IBM) - 142806: refactoring persistence framework
15	********************************************************************************/
16
17	package org.eclipse.rse.internal.core.model;
18	import java.util.Vector;
19
20	import org.eclipse.core.runtime.IAdaptable;
21	import org.eclipse.core.runtime.Platform;
22	import org.eclipse.rse.core.RSECorePlugin;
23	import org.eclipse.rse.core.filters.ISystemFilterPool;
24	import org.eclipse.rse.core.filters.ISystemFilterPoolManager;
25	import org.eclipse.rse.core.model.IHost;
26	import org.eclipse.rse.core.model.IRSEPersistableContainer;
27	import org.eclipse.rse.core.model.ISystemProfile;
28	import org.eclipse.rse.core.model.ISystemProfileManager;
29	import org.eclipse.rse.core.model.ISystemRegistry;
30	import org.eclipse.rse.core.model.RSEModelObject;
31	import org.eclipse.rse.core.subsystems.ISubSystemConfiguration;
32	import org.eclipse.rse.persistence.IRSEPersistenceProvider;
33
34	/**
35	* A profile contains hosts and filter pools. It is the unit of save/restore for RSE model
36	* objects. All model objects are contained within a profile.
37	*/
38	public class SystemProfile extends RSEModelObject implements ISystemProfile, IAdaptable
39	{
40
41	private ISystemProfileManager mgr = null;
42	private IRSEPersistenceProvider provider = null;
43	private boolean isActive = true;
44	private String name = null;
45	private boolean defaultPrivate = false;
46
47	/**
48	* Default constructor
49	*/
50	protected SystemProfile()
51	{
52	super();
53	}
54
55	public SystemProfile(String name, boolean isActive) {
56	this.name = name;
57	this.isActive = isActive;
58	}
59
60	/**
61	* Set the in-memory pointer back to the parent system profile manager
62	*/
63	public void setProfileManager(ISystemProfileManager mgr)
64	{
65	this.mgr = mgr;
66	}
67
68	/**
69	* Get the in-memory pointer back to the parent system profile manager
70	*/
71	public ISystemProfileManager getProfileManager()
72	{
73	return mgr;
74	}
75
76	/**
77	* Convenience method for create a new connection within this profile.
78	* Shortcut for {@link ISystemRegistry#createHost(String,String,String,String)}
79	*/
80	public IHost createHost(String systemType, String connectionName, String hostName, String description) throws Exception
81	{
82	return RSECorePlugin.getDefault().getSystemRegistry().createHost(getName(), systemType, connectionName, hostName, description);
83	}
84
85	/**
86	* Return all connections for this profile
87	*/
88	public IHost[] getHosts()
89	{
90	return RSECorePlugin.getDefault().getSystemRegistry().getHostsByProfile(this);
91	}
92
93	/**
94	* Return all filter pools for this profile
95	*/
96	public ISystemFilterPool[] getFilterPools()
97	{
98	ISubSystemConfiguration[] ssFactories = RSECorePlugin.getDefault().getSystemRegistry().getSubSystemConfigurations();
99	Vector poolsVector = new Vector();
100	for (int idx = 0; idx < ssFactories.length; idx++)
101	{
102	ISystemFilterPoolManager poolMgr = ssFactories[idx].getFilterPoolManager(this);
103	ISystemFilterPool[] pools = poolMgr.getSystemFilterPools();
104	for (int ydx=0; ydx<pools.length; ydx++)
105	{
106	poolsVector.add(pools[ydx]);
107	}
108	}
109	ISystemFilterPool[] allPools = new ISystemFilterPool[poolsVector.size()];
110	poolsVector.toArray(allPools);
111	return allPools;
112	}
113
114	/**
115	* Return all filter pools for this profile, scoped by a given subsystem factory
116	*/
117	public ISystemFilterPool[] getFilterPools(ISubSystemConfiguration ssf)
118	{
119	ISystemFilterPoolManager poolMgr = ssf.getFilterPoolManager(this);
120	return poolMgr.getSystemFilterPools();
121	}
122
123	/**
124	* Return true if this profile is currently active.
125	*/
126	public boolean isActive()
127	{
128	return isActive;
129	}
130	/**
131	* Reset whether this profile is currently active.
132	*/
133	public void setActive(boolean active)
134	{
135	this.isActive = active;
136	setDirty(true);
137	}
138
139	/**
140	* This is the method required by the IAdaptable interface.
141	* Given an adapter class type, return an object castable to the type, or
142	* null if this is not possible.
143	*/
144	public Object getAdapter(Class adapterType)
145	{
146	return Platform.getAdapterManager().getAdapter(this, adapterType);
147	}
148
149	//For debugging
150	public String toString() {
151	String result = getName();
152	if (result == null) {
153	StringBuffer buf = new StringBuffer(super.toString());
154	buf.append("Profile(name: "); //$NON-NLS-1$
155	buf.append(name);
156	buf.append(", defaultPrivate: "); //$NON-NLS-1$
157	buf.append(defaultPrivate);
158	buf.append(')');
159	result = buf.toString();
160	}
161	return result;
162	}
163
164	/**
165	* @generated This field/method will be replaced during code generation
166	*/
167	public String getName()
168	{
169	return name;
170	}
171
172	public String getDescription()
173	{
174	return RSEModelResources.RESID_MODELOBJECTS_PROFILE_DESCRIPTION;
175	}
176
177	/**
178	* @generated This field/method will be replaced during code generation.
179	*/
180	public void setName(String newName)
181	{
182	name = newName;
183	setDirty(true);
184	}
185
186	/**
187	* @generated This field/method will be replaced during code generation
188	* Is this profile created automatically, and is it the profile
189	* that is unique for this developer?
190	*/
191	public boolean isDefaultPrivate()
192	{
193	return defaultPrivate;
194	}
195
196	/**
197	* @generated This field/method will be replaced during code generation.
198	*/
199	public void setDefaultPrivate(boolean newDefaultPrivate)
200	{
201	defaultPrivate = newDefaultPrivate;
202	setDirty(true);
203	}
204
205	public boolean commit()
206	{
207	return RSECorePlugin.getThePersistenceManager().commitProfile(this);
208	}
209
210	/**
211	* The SystemProfile is the top of the persistence hierarchy.
212	* @return null
213	*/
214	public IRSEPersistableContainer getPersistableParent() {
215	return null;
216	}
217
218	public IRSEPersistableContainer[] getPersistableChildren() {
219	ISystemFilterPool[] pools = getFilterPools();
220	IHost[] hosts = getHosts();
221	IRSEPersistableContainer[] result = new IRSEPersistableContainer[pools.length + hosts.length];
222	System.arraycopy(pools, 0, result, 0, pools.length);
223	System.arraycopy(hosts, 0, result, pools.length, hosts.length);
224	return result;
225	}
226
227	/* (non-Javadoc)
228	* @see org.eclipse.rse.core.model.ISystemProfile#getPersistenceProvider()
229	*/
230	public IRSEPersistenceProvider getPersistenceProvider() {
231	return provider;
232	}
233
234	public void setPersistenceProvider(IRSEPersistenceProvider provider) {
235	this.provider = provider;
236	}
237
238
239
240	}

Lines 124-144 Link Here

(-)UI/org/eclipse/rse/ui/validators/ValidatorUniqueString.java (-12 / +5 lines)
124	/**	124	/**
125	* Reset the existing names list.	125	* Reset the existing names list.
126	*/	126	*/
127	public void setExistingNamesList(Vector existingList)	127	public void setExistingNamesList(Vector newList)
128	{	128	{
129	if (existingList == null)	129	if (newList == null)
130	this.existingList = null;	130	existingList = null;
131	else	131	else
132	{	132	{
133	String newList[] = new String[existingList.size()];	133	existingList = new String[newList.size()];
134	for (int idx=0; idx<existingList.size(); idx++)	134	newList.toArray(existingList);
135	{
136	if (!caseSensitive)
137	newList[idx] = existingList.elementAt(idx).toString().toLowerCase();
138	else
139	newList[idx] = existingList.elementAt(idx).toString();
140	}
141	init(newList, true); // don't redo the toLowerCase calls
142	}	135	}
143	}	136	}
144	/**	137	/**

Lines 17-29 Link Here

(-)UI/org/eclipse/rse/internal/ui/SystemProfileForm.java (-6 / +2 lines)
17	package org.eclipse.rse.internal.ui;	17	package org.eclipse.rse.internal.ui;
18	import org.eclipse.jface.wizard.WizardPage;	18	import org.eclipse.jface.wizard.WizardPage;
19	import org.eclipse.rse.core.model.ISystemProfile;	19	import org.eclipse.rse.core.model.ISystemProfile;
20	import org.eclipse.rse.internal.model.SystemProfileManager;
21	import org.eclipse.rse.services.clientserver.messages.SystemMessage;	20	import org.eclipse.rse.services.clientserver.messages.SystemMessage;
22	import org.eclipse.rse.ui.RSEUIPlugin;
23	import org.eclipse.rse.ui.SystemWidgetHelpers;	21	import org.eclipse.rse.ui.SystemWidgetHelpers;
24	import org.eclipse.rse.ui.dialogs.SystemPromptDialog;	22	import org.eclipse.rse.ui.dialogs.SystemPromptDialog;
25	import org.eclipse.rse.ui.messages.ISystemMessageLine;	23	import org.eclipse.rse.ui.messages.ISystemMessageLine;
26	import org.eclipse.rse.ui.validators.ISystemValidator;	24	import org.eclipse.rse.ui.validators.ISystemValidator;
		25	import org.eclipse.rse.ui.validators.ValidatorFactory;
27	import org.eclipse.rse.ui.validators.ValidatorProfileName;	26	import org.eclipse.rse.ui.validators.ValidatorProfileName;
28	import org.eclipse.swt.events.ModifyEvent;	27	import org.eclipse.swt.events.ModifyEvent;
29	import org.eclipse.swt.events.ModifyListener;	28	import org.eclipse.swt.events.ModifyListener;
Lines 79-88 Link Here
79	this.showVerbiage = showVerbiage;	78	this.showVerbiage = showVerbiage;
80	callerInstanceOfWizardPage = (caller instanceof WizardPage);	79	callerInstanceOfWizardPage = (caller instanceof WizardPage);
81	callerInstanceOfSystemPromptDialog = (caller instanceof SystemPromptDialog);	80	callerInstanceOfSystemPromptDialog = (caller instanceof SystemPromptDialog);
82		81	nameValidator = ValidatorFactory.getProfileNameValidator(profile.getName());
83	// FIXME cast to SystemProfileManager is temporary to get at api - need to use an adapter for getting validators
84	SystemProfileManager mgr = (SystemProfileManager)RSEUIPlugin.getTheSystemRegistry().getSystemProfileManager();
85	nameValidator = mgr.getProfileNameValidator(profile);
86	}	82	}
87		83
88	/**	84	/**

Lines 23-29 Link Here

(-)UI/org/eclipse/rse/ui/actions/SystemBaseCopyAction.java (-2 / +2 lines)
23	import org.eclipse.jface.viewers.IStructuredSelection;	23	import org.eclipse.jface.viewers.IStructuredSelection;
24	import org.eclipse.rse.core.model.ISystemProfileManager;	24	import org.eclipse.rse.core.model.ISystemProfileManager;
25	import org.eclipse.rse.core.model.ISystemRegistry;	25	import org.eclipse.rse.core.model.ISystemRegistry;
26	import org.eclipse.rse.internal.model.SystemProfileManager;	26	import org.eclipse.rse.internal.core.model.SystemProfileManager;
27	import org.eclipse.rse.internal.ui.SystemResources;	27	import org.eclipse.rse.internal.ui.SystemResources;
28	import org.eclipse.rse.model.SystemRegistry;	28	import org.eclipse.rse.model.SystemRegistry;
29	import org.eclipse.rse.services.clientserver.messages.SystemMessage;	29	import org.eclipse.rse.services.clientserver.messages.SystemMessage;
Lines 87-93 Link Here
87	: RSEUIPlugin.getDefault().getImageDescriptor(ISystemIconConstants.ICON_SYSTEM_MOVE_ID)),	87	: RSEUIPlugin.getDefault().getImageDescriptor(ISystemIconConstants.ICON_SYSTEM_MOVE_ID)),
88	parent);	88	parent);
89	this.mode = mode;	89	this.mode = mode;
90	mgr = SystemProfileManager.getSystemProfileManager();	90	mgr = SystemProfileManager.getDefault();
91	sr = RSEUIPlugin.getTheSystemRegistry();	91	sr = RSEUIPlugin.getTheSystemRegistry();
92	allowOnMultipleSelection(true);	92	allowOnMultipleSelection(true);
93	setProcessAllSelections(true);	93	setProcessAllSelections(true);

Lines 18-24 Link Here

(-)UI/org/eclipse/rse/internal/ui/dialogs/SystemCopyProfileDialog.java (-5 / +2 lines)
18	import org.eclipse.jface.viewers.ISelection;	18	import org.eclipse.jface.viewers.ISelection;
19	import org.eclipse.jface.viewers.IStructuredSelection;	19	import org.eclipse.jface.viewers.IStructuredSelection;
20	import org.eclipse.rse.core.model.ISystemProfile;	20	import org.eclipse.rse.core.model.ISystemProfile;
21	import org.eclipse.rse.internal.model.SystemProfileManager;
22	import org.eclipse.rse.internal.ui.SystemResources;	21	import org.eclipse.rse.internal.ui.SystemResources;
23	import org.eclipse.rse.services.clientserver.messages.SystemMessage;	22	import org.eclipse.rse.services.clientserver.messages.SystemMessage;
24	import org.eclipse.rse.ui.RSEUIPlugin;	23	import org.eclipse.rse.ui.RSEUIPlugin;
Lines 27-32 Link Here
27	import org.eclipse.rse.ui.dialogs.SystemSimpleContentElement;	26	import org.eclipse.rse.ui.dialogs.SystemSimpleContentElement;
28	import org.eclipse.rse.ui.messages.ISystemMessageLine;	27	import org.eclipse.rse.ui.messages.ISystemMessageLine;
29	import org.eclipse.rse.ui.validators.ISystemValidator;	28	import org.eclipse.rse.ui.validators.ISystemValidator;
		29	import org.eclipse.rse.ui.validators.ValidatorFactory;
30	import org.eclipse.rse.ui.validators.ValidatorProfileName;	30	import org.eclipse.rse.ui.validators.ValidatorProfileName;
31	import org.eclipse.swt.events.ModifyEvent;	31	import org.eclipse.swt.events.ModifyEvent;
32	import org.eclipse.swt.events.ModifyListener;	32	import org.eclipse.swt.events.ModifyListener;
Lines 71-80 Link Here
71	{	71	{
72	setInputObject(profile);	72	setInputObject(profile);
73	}	73	}
74		74	nameValidator = ValidatorFactory.getProfileNameValidator((String)null);
75	// FIXME cast to SystemProfileManager is temporary to get at api - need to use an adapter for getting validators
76	SystemProfileManager mgr = (SystemProfileManager)RSEUIPlugin.getTheSystemRegistry().getSystemProfileManager();
77	nameValidator = mgr.getProfileNameValidator((String)null);
78	//pack();	75	//pack();
79	setHelp(RSEUIPlugin.HELPPREFIX+"drnp0000"); //$NON-NLS-1$	76	setHelp(RSEUIPlugin.HELPPREFIX+"drnp0000"); //$NON-NLS-1$
80	}	77	}

Lines 35-45 Link Here

(-)model/org/eclipse/rse/model/SystemRegistry.java (-15 / +8 lines)
35	import org.eclipse.jface.viewers.Viewer;	35	import org.eclipse.jface.viewers.Viewer;
36	import org.eclipse.rse.core.IRSESystemType;	36	import org.eclipse.rse.core.IRSESystemType;
37	import org.eclipse.rse.core.IRSEUserIdConstants;	37	import org.eclipse.rse.core.IRSEUserIdConstants;
38	import org.eclipse.rse.core.RSECorePlugin;
39	import org.eclipse.rse.core.SystemAdapterHelpers;	38	import org.eclipse.rse.core.SystemAdapterHelpers;
40	import org.eclipse.rse.core.SystemBasePlugin;	39	import org.eclipse.rse.core.SystemBasePlugin;
41	import org.eclipse.rse.core.filters.ISystemFilter;	40	import org.eclipse.rse.core.filters.ISystemFilter;
42	import org.eclipse.rse.core.filters.ISystemFilterPool;
43	import org.eclipse.rse.core.filters.ISystemFilterPoolReferenceManager;	41	import org.eclipse.rse.core.filters.ISystemFilterPoolReferenceManager;
44	import org.eclipse.rse.core.filters.ISystemFilterReference;	42	import org.eclipse.rse.core.filters.ISystemFilterReference;
45	import org.eclipse.rse.core.filters.ISystemFilterStartHere;	43	import org.eclipse.rse.core.filters.ISystemFilterStartHere;
Lines 66-79 Link Here
66	import org.eclipse.rse.core.subsystems.ISubSystemConfiguration;	64	import org.eclipse.rse.core.subsystems.ISubSystemConfiguration;
67	import org.eclipse.rse.core.subsystems.ISubSystemConfigurationProxy;	65	import org.eclipse.rse.core.subsystems.ISubSystemConfigurationProxy;
68	import org.eclipse.rse.core.subsystems.util.ISubSystemConfigurationAdapter;	66	import org.eclipse.rse.core.subsystems.util.ISubSystemConfigurationAdapter;
69	import org.eclipse.rse.internal.core.filters.SystemFilterPool;
70	import org.eclipse.rse.internal.core.filters.SystemFilterStartHere;	67	import org.eclipse.rse.internal.core.filters.SystemFilterStartHere;
		68	import org.eclipse.rse.internal.core.model.SystemProfileManager;
71	import org.eclipse.rse.internal.model.SystemHostPool;	69	import org.eclipse.rse.internal.model.SystemHostPool;
72	import org.eclipse.rse.internal.model.SystemModelChangeEvent;	70	import org.eclipse.rse.internal.model.SystemModelChangeEvent;
73	import org.eclipse.rse.internal.model.SystemModelChangeEventManager;	71	import org.eclipse.rse.internal.model.SystemModelChangeEventManager;
74	import org.eclipse.rse.internal.model.SystemPostableEventNotifier;	72	import org.eclipse.rse.internal.model.SystemPostableEventNotifier;
75	import org.eclipse.rse.internal.model.SystemPreferenceChangeManager;	73	import org.eclipse.rse.internal.model.SystemPreferenceChangeManager;
76	import org.eclipse.rse.internal.model.SystemProfileManager;
77	import org.eclipse.rse.internal.model.SystemRemoteChangeEventManager;	74	import org.eclipse.rse.internal.model.SystemRemoteChangeEventManager;
78	import org.eclipse.rse.internal.model.SystemResourceChangeManager;	75	import org.eclipse.rse.internal.model.SystemResourceChangeManager;
79	import org.eclipse.rse.internal.model.SystemScratchpad;	76	import org.eclipse.rse.internal.model.SystemScratchpad;
Lines 764-770 Link Here
764	*/	761	*/
765	public ISystemProfileManager getSystemProfileManager()	762	public ISystemProfileManager getSystemProfileManager()
766	{	763	{
767	return SystemProfileManager.getSystemProfileManager();	764	return SystemProfileManager.getDefault();
768	}	765	}
769		766
770	/**	767	/**
Lines 795-806 Link Here
795	{	792	{
796	return getSystemProfileManager().getSystemProfileNames();	793	return getSystemProfileManager().getSystemProfileNames();
797	}	794	}
		795
798	/**	796	/**
799	* Return all defined profile names as a vector	797	* Return all defined profile names as a vector
800	*/	798	*/
801	public Vector getAllSystemProfileNamesVector()	799	public Vector getAllSystemProfileNamesVector()
802	{	800	{
803	return getSystemProfileManager().getSystemProfileNamesVector();	801	Vector v = getSystemProfileManager().getSystemProfileNamesVector();
		802	return v;
804	}	803	}
805		804
806	/**	805	/**
Lines 2843-2849 Link Here
2843	public void disconnectAllSubSystems(IHost conn)	2842	public void disconnectAllSubSystems(IHost conn)
2844	{	2843	{
2845	// FIXME - save profile	2844	// FIXME - save profile
2846	save();	2845	// save();
2847		2846
2848	ISubSystem[] subsystems = getSubSystemsLazily(conn);	2847	ISubSystem[] subsystems = getSubSystemsLazily(conn);
2849	if (subsystems == null)	2848	if (subsystems == null)
Lines 3346-3353 Link Here
3346	*/	3345	*/
3347	public boolean save()	3346	public boolean save()
3348	{	3347	{
3349	ISystemProfileManager profileManager = getSystemProfileManager();	3348	return RSEUIPlugin.getThePersistenceManager().commitProfiles();
3350	return RSEUIPlugin.getThePersistenceManager().commit(profileManager);
3351	}	3349	}
3352		3350
3353	/**	3351	/**
Lines 3356-3362 Link Here
3356	*/	3354	*/
3357	public boolean saveHostPool(ISystemHostPool pool)	3355	public boolean saveHostPool(ISystemHostPool pool)
3358	{	3356	{
3359	return RSEUIPlugin.getThePersistenceManager().commit(pool);	3357	return pool.commit();
3360	}	3358	}
3361		3359
3362	/**	3360	/**
Lines 3414-3422 Link Here
3414	return SystemFilterStartHere.getDefault();	3412	return SystemFilterStartHere.getDefault();
3415	}	3413	}
3416		3414
3417	public ISystemFilterPool getSystemFilterPool()
3418	{
3419	return SystemFilterPool.getDefault();
3420	}
3421
3422	}//SystemRegistryImpl	3415	}//SystemRegistryImpl

Lines 25-30 Link Here

(-)UI/org/eclipse/rse/internal/ui/view/SystemViewFilterPoolReferenceAdapter.java (-34 / +31 lines)
25	import org.eclipse.rse.core.SystemAdapterHelpers;	25	import org.eclipse.rse.core.SystemAdapterHelpers;
26	import org.eclipse.rse.core.filters.ISystemFilterPool;	26	import org.eclipse.rse.core.filters.ISystemFilterPool;
27	import org.eclipse.rse.core.filters.ISystemFilterPoolManager;	27	import org.eclipse.rse.core.filters.ISystemFilterPoolManager;
		28	import org.eclipse.rse.core.filters.ISystemFilterPoolManagerProvider;
28	import org.eclipse.rse.core.filters.ISystemFilterPoolReference;	29	import org.eclipse.rse.core.filters.ISystemFilterPoolReference;
29	import org.eclipse.rse.core.filters.ISystemFilterPoolReferenceManagerProvider;	30	import org.eclipse.rse.core.filters.ISystemFilterPoolReferenceManagerProvider;
30	import org.eclipse.rse.core.subsystems.ISubSystem;	31	import org.eclipse.rse.core.subsystems.ISubSystem;
Lines 89-95 Link Here
89	menu.add(menuGroup, action);	90	menu.add(menuGroup, action);
90	}	91	}
91	}	92	}
92	actions = adapter.getFilterPoolReferenceActions(menu, selection, shell, menuGroup, ssFactory, getFilterPoolReference(element));	93	actions = adapter.getFilterPoolReferenceActions(menu, selection, shell, menuGroup, ssFactory, (ISystemFilterPoolReference)element);
93	if (actions != null)	94	if (actions != null)
94	{	95	{
95	//menu.addSeparator();	96	//menu.addSeparator();
Lines 112-146 Link Here
112	*/	113	*/
113	public ISubSystem getSubSystem(Object element)	114	public ISubSystem getSubSystem(Object element)
114	{	115	{
115	return ((ISubSystem)getFilterPoolReference(element).getProvider());	116	ISystemFilterPoolReference ref = (ISystemFilterPoolReference)element;
		117	return (ISubSystem)ref.getProvider();
116	}	118	}
117		119
118	/**	120	/**
119	* Returns an image descriptor for the image. More efficient than getting the image.	121	* Returns an image descriptor for the image. More efficient than getting the image.
120	* @param element The element for which an image is desired	122	* @param element The element for which an image is desired
121	*/	123	*/
122	public ImageDescriptor getImageDescriptor(Object element)	124	public ImageDescriptor getImageDescriptor(Object element) {
123	{	125	ImageDescriptor poolImage = null;
124	ImageDescriptor poolImage = null;	126	ISystemFilterPool pool = getFilterPool(element);
125	ISystemFilterPool pool = getFilterPool(element);	127	if (pool != null) {
126	if (pool.getProvider() != null)	128	ISystemFilterPoolManagerProvider provider = pool.getProvider();
127	{	129	if (provider != null) {
128	ISubSystemConfigurationAdapter adapter = (ISubSystemConfigurationAdapter)pool.getProvider().getAdapter(ISubSystemConfigurationAdapter.class);	130	ISubSystemConfigurationAdapter adapter = (ISubSystemConfigurationAdapter) provider.getAdapter(ISubSystemConfigurationAdapter.class);
129	poolImage = adapter.getSystemFilterPoolImage(pool);	131	poolImage = adapter.getSystemFilterPoolImage(pool);
130	}	132	}
131	if (poolImage == null)	133	}
132	poolImage = RSEUIPlugin.getDefault().getImageDescriptor(ISystemIconConstants.ICON_SYSTEM_FILTERPOOL_ID);	134	if (poolImage == null) {
133	return poolImage;	135	poolImage = RSEUIPlugin.getDefault().getImageDescriptor(ISystemIconConstants.ICON_SYSTEM_FILTERPOOL_ID);
134	}	136	}
135		137	return poolImage;
136	private ISystemFilterPoolReference getFilterPoolReference(Object element)
137	{
138	return (ISystemFilterPoolReference)element; // get referenced object
139	}	138	}
140		139
141	private ISystemFilterPool getFilterPool(Object element)	140	private ISystemFilterPool getFilterPool(Object element)
142	{	141	{
143	return getFilterPoolReference(element).getReferencedFilterPool(); // get master object	142	ISystemFilterPoolReference ref = (ISystemFilterPoolReference)element;
		143	ISystemFilterPool pool = ref.getReferencedFilterPool();
		144	return pool; // get master object
144	}	145	}
145		146
146	/**	147	/**
Lines 148-163 Link Here
148	* @return the label for this filter pool reference.	149	* @return the label for this filter pool reference.
149	*/	150	*/
150	public String getText(Object element) {	151	public String getText(Object element) {
151	String result = "unknown"; // $NON-NLS-1$ //$NON-NLS-1$	152	ISystemFilterPoolReference reference = (ISystemFilterPoolReference) element;
		153	String result = reference.getName();
152	ISystemFilterPool pool = getFilterPool(element);	154	ISystemFilterPool pool = getFilterPool(element);
153	if (pool != null) {	155	if (pool != null) {
154	result = pool.getName();	156	result = pool.getName();
155	// the following looks like it was copied from the host adapter and not really needed here.
156	// boolean qualifyNames = RSEUIPlugin.getTheSystemRegistry().getQualifiedHostNames();
157	// if (qualifyNames) {
158	// String prefix = SubSystemHelpers.getParentSystemProfile(pool).getName();
159	// result = prefix + "." + result;
160	// }
161	}	157	}
162	return result;	158	return result;
163	}	159	}
Lines 178-190 Link Here
178	public String getAbsoluteName(Object element)	174	public String getAbsoluteName(Object element)
179	{	175	{
180	//TODO consider caching the absolute name in the FilterPoolReference to avoid unnecessary String operations - the name won't ever change	176	//TODO consider caching the absolute name in the FilterPoolReference to avoid unnecessary String operations - the name won't ever change
181	ISystemFilterPoolReference filterPoolRef = getFilterPoolReference(element);	177	ISystemFilterPoolReference filterPoolRef = (ISystemFilterPoolReference)element;
182	ISystemFilterPoolReferenceManagerProvider subSystem = filterPoolRef.getProvider();	178	ISystemFilterPoolReferenceManagerProvider subSystem = filterPoolRef.getProvider();
183	ISystemViewElementAdapter adapter = SystemAdapterHelpers.getViewAdapter(subSystem);	179	ISystemViewElementAdapter adapter = SystemAdapterHelpers.getViewAdapter(subSystem);
184	String parentAbsoluteName = (adapter != null) ? adapter.getAbsoluteName(subSystem) : ""; //$NON-NLS-1$	180	String parentAbsoluteName = (adapter != null) ? adapter.getAbsoluteName(subSystem) : ""; //$NON-NLS-1$
185	return parentAbsoluteName + "." + //$NON-NLS-1$	181	String referenceName = filterPoolRef.getName();
186	filterPoolRef.getReferencedFilterPool().getSystemFilterPoolManager().getName() + "." + //$NON-NLS-1$	182	String managerName = filterPoolRef.getReferencedFilterPoolManagerName();
187	filterPoolRef.getName();	183	String absoluteName = parentAbsoluteName + "." + managerName + "." + referenceName; //$NON-NLS-1$ //$NON-NLS-2$
		184	return absoluteName;
188	}	185	}
189		186
190	/**	187	/**
Lines 202-208 Link Here
202	*/	199	*/
203	public Object getParent(Object element)	200	public Object getParent(Object element)
204	{	201	{
205	ISystemFilterPoolReference fpr = getFilterPoolReference(element);	202	ISystemFilterPoolReference fpr = (ISystemFilterPoolReference)element;
206	return SubSystemHelpers.getParentSubSystem(fpr);	203	return SubSystemHelpers.getParentSubSystem(fpr);
207	}	204	}
208		205
Lines 212-218 Link Here
212	*/	209	*/
213	public Object[] getChildren(IProgressMonitor monitor, IAdaptable element)	210	public Object[] getChildren(IProgressMonitor monitor, IAdaptable element)
214	{	211	{
215	ISystemFilterPoolReference fpRef = getFilterPoolReference(element);	212	ISystemFilterPoolReference fpRef = (ISystemFilterPoolReference)element;
216	ISubSystem ss = getSubSystem(element);	213	ISubSystem ss = getSubSystem(element);
217	return fpRef.getSystemFilterReferences(ss);	214	return fpRef.getSystemFilterReferences(ss);
218	}	215	}
Lines 222-228 Link Here
222	*/	219	*/
223	public boolean hasChildren(IAdaptable element) {	220	public boolean hasChildren(IAdaptable element) {
224	int count = 0;	221	int count = 0;
225	ISystemFilterPoolReference fpRef = getFilterPoolReference(element);	222	ISystemFilterPoolReference fpRef = (ISystemFilterPoolReference)element;
226	if (fpRef != null) {	223	if (fpRef != null) {
227	ISystemFilterPool filterPool = fpRef.getReferencedFilterPool();	224	ISystemFilterPool filterPool = fpRef.getReferencedFilterPool();
228	if (filterPool != null) {	225	if (filterPool != null) {

Lines 44-52 Link Here

(-)UI/org/eclipse/rse/ui/RSEUIPlugin.java (-3 / +3 lines)
44	import org.eclipse.rse.core.model.ISystemRegistry;	44	import org.eclipse.rse.core.model.ISystemRegistry;
45	import org.eclipse.rse.core.subsystems.ISubSystemConfiguration;	45	import org.eclipse.rse.core.subsystems.ISubSystemConfiguration;
46	import org.eclipse.rse.core.subsystems.ISubSystemConfigurationProxy;	46	import org.eclipse.rse.core.subsystems.ISubSystemConfigurationProxy;
		47	import org.eclipse.rse.internal.core.model.SystemProfileManager;
47	import org.eclipse.rse.internal.core.subsystems.SubSystemConfigurationProxy;	48	import org.eclipse.rse.internal.core.subsystems.SubSystemConfigurationProxy;
48	import org.eclipse.rse.internal.core.subsystems.SubSystemConfigurationProxyComparator;	49	import org.eclipse.rse.internal.core.subsystems.SubSystemConfigurationProxyComparator;
49	import org.eclipse.rse.internal.model.SystemProfileManager;
50	import org.eclipse.rse.internal.ui.RSESystemTypeAdapterFactory;	50	import org.eclipse.rse.internal.ui.RSESystemTypeAdapterFactory;
51	import org.eclipse.rse.internal.ui.SystemResources;	51	import org.eclipse.rse.internal.ui.SystemResources;
52	import org.eclipse.rse.internal.ui.actions.SystemDynamicPopupMenuExtensionManager;	52	import org.eclipse.rse.internal.ui.actions.SystemDynamicPopupMenuExtensionManager;
Lines 114-120 Link Here
114	if (systemType != null) {	114	if (systemType != null) {
115	RSESystemTypeAdapter adapter = (RSESystemTypeAdapter)(systemType.getAdapter(IRSESystemType.class));	115	RSESystemTypeAdapter adapter = (RSESystemTypeAdapter)(systemType.getAdapter(IRSESystemType.class));
116	if (adapter != null && adapter.isEnabled(systemType)) {	116	if (adapter != null && adapter.isEnabled(systemType)) {
117	ISystemProfileManager profileManager = SystemProfileManager.getSystemProfileManager();	117	ISystemProfileManager profileManager = SystemProfileManager.getDefault();
118	ISystemProfile profile = profileManager.getDefaultPrivateSystemProfile();	118	ISystemProfile profile = profileManager.getDefaultPrivateSystemProfile();
119	String userName = System.getProperty("user.name"); //$NON-NLS-1$	119	String userName = System.getProperty("user.name"); //$NON-NLS-1$
120	registry.createLocalHost(profile, SystemResources.TERM_LOCAL, userName);	120	registry.createLocalHost(profile, SystemResources.TERM_LOCAL, userName);
Lines 761-767 Link Here
761	*/	761	*/
762	public static ISystemProfileManager getTheSystemProfileManager()	762	public static ISystemProfileManager getTheSystemProfileManager()
763	{	763	{
764	return SystemProfileManager.getSystemProfileManager();	764	return SystemProfileManager.getDefault();
765	}	765	}
766		766
767	/**	767	/**

Added Link Here

(-)UI/org/eclipse/rse/ui/validators/ValidatorFactory.java (+27 lines)
1	package org.eclipse.rse.ui.validators;
2
3	import java.util.Vector;
4
5	import org.eclipse.rse.core.RSECorePlugin;
6	import org.eclipse.rse.core.model.ISystemProfileManager;
7
8	/**
9	* This class constructs validators for various bits of the user interface.
10	*/
11	public class ValidatorFactory {
12
13	/**
14	* Reusable method to return a name validator for renaming a profile.
15	* @param profileName the current profile name on updates. Can be null for new profiles. Used
16	* to remove from the existing name list the current connection.
17	* @return the validator
18	*/
19	public static ISystemValidator getProfileNameValidator(String profileName) {
20	ISystemProfileManager manager = RSECorePlugin.getDefault().getSystemRegistry().getSystemProfileManager();
21	Vector profileNames = manager.getSystemProfileNamesVector();
22	if (profileName != null) profileNames.remove(profileName);
23	ISystemValidator nameValidator = new ValidatorProfileName(profileNames);
24	return nameValidator;
25	}
26
27	}