[cleanup] added some observability to track filter pool reference lifecycle

rse/plugins/org.eclipse.rse.core/src/org/eclipse/rse/internal/references/SystemPersistableReferencedObjectHelper.java

@@ -26,14 +26,16 @@ import org.eclipse.rse.core.references.IRSEBasePersistableReferencedObject;
  * specific object, in memory.
  */
 public class SystemPersistableReferencedObjectHelper extends SystemReferencedObjectHelper implements IRSEBasePersistableReferencedObject {
+
 	private String referenceName;
 
 	/**
 	 * Constructor for SystemPersistableReferencedObjectHelper
+	 * @param parent the SystemPersistableReferencedObject that uses this helper.
 	 * @param referenceName The unique name that can be stored to identify this object.
 	 */
-	protected SystemPersistableReferencedObjectHelper(String referenceName) {
+	protected SystemPersistableReferencedObjectHelper(IRSEBasePersistableReferencedObject parent, String referenceName) {
-		super();
+		super(parent);
 		setReferenceName(referenceName);
 	}
 

rse/plugins/org.eclipse.rse.core/src/org/eclipse/rse/internal/references/SystemReferencedObject.java

@@ -29,19 +29,18 @@ import org.eclipse.rse.core.references.IRSEReferencedObject;
  * <p>
  * These references are not persistent. Persistent references are managed
  * by the subclass SystemPersistableReferencedObject.
- */
+ * <p>
-/** 
+ * SystemFilter is a known concrete subclass.
- * @lastgen class SystemReferencedObjectImpl Impl implements SystemReferencedObject, EObject {}
  */
 public abstract class SystemReferencedObject extends RSEModelObject implements IRSEReferencedObject {
+
 	protected SystemReferencedObjectHelper helper = null;
 
 	/**
 	 * Default constructor. Typically called by EMF factory method.
 	 */
 	protected SystemReferencedObject() {
-		super();
+		helper = new SystemReferencedObjectHelper(this);
-		helper = new SystemReferencedObjectHelper();
 	}
 
 	// ----------------------------------

rse/plugins/org.eclipse.rse.core/src/org/eclipse/rse/internal/references/SystemReferencedObjectHelper.java

@@ -16,10 +16,16 @@
 
 package org.eclipse.rse.internal.references;
 
+import java.text.MessageFormat;
 import java.util.Vector;
 
+import org.eclipse.rse.core.filters.ISystemFilterPool;
+import org.eclipse.rse.core.filters.ISystemFilterPoolReference;
+import org.eclipse.rse.core.filters.ISystemFilterPoolReferenceManagerProvider;
+import org.eclipse.rse.core.model.IHost;
 import org.eclipse.rse.core.references.IRSEBaseReferencedObject;
 import org.eclipse.rse.core.references.IRSEBaseReferencingObject;
+import org.eclipse.rse.core.subsystems.ISubSystem;
 
 /**
  * This is a class that implements all the methods in the IRSEReferencedObject.
@@ -28,31 +34,63 @@ import org.eclipse.rse.core.references.IRSEBaseReferencingObject;
  * always possible, it is not abstract and hence can be leveraged via containment.
  */
 public class SystemReferencedObjectHelper implements IRSEBaseReferencedObject {
+
 	private Vector referencingObjects = new Vector();
+	private IRSEBaseReferencedObject parent = null;
 
 	/**
 	 * Constructor for SystemReferencedObjectHelper
+	 * @param parent the SystemReferencedObject creating this helper
 	 */
-	public SystemReferencedObjectHelper() {
+	public SystemReferencedObjectHelper(IRSEBaseReferencedObject parent) {
-		super();
+		this.parent = parent;
 	}
 
 	/**
 	 * @see IRSEBaseReferencedObject#addReference(IRSEBaseReferencingObject)
 	 */
 	public int addReference(IRSEBaseReferencingObject ref) {
+//		String fromName = getReferencingName(ref);
+//		String toName = getReferencedName();
+//		System.out.println(MessageFormat.format("Adding reference from {0} to {1}", new Object[] {fromName, toName}));
 		referencingObjects.addElement(ref);
 		return referencingObjects.size();
 	}
 
+	private String getReferencedName() {
+		String toName = "unknown";
+		if (parent instanceof ISystemFilterPool) {
+			ISystemFilterPool fp = (ISystemFilterPool) parent;
+			toName = fp.getName();
+		}
+		return toName;
+	}
+	
+	private String getReferencingName(IRSEBaseReferencingObject object) {
+		String fromName = "unknown";
+		if (object instanceof ISystemFilterPoolReference) {
+			ISystemFilterPoolReference fpr = (ISystemFilterPoolReference) object;
+			ISystemFilterPoolReferenceManagerProvider provider = fpr.getProvider();
+			String prefix = "unknown|unknown|unknown";
+			if (provider instanceof ISubSystem) {
+				ISubSystem subsystem = (ISubSystem) provider;
+				IHost host = subsystem.getHost();
+				prefix = host.getAliasName() + "|" + subsystem.getName();
+				fromName = prefix + fpr.getName();
+			}
+		}
+		return fromName;
+	}
+
 	/**
 	 * @see IRSEBaseReferencedObject#removeReference(IRSEBaseReferencingObject)
 	 */
 	public int removeReference(IRSEBaseReferencingObject ref) {
-		int before = referencingObjects.size();
+//		String fromName = getReferencingName(ref);
-		referencingObjects.removeElement(ref);
+//		String toName = getReferencedName();
-		int after = referencingObjects.size();
+//		System.out.println(MessageFormat.format("Removing reference from {0} to {1}", new Object[] {fromName, toName}));
-		assertThis((after == (before - 1)), "removeReference failed for " + ref); //$NON-NLS-1$
+		boolean found = referencingObjects.removeElement(ref);
+		assertThis(!found, "removeReference failed for " + ref); //$NON-NLS-1$
 		return referencingObjects.size();
 	}
 
@@ -67,7 +105,12 @@ public class SystemReferencedObjectHelper implements IRSEBaseReferencedObject {
 	 * Clear the list of referenced objects.
 	 */
 	public void removeAllReferences() {
-		referencingObjects.removeAllElements();
+		IRSEBaseReferencingObject[] references = getReferencingObjects();
+		for (int i = 0; i < references.length; i++) {
+			IRSEBaseReferencingObject reference = references[i];
+			removeReference(reference);
+		}
+//		referencingObjects.removeAllElements();
 	}
 
 	/**
@@ -75,8 +118,7 @@ public class SystemReferencedObjectHelper implements IRSEBaseReferencedObject {
 	 */
 	public IRSEBaseReferencingObject[] getReferencingObjects() {
 		IRSEBaseReferencingObject[] references = new IRSEBaseReferencingObject[referencingObjects.size()];
-		for (int idx = 0; idx < referencingObjects.size(); idx++)
+		referencingObjects.toArray(references);
-			references[idx] = (IRSEBaseReferencingObject) referencingObjects.elementAt(idx);
 		return references;
 	}
 
@@ -87,7 +129,7 @@ public class SystemReferencedObjectHelper implements IRSEBaseReferencedObject {
 	 * @param msg the message printed on System.out
 	 */
 	protected void assertThis(boolean assertion, String msg) {
-		if (!assertion) System.out.println("ASSERTION FAILED IN SystemReferencedObject: " + msg); //$NON-NLS-1$
+//		if (!assertion) System.out.println("ASSERTION FAILED IN SystemReferencedObject: " + msg); //$NON-NLS-1$
 	}
 
 }

rse/plugins/org.eclipse.rse.ui/filters/org/eclipse/rse/internal/filters/SystemFilterString.java

@@ -92,7 +92,7 @@ public class SystemFilterString extends RSEModelObject implements ISystemFilterS
 	protected SystemFilterString() 
 	{
 		super();
-		helper = new SystemReferencedObjectHelper();
+		helper = new SystemReferencedObjectHelper(this);
 	}
 	/**
 	 * This is the method required by the IAdaptable interface.