"""
Absolute and Relative Paths

An absolute path is a list of nodes.

A relative path has two parts - the number of levels to go up, and the path
down from that ancestor to the destination.

The question of whether there is a single `root' or many is not important.
"""

class path_absolute:
	def __init__(self, list=None):
		self.list = list or []
	def enter(self, node):
		self.list.append(node)
	def leave(self, n=1):
		while (n>0):
			self.list.pop()
			n = n - 1
	def node(self, level=0):
		return self.list[-1-level]
	def node_from_top(self, level=0):
		return self.list[level]
	def is_root(self):
		return len(self.list) == 0
	def depth(self):
		return len(self.list)
	def __repr__(self):
		return "path_absolute(%s)" % `self.list`
	def move(self, relative):
		self.leave(relative.level())

class path:
	def __init__(self, list=None, up=0):
		self.list = list or []
		self.up = up
	def enter(self, node, place = None):
		if place and place.node:
			self.list.append(node)
	def leave(self):
		if self.list:
			self.list.pop()
		else
			self.level = self.level + 1
	def node(self, level=0, place):
		if self.list:
			return self.list[-1]
		return place.node(self.level)
	def absolute(self, place):
		absolute = path_absolute()
		for i in range(0, place.depth() - self.level):
			absolute.enter(place.node_from_top(i))
		for node in self.list:
			absolute.enter(node)
		return absolute
	def level(self):
		return self.level
	def __repr__(self):
		return "path_relative(%d, %s)" % (self.level, `self.list`)

def test():
	a = path_absolute(['top', 'middle', 'bottom'])
	print a
	r = path_relative(2, ['another'])
	print r
	print r.absolute(a)
	print r.node(a)

if __name__ == '__main__':
        test()

def aptr_to_aaddr(aptr):
	aaddr = []
	for obj in aptr:
		aaddr.append(obj.get_name())
	return aaddr

def aaddr_to_aptr(aaddr):
	aptr = []
	obj = root
	for name in aaddr:
		obj = obj.get_child(name)
		aptr.append(obj)
	return aptr

class node:
	def __init__(self, place, name=None, x=0, y=0):
		# place is an absolute pointer to this object
		self.name     = name
		self.children = {}

#		self.tk_group = None
		self.x        = x
		self.y        = y

#		self.move_to(x,y)
		self.links    = []   # unification links from this node to another
				     # each item is a relative pointer to another node
	def get_name(self):
		return self.name