Rearraging and streamlining

Author: bitwiseman

pom.xml

@@ -145,6 +145,7 @@
     <dependency>
       <groupId>com.fasterxml.jackson.datatype</groupId>
       <artifactId>jackson-datatype-jsr310</artifactId>
+      <version>2.20.0</version>
     </dependency>
     <dependency>
       <groupId>com.github.spotbugs</groupId>
@@ -550,7 +551,6 @@
               <exclude>org.kohsuke.github.PagedIterable#toArray(org.kohsuke.github.PagedIterator)</exclude>
               <exclude>org.kohsuke.github.PagedIterable#PagedIterable()</exclude>
               <exclude>org.kohsuke.github.PagedIterator#base</exclude>
-              <exclude>org.kohsuke.github.PagedIterable#iterator()</exclude>
               <exclude>org.kohsuke.github.PagedIterator#wrapUp(java.lang.Object[])</exclude>
               <exclude>org.kohsuke.github.PagedSearchIterable#_iterator(int)</exclude>
               <exclude>org.kohsuke.github.PagedSearchIterable#adapt(java.util.Iterator)</exclude>

src/main/java/org/kohsuke/github/GitHubPage.java

@@ -1,5 +1,8 @@
 package org.kohsuke.github;
 
+import java.util.Arrays;
+import java.util.List;
+
 /**
  * A page of results from GitHub.
  *
@@ -13,4 +16,8 @@ interface GitHubPage<I> {
      * @return the items
      */
     I[] getItems();
+
+    default List<I> getItemsList() {
+        return Arrays.asList(this.getItems());
+    }
 }

src/main/java/org/kohsuke/github/GitHubPageArrayAdapter.java

@@ -0,0 +1,21 @@
+package org.kohsuke.github;
+
+/**
+ * Represents a page of results
+ *
+ * @author Kohsuke Kawaguchi
+ * @param <I>
+ *            the generic type
+ */
+class GitHubPageArrayAdapter<I> implements GitHubPage<I> {
+
+    private final I[] items;
+
+    public GitHubPageArrayAdapter(I[] items) {
+        this.items = items;
+    }
+
+    public I[] getItems() {
+        return items;
+    }
+}

src/main/java/org/kohsuke/github/PagedIterable.java

@@ -1,7 +1,6 @@
 package org.kohsuke.github;
 
 import java.io.IOException;
-import java.util.Iterator;
 import java.util.List;
 import java.util.Set;
 
@@ -17,18 +16,18 @@
  */
 public class PagedIterable<T> implements Iterable<T> {
 
-    private final PaginatedEndpoint<?, T> paginatedEndpoint;
+    private final PaginatedEndpoint<? extends GitHubPage<T>, T> paginatedEndpoint;
 
     /**
      * Instantiates a new git hub page contents iterable.
      */
-    PagedIterable(PaginatedEndpoint<?, T> paginatedEndpoint) {
+    <Page extends GitHubPage<T>> PagedIterable(PaginatedEndpoint<Page, T> paginatedEndpoint) {
         this.paginatedEndpoint = paginatedEndpoint;
     }
 
     @Nonnull
-    public final Iterator<T> iterator() {
-        return paginatedEndpoint.iterator();
+    public final PagedIterator<T> iterator() {
+        return new PagedIterator<>(items());
     }
 
     @Nonnull
@@ -61,6 +60,14 @@ public PagedIterable<T> withPageSize(int size) {
         return this;
     }
 
+    PaginatedEndpointItems<? extends GitHubPage<T>, T> items() {
+        return paginatedEndpoint.items();
+    }
+
+    PaginatedEndpointPages<? extends GitHubPage<T>, T> pages() {
+        return paginatedEndpoint.pages();
+    }
+
     GitHubResponse<T[]> toResponse() throws IOException {
         return paginatedEndpoint.toResponse();
     }

src/main/java/org/kohsuke/github/PagedIterator.java

@@ -17,17 +17,18 @@
  * @param <T>
  *            the type parameter
  */
+@Deprecated
 public class PagedIterator<T> implements Iterator<T> {
 
-    private final PaginatedEndpointItems<T> endpointIterator;
+    private final PaginatedEndpointItems<? extends GitHubPage<T>, T> endpointIterator;
 
     /**
      * Instantiates a new paged iterator.
      *
      * @param endpointIterator
      *            the base
      */
-    PagedIterator(PaginatedEndpointItems<T> endpointIterator) {
+    PagedIterator(PaginatedEndpointItems<? extends GitHubPage<T>, T> endpointIterator) {
         this.endpointIterator = endpointIterator;
     }
 

src/main/java/org/kohsuke/github/PagedSearchIterable.java

@@ -16,34 +16,35 @@
         justification = "Constructed by JSON API")
 public class PagedSearchIterable<T> extends PagedIterable<T> {
 
-    private final PaginatedEndpoint<? extends SearchResult<T>, T> paginatedEndpoint;
-
+    private final PaginatedEndpoint<? extends SearchResult<T>, T> searchPaginatedEndpoint;
     /**
      * Instantiates a new git hub page contents iterable.
      */
     <Result extends SearchResult<T>> PagedSearchIterable(PaginatedEndpoint<Result, T> paginatedEndpoint) {
         super(paginatedEndpoint);
-        this.paginatedEndpoint = paginatedEndpoint;
+        this.searchPaginatedEndpoint = paginatedEndpoint;
     }
 
     /**
      * Returns the total number of hit, including the results that's not yet fetched.
      *
      * @return the total count
      */
+    @Deprecated
     public int getTotalCount() {
         // populate();
-        return paginatedEndpoint.pages().peek().totalCount;
+        return searchPaginatedEndpoint.pages().peek().totalCount;
     }
 
     /**
      * Is incomplete boolean.
      *
      * @return the boolean
      */
+    @Deprecated
     public boolean isIncomplete() {
         // populate();
-        return paginatedEndpoint.pages().peek().incompleteResults;
+        return searchPaginatedEndpoint.pages().peek().incompleteResults;
     }
 
     /**
@@ -57,4 +58,16 @@ public boolean isIncomplete() {
     public PagedSearchIterable<T> withPageSize(int size) {
         return (PagedSearchIterable<T>) super.withPageSize(size);
     }
+
+    @Override
+    PaginatedEndpointItems<? extends GitHubPage<T>, T> items() {
+        // TODO Auto-generated method stub
+        return super.items();
+    }
+
+    @Override
+    PaginatedEndpointPages<? extends GitHubPage<T>, T> pages() {
+        // TODO Auto-generated method stub
+        return super.pages();
+    }
 }

src/main/java/org/kohsuke/github/PaginatedArrayEndpoint.java

@@ -0,0 +1,73 @@
+package org.kohsuke.github;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.io.IOException;
+import java.util.*;
+import java.util.function.Consumer;
+
+import javax.annotation.Nonnull;
+
+/**
+ * {@link PaginatedEndpoint} implementation that take a {@link Consumer} that initializes all the items on each page as
+ * they are retrieved.
+ *
+ * {@link PaginatedEndpoint} is immutable and thread-safe, but the iterator returned from {@link #iterator()} is not.
+ * Any one instance of iterator should only be called from a single thread.
+ *
+ * @author Liam Newman
+ * @param <Item>
+ *            the type of items on each page
+ */
+class PaginatedArrayEndpoint<Item> extends PaginatedEndpoint<GitHubPage<Item>, Item> {
+
+    private class ArrayPages extends PaginatedEndpointPages<GitHubPage<Item>, Item> {
+
+        ArrayPages(GitHubClient client,
+                Class<GitHubPage<Item>> pageType,
+                GitHubRequest request,
+                int pageSize,
+                Consumer<Item> itemInitializer) {
+            super(client, pageType, request, pageSize, itemInitializer);
+        }
+
+        @Override
+        @NotNull protected GitHubResponse<GitHubPage<Item>> sendNextRequest() throws IOException {
+            GitHubResponse<Item[]> response = client.sendRequest(nextRequest,
+                    (connectorResponse) -> GitHubResponse.parseBody(connectorResponse, arrayReceiverType));
+            return new GitHubResponse<>(response, new GitHubPageArrayAdapter<>(response.body()));
+        }
+    }
+
+    /**
+     * Pretend to get a specific page class type for the sake of the compile time strong typing.
+     *
+     * This class never uses {@code pageType}, so it is safe to pass null as the actual class value.
+     *
+     * @param <I>
+     *            The type of items in the array page.
+     * @param itemType
+     *            The class instance for items in the array page.
+     * @return Always null, but cast to the appropriate class for compile time strong typing.
+     */
+    private static <I> Class<GitHubPage<I>> getArrayPageClass(Class<I> itemType) {
+        return (Class<GitHubPage<I>>) null;
+    }
+
+    private final Class<Item[]> arrayReceiverType;
+
+    PaginatedArrayEndpoint(GitHubClient client,
+            GitHubRequest request,
+            Class<Item[]> arrayReceiverType,
+            Class<Item> itemType,
+            Consumer<Item> itemInitializer) {
+        super(client, request, getArrayPageClass(itemType), itemType, itemInitializer);
+        this.arrayReceiverType = arrayReceiverType;
+    }
+
+    @Nonnull
+    @Override
+    public PaginatedEndpointPages<GitHubPage<Item>, Item> pages() {
+        return new ArrayPages(client, pageType, request, pageSize, itemInitializer);
+    }
+}