Parallel Stream now works

alemazzo · alemazzo · commit a7b3a1be4e35 · 2021-03-05T22:16:47.000+01:00
diff --git a/.gitignore b/.gitignore
@@ -3,4 +3,5 @@ build/
 dist/
 java_stream.egg-info/
 main.py
-parallel_test.py
+parallel_test.py
+performance.py
diff --git a/stream/parallelstream.py b/stream/parallelstream.py
@@ -39,9 +39,8 @@ def _iterator(iterable):
             return
 
     @staticmethod
-    def cloneSplit(iterable, count):
-        it = ParallelUtils._iterator(iterable)
-        return [it for _ in range(count)]
+    def sameSplit(iterable, count):
+        return [ParallelUtils._iterator(iterable) for _ in range(count)]
 
     @staticmethod
     def split(iterable, count):
@@ -67,7 +66,7 @@ class ParallelStream(Stream):
     def __init__(self, iterable):
 
         self.__streams = [StreamThread(Stream(it))
-                          for it in ParallelUtils.split(iterable, self.PROCESS)]
+                          for it in ParallelUtils.sameSplit(iterable, self.PROCESS)]
 
         for _stream in self.__streams:
             _stream.start()
@@ -117,6 +116,9 @@ def forEach(self, function):
         for _stream in self.__streams:
             _stream.forEach(function)
 
+        for _stream in self.__streams:
+            _stream.join()
+
         return self
 
     def anyMatch(self, predicate):
@@ -127,8 +129,8 @@ def anyMatch(self, predicate):
         for _stream in self.__streams:
             _stream.join()
 
-        results = [_stream.getResult().get()
-                   for _stream in self.__streams if _stream.getResult().isPresent()]
+        results = [_stream.getResult()
+                   for _stream in self.__streams]
 
         return Stream(results).anyMatch(lambda x: x)
 
@@ -140,8 +142,8 @@ def allMatch(self, predicate):
         for _stream in self.__streams:
             _stream.join()
 
-        results = [_stream.getResult().get()
-                   for _stream in self.__streams if _stream.getResult().isPresent()]
+        results = [_stream.getResult()
+                   for _stream in self.__streams]
 
         return Stream(results).allMatch(lambda x: x)
 
@@ -153,10 +155,10 @@ def noneMatch(self, predicate):
         for _stream in self.__streams:
             _stream.join()
 
-        results = [_stream.getResult().get()
-                   for _stream in self.__streams if _stream.getResult().isPresent()]
+        results = [_stream.getResult()
+                   for _stream in self.__streams]
 
-        return Stream(results).noneMatch(lambda x: x)
+        return Stream(results).allMatch(lambda x: x)
 
     def findAny(self):
 
@@ -210,18 +212,18 @@ def max(self, comparator=None):
 
         return Stream(results).max(comparator)
 
-    def sum(self, comparator=None):
+    def sum(self):
 
         for _stream in self.__streams:
-            _stream.sum(comparator)
+            _stream.sum()
 
         for _stream in self.__streams:
             _stream.join()
 
         results = [_stream.getResult().get()
                    for _stream in self.__streams if _stream.getResult().isPresent()]
 
-        return Stream(results).sum(comparator)
+        return Stream(results).sum()
 
     def count(self):
 
@@ -277,8 +279,19 @@ def toSet(self):
     def get(self):
         return self.__streams
 
+    def terminate(self):
+        for _stream in self.__streams:
+            _stream.terminate()
+
     def __eq__(self, other):
-        return self.toSet() == other.toSet()
+        return self.toSet() == set(other)
 
     def __iter__(self):
-        return iter(self.toList())
+
+        def _iter(iters):
+            for it in iters:
+                for elem in it:
+                    yield elem
+            self.terminate()
+
+        return _iter(self.__streams)
diff --git a/stream/stream.py b/stream/stream.py
@@ -54,7 +54,7 @@ def of(*elements):
         :param *T elements: the elements of the new stream
         :return: the new stream
         '''
-        return Stream(list(elements))
+        return Stream(iter(list(elements)))
 
     @staticmethod
     def ofNullable(elem):
@@ -97,6 +97,10 @@ def concat(*streams):
         '''
         return Stream(IteratorUtils.concat(*streams))
 
+    """
+    Already Implemented Method
+    """
+
     @staticmethod
     def randint(lower, upper):
         '''
@@ -108,6 +112,55 @@ def randint(lower, upper):
         '''
         return Stream.generate(lambda: random.randint(lower, upper))
 
+    @staticmethod
+    def integers():
+        '''
+        Returns an infinite stream of integer from 0 to infinity
+
+        :return: the infinite stream
+        '''
+        return Stream.iterate(0, lambda i: i + 1)
+
+    @staticmethod
+    def odds():
+        '''
+        Returns an infinite stream of odds number from 0 to infinity
+
+        :return: the infinite stream
+        '''
+        return Stream.iterate(1, lambda i: i + 2)
+
+    @staticmethod
+    def evens():
+        '''
+        Returns an infinite stream of evens number from 0 to infinity
+
+        :return: the infinite stream
+        '''
+        return Stream.iterate(0, lambda i: i + 2)
+
+    @staticmethod
+    def primes():
+        '''
+        Returns an infinite stream of primes number from 2 to infinity
+
+        :return: the infinite stream
+        '''
+        def prime_generator():
+            yield 2
+            primes = [2]
+            actual = 1
+            while True:
+                actual += 2
+                for prime in primes:
+                    if actual % prime == 0:
+                        break
+                else:
+                    primes.append(actual)
+                    yield actual
+
+        return Stream(prime_generator())
+
     """
     Normal Methods
     """
@@ -249,7 +302,7 @@ def noneMatch(self, predicate):
         :param Predicate predicate: predicate to apply to elements of this stream
         :return: True if either no elements of the stream match the provided predicate or the stream is empty, otherwise False
         '''
-        return len(self.__iterable) == 0 or not self.anyMatch(predicate)
+        return not self.anyMatch(predicate)
 
     def findFirst(self):
         '''
@@ -292,7 +345,11 @@ def min(self, comparator=None):
         :param Comparator comparator: Comparator to compare elements of this stream - if null default comparator is used
         :return: an Optional describing the minimum element of this stream, or an empty Optional if the stream is empty
         '''
-        return Optional.ofNullable(min(self.__iterable, key=cmp_to_key(comparator))) if comparator is not None else Optional.ofNullable(min(self.__iterable))
+        elements = list(self.__iterable)
+        if len(elements) == 0:
+            return Optional.empty()
+
+        return Optional.ofNullable(min(elements, key=cmp_to_key(comparator), default=None)) if comparator is not None else Optional.ofNullable(min(elements, default=None))
 
     def max(self, comparator=None):
         '''
@@ -301,7 +358,10 @@ def max(self, comparator=None):
         :param Comparator comparator: Comparator to compare elements of this stream - if null default comparator is used
         :return: an Optional describing the maximum element of this stream, or an empty Optional if the stream is empty
         '''
-        return Optional.ofNullable(max(self.__iterable, key=cmp_to_key(comparator))) if comparator is not None else Optional.ofNullable(max(self.__iterable))
+        elements = list(self.__iterable)
+        if len(elements) == 0:
+            return Optional.empty()
+        return Optional.ofNullable(max(elements, key=cmp_to_key(comparator))) if comparator is not None else Optional.ofNullable(max(elements))
 
     def sum(self):
         '''
diff --git a/stream/threads.py b/stream/threads.py
