ActiveObjectManagerAce.cpp

Go to the documentation of this file.

/*
Copyright 2007, 2008, 2009, 2010, 2011 Instituto de Sistemas e Robotica, Instituto Superior Tecnico

This file is part of MeRMaID.

MeRMaID is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

MeRMaID is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with MeRMaID.  If not, see <http://www.gnu.org/licenses/>.
*/



/**
 * @Filename ActiveObjectManagerAce.cpp
 * @Description ActiveObjectManagerAce implementation
 * @Status Work in Progress
 * @Version $Id: ActiveObjectManagerAce.cpp 1 2011-03-04 18:13:18Z jreis $
 * @Maintainer
 */

#include "config.h"

#include <ActiveObjectManagerAce.hpp>
#include <ActiveObjectAce.hpp>

#include <iostream>



using namespace mermaid::support::activeobject;



shared_ptr<ActiveObjectManagerAce>
ActiveObjectManagerAce::
instance_ = shared_ptr<ActiveObjectManagerAce> ();



ActiveObjectManagerAce::
ActiveObjectManagerAce() :
    ActiveObjectManager()
{
  waitForTerminateSemaphore_ =
    shared_ptr<ACE_Semaphore> (new ACE_Semaphore (0));
}



ActiveObjectManagerAce::
~ActiveObjectManagerAce()
{

}



void
ActiveObjectManagerAce::
notifyActiveObjectStateChange (ActiveObject * ao,
                               ActiveObjectState previousState)
{
  internalDataMutex_.acquire();
  
  ActiveObjectManager::notifyActiveObjectStateChange (ao, previousState);
  
  int numAO =
    ActiveObjectManager::getActiveObjectVector().size();
  // int numUnknown = ActiveObjectManager::getActiveObjectStateSet(UNKNOWN).size();
  // int numInitializing = ActiveObjectManager::getActiveObjectStateSet(INITIALIZING).size();
  // int numInitialized = ActiveObjectManager::getActiveObjectStateSet(INITIALIZED).size();
  // int numStopping = ActiveObjectManager::getActiveObjectStateSet(STOPPING).size();
  int numStopped =
    ActiveObjectManager::getActiveObjectStateSet (STOPPED).size();
  // int numPausing = ActiveObjectManager::getActiveObjectStateSet(PAUSING).size();
  // int numPaused = ActiveObjectManager::getActiveObjectStateSet(PAUSED).size();
  // int numRunning = ActiveObjectManager::getActiveObjectStateSet(RUNNING).size();
  
  // std::cerr << "numAO...........= " << numAO << std::endl;
  // std::cerr << "numUnknown......= " << numUnknown << std::endl;
  // std::cerr << "numInitializing.= " << numInitializing << std::endl;
  // std::cerr << "numInitialized..= " << numInitialized << std::endl;
  // std::cerr << "numStopping.....= " << numStopping << std::endl;
  // std::cerr << "numStopped......= " << numStopped << std::endl;
  // std::cerr << "numPausing......= " << numPausing << std::endl;
  // std::cerr << "numPaused.......= " << numPaused << std::endl;
  // std::cerr << "numRunning......= " << numRunning << std::endl;
  
  if (numAO == numStopped) {
    waitForTerminateSemaphore_->release();
  }
  
  internalDataMutex_.release();
  
}



shared_ptr<ActiveObject> ActiveObjectManagerAce::createActiveObject()
{
  shared_ptr<ActiveObject> ao = shared_ptr<ActiveObject> (new ActiveObjectAce (this));
  addActiveObject (ao);
  return ao;
  
}



shared_ptr<ActiveObjectManagerAce> ActiveObjectManagerAce::getInstance()
{
  if (! instance_)
    instance_ = shared_ptr<ActiveObjectManagerAce> (new ActiveObjectManagerAce());
  return instance_;
}



void ActiveObjectManagerAce::waitForActiveObjectsToStop()
{
  waitForTerminateSemaphore_->acquire();
}



vector<shared_ptr<ActiveObject> > ActiveObjectManagerAce::getActiveObjectVector()
{
  internalDataMutex_.acquire();
  vector<shared_ptr<ActiveObject> > ret = ActiveObjectManager::getActiveObjectVector();
  internalDataMutex_.release();
  return ret;
}



set<shared_ptr<ActiveObject> > ActiveObjectManagerAce::getActiveObjectStateSet (ActiveObjectState s)
{
  internalDataMutex_.acquire();
  set<shared_ptr<ActiveObject> > ret = ActiveObjectManager::getActiveObjectStateSet (s);
  internalDataMutex_.release();
  return ret;
}



void ActiveObjectManagerAce::addActiveObject (shared_ptr<ActiveObject> ao)
{
  internalDataMutex_.acquire();
  ActiveObjectManager::addActiveObject (ao);
  internalDataMutex_.release();
}



void ActiveObjectManagerAce::stopAllActiveObjects()
{
  vector<shared_ptr<ActiveObject> > aov = getActiveObjectVector();
  
  vector<shared_ptr<ActiveObject> >::iterator it;
  
  for (it = aov.begin(); it != aov.end(); it++) {
    shared_ptr<ActiveObject> ao = *it;
    ao->stop();
  }
}