from turbogears import database


def flush():
	database.session.flush()

# some helpers

def map_table(class_, table, *args, **kwargs):
	"""Map tables to objects with knowledge about the session context."""
	class_.mapper = database.session.mapper(class_, table, *args, **kwargs)
	class_.table = table
	return class_.mapper

def map_single_table_inheritance(class_, inherits, *args, **kwargs):
	"""Map tables to multiple types of objects with knowledge about the session context."""
	class_.mapper = database.session.mapper(class_, inherits=inherits, *args, **kwargs)
	class_.table = inherits.mapped_table
	return class_.mapper

def repr_impl(self, fields):
	return "<%s(%s)>" % (self.__class__.__name__, ", ".join(map(name_or_none, fields)))

def name_or_none(possibly_null_relation):
	if possibly_null_relation is None:
		return 'None'
	if hasattr(possibly_null_relation, 'name'):
		return possibly_null_relation.name
	try:
		possibly_null_relation + ''
	except TypeError:
		pass
	else:
		return repr(possibly_null_relation)
	if hasattr(possibly_null_relation, 'iteritems'):
		return '{%s}' % ', '.join(map(lambda k, v: '%s: %s' % (name_or_none(k), name_or_none(v)),
			possibly_null_relation.iteritems()))
	try:
		iter(possibly_null_relation)
	except TypeError:
		return repr(possibly_null_relation)
	else:
		return '[%s]' % ', '.join(map(name_or_none, possibly_null_relation))

def func_once(func):
	"A decorator that runs a function only once."
	def decorated(*args, **kwargs):
		try:
			return decorated._once_result
		except AttributeError:
			decorated._once_result = func(*args, **kwargs)
			return decorated._once_result
	return decorated

def method_once(method):
	"A decorator that runs a method only once."
	attrname = "_%s_once_result" % id(method)
	def decorated(self, *args, **kwargs):
		try:
			return getattr(self, attrname)
		except AttributeError:
			setattr(self, attrname, method(self, *args, **kwargs))
			return getattr(self, attrname)
	return decorated

class Named(object):
	@classmethod
	def byName(cls, name):
		return cls.query.filter(cls.c.name==name).one()
	
	@classmethod
	def delete_byName(cls, name):
		cls.table.delete(cls.c.name==name).execute()