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
|
// Copyright 2017 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.skyframe.serialization;
import com.google.common.collect.ImmutableMap;
import com.google.protobuf.ByteString;
import com.google.protobuf.CodedInputStream;
import com.google.protobuf.CodedOutputStream;
import java.io.IOException;
/**
* Wrapper for the minutiae of serializing and deserializing objects using {@link ObjectCodec}s,
* serving as a layer between the streaming-oriented {@link ObjectCodec} interface and users.
*/
public class ObjectCodecs {
private final ObjectCodecRegistry codecRegistry;
// TODO(shahan): when per-invocation state is needed, for example, memoization, these may
// need to be constructed each time.
private final SerializationContext serializationContext;
private final DeserializationContext deserializationContext;
/**
* Creates an instance using the supplied {@link ObjectCodecRegistry} for looking up {@link
* ObjectCodec}s.
*/
ObjectCodecs(ObjectCodecRegistry codecRegistry, ImmutableMap<Class<?>, Object> dependencies) {
this.codecRegistry = codecRegistry;
serializationContext = new SerializationContext(dependencies);
deserializationContext = new DeserializationContext(dependencies);
}
/**
* Serialize {@code subject}, using the serialization strategy determined by {@code classifier},
* returning a {@link ByteString} containing the serialized representation.
*/
public ByteString serialize(String classifier, Object subject) throws SerializationException {
ByteString.Output resultOut = ByteString.newOutput();
CodedOutputStream codedOut = CodedOutputStream.newInstance(resultOut);
ObjectCodec<?> codec = codecRegistry.getCodecDescriptor(classifier).getCodec();
try {
doSerialize(classifier, codec, subject, codedOut);
codedOut.flush();
return resultOut.toByteString();
} catch (IOException e) {
throw new SerializationException(
"Failed to serialize " + subject + " using " + codec + " for " + classifier, e);
}
}
/**
* Similar to {@link #serialize(String, Object)}, except allows the caller to specify a {@link
* CodedOutputStream} to serialize {@code subject} to. Has less object overhead than {@link
* #serialize(String, Object)} and as such is preferrable when serializing objects in bulk.
*
* <p>{@code codedOut} is not flushed by this method.
*/
public void serialize(String classifier, Object subject, CodedOutputStream codedOut)
throws SerializationException {
ObjectCodec<?> codec = codecRegistry.getCodecDescriptor(classifier).getCodec();
try {
doSerialize(classifier, codec, subject, codedOut);
} catch (IOException e) {
throw new SerializationException(
"Failed to serialize " + subject + " using " + codec + " for " + classifier, e);
}
}
/**
* Deserialize {@code data} using the serialization strategy determined by {@code classifier}.
* {@code classifier} should be the utf-8 encoded {@link ByteString} representation of the {@link
* String} classifier used to serialize {@code data}. This is preferred since callers typically
* have parsed {@code classifier} from a protocol buffer, for which {@link ByteString}s are
* cheaper to use.
*/
public Object deserialize(ByteString classifier, ByteString data) throws SerializationException {
return deserialize(classifier, data.newCodedInput());
}
/**
* Similar to {@link #deserialize(ByteString, ByteString)}, except allows the caller to specify a
* {@link CodedInputStream} to deserialize data from. This is useful for decoding objects
* serialized in bulk by {@link #serialize(String, Object, CodedOutputStream)}.
*/
public Object deserialize(ByteString classifier, CodedInputStream codedIn)
throws SerializationException {
ObjectCodec<?> codec = codecRegistry.getCodecDescriptor(classifier).getCodec();
// If safe, this will allow CodedInputStream to return a direct view of the underlying bytes
// in some situations, bypassing a copy.
codedIn.enableAliasing(true);
try {
Object result = codec.deserialize(deserializationContext, codedIn);
if (result == null) {
throw new NullPointerException(
"ObjectCodec " + codec + " for " + classifier.toStringUtf8() + " returned null");
}
return result;
} catch (IOException e) {
throw new SerializationException(
"Failed to deserialize data using " + codec + " for " + classifier.toStringUtf8(), e);
}
}
private <T> void doSerialize(
String classifier, ObjectCodec<T> codec, Object subject, CodedOutputStream codedOut)
throws SerializationException, IOException {
try {
codec.serialize(serializationContext, codec.getEncodedClass().cast(subject), codedOut);
} catch (ClassCastException e) {
throw new SerializationException(
"Codec "
+ codec
+ " for "
+ classifier
+ " is incompatible with "
+ subject
+ " (of type "
+ subject.getClass().getName()
+ ")",
e);
}
}
}
|
