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
|
// 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.packages;
import com.google.auto.value.AutoValue;
import com.google.common.collect.ImmutableList;
import com.google.devtools.build.lib.cmdline.Label;
import com.google.devtools.build.lib.events.Location;
import com.google.devtools.build.lib.syntax.Type;
import java.util.Collection;
import javax.annotation.Nullable;
/**
* The interface for accessing a {@link Rule}'s attributes.
*
* <p>Since what an attribute lookup should return can be ambiguous (e.g. for configurable
* attributes, should we return a configuration-resolved value or the original, unresolved
* selection expression?), different implementations can apply different policies for how to
* fulfill these methods. Calling code can then use the appropriate implementation for whatever
* its particular needs are.
*/
public interface AttributeMap {
/**
* Returns the name of the rule; this is equivalent to {@code getLabel().getName()}.
*/
String getName();
/**
* Returns the label of the rule.
*/
Label getLabel();
/**
* Returns the name of the rule class.
*/
String getRuleClassName();
/**
* Returns true if an attribute with the given name exists.
*/
boolean has(String attrName);
/**
* Returns true if an attribute with the given name exists with the given type.
*
* <p>Don't use this version unless you really care about the type.
*/
<T> boolean has(String attrName, Type<T> type);
/**
* Returns the value of the named rule attribute, which must be of the given type. This may
* be null (for example, for an attribute with no default value that isn't explicitly set in
* the rule - see {@link Type#getDefaultValue}).
*
* <p>If the rule doesn't have this attribute with the specified type, throws an
* {@link IllegalArgumentException}.
*/
@Nullable
<T> T get(String attributeName, Type<T> type);
/**
* Returns true if the given attribute is configurable for this rule instance, false
* if it isn't configurable or doesn't exist.
*/
boolean isConfigurable(String attributeName);
/**
* Returns the names of all attributes covered by this map.
*/
Iterable<String> getAttributeNames();
/**
* Returns the type of the given attribute, if it exists. Otherwise returns null.
*/
@Nullable
Type<?> getAttributeType(String attrName);
/**
* Returns the attribute definition whose name is {@code attrName}, or null
* if not found.
*/
@Nullable Attribute getAttributeDefinition(String attrName);
/**
* Returns true iff the value of the specified attribute is explicitly set in the BUILD file (as
* opposed to its default value). This also returns true if the value from the BUILD file is the
* same as the default value.
*
* <p>It is probably a good idea to avoid this method in default value and implicit outputs
* computation, because it is confusing that setting an attribute to an empty list (for example)
* is different from not setting it at all.
*/
boolean isAttributeValueExplicitlySpecified(String attributeName);
/** Returns the {@link Location} at which the attribute was defined. */
Location getAttributeLocation(String attrName);
/**
* Returns a {@link Collection} with a {@link DepEdge} for every attribute that contains labels in
* its value (either by *being* a label or being a collection that includes labels).
*/
Collection<DepEdge> visitLabels() throws InterruptedException;
/**
* {@code (Label, Attribute)} pair describing a dependency edge.
*
* <p>The {@link Label} is the target node of the {@code (Rule, Label)} edge. The source node
* should already be known. The {@link Attribute} is the attribute giving the edge.
*/
@AutoValue
abstract class DepEdge {
public abstract Label getLabel();
public abstract Attribute getAttribute();
static DepEdge create(Label label, Attribute attribute) {
return new AutoValue_AttributeMap_DepEdge(label, attribute);
}
}
// TODO(bazel-team): These methods are here to support computed defaults that inherit
// package-level default values. Instead, we should auto-inherit and remove the computed
// defaults. If we really need to give access to package-level defaults, we should come up with
// a more generic interface.
String getPackageDefaultHdrsCheck();
Boolean getPackageDefaultTestOnly();
String getPackageDefaultDeprecation();
ImmutableList<String> getPackageDefaultCopts();
}
|
