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
|
/*
* Copyright (C) 2009, The Android Open Source Project
* Copyright (C) 2009, Shawn O. Pearce <spearce@spearce.org>
* Copyright (C) 2018, David Pursehouse <david.pursehouse@gmail.com> and others
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Distribution License v. 1.0 which is available at
* https://www.eclipse.org/org/documents/edl-v10.php.
*
* SPDX-License-Identifier: BSD-3-Clause
*/
package org.eclipse.jgit.lib;
import static org.eclipse.jgit.lib.Constants.OBJECT_ID_LENGTH;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import org.eclipse.jgit.annotations.NonNull;
import org.eclipse.jgit.annotations.Nullable;
import org.eclipse.jgit.util.IO;
/**
* Helper to serialize {@link ObjectId} instances. {@link ObjectId} is already
* serializable, but this class provides methods to handle null and non-null
* instances.
*
* @since 4.11
*/
public class ObjectIdSerializer {
/*
* Marker to indicate a null ObjectId instance.
*/
private static final byte NULL_MARKER = 0;
/*
* Marker to indicate a non-null ObjectId instance.
*/
private static final byte NON_NULL_MARKER = 1;
/**
* Write a possibly null {@link ObjectId} to the stream, using markers to
* differentiate null and non-null instances.
*
* <p>
* If the id is non-null, writes a {@link #NON_NULL_MARKER} followed by the
* id's words. If it is null, writes a {@link #NULL_MARKER} and nothing
* else.
*
* @param out
* the output stream
* @param id
* the object id to serialize; may be null
* @throws IOException
* the stream writing failed
*/
public static void write(OutputStream out, @Nullable AnyObjectId id)
throws IOException {
if (id != null) {
out.write(NON_NULL_MARKER);
writeWithoutMarker(out, id);
} else {
out.write(NULL_MARKER);
}
}
/**
* Write a non-null {@link ObjectId} to the stream.
*
* @param out
* the output stream
* @param id
* the object id to serialize; never null
* @throws IOException
* the stream writing failed
* @since 4.11
*/
public static void writeWithoutMarker(OutputStream out, @NonNull AnyObjectId id)
throws IOException {
id.copyRawTo(out);
}
/**
* Read a possibly null {@link ObjectId} from the stream.
*
* Reads the first byte of the stream, which is expected to be either
* {@link #NON_NULL_MARKER} or {@link #NULL_MARKER}.
*
* @param in
* the input stream
* @return the object id, or null
* @throws IOException
* there was an error reading the stream
*/
@Nullable
public static ObjectId read(InputStream in) throws IOException {
byte marker = (byte) in.read();
switch (marker) {
case NULL_MARKER:
return null;
case NON_NULL_MARKER:
return readWithoutMarker(in);
default:
throw new IOException("Invalid flag before ObjectId: " + marker); //$NON-NLS-1$
}
}
/**
* Read a non-null {@link ObjectId} from the stream.
*
* @param in
* the input stream
* @return the object id; never null
* @throws IOException
* there was an error reading the stream
* @since 4.11
*/
@NonNull
public static ObjectId readWithoutMarker(InputStream in) throws IOException {
final byte[] b = new byte[OBJECT_ID_LENGTH];
IO.readFully(in, b, 0, OBJECT_ID_LENGTH);
return ObjectId.fromRaw(b);
}
private ObjectIdSerializer() {
}
}
|
