class SpecialNone(object):
	pass

class OrderedDict (object):
	_list = 0
	_listmap = 0
	_classname = 0

	def __init__(self, val={}):
		object.__init__(self)
		self._list = []
		self._classname = "OrderedDict"
		self._listmap = dict(val)

	def addvals(self, key):
		vlst = self.listvals(key)

		for v in vlst[1:]:
			if type(vlst[0]) == list and type(v) != list:
				v = [v]

			vlst[0] += v

		return vlst[0]

	def listvals(self, key):
		return [v[0] for v in self._listmap[key]]

	def last(self, key):
		"""
		get the last-added value to a key
		"""
		lst = self._listmap[key]

		return lst[-1][0]

	def __setitem__(self, key, val):
		if key in self._listmap:
			lst = self._listmap[key]

			val2 = SpecialNone
			for v in lst:
				if v[0] == val:
					val2 = v[0]
					break

			if val2 == SpecialNone:
				lst.append([val, len(self._list)])
		else:
			self._listmap[key] = [[val, len(self._list)]]

		self._list.append([key, val])

	def __len__(self):
		return len(self._list)

	def __getitem__(self, key):
		lst = self._listmap[key]

		if len(lst) == 1: return lst[0][0]
		else: return [val[0] for val in lst]

	def __iter__(self):
		def iter(d):
			for k, v in d._list:
				yield k

		return iter(self)

	def iteritems(self):
		def iter(d):
			for k, v in d._list:
				yield (k, v)

		return iter(self)

	def keys(self):
		lst = []
		for k, v in self._list:
			lst.append(k)

		return lst

	def values(self):
		lst = []
		for k, v in self._list:
			lst.append(v)

		return lst


	def __str__(self):
		return repr(self)

	def __repr__(self):
		s = self._classname + "({"

		i = 0
		for k, v in self.iteritems():
			if i != 0: s += ", "
			s += repr(k) + " : " + repr(v)
			i += 1

		s += "})"

		return s

class AttributeDict (OrderedDict):
	def __init__(self, val={}):
		OrderedDict.__init__(self, val)
		self._classname = "AttributeDict"

	def __getattribute__(self, attr):
		if attr in OrderedDict.__getattribute__(self, "__dict__"):
			return OrderedDict.__getattribute__(self, attr)
		else:
			if attr in self:
				return self[attr]
			else: return OrderedDict.__getattribute__(self, attr)


	def __setattr__(self, attr, val):
		if attr in OrderedDict.__getattribute__(self, "__dict__") or attr in \
		   ["_list", "_listmap", "_classname", "_listmap"]:
			 OrderedDict.__setattr__(self, attr, val)
		else:
			self[attr] = val

	def prettystr(self, tlevel=0):
		t = ""
		for i in xrange(tlevel):
			t += "    "

		s = "{\n"
		for k, v in self.iteritems():
			if type(v) == AttributeDict:
				s += t + "    " + k + ": " + v.prettystr(tlevel+1) + "\n"
			else:
				s += t + "    " + k + ": " + str(v) + "\n"

		s += t + "}\n"

		return s