update kotlin version

fengzhizi715 · Oct 9, 2023 · b22eb44 · b22eb44
1 parent 9d23bdf
commit b22eb44
Show file tree

Hide file tree

Showing 10 changed files with 33 additions and 33 deletions.
diff --git a/build.gradle b/build.gradle
@@ -60,7 +60,7 @@ dependencies {
 }
 
 buildscript {
-    ext.kotlin_version = '1.7.21'
+    ext.kotlin_version = '1.8.21'
 
     repositories {
         jcenter()

diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
@@ -2,4 +2,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.1.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.5.1-bin.zip
diff --git a/rxjava/rxjava3/src/main/kotlin/com/safframework/rxcache/rxjava/rxjava3/RxCache+Extension.kt b/rxjava/rxjava3/src/main/kotlin/com/safframework/rxcache/rxjava/rxjava3/RxCache+Extension.kt
@@ -16,19 +16,19 @@ import java.lang.reflect.Type
  * @version: V1.0 <描述当前版本功能>
  */
 
-fun <T> RxCache.transformObservable(
+fun <T:Any> RxCache.transformObservable(
     key: String,
     type: Type,
     strategy: ObservableStrategy
 ): ObservableTransformer<T, Record<T>> {
     return ObservableTransformer<T, Record<T>> { upstream -> strategy.execute(this, key, upstream, type) }
 }
 
-fun <T> RxCache.transformFlowable(key: String, type: Type, strategy: FlowableStrategy): FlowableTransformer<T, Record<T>> {
+fun <T:Any> RxCache.transformFlowable(key: String, type: Type, strategy: FlowableStrategy): FlowableTransformer<T, Record<T>> {
     return FlowableTransformer { upstream -> strategy.execute(this, key, upstream, type) }
 }
 
-fun <T> RxCache.transformFlowable(
+fun <T:Any> RxCache.transformFlowable(
     key: String,
     type: Type,
     strategy: FlowableStrategy,
@@ -37,15 +37,15 @@ fun <T> RxCache.transformFlowable(
     return FlowableTransformer { upstream -> strategy.execute(this, key, upstream, type, backpressureStrategy) }
 }
 
-fun <T> RxCache.transformSingle(key: String, type: Type, strategy: SingleStrategy): SingleTransformer<T, Record<T>> {
+fun <T:Any> RxCache.transformSingle(key: String, type: Type, strategy: SingleStrategy): SingleTransformer<T, Record<T>> {
     return SingleTransformer { upstream -> strategy.execute(this, key, upstream, type) }
 }
 
 fun <T> RxCache.transformCompletable(key: String, type: Type, strategy: CompletableStrategy): CompletableTransformer {
     return CompletableTransformer { upstream -> strategy.execute(this, key, upstream, type) }
 }
 
-fun <T> RxCache.transformMaybe(key: String, type: Type, strategy: MaybeStrategy): MaybeTransformer<T, Record<T>> {
+fun <T:Any> RxCache.transformMaybe(key: String, type: Type, strategy: MaybeStrategy): MaybeTransformer<T, Record<T>> {
     return MaybeTransformer { upstream -> strategy.execute(this, key, upstream, type) }
 }
 
@@ -81,17 +81,17 @@ fun <T> RxCache.load2Maybe(key: String, type: Type): Maybe<Record<T>> {
     } else Maybe.empty()
 }
 
-inline fun <reified T> RxCache.transformObservable(key: String, strategy: ObservableStrategy): ObservableTransformer<T, Record<T>> = transformObservable<T>(key, object : TypeToken<T>() {}.type, strategy)
+inline fun <reified T:Any> RxCache.transformObservable(key: String, strategy: ObservableStrategy): ObservableTransformer<T, Record<T>> = transformObservable<T>(key, object : TypeToken<T>() {}.type, strategy)
 
-inline fun <reified T> RxCache.transformFlowable(key: String, strategy: FlowableStrategy): FlowableTransformer<T, Record<T>> = transformFlowable<T>(key, object : TypeToken<T>() {}.type, strategy)
+inline fun <reified T:Any> RxCache.transformFlowable(key: String, strategy: FlowableStrategy): FlowableTransformer<T, Record<T>> = transformFlowable<T>(key, object : TypeToken<T>() {}.type, strategy)
 
-inline fun <reified T> RxCache.transformFlowable(key: String, strategy: FlowableStrategy, backpressureStrategy: BackpressureStrategy): FlowableTransformer<T, Record<T>> = transformFlowable<T>(key, object : TypeToken<T>() {}.type, strategy, backpressureStrategy)
+inline fun <reified T:Any> RxCache.transformFlowable(key: String, strategy: FlowableStrategy, backpressureStrategy: BackpressureStrategy): FlowableTransformer<T, Record<T>> = transformFlowable<T>(key, object : TypeToken<T>() {}.type, strategy, backpressureStrategy)
 
-inline fun <reified T> RxCache.transformSingle(key: String, strategy: SingleStrategy): SingleTransformer<T, Record<T>> = transformSingle<T>(key, object : TypeToken<T>() {}.type, strategy)
+inline fun <reified T:Any> RxCache.transformSingle(key: String, strategy: SingleStrategy): SingleTransformer<T, Record<T>> = transformSingle<T>(key, object : TypeToken<T>() {}.type, strategy)
 
 inline fun <reified T> RxCache.transformCompletable(key: String, strategy: CompletableStrategy): CompletableTransformer = transformCompletable<T>(key, object : TypeToken<T>() {}.type, strategy)
 
-inline fun <reified T> RxCache.transformMaybe(key: String, strategy: MaybeStrategy): MaybeTransformer<T, Record<T>> = transformMaybe<T>(key, object : TypeToken<T>() {}.type, strategy)
+inline fun <reified T:Any> RxCache.transformMaybe(key: String, strategy: MaybeStrategy): MaybeTransformer<T, Record<T>> = transformMaybe<T>(key, object : TypeToken<T>() {}.type, strategy)
 
 
 inline fun <reified T> RxCache.load2Observable(key: String): Observable<Record<T>> = load2Observable<T>(key, object : TypeToken<T>() {}.type)

diff --git a/.../com/safframework/rxcache/rxjava/rxjava3/transformstrategy/impl/CacheAndRemoteStrategy.kt b/.../com/safframework/rxcache/rxjava/rxjava3/transformstrategy/impl/CacheAndRemoteStrategy.kt
@@ -27,7 +27,7 @@ import java.util.*
  */
 class CacheAndRemoteStrategy : ObservableStrategy, FlowableStrategy, MaybeStrategy {
 
-    override fun <T> execute(rxCache: RxCache, key: String, source: Flowable<T>, type: Type): Publisher<Record<T>> {
+    override fun <T:Any> execute(rxCache: RxCache, key: String, source: Flowable<T>, type: Type): Publisher<Record<T>> {
         val cache: Flowable<Record<T>> = rxCache.load2Flowable(key, type)
         val remote: Flowable<Record<T>> = source
             .map{ t ->
@@ -38,7 +38,7 @@ class CacheAndRemoteStrategy : ObservableStrategy, FlowableStrategy, MaybeStrate
             .filter{ record -> record.data != null }
     }
 
-    override fun <T> execute(
+    override fun <T:Any> execute(
         rxCache: RxCache,
         key: String,
         source: Flowable<T>,
@@ -67,7 +67,7 @@ class CacheAndRemoteStrategy : ObservableStrategy, FlowableStrategy, MaybeStrate
             .firstElement()
     }
 
-    override fun <T> execute(rxCache: RxCache, key: String, source: Observable<T>, type: Type): Observable<Record<T>> {
+    override fun <T:Any> execute(rxCache: RxCache, key: String, source: Observable<T>, type: Type): Observable<Record<T>> {
         val cache: Observable<Record<T>> = rxCache.load2Observable(key, type)
         val remote: Observable<Record<T>> = source
             .map{ t ->

diff --git a/...tlin/com/safframework/rxcache/rxjava/rxjava3/transformstrategy/impl/CacheFirstStrategy.kt b/...tlin/com/safframework/rxcache/rxjava/rxjava3/transformstrategy/impl/CacheFirstStrategy.kt
@@ -26,7 +26,7 @@ import java.lang.reflect.Type
  */
 class CacheFirstStrategy : ObservableStrategy, FlowableStrategy, MaybeStrategy {
 
-    override fun <T> execute(rxCache: RxCache, key: String, source: Flowable<T>, type: Type): Publisher<Record<T>> {
+    override fun <T:Any> execute(rxCache: RxCache, key: String, source: Flowable<T>, type: Type): Publisher<Record<T>> {
         val cache: Flowable<Record<T>> = rxCache.load2Flowable(key, type)
         val remote: Flowable<Record<T>> = source
             .map{ t ->
@@ -36,7 +36,7 @@ class CacheFirstStrategy : ObservableStrategy, FlowableStrategy, MaybeStrategy {
         return cache.switchIfEmpty(remote)
     }
 
-    override fun <T> execute(
+    override fun <T:Any> execute(
         rxCache: RxCache,
         key: String,
         source: Flowable<T>,
@@ -62,7 +62,7 @@ class CacheFirstStrategy : ObservableStrategy, FlowableStrategy, MaybeStrategy {
         return cache.switchIfEmpty(remote)
     }
 
-    override fun <T> execute(
+    override fun <T:Any> execute(
         rxCache: RxCache,
         key: String,
         source: Observable<T>,

diff --git a/...m/safframework/rxcache/rxjava/rxjava3/transformstrategy/impl/CacheFirstTimeoutStrategy.kt b/...m/safframework/rxcache/rxjava/rxjava3/transformstrategy/impl/CacheFirstTimeoutStrategy.kt
@@ -27,7 +27,7 @@ import java.lang.reflect.Type
 class CacheFirstTimeoutStrategy(private val timestamp: Long) : ObservableStrategy, FlowableStrategy,
     MaybeStrategy {
 
-    override fun <T> execute(rxCache: RxCache, key: String, source: Flowable<T>, type: Type): Publisher<Record<T>> {
+    override fun <T:Any> execute(rxCache: RxCache, key: String, source: Flowable<T>, type: Type): Publisher<Record<T>> {
 
         val cache: Flowable<Record<T>> = rxCache.load2Flowable<T>(key, type)
             .filter{ record -> System.currentTimeMillis() - record.createTime <= timestamp }
@@ -40,7 +40,7 @@ class CacheFirstTimeoutStrategy(private val timestamp: Long) : ObservableStrateg
         return cache.switchIfEmpty(remote)
     }
 
-    override fun <T> execute(
+    override fun <T:Any> execute(
         rxCache: RxCache,
         key: String,
         source: Flowable<T>,
@@ -68,7 +68,7 @@ class CacheFirstTimeoutStrategy(private val timestamp: Long) : ObservableStrateg
         return cache.switchIfEmpty(remote)
     }
 
-    override fun <T> execute(rxCache: RxCache, key: String, source: Observable<T>, type: Type): Observable<Record<T>> {
+    override fun <T:Any> execute(rxCache: RxCache, key: String, source: Observable<T>, type: Type): Observable<Record<T>> {
         val cache: Observable<Record<T>> = rxCache.load2Observable<T>(key, type)
             .filter{ record -> System.currentTimeMillis() - record.createTime <= timestamp }
         val remote: Observable<Record<T>> = source

diff --git a/...otlin/com/safframework/rxcache/rxjava/rxjava3/transformstrategy/impl/CacheOnlyStrategy.kt b/...otlin/com/safframework/rxcache/rxjava/rxjava3/transformstrategy/impl/CacheOnlyStrategy.kt
@@ -25,11 +25,11 @@ import java.lang.reflect.Type
  */
 class CacheOnlyStrategy : ObservableStrategy, FlowableStrategy, MaybeStrategy {
 
-    override fun <T> execute(rxCache: RxCache, key: String, source: Flowable<T>, type: Type): Publisher<Record<T>> {
+    override fun <T:Any> execute(rxCache: RxCache, key: String, source: Flowable<T>, type: Type): Publisher<Record<T>> {
         return rxCache.load2Flowable(key, type)
     }
 
-    override fun <T> execute(
+    override fun <T:Any> execute(
         rxCache: RxCache,
         key: String,
         source: Flowable<T>,
@@ -43,7 +43,7 @@ class CacheOnlyStrategy : ObservableStrategy, FlowableStrategy, MaybeStrategy {
         return rxCache.load2Maybe(key, type)
     }
 
-    override fun <T> execute(
+    override fun <T:Any> execute(
         rxCache: RxCache,
         key: String,
         source: Observable<T>,

diff --git a/.../kotlin/com/safframework/rxcache/rxjava/rxjava3/transformstrategy/impl/NoCacheStrategy.kt b/.../kotlin/com/safframework/rxcache/rxjava/rxjava3/transformstrategy/impl/NoCacheStrategy.kt
@@ -23,11 +23,11 @@ import java.lang.reflect.Type
  */
 class NoCacheStrategy : ObservableStrategy, FlowableStrategy, MaybeStrategy {
 
-    override fun <T> execute(rxCache: RxCache, key: String, source: Flowable<T>, type: Type): Publisher<Record<T>> {
+    override fun <T:Any> execute(rxCache: RxCache, key: String, source: Flowable<T>, type: Type): Publisher<Record<T>> {
         return source.map{ t -> Record(Source.CLOUD, key, t) }
     }
 
-    override fun <T> execute(
+    override fun <T:Any> execute(
         rxCache: RxCache,
         key: String,
         source: Flowable<T>,
@@ -41,7 +41,7 @@ class NoCacheStrategy : ObservableStrategy, FlowableStrategy, MaybeStrategy {
         return source.map{ t -> Record(Source.CLOUD, key, t) }
     }
 
-    override fun <T> execute(
+    override fun <T:Any> execute(
         rxCache: RxCache,
         key: String,
         source: Observable<T>,

diff --git a/...lin/com/safframework/rxcache/rxjava/rxjava3/transformstrategy/impl/RemoteFirstStrategy.kt b/...lin/com/safframework/rxcache/rxjava/rxjava3/transformstrategy/impl/RemoteFirstStrategy.kt
@@ -25,7 +25,7 @@ import java.lang.reflect.Type
  * @version: V1.0 接口的数据优先，接口取不到数据时获取缓存的数据。
  */
 class RemoteFirstStrategy : ObservableStrategy, FlowableStrategy, MaybeStrategy {
-    override fun <T> execute(rxCache: RxCache, key: String, source: Flowable<T>, type: Type): Publisher<Record<T>> {
+    override fun <T:Any> execute(rxCache: RxCache, key: String, source: Flowable<T>, type: Type): Publisher<Record<T>> {
         val cache: Flowable<Record<T>> = rxCache.load2Flowable(key, type)
         val remote: Flowable<Record<T>> = source
             .map{ t ->
@@ -35,7 +35,7 @@ class RemoteFirstStrategy : ObservableStrategy, FlowableStrategy, MaybeStrategy
         return remote.switchIfEmpty(cache)
     }
 
-    override fun <T> execute(
+    override fun <T:Any> execute(
         rxCache: RxCache,
         key: String,
         source: Flowable<T>,
@@ -61,7 +61,7 @@ class RemoteFirstStrategy : ObservableStrategy, FlowableStrategy, MaybeStrategy
         return remote.switchIfEmpty(cache)
     }
 
-    override fun <T> execute(rxCache: RxCache, key: String, source: Observable<T>, type: Type): Observable<Record<T>> {
+    override fun <T:Any> execute(rxCache: RxCache, key: String, source: Observable<T>, type: Type): Observable<Record<T>> {
         val cache: Observable<Record<T>> = rxCache.load2Observable(key, type)
         val remote: Observable<Record<T>> = source
             .map{ t ->

diff --git a/...tlin/com/safframework/rxcache/rxjava/rxjava3/transformstrategy/impl/RemoteOnlyStrategy.kt b/...tlin/com/safframework/rxcache/rxjava/rxjava3/transformstrategy/impl/RemoteOnlyStrategy.kt
@@ -22,7 +22,7 @@ import java.lang.reflect.Type
  * @version: V1.0 只获取接口的数据，并且将获取到数据保持到缓存中。
  */
 class RemoteOnlyStrategy : ObservableStrategy, FlowableStrategy, MaybeStrategy {
-    override fun <T> execute(
+    override fun <T:Any> execute(
         rxCache: RxCache,
         key: String,
         source: Flowable<T>,
@@ -35,7 +35,7 @@ class RemoteOnlyStrategy : ObservableStrategy, FlowableStrategy, MaybeStrategy {
             }
     }
 
-    override fun <T> execute(
+    override fun <T:Any> execute(
         rxCache: RxCache,
         key: String,
         source: Flowable<T>,
@@ -62,7 +62,7 @@ class RemoteOnlyStrategy : ObservableStrategy, FlowableStrategy, MaybeStrategy {
             }
     }
 
-    override fun <T> execute(
+    override fun <T:Any> execute(
         rxCache: RxCache,
         key: String,
         source: Observable<T>,