SPAR/AIModule/SparAIModule/PerceptualState/Locations/Static/PrimitiveLocationBase.h

Go to the documentation of this file.

#pragma once
#include "StaticLocationBase.h"
#include "../../../UnitManager.h"
#include "../../../../Utils/Functors.hpp"
#include <boost/iterator/transform_iterator.hpp>
#include <boost/iterator/filter_iterator.hpp>
#include <hash_map>
//#include <list>

// Can't use boost::unordered_multimap since resizing it apparently invalidates all iterators

class PrimitiveLocation;
class StaticLocation;

class PrimitiveLocationBase : public virtual StaticLocationBase
{
private:
  class BaseUnitWrapper
  {
  public:
    BaseUnitWrapper(UnitLocationData* unit)
      : m_unit(unit)
    {}
  protected:
    friend class PrimitiveLocation;
    UnitLocationData* const m_unit;
    UnitManager::OnIndividualUnitEvade::SubscriberID m_unitEvadeID;
    UnitManager::OnIndividualUnitDestroy::SubscriberID m_unitDestroyID;
    UnitManager::OnIndividualUnitMorph::SubscriberID m_unitMorphID;
    UnitManager::OnIndividualUnitRenegade::SubscriberID m_unitRenegadeID;
  };
  template <class UnitType>
  class UnitWrapper;
  template <class UnitType>
  class UnitWrapper : public BaseUnitWrapper
  {
  public:
    UnitWrapper(UnitType* unit)
      : BaseUnitWrapper(unit)
    {}
    UnitType* getUnit() { return static_cast<UnitType*>(m_unit); }
    const UnitType* getUnit() const { return static_cast<const UnitType*>(m_unit); }

    typename stdext::hash_multimap<BWAPI::UnitType, UnitWrapper<UnitType>>::const_iterator m_posInContainer;
  };
protected:
  friend class PrimitiveLocation;
  friend class StaticLocation;

  template <class UnitType>
  struct extract_unit : std::unary_function<UnitWrapper<UnitType>, UnitType*>
  {
    UnitType* operator()(UnitWrapper<UnitType>& unitWrapper) const
    {
      return unitWrapper.getUnit();
    }
  };
  template <class UnitType>
  struct extract_unit_const : std::unary_function<UnitWrapper<UnitType>, const UnitType*>
  {
    extract_unit_const() {}
    extract_unit_const(const extract_unit<UnitType>&) {}

    const UnitType* operator()(const UnitWrapper<UnitType>& unitWrapper) const
    {
      return unitWrapper.getUnit();
    }
  };

  // Should be generalized to any container (at the moment it works on maps)... but I don't feel like doing it.
  template <class FirstLevelIterator, class SecondLevelIterator>
  class multi_level_iterator : public std::iterator<std::forward_iterator_tag, 
                                                    typename SecondLevelIterator::value_type,
                                                    std::ptrdiff_t,
                                                    typename SecondLevelIterator::pointer,
                                                    typename SecondLevelIterator::reference>
  {
  public:
    multi_level_iterator() {}
    multi_level_iterator(FirstLevelIterator inputIt, FirstLevelIterator endInputIt)
      : m_currentInputIt(inputIt)
      , m_endInputIt(endInputIt)
    {
      if (m_currentInputIt != m_endInputIt)
      {
        m_currentOutputIt = SecondLevelIterator(m_currentInputIt->second.begin());
        findNext();
      }
    }
    template <class OtherFirstLevelIterator, class OtherSecondLevelIterator>
    multi_level_iterator(const multi_level_iterator<OtherFirstLevelIterator, OtherSecondLevelIterator>& other)
      : m_currentInputIt(other.m_currentInputIt)
      , m_endInputIt(other.m_endInputIt)
      , m_currentOutputIt(other.m_currentOutputIt)
    {
    }
    typename SecondLevelIterator::reference operator*() const
    {
      return *m_currentOutputIt;
    }
    multi_level_iterator& operator++()
    {
      ++m_currentOutputIt;
      findNext();
      return *this;
    }
    multi_level_iterator operator++(int)
    {
      multi_level_iterator copy(*this);
      ++(*this);
      return copy;
    }
    bool operator== (const multi_level_iterator& other) const
    {
      assert(other.m_currentInputIt == other.m_endInputIt); // other must be end()

      return (m_currentInputIt == other.m_currentInputIt);
    }
    bool operator!= (const multi_level_iterator& other) const
    {
      assert(other.m_currentInputIt == other.m_endInputIt); // other must be end()

      return (m_currentInputIt != other.m_currentInputIt);
    }
    multi_level_iterator& operator=(const multi_level_iterator& other)
    {
      m_endInputIt = other.m_endInputIt;
      m_currentInputIt = other.m_currentInputIt;
      m_currentOutputIt = other.m_currentOutputIt;
      return *this;
    }
  private:
    template <class OtherFirstLevelIterator, class OtherSecondLevelIterator> friend class multi_level_iterator;
    bool findNext()
    {
      bool found = false;
      if (m_currentOutputIt != SecondLevelIterator(m_currentInputIt->second.end()))
      {
        found = true;
      }
      else
      {
        while (!found && ++m_currentInputIt != m_endInputIt)
        {
          m_currentOutputIt = SecondLevelIterator(m_currentInputIt->second.begin());
          if (m_currentOutputIt != SecondLevelIterator(m_currentInputIt->second.end()))
            found = true;
        }
      }
      return found;
    }

    FirstLevelIterator m_endInputIt;
    FirstLevelIterator m_currentInputIt;
    SecondLevelIterator m_currentOutputIt;
  };

  struct WrapperIsBuilding
  {
    template <class UnitWrapperType>
    bool operator()(const UnitWrapperType& wrapper) const
    {
      return wrapper.getUnit()->getType().isBuilding();
    }
  };

  typedef boost::transform_iterator<extract_pair_second<stdext::hash_multimap<BWAPI::UnitType, UnitWrapper<OwnUnit>>::iterator::value_type>, 
                                    stdext::hash_multimap<BWAPI::UnitType, UnitWrapper<OwnUnit>>::iterator> 
          own_unit_wrapper_iterator;
  typedef boost::transform_iterator<extract_unit<OwnUnit>,
                                    own_unit_wrapper_iterator>
          own_unit_iterator;
  typedef boost::transform_iterator<extract_pair_second_const<stdext::hash_multimap<BWAPI::UnitType, UnitWrapper<OwnUnit>>::const_iterator::value_type>, 
                                    stdext::hash_multimap<BWAPI::UnitType, UnitWrapper<OwnUnit>>::const_iterator> 
          own_unit_wrapper_const_iterator;
  typedef boost::transform_iterator<extract_unit_const<OwnUnit>,
                                    own_unit_wrapper_const_iterator>
          own_unit_const_iterator;
  typedef own_unit_const_iterator
          own_unit_type_const_iterator;
  typedef boost::filter_iterator<IsBuilding<OwnUnit>, own_unit_const_iterator>
          own_building_const_iterator;

  typedef boost::transform_iterator<extract_pair_second<stdext::hash_multimap<BWAPI::UnitType, UnitWrapper<EnemyUnit>>::iterator::value_type>, 
                                    stdext::hash_multimap<BWAPI::UnitType, UnitWrapper<EnemyUnit>>::iterator> 
          enemy_unit_wrapper_iterator;
  typedef boost::filter_iterator<WrapperIsBuilding, enemy_unit_wrapper_iterator>
          enemy_building_wrapper_iterator;
  typedef boost::transform_iterator<extract_unit<EnemyUnit>,
                                    enemy_unit_wrapper_iterator>
          enemy_unit_iterator;
  typedef enemy_unit_iterator
          enemy_unit_type_iterator;
  typedef boost::transform_iterator<extract_unit<EnemyUnit>, enemy_building_wrapper_iterator>
          enemy_building_iterator;
  typedef boost::transform_iterator<extract_pair_second_const<stdext::hash_multimap<BWAPI::UnitType, UnitWrapper<EnemyUnit>>::const_iterator::value_type>, 
                                    stdext::hash_multimap<BWAPI::UnitType, UnitWrapper<EnemyUnit>>::const_iterator> 
          enemy_unit_wrapper_const_iterator;
  typedef boost::filter_iterator<WrapperIsBuilding, enemy_unit_wrapper_const_iterator>
          enemy_building_wrapper_const_iterator;
  typedef boost::transform_iterator<extract_unit_const<EnemyUnit>,
                                    enemy_unit_wrapper_const_iterator>
          enemy_unit_const_iterator;
  typedef enemy_unit_const_iterator
          enemy_unit_type_const_iterator;
  typedef boost::transform_iterator<extract_unit_const<EnemyUnit>, enemy_building_wrapper_const_iterator>
          enemy_building_const_iterator;

  typedef boost::transform_iterator<extract_pair_second<stdext::hash_multimap<BWAPI::UnitType, UnitWrapper<NeutralUnit>>::iterator::value_type>, 
                                    stdext::hash_multimap<BWAPI::UnitType, UnitWrapper<NeutralUnit>>::iterator> 
          neutral_unit_wrapper_iterator;
  typedef boost::filter_iterator<WrapperIsBuilding, neutral_unit_wrapper_iterator>
          neutral_building_wrapper_iterator;
  typedef boost::transform_iterator<extract_unit<NeutralUnit>,
                                    neutral_unit_wrapper_iterator>
          neutral_unit_iterator;
  typedef neutral_unit_iterator
          neutral_unit_type_iterator;
  typedef boost::transform_iterator<extract_unit<NeutralUnit>, neutral_building_wrapper_iterator>
          neutral_building_iterator;
  typedef boost::transform_iterator<extract_pair_second_const<stdext::hash_multimap<BWAPI::UnitType, UnitWrapper<NeutralUnit>>::const_iterator::value_type>, 
                                    stdext::hash_multimap<BWAPI::UnitType, UnitWrapper<NeutralUnit>>::const_iterator> 
          neutral_unit_wrapper_const_iterator;
  typedef boost::filter_iterator<WrapperIsBuilding, neutral_unit_wrapper_const_iterator>
          neutral_building_wrapper_const_iterator;
  typedef boost::transform_iterator<extract_unit_const<NeutralUnit>,
                                    neutral_unit_wrapper_const_iterator>
          neutral_unit_const_iterator;
  typedef neutral_unit_const_iterator
          neutral_unit_type_const_iterator;
  typedef boost::transform_iterator<extract_unit_const<NeutralUnit>, neutral_building_wrapper_const_iterator>
          neutral_building_const_iterator;
};