comparison data/fileio/FileSource.cpp @ 327:1d656dcda8ef

* some tweaks to improve usability of these classes in a console application

 #include <QApplication>
 #include <QProgressDialog>
 #include <QHttpResponseHeader>
 
 #include <iostream>
+
+//#define DEBUG_FILE_SOURCE 1
 
 int
 FileSource::m_count = 0;
 
 QMutex

     m_leaveLocalFile(false),
     m_progressDialog(0),
     m_progressShowTimer(this),
     m_refCounted(false)
 {
+#ifdef DEBUG_FILE_SOURCE
     std::cerr << "FileSource::FileSource(" << fileOrUrl.toStdString() << ")" << std::endl;
+#endif
 
     if (!canHandleScheme(m_url)) {
         std::cerr << "FileSource::FileSource: ERROR: Unsupported scheme in URL \"" << m_url.toString().toStdString() << "\"" << std::endl;
         m_errorString = tr("Unsupported scheme in URL");
         return;

     m_leaveLocalFile(false),
     m_progressDialog(0),
     m_progressShowTimer(this),
     m_refCounted(false)
 {
+#ifdef DEBUG_FILE_SOURCE
     std::cerr << "FileSource::FileSource(" << url.toString().toStdString() << ") [as url]" << std::endl;
+#endif
 
     if (!canHandleScheme(m_url)) {
         std::cerr << "FileSource::FileSource: ERROR: Unsupported scheme in URL \"" << m_url.toString().toStdString() << "\"" << std::endl;
         m_errorString = tr("Unsupported scheme in URL");
         return;

     m_leaveLocalFile(false),
     m_progressDialog(0),
     m_progressShowTimer(0),
     m_refCounted(false)
 {
+#ifdef DEBUG_FILE_SOURCE
     std::cerr << "FileSource::FileSource(" << m_url.toString().toStdString() << ") [copy ctor]" << std::endl;
+#endif
 
     if (!canHandleScheme(m_url)) {
         std::cerr << "FileSource::FileSource: ERROR: Unsupported scheme in URL \"" << m_url.toString().toStdString() << "\"" << std::endl;
         m_errorString = tr("Unsupported scheme in URL");
         return;

 
     if (!isRemote()) {
         m_localFilename = rf.m_localFilename;
     } else {
         QMutexLocker locker(&m_mapMutex);
+#ifdef DEBUG_FILE_SOURCE
         std::cerr << "FileSource::FileSource(copy ctor): ref count is "
                   << m_refCountMap[m_url] << std::endl;
+#endif
         if (m_refCountMap[m_url] > 0) {
             m_refCountMap[m_url]++;
+#ifdef DEBUG_FILE_SOURCE
             std::cerr << "raised it to " << m_refCountMap[m_url] << std::endl;
+#endif
             m_localFilename = m_remoteLocalMap[m_url];
             m_refCounted = true;
         } else {
             m_ok = false;
             m_lastStatus = 404;

     m_done = true;
 }
 
 FileSource::~FileSource()
 {
+#ifdef DEBUG_FILE_SOURCE
     std::cerr << "FileSource(" << m_url.toString().toStdString() << ")::~FileSource" << std::endl;
+#endif
 
     cleanup();
 
     if (isRemote() && !m_leaveLocalFile) deleteCacheFile();
 }

         m_done = true;
         return;
     }
 
     if (createCacheFile()) {
+#ifdef DEBUG_FILE_SOURCE
         std::cerr << "FileSource::init: Already have this one" << std::endl;
+#endif
         m_ok = true;
         if (!QFileInfo(m_localFilename).exists()) {
             m_lastStatus = 404;
         } else {
             m_lastStatus = 200;

     m_localFile = new QFile(m_localFilename);
     m_localFile->open(QFile::WriteOnly);
 
     QString scheme = m_url.scheme().toLower();
 
+#ifdef DEBUG_FILE_SOURCE
     std::cerr << "FileSource::init: Don't have local copy of \""
               << m_url.toString().toStdString() << "\", retrieving" << std::endl;
+#endif
 
     if (scheme == "http") {
         initHttp();
     } else if (scheme == "ftp") {
         initFtp();

         if (m_refCountMap[m_url] > 0) {
             // someone else has been doing the same thing at the same time,
             // but has got there first
             cleanup();
             m_refCountMap[m_url]++;
+#ifdef DEBUG_FILE_SOURCE
             std::cerr << "FileSource::init: Another FileSource has got there first, abandoning our download and using theirs" << std::endl;
+#endif
             m_localFilename = m_remoteLocalMap[m_url];
             m_refCounted = true;
             m_ok = true;
             if (!QFileInfo(m_localFilename).exists()) {
                 m_lastStatus = 404;

     // get the whole URL ready-encoded and then split it on "/" as
     // appropriate...
         
     QString path = "/" + QString(m_url.toEncoded()).section('/', 3);
 
+#ifdef DEBUG_FILE_SOURCE
     std::cerr << "FileSource: path is \""
               << path.toStdString() << "\"" << std::endl;
+#endif
         
     m_http->get(path, m_localFile);
 }
 
 void

 {
     waitForStatus();
     bool available = true;
     if (!m_ok) available = false;
     else available = (m_lastStatus / 100 == 2);
+#ifdef DEBUG_FILE_SOURCE
     std::cerr << "FileSource::isAvailable: " << (available ? "yes" : "no")
               << std::endl;
+#endif
     return available;
 }
 
 void
 FileSource::waitForStatus()

 {
     m_lastStatus = resp.statusCode();
     if (m_lastStatus / 100 >= 4) {
         m_errorString = QString("%1 %2")
             .arg(resp.statusCode()).arg(resp.reasonPhrase());
+#ifdef DEBUG_FILE_SOURCE
         std::cerr << "FileSource::responseHeaderReceived: "
                   << m_errorString.toStdString() << std::endl;
+#endif
     } else {
+#ifdef DEBUG_FILE_SOURCE
         std::cerr << "FileSource::responseHeaderReceived: "
                   << m_lastStatus << std::endl;
+#endif
         if (resp.hasContentType()) m_contentType = resp.contentType();
     }
     emit statusAvailable();
 }
 
 void
 FileSource::ftpCommandFinished(int id, bool error)
 {
+#ifdef DEBUG_FILE_SOURCE
     std::cerr << "FileSource::ftpCommandFinished(" << id << ", " << error << ")" << std::endl;
+#endif
 
     if (!m_ftp) return;
 
     QFtp::Command command = m_ftp->currentCommand();
 
     if (!error) {
+#ifdef DEBUG_FILE_SOURCE
         std::cerr << "FileSource::ftpCommandFinished: success for command "
                   << command << std::endl;
+#endif
         return;
     }
 
     if (command == QFtp::ConnectToHost) {
         m_errorString = tr("Failed to connect to FTP server");

 }
 
 void
 FileSource::dataTransferProgress(qint64 done, qint64 total)
 {
-    if (!m_progressDialog) return;
-
     int percent = int((double(done) / double(total)) * 100.0 - 0.1);
     emit progress(percent);
+
+    if (!m_progressDialog) return;
 
     if (percent > 0) {
         m_progressDialog->setValue(percent);
         m_progressDialog->show();
     }

 }
 
 void
 FileSource::done(bool error)
 {
+    emit progress(100);
+
+#ifdef DEBUG_FILE_SOURCE
     std::cerr << "FileSource::done(" << error << ")" << std::endl;
+#endif
 
     if (m_done) return;
-
-    emit progress(100);
 
     if (error) {
         if (m_http) {
             m_errorString = m_http->errorString();
         } else if (m_ftp) {

             error = true;
         }
     }
 
     if (error) {
+#ifdef DEBUG_FILE_SOURCE
         std::cerr << "FileSource::done: error is " << error << ", deleting cache file" << std::endl;
+#endif
         deleteCacheFile();
     }
 
     m_ok = !error;
     m_done = true;

 }
 
 void
 FileSource::deleteCacheFile()
 {
+#ifdef DEBUG_FILE_SOURCE
     std::cerr << "FileSource::deleteCacheFile(\"" << m_localFilename.toStdString() << "\")" << std::endl;
+#endif
 
     cleanup();
 
     if (m_localFilename == "") {
         return;
     }
 
     if (!isRemote()) {
+#ifdef DEBUG_FILE_SOURCE
         std::cerr << "not a cache file" << std::endl;
+#endif
         return;
     }
 
     if (m_refCounted) {
 
         QMutexLocker locker(&m_mapMutex);
         m_refCounted = false;
 
         if (m_refCountMap[m_url] > 0) {
             m_refCountMap[m_url]--;
+#ifdef DEBUG_FILE_SOURCE
             std::cerr << "reduced ref count to " << m_refCountMap[m_url] << std::endl;
+#endif
             if (m_refCountMap[m_url] > 0) {
                 m_done = true;
                 return;
             }
         }
     }
 
     m_fileCreationMutex.lock();
 
     if (!QFile(m_localFilename).remove()) {
+#ifdef DEBUG_FILE_SOURCE
         std::cerr << "FileSource::deleteCacheFile: ERROR: Failed to delete file \"" << m_localFilename.toStdString() << "\"" << std::endl;
+#endif
     } else {
+#ifdef DEBUG_FILE_SOURCE
         std::cerr << "FileSource::deleteCacheFile: Deleted cache file \"" << m_localFilename.toStdString() << "\"" << std::endl;
+#endif
         m_localFilename = "";
     }
 
     m_fileCreationMutex.unlock();
 

 FileSource::createCacheFile()
 {
     {
         QMutexLocker locker(&m_mapMutex);
 
+#ifdef DEBUG_FILE_SOURCE
         std::cerr << "FileSource::createCacheFile: refcount is " << m_refCountMap[m_url] << std::endl;
+#endif
 
         if (m_refCountMap[m_url] > 0) {
             m_refCountMap[m_url]++;
             m_localFilename = m_remoteLocalMap[m_url];
+#ifdef DEBUG_FILE_SOURCE
             std::cerr << "raised it to " << m_refCountMap[m_url] << std::endl;
+#endif
             m_refCounted = true;
             return true;
         }
     }
 
     QDir dir;
     try {
         dir = TempDirectory::getInstance()->getSubDirectoryPath("download");
     } catch (DirectoryCreationFailed f) {
+#ifdef DEBUG_FILE_SOURCE
         std::cerr << "FileSource::createCacheFile: ERROR: Failed to create temporary directory: " << f.what() << std::endl;
+#endif
         return "";
     }
 
     QString filepart = m_url.path().section('/', -1, -1,
                                             QString::SectionSkipEmpty);

         filename = QString("%1.%2").arg(base).arg(extension);
     }
 
     QString filepath(dir.filePath(filename));
 
+#ifdef DEBUG_FILE_SOURCE
     std::cerr << "FileSource::createCacheFile: URL is \"" << m_url.toString().toStdString() << "\", dir is \"" << dir.path().toStdString() << "\", base \"" << base.toStdString() << "\", extension \"" << extension.toStdString() << "\", filebase \"" << filename.toStdString() << "\", filename \"" << filepath.toStdString() << "\"" << std::endl;
+#endif
 
     QMutexLocker fcLocker(&m_fileCreationMutex);
 
     ++m_count;
 
     if (QFileInfo(filepath).exists() ||
         !QFile(filepath).open(QFile::WriteOnly)) {
 
+#ifdef DEBUG_FILE_SOURCE
         std::cerr << "FileSource::createCacheFile: Failed to create local file \""
                   << filepath.toStdString() << "\" for URL \""
                   << m_url.toString().toStdString() << "\" (or file already exists): appending suffix instead" << std::endl;
-
+#endif
 
         if (extension == "") {
             filename = QString("%1_%2").arg(base).arg(m_count);
         } else {
             filename = QString("%1_%2.%3").arg(base).arg(m_count).arg(extension);

         filepath = dir.filePath(filename);
 
         if (QFileInfo(filepath).exists() ||
             !QFile(filepath).open(QFile::WriteOnly)) {
 
+#ifdef DEBUG_FILE_SOURCE
             std::cerr << "FileSource::createCacheFile: ERROR: Failed to create local file \""
                       << filepath.toStdString() << "\" for URL \""
                       << m_url.toString().toStdString() << "\" (or file already exists)" << std::endl;
+#endif
 
             return "";
         }
     }
 
+#ifdef DEBUG_FILE_SOURCE
     std::cerr << "FileSource::createCacheFile: url "
               << m_url.toString().toStdString() << " -> local filename "
               << filepath.toStdString() << std::endl;
+#endif
     
     m_localFilename = filepath;
 
     return false;
 }
+
+FileSourceProgressPrinter::FileSourceProgressPrinter() :
+    m_lastProgress(0)
+{
+}
+
+FileSourceProgressPrinter::~FileSourceProgressPrinter()
+{
+    if (m_lastProgress > 0 && m_lastProgress != 100) {
+        std::cerr << "\r\n";
+    }
+}
+
+void
+FileSourceProgressPrinter::progress(int progress)
+{
+    if (progress == m_lastProgress) return;
+    if (progress == 100) std::cerr << "\r\n";
+    else std::cerr << "\r" << progress << "%";
+    m_lastProgress = progress;
+}
+