[Checkins] SVN: Products.ZCatalog/trunk/ Made sure `actual_result_count` is available on all lazy classes and falls back to `__len__` if not explicitly provided.

[Hanno Schlichting]

Log message for revision 119145:
  Made sure `actual_result_count` is available on all lazy classes and falls back to `__len__` if not explicitly provided.
  

Changed:
  U   Products.ZCatalog/trunk/CHANGES.txt
  U   Products.ZCatalog/trunk/src/Products/ZCatalog/Lazy.py
  U   Products.ZCatalog/trunk/src/Products/ZCatalog/tests/test_lazy.py

-=-
Modified: Products.ZCatalog/trunk/CHANGES.txt
===================================================================
--- Products.ZCatalog/trunk/CHANGES.txt	2010-12-26 18:40:10 UTC (rev 119144)
+++ Products.ZCatalog/trunk/CHANGES.txt	2010-12-26 19:03:16 UTC (rev 119145)
@@ -4,8 +4,10 @@
 2.13.2 (unreleased)
 -------------------
 
+- Made sure `actual_result_count` is available on all lazy classes and falls
+  back to `__len__` if not explicitly provided.
+
 - Optimized length calculation of Lazy classes.
-  [hannosch]
 
 2.13.1 (2010-12-25)
 -------------------

Modified: Products.ZCatalog/trunk/src/Products/ZCatalog/Lazy.py
===================================================================
--- Products.ZCatalog/trunk/src/Products/ZCatalog/Lazy.py	2010-12-26 18:40:10 UTC (rev 119144)
+++ Products.ZCatalog/trunk/src/Products/ZCatalog/Lazy.py	2010-12-26 19:03:16 UTC (rev 119145)
@@ -21,7 +21,19 @@
     # Allow (reluctantly) access to unprotected attributes
     __allow_access_to_unprotected_subobjects__ = True
     _len = _marker
+    _rlen = _marker
 
+    @property
+    def actual_result_count(self):
+        if self._rlen is not _marker:
+            return self._rlen
+        self._rlen = len(self)
+        return self._rlen
+
+    @actual_result_count.setter
+    def actual_result_count(self, value):
+        self._rlen = value
+
     def __repr__(self):
         return repr(list(self))
 
@@ -61,7 +73,7 @@
     for accessing small parts of big searches.
     """
 
-    def __init__(self, sequences, length=None):
+    def __init__(self, sequences, length=None, actual_result_count=None):
         if len(sequences) < 100:
             # Optimize structure of LazyCats to avoid nesting
             # We don't do this for large numbers of input sequences
@@ -81,6 +93,8 @@
         self._eindex = -1
         if length is not None:
             self._len = length
+        if actual_result_count is not None:
+            self.actual_result_count = actual_result_count
 
     def __getitem__(self, index):
         data = self._data
@@ -145,7 +159,7 @@
     Don't access data until necessary
     """
 
-    def __init__(self, func, seq, length=None):
+    def __init__(self, func, seq, length=None, actual_result_count=None):
         self._seq = seq
         self._data = {}
         self._func = func
@@ -153,7 +167,10 @@
             self._len = length
         else:
             self._len = len(seq)
-        self.actual_result_count = self._len
+        if actual_result_count is not None:
+            self.actual_result_count = actual_result_count
+        else:
+            self.actual_result_count = self._len
 
     def __getitem__(self, index):
         data = self._data

Modified: Products.ZCatalog/trunk/src/Products/ZCatalog/tests/test_lazy.py
===================================================================
--- Products.ZCatalog/trunk/src/Products/ZCatalog/tests/test_lazy.py	2010-12-26 18:40:10 UTC (rev 119144)
+++ Products.ZCatalog/trunk/src/Products/ZCatalog/tests/test_lazy.py	2010-12-26 19:03:16 UTC (rev 119145)
@@ -22,7 +22,16 @@
         self.assertEqual(len(lseq), len(seq))
         self.assertEqual(list(lseq), seq)
 
+    def test_actual_result_count(self):
+        lcat = self._createLSeq(range(10))
+        self.assertEqual(len(lcat), 10)
+        self.assertEqual(lcat.actual_result_count, 10)
 
+        lcat.actual_result_count = 20
+        self.assertEqual(len(lcat), 10)
+        self.assertEqual(lcat.actual_result_count, 20)
+
+
 class TestLazyCat(BaseSequenceTest):
 
     def _createLSeq(self, *sequences):
@@ -32,6 +41,7 @@
     def test_empty(self):
         lcat = self._createLSeq([])
         self._compare(lcat, [])
+        self.assertEqual(lcat.actual_result_count, 0)
 
     def test_repr(self):
         lcat = self._createLSeq([0, 1])
@@ -41,6 +51,7 @@
         seq = range(10)
         lcat = self._createLSeq(seq)
         self._compare(lcat, seq)
+        self.assertEqual(lcat.actual_result_count, 10)
 
     def test_add(self):
         seq1 = range(10)
@@ -49,6 +60,7 @@
         lcat2 = self._createLSeq(seq2)
         lcat = lcat1 + lcat2
         self._compare(lcat, range(20))
+        self.assertEqual(lcat.actual_result_count, 20)
 
     def test_init_multiple(self):
         from string import hexdigits, letters
@@ -80,16 +92,19 @@
         # Unaccessed length
         lcat = self._createLSeq(range(10))
         self.assertEqual(len(lcat), 10)
+        self.assertEqual(lcat.actual_result_count, 10)
 
         # Accessed in the middle
         lcat = self._createLSeq(range(10))
         lcat[4]
         self.assertEqual(len(lcat), 10)
+        self.assertEqual(lcat.actual_result_count, 10)
 
         # Accessed after the lcat is accessed over the whole range
         lcat = self._createLSeq(range(10))
         lcat[:]
         self.assertEqual(len(lcat), 10)
+        self.assertEqual(lcat.actual_result_count, 10)
 
 
 class TestLazyMap(TestLazyCat):
@@ -213,24 +228,24 @@
 
 class TestLazyValues(BaseSequenceTest):
 
-    def _createLValues(self, seq):
+    def _createLSeq(self, seq):
         from Products.ZCatalog.Lazy import LazyValues
         return LazyValues(seq)
 
     def test_empty(self):
-        lvals = self._createLValues([])
+        lvals = self._createLSeq([])
         self._compare(lvals, [])
 
     def test_values(self):
         from string import letters
         seq = zip(letters, range(10))
-        lvals = self._createLValues(seq)
+        lvals = self._createLSeq(seq)
         self._compare(lvals, range(10))
 
     def test_slicing(self):
         from string import letters
         seq = zip(letters, range(10))
-        lvals = self._createLValues(seq)
+        lvals = self._createLSeq(seq)
         self._compare(lvals[2:-2], range(2, 8))