libzypp  17.35.11
progressobserver.h
Go to the documentation of this file.
1 /*---------------------------------------------------------------------\
2 | ____ _ __ __ ___ |
3 | |__ / \ / / . \ . \ |
4 | / / \ V /| _/ _/ |
5 | / /__ | | | | | | |
6 | /_____||_| |_| |_| |
7 | |
8 \---------------------------------------------------------------------*/
9 #ifndef ZYPPNG_PROGRESSOBSERVER_H
10 #define ZYPPNG_PROGRESSOBSERVER_H
11 
12 #include <zypp-core/zyppng/base/Base>
13 #include <zypp-core/zyppng/base/Signals>
14 #include <zypp-core/zyppng/pipelines/Expected>
15 #include <optional>
16 #include <string>
17 
18 // backwards compat
20 
21 
22 namespace zyppng {
23 
24  ZYPP_FWD_DECL_TYPE_WITH_REFS( ProgressObserver );
25  class ProgressObserverPrivate;
26 
27  class ProgressObserver : public Base
28  {
31 
32  public:
33 
34  enum FinishResult {
37  };
38 
39  ZYPP_DECL_PRIVATE_CONSTR_ARGS(ProgressObserver, const std::string &label = std::string(), int steps = 100 );
40 
41  void setBaseSteps( int steps );
42  int baseSteps ( ) const;
43  int steps ( ) const;
44  bool started ( ) const;
45 
52  void start ( );
53  void reset ( );
54  void setCurrent ( double curr );
55  void setFinished ( FinishResult result = Success );
56  void inc ( double inc = 1.0, const std::optional<std::string> &newLabel = {} );
57 
58  double progress() const;
59  double current() const;
60 
61 
62  inline static ProgressObserverRef makeSubTask( ProgressObserverRef parentProgress, float weight = 1.0, const std::string &label = std::string(), int steps = 100 ) {
63  if ( parentProgress ) return parentProgress->makeSubTask( weight, label, steps );
64  return nullptr;
65  }
66 
67  inline static void start ( ProgressObserverRef progress ) {
68  if ( progress ) progress->start();
69  }
70 
71  inline static void setup( ProgressObserverRef progress, const std::string &label = std::string(), int steps = 100 ) {
72  if ( progress ) {
73  progress->setLabel( label );
74  progress->setBaseSteps ( steps );
75  }
76  }
77 
78  inline static void increase( ProgressObserverRef progress, double inc = 1.0, const std::optional<std::string> &newLabel = {} ) {
79  if ( progress ) progress->inc ( inc, newLabel );
80  }
81 
82  inline static void setCurrent ( ProgressObserverRef progress, double curr ) {
83  if ( progress ) progress->setCurrent ( curr );
84  }
85 
86  inline static void setLabel ( ProgressObserverRef progress, const std::string &label ) {
87  if ( progress ) progress->setLabel ( label );
88  }
89 
90  inline static void setSteps ( ProgressObserverRef progress, int steps ) {
91  if ( progress ) progress->setBaseSteps ( steps );
92  }
93 
94  inline static void finish ( ProgressObserverRef progress, ProgressObserver::FinishResult result = ProgressObserver::Success ) {
95  if ( progress ) progress->setFinished ( result );
96  }
97 
98  const std::vector<zyppng::ProgressObserverRef> &children();
99 
100  void setLabel ( const std::string &label );
101  const std::string &label () const;
102 
103  void registerSubTask ( const ProgressObserverRef& child, float weight = 1.0 );
104 
105  ProgressObserverRef makeSubTask( float weight = 1.0 ,const std::string &label = std::string(), int steps = 100 );
106 
108 
116 
117  };
118 
119  namespace operators {
120 
121  namespace detail {
122 
123  enum class progress_helper_mode {
124  Start,
125  Increase,
126  Set,
127  Finish
128  };
129 
130  template <progress_helper_mode mode>
132 
133  progress_helper( ProgressObserverRef &&progressObserver, std::optional<std::string> &&newStr, double inc )
134  : _progressObserver( std::move(progressObserver) )
135  , _newString( std::move(newStr) )
136  , _progressInc( inc )
137  {}
138 
139  template <typename T>
140  auto operator() ( T &&t ) {
141  update();
142  return std::forward<T>(t);
143  }
144 
145  void operator()() {
146  update();
147  }
148 
149  void update() {
150  if ( _progressObserver ) {
151  if constexpr ( mode == progress_helper_mode::Increase ) {
153  } else {
154  _progressObserver->setCurrent ( _progressInc );
155  if ( _newString )
156  _progressObserver->setLabel ( *_newString );
157  }
158  }
159  }
160 
161  private:
162  ProgressObserverRef _progressObserver;
163  std::optional<std::string> _newString;
164  double _progressInc;
165  };
166 
167  template <>
169  {
170  progress_helper( ProgressObserverRef &&progressObserver )
171  : _progressObserver( std::move(progressObserver) ){}
172 
173  template <typename T>
174  auto operator() ( T &&t ) {
175  update();
176  return std::forward<T>(t);
177  }
178 
179  void operator()() {
180  update();
181  }
182 
183  void update() {
184  if ( _progressObserver ) { _progressObserver->start(); }
185  }
186 
187  private:
188  ProgressObserverRef _progressObserver;
189  };
190 
191  template <>
193  {
194  progress_helper( ProgressObserverRef &&progressObserver, ProgressObserver::FinishResult result = ProgressObserver::Success )
195  : _progressObserver( std::move(progressObserver) )
196  , _result(result){}
197 
198  template <typename T>
199  auto operator() ( T &&t ) {
200  update();
201  return std::forward<T>(t);
202  }
203 
204  void operator()() {
205  update();
206  }
207 
208  void update() {
209  if ( _progressObserver ) { _progressObserver->setFinished( _result ); }
210  }
211 
212  private:
213  ProgressObserverRef _progressObserver;
215  };
216  }
217 
221  inline auto startProgress( ProgressObserverRef progressObserver ) {
222  return detail::progress_helper<detail::progress_helper_mode::Start>( std::move(progressObserver) );
223  }
224 
229  inline auto incProgress( ProgressObserverRef progressObserver, double progrIncrease = 1.0, std::optional<std::string> newStr = {} ) {
230  return detail::progress_helper<detail::progress_helper_mode::Increase>( std::move(progressObserver), std::move(newStr), progrIncrease );
231  }
232 
237  inline auto setProgress( ProgressObserverRef progressObserver, double progrValue, std::optional<std::string> newStr = {} ) {
238  return detail::progress_helper<detail::progress_helper_mode::Set>( std::move(progressObserver), std::move(newStr), progrValue );
239  }
240 
244  inline auto setProgressLabel( ProgressObserverRef progressObserver, std::string newStr ) {
245  // use the Increase functor, it allows us to let the progress value untouched and just sets the strings
246  return detail::progress_helper<detail::progress_helper_mode::Increase>( std::move(progressObserver), std::move(newStr), 0.0 );
247  }
248 
252  inline auto finishProgress( ProgressObserverRef progressObserver, ProgressObserver::FinishResult result = ProgressObserver::Success ) {
253  return detail::progress_helper<detail::progress_helper_mode::Finish>( std::move(progressObserver), result );
254  }
255 
256 
257  }
258 
259 } // namespace zyppng
260 
261 #endif // ZYPPNG_PROGRESSOBSERVER_H
const std::string & label() const
auto finishProgress(ProgressObserverRef progressObserver, ProgressObserver::FinishResult result=ProgressObserver::Success)
const std::vector< zyppng::ProgressObserverRef > & children()
function< bool(const ProgressData &)> ReceiverFnc
Most simple version of progress reporting The percentage in most cases.
Definition: progressdata.h:140
void setFinished(FinishResult result=Success)
ZYPP_DECL_PRIVATE_CONSTR_ARGS(ProgressObserver, const std::string &label=std::string(), int steps=100)
#define ZYPP_ADD_CREATE_FUNC(Class)
Definition: zyppglobal.h:205
Definition: Arch.h:363
static void setLabel(ProgressObserverRef progress, const std::string &label)
SignalProxy< void(ProgressObserver &sender, double current) > sigValueChanged()
static void increase(ProgressObserverRef progress, double inc=1.0, const std::optional< std::string > &newLabel={})
static void start(ProgressObserverRef progress)
zypp::ProgressData::ReceiverFnc makeProgressDataReceiver()
ZYPP_FWD_DECL_TYPE_WITH_REFS(Context)
SignalProxy< void(ProgressObserver &sender, const std::string &str)> sigLabelChanged()
auto setProgressLabel(ProgressObserverRef progressObserver, std::string newStr)
static void setup(ProgressObserverRef progress, const std::string &label=std::string(), int steps=100)
progress_helper(ProgressObserverRef &&progressObserver, ProgressObserver::FinishResult result=ProgressObserver::Success)
void setCurrent(double curr)
auto startProgress(ProgressObserverRef progressObserver)
static ProgressObserverRef makeSubTask(ProgressObserverRef parentProgress, float weight=1.0, const std::string &label=std::string(), int steps=100)
#define ZYPP_DECLARE_PRIVATE(Class)
Definition: zyppglobal.h:87
SignalProxy< void(ProgressObserver &sender)> sigStarted()
SignalProxy< void(ProgressObserver &sender, double steps)> sigStepsChanged()
auto setProgress(ProgressObserverRef progressObserver, double progrValue, std::optional< std::string > newStr={})
SignalProxy< void(ProgressObserver &sender, FinishResult result)> sigFinished()
progress_helper(ProgressObserverRef &&progressObserver, std::optional< std::string > &&newStr, double inc)
SignalProxy< void(ProgressObserver &sender, ProgressObserverRef child)> sigNewSubprogress()
static void setSteps(ProgressObserverRef progress, int steps)
SignalProxy< void(ProgressObserver &sender, double progress)> sigProgressChanged()
static void finish(ProgressObserverRef progress, ProgressObserver::FinishResult result=ProgressObserver::Success)
void inc(double inc=1.0, const std::optional< std::string > &newLabel={})
void registerSubTask(const ProgressObserverRef &child, float weight=1.0)
auto incProgress(ProgressObserverRef progressObserver, double progrIncrease=1.0, std::optional< std::string > newStr={})
ZYppCommitResult & _result
Definition: TargetImpl.cc:1610
static void setCurrent(ProgressObserverRef progress, double curr)
std::optional< std::string > _newString