most people don't want pagingobjects returned

start refractoring [CursorBased]PagingObject RestActions

Author: adamint

examples/src/main/kotlin/Examples.kt

@@ -8,4 +8,5 @@ pluginManagement {
     }
 }
 rootProject.name = 'SpotifyKotlinWrapper'
+include 'spotify.examples'
 

settings.gradle

@@ -0,0 +1,27 @@
+plugins {
+    id 'java'
+    id 'org.jetbrains.kotlin.jvm'
+}
+
+group 'com.adamratzman'
+version '2.0.0'
+
+sourceCompatibility = 1.8
+
+repositories {
+    mavenCentral()
+    maven { url 'https://jitpack.io' }
+}
+
+dependencies {
+    implementation 'com.github.adamint:spotify-web-api-kotlin:dev-SNAPSHOT'
+    compile "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
+    testCompile group: 'junit', name: 'junit', version: '4.12'
+}
+
+compileKotlin {
+    kotlinOptions.jvmTarget = "1.8"
+}
+compileTestKotlin {
+    kotlinOptions.jvmTarget = "1.8"
+}

spotify.examples/build.gradle

@@ -0,0 +1,17 @@
+import com.adamratzman.spotify.main.spotifyApi
+import com.adamratzman.spotify.utils.Market
+import com.adamratzman.spotify.utils.Track
+
+fun main(args:Array<String>){
+    val api = spotifyApi {
+        credentials {
+            clientId  = "79d455af5aea45c094c5cea04d167ac1"
+            clientSecret = "2ed0a8e3a946471e928c5e80b83c184d"
+        }
+    }.buildCredentialed()
+
+    //api.search.searchTrack("High Hopes", 4, market = Market.US).queue { ->
+        //items.
+
+    //}
+}

spotify.examples/src/main/kotlin/PublicExamples.kt

@@ -4,7 +4,7 @@ import java.util.concurrent.CompletableFuture
 import java.util.concurrent.TimeUnit
 import java.util.function.Supplier
 
-class SpotifyRestAction<T>(private val api: SpotifyAPI, private val supplier: Supplier<T>) {
+open class SpotifyRestAction<T>(private val api: SpotifyAPI, private val supplier: Supplier<T>) {
     fun complete(): T {
         return try {
             supplier.get()
@@ -38,4 +38,10 @@ class SpotifyRestAction<T>(private val api: SpotifyAPI, private val supplier: Su
     }
 
     override fun toString() = complete().toString()
-}
+}
+/*
+class SpotifyRestPagingAction<Z, T: PagingObject<Z>>(val api: SpotifyAPI) {
+    fun complete(): Z {
+    }
+    fun complete
+}*/

src/main/kotlin/com/adamratzman/spotify/main/SpotifyRestAction.kt

@@ -11,43 +11,19 @@ import java.net.URLEncoder
 import java.util.*
 import java.util.function.Supplier
 
-data class CursorBasedPagingObject<out T>(val href: String, val items: List<T>, val limit: Int, val next: String?, val cursors: Cursor,
-                                          val total: Int, val endpoint: SpotifyEndpoint) {
-    inline fun <reified T> getNext(): SpotifyRestAction<CursorBasedPagingObject<T>?> = endpoint.toAction(
-            Supplier {
-                catch {
-                    next?.let { endpoint.get(it).toCursorBasedPagingObject<T>(endpoint = endpoint) }
-                }
-            })
-
-    inline fun <reified T> getAll(): SpotifyRestAction<List<CursorBasedPagingObject<T>>> {
-       return  endpoint.toAction(Supplier {
-           this as CursorBasedPagingObject<T>
-           val pagingObjects = mutableListOf<CursorBasedPagingObject<T>>(this)
-           var next = getNext<T>().complete()
-           while (next != null) {
-               pagingObjects.add(next)
-               next = getNext<T>().complete()
-           }
-           pagingObjects.toList()
-       })
-    }
-
-    inline fun <reified T> getAllItems(): SpotifyRestAction<List<T>> {
-        return endpoint.toAction(Supplier {
-            getAll<T>().complete().map { it.items }.flatten()
-        })
-    }
-}
-
 data class Cursor(val after: String)
 
-data class PagingObject<out T>(val href: String, val items: List<T>, val limit: Int, val next: String? = null, val offset: Int = 0,
+class CursorBasedPagingObject<out T>(href: String, items: List<T>, limit: Int, next: String?,
+                                     val cursors: Cursor, total: Int, endpoint: SpotifyEndpoint)
+    : PagingObject<T>(href, items, limit, next, 0, null, total, endpoint)
+
+open class PagingObject<out T>(val href: String, val items: List<T>, val limit: Int, val next: String? = null, val offset: Int = 0,
                                val previous: String? = null, val total: Int, var endpoint: SpotifyEndpoint) {
     inline fun <reified T> getNext(): SpotifyRestAction<PagingObject<T>?> = endpoint.toAction(
             Supplier {
                 catch {
-                    next?.let { endpoint.get(it).toPagingObject<T>(endpoint = endpoint) }
+                    if (this is CursorBasedPagingObject) next?.let { endpoint.get(it).toCursorBasedPagingObject<T>(endpoint = endpoint) }
+                    else next?.let { endpoint.get(it).toPagingObject<T>(endpoint = endpoint) }
                 }
             })
 
@@ -62,29 +38,40 @@ data class PagingObject<out T>(val href: String, val items: List<T>, val limit:
         this as PagingObject<T>
         return endpoint.toAction(
                 Supplier {
-                    val pagingObjects = mutableListOf<PagingObject<T>>()
-                    var prev = previous?.let { getPrevious<T>().complete() }
-                    while (prev != null) {
-                        pagingObjects.add(prev)
-                        prev = prev.previous?.let { prev?.getPrevious<T>()?.complete() }
-                    }
-                    pagingObjects.reverse() // closer we are to current, the further we are from the start
-
-                    pagingObjects.add(this)
-
-                    var nxt = next?.let { getNext<T>().complete() }
-                    while (nxt != null) {
-                        pagingObjects.add(nxt)
-                        nxt = nxt.next?.let { nxt?.getNext<T>()?.complete() }
+                    if (this is CursorBasedPagingObject) {
+                        this as CursorBasedPagingObject<T>
+                        val pagingObjects = mutableListOf<CursorBasedPagingObject<T>>(this)
+                        var next = getNext<T>().complete()
+                        while (next != null) {
+                            pagingObjects.add(next as CursorBasedPagingObject<T>)
+                            next = getNext<T>().complete()
+                        }
+                        pagingObjects.toList()
+                    } else {
+                        val pagingObjects = mutableListOf<PagingObject<T>>()
+                        var prev = previous?.let { getPrevious<T>().complete() }
+                        while (prev != null) {
+                            pagingObjects.add(prev)
+                            prev = prev.previous?.let { prev?.getPrevious<T>()?.complete() }
+                        }
+                        pagingObjects.reverse() // closer we are to current, the further we are from the start
+
+                        pagingObjects.add(this)
+
+                        var nxt = next?.let { getNext<T>().complete() }
+                        while (nxt != null) {
+                            pagingObjects.add(nxt)
+                            nxt = nxt.next?.let { nxt?.getNext<T>()?.complete() }
+                        }
+                        // we don't need to reverse here, as it's in order
+                        pagingObjects.toList()
                     }
-                    // we don't need to reverse here, as it's in order
-                    pagingObjects.toList()
                 })
     }
 
     inline fun <reified T> getAllItems(): SpotifyRestAction<List<T>> {
         return endpoint.toAction(Supplier {
-            getAll<T>().complete().asSequence().map { it as PagingObject<T> }.map { it.items }.toList().flatten()
+            getAll<T>().complete().asSequence().map { it.items }.toList().flatten()
         })
     }
 }

src/main/kotlin/com/adamratzman/spotify/utils/Helpers.kt

@@ -206,5 +206,5 @@ enum class Market(val country: String) {
     ZM("Zambia"),
     ZW("Zimbabwe");
 
-    val code = name
+    val code = name;
 }