SPAR/AIModule/SparAIModule/Utils/Component.h

Go to the documentation of this file.

#pragma once
#ifdef _DEBUG_COMPONENT
  #include "Logger.h"
  #include "EventHandler.h"
  #include "Event.h"
  #include "Task.h"
  #include <set>
  #include <BWAPI.h>
#endif

class Component
{
public:
  Component() {}

#ifndef _DEBUG_COMPONENT

  virtual ~Component() {}

#else

  Component(const Component&)
    : m_pendingSubscriptions()
    , m_pendingTasks()
  {}

  struct Subscription
  {
    Subscription(const EventHandlerBase* eventHandler, EventBase* ev)
      : m_eventHandler(eventHandler)
      , m_event(ev)
      , m_eventHandlerTypeInfo(typeid(*eventHandler))
      , m_eventTypeInfo(typeid(*ev))
    {}
    const EventHandlerBase* m_eventHandler;
    EventBase* m_event;
    const type_info& m_eventHandlerTypeInfo;
    const type_info& m_eventTypeInfo;

    friend bool operator< (const Subscription& subscription1, const Subscription& subscription2)
    {
      if (subscription1.m_eventHandler < subscription2.m_eventHandler)
        return true;
      else if (subscription1.m_eventHandler == subscription2.m_eventHandler)
        return subscription1.m_event < subscription2.m_event;
      else 
        return false;
    }
  };

  struct Task
  {
    Task(const RunnableTask* task)
      : m_task(task)
      //, m_taskTypeName(typeid(*task).name())
    {}
    const RunnableTask* const m_task;
    //const char* const m_taskTypeName;

    friend bool operator< (const Task& task1, const Task& task2)
    {
      return task1.m_task < task2.m_task;
    }
  };

  virtual ~Component()
  {
    verifyPendingSubscriptions("ERROR Component::~Component(): Make sure to unsubscribe EventHandler \"%s\" from event \"%s\" before its owner is deleted.");
    verifyPendingTasks("ERROR Component::~Component(): Make sure to deactivate task \"%s\" before its owner is deleted.");

    for (std::multiset<Subscription>::const_iterator it = m_pendingSubscriptions.begin(); it != m_pendingSubscriptions.end(); ++it)
    {
      it->m_event->onOwnerDeleted(this);
    }
  }
  void verifyPendingSubscriptions(const char* error) const
  {
    for (std::multiset<Subscription>::const_iterator it = m_pendingSubscriptions.begin(); it != m_pendingSubscriptions.end(); ++it)
    {
      SPAR_LOG(LogTypes::GENERAL_ERROR, error, 
        it->m_eventHandlerTypeInfo.name(), it->m_eventTypeInfo.name());
    }
  }
  void verifyPendingTasks(const char* error) const
  {
    for (std::set<Task>::const_iterator it = m_pendingTasks.begin(); it != m_pendingTasks.end(); ++it)
    {
      SPAR_LOG(LogTypes::GENERAL_ERROR, error, 
        typeid(*it->m_task).name());
    }
    // Does not work since tasks are removed from the owner upon destruction but stay in the scheduler
    // (this was done to keep the same behavior in both debug and release).
    //if (m_pendingTasks.empty())
    //{
    //  assert(!ownsAtLeastOneActiveTask());
    //}
  }
  void onEventSubscribe(const EventHandlerBase* eventHandler, EventBase* ev) const
  {
    m_pendingSubscriptions.insert(Subscription(eventHandler, ev));
  }
  void onEventUnsubscribe(const EventHandlerBase* eventHandler, EventBase* ev) const
  {
    std::multiset<Subscription>::iterator it = m_pendingSubscriptions.find(Subscription(eventHandler, ev));
    if (it == m_pendingSubscriptions.end())
    {
      SPAR_LOG(LogTypes::GENERAL_ERROR, "ERROR Component::onEventUnsubscribe(): EventHandler \"%\" has not yet subscribed to event \"%s\"", 
        typeid(*eventHandler).name(), typeid(*ev).name());
    }
    else
    {
      m_pendingSubscriptions.erase(it);
    }
  }
  void onEventDeleted(const EventHandlerBase* eventHandler, EventBase* ev) const
  {
    m_pendingSubscriptions.erase(Subscription(eventHandler, ev));
  }
  void onActivateTask(const RunnableTask* task) const
  {
    std::pair<std::set<Task>::iterator, bool> it = m_pendingTasks.insert(Task(task));
    if (!it.second)
    {
      SPAR_LOG(LogTypes::GENERAL_ERROR, "ERROR Component::onActivateTask(): Task \"%s\" has already been activated", 
        typeid(*task).name());
    }
  }
  void onDeactivateTask(const RunnableTask* task) const
  {
    size_t n = m_pendingTasks.erase(Task(task));
    if (n == 0)
    {
      SPAR_LOG(LogTypes::GENERAL_ERROR, "ERROR Component::onDeactivateTask(): Task \"%s\" has not yet been activated", 
        typeid(*task).name());
    }
  }

  void onDeleteTask(const RunnableTask* task) const
  {
    m_pendingTasks.erase(Task(task));
  }

protected:
  bool ownsAtLeastOneActiveTask() const;

  mutable std::multiset<Subscription> m_pendingSubscriptions;
  mutable std::set<Task> m_pendingTasks;
#endif
};