From 0c33fe216a2e64e7d716cfdcb60eb34107ddae4d Mon Sep 17 00:00:00 2001
From: Kiril Mihaylov <k.mihaylov@nolus.io>
Date: Thu, 25 May 2023 12:12:36 +0300
Subject: [PATCH] refactor(oracle): Refactored iterator

---
 contracts/oracle/src/contract/alarms/iter.rs | 47 ++++++++++----------
 1 file changed, 23 insertions(+), 24 deletions(-)

diff --git a/contracts/oracle/src/contract/alarms/iter.rs b/contracts/oracle/src/contract/alarms/iter.rs
index ec1fe3d88..5dc3873f2 100644
--- a/contracts/oracle/src/contract/alarms/iter.rs
+++ b/contracts/oracle/src/contract/alarms/iter.rs
@@ -40,25 +40,24 @@ where
         }
     }
 
-    fn update_alarm_iterator(&mut self) -> Option<ContractResult<&mut AlarmIter<'alarms>>> {
-        self.price_iter.next()?.map_or_else(
-            |error: ContractError| Some(Err(error)),
-            |ref price| {
-                let iter: AlarmIter<'alarms> =
-                    match visit_any_on_ticker::<SwapGroup, Cmd<'storage, 'alarms, '_, S, BaseC>>(
+    fn update_alarm_iterator(&mut self) -> ContractResult<()> {
+        self.alarm_iter = self
+            .price_iter
+            .next()
+            .map(|price_result: PriceResult<BaseC>| {
+                price_result.and_then(|ref price| {
+                    visit_any_on_ticker::<SwapGroup, Cmd<'storage, 'alarms, '_, S, BaseC>>(
                         price.base_ticker(),
                         Cmd {
                             alarms: self.alarms,
                             price,
                         },
-                    ) {
-                        Ok(iter) => iter,
-                        Err(error) => return Some(Err(error)),
-                    };
+                    )
+                })
+            })
+            .transpose()?;
 
-                Some(Ok(self.alarm_iter.insert(iter)))
-            },
-        )
+        Ok(())
     }
 }
 
@@ -71,18 +70,18 @@ where
     type Item = ContractResult<Addr>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        self.alarm_iter
-            .as_mut()
-            .map(Iterator::next)
-            .unwrap_or_else(|| {
-                self.alarm_iter = None;
+        let result: Option<ContractResult<Addr>> =
+            self.alarm_iter.as_mut().and_then(Iterator::next);
 
-                None
-            })
-            .or_else(|| match self.update_alarm_iterator()? {
-                Ok(iter) => iter.next(),
-                Err(err) => Some(Err(err)),
-            })
+        if result.is_some() {
+            result
+        } else {
+            if let Err(error) = self.update_alarm_iterator() {
+                return Some(Err(error));
+            }
+
+            self.alarm_iter.as_mut().and_then(Iterator::next)
+        }
     }
 }