Source code for direct.showbase.CountedResource


[docs]class CountedResource(object): """ This class is an attempt to combine the RAIA idiom with reference counting semantics in order to model shared resources. RAIA stands for "Resource Allocation Is Acquisition" (see 'Effective C++' for a more in-depth explanation) When a resource is needed, create an appropriate CountedResource object. If the resource is already available (meaning another CountedResource object of the same type already exists), no action is taken. Otherwise, acquire() is invoked, and the resource is allocated. The resource will remain valid until all matching CountedResource objects have been deleted. When no objects of a particular CountedResource type exist, the release() function for that type is invoked and the managed resource is cleaned up. Usage: Define a subclass of CountedResource that defines the @classmethods acquire() and release(). In these two functions, define your resource allocation and cleanup code. IMPORTANT: If you define your own __init__ and __del__ methods, you MUST be sure to call down to the ones defined in CountedResource. Notes: Until we figure out a way to wrangle a bit more functionality out of Python, you MUST NOT inherit from any class that has CountedResource as its base class. In debug mode, this will raise a runtime assertion during the invalid class's call to __init__(). If you have more than one resource that you want to manage/access with a single object, you should subclass CountedResource again. See the example code at the bottom of this file to see how to accomplish this (This is useful for dependent resources). """
[docs] @classmethod def incrementCounter(cls): try: cls.RESOURCE_COUNTER += 1 except AttributeError: cls.RESOURCE_COUNTER = 1 if cls.RESOURCE_COUNTER == 1: cls.acquire()
[docs] @classmethod def decrementCounter(cls): try: cls.RESOURCE_COUNTER_INIT_FAILED del cls.RESOURCE_COUNTER_INIT_FAILED except AttributeError: cls.RESOURCE_COUNTER -= 1 if cls.RESOURCE_COUNTER < 1: cls.release()
[docs] @classmethod def getCount(cls): return cls.RESOURCE_COUNTER
[docs] @classmethod def acquire(cls): pass
[docs] @classmethod def release(cls): pass
[docs] def __init__(self): cls = type(self) cls.RESOURCE_COUNTER_INIT_FAILED = True assert cls.mro()[1] == CountedResource, \ (lambda: \ '%s cannot be subclassed.' \ % cls.mro()[list(cls.mro()).index(CountedResource) - 1].__name__)() del cls.RESOURCE_COUNTER_INIT_FAILED self.incrementCounter()
def __del__(self): self.decrementCounter()
if __debug__ and __name__ == '__main__': class MouseResource(CountedResource): """ A simple class to demonstrate the acquisition of a resource. """ @classmethod def acquire(cls): # The call to the super-class's acquire() is # not necessary at the moment, but may be in # the future, so do it now for good measure. super(MouseResource, cls).acquire() # Now acquire the resource this class is # managing. print('-- Acquire Mouse') @classmethod def release(cls): # First, release the resource this class is # managing. print('-- Release Mouse') # The call to the super-class's release() is # not necessary at the moment, but may be in # the future, so do it now for good measure. super(MouseResource, cls).release() def __init__(self): super(MouseResource, self).__init__() def __del__(self): super(MouseResource, self).__del__() class CursorResource(CountedResource): """ A class to demonstrate how to implement a dependent resource. Notice how this class also inherits from CountedResource. Instead of subclassing MouseCounter, we will just acquire it in our __init__() and release it in our __del__(). """ @classmethod def acquire(cls): super(CursorResource, cls).acquire() print('-- Acquire Cursor') @classmethod def release(cls): print('-- Release Cursor') super(CursorResource, cls).release() def __init__(self): # The required resource references should # be stored on 'self' since we want to # release it when the object is deleted. self.__mouseResource = MouseResource() # Call the super-classes __init__() # after all required resources are # referenced. super(CursorResource, self).__init__() def __del__(self): # Free up the most dependent resource # first, the one this class is managing. super(CursorResource, self).__del__() # Now unlink any required resources. del self.__mouseResource class InvalidResource(MouseResource): @classmethod def acquire(cls): super(InvalidResource, cls).acquire() print('-- Acquire Invalid') @classmethod def release(cls): print('-- Release Invalid') super(InvalidResource, cls).release() print('\nAllocate Mouse') m = MouseResource() print('Free up Mouse') del m print('\nAllocate Cursor') c = CursorResource() print('Free up Cursor') del c print('\nAllocate Mouse then Cursor') m = MouseResource() c = CursorResource() print('Free up Cursor') del c print('Free up Mouse') del m print('\nAllocate Mouse then Cursor') m = MouseResource() c = CursorResource() print('Free up Mouse') del m print('Free up Cursor') del c print('\nAllocate Cursor then Mouse') c = CursorResource() m = MouseResource() print('Free up Mouse') del m print('Free up Cursor') del c print('\nAllocate Cursor then Mouse') c = CursorResource() m = MouseResource() print('Free up Cursor') del c # example of an invalid subclass try: print('\nAllocate Invalid') i = InvalidResource() print('Free up Invalid') except AssertionError as e: print(e) print('') print('Free up Mouse') del m def demoFunc(): print('\nAllocate Cursor within function') c = CursorResource() print('Cursor will be freed on function exit') demoFunc()