SPAR/AIModule/SparAIModule/Utils/ProcessContainer.h

Go to the documentation of this file.

#pragma once
#include "Process.h"
#include "SafeList.h"
#include "../SparAIContainer.h"

template <class ProcessType, bool ZombifyOnTerminate=true>
class ProcessContainer : public EventHandler
{
public:
  ProcessContainer(const Component& owner)
    : EventHandler(owner)
    , m_process(NULL)
  {
  }
  ProcessContainer(const Component& owner, ProcessType* process)
    : EventHandler(owner)
    , m_process(NULL)
  {
    setProcess(process);
  }
  ~ProcessContainer()
  {
    if (m_process != NULL)
    {
      m_process->getTerminateEvent().unsubscribe(m_id);
      if (ZombifyOnTerminate)
        delete m_process;
    }
  }
  void setProcess(ProcessType* process)
  {
    if (m_process != process)
    {
      if (m_process != NULL)
      {
        m_process->getTerminateEvent().unsubscribe(m_id);
      }
      m_process = process;
      if (m_process != NULL)
      {
        if (ZombifyOnTerminate)
          Process::zombifyOnTerminate(m_process);

        m_id = m_process->getTerminateEvent().subscribe(this, m_process);
      }
    }
  }
  virtual void onEvent(void* data, boost::tuple<>&)
  {
    const ProcessType* process = reinterpret_cast<const ProcessType*>(data);
    if (m_process == process)
    {
      // m_process just ended
      m_process = NULL;
    }
  }
  ProcessContainer& operator=(ProcessType* process)
  {
    setProcess(process);
    return *this;
  }
  ProcessType* getProcess() { return m_process; }
  const ProcessType* getProcess() const { return m_process; }
  operator ProcessType*() { return m_process; }
  operator const ProcessType*() const { return m_process; }
  ProcessType* operator->() { return m_process; }
  const ProcessType* operator->() const { return m_process; }
  ProcessType& operator*() { return *m_process; }
  const ProcessType& operator*() const { return *m_process; }
private:
  ProcessType* m_process;
  Process::OnTerminate::SubscriberID m_id;
};

template <class ProcessType, bool ZombifyOnTerminate=true>
class ProcessContainerList : public EventHandler
{
private:
  struct ProcessWrapper
  {
    ProcessWrapper(ProcessType* process)
      : m_process(process)
    {}
    typename SafeList<ProcessWrapper>::iterator m_posInList;
    ProcessType* m_process;
    Process::OnTerminate::SubscriberID m_id;
  };

public:
  ProcessContainerList(const Component& owner)
    : EventHandler(owner)
  {
  }
  ~ProcessContainerList()
  {
    if (ZombifyOnTerminate)
    {
      struct DeleteProcess
      {
        DeleteProcess(ProcessContainerList& list)
          : m_list(list)
        {}
        SafeListBase::FunctionReturn operator()(ProcessWrapper& processWrapper) const
        {
          processWrapper.m_process->getTerminateEvent().unsubscribe(processWrapper.m_id);
          delete processWrapper.m_process;
          //m_list.m_processes.erase(processWrapper.m_posInList);
  
          return SafeListBase::FunctionReturn();
        }
      private:
        ProcessContainerList& m_list;
      };
      m_processes.for_each(DeleteProcess(*this));
    }
  }
  void add(ProcessType* process)
  {
    assert(process != NULL);

    SafeList<ProcessWrapper>::iterator it = m_processes.add(ProcessWrapper(process));
    ProcessWrapper& processWrapper = *it;
    processWrapper.m_posInList = it;
    processWrapper.m_id = process->getTerminateEvent().subscribe(this, &processWrapper);
    if (ZombifyOnTerminate)
      Process::zombifyOnTerminate(process);
  }
  virtual void onEvent(void* data, boost::tuple<>&)
  {
    ProcessWrapper* processWrapper = reinterpret_cast<ProcessWrapper*>(data);
#ifdef _DEBUG_COMPONENT
    processWrapper->m_process->getTerminateEvent().unsubscribe(processWrapper->m_id);
#endif
    m_processes.erase(processWrapper->m_posInList);
  }
  template <class Function>
  Function for_each_process(Function function)
  {
    struct InnerFunction
    {
      InnerFunction(Function function)
        : m_function(function)
      {}
      SafeListBase::FunctionReturn operator()(ProcessWrapper& processWrapper)
      {
        return m_function(processWrapper.m_process);
      }
      SafeListBase::ConstFunctionReturn operator()(const ProcessWrapper& processWrapper)
      {
        return m_function(processWrapper.m_process);
      }
    private:
      Function m_function;
    };
    return m_processes.for_each(InnerFunction(function));
  }
  size_t size() const
  {
    return m_processes.size();
  }
  bool empty() const
  {
    return m_processes.empty();
  }
private:
  SafeList<ProcessWrapper> m_processes;
};