#
#
# patch "src/monotone/MonotoneThread.cpp"
#  from [13c307568e9ebe5d05cd5ce6e814f97997bcfa80]
#    to [addea202657bdd3faaa5ccc4abe2e84ee3192a22]
# 
# patch "src/monotone/MonotoneThread.h"
#  from [6ffa825b951bffca47575c53e9d80887331f9c98]
#    to [65915d3a31aa408b5f44edb31609aa464d30ddb8]
# 
# patch "src/monotone/MonotoneUtil.cpp"
#  from [2b552c60706be45c06cf70b46a050f05dd203669]
#    to [1188fc19d37193d33b87bd73c82b9e5c6bd57f22]
# 
# patch "src/monotone/MonotoneUtil.h"
#  from [16514e4a0acd2bd9d75d734cc962cad161484d23]
#    to [a30ed6b32d5ef898ab5ab70137d1e2a5e80d5034]
# 
# patch "src/vocab.h"
#  from [f36bfd022e6881d00b22aba10678ce6b08300c14]
#    to [23470ec5ecce5d6432e5959e745e79e76084a75c]
#
============================================================
--- src/monotone/MonotoneThread.cpp	13c307568e9ebe5d05cd5ce6e814f97997bcfa80
+++ src/monotone/MonotoneThread.cpp	addea202657bdd3faaa5ccc4abe2e84ee3192a22
@@ -278,19 +278,19 @@ void MonotoneThread::abort()
 
 // FIXME: I think we need to care somehow if we pass
 // threads around - i.e. use shared ptrs or something
-MonotoneThread * MonotoneThreadManager::getThreadForWorkspace(const QString & workspace)
+MonotoneThread * MonotoneThreadManager::getThreadForWorkspace(const WorkspacePath & workspace)
 {
-    QString normalizedWorkspace = normalizeWorkspacePath(workspace);
-    QString databaseFile = getDatabaseFilePath(normalizedWorkspace);
+    WorkspacePath normalizedWorkspace = normalizeWorkspacePath(workspace);
+    DatabaseFile databaseFile = getDatabaseFilePath(normalizedWorkspace);
     return getThread(databaseFile, workspace);
 }
 
-MonotoneThread * MonotoneThreadManager::getThreadForDatabase(const QString & database)
+MonotoneThread * MonotoneThreadManager::getThreadForDatabase(const DatabaseFile & database)
 {
     return getThread(database, QString());
 }
 
-MonotoneThread * MonotoneThreadManager::getThread(const QString & database, const QString & workspace)
+MonotoneThread * MonotoneThreadManager::getThread(const DatabaseFile & database, const WorkspacePath & workspace)
 {
     // FIXME: since we cannot set the workspace directory after we've
     // started the process, we need to ensure that each workspace runs with
@@ -319,7 +319,7 @@ MonotoneThread * MonotoneThreadManager::
     return thread;
 }
 
-QString MonotoneThreadManager::normalizeWorkspacePath(const QString & workspace)
+WorkspacePath MonotoneThreadManager::normalizeWorkspacePath(const WorkspacePath & workspace)
 {
     QDir tempDir(workspace);
     if (!tempDir.exists())
@@ -328,7 +328,7 @@ QString MonotoneThreadManager::normalize
     }
 
     bool found = false;
-    QString normalizedWorkspace;
+    WorkspacePath normalizedWorkspace;
     do
     {
         if (tempDir.cd("_MTN"))
@@ -350,7 +350,7 @@ QString MonotoneThreadManager::normalize
 }
 
 // we assume that the workspace was already normalized here
-QString MonotoneThreadManager::getDatabaseFilePath(const QString & workspace)
+DatabaseFile MonotoneThreadManager::getDatabaseFilePath(const WorkspacePath & workspace)
 {
     // now check again if we know it
     if (workspaceMap.contains(workspace))
@@ -381,7 +381,7 @@ QString MonotoneThreadManager::getDataba
     I(stanzas.size() == 1);
     Stanza st = stanzas.at(0);
 
-    QString databaseFilePath;
+    DatabaseFile databaseFilePath;
     foreach (StanzaEntry entry, st)
     {
         if (entry.sym == "database")
============================================================
--- src/monotone/MonotoneThread.h	6ffa825b951bffca47575c53e9d80887331f9c98
+++ src/monotone/MonotoneThread.h	65915d3a31aa408b5f44edb31609aa464d30ddb8
@@ -119,16 +119,16 @@ public:
 
     inline void setMtnBinaryPath(const QString & path) { mtnPath = path; }
 
-    MonotoneThread * getThreadForWorkspace(const QString &);
-    MonotoneThread * getThreadForDatabase(const QString &);
-    MonotoneThread * getThread(const QString &, const QString &);
+    MonotoneThread * getThreadForWorkspace(const WorkspacePath &);
+    MonotoneThread * getThreadForDatabase(const DatabaseFile &);
+    MonotoneThread * getThread(const DatabaseFile &, const WorkspacePath &);
 
 private:
-    QString getDatabaseFilePath(const QString &);
-    QString normalizeWorkspacePath(const QString &);
+    DatabaseFile getDatabaseFilePath(const WorkspacePath &);
+    WorkspacePath normalizeWorkspacePath(const WorkspacePath &);
 
     QMap<QString, MonotoneThread *> threadMap;
-    QMap<QString, QString> workspaceMap;
+    QMap<WorkspacePath, DatabaseFile> workspaceMap;
     QString mtnPath;
     int threadNumber;
 
============================================================
--- src/monotone/MonotoneUtil.cpp	2b552c60706be45c06cf70b46a050f05dd203669
+++ src/monotone/MonotoneUtil.cpp	1188fc19d37193d33b87bd73c82b9e5c6bd57f22
@@ -167,19 +167,28 @@ int MonotoneUtil::versionCompare(const Q
     return 0;
 }
 
-MonotoneTask MonotoneUtil::runSynchronousTask(const QString & db, const MonotoneTask & task)
+MonotoneTask MonotoneUtil::runSynchronousWorkspaceTask(const WorkspacePath & workspace, const MonotoneTask & task)
 {
-    MonotoneThread * thread = APP->manager()->getThread(db);
+    MonotoneThread * thread = APP->manager()->getThreadForWorkspace(workspace);
     MonotoneUtil * instance = new MonotoneUtil(thread, task);
     MonotoneTask result = instance->getTaskResult();
     delete instance;
     return result;
 }
 
-QString MonotoneUtil::getBaseWorkspaceRevision(const QString & db)
+MonotoneTask MonotoneUtil::runSynchronousDatabaseTask(const DatabaseFile & database, const MonotoneTask & task)
 {
+    MonotoneThread * thread = APP->manager()->getThreadForDatabase(database);
+    MonotoneUtil * instance = new MonotoneUtil(thread, task);
+    MonotoneTask result = instance->getTaskResult();
+    delete instance;
+    return result;
+}
+
+QString MonotoneUtil::getBaseWorkspaceRevision(const WorkspacePath & workspace)
+{
     MonotoneTask in(QStringList() << "get_base_revision_id");
-    MonotoneTask out = runSynchronousTask(db, in);
+    MonotoneTask out = runSynchronousWorkspaceTask(workspace, in);
     if (!out.isFinished()) F("task aborted");
 
     QString data = out.getOutputUtf8();
@@ -197,10 +206,10 @@ QString MonotoneUtil::getBaseWorkspaceRe
     return data;
 }
 
-QString MonotoneUtil::getOption(const QString & db, const QString & opt)
+QString MonotoneUtil::getOption(const WorkspacePath & workspace, const QString & opt)
 {
     MonotoneTask in(QStringList() << "get_option" << opt);
-    MonotoneTask out = runSynchronousTask(db, in);
+    MonotoneTask out = runSynchronousWorkspaceTask(workspace, in);
     if (!out.isFinished()) F("task aborted");
 
     QString data = out.getOutputUtf8();
@@ -216,9 +225,9 @@ QString MonotoneUtil::getOption(const QS
     return data;
 }
 
-QString MonotoneUtil::getBranchName(const QString & db, const QString & defaultBranch)
+QString MonotoneUtil::getBranchName(const WorkspacePath & workspace, const QString & defaultBranch)
 {
-    QString branchName = getOption(db, "branch");
+    QString branchName = getOption(workspace, "branch");
 
     if (branchName.size() == 0)
     {
@@ -227,11 +236,11 @@ QString MonotoneUtil::getBranchName(cons
     return branchName;
 }
 
-QString MonotoneUtil::getBranchNameShort(const QString & db)
+QString MonotoneUtil::getBranchNameShort(const WorkspacePath & workspace)
 {
     // FIXME: currently there is only support for the domain branch scheme
     // tld.domain.project.branch
-    QString branchName = getBranchName(db);
+    QString branchName = getBranchName(workspace);
     QStringList parts = branchName.split('.');
     if (parts.size() == 1) return branchName;
 
@@ -258,10 +267,10 @@ QString MonotoneUtil::getBranchNameShort
     return shortBranchName;
 }
 
-QStringList MonotoneUtil::resolveSelector(const QString & db, const QString & selector)
+QStringList MonotoneUtil::resolveSelector(const DatabaseFile & db, const QString & selector)
 {
     MonotoneTask in(QStringList() << "select" << selector);
-    MonotoneTask out = runSynchronousTask(db, in);
+    MonotoneTask out = runSynchronousDatabaseTask(db, in);
     if (!out.isFinished()) F("task aborted");
 
     QString data = out.getOutputUtf8();
@@ -275,10 +284,10 @@ QStringList MonotoneUtil::resolveSelecto
     return revList;
 }
 
-RevisionCerts MonotoneUtil::getRevisionCerts(const QString & db, const QString & revision)
+RevisionCerts MonotoneUtil::getRevisionCerts(const DatabaseFile & db, const QString & revision)
 {
     MonotoneTask in(QStringList() << "certs" << revision);
-    MonotoneTask out = runSynchronousTask(db, in);
+    MonotoneTask out = runSynchronousDatabaseTask(db, in);
     if (!out.isFinished()) F("task aborted");
 
     QString data = out.getOutputUtf8();
@@ -320,14 +329,10 @@ RevisionCerts MonotoneUtil::getRevisionC
     return certs;
 }
 
-FileEntryList MonotoneUtil::getRevisionManifest(const QString & db, const QString & revision)
+FileEntryList MonotoneUtil::getRevisionManifest(const DatabaseFile & db, const QString & revision)
 {
-    QStringList cmd = QStringList()  << "get_manifest_of";
-    if (!revision.isEmpty())
-        cmd << revision;
-
-    MonotoneTask in(cmd);
-    MonotoneTask out = runSynchronousTask(db, in);
+    MonotoneTask in(QStringList() << "get_manifest_of" << revision);
+    MonotoneTask out = runSynchronousDatabaseTask(db, in);
     if (!out.isFinished()) F("task aborted");
 
     QString data = out.getOutputUtf8();
@@ -387,10 +392,10 @@ FileEntryList MonotoneUtil::getRevisionM
     return entries;
 }
 
-QStringList MonotoneUtil::getPrivateKeyList(const QString & db)
+QStringList MonotoneUtil::getPrivateKeyList(const DatabaseFile & db)
 {
     MonotoneTask in(QStringList() << "keys");
-    MonotoneTask out = runSynchronousTask(db, in);
+    MonotoneTask out = runSynchronousDatabaseTask(db, in);
     if (!out.isFinished()) F("task aborted");
 
     QString data = out.getOutputUtf8();
@@ -431,10 +436,10 @@ QStringList MonotoneUtil::getPrivateKeyL
     return keys;
 }
 
-QString MonotoneUtil::getFileId(const QString & db, const QString & path)
+QString MonotoneUtil::getFileId(const DatabaseFile & db, const QString & path)
 {
     MonotoneTask in(QStringList() << "identify" << path);
-    MonotoneTask out = runSynchronousTask(db, in);
+    MonotoneTask out = runSynchronousDatabaseTask(db, in);
     if (!out.isFinished()) F("task aborted");
 
     QString data = out.getOutputUtf8();
============================================================
--- src/monotone/MonotoneUtil.h	16514e4a0acd2bd9d75d734cc962cad161484d23
+++ src/monotone/MonotoneUtil.h	a30ed6b32d5ef898ab5ab70137d1e2a5e80d5034
@@ -41,16 +41,17 @@ public:
     static const QString MaxInterfaceVersion;
 
     // synchronous commands
-    static MonotoneTask runSynchronousTask(const QString &, const MonotoneTask &);
-    static QString getBaseWorkspaceRevision(const QString &);
-    static QString getOption(const QString &, const QString &);
-    static QString getBranchName(const QString &, const QString & defaultBranch = tr("[unknown branch]"));
-    static QString getBranchNameShort(const QString &);
-    static QStringList resolveSelector(const QString &, const QString &);
-    static RevisionCerts getRevisionCerts(const QString &, const QString &);
-    static FileEntryList getRevisionManifest(const QString &, const QString & rev = QString());
-    static QStringList getPrivateKeyList(const QString &);
-    static QString getFileId(const QString &, const QString &);
+    static MonotoneTask runSynchronousWorkspaceTask(const WorkspacePath &, const MonotoneTask &);
+    static MonotoneTask runSynchronousDatabaseTask(const DatabaseFile &, const MonotoneTask &);
+    static QString getBaseWorkspaceRevision(const WorkspacePath &);
+    static QString getOption(const WorkspacePath &, const QString &);
+    static QString getBranchName(const WorkspacePath &, const QString & defaultBranch = tr("[unknown branch]"));
+    static QString getBranchNameShort(const WorkspacePath &);
+    static QStringList resolveSelector(const DatabaseFile &, const QString &);
+    static RevisionCerts getRevisionCerts(const DatabaseFile &, const QString &);
+    static FileEntryList getRevisionManifest(const DatabaseFile &, const QString &);
+    static QStringList getPrivateKeyList(const DatabaseFile &);
+    static QString getFileId(const DatabaseFile &, const QString &);
 
 private:
     MonotoneUtil(MonotoneThread *, const MonotoneTask &);
============================================================
--- src/vocab.h	f36bfd022e6881d00b22aba10678ce6b08300c14
+++ src/vocab.h	23470ec5ecce5d6432e5959e745e79e76084a75c
@@ -50,7 +50,7 @@ struct FileEntry {
     bool is_dir;
     QString fileid;
     QMap<QString, QString> attrs;
-    
+
     inline bool operator<(const FileEntry & other) const
     {
         return path < other.path;
@@ -82,7 +82,7 @@ struct StanzaEntry {
     StanzaEntry() {}
     StanzaEntry(QString s, QString h) : sym(s), hash(h) {}
     StanzaEntry(QString s, QStringList v) : sym(s), vals(v) {}
-    
+
     QString sym;
     QString hash;
     QStringList vals;
@@ -93,4 +93,8 @@ typedef QString GuitoneException;
 
 typedef QString GuitoneException;
 
+// TODO: maybe we can load workspace normalization into this
+typedef QString WorkspacePath;
+typedef QString DatabaseFile;
+
 #endif