Whitespace: {curl_,scp_,}uploader.{cc,h}

diff --git a/src/lib/curl_uploader.cc b/src/lib/curl_uploader.cc
index 389a5d6de50b45859401feb829713f6e793a6ccd..753c664969c97981242f6d60731a8842380edd5d 100644 (file)
--- a/src/lib/curl_uploader.cc
+++ b/src/lib/curl_uploader.cc
@@ -37,35 +37,35 @@ using std::function;
 
 
 static size_t
-read_callback (void* ptr, size_t size, size_t nmemb, void* object)
+read_callback(void* ptr, size_t size, size_t nmemb, void* object)
 {
-       CurlUploader* u = reinterpret_cast<CurlUploader*> (object);
-       return u->read_callback (ptr, size, nmemb);
+       CurlUploader* u = reinterpret_cast<CurlUploader*>(object);
+       return u->read_callback(ptr, size, nmemb);
 }
 
 
 static int
-curl_debug_shim (CURL* curl, curl_infotype type, char* data, size_t size, void* userp)
+curl_debug_shim(CURL* curl, curl_infotype type, char* data, size_t size, void* userp)
 {
        return reinterpret_cast<CurlUploader*>(userp)->debug(curl, type, data, size);
 }
 
 
-CurlUploader::CurlUploader (function<void (string)> set_status, function<void (float)> set_progress)
-       : Uploader (set_status, set_progress)
+CurlUploader::CurlUploader(function<void (string)> set_status, function<void (float)> set_progress)
+       : Uploader(set_status, set_progress)
 {
-       _curl = curl_easy_init ();
+       _curl = curl_easy_init();
        if (!_curl) {
-               throw NetworkError (_("Could not start transfer"));
+               throw NetworkError(_("Could not start transfer"));
        }
 
-       curl_easy_setopt (_curl, CURLOPT_READFUNCTION, ::read_callback);
-       curl_easy_setopt (_curl, CURLOPT_READDATA, this);
-       curl_easy_setopt (_curl, CURLOPT_UPLOAD, 1L);
-       curl_easy_setopt (_curl, CURLOPT_FTP_CREATE_MISSING_DIRS, 1L);
-       curl_easy_setopt (_curl, CURLOPT_READDATA, this);
-       curl_easy_setopt (_curl, CURLOPT_USERNAME, Config::instance()->tms_user().c_str());
-       curl_easy_setopt (_curl, CURLOPT_PASSWORD, Config::instance()->tms_password().c_str());
+       curl_easy_setopt(_curl, CURLOPT_READFUNCTION, ::read_callback);
+       curl_easy_setopt(_curl, CURLOPT_READDATA, this);
+       curl_easy_setopt(_curl, CURLOPT_UPLOAD, 1L);
+       curl_easy_setopt(_curl, CURLOPT_FTP_CREATE_MISSING_DIRS, 1L);
+       curl_easy_setopt(_curl, CURLOPT_READDATA, this);
+       curl_easy_setopt(_curl, CURLOPT_USERNAME, Config::instance()->tms_user().c_str());
+       curl_easy_setopt(_curl, CURLOPT_PASSWORD, Config::instance()->tms_password().c_str());
        if (!Config::instance()->tms_passive()) {
                curl_easy_setopt(_curl, CURLOPT_FTPPORT, "-");
        }
@@ -75,39 +75,39 @@ CurlUploader::CurlUploader (function<void (string)> set_status, function<void (f
 }
 
 
-CurlUploader::~CurlUploader ()
+CurlUploader::~CurlUploader()
 {
-       curl_easy_cleanup (_curl);
+       curl_easy_cleanup(_curl);
 }
 
 
 void
-CurlUploader::create_directory (boost::filesystem::path)
+CurlUploader::create_directory(boost::filesystem::path)
 {
        /* this is done by libcurl */
 }
 
 
 void
-CurlUploader::upload_file (boost::filesystem::path from, boost::filesystem::path to, boost::uintmax_t& transferred, boost::uintmax_t total_size)
+CurlUploader::upload_file(boost::filesystem::path from, boost::filesystem::path to, boost::uintmax_t& transferred, boost::uintmax_t total_size)
 {
-       curl_easy_setopt (
+       curl_easy_setopt(
                _curl, CURLOPT_URL,
                /* Use generic_string so that we get forward-slashes in the path, even on Windows */
-               String::compose ("ftp://%1/%2/%3", Config::instance()->tms_ip(), Config::instance()->tms_path(), to.generic_string ()).c_str ()
+               String::compose("ftp://%1/%2/%3", Config::instance()->tms_ip(), Config::instance()->tms_path(), to.generic_string()).c_str()
                );
 
        dcp::File file(from, "rb");
        if (!file) {
-               throw NetworkError (String::compose (_("Could not open %1 to send"), from));
+               throw NetworkError(String::compose(_("Could not open %1 to send"), from));
        }
        _file = file.get();
        _transferred = &transferred;
        _total_size = total_size;
 
-       auto const r = curl_easy_perform (_curl);
+       auto const r = curl_easy_perform(_curl);
        if (r != CURLE_OK) {
-               throw NetworkError (String::compose (_("Could not write to remote file (%1)"), curl_easy_strerror (r)));
+               throw NetworkError(String::compose(_("Could not write to remote file (%1)"), curl_easy_strerror(r)));
        }
 
        _file = nullptr;
@@ -115,14 +115,14 @@ CurlUploader::upload_file (boost::filesystem::path from, boost::filesystem::path
 
 
 size_t
-CurlUploader::read_callback (void* ptr, size_t size, size_t nmemb)
+CurlUploader::read_callback(void* ptr, size_t size, size_t nmemb)
 {
-       DCPOMATIC_ASSERT (_file);
+       DCPOMATIC_ASSERT(_file);
        size_t const r = fread(ptr, size, nmemb, _file);
        *_transferred += size * nmemb;
 
        if (_total_size > 0) {
-               _set_progress ((double) *_transferred / _total_size);
+               _set_progress((double) *_transferred / _total_size);
        }
 
        return r;

diff --git a/src/lib/curl_uploader.h b/src/lib/curl_uploader.h
index 4ee221f089dd1093b59062c501799603bb93e0f0..0634d564f2bd3959747f5e5181e143e7e6ec450b 100644 (file)
--- a/src/lib/curl_uploader.h
+++ b/src/lib/curl_uploader.h
@@ -27,15 +27,15 @@
 class CurlUploader : public Uploader
 {
 public:
-       CurlUploader (std::function<void (std::string)> set_status, std::function<void (float)> set_progress);
-       ~CurlUploader ();
+       CurlUploader(std::function<void (std::string)> set_status, std::function<void (float)> set_progress);
+       ~CurlUploader();
 
-       size_t read_callback (void* ptr, size_t size, size_t nmemb);
+       size_t read_callback(void* ptr, size_t size, size_t nmemb);
        int debug(CURL* curl, curl_infotype type, char* data, size_t size);
 
 protected:
-       void create_directory (boost::filesystem::path directory) override;
-       void upload_file (boost::filesystem::path from, boost::filesystem::path to, boost::uintmax_t& transferred, boost::uintmax_t total_size) override;
+       void create_directory(boost::filesystem::path directory) override;
+       void upload_file(boost::filesystem::path from, boost::filesystem::path to, boost::uintmax_t& transferred, boost::uintmax_t total_size) override;
 
 private:
        CURL* _curl;

diff --git a/src/lib/scp_uploader.cc b/src/lib/scp_uploader.cc
index 6c63a6c3e881ac698c925a79b93a9cfe3d2bf999..78ab1e7a4a41002fe63f6e5e15c7aab0410ddea1 100644 (file)
--- a/src/lib/scp_uploader.cc
+++ b/src/lib/scp_uploader.cc
@@ -39,110 +39,110 @@ using std::shared_ptr;
 using std::string;
 
 
-SCPUploader::SCPUploader (function<void (string)> set_status, function<void (float)> set_progress)
-       : Uploader (set_status, set_progress)
+SCPUploader::SCPUploader(function<void (string)> set_status, function<void (float)> set_progress)
+       : Uploader(set_status, set_progress)
 {
-       _session = ssh_new ();
+       _session = ssh_new();
        if (!_session) {
-               throw NetworkError (String::compose(_("SSH error [%1]"), "ssh_new"));
+               throw NetworkError(String::compose(_("SSH error [%1]"), "ssh_new"));
        }
 
-       ssh_options_set (_session, SSH_OPTIONS_HOST, Config::instance()->tms_ip().c_str());
-       ssh_options_set (_session, SSH_OPTIONS_USER, Config::instance()->tms_user().c_str());
+       ssh_options_set(_session, SSH_OPTIONS_HOST, Config::instance()->tms_ip().c_str());
+       ssh_options_set(_session, SSH_OPTIONS_USER, Config::instance()->tms_user().c_str());
        int const port = 22;
-       ssh_options_set (_session, SSH_OPTIONS_PORT, &port);
+       ssh_options_set(_session, SSH_OPTIONS_PORT, &port);
 
-       int r = ssh_connect (_session);
+       int r = ssh_connect(_session);
        if (r != SSH_OK) {
-               throw NetworkError (String::compose(_("Could not connect to server %1 (%2)"), Config::instance()->tms_ip(), ssh_get_error(_session)));
+               throw NetworkError(String::compose(_("Could not connect to server %1 (%2)"), Config::instance()->tms_ip(), ssh_get_error(_session)));
        }
 
 LIBDCP_DISABLE_WARNINGS
-       r = ssh_is_server_known (_session);
+       r = ssh_is_server_known(_session);
        if (r == SSH_SERVER_ERROR) {
-               throw NetworkError (String::compose(_("SSH error [%1] (%2)"), "ssh_is_server_known", ssh_get_error(_session)));
+               throw NetworkError(String::compose(_("SSH error [%1] (%2)"), "ssh_is_server_known", ssh_get_error(_session)));
        }
 LIBDCP_ENABLE_WARNINGS
 
-       r = ssh_userauth_password (_session, 0, Config::instance()->tms_password().c_str ());
+       r = ssh_userauth_password(_session, 0, Config::instance()->tms_password().c_str());
        if (r != SSH_AUTH_SUCCESS) {
-               throw NetworkError (String::compose(_("Failed to authenticate with server (%1)"), ssh_get_error(_session)));
+               throw NetworkError(String::compose(_("Failed to authenticate with server (%1)"), ssh_get_error(_session)));
        }
 
 LIBDCP_DISABLE_WARNINGS
-       _scp = ssh_scp_new (_session, SSH_SCP_WRITE | SSH_SCP_RECURSIVE, Config::instance()->tms_path().c_str());
+       _scp = ssh_scp_new(_session, SSH_SCP_WRITE | SSH_SCP_RECURSIVE, Config::instance()->tms_path().c_str());
 LIBDCP_ENABLE_WARNINGS
        if (!_scp) {
-               throw NetworkError (String::compose(_("SSH error [%1] (%2)"), "ssh_scp_new", ssh_get_error(_session)));
+               throw NetworkError(String::compose(_("SSH error [%1] (%2)"), "ssh_scp_new", ssh_get_error(_session)));
        }
 
 LIBDCP_DISABLE_WARNINGS
-       r = ssh_scp_init (_scp);
+       r = ssh_scp_init(_scp);
 LIBDCP_ENABLE_WARNINGS
        if (r != SSH_OK) {
-               throw NetworkError (String::compose(_("SSH error [%1] (%2)"), "ssh_scp_init", ssh_get_error(_session)));
+               throw NetworkError(String::compose(_("SSH error [%1] (%2)"), "ssh_scp_init", ssh_get_error(_session)));
        }
 }
 
 
-SCPUploader::~SCPUploader ()
+SCPUploader::~SCPUploader()
 {
 LIBDCP_DISABLE_WARNINGS
-       ssh_scp_free (_scp);
+       ssh_scp_free(_scp);
 LIBDCP_ENABLE_WARNINGS
-       ssh_disconnect (_session);
-       ssh_free (_session);
+       ssh_disconnect(_session);
+       ssh_free(_session);
 }
 
 
 void
-SCPUploader::create_directory (boost::filesystem::path directory)
+SCPUploader::create_directory(boost::filesystem::path directory)
 {
        /* Use generic_string so that we get forward-slashes in the path, even on Windows */
 LIBDCP_DISABLE_WARNINGS
-       int const r = ssh_scp_push_directory (_scp, directory.generic_string().c_str(), S_IRWXU);
+       int const r = ssh_scp_push_directory(_scp, directory.generic_string().c_str(), S_IRWXU);
 LIBDCP_ENABLE_WARNINGS
        if (r != SSH_OK) {
-               throw NetworkError (String::compose(_("Could not create remote directory %1 (%2)"), directory, ssh_get_error(_session)));
+               throw NetworkError(String::compose(_("Could not create remote directory %1 (%2)"), directory, ssh_get_error(_session)));
        }
 }
 
 
 void
-SCPUploader::upload_file (boost::filesystem::path from, boost::filesystem::path to, boost::uintmax_t& transferred, boost::uintmax_t total_size)
+SCPUploader::upload_file(boost::filesystem::path from, boost::filesystem::path to, boost::uintmax_t& transferred, boost::uintmax_t total_size)
 {
        auto to_do = dcp::filesystem::file_size(from);
        /* Use generic_string so that we get forward-slashes in the path, even on Windows */
 LIBDCP_DISABLE_WARNINGS
-       ssh_scp_push_file (_scp, to.generic_string().c_str(), to_do, S_IRUSR | S_IWUSR);
+       ssh_scp_push_file(_scp, to.generic_string().c_str(), to_do, S_IRUSR | S_IWUSR);
 LIBDCP_ENABLE_WARNINGS
 
        dcp::File f(from, "rb");
        if (!f) {
-               throw NetworkError (String::compose(_("Could not open %1 to send"), from));
+               throw NetworkError(String::compose(_("Could not open %1 to send"), from));
        }
 
        boost::uintmax_t buffer_size = 64 * 1024;
        char buffer[buffer_size];
 
        while (to_do > 0) {
-               int const t = min (to_do, buffer_size);
+               int const t = min(to_do, buffer_size);
                size_t const read = f.read(buffer, 1, t);
-               if (read != size_t (t)) {
-                       throw ReadFileError (from);
+               if (read != size_t(t)) {
+                       throw ReadFileError(from);
                }
 
 LIBDCP_DISABLE_WARNINGS
-               int const r = ssh_scp_write (_scp, buffer, t);
+               int const r = ssh_scp_write(_scp, buffer, t);
 LIBDCP_ENABLE_WARNINGS
                if (r != SSH_OK) {
-                       throw NetworkError (String::compose(_("Could not write to remote file (%1)"), ssh_get_error(_session)));
+                       throw NetworkError(String::compose(_("Could not write to remote file (%1)"), ssh_get_error(_session)));
                }
                to_do -= t;
                transferred += t;
 
                if (total_size > 0) {
-                       _set_progress ((double) transferred / total_size);
+                       _set_progress((double) transferred / total_size);
                }
        }
 }

diff --git a/src/lib/scp_uploader.h b/src/lib/scp_uploader.h
index bc71a0674bb1ad504ff90d6c00a0c9b8bdba74d1..bae175ea850ad8c8fff4b1ff75ead361f40c7c8a 100644 (file)
--- a/src/lib/scp_uploader.h
+++ b/src/lib/scp_uploader.h
@@ -29,12 +29,12 @@ LIBDCP_ENABLE_WARNINGS
 class SCPUploader : public Uploader
 {
 public:
-       SCPUploader (std::function<void (std::string)> set_status, std::function<void (float)> set_progress);
-       ~SCPUploader ();
+       SCPUploader(std::function<void (std::string)> set_status, std::function<void (float)> set_progress);
+       ~SCPUploader();
 
 protected:
-       virtual void create_directory (boost::filesystem::path directory) override;
-       virtual void upload_file (boost::filesystem::path from, boost::filesystem::path to, boost::uintmax_t& transferred, boost::uintmax_t total_size) override;
+       virtual void create_directory(boost::filesystem::path directory) override;
+       virtual void upload_file(boost::filesystem::path from, boost::filesystem::path to, boost::uintmax_t& transferred, boost::uintmax_t total_size) override;
 
 private:
        ssh_session _session;

diff --git a/src/lib/uploader.h b/src/lib/uploader.h
index a68be8dd0b59169666f2e78851d9f481187decdf..440746344bcdadf26d98d376ed1d61e239c1d0e6 100644 (file)
--- a/src/lib/uploader.h
+++ b/src/lib/uploader.h
@@ -32,15 +32,15 @@ class Job;
 class Uploader
 {
 public:
-       Uploader (std::function<void (std::string)> set_status, std::function<void (float)> set_progress);
-       virtual ~Uploader () {}
+       Uploader(std::function<void (std::string)> set_status, std::function<void (float)> set_progress);
+       virtual ~Uploader() {}
 
-       void upload (boost::filesystem::path directory);
+       void upload(boost::filesystem::path directory);
 
 protected:
 
-       virtual void create_directory (boost::filesystem::path directory) = 0;
-       virtual void upload_file (boost::filesystem::path from, boost::filesystem::path to, boost::uintmax_t& transferred, boost::uintmax_t total_size) = 0;
+       virtual void create_directory(boost::filesystem::path directory) = 0;
+       virtual void upload_file(boost::filesystem::path from, boost::filesystem::path to, boost::uintmax_t& transferred, boost::uintmax_t total_size) = 0;
 
        std::function<void (float)> _set_progress;