Helios Engine 0.1.0
A modular ECS based data-oriented C++23 game engine
 
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Friends | List of all members
helios::ecs::BasicQuery< WorldT, Allocator, Components > Class Template Reference

#include <query.hpp>

Public Types

using ComponentsType = std::conditional_t< details::AllComponentsConst< Components... >, const details::Components, details::Components >
 Components manager type based on whether all components are const-qualified.
 
using WithEntityIterator = details::QueryWithEntityIterator< Components... >
 
using iterator = details::QueryIterator< Components... >
 
using value_type = std::iter_value_t< details::QueryIterator< Components... > >
 
using difference_type = std::iter_difference_t< details::QueryIterator< Components... > >
 
using pointer = typename iterator::pointer
 
using reference = std::iter_reference_t< details::QueryIterator< Components... > >
 
using allocator_type = Allocator
 
using ArchetypeAllocator = typename std::allocator_traits< Allocator >::template rebind_alloc< std::reference_wrapper< const details::Archetype > >
 Rebind allocator for archetype references.
 

Public Member Functions

 BasicQuery (WorldT &world, std::vector< ComponentTypeId, Allocator > with_components, std::vector< ComponentTypeId, Allocator > without_components={}, Allocator alloc={})
 Constructs query with specified filtering criteria.
 
 BasicQuery (const BasicQuery &)=delete
 
 BasicQuery (BasicQuery &&) noexcept=default
 
 ~BasicQuery ()=default
 
BasicQuery & operator= (const BasicQuery &)=delete
 
BasicQuery & operator= (BasicQuery &&) noexcept=default
 
auto WithEntity () &noexcept -> BasicQueryWithEntity< WorldT, Allocator, Components... >
 Creates wrapper for entity-aware iteration.
 
auto Collect () const -> std::vector< value_type >
 
template<typename ResultAlloc >
requires std::same_as<typename ResultAlloc::value_type, std::iter_value_t<details::QueryIterator<Components...>>>
auto CollectWith (ResultAlloc alloc) const -> std::vector< value_type, ResultAlloc >
 
template<typename OutIt >
requires std::output_iterator<OutIt, std::iter_value_t<details::QueryIterator<Components...>>>
void Into (OutIt out) const
 
template<typename Action >
requires utils::ActionFor<Action, std::tuple<details::ComponentAccessType<Components>...>>
void ForEach (const Action &action) const
 
template<typename Action >
requires utils::ActionFor<Action, std::tuple<Entity, details::ComponentAccessType<Components>...>>
void ForEachWithEntity (const Action &action) const
 
template<typename Pred >
requires utils::PredicateFor<Pred, std::tuple<details::ComponentAccessType<Components>...>>
auto Filter (Pred predicate) const &-> utils::FilterAdapter< iterator, Pred >
 
template<typename Func >
requires utils::TransformFor<Func, std::tuple<details::ComponentAccessType<Components>...>>
auto Map (Func transform) const &-> utils::MapAdapter< iterator, Func >
 
auto Take (size_t count) const &-> utils::TakeAdapter< iterator >
 
auto Skip (size_t count) const &-> utils::SkipAdapter< iterator >
 
auto Reverse () const &-> utils::ReverseAdapter< iterator >
 
auto Slide (size_t window_size) const &-> utils::SlideAdapter< iterator >
 
auto Stride (size_t stride) const &-> utils::StrideAdapter< iterator >
 
template<typename OtherIter >
requires utils::IteratorLike<OtherIter>
auto Zip (OtherIter other_begin, OtherIter other_end) const &-> utils::ZipAdapter< iterator, OtherIter >
 
template<typename Pred >
requires utils::PredicateFor<Pred, std::tuple<details::ComponentAccessType<Components>...>>
auto TakeWhile (Pred predicate) const &-> utils::TakeWhileAdapter< iterator, Pred >
 
template<typename Pred >
requires utils::PredicateFor<Pred, std::tuple<details::ComponentAccessType<Components>...>>
auto SkipWhile (Pred predicate) const &-> utils::SkipWhileAdapter< iterator, Pred >
 
auto Enumerate () const &-> utils::EnumerateAdapter< iterator >
 
template<typename Func >
requires utils::InspectorFor<Func, std::tuple<details::ComponentAccessType<Components>...>>
auto Inspect (Func inspector) const &-> utils::InspectAdapter< iterator, Func >
 
auto StepBy (size_t step) const &-> utils::StepByAdapter< iterator >
 
template<typename Pred >
requires utils::PredicateFor<Pred, std::tuple<details::ComponentAccessType<Components>...>>
bool Any (const Pred &predicate) const
 
template<typename Pred >
requires utils::PredicateFor<Pred, std::tuple<details::ComponentAccessType<Components>...>>
bool All (const Pred &predicate) const
 
template<typename Pred >
requires utils::PredicateFor<Pred, std::tuple<details::ComponentAccessType<Components>...>>
bool None (const Pred &predicate) const
 
template<typename Pred >
requires utils::PredicateFor<Pred, std::tuple<details::ComponentAccessType<Components>...>>
size_t CountIf (const Pred &predicate) const
 
template<typename T , typename Func >
requires utils::FolderFor<Func, T, std::tuple<details::ComponentAccessType<Components>...>>
T Fold (T init, const Func &folder) const
 
template<typename Pred >
requires utils::PredicateFor<Pred, std::tuple<details::ComponentAccessType<Components>...>>
auto FindFirst (const Pred &predicate) const -> std::optional< value_type >
 
template<typename Pred >
requires utils::PredicateFor<Pred, std::tuple<details::ComponentAccessType<Components>...>>
auto Partition (const Pred &predicate) const -> std::pair< std::vector< value_type >, std::vector< value_type > >
 
template<typename KeyFunc >
requires utils::TransformFor<KeyFunc, std::tuple<details::ComponentAccessType<Components>...>>
auto MaxBy (const KeyFunc &key_func) const -> std::optional< value_type >
 
template<typename KeyFunc >
requires utils::TransformFor<KeyFunc, std::tuple<details::ComponentAccessType<Components>...>>
auto MinBy (const KeyFunc &key_func) const -> std::optional< value_type >
 
bool Empty () const noexcept
 Checks if any entities match the query.
 
size_t Count () const noexcept
 Gets the number of matching entities.
 
iterator begin () const
 Gets iterator to first matching entity.
 
iterator end () const noexcept
 Gets iterator past the last matching entity.
 
allocator_type get_allocator () const noexcept
 Gets the allocator used by this query.
 

Friends

class BasicQueryWithEntity< WorldT, Allocator, Components... >
 

Detailed Description

template<WorldType WorldT, typename Allocator, ComponentTrait... Components>
requires utils::UniqueTypes<Components...>
class helios::ecs::BasicQuery< WorldT, Allocator, Components >

Definition at line 1088 of file query.hpp.

Member Typedef Documentation

◆ allocator_type

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
using helios::ecs::BasicQuery< WorldT, Allocator, Components >::allocator_type = Allocator
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 1101 of file query.hpp.

◆ ArchetypeAllocator

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
using helios::ecs::BasicQuery< WorldT, Allocator, Components >::ArchetypeAllocator = typename std::allocator_traits<Allocator>::template rebind_alloc< std::reference_wrapper<const details::Archetype> >

Rebind allocator for archetype references.

Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 1104 of file query.hpp.

◆ ComponentsType

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
using helios::ecs::BasicQuery< WorldT, Allocator, Components >::ComponentsType = std::conditional_t<details::AllComponentsConst<Components...>, const details::Components, details::Components>

Components manager type based on whether all components are const-qualified.

Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 1091 of file query.hpp.

◆ difference_type

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
using helios::ecs::BasicQuery< WorldT, Allocator, Components >::difference_type = std::iter_difference_t<details::QueryIterator<Components...> >
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 1098 of file query.hpp.

◆ iterator

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
using helios::ecs::BasicQuery< WorldT, Allocator, Components >::iterator = details::QueryIterator<Components...>
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 1096 of file query.hpp.

◆ pointer

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
using helios::ecs::BasicQuery< WorldT, Allocator, Components >::pointer = typename iterator::pointer
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 1099 of file query.hpp.

◆ reference

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
using helios::ecs::BasicQuery< WorldT, Allocator, Components >::reference = std::iter_reference_t<details::QueryIterator<Components...> >
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 1100 of file query.hpp.

◆ value_type

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
using helios::ecs::BasicQuery< WorldT, Allocator, Components >::value_type = std::iter_value_t<details::QueryIterator<Components...> >
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 1097 of file query.hpp.

◆ WithEntityIterator

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
using helios::ecs::BasicQuery< WorldT, Allocator, Components >::WithEntityIterator = details::QueryWithEntityIterator<Components...>
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 1094 of file query.hpp.

Constructor & Destructor Documentation

◆ BasicQuery() [1/3]

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::UniqueTypes<Components...>
helios::ecs::BasicQuery< WorldT, Allocator, Components >::BasicQuery ( WorldT &  world,
std::vector< ComponentTypeId, Allocator >  with_components,
std::vector< ComponentTypeId, Allocator >  without_components = {},
Allocator  alloc = {} 
)

Constructs query with specified filtering criteria.

Creates query that matches entities with required components and without forbidden ones.

Parameters
worldReference to ECS world
with_componentsComponent types that entities must have
without_componentsComponent types that entities must not have
allocAllocator instance for internal storage
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 1991 of file query.hpp.

1995 : world_(world),
1996 with_components_(std::move(with_components)),
1997 without_components_(std::move(without_components)),
1998 matching_archetypes_(ArchetypeAllocator(alloc)),
1999 alloc_(alloc) {
2000 static_assert(details::ValidWorldComponentAccess<WorldT, Components...>,
2001 "Cannot request mutable component access from const World! "
2002 "Use const-qualified components (e.g., 'const Position&') or pass mutable World.");
2003}
helios::ecs::BasicQuery::ArchetypeAllocator
typename std::allocator_traits< Allocator >::template rebind_alloc< std::reference_wrapper< const details::Archetype > > ArchetypeAllocator
Rebind allocator for archetype references.
Definition query.hpp:1105
helios::ecs::Query
BasicQuery< World, Allocator, Components... > Query
Type alias for query with mutable world access.
Definition query.hpp:2481

◆ BasicQuery() [2/3]

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
helios::ecs::BasicQuery< WorldT, Allocator, Components >::BasicQuery ( const BasicQuery< WorldT, Allocator, Components > &  )
delete

◆ BasicQuery() [3/3]

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
helios::ecs::BasicQuery< WorldT, Allocator, Components >::BasicQuery ( BasicQuery< WorldT, Allocator, Components > &&  )
defaultnoexcept

◆ ~BasicQuery()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
helios::ecs::BasicQuery< WorldT, Allocator, Components >::~BasicQuery ( )
default
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Member Function Documentation

◆ All()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::PredicateFor<Pred, std::tuple<details::ComponentAccessType<Components>...>>
template<typename Pred >
requires utils::PredicateFor<Pred, std::tuple<details::ComponentAccessType<Components>...>>
bool helios::ecs::BasicQuery< WorldT, Allocator, Components >::All ( const Pred &  predicate) const
inline
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 2192 of file query.hpp.

2192 {
2193 for (auto&& result : *this) {
2194 if (!std::apply(predicate, result)) {
2195 return false;
2196 }
2197 }
2198 return true;
2199}

◆ Any()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
template<typename Pred >
requires utils::PredicateFor<Pred, std::tuple<details::ComponentAccessType<Components>...>>
bool helios::ecs::BasicQuery< WorldT, Allocator, Components >::Any ( const Pred &  predicate) const
inline
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 1443 of file query.hpp.

1443 {
1444 return FindFirst(predicate).has_value();
1445 }
helios::ecs::BasicQuery::FindFirst
auto FindFirst(const Pred &predicate) const -> std::optional< value_type >
Definition query.hpp:2178

◆ begin()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::UniqueTypes<Components...>
auto helios::ecs::BasicQuery< WorldT, Allocator, Components >::begin ( ) const
inline

Gets iterator to first matching entity.

Returns
Iterator pointing to first result
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 2317 of file query.hpp.

2317 {
2318 RefreshArchetypes();
2319 return {matching_archetypes_, GetComponents(), 0, 0};
2320}

◆ Collect()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::UniqueTypes<Components...>
auto helios::ecs::BasicQuery< WorldT, Allocator, Components >::Collect ( ) const -> std::vector<value_type>
inline
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 2136 of file query.hpp.

2136 {
2137 std::vector<value_type> result;
2138 result.reserve(Count());
2139 for (auto&& tuple : *this) {
2140 result.push_back(tuple);
2141 }
2142 return result;
2143}
helios::ecs::BasicQuery::Count
size_t Count() const noexcept
Gets the number of matching entities.
Definition query.hpp:2306

◆ CollectWith()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires std::same_as<typename ResultAlloc::value_type, std::iter_value_t<details::QueryIterator<Components...>>>
template<typename ResultAlloc >
requires std::same_as<typename ResultAlloc::value_type, std::iter_value_t<details::QueryIterator<Components...>>>
auto helios::ecs::BasicQuery< WorldT, Allocator, Components >::CollectWith ( ResultAlloc  alloc) const -> std::vector<value_type, ResultAlloc>
inline
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 2149 of file query.hpp.

2150 {
2151 std::vector<value_type, ResultAlloc> result{std::move(alloc)};
2152 result.reserve(Count());
2153 for (auto&& tuple : *this) {
2154 result.push_back(tuple);
2155 }
2156 return result;
2157}

◆ Count()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::UniqueTypes<Components...>
size_t helios::ecs::BasicQuery< WorldT, Allocator, Components >::Count ( ) const
inlinenoexcept

Gets the number of matching entities.

Counts entities across all matching archetypes. Time complexity: O(A) where A is the number of matching archetypes.

Returns
Total count of entities that match the query
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 2306 of file query.hpp.

2306 {
2307 RefreshArchetypes();
2308 size_t count = 0;
2309 for (const auto& archetype_ref : matching_archetypes_) {
2310 count += archetype_ref.get().EntityCount();
2311 }
2312 return count;
2313}

◆ CountIf()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::PredicateFor<Pred, std::tuple<details::ComponentAccessType<Components>...>>
template<typename Pred >
requires utils::PredicateFor<Pred, std::tuple<details::ComponentAccessType<Components>...>>
size_t helios::ecs::BasicQuery< WorldT, Allocator, Components >::CountIf ( const Pred &  predicate) const
inline
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 2205 of file query.hpp.

2205 {
2206 size_t count = 0;
2207 for (auto&& tuple : *this) {
2208 if (std::apply(predicate, tuple)) {
2209 ++count;
2210 }
2211 }
2212 return count;
2213}

◆ Empty()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::UniqueTypes<Components...>
bool helios::ecs::BasicQuery< WorldT, Allocator, Components >::Empty ( ) const
inlinenoexcept

Checks if any entities match the query.

Fast check for query result emptiness without full iteration.

Returns
True if at least one entity matches, false otherwise
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 2299 of file query.hpp.

2299 {
2300 RefreshArchetypes();
2301 return matching_archetypes_.empty() || Count() == 0;
2302}

◆ end()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
iterator helios::ecs::BasicQuery< WorldT, Allocator, Components >::end ( ) const
inlinenoexcept

Gets iterator past the last matching entity.

Returns
End iterator
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 1603 of file query.hpp.

1603 {
1604 return {matching_archetypes_, GetComponents(), matching_archetypes_.size(), 0};
1605 }

◆ Enumerate()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::UniqueTypes<Components...>
auto helios::ecs::BasicQuery< WorldT, Allocator, Components >::Enumerate ( ) const & -> utils::EnumerateAdapter<iterator>
inline
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 2106 of file query.hpp.

2106 {
2107 RefreshArchetypes();
2108 auto begin_iter = iterator(GetMatchingArchetypes(), GetComponents(), 0, 0);
2109 auto end_iter = iterator(GetMatchingArchetypes(), GetComponents(), GetMatchingArchetypes().size(), 0);
2110 return {begin_iter, end_iter};
2111}
helios::ecs::BasicQuery::iterator
details::QueryIterator< Components... > iterator
Definition query.hpp:1096

◆ Filter()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::PredicateFor<Pred, std::tuple<details::ComponentAccessType<Components>...>>
template<typename Pred >
requires utils::PredicateFor<Pred, std::tuple<details::ComponentAccessType<Components>...>>
auto helios::ecs::BasicQuery< WorldT, Allocator, Components >::Filter ( Pred  predicate) const & -> utils::FilterAdapter<iterator, Pred>
inline
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 2042 of file query.hpp.

2043 {
2044 RefreshArchetypes();
2045 auto begin_iter = iterator(matching_archetypes_, GetComponents(), 0, 0);
2046 auto end_iter = iterator(matching_archetypes_, GetComponents(), matching_archetypes_.size(), 0);
2047 return {begin_iter, end_iter, std::move(predicate)};
2048}

◆ FindFirst()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::PredicateFor<Pred, std::tuple<details::ComponentAccessType<Components>...>>
template<typename Pred >
requires utils::PredicateFor<Pred, std::tuple<details::ComponentAccessType<Components>...>>
auto helios::ecs::BasicQuery< WorldT, Allocator, Components >::FindFirst ( const Pred &  predicate) const -> std::optional<value_type>
inline
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 2178 of file query.hpp.

2179 {
2180 for (auto&& result : *this) {
2181 if (std::apply(predicate, result)) {
2182 return result;
2183 }
2184 }
2185 return std::nullopt;
2186}

◆ Fold()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::FolderFor<Func, T, std::tuple<details::ComponentAccessType<Components>...>>
template<typename T , typename Func >
requires utils::FolderFor<Func, T, std::tuple<details::ComponentAccessType<Components>...>>
T helios::ecs::BasicQuery< WorldT, Allocator, Components >::Fold ( T  init,
const Func &  folder 
) const
inline
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 2163 of file query.hpp.

2163 {
2164 for (auto&& tuple : *this) {
2165 init = std::apply(
2166 [&init, &folder](auto&&... components) {
2167 return folder(std::move(init), std::forward<decltype(components)>(components)...);
2168 },
2169 tuple);
2170 }
2171 return init;
2172}

◆ ForEach()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::ActionFor<Action, std::tuple<details::ComponentAccessType<Components>...>>
template<typename Action >
requires utils::ActionFor<Action, std::tuple<details::ComponentAccessType<Components>...>>
void helios::ecs::BasicQuery< WorldT, Allocator, Components >::ForEach ( const Action &  action) const
inline
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 2019 of file query.hpp.

2019 {
2020 for (auto&& result : *this) {
2021 std::apply(action, result);
2022 }
2023}

◆ ForEachWithEntity()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::ActionFor<Action, std::tuple<Entity, details::ComponentAccessType<Components>...>>
template<typename Action >
requires utils::ActionFor<Action, std::tuple<Entity, details::ComponentAccessType<Components>...>>
void helios::ecs::BasicQuery< WorldT, Allocator, Components >::ForEachWithEntity ( const Action &  action) const
inline
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 2029 of file query.hpp.

2029 {
2030 RefreshArchetypes();
2031 auto begin_iter = WithEntityIterator(matching_archetypes_, GetComponents(), 0, 0);
2032 auto end_iter = WithEntityIterator(matching_archetypes_, GetComponents(), matching_archetypes_.size(), 0);
2033 for (auto iter = begin_iter; iter != end_iter; ++iter) {
2034 std::apply([&action](Entity entity, auto&&... components) { action(entity, components...); }, *iter);
2035 }
2036}
helios::ecs::BasicQuery::WithEntityIterator
details::QueryWithEntityIterator< Components... > WithEntityIterator
Definition query.hpp:1094

◆ get_allocator()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
allocator_type helios::ecs::BasicQuery< WorldT, Allocator, Components >::get_allocator ( ) const
inlinenoexcept

Gets the allocator used by this query.

Returns
Copy of the allocator
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 1611 of file query.hpp.

1611{ return alloc_; }

◆ Inspect()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::InspectorFor<Func, std::tuple<details::ComponentAccessType<Components>...>>
template<typename Func >
requires utils::InspectorFor<Func, std::tuple<details::ComponentAccessType<Components>...>>
auto helios::ecs::BasicQuery< WorldT, Allocator, Components >::Inspect ( Func  inspector) const & -> utils::InspectAdapter<iterator, Func>
inline
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 2117 of file query.hpp.

2118 {
2119 RefreshArchetypes();
2120 auto begin_iter = iterator(GetMatchingArchetypes(), GetComponents(), 0, 0);
2121 auto end_iter = iterator(GetMatchingArchetypes(), GetComponents(), GetMatchingArchetypes().size(), 0);
2122 return {begin_iter, end_iter, std::move(inspector)};
2123}

◆ Into()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires std::output_iterator<OutIt, std::iter_value_t<details::QueryIterator<Components...>>>
template<typename OutIt >
requires std::output_iterator<OutIt, std::iter_value_t<details::QueryIterator<Components...>>>
void helios::ecs::BasicQuery< WorldT, Allocator, Components >::Into ( OutIt  out) const
inline
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 2009 of file query.hpp.

2009 {
2010 for (auto&& result : *this) {
2011 *out++ = std::forward<decltype(result)>(result);
2012 }
2013}

◆ Map()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::TransformFor<Func, std::tuple<details::ComponentAccessType<Components>...>>
template<typename Func >
requires utils::TransformFor<Func, std::tuple<details::ComponentAccessType<Components>...>>
auto helios::ecs::BasicQuery< WorldT, Allocator, Components >::Map ( Func  transform) const & -> utils::MapAdapter<iterator, Func>
inline
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 2054 of file query.hpp.

2055 {
2056 RefreshArchetypes();
2057 auto begin_iter = iterator(GetMatchingArchetypes(), GetComponents(), 0, 0);
2058 auto end_iter = iterator(GetMatchingArchetypes(), GetComponents(), GetMatchingArchetypes().size(), 0);
2059 return {begin_iter, end_iter, std::move(transform)};
2060}

◆ MaxBy()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::TransformFor<KeyFunc, std::tuple<details::ComponentAccessType<Components>...>>
template<typename KeyFunc >
requires utils::TransformFor<KeyFunc, std::tuple<details::ComponentAccessType<Components>...>>
auto helios::ecs::BasicQuery< WorldT, Allocator, Components >::MaxBy ( const KeyFunc &  key_func) const -> std::optional<value_type>
inline
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 2239 of file query.hpp.

2240 {
2241 auto iter = begin();
2242 const auto end_iter = end();
2243
2244 if (iter == end_iter) {
2245 return std::nullopt;
2246 }
2247
2248 std::optional<value_type> max_element;
2249 max_element.emplace(*iter);
2250 auto max_key = std::apply(key_func, *max_element);
2251 ++iter;
2252
2253 while (iter != end_iter) {
2254 auto current = *iter;
2255 auto current_key = std::apply(key_func, current);
2256 if (current_key > max_key) {
2257 max_key = current_key;
2258 max_element.emplace(current);
2259 }
2260 ++iter;
2261 }
2262
2263 return max_element;
2264}
helios::ecs::BasicQuery::begin
iterator begin() const
Gets iterator to first matching entity.
Definition query.hpp:2317
helios::ecs::BasicQuery::end
iterator end() const noexcept
Gets iterator past the last matching entity.
Definition query.hpp:1603

◆ MinBy()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::TransformFor<KeyFunc, std::tuple<details::ComponentAccessType<Components>...>>
template<typename KeyFunc >
requires utils::TransformFor<KeyFunc, std::tuple<details::ComponentAccessType<Components>...>>
auto helios::ecs::BasicQuery< WorldT, Allocator, Components >::MinBy ( const KeyFunc &  key_func) const -> std::optional<value_type>
inline
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 2270 of file query.hpp.

2271 {
2272 auto iter = begin();
2273 const auto end_iter = end();
2274
2275 if (iter == end_iter) {
2276 return std::nullopt;
2277 }
2278
2279 std::optional<value_type> min_element;
2280 min_element.emplace(*iter);
2281 auto min_key = std::apply(key_func, *min_element);
2282 ++iter;
2283
2284 while (iter != end_iter) {
2285 auto current = *iter;
2286 auto current_key = std::apply(key_func, current);
2287 if (current_key < min_key) {
2288 min_key = current_key;
2289 min_element.emplace(current);
2290 }
2291 ++iter;
2292 }
2293
2294 return min_element;
2295}

◆ None()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
template<typename Pred >
requires utils::PredicateFor<Pred, std::tuple<details::ComponentAccessType<Components>...>>
bool helios::ecs::BasicQuery< WorldT, Allocator, Components >::None ( const Pred &  predicate) const
inline
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 1477 of file query.hpp.

1477 {
1478 return !Any(predicate);
1479 }
helios::ecs::BasicQuery::Any
bool Any(const Pred &predicate) const
Definition query.hpp:1443

◆ operator=() [1/2]

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
BasicQuery & helios::ecs::BasicQuery< WorldT, Allocator, Components >::operator= ( BasicQuery< WorldT, Allocator, Components > &&  )
defaultnoexcept

◆ operator=() [2/2]

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
BasicQuery & helios::ecs::BasicQuery< WorldT, Allocator, Components >::operator= ( const BasicQuery< WorldT, Allocator, Components > &  )
delete
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

◆ Partition()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::PredicateFor<Pred, std::tuple<details::ComponentAccessType<Components>...>>
template<typename Pred >
requires utils::PredicateFor<Pred, std::tuple<details::ComponentAccessType<Components>...>>
auto helios::ecs::BasicQuery< WorldT, Allocator, Components >::Partition ( const Pred &  predicate) const -> std::pair<std::vector<value_type>, std::vector<value_type>>
inline
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 2219 of file query.hpp.

2220 {
2221 std::vector<value_type> matched;
2222 std::vector<value_type> not_matched;
2223
2224 for (auto&& tuple : *this) {
2225 if (std::apply(predicate, tuple)) {
2226 matched.push_back(tuple);
2227 } else {
2228 not_matched.push_back(tuple);
2229 }
2230 }
2231
2232 return {std::move(matched), std::move(not_matched)};
2233}

◆ Reverse()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
auto helios::ecs::BasicQuery< WorldT, Allocator, Components >::Reverse ( ) const & -> utils::ReverseAdapter<iterator>
inline
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 1300 of file query.hpp.

1300{ return {begin(), end()}; }

◆ Skip()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::UniqueTypes<Components...>
auto helios::ecs::BasicQuery< WorldT, Allocator, Components >::Skip ( size_t  count) const & -> utils::SkipAdapter<iterator>
inline
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 2073 of file query.hpp.

2073 {
2074 RefreshArchetypes();
2075 auto begin_iter = iterator(matching_archetypes_, GetComponents(), 0, 0);
2076 auto end_iter = iterator(matching_archetypes_, GetComponents(), matching_archetypes_.size(), 0);
2077 return {begin_iter, end_iter, count};
2078}

◆ SkipWhile()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::PredicateFor<Pred, std::tuple<details::ComponentAccessType<Components>...>>
template<typename Pred >
requires utils::PredicateFor<Pred, std::tuple<details::ComponentAccessType<Components>...>>
auto helios::ecs::BasicQuery< WorldT, Allocator, Components >::SkipWhile ( Pred  predicate) const & -> utils::SkipWhileAdapter<iterator, Pred>
inline
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 2096 of file query.hpp.

2097 {
2098 RefreshArchetypes();
2099 auto begin_iter = iterator(matching_archetypes_, GetComponents(), 0, 0);
2100 auto end_iter = iterator(matching_archetypes_, GetComponents(), matching_archetypes_.size(), 0);
2101 return {begin_iter, end_iter, std::move(predicate)};
2102}

◆ Slide()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
auto helios::ecs::BasicQuery< WorldT, Allocator, Components >::Slide ( size_t  window_size) const & -> utils::SlideAdapter<iterator>
inline
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 1314 of file query.hpp.

1314 {
1315 return {begin(), end(), window_size};
1316 }

◆ StepBy()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::UniqueTypes<Components...>
auto helios::ecs::BasicQuery< WorldT, Allocator, Components >::StepBy ( size_t  step) const & -> utils::StepByAdapter<iterator>
inline
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 2127 of file query.hpp.

2127 {
2128 RefreshArchetypes();
2129 auto begin_iter = iterator(matching_archetypes_, GetComponents(), 0, 0);
2130 auto end_iter = iterator(matching_archetypes_, GetComponents(), matching_archetypes_.size(), 0);
2131 return {begin_iter, end_iter, step};
2132}

◆ Stride()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
auto helios::ecs::BasicQuery< WorldT, Allocator, Components >::Stride ( size_t  stride) const & -> utils::StrideAdapter<iterator>
inline
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 1330 of file query.hpp.

1330{ return {begin(), end(), stride}; }

◆ Take()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::UniqueTypes<Components...>
auto helios::ecs::BasicQuery< WorldT, Allocator, Components >::Take ( size_t  count) const & -> utils::TakeAdapter<iterator>
inline
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 2064 of file query.hpp.

2064 {
2065 RefreshArchetypes();
2066 auto begin_iter = iterator(matching_archetypes_, GetComponents(), 0, 0);
2067 auto end_iter = iterator(matching_archetypes_, GetComponents(), matching_archetypes_.size(), 0);
2068 return {begin_iter, end_iter, count};
2069}

◆ TakeWhile()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::PredicateFor<Pred, std::tuple<details::ComponentAccessType<Components>...>>
template<typename Pred >
requires utils::PredicateFor<Pred, std::tuple<details::ComponentAccessType<Components>...>>
auto helios::ecs::BasicQuery< WorldT, Allocator, Components >::TakeWhile ( Pred  predicate) const & -> utils::TakeWhileAdapter<iterator, Pred>
inline
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 2084 of file query.hpp.

2085 {
2086 RefreshArchetypes();
2087 auto begin_iter = iterator(matching_archetypes_, GetComponents(), 0, 0);
2088 auto end_iter = iterator(matching_archetypes_, GetComponents(), matching_archetypes_.size(), 0);
2089 return {begin_iter, end_iter, std::move(predicate)};
2090}

◆ WithEntity()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
auto helios::ecs::BasicQuery< WorldT, Allocator, Components >::WithEntity ( ) & -> BasicQueryWithEntity<WorldT, Allocator, Components...>
inlinenoexcept

Creates wrapper for entity-aware iteration.

Returns a wrapper that provides iterators returning entity + components.

Note
Only callable on lvalue queries to prevent dangling references.
Warning
Calling on rvalue query results in undefined behavior. Create a named query variable first.
Returns
BasicQueryWithEntity wrapper for this query
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 1132 of file query.hpp.

1132 {
1133 return BasicQueryWithEntity<WorldT, Allocator, Components...>(*this);
1134 }

◆ Zip()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
template<typename OtherIter >
requires utils::IteratorLike<OtherIter>
auto helios::ecs::BasicQuery< WorldT, Allocator, Components >::Zip ( OtherIter  other_begin,
OtherIter  other_end 
) const & -> utils::ZipAdapter<iterator, OtherIter>
inline
Examples
/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/query.hpp.

Definition at line 1348 of file query.hpp.

1348 {
1349 return {begin(), end(), std::move(other_begin), std::move(other_end)};
1350 }

Friends And Related Symbol Documentation

◆ BasicQueryWithEntity< WorldT, Allocator, Components... >

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
friend class BasicQueryWithEntity< WorldT, Allocator, Components... >
friend

Definition at line 1642 of file query.hpp.