new file mode 100644

@@ -0,0 +1,172 @@

+# Copyright (c) 2011 Edward Langley

+# All rights reserved.

+# 

+# Redistribution and use in source and binary forms, with or without

+# modification, are permitted provided that the following conditions

+# are met:

+# 

+# Redistributions of source code must retain the above copyright notice,

+# this list of conditions and the following disclaimer.

+# 

+# Redistributions in binary form must reproduce the above copyright

+# notice, this list of conditions and the following disclaimer in the

+# documentation and/or other materials provided with the distribution.

+# 

+# Neither the name of the project's author nor the names of its

+# contributors may be used to endorse or promote products derived from

+# this software without specific prior written permission.

+# 

+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS

+# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

+# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED

+# TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

+# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

+# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

+# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+

+import contextlib

+import functools

+

+class CallableGeneratorContextManager(contextlib.GeneratorContextManager):

+	'''A subclass of :py:class:`contextlib.GeneratorContextManager` which can be called

+

+	Basically, this exists to avoid unecessary hassles with object methods which need special treatment'''

+	def __call__(self, *a, **kw):

+		'''Enter self's context and call the object returned by __enter__'''

+		with self as obj:

+			return obj(*a, **kw)

+

+#NOTE: (ed) this is ripped out of contextlib but I've replaced contextlib.GeneratorContextManager with the previous class

+def contextmanager(func):

+	'''see documentation for :py:class:`contextlib.GeneratorContextManager`'''

+	@functools.wraps(func)

+	def helper(*args, **kwds):

+		return CallableGeneratorContextManager(func(*args, **kwds))

+		# ^^^ This is the only line diferent from contextlib.contextmanager

+	return helper

+

+

+class RegisteredObj(object):

+	'''Interface definition for :py:attr:`Registry.child_class`'''

+	def __init__(self, name, *args):

+		self.name = name

+

+	def update(self, other):

+		'''override me'''

+		pass

+

+def make_ctxt_manager(name):

+	'''create a factory method for making and registering objects suitable to be registered in

+	the Registry.

+

+	:param str name: The name of the factory method

+	:return: A contextmanager

+	'''

+	@contextmanager

+	def _inner(self, name, *args, **kwargs):

+		obj = self.registry.get(name) if name in self.registry else self.child_class(name, *args, **kwargs)

+		yield obj

+		if obj.name not in self.registry:

+			self.register(obj)

+

+	_inner.__name__ = name

+	return _inner

+

+import threading

+class Registry(object):

+	#: The kind of object to be stored in the registry

+	#: must, as a minimum implement the :py:class:`RegisteredObj` interface

+	child_class = None

+

+	def __setitem__(self, name, value):

+		with self._lock:

+			self.registry[name] = value

+

+	def __getitem__(self, name):

+		with self._lock:

+			return self.registry[name]

+

+	def __delitem__(self, name):

+		with self._lock:

+			del self.registry[name]

+

+	@classmethod

+	def reset(cls):

+		with cls._lock:

+			cls.registry.clear()

+

+	@classmethod

+	def get(cls, name, default=None):

+		with cls._lock:

+			return cls.registry.get(name, default)

+

+	_init_lock = threading.RLock()

+	@staticmethod

+	def setup(cls):

+		'''Decorate the registry with this, this sets the 'registry' attribute to an

+		empty dictionary and a factory function for creating child objects.

+

+		The name of the factory function is that of the class the registry registers,

+		but lowercase'''

+

+		with cls._init_lock:

+			factory_name = cls.child_class.__name__.lower()

+			setattr(cls, factory_name, make_ctxt_manager(factory_name))

+			cls.registry = {}

+			cls._lock = threading.RLock()

+			return cls

+

+	def register(self, obj):

+		with self._lock:

+			old_obj = self.registry.get(obj.name)

+			result = obj

+

+			if old_obj is not None:

+				old_obj.update(obj)

+				result = old_obj

+			else:

+				self.registry[obj.name] = obj

+

+		return result

+

+### DEMO, read this for a practical example of how the above works:

+

+class DataObj(RegisteredObj):

+	def __init__(self, name, a):

+		RegisteredObj.__init__(self, name)

+		self.a = a

+		self.b = None

+		self.c = None

+

+@Registry.setup

+class DataObjRegistry(Registry):

+	child_class = DataObj

+

+if __name__ == '__main__':

+	#Demo code

+

+	registry = DataObjRegistry()

+	with registry.dataobj('first_obj', 1) as obj1:

+		obj1.b = 2

+

+	with registry.dataobj('second_obj', 2) as obj2:

+		obj2.b = 3

+		obj2.c = 4

+

+	with registry.dataobj('third_obj', 3) as obj3:

+		obj1.b = 4

+

+	import random

+	def shuffled(lis):

+	lis = lis[:]

+	random.shuffle(lis)

+	return iter(lis)

+

+

+	for obj_name in shuffled(['first_obj', 'second_obj', 'third_obj']):

+		with registry.dataobj(obj_name) as obj:

+			print '%s - a: %s, b: %s, c: %s' % (obj.name, obj.a, obj.b, obj.c)