com.squareup.sqldelight.runtime.rx.QueryObservable.kt Maven / Gradle / Ivy

Go to download
package com.squareup.sqldelight.runtime.rx

import com.squareup.sqldelight.Query
import io.reactivex.Observable
import io.reactivex.Observer
import io.reactivex.Scheduler
import io.reactivex.annotations.CheckReturnValue
import io.reactivex.disposables.Disposable
import io.reactivex.schedulers.Schedulers
import java.util.Optional
import java.util.concurrent.atomic.AtomicBoolean

/**
 * Turns this [Query] into an [Observable] which emits whenever the underlying result set changes.
 *
 * ### Scheduler:
 *   [observe] by default operates on the [io.reactivex.schedulers.Schedulers.io] scheduler but can
 *   be optionally overridden with [scheduler]
 */
@CheckReturnValue
fun  Query.observe(scheduler: Scheduler = Schedulers.io()): QueryObservable {
  return QueryObservable(this, scheduler)
}

class QueryObservable(
  private val query: Query,
  private val scheduler: Scheduler
) : Observable>() {
  override fun subscribeActual(observer: Observer>) {
    val listener = Listener(query, observer, scheduler)
    observer.onSubscribe(listener)
    query.addListener(listener)
    listener.queryResultsChanged()
  }

  @CheckReturnValue
  fun mapToOne(): Observable {
    return map { it.executeAsOne() }
  }

  @CheckReturnValue
  fun mapToOneOrDefault(defaultValue: RowType): Observable {
    return map { it.executeAsOneOrNull() ?: defaultValue }
  }

  @CheckReturnValue
  fun mapToOptional(): Observable> {
    return map { Optional.ofNullable(it.executeAsOneOrNull()) }
  }

  @CheckReturnValue
  fun mapToList(): Observable> {
    return map { it.executeAsList() }
  }

  @CheckReturnValue
  fun mapToOneNonNull(): Observable {
    return flatMap {
      val result = it.executeAsOneOrNull()
      if (result == null) Observable.empty() else Observable.just(result)
    }
  }
}

private class Listener(
    private val query: Query,
    private val observer: Observer>,
    private val scheduler: Scheduler
) : Query.Listener, Disposable {
  private val unsubscribed = AtomicBoolean()

  override fun isDisposed() = unsubscribed.get()

  override fun dispose() {
    if (unsubscribed.compareAndSet(false, true)) {
      query.removeListener(this)
    }
  }

  override fun queryResultsChanged() {
    if (!isDisposed) {
      scheduler.scheduleDirect {
        observer.onNext(query)
      }
    }
  }
}