"""Manage shelves of pickled objects.

A "shelf" is a persistent, dictionary-like object.  The difference
with dbm databases is that the values (not the keys!) in a shelf can
be essentially arbitrary Python objects -- anything that the "pickle"
module can handle.  This includes most class instances, recursive data
types, and objects containing lots of shared sub-objects.  The keys
are ordinary strings.

To summarize the interface (key is a string, data is an arbitrary
object):

        import shelve
        d = shelve.open(filename) # open, with (g)dbm filename -- no suffix

        d[key] = data   # store data at key (overwrites old data if
                        # using an existing key)
        data = d[key]   # retrieve data at key (raise KeyError if no
                        # such key)
        del d[key]      # delete data stored at key (raises KeyError
                        # if no such key)
        flag = d.has_key(key)   # true if the key exists
        list = d.keys() # a list of all existing keys (slow!)

        d.close()       # close it

Dependent on the implementation, closing a persistent dictionary may
or may not be necessary to flush changes to disk.
"""

# Try using cPickle and cStringIO if available.

try:
        from cPickle import Pickler, Unpickler
except ImportError:
        from pickle import Pickler, Unpickler

try:
        from cStringIO import StringIO
except ImportError:
        from StringIO import StringIO


class Shelf:
        """Base class for shelf implementations.

        This is initialized with a dictionary-like object.
        See the module's __doc__ string for an overview of the interface.
        """

        def __init__(self, dict):
                self.dict = dict
        
        def keys(self):
                return self.dict.keys()
        
        def __len__(self):
                return len(self.dict)
        
        def has_key(self, key):
                return self.dict.has_key(key)

        def get(self, key, default=None):
                if self.dict.has_key(key):
                        return self[key]
                return default
        
        def __getitem__(self, key):
                f = StringIO(self.dict[key])
                return Unpickler(f).load()
        
        def __setitem__(self, key, value):
                f = StringIO()
                p = Pickler(f)
                p.dump(value)
                self.dict[key] = f.getvalue()
        
        def __delitem__(self, key):
                del self.dict[key]
        
        def close(self):
                try:
                        self.dict.close()
                except:
                        pass
                self.dict = 0

        def __del__(self):
                self.close()

        def sync(self):
                if hasattr(self.dict, 'sync'):
                        self.dict.sync()
            

class BsdDbShelf(Shelf):
        """Shelf implementation using the "BSD" db interface.

        This adds methods first(), next(), previous(), last() and
        set_location() that have no counterpart in [g]dbm databases.

        The actual database must be opened using one of the "bsddb"
        modules "open" routines (i.e. bsddb.hashopen, bsddb.btopen or
        bsddb.rnopen) and passed to the constructor.

        See the module's __doc__ string for an overview of the interface.
        """

        def __init__(self, dict):
            Shelf.__init__(self, dict)

        def set_location(self, key):
             (key, value) = self.dict.set_location(key)
             f = StringIO(value)
             return (key, Unpickler(f).load())

        def next(self):
             (key, value) = self.dict.next()
             f = StringIO(value)
             return (key, Unpickler(f).load())

        def previous(self):
             (key, value) = self.dict.previous()
             f = StringIO(value)
             return (key, Unpickler(f).load())

        def first(self):
             (key, value) = self.dict.first()
             f = StringIO(value)
             return (key, Unpickler(f).load())

        def last(self):
             (key, value) = self.dict.last()
             f = StringIO(value)
             return (key, Unpickler(f).load())


class DbfilenameShelf(Shelf):
        """Shelf implementation using the "anydbm" generic dbm interface.

        This is initialized with the filename for the dbm database.
        See the module's __doc__ string for an overview of the interface.
        """
        
        def __init__(self, filename, flag='c'):
                import anydbm
                Shelf.__init__(self, anydbm.open(filename, flag))


def open(filename, flag='c'):
        """Open a persistent dictionary for reading and writing.

        Argument is the filename for the dbm database.
        See the module's __doc__ string for an overview of the interface.
        """
        
        return DbfilenameShelf(filename, flag)