# # Gramps - a GTK+/GNOME based genealogy program # # Copyright (C) 2000-2006 Donald N. Allingham # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # # $Id$ """ Provides the common infrastructure for database formats that must hold all of their data in memory. """ #------------------------------------------------------------------------- # # Python modules # #------------------------------------------------------------------------- import time #------------------------------------------------------------------------- # # GRAMPS modules # #------------------------------------------------------------------------- from RelLib import * from _GrampsDbBase import * class GrampsInMemCursor(GrampsCursor): """ Cursor class for in-memory database classes. Since the in-memory classes use python dictionaries, the python iter class is used to provide the cursor function. """ def __init__(self,src_map): self.src_map = src_map self.current = iter(src_map) def first(self): self.current = iter(self.src_map) return self.next() def next(self): try: index = self.current.next() return (index,self.src_map[index]) except StopIteration: return None def close(self): pass #------------------------------------------------------------------------- # # GrampsInMemDB # #------------------------------------------------------------------------- class GrampsInMemDB(GrampsDbBase): """GRAMPS database object. This object is a base class for other objects.""" ID_INDEX = 1 # an index of the gramps id in the data tuple def __init__(self): """creates a new GrampsDB""" GrampsDbBase.__init__(self) self.person_map = {} self.name_group = {} self.family_map = {} self.place_map = {} self.source_map = {} self.repository_map = {} self.media_map = {} self.event_map = {} self.metadata = {} self.filename = "" self.id_trans = {} self.pid_trans = {} self.fid_trans = {} self.eid_trans = {} self.sid_trans = {} self.rid_trans = {} self.oid_trans = {} self.undodb = [] def load(self,name,callback,mode="w"): self.full_name = name self.readonly = mode == "r" self.open_undodb() # Re-set the undo history to a fresh session start self.undoindex = -1 self.translist = [None] * len(self.translist) self.abort_possible = True self.undo_history_timestamp = time.time() def get_person_cursor(self): return GrampsInMemCursor(self.person_map) def get_family_cursor(self): return GrampsInMemCursor(self.family_map) def get_event_cursor(self): return GrampsInMemCursor(self.event_map) def get_place_cursor(self): return GrampsInMemCursor(self.place_map) def get_source_cursor(self): return GrampsInMemCursor(self.source_map) def get_repository_cursor(self): return GrampsInMemCursor(self.repository_map) def get_media_cursor(self): return GrampsInMemCursor(self.media_map) def get_event_cursor(self): return GrampsInMemCursor(self.event_map) def close(self): self.close_undodb() def set_name_group_mapping(self,name,group): if group == None and self.name_group.has_key(name): del self.name_group[name] else: self.name_group[name] = group def get_surname_list(self): a = {} for person_id in iter(self.person_map): p = self.get_person_from_handle(person_id) a[p.get_primary_name().get_group_as()] = 1 vals = a.keys() vals.sort() return vals def _del_person(self,handle): person = self.get_person_from_handle(str(handle)) del self.id_trans[person.get_gramps_id()] del self.person_map[str(handle)] def _del_source(self,handle): source = self.get_source_from_handle(str(handle)) del self.sid_trans[source.get_gramps_id()] del self.source_map[str(handle)] def _del_repository(self,handle): repository = self.get_repository_from_handle(str(handle)) del self.rid_trans[repository.get_gramps_id()] del self.repository_map[str(handle)] def _del_place(self,handle): place = self.get_place_from_handle(str(handle)) del self.pid_trans[place.get_gramps_id()] del self.place_map[str(handle)] def _del_media(self,handle): obj = self.get_object_from_handle(str(handle)) del self.oid_trans[obj.get_gramps_id()] del self.media_map[str(handle)] def _del_family(self,handle): family = self.get_family_from_handle(str(handle)) del self.fid_trans[family.get_gramps_id()] del self.family_map[str(handle)] def _del_event(self,handle): event = self.get_event_from_handle(str(handle)) del self.eid_trans[event.get_gramps_id()] del self.event_map[str(handle)] def get_trans_map(self,signal_root): """ A silly method to get the secondary index map based on the signal name root for a given object type. The BDB backend manages this transparently, but we need to manually take care of secondary indices in the InMem backend. """ trans_maps = { 'person': self.id_trans, 'family': self.fid_trans, 'source': self.sid_trans, 'event' : self.eid_trans, 'media' : self.oid_trans, 'place' : self.pid_trans, 'repository': self.rid_trans} return trans_maps[signal_root] def undo_data(self, data, handle, db_map, signal_root): """ The BDB backend manages secondary indices transparently, but we need to manually take care of secondary indices in the InMem backend. """ trans_map = self.get_trans_map(signal_root) obj = db_map.get(handle) if data == None: self.emit(signal_root + '-delete', ([handle], )) del trans_map[obj[self.ID_INDEX]] del db_map[handle] else: if obj: signal = signal_root + '-update' if obj[self.ID_INDEX] != data[self.ID_INDEX]: del trans_map[obj[self.ID_INDEX]] else: signal = signal_root + '-add' db_map[handle] = data trans_map[data[self.ID_INDEX]] = str(handle) self.emit(signal, ([handle], )) def _commit_inmem_base(self,obj,db_map,trans_map): if self.readonly or not obj or not obj.get_handle(): return False gid = obj.gramps_id old_data = db_map.get(obj.handle) if old_data: old_id = old_data[self.ID_INDEX] if obj.gramps_id != old_id: del trans_map[old_id] trans_map[gid] = obj.handle return True def commit_person(self,person,transaction,change_time=None): if not self._commit_inmem_base(person,self.person_map,self.id_trans): return GrampsDbBase.commit_person(self,person,transaction,change_time) def commit_place(self,place,transaction,change_time=None): if not self._commit_inmem_base(place,self.place_map,self.pid_trans): return GrampsDbBase.commit_place(self,place,transaction,change_time) def commit_family(self,family,transaction,change_time=None): if not self._commit_inmem_base(family,self.family_map,self.fid_trans): return GrampsDbBase.commit_family(self,family,transaction,change_time) def commit_event(self,event,transaction,change_time=None): if not self._commit_inmem_base(event,self.event_map,self.eid_trans): return GrampsDbBase.commit_event(self,event,transaction,change_time) def commit_media_object(self,obj,transaction,change_time=None): if not self._commit_inmem_base(obj,self.media_map,self.oid_trans): return GrampsDbBase.commit_media_object(self,obj,transaction,change_time) def commit_source(self,source,transaction,change_time=None): if not self._commit_inmem_base(source,self.source_map,self.sid_trans): return GrampsDbBase.commit_source(self,source,transaction,change_time) def commit_repository(self,repository,transaction,change_time=None): if not self._commit_inmem_base(repository,self.repository_map, self.rid_trans): return GrampsDbBase.commit_repository(self,repository,transaction,change_time) def get_person_from_gramps_id(self,val): handle = self.id_trans.get(str(val)) if handle: data = self.person_map[handle] if data: person = Person() person.unserialize(data) return person return None def get_family_from_gramps_id(self,val): handle = self.fid_trans.get(str(val)) if handle: data = self.family_map[handle] if data: family = Family() family.unserialize(data) return family return None def get_event_from_gramps_id(self,val): handle = self.eid_trans.get(str(val)) if handle: data = self.event_map[handle] if data: event = Event() event.unserialize(data) return event return None def get_place_from_gramps_id(self,val): handle = self.pid_trans.get(str(val)) if handle: data = self.place_map[handle] if data: place = Place() place.unserialize(data) return place return None def get_source_from_gramps_id(self,val): handle = self.sid_trans.get(str(val)) if handle: data = self.source_map[handle] if data: source = Source() source.unserialize(data) return source return None def get_repository_from_gramps_id(self,val): handle = self.rid_trans.get(str(val)) if handle: data = self.repository_map[handle] if data: repository = Repository() repository.unserialize(data) return repository return None def get_object_from_gramps_id(self,val): handle = self.oid_trans.get(str(val)) if handle: data = self.media_map[handle] if data: obj = MediaObject() obj.unserialize(data) return obj return None