mirrors/cdt
1
0
Fork 0
mirror of https://github.com/eclipse-cdt/cdt synced 2025-07-10 18:45:26 +02:00
Code Issues Wiki Activity

Apply patch for bug 162177 - Rename ISystem -> IConnectorService in comments

Browse source
This commit is contained in:
Martin Oberhuber 2006-11-08 16:27:59 +00:00
parent e7b4211807
commit 1dda85ab0d
8 changed files with 42 additions and 42 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
rse/plugins/org.eclipse.rse.connectorservice.dstore/src/org/eclipse/rse/connectorservice/dstore/DStoreConnectorServiceManager.java
View file

@ -23,11 +23,11 @@ import org.eclipse.rse.core.subsystems.ISubSystem;
/** /**
* ISystem manager class. * IConnectorService manager class.
* There should be only one of these instantiated. * There should be only one of these instantiated.
* Use getTheUniversalSystemManager to get that singleton. * Use getTheUniversalSystemManager to get that singleton.
* <p> * <p>
* The job of this manager is to manage and return ISystem objects. * The job of this manager is to manage and return IConnectorService objects.
* It ensures there is only ever one per unique SystemConnection, * It ensures there is only ever one per unique SystemConnection,
* so that both the file and cmd subsystems can share the same system object. * so that both the file and cmd subsystems can share the same system object.
*/ */
@ -67,7 +67,7 @@ public class DStoreConnectorServiceManager extends AbstractConnectorServiceManag
// ------------------------------------- // -------------------------------------
/** /**
* Return the actual ISystem object. We return an instance of UniversalSystem. * Return the actual IConnectorService object. We return an instance of UniversalSystem.
*/ */
public IConnectorService createConnectorService(IHost host) public IConnectorService createConnectorService(IHost host)
{ {
@ -77,13 +77,13 @@ public class DStoreConnectorServiceManager extends AbstractConnectorServiceManag
/** /**
* For all subsystems in a particular SystemConnection, we need to know which * For all subsystems in a particular SystemConnection, we need to know which
* ones are to share a single ISystem object. To do this, we need a key which * ones are to share a single IConnectorService object. To do this, we need a key which
* is canonical for all subsystems in a given connection. This can be anything, * is canonical for all subsystems in a given connection. This can be anything,
* but is typically a unique interface that all subsystems supported a shared * but is typically a unique interface that all subsystems supported a shared
* ISystem object implement. * IConnectorService object implement.
* <p> * <p>
* Whatever is returned from here is used as the key into a hashtable to find the * Whatever is returned from here is used as the key into a hashtable to find the
* singleton ISystem object in getSystemObject. * singleton IConnectorService object in getSystemObject.
* <p> * <p>
* @return IUniversalSubSystem.class * @return IUniversalSubSystem.class
*/ */
@ -92,7 +92,7 @@ public class DStoreConnectorServiceManager extends AbstractConnectorServiceManag
return IUniversalDStoreSubSystem.class; return IUniversalDStoreSubSystem.class;
} }
/** /**
* Given another subsystem, return true if that subsystem shares a single ISystem object * Given another subsystem, return true if that subsystem shares a single IConnectorService object
* with this one. You must override this to return true if you recognize that subsystem * with this one. You must override this to return true if you recognize that subsystem
* as one of your own. You are guaranteed the other subsystem will be from the same * as one of your own. You are guaranteed the other subsystem will be from the same
* SystemConnection as this one. * SystemConnection as this one.

2
rse/plugins/org.eclipse.rse.connectorservice.dstore/src/org/eclipse/rse/connectorservice/dstore/util/ConnectionStatusListener.java
View file

@ -174,7 +174,7 @@ public class ConnectionStatusListener implements IDomainListener, IRunnableWithP
} }
/** /**
* Callback method for the ISystem to determine if the connection is down. This is * Callback method for the IConnectorService to determine if the connection is down. This is
* called by the disconnect method to determine if we can do saves or not. * called by the disconnect method to determine if we can do saves or not.
*/ */
public boolean isConnectionDown() public boolean isConnectionDown()

2
rse/plugins/org.eclipse.rse.connectorservice.dstore/src/org/eclipse/rse/connectorservice/dstore/util/ICommunicationsDiagnostic.java
View file

@ -35,7 +35,7 @@ public interface ICommunicationsDiagnostic extends Runnable {
* String id: assign an ID for this diagnostic instance * String id: assign an ID for this diagnostic instance
* boolean quiet: true if user to be prompted for a dialog * boolean quiet: true if user to be prompted for a dialog
* String server: the host network name * String server: the host network name
* ISystem system: the connection to be investigated * IConnectorService system: the connection to be investigated
* String str1, str2, str3: optional strings * String str1, str2, str3: optional strings
*/ */
public void setUp(String id, boolean quiet, String server, IConnectorService system, String str1, String str2, String str3); public void setUp(String id, boolean quiet, String server, IConnectorService system, String str1, String str2, String str3);

14
rse/plugins/org.eclipse.rse.connectorservice.local/src/org/eclipse/rse/connectorservice/local/LocalConnectorServiceManager.java
View file

@ -23,11 +23,11 @@ import org.eclipse.rse.core.subsystems.ISubSystem;
/** /**
* ISystem manager class. * IConnectorService manager class.
* There should be only one of these instantiated. * There should be only one of these instantiated.
* Use getTheLocalSystemManager to get that singleton. * Use getTheLocalSystemManager to get that singleton.
* <p> * <p>
* The job of this manager is to manage and return ISystem objects. * The job of this manager is to manage and return IConnectorService objects.
* It ensures there is only ever one per unique SystemConnection, * It ensures there is only ever one per unique SystemConnection,
* so that both the file and cmd subsystems can share the same system object. * so that both the file and cmd subsystems can share the same system object.
*/ */
@ -69,7 +69,7 @@ public class LocalConnectorServiceManager extends AbstractConnectorServiceManage
/** /**
* Return the actual ISystem object. * Return the actual IConnectorService object.
*/ */
public IConnectorService createConnectorService(IHost host) public IConnectorService createConnectorService(IHost host)
{ {
@ -79,13 +79,13 @@ public class LocalConnectorServiceManager extends AbstractConnectorServiceManage
/** /**
* For all subsystems in a particular SystemConnection, we need to know which * For all subsystems in a particular SystemConnection, we need to know which
* ones are to share a single ISystem object. To do this, we need a key which * ones are to share a single IConnectorService object. To do this, we need a key which
* is canonical for all subsystems in a given connection. This can be anything, * is canonical for all subsystems in a given connection. This can be anything,
* but is typically a unique interface that all subsystems supported a shared * but is typically a unique interface that all subsystems supported a shared
* ISystem object implement. * IConnectorService object implement.
* <p> * <p>
* Whatever is returned from here is used as the key into a hashtable to find the * Whatever is returned from here is used as the key into a hashtable to find the
* singleton ISystem object in getSystemObject. * singleton IConnectorService object in getSystemObject.
* <p> * <p>
* @return ILocalSubSystem.class * @return ILocalSubSystem.class
*/ */
@ -94,7 +94,7 @@ public class LocalConnectorServiceManager extends AbstractConnectorServiceManage
return ILocalSubSystem.class; return ILocalSubSystem.class;
} }
/** /**
* Given another subsystem, return true if that subsystem shares a single ISystem object * Given another subsystem, return true if that subsystem shares a single IConnectorService object
* with this one. You must override this to return true if you recognize that subsystem * with this one. You must override this to return true if you recognize that subsystem
* as one of your own. You are guaranteed the other subsystem will be from the same * as one of your own. You are guaranteed the other subsystem will be from the same
* SystemConnection as this one. * SystemConnection as this one.

4
rse/plugins/org.eclipse.rse.core/src/org/eclipse/rse/core/subsystems/IRemoteServerLauncher.java
View file

@ -22,7 +22,7 @@ package org.eclipse.rse.core.subsystems;
* <p> * <p>
* A server launcher is responsible for starting the server-side code needed for this client subsystem to * A server launcher is responsible for starting the server-side code needed for this client subsystem to
* access remote resources on the remote system. It starts the server half of the client/server code needed * access remote resources on the remote system. It starts the server half of the client/server code needed
* for this subsystem. It is consulted in the default implementation of connect() in ISystem, and the * for this subsystem. It is consulted in the default implementation of connect() in IConnectorService, and the
* manages the properties in the Remote Server Launcher property page. * manages the properties in the Remote Server Launcher property page.
* <p> * <p>
* The following features are supported: * The following features are supported:
@ -174,7 +174,7 @@ public interface IRemoteServerLauncher extends IServerLauncherProperties{
* You normally do not call this! Rather, your subsystem factory class will override * You normally do not call this! Rather, your subsystem factory class will override
* {@link org.eclipse.rse.core.subsystems.SubSystemConfiguration#supportsServerLaunchType(ServerLaunchType)}. * {@link org.eclipse.rse.core.subsystems.SubSystemConfiguration#supportsServerLaunchType(ServerLaunchType)}.
* However, this method is needed by ISVs that re-use IBM-supplied subsystem factories, * However, this method is needed by ISVs that re-use IBM-supplied subsystem factories,
* and merely supply their own ISystem object via the "systemClass" attribute of the * and merely supply their own IConnectorService object via the "systemClass" attribute of the
* subsystemConfigurations extension point. They don't call this method directly actually, but * subsystemConfigurations extension point. They don't call this method directly actually, but
* rather {@link AbstractConnectorService#enableServerLaunchType(SubSystem, ServerLaunchType, boolean)}, * rather {@link AbstractConnectorService#enableServerLaunchType(SubSystem, ServerLaunchType, boolean)},
* which in turn calls this. * which in turn calls this.

10
rse/plugins/org.eclipse.rse.core/src/org/eclipse/rse/core/subsystems/ISubSystem.java
View file

@ -74,21 +74,21 @@ public interface ISubSystem extends ISystemFilterPoolReferenceManagerProvider, I
public IHost getHost(); public IHost getHost();
/** /**
* Called on each subsystem associated with a particular ISystem after it connects * Called on each subsystem associated with a particular IConnectorService after it connects
*/ */
public void initializeSubSystem(IProgressMonitor monitor); public void initializeSubSystem(IProgressMonitor monitor);
/** /**
* Called on each subsystem associated with a particular ISystem after it disconnects * Called on each subsystem associated with a particular IConnectorService after it disconnects
*/ */
public void uninitializeSubSystem(IProgressMonitor monitor); public void uninitializeSubSystem(IProgressMonitor monitor);
/** /**
* @return true if this subsystem's properties should take precedence over other subsystems that share the same ISystem * @return true if this subsystem's properties should take precedence over other subsystems that share the same IConnectorService
*/ */
public boolean isPrimarySubSystem(); public boolean isPrimarySubSystem();
/** /**
* Return the primary subsystem associated with this subsystem's ISystem * Return the primary subsystem associated with this subsystem's IConnectorService
*/ */
public ISubSystem getPrimarySubSystem(); public ISubSystem getPrimarySubSystem();
@ -301,7 +301,7 @@ public interface ISubSystem extends ISystemFilterPoolReferenceManagerProvider, I
// The following methods relate to the live connection // The following methods relate to the live connection
// --------------------------------------------------- // ---------------------------------------------------
/** /**
* Return the ISystem object that represents the live connection for this system. * Return the IConnectorService object that represents the live connection for this system.
*/ */
public IConnectorService getConnectorService(); public IConnectorService getConnectorService();

14
rse/plugins/org.eclipse.rse.subsystems.files.ftp/src/org/eclipse/rse/subsystems/files/ftp/connectorservice/FTPConnectorServiceManager.java
View file

@ -25,9 +25,9 @@ import org.eclipse.rse.core.subsystems.ISubSystem;
/** /**
* ISystem manager class. * IConnectorService manager class.
* There should be only one of these instantiated. * There should be only one of these instantiated.
* The job of this manager is to manage and return ISystem objects. * The job of this manager is to manage and return IConnectorService objects.
* It ensures there is only ever one per unique SystemConnection, * It ensures there is only ever one per unique SystemConnection,
* so that both the file and cmd subsystems can share the same system object. * so that both the file and cmd subsystems can share the same system object.
*/ */
@ -67,7 +67,7 @@ public class FTPConnectorServiceManager extends AbstractConnectorServiceManager
// ------------------------------------- // -------------------------------------
/** /**
* Return the actual ISystem object. We return an instance of UniversalSystem. * Return the actual IConnectorService object. We return an instance of UniversalSystem.
*/ */
public IConnectorService createConnectorService(IHost host) public IConnectorService createConnectorService(IHost host)
{ {
@ -76,20 +76,20 @@ public class FTPConnectorServiceManager extends AbstractConnectorServiceManager
/** /**
* For all subsystems in a particular SystemConnection, we need to know which * For all subsystems in a particular SystemConnection, we need to know which
* ones are to share a single ISystem object. To do this, we need a key which * ones are to share a single IConnectorService object. To do this, we need a key which
* is canonical for all subsystems in a given connection. This can be anything, * is canonical for all subsystems in a given connection. This can be anything,
* but is typically a unique interface that all subsystems supported a shared * but is typically a unique interface that all subsystems supported a shared
* ISystem object implement. * IConnectorService object implement.
* <p> * <p>
* Whatever is returned from here is used as the key into a hashtable to find the * Whatever is returned from here is used as the key into a hashtable to find the
* singleton ISystem object in getSystemObject. * singleton IConnectorService object in getSystemObject.
*/ */
public Class getSubSystemCommonInterface(ISubSystem subsystem) public Class getSubSystemCommonInterface(ISubSystem subsystem)
{ {
return IFTPSubSystem.class; return IFTPSubSystem.class;
} }
/** /**
* Given another subsystem, return true if that subsystem shares a single ISystem object * Given another subsystem, return true if that subsystem shares a single IConnectorService object
* with this one. You must override this to return true if you recognize that subsystem * with this one. You must override this to return true if you recognize that subsystem
* as one of your own. You are guaranteed the other subsystem will be from the same * as one of your own. You are guaranteed the other subsystem will be from the same
* SystemConnection as this one. * SystemConnection as this one.

24
rse/plugins/org.eclipse.rse.ui/subsystems/org/eclipse/rse/core/subsystems/AbstractConnectorServiceManager.java
View file

@ -27,13 +27,13 @@ import org.eclipse.swt.widgets.Shell;
/** /**
* This class is only needed if you need/want to support multiple * This class is only needed if you need/want to support multiple
* subsystems and want them to share a single {@link org.eclipse.rse.core.subsystems.IConnectorService ISystem} object per * subsystems and want them to share a single {@link org.eclipse.rse.core.subsystems.IConnectorService IConnectorService} object per
* system connection. This is the base system manager implementation * system connection. This is the base system manager implementation
* that returns the same ISystem object for all subsystems in the * that returns the same IConnectorService object for all subsystems in the
* same system connection, which implement a given interface. * same system connection, which implement a given interface.
* <p> * <p>
* For this to work all your subsystem classes that wish to share the * For this to work all your subsystem classes that wish to share the
* same ISystem object must implement a common interface of your choosing. * same IConnectorService object must implement a common interface of your choosing.
* <p> * <p>
* Another benefit of using this class or a subclass of it, is that whenever * Another benefit of using this class or a subclass of it, is that whenever
* the user changes the core properties for a single subsystem (port, userId) * the user changes the core properties for a single subsystem (port, userId)
@ -41,8 +41,8 @@ import org.eclipse.swt.widgets.Shell;
* connection which share that same common interface. This means the user can change * connection which share that same common interface. This means the user can change
* these properties in any one subsystem, and they are changed in all related * these properties in any one subsystem, and they are changed in all related
* subsystems magically. This is necessary because while these properties are * subsystems magically. This is necessary because while these properties are
* persisted in the subsystem object, they really belong to the ISystem object, * persisted in the subsystem object, they really belong to the IConnectorService object,
* so when multiple subsystems share an ISystem object, changes to these properties * so when multiple subsystems share an IConnectorService object, changes to these properties
* in one subsystem need to be cascaded to the other subsystems. * in one subsystem need to be cascaded to the other subsystems.
* <p> * <p>
* Because you only need a singleton of these class, the constructor is protected. * Because you only need a singleton of these class, the constructor is protected.
@ -64,7 +64,7 @@ public abstract class AbstractConnectorServiceManager implements IConnectorServi
// we maintain a hashtable of hashtables. The first is keyed by SystemConnection. // we maintain a hashtable of hashtables. The first is keyed by SystemConnection.
// The hashtable for each connection, maintains a list of ISystem objects keyed by // The hashtable for each connection, maintains a list of IConnectorService objects keyed by
// a unique interface class object supplied by the subclasses. // a unique interface class object supplied by the subclasses.
private Hashtable systemConnectionRegistry = new Hashtable(); private Hashtable systemConnectionRegistry = new Hashtable();
@ -143,12 +143,12 @@ public abstract class AbstractConnectorServiceManager implements IConnectorServi
} }
/** /**
* Return the actual ISystem object. Must be overridden by subclass. * Return the actual IConnectorService object. Must be overridden by subclass.
*/ */
public abstract IConnectorService createConnectorService(IHost host); public abstract IConnectorService createConnectorService(IHost host);
/** /**
* Given another subsystem, return true if that subsystem shares a single ISystem object * Given another subsystem, return true if that subsystem shares a single IConnectorService object
* with this one. You must override this to return true if you recognize that subsystem * with this one. You must override this to return true if you recognize that subsystem
* as one of your own. You are guaranteed the other subsystem will be from the same * as one of your own. You are guaranteed the other subsystem will be from the same
* SystemConnection as this one. * SystemConnection as this one.
@ -164,13 +164,13 @@ public abstract class AbstractConnectorServiceManager implements IConnectorServi
/** /**
* For all subsystems in a particular SystemConnection, we need to know which * For all subsystems in a particular SystemConnection, we need to know which
* ones are to share a single ISystem object. To do this, we need a key which * ones are to share a single IConnectorService object. To do this, we need a key which
* is canonical for all subsystems in a given connection. This can be anything, * is canonical for all subsystems in a given connection. This can be anything,
* but is typically a unique interface that all subsystems supported a shared * but is typically a unique interface that all subsystems supported a shared
* ISystem object implement. * IConnectorService object implement.
* <p> * <p>
* Whatever is returned from here is used as the key into a hashtable to find the * Whatever is returned from here is used as the key into a hashtable to find the
* singleton ISystem object in getSystemObject. * singleton IConnectorService object in getSystemObject.
* <p> * <p>
* @param subsystem - rarely used, but if you support multiple common interfaces then this will help you * @param subsystem - rarely used, but if you support multiple common interfaces then this will help you
* decide which one to return. * decide which one to return.
@ -182,7 +182,7 @@ public abstract class AbstractConnectorServiceManager implements IConnectorServi
* <i>Internal use. Fully implemented, no need to override.</i><br> * <i>Internal use. Fully implemented, no need to override.</i><br>
* Updates user-editable attributes of an existing subsystem instance. * Updates user-editable attributes of an existing subsystem instance.
* The goal of this method is to intercept the request and forward it on to all our * The goal of this method is to intercept the request and forward it on to all our
* subsystems in this SystemConnection, that share a single ISystem, * subsystems in this SystemConnection, that share a single IConnectorService,
* so we keep them all in synch in terms of these two properties used * so we keep them all in synch in terms of these two properties used
* by all ISystems. * by all ISystems.
* @see org.eclipse.rse.core.subsystems.SubSystemConfiguration#updateSubSystem(Shell,ISubSystem,boolean,String,boolean,Integer) * @see org.eclipse.rse.core.subsystems.SubSystemConfiguration#updateSubSystem(Shell,ISubSystem,boolean,String,boolean,Integer)