refactor 200 iterator

lib/primes/src/lib.rs

@@ -6,12 +6,13 @@ use std::fs::File;
 use std::hash::Hash;
 use std::io::Write;
 use std::slice::Iter;
+use std::vec::IntoIter;
 
 use num::FromPrimitive;
 use num::Num;
 use num::ToPrimitive;
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct Primes<T> {
     vector: Vec<T>,
     set: HashSet<T>,
@@ -110,6 +111,10 @@ where
     pub fn into_vec(self) -> Vec<T> {
         self.vector
     }
+
+    pub fn to_cloned_iter(&self) -> IntoIter<T> {
+        self.vector.clone().into_iter()
+    }
 }
 
 #[cfg(test)]

src/euler200/src/main.rs

@@ -19,35 +19,36 @@ fn main() {
 #[derive(Debug)]
 struct Squbes {
     squbes: HashSet<u64>,
-    new_squbes: Vec<u64>,
-    primes: IntoIter<u64>,
+    primes: Primes<u64>,
+    primes_iter: IntoIter<u64>,
     used_primes: Vec<u64>,
     current_prime: u64,
 }
 
 impl Squbes {
     pub fn new(max: u64) -> Self {
-        let mut primes = Primes::get_between(2, max).into_vec().into_iter();
-        let first = primes.next().unwrap();
-        let second = primes.next().unwrap();
+        let primes = Primes::get_between(2, max);
+        let mut primes_iter = primes.to_cloned_iter();
+        let first = primes_iter.next().unwrap();
+        let second = primes_iter.next().unwrap();
         Self {
             squbes: HashSet::new(),
-            new_squbes: vec![],
             primes,
+            primes_iter,
             used_primes: vec![first],
             current_prime: second,
         }
     }
 
     pub fn iterate(&mut self) {
-        self.calculate_squbes_with_current_prime();
+        let squbes = self.calculate_squbes_with_current_prime();
         self.save_current_prime();
         self.update_current_prime();
         self.save_new_squbes();
     }
 
     fn save_new_squbes(&mut self) {
-        self.squbes.extend(self.new_squbes.drain(0..));
+        todo!()
     }
 
     pub fn get_output(&self) -> Vec<u64> {
@@ -61,13 +62,13 @@ impl Squbes {
     }
 
     fn update_current_prime(&mut self) {
-        self.current_prime = self.primes.next().unwrap();
+        self.current_prime = self.primes_iter.next().unwrap();
     }
 
-    fn calculate_squbes_with_current_prime(&mut self) {
-        let iter = get_iterator_over_pairs_both_ways(&self.used_primes, self.current_prime)
-            .map(|(p, q)| Self::core(p, q));
-        self.new_squbes.extend(iter);
+    fn calculate_squbes_with_current_prime(&mut self) -> Vec<u64> {
+        get_iterator_over_pairs_both_ways(&self.used_primes, self.current_prime)
+            .map(|(p, q)| Self::core(p, q))
+            .collect()
     }
 
     fn core(p: u64, q: u64) -> u64 {