Cleanup: use some more vector instead of list.

[dcpomatic.git] / src / lib / job.cc

diff --git a/src/lib/job.cc b/src/lib/job.cc
index 1c7fe5a83ff5d333eafa62141fce4ec3c00e059e..811e4c983672f27fb4a996280aacb86d3916ada9 100644 (file)
--- a/src/lib/job.cc
+++ b/src/lib/job.cc
@@ -25,6 +25,7 @@
 
 
 #include "compose.hpp"
+#include "constants.h"
 #include "cross.h"
 #include "dcpomatic_log.h"
 #include "exceptions.h"
@@ -37,6 +38,7 @@
 #include <boost/date_time/posix_time/posix_time.hpp>
 #include <boost/filesystem.hpp>
 #include <boost/thread.hpp>
+#include <time.h>
 #include <iostream>
 
 #include "i18n.h"
@@ -55,10 +57,8 @@ using namespace dcpomatic;
 Job::Job (shared_ptr<const Film> film)
        : _film (film)
        , _state (NEW)
-       , _start_time (0)
        , _sub_start_time (0)
        , _progress (0)
-       , _ran_for (0)
 {
 
 }
@@ -235,6 +235,12 @@ Job::run_wrapper ()
                set_progress (1);
                set_state (FINISHED_ERROR);
 
+       } catch (CPLNotFoundError& e) {
+
+               set_error(e.what());
+               set_progress(1);
+               set_state(FINISHED_ERROR);
+
        } catch (std::exception& e) {
 
                set_error (
@@ -337,22 +343,45 @@ Job::set_state (State s)
 
        {
                boost::mutex::scoped_lock lm (_state_mutex);
+               if (_state == s) {
+                       return;
+               }
+
                _state = s;
 
                if (_state == FINISHED_OK || _state == FINISHED_ERROR || _state == FINISHED_CANCELLED) {
-                       _ran_for = time(0) - _start_time;
+                       _finish_time = time(nullptr);
                        finished = true;
                        _sub_name.clear ();
                }
        }
 
        if (finished) {
-               emit (boost::bind (boost::ref (Finished)));
-               FinishedImmediate ();
+               auto const result = state_to_result(s);
+               emit(boost::bind(boost::ref(Finished), result));
+               FinishedImmediate(result);
        }
 }
 
 
+Job::Result
+Job::state_to_result(State state) const
+{
+       switch (state) {
+       case FINISHED_OK:
+               return Result::RESULT_OK;
+       case FINISHED_ERROR:
+               return Result::RESULT_ERROR;
+       case FINISHED_CANCELLED:
+               return Result::RESULT_CANCELLED;
+       default:
+               DCPOMATIC_ASSERT(false);
+       };
+
+       DCPOMATIC_ASSERT(false);
+}
+
+
 /** @return DCPTime (in seconds) that this sub-job has been running */
 int
 Job::elapsed_sub_time () const
@@ -507,6 +536,27 @@ Job::status () const
        int const t = elapsed_sub_time ();
        int const r = remaining_time ();
 
+       auto day_of_week_to_string = [](boost::gregorian::greg_weekday d) -> std::string {
+               switch (d.as_enum()) {
+               case boost::date_time::Sunday:
+                       return _("Sunday");
+               case boost::date_time::Monday:
+                       return _("Monday");
+               case boost::date_time::Tuesday:
+                       return _("Tuesday");
+               case boost::date_time::Wednesday:
+                       return _("Wednesday");
+               case boost::date_time::Thursday:
+                       return _("Thursday");
+               case boost::date_time::Friday:
+                       return _("Friday");
+               case boost::date_time::Saturday:
+                       return _("Saturday");
+               }
+
+               return d.as_long_string();
+       };
+
        string s;
        if (!finished () && p) {
                int pc = lrintf (p.get() * 100);
@@ -538,7 +588,22 @@ Job::status () const
                                );
                }
        } else if (finished_ok ()) {
-               s = String::compose (_("OK (ran for %1)"), seconds_to_hms (_ran_for));
+               auto time_string = [](time_t time) {
+                       auto tm = localtime(&time);
+                       char buffer[8];
+                       snprintf(buffer, sizeof(buffer), "%02d:%02d", tm->tm_hour, tm->tm_min);
+                       return string(buffer);
+               };
+               auto const duration = _finish_time - _start_time;
+               if (duration < 10) {
+                       /* It took less than 10 seconds; it doesn't seem worth saying how long it took */
+                       s = _("OK");
+               } else if (duration < 600) {
+                       /* It took less than 10 minutes; it doesn't seem worth saying when it started and finished */
+                       s = String::compose(_("OK (ran for %1)"), seconds_to_hms(duration));
+               } else {
+                       s = String::compose(_("OK (ran for %1 from %2 to %3)"),  seconds_to_hms(duration), time_string(_start_time), time_string(_finish_time));
+               }
        } else if (finished_in_error ()) {
                s = String::compose (_("Error: %1"), error_summary ());
        } else if (finished_cancelled ()) {
@@ -645,11 +710,11 @@ Job::resume ()
 
 
 void
-Job::when_finished (boost::signals2::connection& connection, function<void()> finished)
+Job::when_finished(boost::signals2::connection& connection, function<void(Result)> finished)
 {
        boost::mutex::scoped_lock lm (_state_mutex);
        if (_state == FINISHED_OK || _state == FINISHED_ERROR || _state == FINISHED_CANCELLED) {
-               finished ();
+               finished(state_to_result(_state));
        } else {
                connection = Finished.connect (finished);
        }