Beispiel #1
0
    def __init__(self, options):
        """Konstruktor

        options ist ein dictionary, das bisher nur die Parameter
        root_directory und main_priority gesetzt haben braucht. Das
        Verhalten für refresh gehört aber ebenfalls hier hinein."""
        self.__sub_indexers = generateSubindexers(options)
        self.__storage = Storage(options)
        options["cache"]["storage"] = self.__storage
        self.__cache = Cache(options) # self.__storage, self.__sub_indexers)
        options["watcher"]["root_directory"] = options["root_directory"]
        self.__watcher = Watcher(options)
Beispiel #2
0
class Indexer:
    """Indexer-Basisklasse

    Diese Klasse verwaltet die gesammelten Informationen und die Indexer
    für im Dateibaum weiter unten liegende Verzeichnisse und stellt sie
    zur Verfügung."""
    def __init__(self, options):
        """Konstruktor

        options ist ein dictionary, das bisher nur die Parameter
        root_directory und main_priority gesetzt haben braucht. Das
        Verhalten für refresh gehört aber ebenfalls hier hinein."""
        self.__sub_indexers = generateSubindexers(options)
        self.__storage = Storage(options)
        options["cache"]["storage"] = self.__storage
        self.__cache = Cache(options) # self.__storage, self.__sub_indexers)
        options["watcher"]["root_directory"] = options["root_directory"]
        self.__watcher = Watcher(options)

    def __iter__(self):
        """Liefert einen Iterator auf die Sub-Indexer zurück."""
        return iter(self.__sub_indexers)

    def __cmp__(self, other):
        """Vergleichsfunktion, um das Sortieren zu vereinfachen"""
        return cmp(self.__priority, other.__priority)

    def refresh(self):
        res = self.__watcher.collect()
        self.__watcher.reset()

    def could_be(self, query):
        """Unscharfe Suchfunktion

        Diese Funktion soll anhand der Parameter überprüfen, ob eine genaue 
        Übereinstimmung überhaupt möglich ist (ohne die REs zu benutzen).
        Das ganze muss per Rekursion geschehen, um sinnvoll zu sein!
        Die Zwischenergebnisse müssen gecached werden, damit sie in der
        eigentlichen Suche wiederverwendet werden können."""
        return self.__cache.could_be(query)

    def find(self, query):
        return self.__cache.find(query)

    def __refresh_files(filelist):
        """Aktualisierungsfunktion für Dateien

        Aktualisiert alle Dateien in files. files ist ein Dictionary, das
        den Dateinamen (oder die Cachenummer) und die Änderungsart enthält."""
        self.__cache.refresh(filelist)
        for i in filelist:
            self.__handle (i)

    def __refresh_dirs(dirlist):
        """Aktualisierungsfunktion für Verzeichnisse"""
        for i in dirlist["deleted"]:
            del self.__subindexer[i]
        for i in dirlist["created"]:
            options = self.options
            options["root_directory"] = join (self.root_directory, i)
            self.__sub_indexers.append(Indexer(options))
        for i in dirlist["changed"]:
            self.__sub_indexers[i].refresh()

    def __handle(file):
        from mimetypes import guess_type
        type = guess_type(file)[0]
        if type in handler.keys():
            ## Tupel aus Standardelementen und dem Zusatz (ansonsten None)
            self.__storage.replace (file, (mtime, mod, handler[type]))
        else:
            self.__storage.replace (file, (mtime, mod, None))