Java JavaCommandLineState类代码示例

import com.intellij.execution.configurations.JavaCommandLineState; //导入依赖的package包/类
@Override
public RunProfileState getState(@NotNull final Executor executor, @NotNull final ExecutionEnvironment env) throws ExecutionException
{
	final JavaCommandLineState state = new JavaCommandLineState(env)
	{
		@Override
		protected OwnJavaParameters createJavaParameters()
		{
			return myParameters;
		}
	};
	final TextConsoleBuilder builder = TextConsoleBuilderFactory.getInstance().createBuilder(myProject);
	if(myFilters != null)
	{
		builder.filters(myFilters);
	}
	state.setConsoleBuilder(builder);
	return state;
}
 

import com.intellij.execution.configurations.JavaCommandLineState; //导入依赖的package包/类
/**
 * Plugin jar has been previously created via blaze build. This method: - copies jar to sandbox
 * environment - cracks open jar and finds plugin.xml (with ID, etc., needed for JVM args) - sets
 * up the SDK, etc. (use project SDK?) - sets up the JVM, and returns a JavaCommandLineState
 */
@Nullable
@Override
public RunProfileState getState(Executor executor, ExecutionEnvironment env)
    throws ExecutionException {
  final Sdk ideaJdk = pluginSdk;
  if (!IdeaJdkHelper.isIdeaJdk(ideaJdk)) {
    throw new ExecutionException("Choose an IntelliJ Platform Plugin SDK");
  }
  String sandboxHome = IdeaJdkHelper.getSandboxHome(ideaJdk);
  if (sandboxHome == null) {
    throw new ExecutionException("No sandbox specified for IntelliJ Platform Plugin SDK");
  }

  try {
    sandboxHome = new File(sandboxHome).getCanonicalPath();
  } catch (IOException e) {
    throw new ExecutionException("No sandbox specified for IntelliJ Platform Plugin SDK");
  }
  String buildNumber = IdeaJdkHelper.getBuildNumber(ideaJdk);
  final BlazeIntellijPluginDeployer deployer =
      new BlazeIntellijPluginDeployer(sandboxHome, buildNumber, getTarget());
  env.putUserData(BlazeIntellijPluginDeployer.USER_DATA_KEY, deployer);

  // copy license from running instance of idea
  IdeaJdkHelper.copyIDEALicense(sandboxHome);

  return new JavaCommandLineState(env) {
    @Override
    protected JavaParameters createJavaParameters() throws ExecutionException {
      List<String> pluginIds = deployer.deployNonBlocking();

      final JavaParameters params = new JavaParameters();

      ParametersList vm = params.getVMParametersList();

      fillParameterList(vm, vmParameters);
      fillParameterList(params.getProgramParametersList(), programParameters);

      IntellijWithPluginClasspathHelper.addRequiredVmParams(params, ideaJdk);

      vm.defineProperty(
          JetBrainsProtocolHandler.REQUIRED_PLUGINS_KEY, Joiner.on(',').join(pluginIds));

      if (!vm.hasProperty(PlatformUtils.PLATFORM_PREFIX_KEY) && buildNumber != null) {
        String prefix = IdeaJdkHelper.getPlatformPrefix(buildNumber);
        if (prefix != null) {
          vm.defineProperty(PlatformUtils.PLATFORM_PREFIX_KEY, prefix);
        }
      }
      return params;
    }

    @Override
    protected OSProcessHandler startProcess() throws ExecutionException {
      deployer.blockUntilDeployComplete();
      final OSProcessHandler handler = super.startProcess();
      handler.addProcessListener(
          new ProcessAdapter() {
            @Override
            public void processTerminated(ProcessEvent event) {
              deployer.deleteDeployment();
            }
          });
      return handler;
    }
  };
}
 

import com.intellij.execution.configurations.JavaCommandLineState; //导入依赖的package包/类
protected RunContentDescriptor doExecute(@NotNull RunProfileState state, @NotNull ExecutionEnvironment env) throws ExecutionException
{
	FileDocumentManager.getInstance().saveAllDocuments();

	ExecutionResult executionResult;
	boolean shouldAddDefaultActions = true;
	if(state instanceof JavaCommandLine)
	{
		final OwnJavaParameters parameters = ((JavaCommandLine) state).getJavaParameters();
		patch(parameters, env.getRunnerSettings(), env.getRunProfile(), true);

		ProcessProxy proxy = ProcessProxyFactory.getInstance().createCommandLineProxy((JavaCommandLine) state);
		executionResult = state.execute(env.getExecutor(), this);
		if(proxy != null)
		{
			ProcessHandler handler = executionResult != null ? executionResult.getProcessHandler() : null;
			if(handler != null)
			{
				proxy.attach(handler);
				handler.addProcessListener(new ProcessAdapter()
				{
					@Override
					public void processTerminated(@NotNull ProcessEvent event)
					{
						proxy.destroy();
					}
				});
			}
			else
			{
				proxy.destroy();
			}
		}

		if(state instanceof JavaCommandLineState && !((JavaCommandLineState) state).shouldAddJavaProgramRunnerActions())
		{
			shouldAddDefaultActions = false;
		}
	}
	else
	{
		executionResult = state.execute(env.getExecutor(), this);
	}

	if(executionResult == null)
	{
		return null;
	}

	onProcessStarted(env.getRunnerSettings(), executionResult);

	final RunContentBuilder contentBuilder = new RunContentBuilder(executionResult, env);
	if(shouldAddDefaultActions)
	{
		addDefaultActions(contentBuilder, executionResult);
	}
	return contentBuilder.showRunContent(env.getContentToReuse());
}