# HG changeset patch # User Chris Cannam # Date 1328896384 0 # Node ID bdc9de7948396f42632e0e2e9e79419ff6e6694c # Parent a4e699d32a9a5c39fabdd58b53a49931517b1b34 Start separate FsWatcher class to manage filesystem watch policy diff -r a4e699d32a9a -r bdc9de794839 easyhg.pro --- a/easyhg.pro Fri Feb 10 13:08:07 2012 +0000 +++ b/easyhg.pro Fri Feb 10 17:53:04 2012 +0000 @@ -64,7 +64,8 @@ src/annotatedialog.h \ src/hgignoredialog.h \ src/versiontester.h \ - src/squeezedlabel.h + src/squeezedlabel.h \ + src/fswatcher.h SOURCES = \ src/main.cpp \ src/mainwindow.cpp \ @@ -101,7 +102,8 @@ src/annotatedialog.cpp \ src/hgignoredialog.cpp \ src/versiontester.cpp \ - src/squeezedlabel.cpp + src/squeezedlabel.cpp \ + src/fswatcher.cpp macx-* { SOURCES += src/common_osx.mm diff -r a4e699d32a9a -r bdc9de794839 src/fswatcher.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/fswatcher.cpp Fri Feb 10 17:53:04 2012 +0000 @@ -0,0 +1,145 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + EasyMercurial + + Based on hgExplorer by Jari Korhonen + Copyright (c) 2010 Jari Korhonen + Copyright (c) 2011 Chris Cannam + Copyright (c) 2011 Queen Mary, University of London + + 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. See the file + COPYING included with this distribution for more information. +*/ + +#include "fswatcher.h" + +#include +#include + +#include + +FsWatcher::FsWatcher() : + m_lastToken(0), + m_lastCounter(0) +{ + connect(&m_watcher, SIGNAL(directoryChanged(QString)), + this, SLOT(fsDirectoryChanged(QString))); + connect(&m_watcher, SIGNAL(fileChanged(QString)), + this, SLOT(fsFileChanged(QString))); +} + +FsWatcher::~FsWatcher() +{ +} + +void +FsWatcher::setWorkDirPath(QString path) +{ + QMutexLocker locker(&m_mutex); + m_watcher.removePaths(m_watcher.directories()); + m_watcher.removePaths(m_watcher.files()); + m_workDirPath = path; + addWorkDirectory(path); +} + +void +FsWatcher::addWorkDirectory(QString path) +{ + // QFileSystemWatcher will refuse to add a file or directory to + // its watch list that it is already watching -- fine -- but it + // prints a warning when this happens, which we wouldn't want. So + // we'll check for duplicates ourselves. + QSet alreadyWatched = + QSet::fromList(m_watcher.directories()); + + std::deque pending; + pending.push_back(path); + + while (!pending.empty()) { + + QString path = pending.front(); + pending.pop_front(); + if (!alreadyWatched.contains(path)) { + m_watcher.addPath(path); + } + + QDir d(path); + if (d.exists()) { + d.setFilter(QDir::Dirs | QDir::NoDotAndDotDot | + QDir::Readable | QDir::NoSymLinks); + foreach (QString entry, d.entryList()) { + if (entry.startsWith('.')) continue; + QString entryPath = d.absoluteFilePath(entry); + pending.push_back(entryPath); + } + } + } +} + +void +FsWatcher::setIgnoredFilePrefixes(QStringList prefixes) +{ + QMutexLocker locker(&m_mutex); + m_ignoredPrefixes = prefixes; +} + +void +FsWatcher::setIgnoredFileSuffixes(QStringList suffixes) +{ + QMutexLocker locker(&m_mutex); + m_ignoredSuffixes = suffixes; +} + +int +FsWatcher::getNewToken() +{ + QMutexLocker locker(&m_mutex); + int token = ++m_lastToken; + m_tokenMap[token] = m_lastCounter; + return token; +} + +QSet +FsWatcher::getChangedPaths(int token) +{ + QMutexLocker locker(&m_mutex); + size_t lastUpdatedAt = m_tokenMap[token]; + QSet changed; + for (QHash::const_iterator i = m_changes.begin(); + i != m_changes.end(); ++i) { + if (i.value() > lastUpdatedAt) { + changed.insert(i.key()); + } + } + m_tokenMap[token] = m_lastCounter; + return changed; +} + +void +FsWatcher::fsDirectoryChanged(QString path) +{ + { + QMutexLocker locker(&m_mutex); + if (shouldIgnore(path)) return; + size_t counter = ++m_lastCounter; + m_changes[path] = counter; + } + emit changed(); +} + +void +FsWatcher::fsFileChanged(QString path) +{ + QMutexLocker locker(&m_mutex); +} + +bool +FsWatcher::shouldIgnore(QString path) +{ + +} + diff -r a4e699d32a9a -r bdc9de794839 src/fswatcher.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/fswatcher.h Fri Feb 10 17:53:04 2012 +0000 @@ -0,0 +1,119 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + EasyMercurial + + Based on HgExplorer by Jari Korhonen + Copyright (c) 2010 Jari Korhonen + Copyright (c) 2011 Chris Cannam + Copyright (c) 2011 Queen Mary, University of London + + 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. See the file + COPYING included with this distribution for more information. +*/ + +#ifndef FSWATCHER_H +#define FSWATCHER_H + +#include +#include +#include +#include +#include +#include +#include +#include + +class FsWatcher : public QObject +{ + Q_OBJECT + +public: + FsWatcher(); + virtual ~FsWatcher(); + + /** + * Set the root path of the work directory to be monitored. + */ + void setWorkDirPath(QString path); + + /** + * Provide a set of prefixes to ignore. Files whose names start + * with a prefix in this set will be ignored when they change. + */ + void setIgnoredFilePrefixes(QStringList prefixes); + + /** + * Provide a set of suffixes to ignore. Files whose names end + * with a suffix in this set will be ignored when they change. + */ + void setIgnoredFileSuffixes(QStringList suffixes); + + /** + * Return a token to identify the current caller in subsequent + * calls to getChangedPaths(). Only changes that occur after this + * has been called can be detected by the caller. + */ + int getNewToken(); + + /** + * Return a list of all non-ignored file paths that have been + * observed to have changed since the last call to getChangedPaths + * with the same token. + */ + QSet getChangedPaths(int token); + +signals: + /** + * Emitted when something has changed. Use the asynchronous + * interface to find out what. + */ + void changed(); + +private slots: + void fsDirectoryChanged(QString); + void fsFileChanged(QString); + +private: + // call with lock already held + void addWorkDirectory(QString path); + + // call with lock already held + bool shouldIgnore(QString path); + +private: + /** + * A change associates a filename with a counter (the + * size_t). Each time a file is changed, its counter is assigned + * from m_lastCounter and m_lastCounter is incremented. + * + * This is not especially efficient -- we often want to find "all + * files whose counter is greater than X" which involves a + * traversal. Maybe something better later. + */ + QHash m_changes; + + /** + * Associates a token (the client identifier) with a counter. The + * counter represents the value of m_lastCounter at the moment + * getChangedPaths last completed for that token. Any files in + * m_changes whose counters are larger must have been modified. + */ + QMap m_tokenMap; + + QStringList m_ignoredPrefixes; + QStringList m_ignoredSuffixes; + + /// Everything in this class is synchronised. + QMutex m_mutex; + + QString m_workDirPath; + int m_lastToken; + size_t m_lastCounter; + QFileSystemWatcher m_watcher; +}; + +#endif