list.zc

实现树形结构

//[of]:description
//[c]Linked list of pointers
//[cf]
//[of]:imports
//[c]
import "base/types"
import "base/memory-allocator"
import "collection/collection"
//[cf]
//[of]:structures
//[c]
private typedef value = -> void
//[c]
public struct list item: local element
	value: value
end	
//[c]
public struct list
	first: list item
	last: list item
	size: size
end
//[cf]
//[c]
//[of]:list
//[of]:initialize - release
//[of]:initialize (list)
//[c]
public func initialize (list: list)

	first (list) = nil
	last (list) = nil
	size (list) = 0

end
//[cf]
//[of]:release (list)
//[c]
public func release (list: list)

	def item = first (list)
	while not nil (item)
		def next = next (item)
		free memory (item)
		item = next
	end

end
//[cf]
//[cf]
//[of]:enumerating
//[of]:each (list)
//[c]
public equ each (list: list)

	def e = first (list)
	while not nil (e)
		def v = value (e)
		yield (v)
		e = next sibling (e): list item
	end

end
//[cf]
//[cf]
//[of]:adding - removing
//[of]:append (list, value)
//[c]Appends an element
//[c]
public func append (list: list, value: value)

	// Create the node
	def e = allocate memory (sizeof local list item): list item
	next sibling (e) = nil
	value (e) = value

	// Update the last item	
	if not nil (last (list))
		next sibling (last (list)) = e
	end

	// Update the list	
	last (list) = e
	if is nil (first (list))
		first (list) = e
	end
	++ size (list)

end
//[cf]
//[of]:add (list, value)
//[c]
public equ add (list: list, value: value) = 
	append (list, value)
//[cf]
//[cf]
//[of]:testing
//[of]:is empty (list)
//[c]
public equ is empty (list: list) = is nil (first (list))
//[cf]
//[of]:not empty (list)
//[c]
public equ not empty (list: list) = not nil (first (list))
//[cf]
//[cf]
//[cf]
//[of]:list item
//[of]:enumerating
//[of]:each (item)
//[c]Enumerates all items of a list starting from this one
//[c]
public equ each (item: list item)

	def e = item
	while not nil (e)
		def v = value (e)
		yield (v)
		e = next sibling (e): list item
	end

end
//[cf]
//[cf]
//[of]:accessing
//[of]:next (item)
//[c]
public equ next (item: list item) = 
	next sibling (item) : list item
//[cf]
//[cf]
//[cf]