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
|
// 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.packages;
import com.google.common.base.Preconditions;
import com.google.devtools.build.lib.concurrent.ThreadSafety.Immutable;
import com.google.devtools.build.lib.skyframe.serialization.DeserializationContext;
import com.google.devtools.build.lib.skyframe.serialization.ObjectCodec;
import com.google.devtools.build.lib.skyframe.serialization.SerializationContext;
import com.google.devtools.build.lib.skyframe.serialization.SerializationException;
import com.google.protobuf.CodedInputStream;
import com.google.protobuf.CodedOutputStream;
import java.io.IOException;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* An instance of a given {@code AspectClass} with loaded definition and parameters.
*
* This is an aspect equivalent of {@link Rule} class for build rules.
*
* Note: this class does not have {@code equals()} and {@code hashCode()} redefined, so should
* not be used in SkyKeys.
*/
@Immutable
public final class Aspect implements DependencyFilter.AttributeInfoProvider {
/**
* The aspect definition is a function of the aspect class + its parameters, so we can cache that.
*
* <p>The native aspects are loaded with blaze and are not stateful. Reference equality works fine
* in this case.
*
* <p>Caching of Skylark aspects is not yet implemented.
*/
private static final Map<NativeAspectClass, Map<AspectParameters, AspectDefinition>>
definitionCache = new ConcurrentHashMap<>();
private final AspectDescriptor aspectDescriptor;
private final AspectDefinition aspectDefinition;
private Aspect(
AspectClass aspectClass,
AspectDefinition aspectDefinition,
AspectParameters parameters) {
this.aspectDescriptor = new AspectDescriptor(
Preconditions.checkNotNull(aspectClass),
Preconditions.checkNotNull(parameters));
this.aspectDefinition = Preconditions.checkNotNull(aspectDefinition);
}
public static Aspect forNative(
NativeAspectClass nativeAspectClass, AspectParameters parameters) {
AspectDefinition definition =
definitionCache
.computeIfAbsent(nativeAspectClass, key -> new ConcurrentHashMap<>())
.computeIfAbsent(parameters, nativeAspectClass::getDefinition);
return new Aspect(nativeAspectClass, definition, parameters);
}
public static Aspect forNative(NativeAspectClass nativeAspectClass) {
return forNative(nativeAspectClass, AspectParameters.EMPTY);
}
public static Aspect forSkylark(
SkylarkAspectClass skylarkAspectClass,
AspectDefinition aspectDefinition,
AspectParameters parameters) {
return new Aspect(skylarkAspectClass, aspectDefinition, parameters);
}
/**
* Returns the aspectClass required for building the aspect.
*/
public AspectClass getAspectClass() {
return aspectDescriptor.getAspectClass();
}
/**
* Returns parameters for evaluation of the aspect.
*/
public AspectParameters getParameters() {
return aspectDescriptor.getParameters();
}
public AspectDescriptor getDescriptor() {
return aspectDescriptor;
}
@Override
public String toString() {
return String.format("Aspect %s", aspectDescriptor.toString());
}
public AspectDefinition getDefinition() {
return aspectDefinition;
}
@Override
public boolean isAttributeValueExplicitlySpecified(Attribute attribute) {
// All aspect attributes are implicit.
return false;
}
/** {@link ObjectCodec} for {@link Aspect}. */
static class AspectCodec implements ObjectCodec<Aspect> {
@Override
public Class<Aspect> getEncodedClass() {
return Aspect.class;
}
@Override
public void serialize(SerializationContext context, Aspect obj, CodedOutputStream codedOut)
throws SerializationException, IOException {
context.serialize(obj.getDescriptor(), codedOut);
boolean nativeAspect = obj.getDescriptor().getAspectClass() instanceof NativeAspectClass;
codedOut.writeBoolNoTag(nativeAspect);
if (!nativeAspect) {
context.serialize(obj.getDefinition(), codedOut);
}
}
@Override
public Aspect deserialize(DeserializationContext context, CodedInputStream codedIn)
throws SerializationException, IOException {
AspectDescriptor aspectDescriptor = context.deserialize(codedIn);
if (codedIn.readBool()) {
return forNative(
(NativeAspectClass) aspectDescriptor.getAspectClass(),
aspectDescriptor.getParameters());
} else {
AspectDefinition aspectDefinition = context.deserialize(codedIn);
return forSkylark(
(SkylarkAspectClass) aspectDescriptor.getAspectClass(),
aspectDefinition,
aspectDescriptor.getParameters());
}
}
}
}
|
