X-Git-Url: https://git.carlh.net/gitweb/?p=dcpomatic.git;a=blobdiff_plain;f=src%2Flib%2Fjob.h;h=5562afc16cc89cae1e9dec8941ee837622598d8b;hp=5e3127dc158a432522590ffec566e5cfa1e21bbf;hb=a6c4b4fa16d9c6597e362044b875f3d6df80753f;hpb=8e0ab80930d39a005f8dc7692f871e7fbe5e3723 diff --git a/src/lib/job.h b/src/lib/job.h index 5e3127dc1..5562afc16 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 . */ @@ -24,31 +25,39 @@ #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, public boost::noncopyable +class Job : public std::enable_shared_from_this, public Signaller { public: - Job (boost::shared_ptr); - 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 (); - void pause (); + bool pause_by_user (); + void pause_by_priority (); void resume (); void cancel (); @@ -58,12 +67,14 @@ public: bool finished_ok () const; bool finished_in_error () const; bool finished_cancelled () const; - bool paused () 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 { @@ -73,18 +84,26 @@ public: void set_progress_unknown (); void set_progress (float, bool force = false); void sub (std::string); - float progress () const; - bool progress_unknown () const { - return !_progress; - } + boost::optional progress () const; + boost::optional seconds_since_last_progress_update () const; - boost::shared_ptr film () const { + std::shared_ptr film () const { return _film; } + enum class Result { + RESULT_OK, + RESULT_ERROR, // we can't have plain ERROR on Windows + RESULT_CANCELLED + }; + + 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; + boost::signals2::signal Finished; + /** Emitted from the job thread when the job is finished */ + boost::signals2::signal FinishedImmediate; protected: @@ -94,38 +113,55 @@ protected: enum State { NEW, ///< the job hasn't been started yet RUNNING, ///< the job is running - PAUSED, ///< the job has been paused + 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 }; - + + Result state_to_result(State state) const; 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 (); - boost::shared_ptr _film; + std::shared_ptr _film; private: void run_wrapper (); + void set_progress_common (boost::optional p); - boost::thread* _thread; + boost::thread _thread; - /** mutex for _state and _error */ + /** 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 sub-job was started */ + /** 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 _progress */ + /** mutex for _progress and _last_progress_update */ mutable boost::mutex _progress_mutex; boost::optional _progress; + boost::optional _last_progress_update; + + /** 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; };