ComponentManager.cpp

Go to the documentation of this file.

#include <Poco/ScopedLock.h>

#include "ComponentManager.hpp"
#include "TaskManagerEmptyException.hpp"
#include "TaskWaitObjectWrapper.hpp"
#include "ThreadAlreadyRunException.hpp"

#include <unistd.h>

#define COMPONENT_WAIT_TIME 10

namespace HCE
{
  namespace component
  {
    Poco::SharedPtr<ComponentBase> ComponentManager::getFreeComponent()
    {
      Poco::SharedPtr<ComponentBase> retComponent;
      insertComponentMutex.lock();
      typename std::vector<Poco::SharedPtr<ComponentBase> >::iterator it;
      while(retComponent.isNull())
      {
        for(it = componentsList.begin(); it != componentsList.end(); ++it)
        {
          if(!((*it)->getIsBusy()))
          {
            (*it)->setIsBusy(true);
            retComponent = (*it);
            break;
          }
        }
        usleep(COMPONENT_WAIT_TIME);
      }
      insertComponentMutex.unlock();
      return retComponent;
    }

    void ComponentManager::addComponent(Poco::SharedPtr<ComponentBase> componentPtr)
    {
      if(!componentPtr.isNull())
      {
        insertComponentMutex.lock();
        componentsList.push_back(componentPtr);
        insertComponentMutex.unlock();
      }
    }

    void ComponentManager::setTaskManager(Poco::SharedPtr<Poco::TaskManager> taskManager)
    {
      if(_taskManager.isNull())
      {
        _taskManager = taskManager;
      }
    }

    void ComponentManager::addTask(Poco::SharedPtr<TaskWaitObject> task)
    {
      if(_taskManager.isNull())
      {
        throw TaskManagerEmptyException("TaskManagerEmpty"); 
      }
      else
      {
        Poco::ScopedLock<Poco::FastMutex> sLock(incomeDataMutex); 
        taskQueue.push(task);
        conditionVar.signal();
      }
    }

    void ComponentManager::clearTaskQueue()
    {
      Poco::ScopedLock<Poco::FastMutex> sLock(incomeDataMutex); 
      while(!taskQueue.empty())
      {
        taskQueue.pop();
      }
    }

    void ComponentManager::start()
    {
      if(!ownThread.isRunning())
      {
        ownThread.start(*this);
      }
      else
      {
        throw ThreadAlreadyRunException("ThreadAlreadyRun");
      }
    }

    void ComponentManager::stop() 
    {
      exitFlag = true;
      Poco::ScopedLock<Poco::FastMutex> sLock(incomeDataMutex); 
      conditionVar.signal();
    }
    

    void ComponentManager::run()
    {
      Poco::SharedPtr<ComponentBase> localObjectPtr;
      while(!exitFlag)
      {
        incomeDataMutex.lock();
        while(!taskQueue.empty())
        {
          Poco::SharedPtr<TaskWaitObject> taskPtr = taskQueue.front();
          taskQueue.pop();
          incomeDataMutex.unlock();
          localObjectPtr = getFreeComponent();
//------------------------ insert task ---------------------------------------------------------------------------      
          TaskWaitObjectWrapper *taskWrapper = new TaskWaitObjectWrapper(taskPtr, localObjectPtr, componentMutex);
          while(true)
          {
            try
            {
              _taskManager->start(taskWrapper);
              break;
            }
            catch(Poco::NoThreadAvailableException &excp)
            {
              usleep(COMPONENT_WAIT_TIME);
            }
            catch(Poco::Exception &exp)
            {
//            std::string what = exp.what();
              usleep(COMPONENT_WAIT_TIME);
            }
          }
//------------------------ insert task END ----------------------------------------------------------------------- 
          incomeDataMutex.lock();
        }
        if(exitFlag)
        {
          incomeDataMutex.unlock();
          break;
        }
        conditionVar.wait(incomeDataMutex);
        incomeDataMutex.unlock();
      }
      if(!_threadPool.isNull())
      {
        _threadPool->stopAll();
        _threadPool->joinAll();
      }
    }
  }
}