Merge branch 'master' into speed-up

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

diff --git a/src/lib/job.cc b/src/lib/job.cc
index 22754eb909659ffd8693b48c77a9c184b6c40f9b..896862d143f7c9c7c26514d4e17d1e7d966652f5 100644 (file)
--- a/src/lib/job.cc
+++ b/src/lib/job.cc
@@ -27,23 +27,22 @@
 #include "job.h"
 #include "util.h"
 
-using namespace std;
-using namespace boost;
+using std::string;
+using std::list;
+using std::stringstream;
+using boost::shared_ptr;
 
-/** @param s FilmState for the film that we are operating on.
- *  @param o Options.
- *  @param l A log that we can write to.
+/** @param s Film that we are operating on.
+ *  @param req Job that must be completed before this job is run.
  */
-Job::Job (shared_ptr<const FilmState> s, shared_ptr<const Options> o, Log* l)
-       : _fs (s)
-       , _opt (o)
-       , _log (l)
+Job::Job (shared_ptr<Film> f, shared_ptr<Job> req)
+       : _film (f)
+       , _required (req)
        , _state (NEW)
        , _start_time (0)
        , _progress_unknown (false)
+       , _ran_for (0)
 {
-       assert (_log);
-       
        descend (1);
 }
 
@@ -68,9 +67,7 @@ Job::run_wrapper ()
                
                set_progress (1);
                set_state (FINISHED_ERROR);
-               stringstream s;
-               s << e.what() << "(" << filesystem::path (e.filename()).leaf() << ")";
-               set_error (s.str ());
+               set_error (String::compose ("%1 (%2)", e.what(), boost::filesystem::path (e.filename()).leaf()));
                
        } catch (std::exception& e) {
 
@@ -78,9 +75,23 @@ Job::run_wrapper ()
                set_state (FINISHED_ERROR);
                set_error (e.what ());
 
+       } catch (...) {
+
+               set_progress (1);
+               set_state (FINISHED_ERROR);
+               set_error ("unknown exception");
+
        }
 }
 
+/** @return true if this job is new (ie has not started running) */
+bool
+Job::is_new () const
+{
+       boost::mutex::scoped_lock lm (_state_mutex);
+       return _state == NEW;
+}
+
 /** @return true if the job is running */
 bool
 Job::running () const
@@ -121,17 +132,11 @@ Job::set_state (State s)
 {
        boost::mutex::scoped_lock lm (_state_mutex);
        _state = s;
-}
 
-/** A hack to work around our lack of cross-thread
- *  signalling; this emits Finished, and listeners
- *  assume that it will be emitted in the GUI thread,
- *  so this method must be called from the GUI thread.
- */
-void
-Job::emit_finished ()
-{
-       Finished ();
+       if (_state == FINISHED_OK || _state == FINISHED_ERROR) {
+               _ran_for = elapsed_time ();
+               Finished ();
+       }
 }
 
 /** @return Time (in seconds) that this job has been running */
@@ -152,6 +157,7 @@ void
 Job::set_progress (float p)
 {
        boost::mutex::scoped_lock lm (_progress_mutex);
+       _progress_unknown = false;
        _stack.back().normalised = p;
 }
 
@@ -223,7 +229,7 @@ Job::set_error (string e)
        _error = e;
 }
 
-/** Say that this job's progress will always be unknown */
+/** Say that this job's progress will be unknown until further notice */
 void
 Job::set_progress_unknown ()
 {
@@ -238,14 +244,14 @@ Job::status () const
        float const p = overall_progress ();
        int const t = elapsed_time ();
        int const r = remaining_time ();
-       
+
        stringstream s;
        if (!finished () && p >= 0 && t > 10 && r > 0) {
                s << rint (p * 100) << "%; " << seconds_to_approximate_hms (r) << " remaining";
        } else if (!finished () && (t <= 10 || r == 0)) {
                s << rint (p * 100) << "%";
        } else if (finished_ok ()) {
-               s << "OK (ran for " << seconds_to_hms (t) << ")";
+               s << "OK (ran for " << seconds_to_hms (_ran_for) << ")";
        } else if (finished_in_error ()) {
                s << "Error (" << error() << ")";
        }