use reversely linked list for storing workflow history to reduce data size.

git-svn-id: https://svn.erp5.org/repos/public/erp5/trunk@18529 20353a03-c40f-0410-a6d1-a30d3c3de9de

product/ERP5Type/patches/WorkflowTool.py

@@ -29,6 +29,9 @@ from Products.ZSQLCatalog.SQLCatalog import Query, ComplexQuery, NegatedQuery
 from Products.CMFCore.utils import _getAuthenticatedUser
 from Products.ERP5Type.Cache import CachingMethod
 from sets import ImmutableSet
+from Acquisition import aq_base
+from Persistence import Persistent
+from Globals import PersistentMapping
 
 def DCWorkflowDefinition_notifyWorkflowMethod(self, ob, transition_list, args=None, kw=None):
     '''
@@ -604,3 +607,103 @@ def WorkflowTool_refreshWorklistCache(self):
           Base_zInsertIntoWorklistTable(**value_column_dict)
 
 WorkflowTool.refreshWorklistCache = WorkflowTool_refreshWorklistCache
+
+class WorkflowHistoryList(Persistent):
+    _bucket_size = 16
+
+    def __init__(self, iterable=None, prev=None):
+        self._prev = prev
+        self._slots = []
+        if iterable is not None:
+            for x in iterable:
+                self.append(x)
+
+    def __add__(self, iterable):
+        return self.__class__(tuple(self) + tuple(iterable))
+
+    def __contains__(self, item):
+        return item in tuple(self)
+
+    def __eq__(self, other):
+        return tuple(self) == tuple(other)
+
+    def __getitem__(self, index):
+        if index == -1:
+            return self._slots[-1]
+        elif isinstance(index, (int, long)):
+            # XXX this implementation is not so good, but rarely used.
+            return tuple(self)[index]
+        elif isinstance(index, slice):
+            return self.__class__((self[x] for x in
+                                   xrange(*index.indices(len(self)))))
+        else:
+            raise TypeError, 'tuple indices must be integers'
+
+    def __getslice__(self, start, end):
+        return self.__getitem__(slice(start, end))
+
+    def __getstate__(self):
+        return (self._prev, self._slots)
+
+    def __iter__(self):
+        bucket = self
+        stack = []
+        while bucket is not None:
+            stack.append(bucket)
+            bucket = bucket._prev
+        for i in reversed(stack):
+            for j in i._slots:
+                yield j
+
+    def __len__(self):
+        length = len(self._slots)
+        bucket = self._prev
+        while bucket is not None:
+            length += len(bucket._slots)
+            bucket = bucket._prev
+        return length
+
+    def __mul__(self, x):
+        return self.__class__(tuple(self) * x)
+
+    def __repr__(self):
+        #return '%s' % repr(tuple(self.__iter__()))
+        return '<%s object at 0x%x %r>' % (self.__class__.__name__, id(self), tuple(self))
+
+    def __rmul__(self, x):
+        return self.__class__(x * tuple(self))
+
+    def __setstate__(self, state):
+        self._prev, self._slots = state
+
+    def append(self, value):
+        if len(self._slots) < self._bucket_size:
+            self._slots.append(value)
+            self._p_changed = 1
+        else:
+            self._prev = self.__class__(self._slots, prev=self._prev)
+            self._slots = [value]
+
+def WorkflowTool_setStatusOf(self, wf_id, ob, status):
+    """ Append an entry to the workflow history.
+
+    o Invoked by workflow definitions.
+    """
+    wfh = None
+    has_history = 0
+    if getattr(aq_base(ob), 'workflow_history', None) is not None:
+        history = ob.workflow_history
+        if history is not None:
+            has_history = 1
+            wfh = history.get(wf_id, None)
+            if wfh is not None and not isinstance(wfh, WorkflowHistoryList):
+                wfh = WorkflowHistoryList(list(wfh))
+                ob.workflow_history[wf_id] = wfh
+    if wfh is None:
+        wfh = WorkflowHistoryList()
+        if not has_history:
+            ob.workflow_history = PersistentMapping()
+        ob.workflow_history[wf_id] = wfh
+    wfh.append(status)
+
+WorkflowTool.setStatusOf = WorkflowTool_setStatusOf