16    void setLabel( 
const std::string &label );
 
   46        other._signalConns.clear ();
 
 
   58        other._signalConns.clear ();
 
 
 
 
   95    double accumSteps        = 
static_cast<double>(
_baseSteps);
 
   97    for ( std::vector<ProgressObserverRef>::size_type i = 0; i < 
_children.size (); i++ ) {
 
  100      const auto weight = childInfo._childWeight;
 
  101      currProgressSteps +=  childPtr->current() * weight;
 
  102      accumSteps += childPtr->steps()* weight;
 
  114    if ( notifyAccuMaxSteps )
 
  116    if ( notifyCurrSteps) {
 
 
  124    auto i = std::find_if( 
_children.begin (), 
_children.end (), [&]( 
const auto &elem ) { return ( &child == elem.get() ); } );
 
  126      WAR << 
"Unknown child sent a finished message, ignoring" << std::endl;
 
  130    const auto idx = std::distance ( 
_children.begin (), i );
 
 
  139    d->_baseSteps = steps;
 
 
  155    return d_func()->_counterSteps;
 
 
  160    return d_func()->_started;
 
 
  172    d->_sigStarted.emit( *
this );
 
 
  180      d->_ignoreChildSigs = 
true;
 
  181      std::for_each( d->_children.begin (), d->_children.end(), []( 
auto &child ) { child->reset(); });
 
 
  193    return d_func()->_counterValue;
 
 
  198    return d_func()->_children;
 
 
  203    return d_func()->_label;
 
 
  208    return d_func()->_sigStarted;
 
 
  213    return d_func()->_sigLabelChanged;
 
 
  218    return d_func()->_sigStepsChanged;
 
 
  223    return d_func()->_sigValueChanged;
 
 
  228    return d_func()->_sigProgressChanged;
 
 
  233    return d_func()->_sigFinished;
 
 
  238    return d_func()->_sigNewSubprogress;
 
 
  244    if ( d->_baseSteps == 
steps )
 
  247    d->_baseSteps = 
steps;
 
 
  255    d_func()->setLabel( 
label );
 
 
  261    auto set = std::max<double>(0, std::min<double>( curr, d->_baseSteps ) );
 
  262    if ( set == d->_baseValue )
 
 
  272    return d_func()->_baseSteps;
 
 
  281    while ( d->_children.size() ) {
 
  282      auto back   = d->_children.back();
 
  283      bool remove = !back->started ();
 
  284      back->setFinished( result );
 
  285      if ( remove ) d->_children.pop_back();
 
  288    if ( result != 
Error )
 
  292      d->_sigFinished.emit( *
this , result );
 
 
  298    if ( newLabel ) 
setLabel ( *newLabel );
 
 
  304    auto i = std::find( d->_children.begin(), d->_children.end(), child );
 
  305    const auto adjustedWeight = std::min<float>( std::max<float>( 0.0, weight ), 1.0 );
 
  306    if ( i != d->_children.end() ) {
 
  307      const auto index = std::distance ( d->_children.begin (), i );
 
  308      d->_childInfo[index]._childWeight = adjustedWeight;
 
  310      d->_children.push_back( child );
 
  311      d->_childInfo.push_back( {
 
  319      d->_sigNewSubprogress.emit( *
this, child );
 
  322      if ( child->started () )
 
 
  332    auto r = ProgressObserver::create( 
label, 
steps );
 
 
  347      auto instance = sThis.get();
 
  349      instance->setBaseSteps ( data.max () - data.min () );
 
  350      instance->setCurrent ( data.val () - data.min () );
 
  351      instance->setLabel ( data.name () );
 
  352      if ( data.finalReport() )
 
  353        instance->setFinished();
 
 
Assign a vaiable a certain value when going out of scope.
Maintain [min,max] and counter (value) for progress counting.
function< bool(const ProgressData &)> ReceiverFnc
Most simple version of progress reporting The percentage in most cases.
std::shared_ptr< T > shared_this() const
static auto connectFunc(typename internal::MemberFunction< SenderFunc >::ClassType &s, SenderFunc &&sFun, ReceiverFunc &&rFunc, const Tracker &...trackers)
static auto connect(typename internal::MemberFunction< SenderFunc >::ClassType &s, SenderFunc &&sFun, typename internal::MemberFunction< ReceiverFunc >::ClassType &recv, ReceiverFunc &&rFunc)
void setLabel(const std::string &label)
Signal< void(ProgressObserver &sender, const std::string &str)> _sigLabelChanged
void onChildFinished(ProgressObserver &child, ProgressObserver::FinishResult)
Signal< void(ProgressObserver &sender, ProgressObserverRef child)> _sigNewSubprogress
Signal< void(ProgressObserver &sender, double steps) > _sigStepsChanged
std::vector< ChildInfo > _childInfo
Signal< void(ProgressObserver &sender, double steps) > _sigProgressChanged
std::vector< ProgressObserverRef > _children
void onChildStarted(ProgressObserver &)
Signal< void(ProgressObserver &sender, ProgressObserver::FinishResult)> _sigFinished
ProgressObserverPrivate(ProgressObserver &p)
ProgressObserverWeakRef _parent
Signal< void(ProgressObserver &sender, double steps) > _sigValueChanged
Signal< void(ProgressObserver &sender) > _sigStarted
SignalProxy< void(ProgressObserver &sender, double current) > sigValueChanged()
SignalProxy< void(ProgressObserver &sender)> sigStarted()
void inc(double inc=1.0, const std::optional< std::string > &newLabel={})
SignalProxy< void(ProgressObserver &sender, FinishResult result)> sigFinished()
void setBaseSteps(int steps)
static void setLabel(ProgressObserverRef progress, const std::string &label)
static ProgressObserverRef makeSubTask(ProgressObserverRef parentProgress, float weight=1.0, const std::string &label=std::string(), int steps=100)
const std::vector< zyppng::ProgressObserverRef > & children()
SignalProxy< void(ProgressObserver &sender, double steps)> sigStepsChanged()
zypp::ProgressData::ReceiverFnc makeProgressDataReceiver()
const std::string & label() const
void setCurrent(double curr)
SignalProxy< void(ProgressObserver &sender, double progress)> sigProgressChanged()
void setFinished(FinishResult result=Success)
SignalProxy< void(ProgressObserver &sender, ProgressObserverRef child)> sigNewSubprogress()
void registerSubTask(const ProgressObserverRef &child, float weight=1.0)
SignalProxy< void(ProgressObserver &sender, const std::string &str)> sigLabelChanged()
String related utilities and Regular expression matching.
ChildInfo(ChildInfo &&other) noexcept
ChildInfo(std::vector< connection > &&conns, float weight)
ChildInfo & operator=(ChildInfo &&other)
ChildInfo & operator=(const ChildInfo &)=delete
ChildInfo(const ChildInfo &other)=delete
std::vector< connection > _signalConns
#define ZYPP_IMPL_PRIVATE_CONSTR_ARGS(Class,...)
#define ZYPP_IMPL_PRIVATE(Class)
#define ZYPP_DECLARE_PUBLIC(Class)