nhphong

swagger: '2.0'
info:
  title: Vector DB Client API
  version: '1.0.0'
host: 'your-api.com'
schemes:
  - https
basePath: /api/v1
produces:
  - application/json

nhphong

package com.ea.credgreen.testutils

import androidx.lifecycle.LiveData
import androidx.lifecycle.Observer
import com.ea.credgreen.assertWithTimeout

internal class DataRecorder<T> {

    private val mutex = Any()
    private val _values = mutableListOf<T?>()

nhphong

pragma solidity ^0.5.10;

import "github.com/OpenZeppelin/openzeppelin-solidity/contracts/ownership/Ownable.sol";

contract Authorizable is Ownable {
    
    address[] private _authorized;
    
    modifier onlyAuthorized() {
        require(isAuthorized(), "Authorizable: caller is not authorized");

nhphong

fun <T> Observable<T>.debounceIf(
    predicate: (T) -> Boolean,
    timeout: Long,
    unit: TimeUnit,
    scheduler: Scheduler
): Observable<T> {
    return this.publish { sharedSrc ->
        Observable.merge(
            sharedSrc.debounce(timeout, unit, scheduler)
                .filter { predicate(it) },

nhphong

val scheduler = TestScheduler()
val source = Observable.just(1)
    .doOnSubscribe {
        println("Hello World")
    }

source
    .debounceIf({ it == 1 }, 2, SECONDS, scheduler)
    .test()

nhphong

val scheduler = TestScheduler()
val source = Observable.just(1)
    .doOnSubscribe {
        println("Hello World")
    }

source
    .debounceIf({ it == 1 }, 2, SECONDS, scheduler)
    .test()

nhphong

fun <T> Observable<T>.debounceIf(
    ...
): Observable<T> {
    return Observable.merge(
        debounce(timeout, unit, scheduler)
            .filter { predicate(it) },      // The first stream
        filter { !predicate(it) }          // The second stream
    )
}

nhphong

val source = PublishSubject.create<Int>()
source
    .debounceIf({ it.isOdd }, 2, SECONDS, Schedulers.io())
    .subscribe { print(it) }

source.onNext(1)
source.onNext(2)
source.onNext(3)
source.onNext(4)
Thread.sleep(10000)

nhphong

fun <T> Observable<T>.debounceIf(
    predicate: (T) -> Boolean,
    timeout: Long,
    unit: TimeUnit,
    scheduler: Scheduler
): Observable<T> {
    return Observable.merge(
        debounce(timeout, unit, scheduler)
            .filter { predicate(it) },
        filter { !predicate(it) }

nhphong

val source = PublishSubject.create<Int>()
source
    .debounceIf({ it.isOdd }, 2, SECONDS, Schedulers.io())
    .subscribe { print(it) }

source.onNext(1)
source.onNext(2)
source.onNext(3)
source.onNext(4)
Thread.sleep(10000)