SPAR/AIModule/SparAIModule/Utils/Process.h

Go to the documentation of this file.

#pragma once
#include "Utils.h."
#include "Component.h"
#include "Event.h"
#include "Logger.h"
#include "SafeList.h"
#include "SafeListAdaptor.h"
#include <boost/iterator/transform_iterator.hpp>
#include <cassert>
#include <iostream>
#include <algorithm>

class Process : public Component
{
protected:
  class Mode
  {
  public:
    virtual ~Mode() {} // Useless aside from allowing dynamic_casting of modes

    friend bool operator== (const Mode& mode1, const Mode& mode2) { return &mode1 == &mode2; }
    friend bool operator!= (const Mode& mode1, const Mode& mode2) { return &mode1 != &mode2; }
  
  protected:
    friend class Process;
    Mode() {} // Only possible (non-derived) mode is WaitingToExecute
  };

  class ExecutionMode : public Mode
  {
  };

  class TerminationMode : public Mode
  {
  };
private:
  struct ProcessWrapper;
  struct extract_process_const;

public:
  Process(const Process* parent)
    : m_currentMode(&WaitingToExecute)
    , m_parent(parent)
    , m_childProcessTerminatedEventHandler(*this)
    , m_zombifyOnTerminate(false)
  {
  }

  ~Process()
  {
    assert(m_executingChildProcesses.empty());
  }

  static void zombifyOnTerminate(const Process* process)
  {
    process->m_zombifyOnTerminate = true;
    //ProcessZombification::zombifyOnTerminate(process);
  }

  const Mode& getCurrentMode() const
  {
    return *m_currentMode;
  }

  const ExecutionMode& getExecutionMode() const
  {
    assert(isExecuting());
    return *dynamic_cast<const ExecutionMode*>(m_currentMode);
  }

  const TerminationMode& getTerminationMode() const
  {
    assert(isTerminated());
    return *dynamic_cast<const TerminationMode*>(m_currentMode);
  }

  // Either "waiting to start", "running", or "terminated" (with several possible states when running or terminated)

  bool isWaitingToExecute() const
  {
    return m_currentMode == &WaitingToExecute; 
  }

  bool isExecuting() const
  {
    return dynamic_cast<const ExecutionMode*>(m_currentMode) != NULL;
  }

  bool isTerminated() const
  {
    return dynamic_cast<const TerminationMode*>(m_currentMode) != NULL;
  }

  void execute()
  {
    assert(isWaitingToExecute());

    // Can't execute a process if parent has terminated (or has not yet started)
    if (m_parent == NULL || m_parent->isExecuting())
    {
      m_currentMode = &Executing;

      executeImpl();

      if (isExecuting() && m_parent != NULL)
        m_parent->onChildProcessExecuted(this);
    }
  }

  void externalTerminate()
  {
    terminate(ExternalEvent);
  }

  DECLARE_EVENT(OnTerminate);

#ifdef USE_SPAR_GUI
  DECLARE_EVENT1(OnChildProcessExecuted, const Process*);
#endif

  OnTerminate& getTerminateEvent() const { return m_terminateEvent; }

  size_t getNbChildProcesses() const
  {
    return m_executingChildProcesses.size();
  }

  template <class Function>
  Function for_each_child_process(Function function)
  {
    struct FunctionTraits : std::unary_function<Process*, SafeListBase::FunctionReturn>
    {
      FunctionTraits(Function function) : m_function(function)
      {}
      SafeListBase::FunctionReturn operator()(Process* process) const
      {
        return m_function(process);
      }
      Function m_function;
    };
    FunctionTraits functionTraits(function);
    composite_functor<FunctionTraits, extract_process> composite(functionTraits);
    composite_functor<FunctionTraits, extract_process> composite2 = m_executingChildProcesses.for_each<composite_functor<FunctionTraits, extract_process>>(composite);
    return composite2.m_f1.m_function;
    
    //return m_executingChildProcesses.for_each(composite).m_f1.m_function;
  }

  static const Mode WaitingToExecute;
  static const ExecutionMode Executing;
  static const TerminationMode Success;
  static const TerminationMode ExternalEvent;

  struct TerminateProcess
  {
    typedef SafeListBase::FunctionReturn result_type;

    SafeListBase::FunctionReturn operator()(Process* process) const
    {
      process->externalTerminate();
      return SafeListBase::FunctionReturn();
    }
  };

  friend std::ostream& operator<<(std::ostream& out, const Process& process)
  {
    process.output(out);
    return out;
  }

  // GUI //
  typedef boost::transform_iterator<extract_process_const, ConstSafeListAdaptor<ProcessWrapper>::const_iterator> ProcessIterator;
  std::pair<ProcessIterator, ProcessIterator> getCurrentChildProcesses() const
  {
    ConstSafeListAdaptor<ProcessWrapper> adaptor(m_executingChildProcesses);
    return std::make_pair(ProcessIterator(adaptor.unsafe_begin()), ProcessIterator(adaptor.unsafe_end()));
  }
  virtual std::set<BWAPI::Unit*> getCommandedUnits() const = 0;

protected:
  virtual void output(std::ostream& out) const = 0;

  void changeMode(const ExecutionMode& newMode)
  {
    assert(isExecuting());

    m_currentMode = &newMode;
  }

  void terminate(const TerminationMode& mode);

  virtual void executeImpl() {}

  virtual void terminateImpl() {}

  void onChildProcessExecuted(Process* process) const
  {
    // No duplicates
    assert(std::find(ConstSafeListAdaptor<ProcessWrapper>(m_executingChildProcesses).unsafe_begin(),
                     ConstSafeListAdaptor<ProcessWrapper>(m_executingChildProcesses).unsafe_end(),
                     ProcessWrapper(process)) == ConstSafeListAdaptor<ProcessWrapper>(m_executingChildProcesses).unsafe_end());

    SafeList<ProcessWrapper>::iterator pos = m_executingChildProcesses.add(ProcessWrapper(process));
    ProcessWrapper& wrapper = *pos;
    wrapper.m_posInContainer = pos;
    Process::OnTerminate::SubscriberID sid = process->getTerminateEvent().subscribe(&m_childProcessTerminatedEventHandler, &wrapper);
    unused(sid);
#ifdef _DEBUG_COMPONENT
    wrapper.m_processTerminationID = sid;
#endif
#ifdef USE_SPAR_GUI
    m_childProcessExecutedEvent.raise(process);
#endif
  }

  void onChildProcessTerminated(void* data) const
  {
    ProcessWrapper* wrapper = reinterpret_cast<ProcessWrapper*>(data);
#ifdef _DEBUG_COMPONENT
    wrapper->m_process->getTerminateEvent().unsubscribe(wrapper->m_processTerminationID);
#endif
    m_executingChildProcesses.erase(wrapper->m_posInContainer);
  }

private:
  //class ProcessZombification : public Component
  //{
  //public:
  //  static void zombifyOnTerminate(const Process* process)
  //  {
  //    process->getTerminateEvent().subscribe(&s_processZombification.m_zombifyProcessOnTerminateEventHandler, const_cast<void*>(reinterpret_cast<const void*>(process)));
  //  }
  //  void onTerminate(void* data);
  //private:
  //  static ProcessZombification s_processZombification;
  //  ProcessZombification()
  //    :  m_zombifyProcessOnTerminateEventHandler(*this)
  //  {}
  //  EVENT_HANDLER(ProcessZombification, onTerminate) m_zombifyProcessOnTerminateEventHandler;
  //};

  struct ProcessWrapper
  {
    ProcessWrapper(Process* process)
      : m_process(process) { }

    bool operator==(const ProcessWrapper& other) const
    {
      return m_process == other.m_process;
    }

    Process* const m_process;
    SafeList<ProcessWrapper>::iterator m_posInContainer;

#ifdef _DEBUG_COMPONENT

    Process::OnTerminate::SubscriberID m_processTerminationID;
#endif
  };
  struct extract_process : std::unary_function<ProcessWrapper&,Process*>
  {
    Process* operator()(ProcessWrapper& wrapper) const { return wrapper.m_process; }
  };
  struct extract_process_const : std::unary_function<const ProcessWrapper&,const Process*>
  {
    const Process* operator()(const ProcessWrapper& wrapper) const { return wrapper.m_process; }
  };

  const Process* const m_parent;

  const Mode* m_currentMode;

  EVENT(OnTerminate) m_terminateEvent;


#ifdef USE_SPAR_GUI
  EVENT(OnChildProcessExecuted) m_childProcessExecutedEvent;
#endif

  mutable EVENT_HANDLER(Process, onChildProcessTerminated) m_childProcessTerminatedEventHandler;

  mutable SafeList<ProcessWrapper> m_executingChildProcesses;

  mutable bool m_zombifyOnTerminate;
};