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>

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

@@ -17,18 +17,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<>(paginatedEndpoint.items());
     }
 
     @Nonnull
@@ -61,6 +61,22 @@ public PagedIterable<T> withPageSize(int size) {
         return this;
     }
 
+    Iterator<T> itemIterator() {
+        return paginatedEndpoint.items();
+    }
+
+    PaginatedEndpointItems<? extends GitHubPage<T>, T> items() {
+        return paginatedEndpoint.items();
+    }
+
+    Iterator<? extends GitHubPage<T>> pageIterator() {
+        return paginatedEndpoint.pages();
+    }
+
+    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

@@ -2,6 +2,8 @@
 
 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
 
+import java.util.Iterator;
+
 // TODO: Auto-generated Javadoc
 /**
  * {@link PagedIterable} enhanced to report search result specific information.
@@ -16,34 +18,42 @@
         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 Use {@link #pageIterator()}.peek().totalCount
      */
+    @Deprecated
     public int getTotalCount() {
         // populate();
-        return paginatedEndpoint.pages().peek().totalCount;
+        return searchPaginatedEndpoint.pages().peek().totalCount;
     }
 
     /**
      * Is incomplete boolean.
      *
      * @return the boolean
+     * @deprecated Use {@link #pageIterator()}.peek().incompleteResults
      */
+    @Deprecated
     public boolean isIncomplete() {
         // populate();
-        return paginatedEndpoint.pages().peek().incompleteResults;
+        return searchPaginatedEndpoint.pages().peek().incompleteResults;
+    }
+
+    @Override
+    public Iterator<? extends SearchResult<T>> pageIterator() {
+        return searchPaginatedEndpoint.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);
+    }
+}

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

@@ -1,8 +1,5 @@
 package org.kohsuke.github;
 
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-import org.jetbrains.annotations.NotNull;
-
 import java.io.IOException;
 import java.lang.reflect.Array;
 import java.util.*;
@@ -23,75 +20,7 @@
  */
 class PaginatedEndpoint<Page extends GitHubPage<Item>, Item> implements Iterable<Item> {
 
-    private static class ArrayIterable<I> extends PaginatedEndpoint<GitHubArrayPage<I>, I> {
-
-        private class ArrayIterator extends PaginatedEndpointPages<GitHubArrayPage<I>, I> {
-
-            ArrayIterator(GitHubClient client,
-                    Class<GitHubArrayPage<I>> pageType,
-                    GitHubRequest request,
-                    int pageSize,
-                    Consumer<I> itemInitializer) {
-                super(client, pageType, request, pageSize, itemInitializer);
-            }
-
-            @Override
-            @NotNull protected GitHubResponse<GitHubArrayPage<I>> sendNextRequest() throws IOException {
-                GitHubResponse<I[]> response = client.sendRequest(nextRequest,
-                        (connectorResponse) -> GitHubResponse.parseBody(connectorResponse, receiverType));
-                return new GitHubResponse<>(response, new GitHubArrayPage<>(response.body()));
-            }
-
-        }
-
-        private final Class<I[]> receiverType;
-
-        private ArrayIterable(GitHubClient client,
-                GitHubRequest request,
-                Class<I[]> receiverType,
-                Class<I> itemType,
-                Consumer<I> itemInitializer) {
-            super(client, request, GitHubArrayPage.getArrayPageClass(itemType), itemType, itemInitializer);
-            this.receiverType = receiverType;
-        }
-
-        @Nonnull
-        @Override
-        public PaginatedEndpointPages<GitHubArrayPage<I>, I> pages() {
-            return new ArrayIterator(client, pageType, request, pageSize, itemInitializer);
-        }
-    }
-
-    /**
-     * Represents a page of results
-     *
-     * @author Kohsuke Kawaguchi
-     * @param <I>
-     *            the generic type
-     */
-    private static class GitHubArrayPage<I> implements GitHubPage<I> {
-
-        @SuppressFBWarnings(value = { "DM_NEW_FOR_GETCLASS" }, justification = "BUG?")
-        private static <P extends GitHubPage<I>, I> Class<P> getArrayPageClass(Class<I> itemType) {
-            return (Class<P>) new GitHubArrayPage<>(itemType).getClass();
-        }
-
-        private final I[] items;
-
-        public GitHubArrayPage(I[] items) {
-            this.items = items;
-        }
-
-        private GitHubArrayPage(Class<I> itemType) {
-            this.items = null;
-        }
-
-        public I[] getItems() {
-            return items;
-        }
-    }
-
-    private static class SinglePageEndpoint<P extends GitHubPage<I>, I> extends PaginatedEndpoint<P, I> {
+    static class SinglePageEndpoint<P extends GitHubPage<I>, I> extends PaginatedEndpoint<P, I> {
         private final P page;
 
         SinglePageEndpoint(P page, Class<I> itemType) {
@@ -107,23 +36,20 @@ public PaginatedEndpointPages<P, I> pages() {
 
     }
 
-    static <I> PaginatedEndpoint<GitHubArrayPage<I>, I> fromSinglePage(I[] array, Class<I> itemType) {
-        return fromSinglePage(new GitHubArrayPage<>(array), itemType);
+    static <I> PaginatedEndpoint<GitHubPageArrayAdapter<I>, I> fromSinglePage(I[] array, Class<I> itemType) {
+        return fromSinglePage(new GitHubPageArrayAdapter<>(array), itemType);
     }
 
     static <P extends GitHubPage<I>, I> PaginatedEndpoint<P, I> fromSinglePage(P page, Class<I> itemType) {
         return new SinglePageEndpoint<>(page, itemType);
     }
 
-    static <I> PaginatedEndpoint<GitHubArrayPage<I>, I> ofArrayEndpoint(GitHubClient client,
+    static <I> PaginatedEndpoint<GitHubPage<I>, I> ofArrayEndpoint(GitHubClient client,
             GitHubRequest request,
             Class<I[]> receiverType,
             Consumer<I> itemInitializer) {
-        return new ArrayIterable<I>(client,
-                request,
-                (Class<I[]>) receiverType,
-                (Class<I>) receiverType.getComponentType(),
-                itemInitializer);
+        Class<I> itemType = (Class<I>) receiverType.getComponentType();
+        return new PaginatedArrayEndpoint<I>(client, request, receiverType, itemType, itemInitializer);
     }
 
     protected final GitHubClient client;
@@ -134,7 +60,6 @@ static <I> PaginatedEndpoint<GitHubArrayPage<I>, I> ofArrayEndpoint(GitHubClient
      * Page size. 0 is default.
      */
     protected int pageSize = 0;
-
     protected final Class<Page> pageType;
 
     protected final GitHubRequest request;
@@ -164,7 +89,7 @@ static <I> PaginatedEndpoint<GitHubArrayPage<I>, I> ofArrayEndpoint(GitHubClient
     }
 
     @Nonnull
-    public final PaginatedEndpointItems<Item> items() {
+    public final PaginatedEndpointItems<Page, Item> items() {
         return new PaginatedEndpointItems<>(this.pages());
     }