remove reflection from spotifyuri

Author: adamint

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

@@ -5,8 +5,22 @@ import com.adamratzman.spotify.models.AbstractPagingObject
 import com.adamratzman.spotify.utils.TimeUnit
 import com.adamratzman.spotify.utils.getCurrentTimeMs
 import com.adamratzman.spotify.utils.schedule
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.FlowPreview
 import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.asFlow
+import kotlinx.coroutines.flow.emitAll
+import kotlinx.coroutines.flow.flatMapConcat
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+import kotlin.coroutines.suspendCoroutine
 
 /**
  * Provides a uniform interface to retrieve, whether synchronously or asynchronously, [T] from Spotify
@@ -39,25 +53,49 @@ open class SpotifyRestAction<T> internal constructor(protected val api: SpotifyA
         }
     }
 
+    /**
+     * Suspend the coroutine, invoke [SpotifyRestAction.supplier] asynchronously/queued and resume with result [T]
+     * */
+    suspend fun <T> SpotifyRestAction<T>.suspendQueue(): T {
+        return suspendCoroutine { continuation ->
+            queue({ throwable ->
+                continuation.resumeWithException(throwable)
+            }) { result ->
+                continuation.resume(result)
+            }
+        }
+    }
+
+    /**
+     * Switch to given [context][dispatcher], invoke [SpotifyRestAction.supplier] and synchronously retrieve [T]
+     *
+     * @param dispatcher The context to execute the [SpotifyRestAction.complete] in
+     * */
+    @Suppress("UNCHECKED_CAST")
+    suspend fun <T> suspendComplete(dispatcher: CoroutineDispatcher = Dispatchers.Default): T =
+        withContext(dispatcher) {
+            complete() as T
+        }
+
     /**
      * Invoke [supplier] asynchronously with no consumer
      */
-    fun queue(): SpotifyRestAction<T> = queue({}, { throw it })
+    fun queue(): SpotifyRestAction<T> = queue({ throw it }, {})
 
     /**
      * Invoke [supplier] asynchronously and consume [consumer] with the [T] value returned
      *
      * @param consumer to be invoked with [T] after successful completion of [supplier]
      */
-    fun queue(consumer: (T) -> Unit): SpotifyRestAction<T> = queue(consumer, {})
+    fun queue(consumer: (T) -> Unit): SpotifyRestAction<T> = queue({ throw it }, consumer)
 
     /**
      * Invoke [supplier] asynchronously and consume [consumer] with the [T] value returned
      *
      * @param failure Consumer to invoke when an exception is thrown by [supplier]
      * @param consumer to be invoked with [T] after successful completion of [supplier]
      */
-    fun queue(consumer: ((T) -> Unit), failure: ((Throwable) -> Unit)): SpotifyRestAction<T> {
+    fun queue(failure: ((Throwable) -> Unit), consumer: ((T) -> Unit)): SpotifyRestAction<T> {
         hasRunBacking = true
         GlobalScope.launch {
             try {
@@ -111,3 +149,48 @@ class SpotifyRestActionPaging<Z : Any, T : AbstractPagingObject<Z>>(api: Spotify
         }
     }
 }
+
+/**
+ * Flow the paging action ordered. This can be less performant than [flow] if you are in the middle of the pages.
+ * */
+@Suppress("UNCHECKED_CAST")
+@FlowPreview
+@ExperimentalCoroutinesApi
+fun <Z : Any, T : AbstractPagingObject<Z>> SpotifyRestActionPaging<Z, T>.flowOrdered(): Flow<T> = flow<T> {
+    emitAll(flowPagingObjectsOrdered().flatMapConcat { it.asFlow() as Flow<T> })
+}.flowOn(Dispatchers.Default)
+
+/**
+ * Flow the paging objects ordered. This can be less performant than [flowPagingObjects] if you are in the middle of the pages.
+ * */
+@ExperimentalCoroutinesApi
+fun <Z : Any, T : AbstractPagingObject<Z>> SpotifyRestActionPaging<Z, T>.flowPagingObjectsOrdered(): Flow<AbstractPagingObject<Z>> =
+    flow<AbstractPagingObject<Z>> {
+        complete().also { master ->
+            emitAll(master.flowStartOrdered())
+            emit(master)
+            emitAll(master.flowEndOrdered())
+        }
+    }.flowOn(Dispatchers.Default)
+
+/**
+ * Flow the Paging action.
+ * */
+@FlowPreview
+@ExperimentalCoroutinesApi
+fun <Z : Any, T : AbstractPagingObject<Z>> SpotifyRestActionPaging<Z, T>.flow(): Flow<Z> = flow<Z> {
+    emitAll(flowPagingObjects().flatMapConcat { it.asFlow() })
+}.flowOn(Dispatchers.Default)
+
+/**
+ * Flow the paging objects.
+ * */
+@ExperimentalCoroutinesApi
+fun <Z : Any, T : AbstractPagingObject<Z>> SpotifyRestActionPaging<Z, T>.flowPagingObjects(): Flow<AbstractPagingObject<Z>> =
+    flow<AbstractPagingObject<Z>> {
+        complete().also { master ->
+            emitAll(master.flowBackward())
+            emit(master)
+            emitAll(master.flowForward())
+        }
+    }.flowOn(Dispatchers.Default)

src/commonMain/kotlin/com.adamratzman.spotify/models/PagingObjects.kt

@@ -5,11 +5,18 @@ import com.adamratzman.spotify.SpotifyApi
 import com.adamratzman.spotify.http.SpotifyEndpoint
 import com.adamratzman.spotify.models.serialization.toCursorBasedPagingObject
 import com.adamratzman.spotify.models.serialization.toPagingObject
-import com.adamratzman.spotify.utils.catch
-import kotlin.reflect.KClass
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.asFlow
+import kotlinx.coroutines.flow.emitAll
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.toList
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.Transient
+import kotlin.reflect.KClass
 
 /*
     Types used in PagingObjects and CursorBasedPagingObjects:
@@ -59,24 +66,6 @@ class PagingObject<T : Any>(
     override val previous: String?,
     override val total: Int
 ) : AbstractPagingObject<T>(href, items, limit, next, offset, previous, total) {
-    /**
-     * Get the next set of [T] items
-     */
-    fun getNext() = endpoint!!.toAction {
-        catch {
-            getImpl(PagingTraversalType.FORWARDS) as? PagingObject<T>
-        }
-    }
-
-    /**
-     * Get the previous set of [T] items
-     */
-    fun getPrevious() = endpoint!!.toAction {
-        catch {
-            getImpl(PagingTraversalType.BACKWARDS) as? PagingObject<T>
-        }
-    }
-
     @Suppress("UNCHECKED_CAST")
     override fun getImpl(type: PagingTraversalType): AbstractPagingObject<T>? {
         val endpointFinal = endpoint!!
@@ -97,20 +86,20 @@ class PagingObject<T : Any>(
     }
 
     override fun getAllImpl(): Sequence<AbstractPagingObject<T>> {
-        val pagingObjects = mutableListOf<PagingObject<T>>()
-        var prev = previous?.let { getPrevious().complete() }
+        val pagingObjects = mutableListOf<AbstractPagingObject<T>>()
+        var prev = previous?.let { getPrevious() }
         while (prev != null) {
             pagingObjects.add(prev)
-            prev = prev.previous?.let { prev?.getPrevious()?.complete() }
+            prev = prev.previous?.let { prev?.getPrevious() }
         }
         pagingObjects.reverse() // closer we are to current, the further we are from the start
 
         pagingObjects.add(this)
 
-        var nxt = next?.let { getNext().complete() }
+        var nxt = next?.let { getNext() }
         while (nxt != null) {
             pagingObjects.add(nxt)
-            nxt = nxt.next?.let { nxt?.getNext()?.complete() }
+            nxt = nxt.next?.let { nxt?.getNext() }
         }
         // we don't need to reverse here, as it's in order
         return pagingObjects.asSequence()
@@ -149,15 +138,6 @@ class CursorBasedPagingObject<T : Any>(
     @SerialName("cursors") val cursor: Cursor,
     override val total: Int
 ) : AbstractPagingObject<T>(href, items, limit, next, 0, null, total) {
-    /**
-     * Get the next set of [T] items
-     */
-    fun getNext() = endpoint!!.toAction {
-        catch {
-            getImpl(PagingTraversalType.FORWARDS) as? CursorBasedPagingObject<T>
-        }
-    }
-
     /**
      * Get all CursorBasedPagingObjects associated with the request
      */
@@ -226,7 +206,29 @@ abstract class AbstractPagingObject<T : Any>(
     @Transient open val offset: Int = 0,
     @Transient open val previous: String? = null,
     @Transient open val total: Int = -1
-) {
+) : List<T> {
+    override val size: Int = items.size
+
+    override fun contains(element: T) = items.contains(element)
+
+    override fun containsAll(elements: Collection<T>) = items.containsAll(elements)
+
+    override fun get(index: Int) = items[index]
+
+    override fun indexOf(element: T) = items.indexOf(element)
+
+    override fun isEmpty() = items.isEmpty()
+
+    override fun iterator() = items.iterator()
+
+    override fun lastIndexOf(element: T) = items.lastIndexOf(element)
+
+    override fun listIterator() = items.listIterator()
+
+    override fun listIterator(index: Int) = items.listIterator(index)
+
+    override fun subList(fromIndex: Int, toIndex: Int) = items.subList(fromIndex, toIndex)
+
     @Transient
     internal var endpoint: SpotifyEndpoint? = null
 
@@ -236,13 +238,56 @@ abstract class AbstractPagingObject<T : Any>(
     internal abstract fun getImpl(type: PagingTraversalType): AbstractPagingObject<T>?
     internal abstract fun getAllImpl(): Sequence<AbstractPagingObject<T>>
 
-    internal fun getNextImpl() = getImpl(PagingTraversalType.FORWARDS)
-    internal fun getPreviousImpl() = getImpl(PagingTraversalType.BACKWARDS)
+    private fun getNextImpl() = getImpl(PagingTraversalType.FORWARDS)
+    private fun getPreviousImpl() = getImpl(PagingTraversalType.BACKWARDS)
+
+
+    fun getNext(): AbstractPagingObject<T>? = getNextImpl()
+    fun getPrevious(): AbstractPagingObject<T>? = getPreviousImpl()
+
+    /**
+     * Flow from current page backwards.
+     * */
+    @ExperimentalCoroutinesApi
+    fun flowBackward(): Flow<AbstractPagingObject<T>> = flow<AbstractPagingObject<T>> {
+        if (previous == null) return@flow
+        var next = getPrevious()
+        while (next != null) {
+            emit(next)
+            next = next.getPrevious()
+        }
+    }.flowOn(Dispatchers.Default)
+
+    /**
+     * Flow from current page forwards.
+     * */
+    @ExperimentalCoroutinesApi
+    fun flowForward(): Flow<AbstractPagingObject<T>> = flow<AbstractPagingObject<T>> {
+        if (next == null) return@flow
+        var next = getNext()
+        while (next != null) {
+            emit(next)
+            next = next.getNext()
+        }
+    }.flowOn(Dispatchers.Default)
+
+    @ExperimentalCoroutinesApi
+    fun flowStartOrdered(): Flow<AbstractPagingObject<T>> =
+        flow<AbstractPagingObject<T>> {
+            if (previous == null) return@flow
+            flowBackward().toList().reversed().also {
+                emitAll(it.asFlow())
+            }
+        }.flowOn(Dispatchers.Default)
+
+    @ExperimentalCoroutinesApi
+    fun flowEndOrdered(): Flow<AbstractPagingObject<T>> = flowForward()
+
 }
 
-internal fun Any.instantiatePagingObjects(spotifyAPI: SpotifyApi) = when (this) {
-    is FeaturedPlaylists -> this.playlists
+internal fun Any.instantiatePagingObjects(spotifyApi: SpotifyApi) = when (this) {
+     is FeaturedPlaylists -> this.playlists
     is Album -> this.tracks
-    is Playlist -> this.tracks
+     is Playlist -> this.tracks
     else -> null
-}.let { it?.endpoint = spotifyAPI.tracks; this }
+}.let { it?.endpoint = spotifyApi.tracks; this }

src/commonMain/kotlin/com.adamratzman.spotify/models/SpotifyUris.kt

@@ -70,7 +70,7 @@ sealed class SpotifyUri(val input: String, val type: UriType) {
     }
 
     override fun toString(): String {
-        return "${this::class.simpleName}($uri)"
+        return "SpotifyUri($uri)"
     }
 
     enum class UriType(private val typeStr: String) {

src/jvmMain/kotlin/com/adamratzman/spotify/utils/Concurrency.kt

@@ -1,9 +1,11 @@
 /* Spotify Web API - Kotlin Wrapper; MIT License, 2019; Original author: Adam Ratzman */
 package com.adamratzman.spotify.utils
 
+import com.adamratzman.spotify.SpotifyRestAction
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
+import java.util.concurrent.CompletableFuture
 
 actual typealias TimeUnit = java.util.concurrent.TimeUnit
 
@@ -17,3 +19,5 @@ actual fun CoroutineScope.schedule(
         consumer()
     }
 }
+
+fun <T> SpotifyRestAction<T>.asFuture() = CompletableFuture.supplyAsync(supplier)