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
|
// 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.ImmutableList;
import com.google.common.collect.Iterators;
import com.google.devtools.build.lib.analysis.actions.CustomCommandLine;
import com.google.devtools.build.lib.analysis.actions.CustomCommandLine.VectorArg;
import com.google.devtools.build.lib.rules.android.ResourceContainer.ResourceType;
/**
* 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();
}
static class Builder {
private boolean includeResourceRoots;
private boolean includeLabel;
private boolean includeManifest;
private boolean includeRTxt;
private boolean includeSymbolsBin;
private boolean includeCompiledSymbols;
private boolean includeStaticLibrary;
private boolean includeAapt2RTxt;
private SeparatorType separatorType;
private Joiner argJoiner;
private Function<String, String> escaper = Functions.identity();
enum SeparatorType {
COLON_COMMA,
SEMICOLON_AMPERSAND
}
Builder() {
}
Builder includeAapt2RTxt() {
includeAapt2RTxt = true;
return this;
}
Builder includeStaticLibrary() {
includeStaticLibrary = true;
return this;
}
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 includeCompiledSymbols() {
includeCompiledSymbols = 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 = (String input) -> 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 (includeAapt2RTxt) {
cmdPieces.add(
container.getAapt2RTxt() == null
? ""
: container.getAapt2RTxt().getExecPathString());
}
if (includeStaticLibrary) {
cmdPieces.add(
container.getStaticLibrary() == null
? ""
: container.getStaticLibrary().getExecPathString());
}
if (includeCompiledSymbols) {
cmdPieces.add(
container.getCompiledSymbols() == null
? ""
: container.getCompiledSymbols().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;
}
}
};
}
}
@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 addToCommandLine(
ResourceDependencies dependencies, CustomCommandLine.Builder cmdBuilder, ToArg toArg) {
cmdBuilder.addAll(
"--data",
VectorArg.join(toArg.listSeparator())
.each(dependencies.getTransitiveResources())
.mapped(toArg));
cmdBuilder.addAll(
"--directData",
VectorArg.join(toArg.listSeparator())
.each(dependencies.getDirectResources())
.mapped(toArg));
}
}
|
