OmegaRepository handle exception logic updated

roman_tcaregorodtcev · roman_tcaregorodtcev · commit bb7500499018 · 2019-08-19T13:14:32.000+03:00
diff --git a/lib/src/main/java/com/omega_r/base/data/OmegaRepository.kt b/lib/src/main/java/com/omega_r/base/data/OmegaRepository.kt
@@ -42,7 +42,7 @@ class OmegaRepository<SOURCE : Source>(vararg sources: SOURCE) {
                 CACHE_AND_REMOTE -> applyCacheAndRemote(block)
                 MEMORY_ELSE_CACHE_AND_REMOTE -> {
                     if (memoryCacheSource != null) {
-                        ignoreSourceException {
+                        ignoreException {
                             send(block(memoryCacheSource as SOURCE))
                             return@produce
                         }
@@ -55,10 +55,10 @@ class OmegaRepository<SOURCE : Source>(vararg sources: SOURCE) {
 
 
     private suspend fun <R> ProducerScope<R>.applyOnlyRemote(block: suspend SOURCE.() -> R) {
-        var remoteException: AppException? = null
+        var remoteException: Exception? = null
 
         if (remoteSource != null) {
-            remoteException = ignoreSourceException {
+            remoteException = ignoreException {
                 val result = block(remoteSource)
                 send(result)
                 memoryCacheSource?.update(result)
@@ -68,7 +68,7 @@ class OmegaRepository<SOURCE : Source>(vararg sources: SOURCE) {
         }
 
         if (defaultSource != null) {
-            ignoreSourceException {
+            ignoreException {
                 return send(block(defaultSource))
             }
         }
@@ -82,14 +82,14 @@ class OmegaRepository<SOURCE : Source>(vararg sources: SOURCE) {
 
     private suspend fun <R> ProducerScope<R>.applyOnlyCache(block: suspend SOURCE.() -> R) {
         if (memoryCacheSource != null) {
-            ignoreSourceException {
+            ignoreException {
                 send(block(memoryCacheSource as SOURCE))
                 return
             }
         }
 
         if (fileCacheSource != null) {
-            ignoreSourceException {
+            ignoreException {
                 val result = block(fileCacheSource as SOURCE)
                 send(result)
                 memoryCacheSource?.update(result)
@@ -98,7 +98,7 @@ class OmegaRepository<SOURCE : Source>(vararg sources: SOURCE) {
         }
 
         if (defaultSource != null) {
-            ignoreSourceException {
+            ignoreException {
                 return send(block(defaultSource))
             }
         }
@@ -107,9 +107,9 @@ class OmegaRepository<SOURCE : Source>(vararg sources: SOURCE) {
     }
 
     private suspend fun <R> ProducerScope<R>.applyRemoteElseCache(block: suspend SOURCE.() -> R) {
-        var remoteException: AppException? = null
+        var remoteException: Exception? = null
         if (remoteSource != null) {
-            remoteException = ignoreSourceException {
+            remoteException = ignoreException {
                 val result = block(remoteSource)
                 send(result)
                 memoryCacheSource?.update(result)
@@ -119,14 +119,14 @@ class OmegaRepository<SOURCE : Source>(vararg sources: SOURCE) {
         }
 
         if (memoryCacheSource != null) {
-            ignoreSourceException {
+            ignoreException {
                 send(block(memoryCacheSource as SOURCE))
                 return
             }
         }
 
         if (fileCacheSource != null) {
-            ignoreSourceException {
+            ignoreException {
                 val result = block(fileCacheSource as SOURCE)
                 send(result)
                 memoryCacheSource?.update(result)
@@ -135,7 +135,7 @@ class OmegaRepository<SOURCE : Source>(vararg sources: SOURCE) {
         }
 
         if (defaultSource != null) {
-            ignoreSourceException {
+            ignoreException {
                 return send(block(defaultSource))
             }
         }
@@ -145,25 +145,25 @@ class OmegaRepository<SOURCE : Source>(vararg sources: SOURCE) {
 
     private suspend fun <R> ProducerScope<R>.applyCacheElseRemote(block: suspend SOURCE.() -> R) {
         if (memoryCacheSource != null) {
-            ignoreSourceException {
+            ignoreException {
                 send(block(memoryCacheSource as SOURCE))
                 return
             }
         }
 
         if (fileCacheSource != null) {
-            ignoreSourceException {
+            ignoreException {
                 val result = block(fileCacheSource as SOURCE)
                 send(result)
                 memoryCacheSource?.update(result)
                 return
             }
         }
 
-        var remoteException: AppException? = null
+        var remoteException: Exception? = null
 
         if (remoteSource != null) {
-            remoteException = ignoreSourceException {
+            remoteException = ignoreException {
                 val result = block(remoteSource)
                 send(result)
                 memoryCacheSource?.update(result)
@@ -173,7 +173,7 @@ class OmegaRepository<SOURCE : Source>(vararg sources: SOURCE) {
         }
 
         if (defaultSource != null) {
-            ignoreSourceException {
+            ignoreException {
                 return send(block(defaultSource))
             }
         }
@@ -188,7 +188,7 @@ class OmegaRepository<SOURCE : Source>(vararg sources: SOURCE) {
     private suspend fun <R> ProducerScope<R>.applyCacheAndRemote(block: suspend SOURCE.() -> R) {
         val cacheReturnDeferred = async {
             if (memoryCacheSource != null) {
-                ignoreSourceException {
+                ignoreException {
                     val result = block(memoryCacheSource as SOURCE)
 
                     if (isActive && !isClosedForSend) {
@@ -198,7 +198,7 @@ class OmegaRepository<SOURCE : Source>(vararg sources: SOURCE) {
                 }
             }
             if (fileCacheSource != null) {
-                ignoreSourceException {
+                ignoreException {
                     val result = block(fileCacheSource as SOURCE)
                     if (isActive && !isClosedForSend) {
                         send(result)
@@ -209,7 +209,7 @@ class OmegaRepository<SOURCE : Source>(vararg sources: SOURCE) {
             }
 
             if (defaultSource != null) {
-                ignoreSourceException {
+                ignoreException {
                     if (isActive && !isClosedForSend) {
                         send(block(defaultSource))
                     }
@@ -221,7 +221,7 @@ class OmegaRepository<SOURCE : Source>(vararg sources: SOURCE) {
         }
 
         val remoteException = if (remoteSource != null) {
-            ignoreSourceException {
+            ignoreException {
                 val result = block(remoteSource)
                 cacheReturnDeferred.cancel()
                 send(result)
@@ -255,11 +255,11 @@ class OmegaRepository<SOURCE : Source>(vararg sources: SOURCE) {
 
     }
 
-    private inline fun ignoreSourceException(block: () -> Unit): AppException? {
+    private inline fun ignoreException(block: () -> Unit): Exception? {
         return try {
             block()
             null
-        } catch (exception: AppException) {
+        } catch (exception: Exception) {
             exception
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ class OmegaRepository<SOURCE : Source>(vararg sources: SOURCE) {`
`42`	`42`	`CACHE_AND_REMOTE -> applyCacheAndRemote(block)`
`43`	`43`	`MEMORY_ELSE_CACHE_AND_REMOTE -> {`
`44`	`44`	`if (memoryCacheSource != null) {`
`45`		`- ignoreSourceException {`
	`45`	`+ ignoreException {`
`46`	`46`	`send(block(memoryCacheSource as SOURCE))`
`47`	`47`	`return@produce`
`48`	`48`	`}`
`@@ -55,10 +55,10 @@ class OmegaRepository<SOURCE : Source>(vararg sources: SOURCE) {`
`55`	`55`
`56`	`56`
`57`	`57`	`private suspend fun <R> ProducerScope<R>.applyOnlyRemote(block: suspend SOURCE.() -> R) {`
`58`		`- var remoteException: AppException? = null`
	`58`	`+ var remoteException: Exception? = null`
`59`	`59`
`60`	`60`	`if (remoteSource != null) {`
`61`		`- remoteException = ignoreSourceException {`
	`61`	`+ remoteException = ignoreException {`
`62`	`62`	`val result = block(remoteSource)`
`63`	`63`	`send(result)`
`64`	`64`	`memoryCacheSource?.update(result)`
`@@ -68,7 +68,7 @@ class OmegaRepository<SOURCE : Source>(vararg sources: SOURCE) {`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`if (defaultSource != null) {`
`71`		`- ignoreSourceException {`
	`71`	`+ ignoreException {`
`72`	`72`	`return send(block(defaultSource))`
`73`	`73`	`}`
`74`	`74`	`}`
`@@ -82,14 +82,14 @@ class OmegaRepository<SOURCE : Source>(vararg sources: SOURCE) {`
`82`	`82`
`83`	`83`	`private suspend fun <R> ProducerScope<R>.applyOnlyCache(block: suspend SOURCE.() -> R) {`
`84`	`84`	`if (memoryCacheSource != null) {`
`85`		`- ignoreSourceException {`
	`85`	`+ ignoreException {`
`86`	`86`	`send(block(memoryCacheSource as SOURCE))`
`87`	`87`	`return`
`88`	`88`	`}`
`89`	`89`	`}`
`90`	`90`
`91`	`91`	`if (fileCacheSource != null) {`
`92`		`- ignoreSourceException {`
	`92`	`+ ignoreException {`
`93`	`93`	`val result = block(fileCacheSource as SOURCE)`
`94`	`94`	`send(result)`
`95`	`95`	`memoryCacheSource?.update(result)`
`@@ -98,7 +98,7 @@ class OmegaRepository<SOURCE : Source>(vararg sources: SOURCE) {`
`98`	`98`	`}`
`99`	`99`
`100`	`100`	`if (defaultSource != null) {`
`101`		`- ignoreSourceException {`
	`101`	`+ ignoreException {`
`102`	`102`	`return send(block(defaultSource))`
`103`	`103`	`}`
`104`	`104`	`}`
`@@ -107,9 +107,9 @@ class OmegaRepository<SOURCE : Source>(vararg sources: SOURCE) {`
`107`	`107`	`}`
`108`	`108`
`109`	`109`	`private suspend fun <R> ProducerScope<R>.applyRemoteElseCache(block: suspend SOURCE.() -> R) {`
`110`		`- var remoteException: AppException? = null`
	`110`	`+ var remoteException: Exception? = null`
`111`	`111`	`if (remoteSource != null) {`
`112`		`- remoteException = ignoreSourceException {`
	`112`	`+ remoteException = ignoreException {`
`113`	`113`	`val result = block(remoteSource)`
`114`	`114`	`send(result)`
`115`	`115`	`memoryCacheSource?.update(result)`
`@@ -119,14 +119,14 @@ class OmegaRepository<SOURCE : Source>(vararg sources: SOURCE) {`
`119`	`119`	`}`
`120`	`120`
`121`	`121`	`if (memoryCacheSource != null) {`
`122`		`- ignoreSourceException {`
	`122`	`+ ignoreException {`
`123`	`123`	`send(block(memoryCacheSource as SOURCE))`
`124`	`124`	`return`
`125`	`125`	`}`
`126`	`126`	`}`
`127`	`127`
`128`	`128`	`if (fileCacheSource != null) {`
`129`		`- ignoreSourceException {`
	`129`	`+ ignoreException {`
`130`	`130`	`val result = block(fileCacheSource as SOURCE)`
`131`	`131`	`send(result)`
`132`	`132`	`memoryCacheSource?.update(result)`
`@@ -135,7 +135,7 @@ class OmegaRepository<SOURCE : Source>(vararg sources: SOURCE) {`
`135`	`135`	`}`
`136`	`136`
`137`	`137`	`if (defaultSource != null) {`
`138`		`- ignoreSourceException {`
	`138`	`+ ignoreException {`
`139`	`139`	`return send(block(defaultSource))`
`140`	`140`	`}`
`141`	`141`	`}`
`@@ -145,25 +145,25 @@ class OmegaRepository<SOURCE : Source>(vararg sources: SOURCE) {`
`145`	`145`
`146`	`146`	`private suspend fun <R> ProducerScope<R>.applyCacheElseRemote(block: suspend SOURCE.() -> R) {`
`147`	`147`	`if (memoryCacheSource != null) {`
`148`		`- ignoreSourceException {`
	`148`	`+ ignoreException {`
`149`	`149`	`send(block(memoryCacheSource as SOURCE))`
`150`	`150`	`return`
`151`	`151`	`}`
`152`	`152`	`}`
`153`	`153`
`154`	`154`	`if (fileCacheSource != null) {`
`155`		`- ignoreSourceException {`
	`155`	`+ ignoreException {`
`156`	`156`	`val result = block(fileCacheSource as SOURCE)`
`157`	`157`	`send(result)`
`158`	`158`	`memoryCacheSource?.update(result)`
`159`	`159`	`return`
`160`	`160`	`}`
`161`	`161`	`}`
`162`	`162`
`163`		`- var remoteException: AppException? = null`
	`163`	`+ var remoteException: Exception? = null`
`164`	`164`
`165`	`165`	`if (remoteSource != null) {`
`166`		`- remoteException = ignoreSourceException {`
	`166`	`+ remoteException = ignoreException {`
`167`	`167`	`val result = block(remoteSource)`
`168`	`168`	`send(result)`
`169`	`169`	`memoryCacheSource?.update(result)`
`@@ -173,7 +173,7 @@ class OmegaRepository<SOURCE : Source>(vararg sources: SOURCE) {`
`173`	`173`	`}`
`174`	`174`
`175`	`175`	`if (defaultSource != null) {`
`176`		`- ignoreSourceException {`
	`176`	`+ ignoreException {`
`177`	`177`	`return send(block(defaultSource))`
`178`	`178`	`}`
`179`	`179`	`}`
`@@ -188,7 +188,7 @@ class OmegaRepository<SOURCE : Source>(vararg sources: SOURCE) {`
`188`	`188`	`private suspend fun <R> ProducerScope<R>.applyCacheAndRemote(block: suspend SOURCE.() -> R) {`
`189`	`189`	`val cacheReturnDeferred = async {`
`190`	`190`	`if (memoryCacheSource != null) {`
`191`		`- ignoreSourceException {`
	`191`	`+ ignoreException {`
`192`	`192`	`val result = block(memoryCacheSource as SOURCE)`
`193`	`193`
`194`	`194`	`if (isActive && !isClosedForSend) {`
`@@ -198,7 +198,7 @@ class OmegaRepository<SOURCE : Source>(vararg sources: SOURCE) {`
`198`	`198`	`}`
`199`	`199`	`}`
`200`	`200`	`if (fileCacheSource != null) {`
`201`		`- ignoreSourceException {`
	`201`	`+ ignoreException {`
`202`	`202`	`val result = block(fileCacheSource as SOURCE)`
`203`	`203`	`if (isActive && !isClosedForSend) {`
`204`	`204`	`send(result)`
`@@ -209,7 +209,7 @@ class OmegaRepository<SOURCE : Source>(vararg sources: SOURCE) {`
`209`	`209`	`}`
`210`	`210`
`211`	`211`	`if (defaultSource != null) {`
`212`		`- ignoreSourceException {`
	`212`	`+ ignoreException {`
`213`	`213`	`if (isActive && !isClosedForSend) {`
`214`	`214`	`send(block(defaultSource))`
`215`	`215`	`}`
`@@ -221,7 +221,7 @@ class OmegaRepository<SOURCE : Source>(vararg sources: SOURCE) {`
`221`	`221`	`}`
`222`	`222`
`223`	`223`	`val remoteException = if (remoteSource != null) {`
`224`		`- ignoreSourceException {`
	`224`	`+ ignoreException {`
`225`	`225`	`val result = block(remoteSource)`
`226`	`226`	`cacheReturnDeferred.cancel()`
`227`	`227`	`send(result)`
`@@ -255,11 +255,11 @@ class OmegaRepository<SOURCE : Source>(vararg sources: SOURCE) {`
`255`	`255`
`256`	`256`	`}`
`257`	`257`
`258`		`- private inline fun ignoreSourceException(block: () -> Unit): AppException? {`
	`258`	`+ private inline fun ignoreException(block: () -> Unit): Exception? {`
`259`	`259`	`return try {`
`260`	`260`	`block()`
`261`	`261`	`null`
`262`		`- } catch (exception: AppException) {`
	`262`	`+ } catch (exception: Exception) {`
`263`	`263`	`exception`
`264`	`264`	`}`
`265`	`265`	`}`