blob: e855d8f700a75bce88ad4da4a23d528452105327 (
plain)
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
|
/*
* Copyright (C) 2008, Shawn O. Pearce <spearce@spearce.org> 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.revwalk;
import java.io.IOException;
import org.eclipse.jgit.errors.IncorrectObjectTypeException;
import org.eclipse.jgit.errors.MissingObjectException;
abstract class BlockRevQueue extends AbstractRevQueue {
protected BlockFreeList free;
/**
* Create an empty revision queue.
*
* @param firstParent
* whether only first-parent links should be followed when
* walking
*/
protected BlockRevQueue(boolean firstParent) {
super(firstParent);
free = new BlockFreeList();
}
BlockRevQueue(Generator s) throws MissingObjectException,
IncorrectObjectTypeException, IOException {
super(s.firstParent);
free = new BlockFreeList();
outputType = s.outputType();
s.shareFreeList(this);
for (;;) {
final RevCommit c = s.next();
if (c == null)
break;
add(c);
}
}
/**
* Reconfigure this queue to share the same free list as another.
* <p>
* Multiple revision queues can be connected to the same free list, making
* it less expensive for applications to shuttle commits between them. This
* method arranges for the receiver to take from / return to the same free
* list as the supplied queue.
* <p>
* Free lists are not thread-safe. Applications must ensure that all queues
* sharing the same free list are doing so from only a single thread.
*
* @param q
* another FIFO queue that wants to share our queue's free list.
*
* @see Generator#shareFreeList
*/
@Override
public void shareFreeList(BlockRevQueue q) {
free = q.free;
}
static final class BlockFreeList {
private Block next;
Block newBlock() {
Block b = next;
if (b == null)
return new Block();
next = b.next;
b.clear();
return b;
}
void freeBlock(Block b) {
b.next = next;
next = b;
}
void clear() {
next = null;
}
}
static final class Block {
static final int BLOCK_SIZE = 256;
/** Next block in our chain of blocks; null if we are the last. */
Block next;
/** Our table of queued commits. */
final RevCommit[] commits = new RevCommit[BLOCK_SIZE];
/** Next valid entry in {@link #commits}. */
int headIndex;
/** Next free entry in {@link #commits} for addition at. */
int tailIndex;
boolean isFull() {
return tailIndex == BLOCK_SIZE;
}
boolean isEmpty() {
return headIndex == tailIndex;
}
boolean canUnpop() {
return headIndex > 0;
}
void add(RevCommit c) {
commits[tailIndex++] = c;
}
void unpop(RevCommit c) {
commits[--headIndex] = c;
}
RevCommit pop() {
return commits[headIndex++];
}
RevCommit peek() {
return commits[headIndex];
}
void clear() {
next = null;
headIndex = 0;
tailIndex = 0;
}
void resetToMiddle() {
headIndex = tailIndex = BLOCK_SIZE / 2;
}
void resetToEnd() {
headIndex = tailIndex = BLOCK_SIZE;
}
}
}
|
