New Frame uses a distinct type to express the different mode of operation. This is clean enough to get going

Author: Byron

fun.py

@@ -237,7 +237,13 @@ def delta_list_apply(dcl, bbuf, write, lbound_offset=0, size=0):
 
 
 class DeltaChunkList(list):
-	"""List with special functionality to deal with DeltaChunks"""
+	"""List with special functionality to deal with DeltaChunks.
+	There are two types of lists we represent. The one was created bottom-up, working
+	towards the latest delta, the other kind was created top-down, working from the 
+	latest delta down to the earliest ancestor. This attribute is queryable 
+	after all processing with is_reversed."""
+	
+	__slots__ = tuple()
 
 	def rbound(self):
 		""":return: rightmost extend in bytes, absolute"""
@@ -255,24 +261,18 @@ def size(self):
 		""":return: size of bytes as measured by our delta chunks"""
 		return self.rbound() - self.lbound()
 
-	def connect_with(self, bdcl, tdcl):
+	def connect_with(self, bdcl):
 		"""Connect this instance's delta chunks virtually with the given base.
 		This means that all copy deltas will simply apply to the given region 
 		of the given base. Afterwards, the base is optimized so that add-deltas
 		will be truncated to the region actually used, or removed completely where
 		adequate. This way, memory usage is reduced.
-		:param bdcl: DeltaChunkList to serve as base
-		:param tdcl: topmost delta chunk list. If set, reverse order is assumed
-			and the list is connected more efficiently"""
-		if tdcl is None:
-			for dc in self:
-				if not dc.has_data():
-					dc.set_copy_chunklist(bdcl[dc.so:dc.ts])
-				# END handle overlap
-			# END for each dc
-		else:
-			raise NotImplementedError("todo")
-		# END handle order
+		:param bdcl: DeltaChunkList to serve as base"""
+		for dc in self:
+			if not dc.has_data():
+				dc.set_copy_chunklist(bdcl[dc.so:dc.ts])
+			# END handle overlap
+		# END for each dc
 
 	def apply(self, bbuf, write, lbound_offset=0, size=0):
 		"""Only used by public clients, internally we only use the global routines
@@ -396,8 +396,37 @@ def __getslice__(self, absofs, size):
 
 		# ndcl.check_integrity()
 		return ndcl
-			
-			
+
+	
+class TopdownDeltaChunkList(DeltaChunkList):
+	"""Represents a list which is generated by feeding its ancestor streams one by 
+	one"""
+	__slots__ = ('frozen', )	# if True, the list is frozen and can reproduce all data
+								# Will only be set in lists which where processed top-down 
+	
+	def __init__(self):
+		self.frozen = False
+	
+	def connect_with_next_base(self, bdcl):
+		"""Connect this chain with the next level of our base delta chunklist.
+		The goal in this game is to mark as many of our chunks rigid, hence they
+		cannot be changed by any of the upcoming bases anymore. Once all our 
+		chunks are marked like that, we can stop all processing
+		:param bdcl: data chunk list being one of our bases. They must be fed in 
+			consequtively and in order, towards the earliest ancestor delta
+		:return: True if processing was done. Use it to abort processing of
+			remaining streams"""
+		if self.frozen == 1:
+			# Can that ever be hit ?
+			return False
+		# END early abort
+		# mark us so that the is_reversed method returns True, without us thinking
+		# we are frozen
+		self.frozen = -1
+		
+		raise NotImplementedError("todo")
+		return True
+		
 
 #} END structures
 
@@ -540,8 +569,14 @@ def connect_deltas(dstreams, reverse):
 		If True, deltas are ordered so that the one to be applied last comes first.
 	:return: DeltaChunkList, containing all operations to apply"""
 	bdcl = None							# data chunk list for initial base
-	dcl = DeltaChunkList()
 	tdcl = None							# topmost dcl, only effective if reverse is True
+	
+	if reverse:
+		dcl = tdcl = TopdownDeltaChunkList()
+	else:
+		dcl = DeltaChunkList()
+	# END handle type of first chunk list
+	
 	for dsi, ds in enumerate(dstreams):
 		# print "Stream", dsi
 		db = ds.read()
@@ -603,13 +638,14 @@ def connect_deltas(dstreams, reverse):
 
 		dcl.compress()
 
-		if reverse and tdcl is None:
-			tdcl = dcl
-		# END handle reverse
-		
 		# merge the lists !
 		if bdcl is not None:
-			dcl.connect_with(bdcl, tdcl)
+			if tdcl:
+				if not tdcl.connect_with_next_base(dcl):
+					break
+				# END early abort
+			else:
+				dcl.connect_with(bdcl)
 		# END handle merge
 
 		# dcl.check_integrity()
@@ -619,7 +655,10 @@ def connect_deltas(dstreams, reverse):
 		dcl = DeltaChunkList()
 	# END for each delta stream
 
-	return bdcl
+	if tdcl:
+		return tdcl
+	else:
+		return bdcl
 
 
 def apply_delta_data(src_buf, src_buf_size, delta_buf, delta_buf_size, write):