pair_lookup.h

#pragma once
#include "gaia/config/config.h"
 
#include "gaia/cnt/darray_ext.h"
#include "gaia/cnt/map.h"
#include "gaia/cnt/set.h"
#include "gaia/ecs/id.h"
 
namespace gaia {
  namespace ecs {
    using PairLookupMap = cnt::map<EntityLookupKey, cnt::set<EntityLookupKey>>;
 
    class PairLookup {
      PairLookupMap m_relToTgt;
      PairLookupMap m_tgtToRel;
 
    public:
      void clear() {
        m_relToTgt = {};
        m_tgtToRel = {};
      }
 
      GAIA_NODISCARD const cnt::set<EntityLookupKey>* targets(Entity relation) const {
        const auto it = m_relToTgt.find(EntityLookupKey(relation));
        if (it == m_relToTgt.end())
          return nullptr;
 
        return &it->second;
      }
 
      GAIA_NODISCARD const cnt::set<EntityLookupKey>* relations(Entity target) const {
        const auto it = m_tgtToRel.find(EntityLookupKey(target));
        if (it == m_tgtToRel.end())
          return nullptr;
 
        return &it->second;
      }
 
      GAIA_NODISCARD auto relation_begin() const {
        return m_relToTgt.begin();
      }
 
      GAIA_NODISCARD auto relation_end() const {
        return m_relToTgt.end();
      }
 
      void add_pair(Entity relation, Entity target) {
        const auto relKey = EntityLookupKey(relation);
        const auto tgtKey = EntityLookupKey(target);
        const auto allKey = EntityLookupKey(All);
 
        auto& relTargets = m_relToTgt[relKey];
        const bool relHadTargets = !relTargets.empty();
        relTargets.insert(tgtKey);
 
        auto& tgtRelations = m_tgtToRel[tgtKey];
        const bool tgtHadRelations = !tgtRelations.empty();
        tgtRelations.insert(relKey);
 
        if (!tgtHadRelations)
          m_relToTgt[allKey].insert(tgtKey);
        if (!relHadTargets)
          m_tgtToRel[allKey].insert(relKey);
      }
 
      static bool del_bucket_entry(PairLookupMap& map, EntityLookupKey source, EntityLookupKey remove) {
        auto itTargets = map.find(source);
        if (itTargets == map.end())
          return false;
 
        auto& targets = itTargets->second;
        targets.erase(remove);
        return targets.empty();
      }
 
      static void collect_bucket_entries(
          const PairLookupMap& map, EntityLookupKey source, cnt::darray_ext<EntityLookupKey, 64>& out) {
        const auto it = map.find(source);
        if (it == map.end())
          return;
 
        for (auto entry: it->second)
          out.push_back(entry);
      }
 
      void del_pair(Entity relation, Entity target) {
        const auto relKey = EntityLookupKey(relation);
        const auto tgtKey = EntityLookupKey(target);
        const auto allKey = EntityLookupKey(All);
 
        const bool relEmpty = del_bucket_entry(m_relToTgt, relKey, tgtKey);
        const bool tgtEmpty = del_bucket_entry(m_tgtToRel, tgtKey, relKey);
        if (tgtEmpty)
          (void)del_bucket_entry(m_relToTgt, allKey, tgtKey);
        if (relEmpty)
          (void)del_bucket_entry(m_tgtToRel, allKey, relKey);
      }
 
      void del_entity_pairs(Entity entity) {
        const auto key = EntityLookupKey(entity);
 
        cnt::darray_ext<EntityLookupKey, 64> targets;
        cnt::darray_ext<EntityLookupKey, 64> relations;
        collect_bucket_entries(m_relToTgt, key, targets);
        collect_bucket_entries(m_tgtToRel, key, relations);
 
        for (auto target: targets)
          del_pair(entity, target.entity());
        for (auto relation: relations)
          del_pair(relation.entity(), entity);
 
        m_relToTgt.erase(key);
        m_tgtToRel.erase(key);
      }
    };
  } // namespace ecs
} // namespace gaia