Scroom::Utils::ProgressInterfaceMultiplexer Class Reference

#include <progressinterfacehelpers.hh>

Inheritance diagram for Scroom::Utils::ProgressInterfaceMultiplexer:

Collaboration diagram for Scroom::Utils::ProgressInterfaceMultiplexer:

Classes
class	Child
class	ChildData

Public Types
using	Ptr = boost::shared_ptr< ProgressInterfaceMultiplexer >

Public Member Functions
ProgressInterface::Ptr	createProgressInterface ()
Public Member Functions inherited from Scroom::Utils::Base
	Base ()=default
	Base (const Base &)=delete
	Base (Base &&)=delete
Base &	operator= (const Base &)=delete
Base &	operator= (Base &&)=delete
virtual	~Base ()=default
template<typename R >
boost::shared_ptr< R >	shared_from_this ()
template<typename R >
boost::shared_ptr< R const >	shared_from_this () const

Static Public Member Functions
static Ptr	create (ProgressInterface::Ptr parent)

Private Member Functions
	ProgressInterfaceMultiplexer (ProgressInterface::Ptr parent)
void	updateProgressState ()
void	unsubscribe (const ChildData::Ptr &data)

Private Attributes
boost::mutex	mut
ProgressStateInterface::Ptr	parent
std::set< ChildData::Ptr >	children

Friends
class	Child

Member Typedef Documentation

Ptr

using Scroom::Utils::ProgressInterfaceMultiplexer::Ptr = boost::shared_ptr<ProgressInterfaceMultiplexer>

Constructor & Destructor Documentation

ProgressInterfaceMultiplexer()

Scroom::Utils::ProgressInterfaceMultiplexer::ProgressInterfaceMultiplexer ( ProgressInterface::Ptr  parent )

explicitprivate

    : parent(ProgressStateInterfaceFromProgressInterfaceForwarder::create(std::move(parent_)))
  {
  }

Referenced by create().

Here is the caller graph for this function:

Member Function Documentation

create()

ProgressInterfaceMultiplexer::Ptr Scroom::Utils::ProgressInterfaceMultiplexer::create ( ProgressInterface::Ptr  parent )

static

  {
    return Ptr(new ProgressInterfaceMultiplexer(std::move(parent)));
  }

Referenced by ProgressInterfaceMultiplexer_Fixture::ProgressInterfaceMultiplexer_Fixture().

Here is the call graph for this function:

Here is the caller graph for this function:

createProgressInterface()

ProgressInterface::Ptr Scroom::Utils::ProgressInterfaceMultiplexer::createProgressInterface

(

)

  {
    ChildData::Ptr const data  = ChildData::create();
    Child::Ptr           child = Child::create(shared_from_this<ProgressInterfaceMultiplexer>(), data);
 
    boost::mutex::scoped_lock const l(mut);
    children.insert(data);
 
    return child;
  }

Here is the call graph for this function:

unsubscribe()

void Scroom::Utils::ProgressInterfaceMultiplexer::unsubscribe ( const ChildData::Ptr &  data )

private

  {
    boost::mutex::scoped_lock const l(mut);
    children.erase(data);
  }

updateProgressState()

void Scroom::Utils::ProgressInterfaceMultiplexer::updateProgressState ( )

private

  {
    ProgressStateInterface::State state    = ProgressStateInterface::IDLE;
    double                        progress = 0.0;
    int                           workers  = 0;
 
    boost::mutex::scoped_lock const l(mut);
    for(const ChildData::Ptr& child: children)
    {
      boost::mutex::scoped_lock const child_lock(child->mut);
      switch(child->state)
      {
      case ProgressStateInterface::IDLE:
        break;
      case ProgressStateInterface::WAITING:
        if(state == ProgressStateInterface::IDLE || state == ProgressStateInterface::FINISHED)
        {
          state = ProgressStateInterface::WAITING;
        }
        progress += child->progress;
        workers++;
        break;
      case ProgressStateInterface::WORKING:
        if(state != ProgressStateInterface::WORKING)
        {
          state = ProgressStateInterface::WORKING;
        }
        progress += child->progress;
        workers++;
        break;
      case ProgressStateInterface::FINISHED:
        if(state == ProgressStateInterface::IDLE)
        {
          state = ProgressStateInterface::FINISHED;
        }
        progress += 1.0;
        workers++;
        break;
      }
    }
 
    parent->setProgress(state, progress / workers);
 
    if(state == ProgressStateInterface::FINISHED)
    {
      for(const ChildData::Ptr& child: children)
      {
        child->clearFinished();
      }
    }
  }

Friends And Related Function Documentation

Child

friend class Child

friend

Referenced by Scroom::Utils::ProgressInterfaceMultiplexer::Child::create().

Member Data Documentation

children

std::set<ChildData::Ptr> Scroom::Utils::ProgressInterfaceMultiplexer::children

private

Referenced by createProgressInterface(), unsubscribe(), and updateProgressState().

mut

boost::mutex Scroom::Utils::ProgressInterfaceMultiplexer::mut

private

Referenced by createProgressInterface(), unsubscribe(), and updateProgressState().

parent

ProgressStateInterface::Ptr Scroom::Utils::ProgressInterfaceMultiplexer::parent

private

Referenced by Scroom::Utils::ProgressInterfaceMultiplexer::Child::create(), create(), Scroom::Utils::ProgressInterfaceMultiplexer::Child::setProgress(), updateProgressState(), and Scroom::Utils::ProgressInterfaceMultiplexer::Child::~Child().

---

The documentation for this class was generated from the following files:

• inc/scroom/progressinterfacehelpers.hh
• libs/util/src/progressinterfacehelpers.cc