1
2
3
4
5
6
7
8
9
10
11
12 package org.eclipse.jgit.internal.storage.pack;
13
14 import org.eclipse.jgit.lib.AnyObjectId;
15 import org.eclipse.jgit.lib.Constants;
16 import org.eclipse.jgit.lib.ObjectId;
17 import org.eclipse.jgit.transport.PackedObjectInfo;
18
19
20
21
22
23
24
25
26
27 public class ObjectToPack extends PackedObjectInfo {
28 private static final int REUSE_AS_IS = 1 << 0;
29 private static final int DELTA_ATTEMPTED = 1 << 1;
30 private static final int DO_NOT_DELTA = 1 << 2;
31 private static final int EDGE = 1 << 3;
32 private static final int ATTEMPT_DELTA_MASK = REUSE_AS_IS | DELTA_ATTEMPTED;
33 private static final int TYPE_SHIFT = 5;
34 private static final int EXT_SHIFT = 8;
35 private static final int EXT_MASK = 0xf;
36 private static final int DELTA_SHIFT = 12;
37 private static final int NON_EXT_MASK = ~(EXT_MASK << EXT_SHIFT);
38 private static final int NON_DELTA_MASK = 0xfff;
39
40
41 private ObjectId deltaBase;
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57 private int flags;
58
59
60 private int pathHash;
61
62
63 private DeltaCache.Ref cachedDelta;
64
65
66
67
68
69
70
71
72
73 public ObjectToPack(AnyObjectId src, int type) {
74 super(src);
75 flags = type << TYPE_SHIFT;
76 }
77
78
79
80
81
82
83
84
85
86 public final ObjectId getDeltaBaseId() {
87 return deltaBase;
88 }
89
90
91
92
93
94
95
96
97
98
99 public final ObjectToPack getDeltaBase() {
100 if (deltaBase instanceof ObjectToPack)
101 return (ObjectToPack) deltaBase;
102 return null;
103 }
104
105
106
107
108
109
110
111
112
113
114
115 final void setDeltaBase(ObjectId deltaBase) {
116 this.deltaBase = deltaBase;
117 }
118
119 final void setCachedDelta(DeltaCache.Ref data) {
120 cachedDelta = data;
121 }
122
123 final DeltaCache.Ref popCachedDelta() {
124 DeltaCache.Ref r = cachedDelta;
125 if (r != null)
126 cachedDelta = null;
127 return r;
128 }
129
130 final void clearDeltaBase() {
131 this.deltaBase = null;
132
133 if (cachedDelta != null) {
134 cachedDelta.clear();
135 cachedDelta.enqueue();
136 cachedDelta = null;
137 }
138 }
139
140
141
142
143
144
145 public final boolean isDeltaRepresentation() {
146 return deltaBase != null;
147 }
148
149
150
151
152
153
154
155 public final boolean isWritten() {
156 return 1 < getOffset();
157 }
158
159
160 @Override
161 public final int getType() {
162 return (flags >> TYPE_SHIFT) & 0x7;
163 }
164
165 final int getDeltaDepth() {
166 return flags >>> DELTA_SHIFT;
167 }
168
169 final void setDeltaDepth(int d) {
170 flags = (d << DELTA_SHIFT) | (flags & NON_DELTA_MASK);
171 }
172
173 final int getChainLength() {
174 return getDeltaDepth();
175 }
176
177 final void setChainLength(int len) {
178 setDeltaDepth(len);
179 }
180
181 final void clearChainLength() {
182 flags &= NON_DELTA_MASK;
183 }
184
185 final boolean wantWrite() {
186 return getOffset() == 1;
187 }
188
189 final void markWantWrite() {
190 setOffset(1);
191 }
192
193
194
195
196
197
198
199
200 public final boolean isReuseAsIs() {
201 return (flags & REUSE_AS_IS) != 0;
202 }
203
204 final void setReuseAsIs() {
205 flags |= REUSE_AS_IS;
206 }
207
208
209
210
211
212
213
214
215 protected void clearReuseAsIs() {
216 flags &= ~REUSE_AS_IS;
217 }
218
219 final boolean isDoNotDelta() {
220 return (flags & DO_NOT_DELTA) != 0;
221 }
222
223 final void setDoNotDelta() {
224 flags |= DO_NOT_DELTA;
225 }
226
227 final boolean isEdge() {
228 return (flags & EDGE) != 0;
229 }
230
231 final void setEdge() {
232 flags |= EDGE;
233 }
234
235 final boolean doNotAttemptDelta() {
236
237 return (flags & ATTEMPT_DELTA_MASK) == ATTEMPT_DELTA_MASK;
238 }
239
240 final void setDeltaAttempted(boolean deltaAttempted) {
241 if (deltaAttempted)
242 flags |= DELTA_ATTEMPTED;
243 else
244 flags &= ~DELTA_ATTEMPTED;
245 }
246
247
248
249
250
251
252 protected final int getExtendedFlags() {
253 return (flags >>> EXT_SHIFT) & EXT_MASK;
254 }
255
256
257
258
259
260
261
262
263
264
265
266 protected final boolean isExtendedFlag(int flag) {
267 return (flags & (flag << EXT_SHIFT)) != 0;
268 }
269
270
271
272
273
274
275
276
277
278
279 protected final void setExtendedFlag(int flag) {
280 flags |= (flag & EXT_MASK) << EXT_SHIFT;
281 }
282
283
284
285
286
287
288
289
290
291
292 protected final void clearExtendedFlag(int flag) {
293 flags &= ~((flag & EXT_MASK) << EXT_SHIFT);
294 }
295
296
297
298
299
300
301
302
303
304
305
306 protected final void setExtendedFlags(int extFlags) {
307 flags = ((extFlags & EXT_MASK) << EXT_SHIFT) | (flags & NON_EXT_MASK);
308 }
309
310 final int getFormat() {
311 if (isReuseAsIs()) {
312 if (isDeltaRepresentation())
313 return StoredObjectRepresentation.PACK_DELTA;
314 return StoredObjectRepresentation.PACK_WHOLE;
315 }
316 return StoredObjectRepresentation.FORMAT_OTHER;
317 }
318
319
320 final int getWeight() {
321 return getCRC();
322 }
323
324 final void setWeight(int weight) {
325 setCRC(weight);
326 }
327
328 final int getPathHash() {
329 return pathHash;
330 }
331
332 final void setPathHash(int hc) {
333 pathHash = hc;
334 }
335
336 final int getCachedSize() {
337 return pathHash;
338 }
339
340 final void setCachedSize(int sz) {
341 pathHash = sz;
342 }
343
344
345
346
347
348
349
350
351
352
353
354
355
356 public void select(StoredObjectRepresentation ref) {
357
358 }
359
360
361 @SuppressWarnings("nls")
362 @Override
363 public String toString() {
364 StringBuilder buf = new StringBuilder();
365 buf.append("ObjectToPack[");
366 buf.append(Constants.typeString(getType()));
367 buf.append(" ");
368 buf.append(name());
369 if (wantWrite())
370 buf.append(" wantWrite");
371 if (isReuseAsIs())
372 buf.append(" reuseAsIs");
373 if (isDoNotDelta())
374 buf.append(" doNotDelta");
375 if (isEdge())
376 buf.append(" edge");
377 if (getDeltaDepth() > 0)
378 buf.append(" depth=").append(getDeltaDepth());
379 if (isDeltaRepresentation()) {
380 if (getDeltaBase() != null)
381 buf.append(" base=inpack:").append(getDeltaBase().name());
382 else
383 buf.append(" base=edge:").append(getDeltaBaseId().name());
384 }
385 if (isWritten())
386 buf.append(" offset=").append(getOffset());
387 buf.append("]");
388 return buf.toString();
389 }
390 }