SPAR/AIModule/SparAIModule/PersistentUnitGroup.h

Go to the documentation of this file.

#pragma once
#include "../Utils/ReferenceCounted.h"
#include "Utils/Component.h"
#include "Utils/EventHandler.h"
#include "Utils/Event.h"
#include "Utils/Utils.h"
#include "Utils/GroupBase.h"
#include "SparAIContainer.h"
#include "UnitManager.h"
#include <BWAPI.h>
#include <boost/iterator/transform_iterator.hpp>
#include <utility>
#include <hash_set>
#include <set>

class PersistentUnitGroup : public ReferenceCounted, public Component, public GroupBase<PersistentUnitGroup>
{
protected:
  class UnitWrapper;
  //typedef std::set<UnitWrapper> UnitWrapperSet;
  typedef stdext::hash_set<UnitWrapper, UnitWrapperBaseHashCompare> UnitWrapperSet;
  class UnitWrapper : public UnitWrapperBase
  {
  public:
    UnitWrapper(BWAPI::Unit* unit)
      : UnitWrapperBase(unit) {}
  protected:
    friend class PersistentUnitGroup;
    mutable UnitManager::OnIndividualUnitDestroy::SubscriberID m_unitDestroyID;
    UnitWrapperSet::const_iterator m_unitPosInSet;
  };
public:
  //typedef boost::transform_iterator<extract_unit, UnitWrapperSet::const_iterator> const_iterator;
  //typedef boost::transform_iterator<extract_unit, UnitWrapperSet::iterator> iterator;
  typedef UnitWrapperSet::const_iterator const_iterator;
  typedef UnitWrapperSet::iterator iterator;
  
  PersistentUnitGroup(const std::string& name)
    : m_name(name)
    , m_unitDestroyEventHandler(*this)
  {
  }

  template <class iterator>
  PersistentUnitGroup(const std::string& name, iterator begin, iterator end)
    : m_name(name)
    , m_unitDestroyEventHandler(*this)
  {
    for (; begin != end; ++begin)
      insert(*begin);
  }

  ~PersistentUnitGroup();

  bool insert(BWAPI::Unit* unit)
  {
    std::pair<UnitWrapperSet::iterator, bool> p = m_group.insert(UnitWrapper(unit));
    if (p.second)
    {
      p.first->m_unitPosInSet = p.first;
      UnitManager::OnIndividualUnitDestroy::SubscriberID unitManagerID = 
        Spar->getUnitManager().subscribeIndividualUnitDestroy(unit, &m_unitDestroyEventHandler, &(p.first->m_unitPosInSet));
      p.first->m_unitDestroyID = unitManagerID;

      m_unitAddedEvent.raise(unit);
    }
    return p.second;
  }

  bool insert(const_iterator hint, BWAPI::Unit* unit)
  {
    UnitWrapperSet::iterator it = m_group.insert(hint, UnitWrapper(unit));

    it->m_unitPosInSet = it;
    UnitManager::OnIndividualUnitDestroy::SubscriberID unitManagerID = 
      Spar->getUnitManager().subscribeIndividualUnitDestroy(unit, &m_unitDestroyEventHandler, &(it->m_unitPosInSet));
    it->m_unitDestroyID = unitManagerID;

    m_unitAddedEvent.raise(unit);
    
    return true;
  }

  template <class iterator>
  size_t insert(iterator begin, iterator end)
  {
    size_t nb = 0; 
    for (; begin != end; ++begin)
    {
      if(insert(*begin))
        ++nb;
    }
    return nb;
  }

  bool remove(BWAPI::Unit* unit)
  {
    const_iterator it = m_group.find(UnitWrapper(unit));
    const bool exists = (it != m_group.end());
    if (exists)
    {
      remove(it);
    }
    return exists;
  }

  void remove(const_iterator pos)
  {
    BWAPI::Unit* unit = (*pos).getUnit();
    Spar->getUnitManager().unsubscribeIndividualUnitDestroy(unit, (*pos).m_unitDestroyID);
    m_group.erase(pos);
    m_unitRemovedEvent.raise(unit);

    if(m_group.empty())
    {
      m_emptyEvent.raise();
    }
  }

  void clear()
  {
    iterator it = begin();
    iterator nextIt;
    while(it != end())
    {
      nextIt = it;
      ++nextIt;
      remove(it);
      it = nextIt;
    }
  }



  bool contains(BWAPI::Unit* unit) const
  {
    return m_group.find(unit) != m_group.end();
  }

  const_iterator find(BWAPI::Unit* unit) const
  {
    return m_group.find(unit);
  }

  const_iterator begin() const
  {
    //return boost::transform_iterator<extract_unit, UnitWrapperSet::const_iterator>(m_group.begin());
    return m_group.begin();
  }

  const_iterator end() const
  {
    //return boost::transform_iterator<extract_unit, UnitWrapperSet::const_iterator>(m_group.end());
    return m_group.end();
  }

  iterator begin()
  {
    //return boost::transform_iterator<extract_unit, UnitWrapperSet::iterator>(m_group.begin());
    return m_group.begin();
  }

  iterator end()
  {
    //return boost::transform_iterator<extract_unit, UnitWrapperSet::iterator>(m_group.end());
    return m_group.end();
  }

  size_t size() const
  {
          return m_group.size();
  }

  bool empty() const
  {
    return m_group.size() == 0;
  }

  void onUnitDestroy(void* data)
  {
    UnitWrapperSet::iterator* id = reinterpret_cast<UnitWrapperSet::iterator*>(data);
    remove(*id);
  }

  const std::string& getName() const { return m_name; }
  virtual std::string toString() const { return m_name; }

  friend std::ostream& operator<<(std::ostream& out, const PersistentUnitGroup& group);

  DECLARE_EVENT(OnEmpty);
  OnEmpty& getEmptyEvent() const { return m_emptyEvent; }

  DECLARE_EVENT(OnGroupDestroyed);
  OnGroupDestroyed& getGroupDestroyedEvent() const { return m_groupDestroyedEvent; }

  DECLARE_EVENT1(OnUnitAdded, BWAPI::Unit*);
  OnUnitAdded& getUnitAddedEvent() const { return m_unitAddedEvent; }

  DECLARE_EVENT1(OnUnitRemoved, BWAPI::Unit*);
  OnUnitRemoved& getUnitRemovedEvent() const { return m_unitRemovedEvent; }

  static const PersistentUnitGroup EmptyGroup;

protected:
  PersistentUnitGroup(const PersistentUnitGroup& other);
  PersistentUnitGroup& operator=(const PersistentUnitGroup& other) const;

  EVENT(OnEmpty) m_emptyEvent;

  EVENT(OnGroupDestroyed) m_groupDestroyedEvent;

  EVENT(OnUnitAdded) m_unitAddedEvent;

  EVENT(OnUnitRemoved) m_unitRemovedEvent;

  const std::string m_name;

  EVENT_HANDLER(PersistentUnitGroup, onUnitDestroy) m_unitDestroyEventHandler;

  UnitWrapperSet m_group;

private:
  PersistentUnitGroup();
};