#include <Fireworks/Core/interface/FWModelChangeManager.h>

Public Member Functions
void	beginChanges ()

void	changed (const FWEventItem *)

void	changed (const FWModelId &)

void	endChanges ()

	FWModelChangeManager ()

void	itemsGoingToBeClearedSlot (void)

void	newItemSlot (FWEventItem *)

virtual	~FWModelChangeManager ()

Public Attributes
sigc::signal< void >	changeSignalsAreComing_

sigc::signal< void >	changeSignalsAreDone_

Private Member Functions
	FWModelChangeManager (const FWModelChangeManager &)=delete

const FWModelChangeManager &	operator= (const FWModelChangeManager &)=delete

Private Attributes
std::vector< FWModelIds >	m_changes

std::vector< FWModelChangeSignal >	m_changeSignals

unsigned int	m_depth

std::set< const FWEventItem * >	m_itemChanges

std::vector< FWItemChangeSignal >	m_itemChangeSignals

Detailed Description

Description: Manages propagating announcements of changes to Models to any interested party

Usage: <usage>

Definition at line 33 of file FWModelChangeManager.h.

Constructor & Destructor Documentation

◆ FWModelChangeManager() [1/2]

FWModelChangeManager::FWModelChangeManager ( )

Definition at line 35 of file FWModelChangeManager.cc.

35 : m_depth(0) {}

◆ ~FWModelChangeManager()

FWModelChangeManager::~FWModelChangeManager ( )

virtual

Definition at line 42 of file FWModelChangeManager.cc.

42 {}

◆ FWModelChangeManager() [2/2]

FWModelChangeManager::FWModelChangeManager ( const FWModelChangeManager & )

privatedelete

Member Function Documentation

◆ beginChanges()

void FWModelChangeManager::beginChanges ( )

Definition at line 59 of file FWModelChangeManager.cc.

59 { ++m_depth; }

References m_depth.

Referenced by FWChangeSentry::FWChangeSentry().

◆ changed() [1/2]

void FWModelChangeManager::changed ( const FWEventItem * iItem )

Definition at line 68 of file FWModelChangeManager.cc.

                                                            {
   FWChangeSentry sentry(*this);
   assert(nullptr != iItem);
   m_itemChanges.insert(iItem);
   //remove any pending changes on models owned by this item
   assert(iItem->id() < m_changes.size());
   m_changes[iItem->id()].clear();
 }

References cms::cuda::assert(), FWEventItem::id(), m_changes, and m_itemChanges.

◆ changed() [2/2]

void FWModelChangeManager::changed ( const FWModelId & iID )

Definition at line 61 of file FWModelChangeManager.cc.

                                                        {
   FWChangeSentry sentry(*this);
   assert(iID.item());
   assert(iID.item()->id() < m_changes.size());
   m_changes[iID.item()->id()].insert(iID);
 }

References cms::cuda::assert(), FWEventItem::id(), FWModelId::item(), and m_changes.

Referenced by FWEventItem::destroy(), FWEventItem::handleChange(), FWEventItem::proxyConfigChanged(), FWEventItem::resetColor(), FWEventItem::runFilter(), FWEventItem::select(), FWEventItem::setDefaultDisplayProperties(), FWEventItem::setDisplayProperties(), FWEventItem::toggleSelect(), and FWEventItem::unselect().

◆ endChanges()

void FWModelChangeManager::endChanges ( )

Definition at line 83 of file FWModelChangeManager.cc.

                                       {
   assert(m_depth != 0);
   //makes sure that 'changeSignalsAreDone is called if changeSignalsAreComing_ is sent
   bool guard(false);
   if (0 == --m_depth) {
     unsigned int index = 0;
     for (std::set<const FWEventItem*>::iterator itChanges = m_itemChanges.begin(); itChanges != m_itemChanges.end();
          ++itChanges, ++index) {
       if (!guard) {
         // std::shared_ptr<FWModelChangeManager> done(this, &sendChangeSignalsAreDone);
         guard = true;
         changeSignalsAreComing_();
       }
       FWItemChangeSignal& signal = m_itemChangeSignals[(*itChanges)->id()];
       //loop over the slots ourself so we can control the behavior in case of a failure
       FWItemChangeSignal::slot_list_type slots = signal.slots();
       for (FWItemChangeSignal::slot_list_type::iterator itSlot = slots.begin(), itEnd = slots.end(); itSlot != itEnd;
            ++itSlot) {
         try {
           (*itSlot)(*itChanges);
         } catch (const cms::Exception& iE) {
           fwLog(fwlog::kError) << (*itChanges)->name() << " had the failure in process FWItemChanged signals\n"
                                << iE.what() << std::endl;
         } catch (const std::bad_alloc& iE) {
           std::cerr << "Ran out of memory while processing " << (*itChanges)->name() << std::endl;
           exit(1);
         } catch (const std::exception& iE) {
           fwLog(fwlog::kError) << (*itChanges)->name() << " had the failure in process FWItemChanged signals (2) \n"
                                << iE.what() << std::endl;
         }
       }
     }
     m_itemChanges.clear();
  
     for (size_t ci = 0, ce = m_changes.size(), si = 0; ci != ce; ++ci, ++si) {
       FWModelIds& changes = m_changes[ci];
       FWModelChangeSignal& signal = m_changeSignals[si];
  
       if (not changes.empty()) {
         if (!guard) {
           // std::shared_ptr<FWModelChangeManager> done(this, &sendChangeSignalsAreDone);
           guard = true;
           changeSignalsAreComing_();
         }
         //loop over the slots ourself so we can control the behavior in case of a failure
         FWModelChangeSignal::slot_list_type slots = signal.slots();
         for (FWModelChangeSignal::slot_list_type::iterator itSlot = slots.begin(), itEnd = slots.end(); itSlot != itEnd;
              ++itSlot) {
           try {
             (*itSlot)(changes);
           } catch (const cms::Exception& iE) {
             fwLog(fwlog::kError) << changes.begin()->item()->name()
                                  << " had the failure in process FWModelChangeSignals\n"
                                  << iE.what() << "\n";
           } catch (const std::bad_alloc& iE) {
             // GE: if we run out of memory why do we assume that we will be able to print?
             fwLog(fwlog::kError) << "Ran out of memory while processing " << changes.begin()->item()->name() << "\n";
             exit(1);
           } catch (const std::exception& iE) {
             fwLog(fwlog::kError) << changes.begin()->item()->name()
                                  << " had the failure in process FWModelChangeSignals (2)\n"
                                  << iE.what() << "\n";
           }
         }
         changes.clear();
       }
     }
   }
   if (guard)
     sendChangeSignalsAreDone(this);
 }

References cms::cuda::assert(), beam_dqm_sourceclient-live_cfg::cerr, changeSignalsAreComing_, cppFunctionSkipper::exception, beamvalidation::exit(), fwLog, fwlog::kError, m_changes, m_changeSignals, m_depth, m_itemChanges, m_itemChangeSignals, sendChangeSignalsAreDone(), and cms::Exception::what().

Referenced by FWChangeSentry::~FWChangeSentry().

◆ itemsGoingToBeClearedSlot()

void FWModelChangeManager::itemsGoingToBeClearedSlot ( void )

Whenever all the items are removed from the FWItemsManager clean also the associated vectors here.

Definition at line 170 of file FWModelChangeManager.cc.

                                                          {
   m_changes.clear();
   m_changeSignals.clear();
  
   m_itemChangeSignals.clear();
   m_itemChanges.clear();
 }

References m_changes, m_changeSignals, m_itemChanges, and m_itemChangeSignals.

Referenced by FWSummaryManager::FWSummaryManager().

◆ newItemSlot()

void FWModelChangeManager::newItemSlot ( FWEventItem * iItem )

Definition at line 155 of file FWModelChangeManager.cc.

                                                          {
   assert(nullptr != iItem);
   assert(iItem->id() == m_changes.size());
   assert(iItem->id() == m_changeSignals.size());
   m_changes.push_back(FWModelIds());
   m_changeSignals.push_back(FWModelChangeSignal());
   m_itemChangeSignals.push_back(FWItemChangeSignal());
   //propagate our signal to the item
   m_changeSignals.back().connect(iItem->changed_);
   m_itemChangeSignals.back().connect(iItem->itemChanged_);
 }