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
142
143
144
145
146
147
148
149
150
151
152
153
154
|
// Copyright 2014 The Bazel Authors. All rights reserved.
//
// 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.google.devtools.build.lib.actions;
import static java.nio.charset.StandardCharsets.ISO_8859_1;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;
import com.google.devtools.build.lib.actions.ParameterFile.ParameterFileType;
import java.nio.charset.Charset;
import java.util.Objects;
import javax.annotation.concurrent.Immutable;
/**
* An object that encapsulates how a params file should be constructed: what is the filetype,
* what charset to use and what prefix (typically "@") to use.
*/
@Immutable
public final class ParamFileInfo {
private final ParameterFileType fileType;
private final Charset charset;
private final String flagFormatString;
private final boolean always;
private final Iterable<Artifact> inputs;
private ParamFileInfo(
ParameterFileType fileType,
Charset charset,
String flagFormatString,
Iterable<Artifact> inputs,
boolean always) {
this.fileType = Preconditions.checkNotNull(fileType);
this.charset = Preconditions.checkNotNull(charset);
this.flagFormatString = Preconditions.checkNotNull(flagFormatString);
this.always = always;
this.inputs = Iterables.transform(inputs, input -> {
Preconditions.checkArgument(input.isTreeArtifact(),
input.getExecPath() + " is not tree artifacts, "
+ "it should not be put into ParamFileInfo's inputs");
return input;
});
}
/**
* Returns the file type.
*/
public ParameterFileType getFileType() {
return fileType;
}
/**
* Returns the charset.
*/
public Charset getCharset() {
return charset;
}
/** Returns the format string for the params filename on the command line (typically "@%s"). */
public String getFlagFormatString() {
return flagFormatString;
}
/** Returns true if a params file should always be used. */
public boolean always() {
return always;
}
/** Returns the tree artifacts that are needed as input for {@code ParameterFileWriteAction} */
public Iterable<Artifact> getInputs() {
return inputs;
}
@Override
public int hashCode() {
return Objects.hash(charset, flagFormatString, fileType, always);
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (!(obj instanceof ParamFileInfo)) {
return false;
}
ParamFileInfo other = (ParamFileInfo) obj;
return fileType.equals(other.fileType)
&& charset.equals(other.charset)
&& flagFormatString.equals(other.flagFormatString)
&& always == other.always;
}
public static Builder builder(ParameterFileType parameterFileType) {
return new Builder(parameterFileType);
}
/** Builder for a ParamFileInfo. */
public static class Builder {
private final ParameterFileType fileType;
private Charset charset = ISO_8859_1;
private String flagFormatString = "@%s";
private boolean always;
private Iterable<Artifact> inputs = ImmutableList.<Artifact>of();
private Builder(ParameterFileType fileType) {
this.fileType = fileType;
}
/** Sets the encoding to write the parameter file with. */
public Builder setCharset(Charset charset) {
this.charset = charset;
return this;
}
/**
* Sets a format string to use for the flag that is passed to original command.
*
* <p>The format string must have a single "%s" that will be replaced by the execution path to
* the param file.
*/
public Builder setFlagFormatString(String flagFormatString) {
this.flagFormatString = flagFormatString;
return this;
}
/** Set whether the parameter file is always used, regardless of parameter file length. */
public Builder setUseAlways(boolean always) {
this.always = always;
return this;
}
public Builder setInputs(Iterable<Artifact> inputs) {
this.inputs = inputs;
return this;
}
public ParamFileInfo build() {
return new ParamFileInfo(fileType, charset, flagFormatString, inputs, always);
}
}
}
|
