1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
/*
* Copyright 2000-2013 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.intellij.execution.runners;
import com.intellij.execution.DefaultExecutionTarget;
import com.intellij.execution.ExecutionTarget;
import com.intellij.execution.Executor;
import com.intellij.execution.RunnerAndConfigurationSettings;
import com.intellij.execution.configurations.ConfigurationPerRunnerSettings;
import com.intellij.execution.configurations.RunProfile;
import com.intellij.execution.configurations.RunnerSettings;
import com.intellij.execution.ui.RunContentDescriptor;
import com.intellij.openapi.actionSystem.DataContext;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.project.Project;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
/**
* User: Vassiliy.Kudryashov
*/
public final class ExecutionEnvironmentBuilder {
private static final Logger LOG = Logger.getInstance("#com.intellij.execution.runners.ExecutionEnvironmentBuilder");
@NotNull private RunProfile myRunProfile;
@NotNull private ExecutionTarget myTarget = DefaultExecutionTarget.INSTANCE;
@NotNull private final Project myProject;
@Nullable private RunnerSettings myRunnerSettings;
@Nullable private ConfigurationPerRunnerSettings myConfigurationSettings;
@Nullable private RunContentDescriptor myContentToReuse;
@Nullable private RunnerAndConfigurationSettings myRunnerAndConfigurationSettings;
@Nullable private String myRunnerId;
private boolean myAssignNewId;
@NotNull private Executor myExecutor;
@Nullable private DataContext myDataContext;
public ExecutionEnvironmentBuilder(@NotNull Project project, @NotNull Executor executor) {
myProject = project;
myExecutor = executor;
}
/**
* Creates an execution environment builder initialized with a copy of the specified environment.
*
* @param copySource the environment to copy from.
*/
public ExecutionEnvironmentBuilder(@NotNull ExecutionEnvironment copySource) {
setTarget(copySource.getExecutionTarget());
myProject = copySource.getProject();
myRunnerAndConfigurationSettings = copySource.getRunnerAndConfigurationSettings();
myRunProfile = copySource.getRunProfile();
myRunnerSettings = copySource.getRunnerSettings();
myConfigurationSettings = copySource.getConfigurationSettings();
myRunnerId = copySource.getRunnerId();
setContentToReuse(copySource.getContentToReuse());
myExecutor = copySource.getExecutor();
}
public ExecutionEnvironmentBuilder setTarget(@NotNull ExecutionTarget target) {
myTarget = target;
return this;
}
public ExecutionEnvironmentBuilder setRunnerAndSettings(@NotNull ProgramRunner programRunner,
@NotNull RunnerAndConfigurationSettings settings) {
myRunnerAndConfigurationSettings = settings;
setRunProfile(settings.getConfiguration());
setRunnerSettings(settings.getRunnerSettings(programRunner));
setConfigurationSettings(settings.getConfigurationSettings(programRunner));
setRunnerId(programRunner.getRunnerId());
return this;
}
public ExecutionEnvironmentBuilder setRunnerSettings(@Nullable RunnerSettings runnerSettings) {
myRunnerSettings = runnerSettings;
return this;
}
public ExecutionEnvironmentBuilder setConfigurationSettings(@Nullable ConfigurationPerRunnerSettings configurationSettings) {
myConfigurationSettings = configurationSettings;
return this;
}
public ExecutionEnvironmentBuilder setContentToReuse(@Nullable RunContentDescriptor contentToReuse) {
myContentToReuse = contentToReuse;
return this;
}
public ExecutionEnvironmentBuilder setRunProfile(@NotNull RunProfile runProfile) {
myRunProfile = runProfile;
return this;
}
public ExecutionEnvironmentBuilder setRunnerId(@Nullable String runnerId) {
myRunnerId = runnerId;
return this;
}
public ExecutionEnvironmentBuilder assignNewId() {
myAssignNewId = true;
return this;
}
public ExecutionEnvironmentBuilder setDataContext(@Nullable DataContext dataContext) {
myDataContext = dataContext;
return this;
}
public ExecutionEnvironmentBuilder setExecutor(@NotNull Executor executor) {
myExecutor = executor;
return this;
}
@NotNull
public ExecutionEnvironment build() {
ExecutionEnvironment environment =
new ExecutionEnvironment(myRunProfile, myExecutor, myTarget, myProject, myRunnerSettings, myConfigurationSettings, myContentToReuse,
myRunnerAndConfigurationSettings, myRunnerId);
if (myAssignNewId) {
environment.assignNewExecutionId();
}
if (myDataContext != null) {
environment.setDataContext(myDataContext);
}
return environment;
}
}
|
