FilesExpand file tree

 main

/

PagedIterator.java

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

158 lines (143 loc) · 4.89 KB

 main

/

PagedIterator.java

Copy path

Top

File metadata and controls

• Code
• Blame

158 lines (143 loc) · 4.89 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

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

152

153

154

155

156

157

158

package org.kohsuke.github;

import java.util.Arrays;

import java.util.Iterator;

import java.util.List;

import java.util.NoSuchElementException;

import java.util.Objects;

import java.util.function.Consumer;

import javax.annotation.CheckForNull;

import javax.annotation.Nonnull;

// TODO: Auto-generated Javadoc

/**

* Iterator over a paginated data source. Iterates of the content items of each page, automatically requesting new pages

* as needed.

* <p>

* Aside from the normal iterator operation, this method exposes {@link #nextPage()} and {@link #nextPageArray()} that

* allows the caller to retrieve entire pages.

*

* This class is not thread-safe. Any one instance should only be called from a single thread.

*

* @author Kohsuke Kawaguchi

* @param <T>

* the type parameter

*/

public class PagedIterator<T> implements Iterator<T> {

/**

* Current batch of items. Each time {@link #next()} is called the next item in this array will be returned. After

* the last item of the array is returned, when {@link #next()} is called again, a new page of items will be fetched

* and iterating will continue from the first item in the new page.

*

* @see #fetch() {@link #fetch()} for details on how this field is used.

*/

private T[] currentPage;

@CheckForNull

private final Consumer<T> itemInitializer;

/**

* The index of the next item on the page, the item that will be returned when {@link #next()} is called.

*

* @see #fetch() {@link #fetch()} for details on how this field is used.

*/

private int nextItemIndex;

/** The base. */

@Nonnull

protected final Iterator<T[]> base;

/**

* Instantiates a new paged iterator.

*

* @param base

* the base

* @param itemInitializer

* the item initializer

*/

PagedIterator(@Nonnull Iterator<T[]> base, @CheckForNull Consumer<T> itemInitializer) {

this.base = base;

this.itemInitializer = itemInitializer;

}

/**

* {@inheritDoc}

*/

public boolean hasNext() {

fetch();

return (currentPage != null && currentPage.length > nextItemIndex);

}

/**

* {@inheritDoc}

*/

public T next() {

if (!hasNext())

throw new NoSuchElementException();

return currentPage[nextItemIndex++];

}

/**

* Gets the next page worth of data.

*

* @return the list

*/

public List<T> nextPage() {

return Arrays.asList(nextPageArray());

}

/**

* Fetch is called at the start of {@link #next()} or {@link #hasNext()} to fetch another page of data if it is

* needed and available.

* <p>

* If there is no current page yet (at the start of iterating), a page is fetched. If {@link #nextItemIndex} points

* to an item in the current page array, the state is valid - no more work is needed. If {@link #nextItemIndex} is

* greater than the last index in the current page array, the method checks if there is another page of data

* available.

* </p>

* <p>

* If there is another page, get that page of data and reset the check {@link #nextItemIndex} to the start of the

* new page.

* </p>

* <p>

* If no more pages are available, leave the page and index unchanged. In this case, {@link #hasNext()} will return

* {@code false} and {@link #next()} will throw an exception.

* </p>

*/

private void fetch() {

if ((currentPage == null || currentPage.length <= nextItemIndex) && base.hasNext()) {

// On first call, always get next page (may be empty array)

T[] result = Objects.requireNonNull(base.next());

wrapUp(result);

currentPage = result;

nextItemIndex = 0;

}

}

/**

* This poorly named method, initializes items with local data after they are fetched. It is up to the implementer

* to decide what local data to apply.

*

* @param page

* the page of items to be initialized

*/

protected void wrapUp(T[] page) {

if (itemInitializer != null) {

for (T item : page) {

itemInitializer.accept(item);

}

}

}

/**

* Gets the next page worth of data.

*

* @return the list

*/

@Nonnull

T[] nextPageArray() {

// if we have not fetched any pages yet, always fetch.

// If we have fetched at least one page, check hasNext()

if (currentPage == null) {

fetch();

} else if (!hasNext()) {

throw new NoSuchElementException();

}

// Current should never be null after fetch

Objects.requireNonNull(currentPage);

T[] r = currentPage;

if (nextItemIndex != 0) {

r = Arrays.copyOfRange(r, nextItemIndex, r.length);

}

nextItemIndex = currentPage.length;

return r;

}

}