helios::ecs::BasicQueryWithEntity< WorldT, Allocator, Components > Class Template Reference

Wrapper for queries that include entity in iteration. More...

#include <query.hpp>

Public Types
using	iterator = details::QueryWithEntityIterator< Components... >
using	value_type = std::iter_value_t< details::QueryWithEntityIterator< Components... > >
using	difference_type = std::iter_difference_t< details::QueryWithEntityIterator< Components... > >
using	pointer = typename iterator::pointer
using	reference = std::iter_reference_t< details::QueryWithEntityIterator< Components... > >
using	allocator_type = Allocator

Public Member Functions
	BasicQueryWithEntity (BasicQuery< WorldT, Allocator, Components... > &query) noexcept
	Constructs entity-aware query wrapper.
	BasicQueryWithEntity (const BasicQueryWithEntity &)=delete
	BasicQueryWithEntity (BasicQueryWithEntity &&)=delete
	~BasicQueryWithEntity () noexcept=default
BasicQueryWithEntity &	operator= (const BasicQueryWithEntity &)=delete
BasicQueryWithEntity &	operator= (BasicQueryWithEntity &&)=delete
auto	Collect () const -> std::vector< value_type >
template<typename ResultAlloc > requires std::same_as<typename ResultAlloc::value_type, std::iter_value_t<details::QueryWithEntityIterator<Components...>>>
auto	CollectWith (ResultAlloc alloc) const -> std::vector< value_type, ResultAlloc >
auto	CollectEntities () const -> std::vector< Entity >
template<typename ResultAlloc > requires std::same_as<typename ResultAlloc::value_type, Entity>
auto	CollectEntitiesWith (ResultAlloc alloc) const -> std::vector< Entity, ResultAlloc >
	Collects all entities into a vector using a custom allocator.
template<typename OutIt > requires std::output_iterator<OutIt, std::iter_value_t<details::QueryWithEntityIterator<Components...>>>
void	Into (OutIt out)
template<typename Action > requires utils::ActionFor<Action, std::tuple<Entity, details::ComponentAccessType<Components>...>>
void	ForEach (const Action &action)
template<typename KeyFunc > requires utils::TransformFor<KeyFunc, std::tuple<Entity, details::ComponentAccessType<Components>...>>
auto	MaxBy (const KeyFunc &key_func) const -> std::optional< value_type >
template<typename KeyFunc > requires utils::TransformFor<KeyFunc, std::tuple<Entity, details::ComponentAccessType<Components>...>>
auto	MinBy (const KeyFunc &key_func) const -> std::optional< value_type >
template<typename Pred > requires utils::PredicateFor<Pred, std::tuple<Entity, details::ComponentAccessType<Components>...>>
auto	Filter (Pred predicate) const &-> utils::FilterAdapter< iterator, Pred >
template<typename Func > requires utils::TransformFor<Func, std::tuple<Entity, 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 >
template<typename Pred > requires utils::PredicateFor<Pred, std::tuple<Entity, details::ComponentAccessType<Components>...>>
auto	TakeWhile (Pred predicate) const &-> utils::TakeWhileAdapter< iterator, Pred >
template<typename Pred > requires utils::PredicateFor<Pred, std::tuple<Entity, 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<Entity, details::ComponentAccessType<Components>...>>
auto	Inspect (Func inspector) const &-> utils::InspectAdapter< iterator, Func >
auto	StepBy (size_t step) const &-> utils::StepByAdapter< 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<Entity, details::ComponentAccessType<Components>...>>
bool	Any (const Pred &predicate)
template<typename Pred > requires utils::PredicateFor<Pred, std::tuple<Entity, details::ComponentAccessType<Components>...>>
bool	All (const Pred &predicate)
template<typename Pred > requires utils::PredicateFor<Pred, std::tuple<Entity, details::ComponentAccessType<Components>...>>
bool	None (const Pred &predicate)
template<typename Pred > requires utils::PredicateFor<Pred, std::tuple<Entity, details::ComponentAccessType<Components>...>>
auto	FindFirst (const Pred &predicate) -> std::optional< value_type >
template<typename Pred > requires utils::PredicateFor<Pred, std::tuple<Entity, details::ComponentAccessType<Components>...>>
size_t	CountIf (const Pred &predicate)
template<typename Pred > requires utils::PredicateFor<Pred, std::tuple<Entity, details::ComponentAccessType<Components>...>>
auto	Partition (const Pred &predicate) -> std::pair< std::vector< Entity >, std::vector< Entity > >
template<typename KeyExtractor > requires utils::TransformFor<KeyExtractor, std::tuple<Entity, details::ComponentAccessType<Components>...>>
auto	GroupBy (const KeyExtractor &key_extractor) -> std::unordered_map< std::invoke_result_t< KeyExtractor, Entity, details::ComponentAccessType< Components >... >, std::vector< Entity > >
iterator	begin () const
	Gets iterator to first matching entity and components.
iterator	end () const
	Gets iterator past the last matching entity.

Detailed Description

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

Wrapper for queries that include entity in iteration.

Provides iteration interface that returns both entity and components. Supports const-qualified component access for read-only operations.

Note

Not thread-safe.

Template Parameters

WorldT	World type (World or const World), must satisfy WorldType concept
Allocator	Allocator type for internal storage
Components	Requested component access types (may include const qualifiers)

Definition at line 568 of file query.hpp.

Member Typedef Documentation

allocator_type

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>

using helios::ecs::BasicQueryWithEntity< WorldT, Allocator, Components >::allocator_type = Allocator

Examples

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

Definition at line 575 of file query.hpp.

difference_type

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>

using helios::ecs::BasicQueryWithEntity< WorldT, Allocator, Components >::difference_type = std::iter_difference_t<details::QueryWithEntityIterator<Components...> >

Examples

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

Definition at line 572 of file query.hpp.

iterator

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>

using helios::ecs::BasicQueryWithEntity< WorldT, Allocator, Components >::iterator = details::QueryWithEntityIterator<Components...>

Examples

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

Definition at line 570 of file query.hpp.

pointer

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>

using helios::ecs::BasicQueryWithEntity< WorldT, Allocator, Components >::pointer = typename iterator::pointer

Examples

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

Definition at line 573 of file query.hpp.

reference

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>

using helios::ecs::BasicQueryWithEntity< WorldT, Allocator, Components >::reference = std::iter_reference_t<details::QueryWithEntityIterator<Components...> >

Examples

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

Definition at line 574 of file query.hpp.

value_type

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>

using helios::ecs::BasicQueryWithEntity< WorldT, Allocator, Components >::value_type = std::iter_value_t<details::QueryWithEntityIterator<Components...> >

Examples

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

Definition at line 571 of file query.hpp.

Constructor & Destructor Documentation

BasicQueryWithEntity() [1/3]

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>

helios::ecs::BasicQueryWithEntity< WorldT, Allocator, Components >::BasicQueryWithEntity ( BasicQuery< WorldT, Allocator, Components... > &  query )

inlineexplicitnoexcept

Constructs entity-aware query wrapper.

Parameters

query

Reference to the underlying query

Definition at line 581 of file query.hpp.

: query_(query) {}

BasicQueryWithEntity() [2/3]

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>

helios::ecs::BasicQueryWithEntity< WorldT, Allocator, Components >::BasicQueryWithEntity ( const BasicQueryWithEntity< WorldT, Allocator, Components > &  )

delete

BasicQueryWithEntity() [3/3]

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>

helios::ecs::BasicQueryWithEntity< WorldT, Allocator, Components >::BasicQueryWithEntity ( BasicQueryWithEntity< WorldT, Allocator, Components > &&  )

delete

~BasicQueryWithEntity()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>

helios::ecs::BasicQueryWithEntity< WorldT, Allocator, Components >::~BasicQueryWithEntity ( )

defaultnoexcept

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<Entity, details::ComponentAccessType<Components>...>>

template<typename Pred >
requires utils::PredicateFor<Pred, std::tuple<Entity, details::ComponentAccessType<Components>...>>

bool helios::ecs::BasicQueryWithEntity< WorldT, Allocator, Components >::All ( const Pred &  predicate )

inline

Examples

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

Definition at line 1925 of file query.hpp.

                                                                                             {
  for (auto&& result : *this) {
    if (!std::apply(predicate, result)) {
      return false;
    }
  }
  return true;
}

Any()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>

template<typename Pred >
requires utils::PredicateFor<Pred, std::tuple<Entity, details::ComponentAccessType<Components>...>>

bool helios::ecs::BasicQueryWithEntity< WorldT, Allocator, Components >::Any ( const Pred &  predicate )

inline

Examples

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

Definition at line 938 of file query.hpp.

                                                {
    return FindFirst(predicate).has_value();
  }

begin()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::UniqueTypes<Components...>

auto helios::ecs::BasicQueryWithEntity< WorldT, Allocator, Components >::begin ( ) const

inline

Gets iterator to first matching entity and components.

Returns

Iterator pointing to first result

Examples

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

Definition at line 1974 of file query.hpp.

                                                                                            {
  query_.RefreshArchetypes();
  return {query_.GetMatchingArchetypes(), query_.GetComponents(), 0, 0};
}

Collect()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::UniqueTypes<Components...>

auto helios::ecs::BasicQueryWithEntity< 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 1653 of file query.hpp.

                                                                                                           {
  std::vector<value_type> result;
  result.reserve(query_.Count());
  for (auto&& tuple : *this) {
    result.push_back(tuple);
  }
  return result;
}

CollectEntities()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::UniqueTypes<Components...>

auto helios::ecs::BasicQueryWithEntity< WorldT, Allocator, Components >::CollectEntities ( ) const -> std::vector<Entity>

inline

Examples

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

Definition at line 1679 of file query.hpp.

                                                                                                               {
  std::vector<Entity> result;
  result.reserve(query_.Count());
  for (auto&& tuple : *this) {
    result.push_back(std::get<0>(tuple));
  }
  return result;
}

CollectEntitiesWith()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires std::same_as<typename ResultAlloc::value_type, Entity>

template<typename ResultAlloc >
requires std::same_as<typename ResultAlloc::value_type, Entity>

auto helios::ecs::BasicQueryWithEntity< WorldT, Allocator, Components >::CollectEntitiesWith ( ResultAlloc  alloc ) const -> std::vector<Entity, ResultAlloc>

inline

Collects all entities into a vector using a custom allocator.

Warning

When using a frame allocator (via SystemContext::MakeFrameAllocator()), the returned data is only valid for the current frame. All pointers and references to frame-allocated data become invalid after the frame ends. Do not store frame-allocated data in components, resources, or any persistent storage.

Template Parameters

ResultAlloc

STL-compatible allocator type for Entity

Parameters

alloc

Allocator instance to use for the result vector

Returns

Vector of Entity objects using the provided allocator

Examples

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

Definition at line 1692 of file query.hpp.

                                      {
  std::vector<Entity, ResultAlloc> result{std::move(alloc)};
  result.reserve(query_.Count());
  for (auto&& tuple : *this) {
    result.push_back(std::get<0>(tuple));
  }
  return result;
}

CollectWith()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires std::same_as<typename ResultAlloc::value_type, std::iter_value_t<details::QueryWithEntityIterator<Components...>>>

template<typename ResultAlloc >
requires std::same_as<typename ResultAlloc::value_type, std::iter_value_t<details::QueryWithEntityIterator<Components...>>>

auto helios::ecs::BasicQueryWithEntity< 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 1667 of file query.hpp.

                                          {
  std::vector<value_type, ResultAlloc> result{std::move(alloc)};
  result.reserve(query_.Count());
  for (auto&& tuple : *this) {
    result.push_back(tuple);
  }
  return result;
}

CountIf()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::PredicateFor<Pred, std::tuple<Entity, details::ComponentAccessType<Components>...>>

template<typename Pred >
requires utils::PredicateFor<Pred, std::tuple<Entity, details::ComponentAccessType<Components>...>>

size_t helios::ecs::BasicQueryWithEntity< WorldT, Allocator, Components >::CountIf ( const Pred &  predicate )

inline

Examples

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

Definition at line 1911 of file query.hpp.

                                                                                                   {
  size_t count = 0;
  for (auto&& tuple : *this) {
    if (std::apply(predicate, tuple)) {
      ++count;
    }
  }
  return count;
}

end()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::UniqueTypes<Components...>

auto helios::ecs::BasicQueryWithEntity< WorldT, Allocator, Components >::end ( ) const

inline

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 1981 of file query.hpp.

                                                                                          {
  return {query_.GetMatchingArchetypes(), query_.GetComponents(), query_.GetMatchingArchetypes().size(), 0};
}

Enumerate()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::UniqueTypes<Components...>

auto helios::ecs::BasicQueryWithEntity< 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 1798 of file query.hpp.

                                              {
  query_.RefreshArchetypes();
  auto begin_iter = iterator(query_.GetMatchingArchetypes(), query_.GetComponents(), 0, 0);
  auto end_iter =
      iterator(query_.GetMatchingArchetypes(), query_.GetComponents(), query_.GetMatchingArchetypes().size(), 0);
  return {begin_iter, end_iter};
}

Filter()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::PredicateFor<Pred, std::tuple<Entity, details::ComponentAccessType<Components>...>>

template<typename Pred >
requires utils::PredicateFor<Pred, std::tuple<Entity, details::ComponentAccessType<Components>...>>

auto helios::ecs::BasicQueryWithEntity< 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 1726 of file query.hpp.

                                                                 {
  query_.RefreshArchetypes();
  auto begin_iter = iterator(query_.GetMatchingArchetypes(), query_.GetComponents(), 0, 0);
  auto end_iter =
      iterator(query_.GetMatchingArchetypes(), query_.GetComponents(), query_.GetMatchingArchetypes().size(), 0);
  return {begin_iter, end_iter, std::move(predicate)};
}

FindFirst()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::PredicateFor<Pred, std::tuple<Entity, details::ComponentAccessType<Components>...>>

template<typename Pred >
requires utils::PredicateFor<Pred, std::tuple<Entity, details::ComponentAccessType<Components>...>>

auto helios::ecs::BasicQueryWithEntity< WorldT, Allocator, Components >::FindFirst ( const Pred &  predicate ) -> std::optional<value_type>

inline

Examples

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

Definition at line 1835 of file query.hpp.

                               {
  for (auto&& result : *this) {
    if (std::apply(predicate, result)) {
      return result;
    }
  }
  return std::nullopt;
}

ForEach()

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::BasicQueryWithEntity< WorldT, Allocator, Components >::ForEach ( const Action &  action )

inline

Examples

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

Definition at line 1716 of file query.hpp.

                                                                                                {
  for (auto&& result : *this) {
    std::apply(action, result);
  }
}

GroupBy()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::TransformFor<KeyExtractor, std::tuple<Entity, details::ComponentAccessType<Components>...>>

template<typename KeyExtractor >
requires utils::TransformFor<KeyExtractor, std::tuple<Entity, details::ComponentAccessType<Components>...>>

auto helios::ecs::BasicQueryWithEntity< WorldT, Allocator, Components >::GroupBy ( const KeyExtractor &  key_extractor ) -> std::unordered_map<std::invoke_result_t<KeyExtractor, Entity, details::ComponentAccessType<Components>...>, std::vector<Entity>>

inline

Examples

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

Definition at line 1958 of file query.hpp.

                                             {
  using KeyType = std::invoke_result_t<KeyExtractor, Entity, details::ComponentAccessType<Components>...>;
  std::unordered_map<KeyType, std::vector<Entity>> groups;
 
  for (auto&& tuple : *this) {
    auto key = std::apply(key_extractor, tuple);
    groups[key].push_back(std::get<0>(tuple));
  }
 
  return groups;
}

Inspect()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::InspectorFor<Func, std::tuple<Entity, details::ComponentAccessType<Components>...>>

template<typename Func >
requires utils::InspectorFor<Func, std::tuple<Entity, details::ComponentAccessType<Components>...>>

auto helios::ecs::BasicQueryWithEntity< 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 1811 of file query.hpp.

                                                                  {
  query_.RefreshArchetypes();
  auto begin_iter = iterator(query_.GetMatchingArchetypes(), query_.GetComponents(), 0, 0);
  auto end_iter =
      iterator(query_.GetMatchingArchetypes(), query_.GetComponents(), query_.GetMatchingArchetypes().size(), 0);
  return {begin_iter, end_iter, std::move(inspector)};
}

Into()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires std::output_iterator<OutIt, std::iter_value_t<details::QueryWithEntityIterator<Components...>>>

template<typename OutIt >
requires std::output_iterator<OutIt, std::iter_value_t<details::QueryWithEntityIterator<Components...>>>

void helios::ecs::BasicQueryWithEntity< WorldT, Allocator, Components >::Into ( OutIt  out )

inline

Examples

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

Definition at line 1706 of file query.hpp.

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

Map()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::TransformFor<Func, std::tuple<Entity, details::ComponentAccessType<Components>...>>

template<typename Func >
requires utils::TransformFor<Func, std::tuple<Entity, details::ComponentAccessType<Components>...>>

auto helios::ecs::BasicQueryWithEntity< 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 1739 of file query.hpp.

                                                              {
  query_.RefreshArchetypes();
  auto begin_iter = iterator(query_.GetMatchingArchetypes(), query_.GetComponents(), 0, 0);
  auto end_iter =
      iterator(query_.GetMatchingArchetypes(), query_.GetComponents(), query_.GetMatchingArchetypes().size(), 0);
  return {begin_iter, end_iter, std::move(transform)};
}

MaxBy()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::TransformFor<KeyFunc, std::tuple<Entity, details::ComponentAccessType<Components>...>>

template<typename KeyFunc >
requires utils::TransformFor<KeyFunc, std::tuple<Entity, details::ComponentAccessType<Components>...>>

auto helios::ecs::BasicQueryWithEntity< 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 1849 of file query.hpp.

                               {
  auto iter = begin();
  const auto end_iter = end();
 
  if (iter == end_iter) {
    return std::nullopt;
  }
 
  std::optional<value_type> max_element;
  max_element.emplace(*iter);
  auto max_key = std::apply(key_func, *max_element);
  ++iter;
 
  while (iter != end_iter) {
    auto current = *iter;
    auto current_key = std::apply(key_func, current);
    if (current_key > max_key) {
      max_key = current_key;
      max_element.emplace(current);
    }
    ++iter;
  }
 
  return max_element;
}

MinBy()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::TransformFor<KeyFunc, std::tuple<Entity, details::ComponentAccessType<Components>...>>

template<typename KeyFunc >
requires utils::TransformFor<KeyFunc, std::tuple<Entity, details::ComponentAccessType<Components>...>>

auto helios::ecs::BasicQueryWithEntity< 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 1880 of file query.hpp.

                               {
  auto iter = begin();
  const auto end_iter = end();
 
  if (iter == end_iter) {
    return std::nullopt;
  }
 
  std::optional<value_type> min_element;
  min_element.emplace(*iter);
  auto min_key = std::apply(key_func, *min_element);
  ++iter;
 
  while (iter != end_iter) {
    auto current = *iter;
    auto current_key = std::apply(key_func, current);
    if (current_key < min_key) {
      min_key = current_key;
      min_element.emplace(current);
    }
    ++iter;
  }
 
  return min_element;
}

None()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>

template<typename Pred >
requires utils::PredicateFor<Pred, std::tuple<Entity, details::ComponentAccessType<Components>...>>

bool helios::ecs::BasicQueryWithEntity< WorldT, Allocator, Components >::None ( const Pred &  predicate )

inline

Examples

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

Definition at line 974 of file query.hpp.

                                                 {
    return !Any(predicate);
  }

operator=() [1/2]

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>

BasicQueryWithEntity & helios::ecs::BasicQueryWithEntity< WorldT, Allocator, Components >::operator= ( BasicQueryWithEntity< WorldT, Allocator, Components > &&  )

delete

operator=() [2/2]

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>

BasicQueryWithEntity & helios::ecs::BasicQueryWithEntity< WorldT, Allocator, Components >::operator= ( const BasicQueryWithEntity< 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<Entity, details::ComponentAccessType<Components>...>>

template<typename Pred >
requires utils::PredicateFor<Pred, std::tuple<Entity, details::ComponentAccessType<Components>...>>

auto helios::ecs::BasicQueryWithEntity< WorldT, Allocator, Components >::Partition ( const Pred &  predicate ) -> std::pair<std::vector<Entity>, std::vector<Entity>>

inline

Examples

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

Definition at line 1938 of file query.hpp.

                                                     {
  std::vector<Entity> matched;
  std::vector<Entity> not_matched;
 
  for (auto&& tuple : *this) {
    if (std::apply(predicate, tuple)) {
      matched.push_back(std::get<0>(tuple));
    } else {
      not_matched.push_back(std::get<0>(tuple));
    }
  }
 
  return {std::move(matched), std::move(not_matched)};
}

Reverse()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>

auto helios::ecs::BasicQueryWithEntity< 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 871 of file query.hpp.

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

Skip()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::UniqueTypes<Components...>

auto helios::ecs::BasicQueryWithEntity< 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 1761 of file query.hpp.

                                                       {
  query_.RefreshArchetypes();
  auto begin_iter = iterator(query_.GetMatchingArchetypes(), query_.GetComponents(), 0, 0);
  auto end_iter =
      iterator(query_.GetMatchingArchetypes(), query_.GetComponents(), query_.GetMatchingArchetypes().size(), 0);
  return {begin_iter, end_iter, count};
}

SkipWhile()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::PredicateFor<Pred, std::tuple<Entity, details::ComponentAccessType<Components>...>>

template<typename Pred >
requires utils::PredicateFor<Pred, std::tuple<Entity, details::ComponentAccessType<Components>...>>

auto helios::ecs::BasicQueryWithEntity< 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 1787 of file query.hpp.

                                                                    {
  query_.RefreshArchetypes();
  auto begin_iter = iterator(query_.GetMatchingArchetypes(), query_.GetComponents(), 0, 0);
  auto end_iter =
      iterator(query_.GetMatchingArchetypes(), query_.GetComponents(), query_.GetMatchingArchetypes().size(), 0);
  return {begin_iter, end_iter, std::move(predicate)};
}

Slide()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>

auto helios::ecs::BasicQueryWithEntity< 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 885 of file query.hpp.

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

StepBy()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::UniqueTypes<Components...>

auto helios::ecs::BasicQueryWithEntity< 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 1822 of file query.hpp.

                                                        {
  query_.RefreshArchetypes();
  auto begin_iter = iterator(query_.GetMatchingArchetypes(), query_.GetComponents(), 0, 0);
  auto end_iter =
      iterator(query_.GetMatchingArchetypes(), query_.GetComponents(), query_.GetMatchingArchetypes().size(), 0);
  return {begin_iter, end_iter, step};
}

Stride()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>

auto helios::ecs::BasicQueryWithEntity< 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 901 of file query.hpp.

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

Take()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::UniqueTypes<Components...>

auto helios::ecs::BasicQueryWithEntity< 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 1750 of file query.hpp.

                                                       {
  query_.RefreshArchetypes();
  auto begin_iter = iterator(query_.GetMatchingArchetypes(), query_.GetComponents(), 0, 0);
  auto end_iter =
      iterator(query_.GetMatchingArchetypes(), query_.GetComponents(), query_.GetMatchingArchetypes().size(), 0);
  return {begin_iter, end_iter, count};
}

TakeWhile()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>
requires utils::PredicateFor<Pred, std::tuple<Entity, details::ComponentAccessType<Components>...>>

template<typename Pred >
requires utils::PredicateFor<Pred, std::tuple<Entity, details::ComponentAccessType<Components>...>>

auto helios::ecs::BasicQueryWithEntity< 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 1774 of file query.hpp.

                                                                    {
  query_.RefreshArchetypes();
  auto begin_iter = iterator(query_.GetMatchingArchetypes(), query_.GetComponents(), 0, 0);
  auto end_iter =
      iterator(query_.GetMatchingArchetypes(), query_.GetComponents(), query_.GetMatchingArchetypes().size(), 0);
  return {begin_iter, end_iter, std::move(predicate)};
}

Zip()

template<WorldType WorldT, typename Allocator , ComponentTrait... Components>

template<typename OtherIter >
requires utils::IteratorLike<OtherIter>

auto helios::ecs::BasicQueryWithEntity< 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 919 of file query.hpp.

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