mirrors/cdt
1
0
Fork 0
mirror of https://github.com/eclipse-cdt/cdt synced 2025-07-04 23:55: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.
* Use getTheUniversalSystemManager to get that singleton.
* <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,
* 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)
{
@ -77,13 +77,13 @@ public class DStoreConnectorServiceManager extends AbstractConnectorServiceManag
/**
* 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,
* but is typically a unique interface that all subsystems supported a shared
* ISystem object implement.
* IConnectorService object implement.
* <p>
* 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>
* @return IUniversalSubSystem.class
*/
@ -92,7 +92,7 @@ public class DStoreConnectorServiceManager extends AbstractConnectorServiceManag
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
* as one of your own. You are guaranteed the other subsystem will be from the same
* 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.
*/
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
* boolean quiet: true if user to be prompted for a dialog
* 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
*/
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.
* Use getTheLocalSystemManager to get that singleton.
* <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,
* 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)
{
@ -79,13 +79,13 @@ public class LocalConnectorServiceManager extends AbstractConnectorServiceManage
/**
* 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,
* but is typically a unique interface that all subsystems supported a shared
* ISystem object implement.
* IConnectorService object implement.
* <p>
* 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>
* @return ILocalSubSystem.class
*/
@ -94,7 +94,7 @@ public class LocalConnectorServiceManager extends AbstractConnectorServiceManage
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
* as one of your own. You are guaranteed the other subsystem will be from the same
* 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>
* 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
* 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.
* <p>
* 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
* {@link org.eclipse.rse.core.subsystems.SubSystemConfiguration#supportsServerLaunchType(ServerLaunchType)}.
* 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
* rather {@link AbstractConnectorService#enableServerLaunchType(SubSystem, ServerLaunchType, boolean)},
* 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();
/**
* 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);
/**
* 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);
/**
* @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();
/**
* Return the primary subsystem associated with this subsystem's ISystem
* Return the primary subsystem associated with this subsystem's IConnectorService
*/
public ISubSystem getPrimarySubSystem();
@ -301,7 +301,7 @@ public interface ISubSystem extends ISystemFilterPoolReferenceManagerProvider, I
// 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();

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.
* 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,
* 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)
{
@ -76,20 +76,20 @@ public class FTPConnectorServiceManager extends AbstractConnectorServiceManager
/**
* 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,
* but is typically a unique interface that all subsystems supported a shared
* ISystem object implement.
* IConnectorService object implement.
* <p>
* 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)
{
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
* as one of your own. You are guaranteed the other subsystem will be from the same
* 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
* 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
* 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.
* <p>
* 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>
* 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)
@ -41,8 +41,8 @@ import org.eclipse.swt.widgets.Shell;
* 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
* subsystems magically. This is necessary because while these properties are
* persisted in the subsystem object, they really belong to the ISystem object,
* so when multiple subsystems share an ISystem object, changes to these properties
* persisted in the subsystem object, they really belong to the IConnectorService object,
* so when multiple subsystems share an IConnectorService object, changes to these properties
* in one subsystem need to be cascaded to the other subsystems.
* <p>
* 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.
// 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.
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);
/**
* 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
* as one of your own. You are guaranteed the other subsystem will be from the same
* 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
* 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,
* but is typically a unique interface that all subsystems supported a shared
* ISystem object implement.
* IConnectorService object implement.
* <p>
* 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>
* @param subsystem - rarely used, but if you support multiple common interfaces then this will help you
* 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>
* 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
* 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
* by all ISystems.
* @see org.eclipse.rse.core.subsystems.SubSystemConfiguration#updateSubSystem(Shell,ISubSystem,boolean,String,boolean,Integer)