helios::ecs::details::QueryState Struct Reference

Query state that caches archetype matching results. More...

#include <query_cache.hpp>

Public Member Functions
	QueryState () noexcept=default
	QueryState (const QueryState &other)
	QueryState (QueryState &&other) noexcept
	~QueryState ()=default
QueryState &	operator= (const QueryState &other)
QueryState &	operator= (QueryState &&other) noexcept

Public Attributes
std::vector< std::reference_wrapper< const Archetype > >	matching_archetypes
	Archetypes that match this query.
std::vector< size_t >	archetype_generations
	Generation of each matched archetype when cached.
std::vector< ComponentTypeId >	with_component_types
	Required component types (sorted)
std::vector< ComponentTypeId >	without_component_types
	Forbidden component types (sorted)
size_t	query_generation = 0
	Generation when this state was computed.
size_t	query_hash = 0
	Hash of the query signature.
std::atomic< size_t >	last_access_time {0}
	Last access timestamp for LRU eviction.

Detailed Description

Query state that caches archetype matching results.

Inspired by Bevy's QueryState, this stores pre-computed information about which archetypes match a specific query signature. Each QueryState corresponds to a unique combination of required and forbidden components.

The state includes:

• List of matching archetypes (cached)
• Archetype generation counters (for invalidation detection)
• Component type signature (for efficient lookup)

Definition at line 31 of file query_cache.hpp.

Constructor & Destructor Documentation

QueryState() [1/3]

helios::ecs::details::QueryState::QueryState ( )

defaultnoexcept

QueryState() [2/3]

helios::ecs::details::QueryState::QueryState ( const QueryState &  other )

inline

Definition at line 49 of file query_cache.hpp.

    : matching_archetypes(other.matching_archetypes),
      archetype_generations(other.archetype_generations),
      with_component_types(other.with_component_types),
      without_component_types(other.without_component_types),
      query_generation(other.query_generation),
      query_hash(other.query_hash),
      last_access_time(other.last_access_time.load(std::memory_order_relaxed)) {}

QueryState() [3/3]

helios::ecs::details::QueryState::QueryState ( QueryState &&  other )

inlinenoexcept

Definition at line 58 of file query_cache.hpp.

    : matching_archetypes(std::move(other.matching_archetypes)),
      archetype_generations(std::move(other.archetype_generations)),
      with_component_types(std::move(other.with_component_types)),
      without_component_types(std::move(other.without_component_types)),
      query_generation(other.query_generation),
      query_hash(other.query_hash),
      last_access_time(other.last_access_time.load(std::memory_order_relaxed)) {}

~QueryState()

helios::ecs::details::QueryState::~QueryState ( )

default

Member Function Documentation

operator=() [1/2]

QueryState & helios::ecs::details::QueryState::operator= ( const QueryState &  other )

inline

Definition at line 67 of file query_cache.hpp.

                                                                {
  if (this == &other) [[unlikely]] {
    return *this;
  }
 
  matching_archetypes = other.matching_archetypes;
  archetype_generations = other.archetype_generations;
  with_component_types = other.with_component_types;
  without_component_types = other.without_component_types;
  query_generation = other.query_generation;
  query_hash = other.query_hash;
  last_access_time.store(other.last_access_time.load(std::memory_order_relaxed), std::memory_order_relaxed);
 
  return *this;
}

operator=() [2/2]

QueryState & helios::ecs::details::QueryState::operator= ( QueryState &&  other )

inlinenoexcept

Definition at line 83 of file query_cache.hpp.

                                                                    {
  if (this == &other) [[unlikely]] {
    return *this;
  }
 
  matching_archetypes = std::move(other.matching_archetypes);
  archetype_generations = std::move(other.archetype_generations);
  with_component_types = std::move(other.with_component_types);
  without_component_types = std::move(other.without_component_types);
  query_generation = other.query_generation;
  query_hash = other.query_hash;
  last_access_time.store(other.last_access_time.load(std::memory_order_relaxed), std::memory_order_relaxed);
 
  return *this;
}

Member Data Documentation

archetype_generations

std::vector<size_t> helios::ecs::details::QueryState::archetype_generations

Generation of each matched archetype when cached.

Definition at line 33 of file query_cache.hpp.

last_access_time

std::atomic<size_t> helios::ecs::details::QueryState::last_access_time {0}

mutable

Last access timestamp for LRU eviction.

Definition at line 38 of file query_cache.hpp.

{0};       ///< Last access timestamp for LRU eviction

matching_archetypes

std::vector<std::reference_wrapper<const Archetype> > helios::ecs::details::QueryState::matching_archetypes

Archetypes that match this query.

Definition at line 32 of file query_cache.hpp.

query_generation

size_t helios::ecs::details::QueryState::query_generation = 0

Generation when this state was computed.

Definition at line 36 of file query_cache.hpp.

query_hash

size_t helios::ecs::details::QueryState::query_hash = 0

Hash of the query signature.

Definition at line 37 of file query_cache.hpp.

with_component_types

std::vector<ComponentTypeId> helios::ecs::details::QueryState::with_component_types

Required component types (sorted)

Definition at line 34 of file query_cache.hpp.

without_component_types

std::vector<ComponentTypeId> helios::ecs::details::QueryState::without_component_types

Forbidden component types (sorted)

Definition at line 35 of file query_cache.hpp.