From ac64501e406cade929aefda6b58c6d62a7ba1d17 Mon Sep 17 00:00:00 2001
From: Vladimir Shirobokov <vladimir.shirobokov@south.rt.ru>
Date: Sat, 26 Mar 2022 23:51:57 +0300
Subject: [PATCH 1/2] HomeWork 1

---
 src/main/kotlin/Main.kt | 59 +++++++++++++++++++++++++++++++++--------
 1 file changed, 48 insertions(+), 11 deletions(-)

diff --git a/src/main/kotlin/Main.kt b/src/main/kotlin/Main.kt
index 18c0de6..4b90dc1 100644
--- a/src/main/kotlin/Main.kt
+++ b/src/main/kotlin/Main.kt
@@ -10,6 +10,13 @@ private const val LATENCY = 700L
 private const val RESPONSE_LENGTH = 2048
 
 fun main() {
+    //requestDataFromServerAsync()
+    //requestServerAsync()
+    //requestDataFromDbAsync<String>()
+    //emitEachSecond()
+    //xMap { flatMapCompletable(it) }
+    //xMap { concatMapCompletable(it) }
+    //xMap { switchMapCompletable(it) }
     // Функции можно вызывать отсюда для проверки
     //  для ДЗ лучше использовать blockingSubscribe вместо subscribe потому что subscribe подпишется на изменения,
     //  но изменения в большинстве случаев будут получены позже, чем выполнится функция main, поэтому в консоли ничего
@@ -23,46 +30,73 @@ fun main() {
 }
 
 // 1) Какой источник лучше всего подойдёт для запроса на сервер, который возвращает результат?
-// Почему?
+// Почему? Maybe позволяет обработать null в источнике данных
 // Дописать функцию
-fun requestDataFromServerAsync() /* -> ???<ByteArray> */ {
+fun requestDataFromServerAsync(): ByteArray?/* -> ???<ByteArray> */ {
 
     // Функция имитирует синхронный запрос на сервер, возвращающий результат
     fun getDataFromServerSync(): ByteArray? {
-        Thread.sleep(LATENCY);
+        Thread.sleep(LATENCY)
         val success = Random.nextBoolean()
         return if (success) Random.nextBytes(RESPONSE_LENGTH) else null
     }
 
+    var result: ByteArray? = null
+    Maybe.fromCallable<Any> { getDataFromServerSync() }
+        .blockingSubscribe({
+            println(it)
+            result = it as ByteArray?
+        }, { it.printStackTrace() }, {
+            println("complete")
+        })
     /* return ??? */
+    return result
 }
 
 
 // 2) Какой источник лучше всего подойдёт для запроса на сервер, который НЕ возвращает результат?
-// Почему?
+// Почему? Completable потому что нас интересует лишь факт выполнения операции
 // Дописать функцию
-fun requestServerAsync() /* -> ??? */ {
-
+fun requestServerAsync(): Boolean/* -> ??? */ {
     // Функция имитирует синхронный запрос на сервер, не возвращающий результат
     fun getDataFromServerSync() {
         Thread.sleep(LATENCY)
         if (Random.nextBoolean()) throw ServerNotActiveException()
     }
 
-    /* return ??? */
+    var result = true
+    Completable.fromAction { getDataFromServerSync() }
+        .blockingSubscribe({
+            println("requestServerAsync success")
+        }, {
+            result = false
+            it.printStackTrace()
+        })
+    return result
 }
 
 // 3) Какой источник лучше всего подойдёт для однократного асинхронного возвращения значения из базы данных?
-// Почему?
+// Почему? Maybe мы ожидаем возможное null значение
 // Дописать функцию
-fun <T> requestDataFromDbAsync() /* -> ??? */ {
-
+fun <T> requestDataFromDbAsync(): T? /* -> ??? */ {
     // Функция имитирует синхронный запрос к БД не возвращающий результата
     fun getDataFromDbSync(): T? {
         Thread.sleep(LATENCY); return null
     }
 
+    var result: T? = null
+    Maybe.fromCallable<Any> { getDataFromDbSync() }
+        .blockingSubscribe({
+            println("requestDataFromDbAsync $it success")
+                result = it as T
+        },
+            { println("requestDataFromDbAsync error") },
+            {
+                println("requestDataFromDbAsync complete")
+                result = null
+            })
     /* return */
+    return result
 }
 
 // 4) Примените к источнику оператор (несколько операторов), которые приведут к тому, чтобы элемент из источника
@@ -78,6 +112,10 @@ fun emitEachSecond() {
     fun printer(value: Long) = println("${Date()}: value = $value")
 
     // code here
+    source()
+        .onBackpressureBuffer()
+        .concatMap { Flowable.interval(1000, TimeUnit.MILLISECONDS) }
+        .blockingSubscribe({ printer(it) }, { it.printStackTrace() })
 }
 
 // 5) Функция для изучения разницы между операторами concatMap, flatMap, switchMap
@@ -102,7 +140,6 @@ fun xMap(mapper: Flowable<Int>.(internalMapper: (Int) -> Completable) -> Complet
     println("${Date()}: start")
     Flowable.fromIterable(0..20)
         .mapper { iterableIndex ->
-
             waitOneSecond()
                 .doOnComplete { println("${Date()}: finished operation for iterable index $iterableIndex") }
 

From 59221e3d45b73c64d168cbc59e5ee33ef499a9e5 Mon Sep 17 00:00:00 2001
From: Vladimir Shirobokov <vladimir.shirobokov@south.rt.ru>
Date: Sun, 27 Mar 2022 00:08:34 +0300
Subject: [PATCH 2/2] HomeWork 1

---
 src/main/kotlin/Main.kt | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/src/main/kotlin/Main.kt b/src/main/kotlin/Main.kt
index 4b90dc1..d5ce923 100644
--- a/src/main/kotlin/Main.kt
+++ b/src/main/kotlin/Main.kt
@@ -1,6 +1,7 @@
 import io.reactivex.rxjava3.core.Completable
 import io.reactivex.rxjava3.core.Flowable
 import io.reactivex.rxjava3.core.Maybe
+import io.reactivex.rxjava3.core.Single
 import java.rmi.server.ServerNotActiveException
 import java.util.*
 import java.util.concurrent.TimeUnit
@@ -30,9 +31,9 @@ fun main() {
 }
 
 // 1) Какой источник лучше всего подойдёт для запроса на сервер, который возвращает результат?
-// Почему? Maybe позволяет обработать null в источнике данных
+// Почему? Single сгенерирует ошибку, в случае отсутсвия значение, а мы всегда ожидаем результат
 // Дописать функцию
-fun requestDataFromServerAsync(): ByteArray?/* -> ???<ByteArray> */ {
+fun requestDataFromServerAsync(): ByteArray/* -> ???<ByteArray> */ {
 
     // Функция имитирует синхронный запрос на сервер, возвращающий результат
     fun getDataFromServerSync(): ByteArray? {
@@ -41,14 +42,12 @@ fun requestDataFromServerAsync(): ByteArray?/* -> ???<ByteArray> */ {
         return if (success) Random.nextBytes(RESPONSE_LENGTH) else null
     }
 
-    var result: ByteArray? = null
-    Maybe.fromCallable<Any> { getDataFromServerSync() }
-        .blockingSubscribe({
+    lateinit var result: ByteArray
+    Single.fromCallable<ByteArray> { getDataFromServerSync() }
+        .blockingSubscribe {
             println(it)
-            result = it as ByteArray?
-        }, { it.printStackTrace() }, {
-            println("complete")
-        })
+            result = it
+        }
     /* return ??? */
     return result
 }
@@ -88,7 +87,7 @@ fun <T> requestDataFromDbAsync(): T? /* -> ??? */ {
     Maybe.fromCallable<Any> { getDataFromDbSync() }
         .blockingSubscribe({
             println("requestDataFromDbAsync $it success")
-                result = it as T
+            result = it as T
         },
             { println("requestDataFromDbAsync error") },
             {