Java ServerConfiguration类代码示例

import com.intellij.remoteServer.configuration.ServerConfiguration; //导入依赖的package包/类
private static <C extends ServerConfiguration> RemoteServerConfigurable createConfigurable(RemoteServer<C> server, C configuration) {
  try {
    return server.getType().createServerConfigurable(configuration);
  }
  catch (UnsupportedOperationException e) {
    return new DelegatingRemoteServerConfigurable(server.getType().createConfigurable(configuration));
  }
}
 

import com.intellij.remoteServer.configuration.ServerConfiguration; //导入依赖的package包/类
@Override
public <C extends ServerConfiguration> List<RemoteServer<C>> getServers(@NotNull ServerType<C> type) {
  List<RemoteServer<C>> servers = new ArrayList<RemoteServer<C>>();
  for (RemoteServer<?> server : myServers) {
    if (server.getType().equals(type)) {
      servers.add((RemoteServer<C>)server);
    }
  }
  return servers;
}
 

import com.intellij.remoteServer.configuration.ServerConfiguration; //导入依赖的package包/类
@Nullable
@Override
public <C extends ServerConfiguration> RemoteServer<C> findByName(@NotNull String name, @NotNull ServerType<C> type) {
  for (RemoteServer<?> server : myServers) {
    if (server.getType().equals(type) && server.getName().equals(name)) {
      return (RemoteServer<C>)server;
    }
  }
  return null;
}
 

import com.intellij.remoteServer.configuration.ServerConfiguration; //导入依赖的package包/类
@NotNull
@Override
public <C extends ServerConfiguration> ServerConnection getOrCreateConnection(@NotNull RemoteServer<C> server) {
  ApplicationManager.getApplication().assertIsDispatchThread();
  ServerConnection connection = myConnections.get(server);
  if (connection == null) {
    connection = doCreateConnection(server, this);
    myConnections.put(server, connection);
    myEventDispatcher.fireConnectionCreated(connection);
  }
  return connection;
}
 

import com.intellij.remoteServer.configuration.ServerConfiguration; //导入依赖的package包/类
public <C extends ServerConfiguration> RemoteServerConfigurable(RemoteServer<C> server, Runnable treeUpdater, boolean isNew) {
  super(true, treeUpdater);
  myServer = server;
  myNew = isNew;
  myServerName = myServer.getName();
  C c = server.getConfiguration();
  myConfigurable = server.getType().createConfigurable(c);
}
 

import com.intellij.remoteServer.configuration.ServerConfiguration; //导入依赖的package包/类
@NotNull
@Override
public <C extends ServerConfiguration> ServerConnection getOrCreateConnection(@NotNull RemoteServer<C> server) {
  ApplicationManager.getApplication().assertIsDispatchThread();
  ServerConnection connection = myConnections.get(server);
  if (connection == null) {
    ServerTaskExecutorImpl executor = new ServerTaskExecutorImpl();
    connection = new ServerConnectionImpl(server, server.getType().createConnector(server.getConfiguration(), executor));
    myConnections.put(server, connection);
  }
  return connection;
}
 

import com.intellij.remoteServer.configuration.ServerConfiguration; //导入依赖的package包/类
@Override
public <C extends ServerConfiguration> List<RemoteServer<C>> getServers(@Nonnull ServerType<C> type) {
  List<RemoteServer<C>> servers = new ArrayList<RemoteServer<C>>();
  for (RemoteServer<?> server : myServers) {
    if (server.getType().equals(type)) {
      servers.add((RemoteServer<C>)server);
    }
  }
  return servers;
}
 

import com.intellij.remoteServer.configuration.ServerConfiguration; //导入依赖的package包/类
@javax.annotation.Nullable
@Override
public <C extends ServerConfiguration> RemoteServer<C> findByName(@Nonnull String name, @Nonnull ServerType<C> type) {
  for (RemoteServer<?> server : myServers) {
    if (server.getType().equals(type) && server.getName().equals(name)) {
      return (RemoteServer<C>)server;
    }
  }
  return null;
}
 

import com.intellij.remoteServer.configuration.ServerConfiguration; //导入依赖的package包/类
@Nonnull
@Override
public <C extends ServerConfiguration> ServerConnection getOrCreateConnection(@Nonnull RemoteServer<C> server) {
  ApplicationManager.getApplication().assertIsDispatchThread();
  ServerConnection connection = myConnections.get(server);
  if (connection == null) {
    ServerTaskExecutorImpl executor = new ServerTaskExecutorImpl();
    connection = new ServerConnectionImpl(server, server.getType().createConnector(server.getConfiguration(), executor), this);
    myConnections.put(server, connection);
    myEventDispatcher.fireConnectionCreated(connection);
  }
  return connection;
}
 

import com.intellij.remoteServer.configuration.ServerConfiguration; //导入依赖的package包/类
@NotNull
public abstract <C extends ServerConfiguration> ServerConnection getOrCreateConnection(@NotNull RemoteServer<C> server);
 

import com.intellij.remoteServer.configuration.ServerConfiguration; //导入依赖的package包/类
@Nullable
public abstract <C extends ServerConfiguration> ServerConnection getConnection(@NotNull RemoteServer<C> server);
 

import com.intellij.remoteServer.configuration.ServerConfiguration; //导入依赖的package包/类
@NotNull
public <C extends ServerConfiguration> ServerConnection createTemporaryConnection(@NotNull RemoteServer<C> server) {
  throw new UnsupportedOperationException();
}
 

import com.intellij.remoteServer.configuration.ServerConfiguration; //导入依赖的package包/类
public static <SC extends ServerConfiguration, DC extends DeploymentConfiguration>
DeployToServerRunConfiguration<SC, DC> createRunConfiguration(RemoteServer<SC> account, Module module, DC deploymentConfiguration) {
  final ModulePointer modulePointer = ModulePointerManager.getInstance(module.getProject()).create(module);
  DeploymentSource deploymentSource = new ModuleDeploymentSourceImpl(modulePointer);
  return createRunConfiguration(account, module, deploymentSource, deploymentConfiguration);
}
 

import com.intellij.remoteServer.configuration.ServerConfiguration; //导入依赖的package包/类
public <C extends ServerConfiguration> void setupUploadLabel(HyperlinkLabel label,
                                                             UnnamedConfigurable serverConfigurable,
                                                             C serverConfiguration,
                                                             ServerType<C> serverType) {
  new ConfigurableHandler<C>(label, serverConfigurable, serverConfiguration, serverType);
}
 

import com.intellij.remoteServer.configuration.ServerConfiguration; //导入依赖的package包/类
public <C extends ServerConfiguration> SingleRemoteServerConfigurable(RemoteServer<C> server, Runnable treeUpdater, boolean isNew) {
  super(true, treeUpdater);
  myServer = server;
  myNew = isNew;
  myServerName = myServer.getName();
  C configuration = server.getConfiguration();
  C innerConfiguration = XmlSerializerUtil.createCopy(configuration);
  myInnerServer = new RemoteServerImpl<C>("<temp inner server>", server.getType(), innerConfiguration);
  myInnerApplied = false;
  myUncheckedApply = false;

  myConfigurable = createConfigurable(server, innerConfiguration);

  myConnected = false;
  myRunner = new DelayedRunner(myMainPanel) {

    @Override
    protected boolean wasChanged() {
      if (!myConfigurable.canCheckConnection()) return false;

      boolean modified = myConfigurable.isModified();
      boolean result = modified || myUncheckedApply;
      if (result) {
        myUncheckedApply = false;

        setConnectionStatus(false, false, "");
        myConnectionTester = null;

        if (modified) {
          try {
            myConfigurable.apply();
            myInnerApplied = true;
          }
          catch (ConfigurationException e) {
            setConnectionStatus(true, false, e.getMessage());
          }
        }
      }
      return result;
    }

    @Override
    protected void run() {
      setConnectionStatus(false, false, "Connecting...");

      myConnectionTester = new ConnectionTester();
      myConnectionTester.testConnection();
    }
  };
}