observer_registry.h

#pragma once
#include "gaia/config/config.h"
 
#include "gaia/cnt/darray.h"
#include "gaia/cnt/darray_ext.h"
#include "gaia/cnt/ilist.h"
#include "gaia/cnt/map.h"
#include "gaia/cnt/set.h"
#include "gaia/ecs/observer.h"
 
#if GAIA_OBSERVERS_ENABLED
namespace gaia {
  namespace ecs {
    class World;
    class Archetype;
    class ObserverBuilder;
 
    class ObserverRegistry {
      friend class ObserverBuilder;
 
      struct DiffObserverIndex {
        cnt::map<EntityLookupKey, cnt::darray<Entity>> direct;
        cnt::map<EntityLookupKey, cnt::darray<Entity>> sourceTerm;
        cnt::map<EntityLookupKey, cnt::darray<Entity>> traversalRelation;
        cnt::map<EntityLookupKey, cnt::darray<Entity>> pairRelation;
        cnt::map<EntityLookupKey, cnt::darray<Entity>> pairTarget;
        cnt::darray<Entity> all;
        cnt::darray<Entity> global;
 
        GAIA_NODISCARD bool empty() const {
          return direct.empty() && sourceTerm.empty() && traversalRelation.empty() && pairRelation.empty() &&
                 pairTarget.empty() && all.empty() && global.empty();
        }
      };
 
      struct PropagatedTargetCacheKey {
        Entity bindingRelation = EntityBad;
        Entity traversalRelation = EntityBad;
        Entity rootTarget = EntityBad;
        QueryTravKind travKind = QueryTravKind::None;
        uint8_t travDepth = QueryTermOptions::TravDepthUnlimited;
 
        GAIA_NODISCARD size_t hash() const {
          size_t seed = EntityLookupKey(bindingRelation).hash();
          seed ^= EntityLookupKey(traversalRelation).hash() + 0x9e3779b9u + (seed << 6u) + (seed >> 2u);
          seed ^= EntityLookupKey(rootTarget).hash() + 0x9e3779b9u + (seed << 6u) + (seed >> 2u);
          seed ^= size_t(travKind) + 0x9e3779b9u + (seed << 6u) + (seed >> 2u);
          seed ^= size_t(travDepth) + 0x9e3779b9u + (seed << 6u) + (seed >> 2u);
          return seed;
        }
 
        GAIA_NODISCARD bool operator==(const PropagatedTargetCacheKey& other) const {
          return bindingRelation == other.bindingRelation && traversalRelation == other.traversalRelation &&
                 rootTarget == other.rootTarget && travKind == other.travKind && travDepth == other.travDepth;
        }
      };
 
      struct PropagatedTargetCacheEntry {
        uint32_t bindingRelationVersion = 0;
        uint32_t traversalRelationVersion = 0;
        cnt::darray<Entity> targets;
      };
 
    public:
      struct DiffDispatcher {
        struct Snapshot {
          Entity observer = EntityBad;
          ObserverEvent event = ObserverEvent::OnAdd;
          bool monitorsQuery = false;
          uint32_t matchesBeforeIdx = UINT32_MAX;
        };
 
        struct MatchCacheEntry {
          ObserverRuntimeData* pObsRepresentative = nullptr;
          QueryInfo* pQueryInfoRepresentative = nullptr;
          uint64_t queryHash = 0;
          cnt::darray<Entity> matches;
        };
 
        struct TargetNarrowCacheEntry {
          ObserverPlan::DiffPlan::DispatchKind kind = ObserverPlan::DiffPlan::DispatchKind::LocalTargets;
          Entity bindingRelation = EntityBad;
          Entity traversalRelation = EntityBad;
          QueryTravKind travKind = QueryTravKind::None;
          uint8_t travDepth = QueryTermOptions::TravDepthUnlimited;
          QueryEntityArray triggerTerms{};
          uint8_t triggerTermCount = 0;
          cnt::darray<Entity> targets;
        };
 
        struct Context {
          ObserverEvent event = ObserverEvent::OnAdd;
          cnt::darray<Snapshot> observers;
          cnt::darray<MatchCacheEntry> matchesBeforeCache;
          cnt::darray<Entity> targets;
          bool active = false;
          bool targeted = false;
          bool targetsAddedAfterPrepare = false;
          bool targetsRemovedAfterPrepare = false;
          bool resetTraversalCaches = false;
        };
 
        static void collect_query_matches(World& world, ObserverRuntimeData& obs, cnt::darray<Entity>& out);
 
        static void collect_query_target_matches(
            World& world, ObserverRuntimeData& obs, EntitySpan targets, cnt::darray<Entity>& out);
 
        static void add_valid_targets(World& world, cnt::darray<Entity>& out, EntitySpan targets);
 
        static void copy_target_narrow_plan(const ObserverRuntimeData& obs, TargetNarrowCacheEntry& entry);
 
        GAIA_NODISCARD static bool
        same_target_narrow_plan(const ObserverRuntimeData& obs, const TargetNarrowCacheEntry& entry);
 
        static void normalize_targets(cnt::darray<Entity>& targets);
 
        GAIA_NODISCARD static uint64_t query_hash(ObserverRuntimeData& obs);
 
        GAIA_NODISCARD static bool same_query_ctx(const QueryCtx& left, const QueryCtx& right);
 
        template <typename TMatchCache>
        GAIA_NODISCARD static int32_t find_match_cache_entry(TMatchCache& cache, ObserverRuntimeData& obs);
 
        GAIA_NODISCARD static Context prepare(
            ObserverRegistry& registry, World& world, ObserverEvent event, EntitySpan terms,
            EntitySpan targetEntities = {});
 
        GAIA_NODISCARD static Context prepare_add_new(ObserverRegistry& registry, World& world, EntitySpan terms);
 
        static void add_targets(World& world, Context& ctx, EntitySpan targets);
 
        static void finish(World& world, Context&& ctx);
      };
 
      struct DirectDispatcher {
        static void on_add(
            ObserverRegistry& registry, World& world, const Archetype& archetype, EntitySpan entsAdded,
            EntitySpan targets);
 
        static void on_del(
            ObserverRegistry& registry, World& world, const Archetype& archetype, EntitySpan entsRemoved,
            EntitySpan targets);
 
        static void on_set(ObserverRegistry& registry, World& world, Entity term, EntitySpan targets);
      };
 
      struct SharedDispatch {
        template <bool DiffOnly, typename TObserverMap, typename TObserverList>
        static void collect_from_map(
            ObserverRegistry& registry, World& world, const TObserverMap& map, Entity term, uint64_t matchStamp,
            TObserverList& out);
 
        template <typename TObserverList>
        static void collect_diff_from_list(
            ObserverRegistry& registry, World& world, const cnt::darray<Entity>& observers, uint64_t matchStamp,
            TObserverList& out);
 
        template <typename TObserverMap>
        GAIA_NODISCARD static bool has_terms(const TObserverMap& map, EntitySpan terms) {
          for (auto term: terms) {
            const auto it = map.find(EntityLookupKey(term));
            if (it != map.end() && !it->second.empty())
              return true;
          }
 
          return false;
        }
 
        template <typename TObserverMap>
        GAIA_NODISCARD static bool has_pair_relations(World& world, const TObserverMap& map, EntitySpan terms);
 
        template <typename TObserverMap, typename TObserverList>
        static void collect_for_event_term(
            ObserverRegistry& registry, World& world, const TObserverMap& map, Entity term, uint64_t matchStamp,
            TObserverList& out);
 
        template <typename TObserverMap, typename TObserverList>
        static void collect_for_is_target(
            ObserverRegistry& registry, World& world, const TObserverMap& map, Entity target, uint64_t matchStamp,
            TObserverList& out);
 
        template <typename Func>
        static void each_inherited_term(World& world, Entity baseEntity, Func&& func);
 
        template <typename TObserverMap>
        GAIA_NODISCARD static bool has_semantic_is_terms(World& world, const TObserverMap& map, EntitySpan terms);
 
        template <typename TObserverMap>
        GAIA_NODISCARD static bool has_inherited_terms(World& world, const TObserverMap& map, EntitySpan terms);
 
        template <typename TObserverMap, typename TObserverList>
        static void collect_for_inherited_terms(
            ObserverRegistry& registry, World& world, const TObserverMap& map, Entity baseEntity, uint64_t matchStamp,
            TObserverList& out);
 
        static void execute_targets(World& world, ObserverRuntimeData& obs, EntitySpan targets, ObserverEvent event);
 
        GAIA_NODISCARD static bool matches_direct_targets(
            ObserverRuntimeData& obs, const Archetype& archetype, EntitySpan targets, QueryInfo* pQueryInfo = nullptr);
      };
 
      using DiffDispatchCtx = DiffDispatcher::Context;
 
    private:
      struct ObserverRuntimeSlot {
        uint32_t idx = 0;
        uint32_t gen = 0;
        ObserverRuntimeData runtime;
 
        ObserverRuntimeSlot(uint32_t index, uint32_t generation): idx(index), gen(generation) {}
 
        GAIA_NODISCARD static ObserverRuntimeSlot
        create(uint32_t index, uint32_t generation, [[maybe_unused]] void* pContext) {
          return ObserverRuntimeSlot(index, generation);
        }
 
        GAIA_NODISCARD static Entity handle(const ObserverRuntimeSlot& slot) {
          return Entity(slot.idx, slot.gen, false, false);
        }
      };
 
      using ObserverRuntimeSlots = cnt::paged_ilist<ObserverRuntimeSlot, Entity>;
 
      cnt::darray<ObserverRuntimeData*> m_candidate_observers;
      cnt::darray<cnt::darray<ObserverRuntimeData*>*> m_nested_candidate_observers;
      uint32_t m_candidate_depth = 0;
      ObserverRuntimeSlots m_observer_runtime_slots;
      cnt::map<EntityLookupKey, Entity> m_observer_data;
      cnt::darray<Entity> m_retired_observer_data;
      uint32_t m_dispatch_depth = 0;
      cnt::map<EntityLookupKey, cnt::darray<Entity>> m_observer_map_add;
      cnt::map<EntityLookupKey, cnt::darray<Entity>> m_observer_map_del;
      cnt::map<EntityLookupKey, cnt::darray<Entity>> m_observer_map_set;
      bool m_hasOnSetObservers = false;
      cnt::map<EntityLookupKey, cnt::darray<Entity>> m_observer_map_add_is;
      cnt::map<EntityLookupKey, cnt::darray<Entity>> m_observer_map_del_is;
      DiffObserverIndex m_diff_index_add;
      DiffObserverIndex m_diff_index_del;
      cnt::map<PropagatedTargetCacheKey, PropagatedTargetCacheEntry> m_propagated_target_cache;
      uint64_t m_current_match_stamp = 0;
 
      class CandidateScope final {
        ObserverRegistry& m_registry;
        cnt::darray<ObserverRuntimeData*>* m_pCandidates = nullptr;
 
      public:
        explicit CandidateScope(ObserverRegistry& registry): m_registry(registry) {
          const auto depth = m_registry.m_candidate_depth++;
          if (depth == 0) {
            m_pCandidates = &m_registry.m_candidate_observers;
          } else {
            const auto nestedIdx = depth - 1;
            if (nestedIdx == m_registry.m_nested_candidate_observers.size())
              m_registry.m_nested_candidate_observers.push_back(new cnt::darray<ObserverRuntimeData*>());
            m_pCandidates = m_registry.m_nested_candidate_observers[nestedIdx];
          }
          m_pCandidates->clear();
        }
 
        GAIA_NODISCARD cnt::darray<ObserverRuntimeData*>& candidates() {
          return *m_pCandidates;
        }
 
        ~CandidateScope() {
          GAIA_ASSERT(m_registry.m_candidate_depth > 0);
          --m_registry.m_candidate_depth;
        }
 
        CandidateScope(CandidateScope&&) = delete;
        CandidateScope(const CandidateScope&) = delete;
        CandidateScope& operator=(CandidateScope&&) = delete;
        CandidateScope& operator=(const CandidateScope&) = delete;
      };
 
      class DispatchScope final {
        ObserverRegistry& m_registry;
 
      public:
        explicit DispatchScope(ObserverRegistry& registry): m_registry(registry) {
          ++m_registry.m_dispatch_depth;
        }
 
        ~DispatchScope() {
          GAIA_ASSERT(m_registry.m_dispatch_depth > 0);
          if (--m_registry.m_dispatch_depth == 0)
            m_registry.release_retired_observer_data();
        }
 
        DispatchScope(DispatchScope&&) = delete;
        DispatchScope(const DispatchScope&) = delete;
        DispatchScope& operator=(DispatchScope&&) = delete;
        DispatchScope& operator=(const DispatchScope&) = delete;
      };
 
      void release_retired_observer_data() {
        for (auto handle: m_retired_observer_data)
          m_observer_runtime_slots.free(handle);
        m_retired_observer_data.clear();
      }
 
      void retire_observer_data(Entity handle) {
        GAIA_ASSERT(m_observer_runtime_slots.has(handle));
        if (m_dispatch_depth == 0)
          m_observer_runtime_slots.free(handle);
        else
          m_retired_observer_data.push_back(handle);
      }
 
      GAIA_NODISCARD DiffObserverIndex& diff_index(ObserverEvent event) {
        GAIA_ASSERT(event == ObserverEvent::OnAdd || event == ObserverEvent::OnDel);
        return event == ObserverEvent::OnAdd ? m_diff_index_add : m_diff_index_del;
      }
 
      GAIA_NODISCARD const DiffObserverIndex& diff_index(ObserverEvent event) const {
        GAIA_ASSERT(event == ObserverEvent::OnAdd || event == ObserverEvent::OnDel);
        return event == ObserverEvent::OnAdd ? m_diff_index_add : m_diff_index_del;
      }
 
      GAIA_NODISCARD static ObserverEvent structural_event(ObserverEvent event, QueryOpKind op) {
        if (op != QueryOpKind::Not || event == ObserverEvent::OnSet || event == ObserverEvent::None)
          return event;
        return event == ObserverEvent::OnAdd ? ObserverEvent::OnDel : ObserverEvent::OnAdd;
      }
 
      GAIA_NODISCARD bool has_observers_for_term(Entity term) const {
        const auto termKey = EntityLookupKey(term);
        return observer_map_has_observers(m_observer_map_add, termKey) ||
               observer_map_has_observers(m_observer_map_del, termKey) ||
               observer_map_has_observers(m_observer_map_set, termKey);
      }
 
      GAIA_NODISCARD static bool can_mark_term_observed(World& world, Entity term);
 
      GAIA_NODISCARD static bool is_semantic_is_term(Entity term, QueryMatchKind matchKind = QueryMatchKind::Semantic);
 
      void mark_term_observed(World& world, Entity term, bool observed);
 
      void remove_observer_indices(World& world, Entity observer);
 
      template <typename TObserverMap>
      static void add_observer_to_map(TObserverMap& map, Entity term, Entity observer) {
        const auto entityKey = EntityLookupKey(term);
        const auto it = map.find(entityKey);
        if (it == map.end())
          map.emplace(entityKey, cnt::darray<Entity>{observer});
        else
          it->second.push_back(observer);
      }
 
      template <typename TObserverMap>
      static void add_observer_to_map_unique(TObserverMap& map, Entity term, Entity observer) {
        const auto entityKey = EntityLookupKey(term);
        const auto it = map.find(entityKey);
        if (it == map.end())
          map.emplace(entityKey, cnt::darray<Entity>{observer});
        else
          add_observer_to_list(it->second, observer);
      }
 
      static void add_observer_to_list(cnt::darray<Entity>& list, Entity observer) {
        if (core::has(list, observer))
          return;
        list.push_back(observer);
      }
 
      static void remove_observer_from_list(cnt::darray<Entity>& list, Entity observer) {
        for (uint32_t i = 0; i < list.size();) {
          if (list[i] == observer)
            core::swap_erase_unsafe(list, i);
          else
            ++i;
        }
      }
      template <typename TObserverMap>
      GAIA_NODISCARD bool observer_map_has_observers(const TObserverMap& map, const EntityLookupKey& termKey) const {
        const auto it = map.find(termKey);
        if (it == map.end())
          return false;
 
        for (const auto observer: it->second) {
          if (m_observer_data.find(EntityLookupKey(observer)) != m_observer_data.end())
            return true;
        }
        return false;
      }
 
      static void collect_traversal_descendants(
          World& world, Entity relation, Entity root, QueryTravKind travKind, uint8_t travDepth, uint64_t visitStamp,
          cnt::darray<Entity>& outTargets);
 
      static PropagatedTargetCacheEntry& ensure_propagated_targets_cached(
          ObserverRegistry& registry, World& world, const ObserverRuntimeData& obs, Entity changedSource);
 
      static void collect_propagated_targets_cached(
          ObserverRegistry& registry, World& world, const ObserverRuntimeData& obs, Entity changedSource,
          uint64_t visitStamp, cnt::set<EntityLookupKey>& visitedPairs, cnt::darray<Entity>& outTargets);
 
      static void add_propagated_targets_cached(
          ObserverRegistry& registry, World& world, const ObserverRuntimeData& obs, Entity changedSource,
          cnt::darray<Entity>& outTargets);
 
      GAIA_NODISCARD static bool collect_source_traversal_diff_targets(
          ObserverRegistry& registry, World& world, ObserverRuntimeData& obs, EntitySpan changedTerms,
          EntitySpan changedSources, cnt::darray<Entity>& outTargets);
 
      GAIA_NODISCARD static bool collect_diff_targets_for_observer(
          ObserverRegistry& registry, World& world, ObserverRuntimeData& obs, EntitySpan changedTerms,
          EntitySpan changedTargets, cnt::darray<Entity>& outTargets);
 
      GAIA_NODISCARD static bool
      observer_uses_changed_traversal_relation(World& world, const ObserverRuntimeData& obs, EntitySpan changedTerms);
 
      GAIA_NODISCARD static bool is_dynamic_pair_endpoint(EntityId endpoint) {
        return is_wildcard(endpoint) || is_variable(endpoint);
      }
 
      static void pair_endpoint_entities(Entity term, Entity& rel, Entity& tgt) {
        GAIA_ASSERT(term.pair());
        rel = Entity((EntityId)term.id(), 0, false, false);
        tgt = Entity((EntityId)term.gen(), 0, false, false);
      }
 
      GAIA_NODISCARD static bool is_observer_term_globally_dynamic(Entity term) {
        if (term == EntityBad || term == All)
          return true;
 
        if (!term.pair())
          return is_variable((EntityId)term.id());
 
        const bool relDynamic = is_dynamic_pair_endpoint(term.id());
        const bool tgtDynamic = is_dynamic_pair_endpoint(term.gen());
        return relDynamic && tgtDynamic;
      }
 
    public:
      GAIA_NODISCARD bool has_observers(Entity term) const {
        return has_observers_for_term(term);
      }
 
      GAIA_NODISCARD bool has_on_add_observers() const {
        return !m_observer_map_add.empty() || !m_observer_map_add_is.empty() || !m_diff_index_add.empty();
      }
 
      GAIA_NODISCARD bool has_on_del_observers() const {
        return !m_observer_map_del.empty() || !m_observer_map_del_is.empty() || !m_diff_index_del.empty();
      }
 
      GAIA_NODISCARD bool has_on_set_observers(Entity term) const {
        if (!m_hasOnSetObservers)
          return false;
 
        if (observer_map_has_observers(m_observer_map_set, EntityLookupKey(term)))
          return true;
        if (!term.pair())
          return false;
 
        Entity rel, tgt;
        pair_endpoint_entities(term, rel, tgt);
        return observer_map_has_observers(m_observer_map_set, EntityLookupKey(Pair(rel, All))) ||
               observer_map_has_observers(m_observer_map_set, EntityLookupKey(Pair(All, tgt))) ||
               observer_map_has_observers(m_observer_map_set, EntityLookupKey(Pair(All, All)));
      }
 
      void add_diff_observer_term(
          World& world, Entity observer, QueryOpKind op, Entity term, const QueryTermOptions& options);
 
      GAIA_NODISCARD DiffDispatchCtx
      prepare_diff(World& world, ObserverEvent event, EntitySpan terms, EntitySpan targetEntities = {});
 
      GAIA_NODISCARD DiffDispatchCtx prepare_diff_add_new(World& world, EntitySpan terms);
 
      void add_diff_targets(World& world, DiffDispatchCtx& ctx, EntitySpan targets);
 
      void finish_diff(World& world, DiffDispatchCtx&& ctx);
 
      void teardown() {
        for (auto& slot: m_observer_runtime_slots) {
          auto& obs = slot.runtime;
          obs.on_each_func = {};
          obs.query = {};
          obs.plan = {};
          obs.lastMatchStamp = 0;
        }
 
        m_observer_data = {};
        m_observer_runtime_slots = {};
        m_retired_observer_data = {};
        m_dispatch_depth = 0;
        m_candidate_observers = {};
        for (auto* pCandidates: m_nested_candidate_observers)
          delete pCandidates;
        m_nested_candidate_observers = {};
        m_candidate_depth = 0;
        m_observer_map_add = {};
        m_observer_map_del = {};
        m_observer_map_set = {};
        m_hasOnSetObservers = false;
        m_observer_map_add_is = {};
        m_observer_map_del_is = {};
        m_diff_index_add = {};
        m_diff_index_del = {};
        m_propagated_target_cache = {};
      }
 
      ObserverRuntimeData& data_add(Entity observer) {
        const auto key = EntityLookupKey(observer);
        const auto it = m_observer_data.find(key);
        if (it != m_observer_data.end())
          return m_observer_runtime_slots[it->second.id()].runtime;
 
        const auto handle = m_observer_runtime_slots.alloc(nullptr);
        m_observer_data.emplace(key, handle);
        return m_observer_runtime_slots[handle.id()].runtime;
      }
 
      GAIA_NODISCARD ObserverRuntimeData* data_try(Entity observer) {
        const auto it = m_observer_data.find(EntityLookupKey(observer));
        if (it == m_observer_data.end() || !m_observer_runtime_slots.has(it->second))
          return nullptr;
        return &m_observer_runtime_slots[it->second.id()].runtime;
      }
 
      GAIA_NODISCARD const ObserverRuntimeData* data_try(Entity observer) const {
        const auto it = m_observer_data.find(EntityLookupKey(observer));
        if (it == m_observer_data.end() || !m_observer_runtime_slots.has(it->second))
          return nullptr;
        return &m_observer_runtime_slots[it->second.id()].runtime;
      }
 
      GAIA_NODISCARD ObserverRuntimeData& data(Entity observer) {
        auto* pData = data_try(observer);
        GAIA_ASSERT(pData != nullptr);
        return *pData;
      }
 
      GAIA_NODISCARD const ObserverRuntimeData& data(Entity observer) const {
        const auto* pData = data_try(observer);
        GAIA_ASSERT(pData != nullptr);
        return *pData;
      }
 
      void try_mark_term_observed(World& world, Entity term);
 
      void
      add(World& world, Entity term, Entity observer, QueryOpKind op,
          QueryMatchKind matchKind = QueryMatchKind::Semantic);
 
      void del(World& world, Entity term);
 
      void on_add(World& world, const Archetype& archetype, EntitySpan entsAdded, EntitySpan targets);
 
      void on_del(World& world, const Archetype& archetype, EntitySpan entsRemoved, EntitySpan targets);
 
      void on_set(World& world, Entity term, EntitySpan targets);
    };
  } // namespace ecs
} // namespace gaia
#endif