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
|
// Copyright 2015 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.java;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.devtools.build.lib.actions.Artifact;
import com.google.devtools.build.lib.analysis.TransitiveInfoProvider;
import com.google.devtools.build.lib.concurrent.ThreadSafety.Immutable;
import com.google.devtools.build.lib.vfs.PathFragment;
import java.util.Collection;
import java.util.Map;
/**
* A Provider describing the java sources directly belonging to a java rule.
*/
@Immutable
public final class JavaSourceInfoProvider implements TransitiveInfoProvider {
private final Collection<Artifact> sourceFiles;
private final Collection<Artifact> sourceJars;
private final Collection<Artifact> jarFiles;
private final Collection<Artifact> sourceJarsForJarFiles;
private final Map<PathFragment, Artifact> resources;
private final Collection<String> processorNames;
private final Collection<Artifact> processorPath;
private JavaSourceInfoProvider(
Collection<Artifact> sourceFiles,
Collection<Artifact> sourceJars,
Collection<Artifact> jarFiles,
Collection<Artifact> sourceJarsForJarFiles,
Map<PathFragment, Artifact> resources,
Collection<String> processorNames,
Collection<Artifact> processorPath) {
this.sourceFiles = sourceFiles;
this.sourceJars = sourceJars;
this.jarFiles = jarFiles;
this.sourceJarsForJarFiles = sourceJarsForJarFiles;
this.resources = resources;
this.processorNames = processorNames;
this.processorPath = processorPath;
}
/** Gets the original Java source files provided as inputs to this rule. */
public Collection<Artifact> getSourceFiles() {
return sourceFiles;
}
/**
* Gets the original source jars provided as inputs to this rule.
*
* <p>These should contain Java source files, but can contain other files as well.
*/
public Collection<Artifact> getSourceJars() {
return sourceJars;
}
/**
* Gets the original pre-built jars provided as inputs to this rule.
*
* <p>These should be used where .class files are needed or wanted in place of recompiling the
* sources from {@link #getSourceJarsForJarFiles()}, as this is the source of truth used by the
* normal Java machinery.
*/
public Collection<Artifact> getJarFiles() {
return jarFiles;
}
/**
* Gets the source jars containing the sources of the jars contained in {@link #getJarFiles}.
*
* <p>These should be used in place of {@link #getJarFiles()} if and only if source is required.
*/
public Collection<Artifact> getSourceJarsForJarFiles() {
return sourceJarsForJarFiles;
}
/**
* Gets the Java resources which were included in this rule's output.
*
* <p>Each key in the map (a path within the jar) should correspond to the artifact which belongs
* at that path. The path fragment should be some suffix of the artifact's exec path.
*/
public Map<PathFragment, Artifact> getResources() {
return resources;
}
/** Gets the names of the annotation processors which operate on this rule's sources. */
public Collection<String> getProcessorNames() {
return processorNames;
}
/** Gets the classpath for the annotation processors which operate on this rule's sources. */
public Collection<Artifact> getProcessorPath() {
return processorPath;
}
/**
* Constructs a JavaSourceInfoProvider using the sources in the given JavaTargetAttributes.
*
* @param attributes the object from which to draw the sources
* @param semantics semantics used to find the path for a resource within the jar
*/
public static JavaSourceInfoProvider fromJavaTargetAttributes(
JavaTargetAttributes attributes, JavaSemantics semantics) {
return new Builder()
.setSourceFiles(attributes.getSourceFiles())
.setSourceJars(attributes.getSourceJars())
.setResources(attributes.getResources())
.setProcessorNames(attributes.getProcessorNames())
.setProcessorPath(attributes.getProcessorPath())
.build();
}
/** Builder class for constructing JavaSourceInfoProviders. */
public static final class Builder {
private Collection<Artifact> sourceFiles = ImmutableList.<Artifact>of();
private Collection<Artifact> sourceJars = ImmutableList.<Artifact>of();
private Collection<Artifact> jarFiles = ImmutableList.<Artifact>of();
private Collection<Artifact> sourceJarsForJarFiles = ImmutableList.<Artifact>of();
private Map<PathFragment, Artifact> resources = ImmutableMap.<PathFragment, Artifact>of();
private Collection<String> processorNames = ImmutableList.<String>of();
private Collection<Artifact> processorPath = ImmutableList.<Artifact>of();
/** Sets the source files included as part of the sources of this rule. */
public Builder setSourceFiles(Collection<Artifact> sourceFiles) {
this.sourceFiles = Preconditions.checkNotNull(sourceFiles);
return this;
}
/** Sets the source jars included as part of the sources of this rule. */
public Builder setSourceJars(Collection<Artifact> sourceJars) {
this.sourceJars = Preconditions.checkNotNull(sourceJars);
return this;
}
/**
* Sets the pre-built jar files included as part of the sources of this rule.
*/
public Builder setJarFiles(Collection<Artifact> jarFiles) {
this.jarFiles = Preconditions.checkNotNull(jarFiles);
return this;
}
/**
* Sets the source jars corresponding to the jar files included in this rule.
*
* <p>Used by, e.g., the srcjars attribute of {@link JavaImport}.
*/
public Builder setSourceJarsForJarFiles(Collection<Artifact> sourceJarsForJarFiles) {
this.sourceJarsForJarFiles = Preconditions.checkNotNull(sourceJarsForJarFiles);
return this;
}
/**
* Sets the resources included in this rule.
*
* <p>Each key in the map (a path within the jar) should correspond to the artifact which
* belongs at that path. The path fragment should be some tail of the artifact's exec path.
*/
public Builder setResources(Map<PathFragment, Artifact> resources) {
this.resources = Preconditions.checkNotNull(resources);
return this;
}
/** Sets the names of the annotation processors used by this rule. */
public Builder setProcessorNames(Collection<String> processorNames) {
this.processorNames = Preconditions.checkNotNull(processorNames);
return this;
}
/** Sets the classpath used by this rule for annotation processing. */
public Builder setProcessorPath(Collection<Artifact> processorPath) {
this.processorPath = Preconditions.checkNotNull(processorPath);
return this;
}
/** Constructs the JavaSourceInfoProvider from the provided Java sources. */
public JavaSourceInfoProvider build() {
return new JavaSourceInfoProvider(
sourceFiles,
sourceJars,
jarFiles,
sourceJarsForJarFiles,
resources,
processorNames,
processorPath);
}
}
}
|
