X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Flib%2Fjob.h;h=f50ed078434efb6cd3661de2802a4c528fb18c7d;hb=dba3b79e848c70e405e41744c40b416014e86eb8;hp=95599bdbb65bf1dd1ca8bae44b4347ac5bb1015d;hpb=266fe11af7f3bdc194cfedf92db7352b7b68be97;p=dcpomatic.git diff --git a/src/lib/job.h b/src/lib/job.h index 95599bdbb..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,97 +22,141 @@ * @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 Log; -class FilmState; -class Options; +class Film; /** @class Job * @brief A parent class to represent long-running tasks which are run in their own thread. */ -class Job +class Job : public std::enable_shared_from_this, public Signaller { public: - Job (boost::shared_ptr s, boost::shared_ptr o, Log* l); + 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; - std::string error () const; + boost::optional message () const; - int elapsed_time () 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; + } - void emit_finished (); + void when_finished (boost::signals2::connection& connection, std::function finished); - /** Emitted from the GUI thread */ - sigc::signal0 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: virtual int remaining_time () const; + /** 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 e); - boost::shared_ptr _fs; - boost::shared_ptr _opt; + void set_state (State); + 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 (); - /** A log that this job can write to */ - Log* _log; + 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; - std::string _error; + /** 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; - - mutable boost::mutex _progress_mutex; + /** time that this sub-job was started */ + time_t _sub_start_time; + std::string _sub_name; - struct Level { - Level (float a) : allocation (a), normalised (0) {} - - float allocation; - float normalised; - }; + /** mutex for _progress and _last_progress_update */ + mutable boost::mutex _progress_mutex; + boost::optional _progress; + boost::optional _last_progress_update; - std::list _stack; + /** 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; - /** true if this job's progress will always be unknown */ - bool _progress_unknown; + int _ran_for; }; #endif