home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 January / maximum-cd-2011-01.iso / DiscContents / xbmc-9.11.exe / system / python / spyce / spyceCache.py < prev    next >
Encoding:
Python Source  |  2009-12-23  |  4.1 KB  |  153 lines
  1. ##################################################
  2. # SPYCE - Python-based HTML Scripting
  3. # Copyright (c) 2002 Rimon Barr.
  4. #
  5. # Refer to spyce.py
  6. # CVS: $Id: spyceCache.py 20864 2009-06-02 06:16:47Z ceros7 $
  7. ##################################################
  8.  
  9. import md5, binascii, os, string
  10. try: from cPickle import dumps, loads
  11. except: from pickle import dumps, loads
  12.  
  13. __doc__ = '''Caching related functionality.'''
  14.  
  15. # rimtodo: specify some sort of cache size limit
  16.  
  17. ##################################################
  18. # Generic cache
  19. #
  20.  
  21. class cache:
  22.   "Generic cache"
  23.   def __getitem__(self, key):
  24.     raise 'not implemented'
  25.   def __setitem__(self, key, value):
  26.     raise 'not implemented'
  27.   def __delitem__(self, key):
  28.     raise 'not implemented'
  29.   def keys(self):
  30.     raise 'not implemented'
  31.   def has_key(self, key):
  32.     raise 'not implemented'
  33.  
  34. ##################################################
  35. # Storage caches
  36. #
  37.  
  38. class memoryCache(cache):
  39.   "In-memory cache"
  40.   def __init__(self, infoStr=None):
  41.     self.cache = {}
  42.     self.info = infoStr
  43.   def __getitem__(self, key):
  44.     return self.cache[key]
  45.   def __setitem__(self, key, value):
  46.     self.cache[key]=value
  47.   def __delitem__(self, key):
  48.     del self.cache[key]
  49.   def keys(self):
  50.     return self.cache.keys()
  51.   def has_key(self, key):
  52.     return self.cache.has_key(key)
  53.  
  54. class fileCache(cache):
  55.   "File-based cache"
  56.   def __init__(self, infoStr):
  57.     self._cachedir = string.strip(infoStr)
  58.   def __getitem__(self, key):
  59.     filename = os.path.join(self._cachedir, self._encodeKey(key))
  60.     f = None
  61.     try:
  62.       try:
  63.         f = open(filename, 'r')
  64.         return loads(f.read())
  65.       finally:
  66.         if f: f.close()
  67.     except IOError: pass
  68.     except EOFError: pass
  69.     raise KeyError()
  70.   def __setitem__(self, key, value):
  71.     try:
  72.       if self[key]==value: return
  73.     except KeyError: pass
  74.     filename = os.path.join(self._cachedir, self._encodeKey(key))
  75.     f = None
  76.     try:
  77.       f = open(filename, 'w')
  78.       f.write(dumps(value,1))
  79.     finally:
  80.       if f: f.close()
  81.   def __delitem__(self, key):
  82.     filename = os.path.join(self._cachedir, self._encodeKey(key))
  83.     if os.path.exists(filename):
  84.       os.remove(filename)
  85.   def keys(keys):
  86.     raise 'not implemented'
  87.   def has_key(self, key):
  88.     try:
  89.       self[key]
  90.       return 1
  91.     except KeyError:
  92.       return 0
  93.   def _encodeKey(self, key):
  94.     return 'spyceCache-'+binascii.hexlify(md5.new(str(key)).digest())
  95.     
  96.  
  97. ##################################################
  98. # Policy caches
  99. #
  100.  
  101. #rimtodo:
  102.  
  103. ##################################################
  104. # Semantic cache
  105. #
  106.  
  107. class semanticCache(cache):
  108.   """Cache that knows how to validate and generate its own data. Note, that the
  109.   cache stores elements as (validity, data) tuples. The valid is a function
  110.   invoked as valid(key,validity), returning a boolean; and generate is a
  111.   function invoked as generate(key) returning (validity, data). The get()
  112.   method returns only the data."""
  113.   def __init__(self, cache, valid, generate):
  114.     self.valid = valid
  115.     self.generate = generate
  116.     self.cache = cache
  117.   def get(self, key):
  118.     "Get (or generate) a cache element."
  119.     if self.cache:
  120.       if not self.cache.has_key(key) or not self.valid(key, self.cache[key][0]):
  121.         self.cache[key] = self.generate(key)
  122.       return self.cache[key][1]
  123.     else:
  124.       return self.generate(key)[1]
  125.   def purge(self, key):
  126.     "Remove a cache element, if it exists."
  127.     if self.cache.has_key(key):
  128.       del self.cache[key]
  129.   # standard dictionary methods
  130.   def __getitem__(self, key):
  131.     return self.get(key)
  132.   def __delitem__(self, key):
  133.     return self.purge(key)
  134.   def has_key(self, key):
  135.     if self.cache:
  136.       return self.cache.has_key()
  137.     else:
  138.       return 0
  139.   def keys(self):
  140.     if self.cache:
  141.       return self.cache.keys()
  142.     else:
  143.       return []
  144.   def values(self):
  145.     if self.cache:
  146.       return map(lambda x: x[1], self.cache.values())
  147.     else:
  148.       return []
  149.   def clear(self):
  150.     if self.cache:
  151.       self.cache.clear()
  152.  
  153.