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
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
|
// Copyright 2016 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.rules.android;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Function;
import com.google.common.base.Functions;
import com.google.common.base.Joiner;
import com.google.common.base.Preconditions;
import com.google.common.collect.FluentIterable;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterators;
import com.google.devtools.build.lib.actions.Artifact;
import com.google.devtools.build.lib.analysis.actions.CustomCommandLine;
import com.google.devtools.build.lib.collect.nestedset.NestedSet;
import com.google.devtools.build.lib.collect.nestedset.NestedSetBuilder;
import com.google.devtools.build.lib.collect.nestedset.Order;
import com.google.devtools.build.lib.rules.android.ResourceContainer.ResourceType;
import javax.annotation.Nullable;
/**
* Factory for functions to convert a {@link ResourceContainer} to a commandline argument, or a
* collection of artifacts. Uses a certain convention for commandline arguments (e.g., separators,
* and ordering of container elements).
*/
@VisibleForTesting
public class ResourceContainerConverter {
static Builder builder() {
return new Builder();
}
interface ToArg extends Function<ResourceContainer, String> {
String listSeparator();
}
interface ToArtifacts extends Function<ResourceContainer, NestedSet<Artifact>> {
}
static class Builder {
private boolean includeResourceRoots;
private boolean includeLabel;
private boolean includeManifest;
private boolean includeRTxt;
private boolean includeSymbolsBin;
private SeparatorType separatorType;
private Joiner argJoiner;
private Function<String, String> escaper = Functions.identity();
enum SeparatorType {
COLON_COMMA,
SEMICOLON_AMPERSAND
}
Builder() {
}
Builder includeResourceRoots() {
includeResourceRoots = true;
return this;
}
Builder includeLabel() {
includeLabel = true;
return this;
}
Builder includeManifest() {
includeManifest = true;
return this;
}
Builder includeRTxt() {
includeRTxt = true;
return this;
}
Builder includeSymbolsBin() {
includeSymbolsBin = true;
return this;
}
Builder withSeparator(SeparatorType type) {
separatorType = type;
return this;
}
ToArg toArgConverter() {
switch (separatorType) {
case COLON_COMMA:
argJoiner = Joiner.on(":");
// We currently use ":" to separate components of an argument and "," to separate
// arguments in a list of arguments. Those characters require escaping if used in a label
// (part of the set of allowed characters in a label).
if (includeLabel) {
escaper = new Function<String, String>() {
@Override
public String apply(String input) {
return input.replace(":", "\\:").replace(",", "\\,");
}
};
}
break;
case SEMICOLON_AMPERSAND:
argJoiner = Joiner.on(";");
break;
default:
Preconditions.checkState(false, "Unknown separator type " + separatorType);
break;
}
return new ToArg() {
@Override
public String apply(ResourceContainer container) {
ImmutableList.Builder<String> cmdPieces = ImmutableList.builder();
if (includeResourceRoots) {
cmdPieces.add(convertRoots(container, ResourceType.RESOURCES));
cmdPieces.add(convertRoots(container, ResourceType.ASSETS));
}
if (includeLabel) {
cmdPieces.add(escaper.apply(container.getLabel().toString()));
}
if (includeManifest) {
cmdPieces.add(container.getManifest().getExecPathString());
}
if (includeRTxt) {
cmdPieces.add(
container.getRTxt() == null ? "" : container.getRTxt().getExecPathString());
}
if (includeSymbolsBin) {
cmdPieces.add(
container.getSymbols() == null
? ""
: container.getSymbols().getExecPathString());
}
return argJoiner.join(cmdPieces.build());
}
@Override
public String listSeparator() {
switch (separatorType) {
case COLON_COMMA:
return ",";
case SEMICOLON_AMPERSAND:
return "&";
default:
Preconditions.checkState(false, "Unknown separator type " + separatorType);
return null;
}
}
};
}
ToArtifacts toArtifactConverter() {
return new ToArtifacts() {
@Override
public NestedSet<Artifact> apply(ResourceContainer container) {
NestedSetBuilder<Artifact> artifacts = NestedSetBuilder.naiveLinkOrder();
if (includeResourceRoots) {
artifacts.addAll(container.getArtifacts());
}
if (includeManifest) {
addIfNotNull(container.getManifest(), artifacts);
}
if (includeRTxt) {
addIfNotNull(container.getRTxt(), artifacts);
}
if (includeSymbolsBin) {
addIfNotNull(container.getSymbols(), artifacts);
}
return artifacts.build();
}
};
}
}
private static void addIfNotNull(
@Nullable Artifact artifact, NestedSetBuilder<Artifact> artifacts) {
if (artifact != null) {
artifacts.add(artifact);
}
}
@VisibleForTesting
public static String convertRoots(ResourceContainer container, ResourceType resourceType) {
return Joiner.on("#")
.join(
Iterators.transform(
container.getRoots(resourceType).iterator(), Functions.toStringFunction()));
}
/**
* Convert ResourceDependencies to commandline args and artifacts, assuming the commandline
* arguments should be split into direct deps and transitive deps.
*/
static void convertDependencies(
ResourceDependencies dependencies,
CustomCommandLine.Builder cmdBuilder,
NestedSetBuilder<Artifact> inputs,
ToArg toArg,
ToArtifacts toArtifacts) {
if (dependencies != null) {
if (!dependencies.getTransitiveResources().isEmpty()) {
cmdBuilder.addJoinValues(
"--data", toArg.listSeparator(), dependencies.getTransitiveResources(), toArg);
}
if (!dependencies.getDirectResources().isEmpty()) {
cmdBuilder.addJoinValues(
"--directData", toArg.listSeparator(), dependencies.getDirectResources(), toArg);
}
// This flattens the nested set. Since each ResourceContainer needs to be transformed into
// Artifacts, and the NestedSetBuilder.wrap doesn't support lazy Iterator evaluation
// and SpawnActionBuilder.addInputs evaluates Iterables, it becomes necessary to make the
// best effort and let it get flattened.
inputs.addTransitive(
NestedSetBuilder.wrap(
Order.NAIVE_LINK_ORDER,
FluentIterable.from(dependencies.getResources()).transformAndConcat(toArtifacts)));
}
}
}
|
