X-Git-Url: https://git.carlh.net/gitweb/?p=dcpomatic.git;a=blobdiff_plain;f=src%2Flib%2Fjob.h;h=c8204c2806aa20ff14bcb82a16eba70f0de1291a;hp=c98dbaea15dfb13133611f61727439d332158470;hb=dba3b79e848c70e405e41744c40b416014e86eb8;hpb=d0d93259d096faa0d410a27450445a3a1a16c430 diff --git a/src/lib/job.h b/src/lib/job.h index c98dbaea1..c8204c280 100644 --- a/src/lib/job.h +++ b/src/lib/job.h @@ -1,19 +1,20 @@ /* Copyright (C) 2012 Carl Hetherington - This program is free software; you can redistribute it and/or modify + This file is part of DCP-o-matic. + + DCP-o-matic is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. - This program is distributed in the hope that it will be useful, + DCP-o-matic is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + along with DCP-o-matic. If not, see . */ @@ -21,52 +22,82 @@ * @brief A parent class to represent long-running tasks which are run in their own thread. */ -#ifndef DVDOMATIC_JOB_H -#define DVDOMATIC_JOB_H +#ifndef DCPOMATIC_JOB_H +#define DCPOMATIC_JOB_H -#include +#include "signaller.h" #include -#include #include +#include +#include class Film; /** @class Job * @brief A parent class to represent long-running tasks which are run in their own thread. */ -class Job : public boost::enable_shared_from_this +class Job : public std::enable_shared_from_this, public Signaller { public: - Job (boost::shared_ptr s); - virtual ~Job() {} + explicit Job (std::shared_ptr film); + virtual ~Job (); + + Job (Job const&) = delete; + Job& operator= (Job const&) = delete; /** @return user-readable name of this job */ virtual std::string name () const = 0; + virtual std::string json_name () const = 0; /** Run this job in the current thread. */ virtual void run () = 0; - + /** @return true if it should be possible to notify when this job finishes */ + virtual bool enable_notify () const { + return false; + } + void start (); + bool pause_by_user (); + void pause_by_priority (); + void resume (); + void cancel (); bool is_new () const; bool running () const; bool finished () const; bool finished_ok () const; bool finished_in_error () const; + bool finished_cancelled () const; + bool paused_by_user () const; + bool paused_by_priority () const; std::string error_summary () const; std::string error_details () const; - int elapsed_time () const; + boost::optional message () const; + virtual std::string status () const; + std::string json_status () const; + std::string sub_name () const { + return _sub_name; + } void set_progress_unknown (); - void set_progress (float); - void ascend (); - void descend (float); - float overall_progress () const; + void set_progress (float, bool force = false); + void sub (std::string); + boost::optional progress () const; + boost::optional seconds_since_last_progress_update () const; + + std::shared_ptr film () const { + return _film; + } - /** Emitted by the JobManagerView from the UI thread */ + void when_finished (boost::signals2::connection& connection, std::function finished); + + boost::signals2::signal Progress; + /** Emitted from the UI thread when the job is finished */ boost::signals2::signal Finished; + /** Emitted from the job thread when the job is finished */ + boost::signals2::signal FinishedImmediate; protected: @@ -74,47 +105,56 @@ protected: /** Description of a job's state */ enum State { - NEW, ///< the job hasn't been started yet - RUNNING, ///< the job is running - FINISHED_OK, ///< the job has finished successfully - FINISHED_ERROR ///< the job has finished in error + NEW, ///< the job hasn't been started yet + RUNNING, ///< the job is running + PAUSED_BY_USER, ///< the job has been paused + PAUSED_BY_PRIORITY, ///< the job has been paused + FINISHED_OK, ///< the job has finished successfully + FINISHED_ERROR, ///< the job has finished in error + FINISHED_CANCELLED ///< the job was cancelled }; - + void set_state (State); - void set_error (std::string s, std::string d); + void set_error (std::string s, std::string d = ""); + void set_message (std::string m); + int elapsed_sub_time () const; + void check_for_interruption_or_pause (); + void stop_thread (); - /** Film for this job */ - boost::shared_ptr _film; + std::shared_ptr _film; private: void run_wrapper (); + void set_progress_common (boost::optional p); - /** mutex for _state and _error */ + boost::thread _thread; + + /** mutex for _state, _error*, _message */ mutable boost::mutex _state_mutex; /** current state of the job */ State _state; /** summary of an error that has occurred (when state == FINISHED_ERROR) */ std::string _error_summary; std::string _error_details; + /** a message that should be given to the user when the job finishes */ + boost::optional _message; /** time that this job was started */ time_t _start_time; + /** time that this sub-job was started */ + time_t _sub_start_time; + std::string _sub_name; - /** mutex for _stack and _progress_unknown */ + /** mutex for _progress and _last_progress_update */ mutable boost::mutex _progress_mutex; + boost::optional _progress; + boost::optional _last_progress_update; - struct Level { - Level (float a) : allocation (a), normalised (0) {} - - float allocation; - float normalised; - }; - - std::list _stack; - - /** true if this job's progress will always be unknown */ - bool _progress_unknown; + /** condition to signal changes to pause/resume so that we know when to wake; + this could be a general _state_change if it made more sense. + */ + boost::condition_variable _pause_changed; int _ran_for; };