FWModelChangeManager.cc

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:     Core
// Class  :     FWModelChangeManager
//
// Implementation:
//     <Notes on implementation>
//
// Original Author:  Chris Jones
//         Created:  Thu Jan 17 19:13:46 EST 2008
//

// system include files
#include <cassert>
#include <memory>
#include <exception>

// user include files
#include "Fireworks/Core/interface/FWModelChangeManager.h"
#include "Fireworks/Core/interface/FWEventItem.h"
#include "Fireworks/Core/interface/fwLog.h"
#include "FWCore/Utilities/interface/Exception.h"


//
// constants, enums and typedefs
//

//
// static data member definitions
//

//
// constructors and destructor
//
FWModelChangeManager::FWModelChangeManager() :
   m_depth(0)
{
}

// FWModelChangeManager::FWModelChangeManager(const FWModelChangeManager& rhs)
// {
//    // do actual copying here;
// }

FWModelChangeManager::~FWModelChangeManager()
{
}

//
// assignment operators
//
// const FWModelChangeManager& FWModelChangeManager::operator=(const FWModelChangeManager& rhs)
// {
//   //An exception safe implementation is
//   FWModelChangeManager temp(rhs);
//   swap(rhs);
//
//   return *this;
// }

//
// member functions
//
void
FWModelChangeManager::beginChanges()
{
   ++m_depth;
}

void
FWModelChangeManager::changed(const FWModelId& iID)
{
   FWChangeSentry sentry(*this);
   assert(iID.item());
   assert(iID.item()->id() < m_changes.size());
   m_changes[iID.item()->id()].insert(iID);
}

void
FWModelChangeManager::changed(const FWEventItem* iItem)
{
   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();
}

static
void sendChangeSignalsAreDone(FWModelChangeManager* iCM)
{
   //since this can cause other changes, we might as well aggregate them
   FWChangeSentry sentry(*iCM);
   iCM->changeSignalsAreDone_();
}

void
FWModelChangeManager::endChanges()
{
   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);
}

void
FWModelChangeManager::newItemSlot(FWEventItem* iItem)
{
   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_);
}

void
FWModelChangeManager::itemsGoingToBeClearedSlot(void)
{
   m_changes.clear();
   m_changeSignals.clear();

   m_itemChangeSignals.clear();
   m_itemChanges.clear();
}

//
// const member functions
//

//
// static member functions
//