FilesExpand file tree

 main

/

PagedIterable.java

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

165 lines (148 loc) · 4.56 KB

 main

/

PagedIterable.java

Copy path

Top

File metadata and controls

• Code
• Blame

165 lines (148 loc) · 4.56 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

159

160

161

162

163

164

165

package org.kohsuke.github;

import java.io.IOException;

import java.lang.reflect.Array;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.LinkedHashSet;

import java.util.List;

import java.util.Set;

import javax.annotation.Nonnull;

// TODO: Auto-generated Javadoc

/**

* {@link Iterable} that returns {@link PagedIterator}. {@link PagedIterable} is thread-safe but {@link PagedIterator}

* is not. Any one instance of {@link PagedIterator} should only be called from a single thread.

*

* @author Kohsuke Kawaguchi

* @param <T>

* the type of items on each page

*/

public abstract class PagedIterable<T> implements Iterable<T> {

/**

* Page size. 0 is default.

*/

private int pageSize = 0;

/**

* Instantiate a PagedIterable.

*/

public PagedIterable() {

}

/**

* Iterator over page items.

*

* @param pageSize

* the page size

* @return the paged iterator

*/

@Nonnull

public abstract PagedIterator<T> _iterator(int pageSize);

/**

* Returns an iterator over elements of type {@code T}.

*

* @return an Iterator.

*/

@Nonnull

public final PagedIterator<T> iterator() {

return _iterator(pageSize);

}

/**

* Eagerly walk {@link Iterable} and return the result in an array.

*

* @return the list

* @throws IOException

* if an I/O exception occurs.

*/

@Nonnull

public T[] toArray() throws IOException {

return toArray(iterator());

}

/**

* Eagerly walk {@link Iterable} and return the result in a list.

*

* @return the list

* @throws IOException

* if an I/O Exception occurs

*/

@Nonnull

public List<T> toList() throws IOException {

return Collections.unmodifiableList(Arrays.asList(this.toArray()));

}

/**

* Eagerly walk {@link Iterable} and return the result in a set.

*

* @return the set

* @throws IOException

* if an I/O Exception occurs

*/

@Nonnull

public Set<T> toSet() throws IOException {

return Collections.unmodifiableSet(new LinkedHashSet<>(Arrays.asList(this.toArray())));

}

/**

* Sets the pagination size.

*

* <p>

* When set to non-zero, each API call will retrieve this many entries.

*

* @param size

* the size

* @return the paged iterable

*/

public PagedIterable<T> withPageSize(int size) {

this.pageSize = size;

return this;

}

/**

* Concatenates a list of arrays into a single array.

*

* @param type

* the type of array to be returned.

* @param pages

* the list of arrays to be concatenated.

* @param totalLength

* the total length of the returned array.

* @return an array containing all elements from all pages.

*/

@Nonnull

private T[] concatenatePages(Class<T[]> type, List<T[]> pages, int totalLength) {

T[] result = type.cast(Array.newInstance(type.getComponentType(), totalLength));

int position = 0;

for (T[] page : pages) {

final int pageLength = Array.getLength(page);

System.arraycopy(page, 0, result, position, pageLength);

position += pageLength;

}

return result;

}

/**

* Eagerly walk {@link PagedIterator} and return the result in an array.

*

* @param iterator

* the {@link PagedIterator} to read

* @return an array of all elements from the {@link PagedIterator}

* @throws IOException

* if an I/O exception occurs.

*/

protected T[] toArray(final PagedIterator<T> iterator) throws IOException {

try {

ArrayList<T[]> pages = new ArrayList<>();

int totalSize = 0;

T[] item;

do {

item = iterator.nextPageArray();

totalSize += Array.getLength(item);

pages.add(item);

} while (iterator.hasNext());

Class<T[]> type = (Class<T[]>) item.getClass();

return concatenatePages(type, pages, totalSize);

} catch (GHException e) {

// if there was an exception inside the iterator it is wrapped as a GHException

// if the wrapped exception is an IOException, throw that

if (e.getCause() instanceof IOException) {

throw (IOException) e.getCause();

} else {

throw e;

}

}

}

}