CRTP base class providing common adapter operations. More...

#include <functional_adapters.hpp>

Public Member Functions
template<typename Pred >
constexpr auto	Filter (Pred predicate) const noexcept(noexcept(FilterAdapter< Derived, Pred >(GetDerived().begin(), GetDerived().end(), std::move(predicate))))
	Chains another filter operation on top of this iterator.

template<typename Func >
constexpr auto	Map (Func transform) const noexcept(noexcept(MapAdapter< Derived, Func >(GetDerived().begin(), GetDerived().end(), std::move(transform))))
	Transforms each element using the given function.

constexpr auto	Take (size_t count) const noexcept(noexcept(TakeAdapter< Derived >(GetDerived().begin(), GetDerived().end(), count)))
	Limits the number of elements to at most count.

constexpr auto	Skip (size_t count) const noexcept(noexcept(SkipAdapter< Derived >(GetDerived().begin(), GetDerived().end(), count)))
	Skips the first count elements.

template<typename Pred >
constexpr auto	TakeWhile (Pred predicate) const noexcept(noexcept(TakeWhileAdapter< Derived, Pred >(GetDerived().begin(), GetDerived().end(), std::move(predicate))))
	Takes elements while a predicate is true.

template<typename Pred >
constexpr auto	SkipWhile (Pred predicate) const noexcept(noexcept(SkipWhileAdapter< Derived, Pred >(GetDerived().begin(), GetDerived().end(), std::move(predicate))))
	Skips elements while a predicate is true.

constexpr auto	Enumerate () const noexcept(noexcept(EnumerateAdapter< Derived >(GetDerived().begin(), GetDerived().end())))
	Adds an index to each element.

template<typename Func >
constexpr auto	Inspect (Func inspector) const noexcept(noexcept(InspectAdapter< Derived, Func >(GetDerived().begin(), GetDerived().end(), std::move(inspector))))
	Observes each element without modifying it.

constexpr auto	StepBy (size_t step) const noexcept(noexcept(StepByAdapter< Derived >(GetDerived().begin(), GetDerived().end(), step)))
	Takes every Nth element.

template<typename OtherIter >
constexpr auto	Chain (OtherIter begin, OtherIter end) const noexcept(noexcept(ChainAdapter< Derived, OtherIter >(GetDerived().begin(), GetDerived().end(), std::move(begin), std::move(end))))
	Chains another range after this one.

template<typename R >
constexpr auto	Chain (R &range) const noexcept(noexcept(ChainAdapterFromRange(GetDerived(), range)))
	Chains another range after this one.

template<typename R >
constexpr auto	Chain (const R &range) const noexcept(noexcept(ChainAdapterFromRange(GetDerived(), range)))
	Chains another range after this one.

constexpr auto	Reverse () const noexcept(noexcept(ReverseAdapter< Derived >(GetDerived().begin(), GetDerived().end())))
	Reverses the order of elements.

constexpr auto	Slide (size_t window_size) const noexcept(noexcept(SlideAdapter< Derived >(GetDerived().begin(), GetDerived().end(), window_size)))
	Creates sliding windows over elements.

constexpr auto	Stride (size_t stride) const noexcept(noexcept(StrideAdapter< Derived >(GetDerived().begin(), GetDerived().end(), stride)))
	Takes every Nth element with stride.

template<typename OtherIter >
constexpr auto	Zip (OtherIter begin, OtherIter end) const noexcept(noexcept(ZipAdapter< Derived, OtherIter >(GetDerived().begin(), GetDerived().end(), std::move(begin), std::move(end))))
	Zips another range with this one.

template<typename R >
constexpr auto	Zip (R &range) const noexcept(noexcept(ZipAdapterFromRange(GetDerived(), range)))
	Zips another range with this one.

template<typename R >
constexpr auto	Zip (const R &range) const noexcept(noexcept(ZipAdapterFromRange(GetDerived(), range)))
	Zips another range with this one.

template<typename Action >
constexpr void	ForEach (const Action &action) const
	Terminal operation: applies an action to each element.

template<typename T , typename Folder >
constexpr T	Fold (T init, const Folder &folder) const
	Terminal operation: reduces elements to a single value using a folder function.

template<typename Pred >
constexpr bool	Any (const Pred &predicate) const
	Terminal operation: checks if any element satisfies a predicate.

template<typename Pred >
constexpr bool	All (const Pred &predicate) const
	Terminal operation: checks if all elements satisfy a predicate.

template<typename Pred >
constexpr bool	None (const Pred &predicate) const
	Terminal operation: checks if no elements satisfy a predicate.

template<typename Pred >
constexpr auto	Find (const Pred &predicate) const
	Terminal operation: finds the first element satisfying a predicate.

template<typename Pred >
constexpr size_t	CountIf (const Pred &predicate) const
	Terminal operation: counts elements satisfying a predicate.

template<typename Pred >
constexpr auto	Partition (const Pred &predicate) const
	Terminal operation: partitions elements into two groups based on a predicate.

template<typename KeyFunc >
constexpr auto	MaxBy (const KeyFunc &key_func) const
	Terminal operation: finds the element with the maximum value according to a key function.

template<typename KeyFunc >
constexpr auto	MinBy (const KeyFunc &key_func) const
	Terminal operation: finds the element with the minimum value according to a key function.

template<typename KeyFunc >
constexpr auto	GroupBy (const KeyFunc &key_func) const
	Terminal operation: groups elements by a key function.

constexpr auto	Collect () const
	Terminal operation: collects all elements into a vector.

template<typename OutIt >
constexpr void	Into (OutIt out) const

Protected Member Functions
constexpr Derived &	GetDerived () noexcept
	Gets reference to derived class instance.

constexpr const Derived &	GetDerived () const noexcept
	Gets const reference to derived class instance.

Detailed Description

template<typename Derived>
class helios::utils::FunctionalAdapterBase< Derived >

CRTP base class providing common adapter operations.

Provides chaining methods (Filter, Map, Take, Skip, etc.) that can be used by any derived adapter class. Uses CRTP pattern to return the correct derived type.

Template Parameters

Derived The derived adapter class

Definition at line 2702 of file functional_adapters.hpp.

Member Function Documentation

◆ All()

template<typename Derived >

template<typename Pred >

constexpr bool helios::utils::FunctionalAdapterBase< Derived >::All ( const Pred & predicate ) const

constexpr

Terminal operation: checks if all elements satisfy a predicate.

Template Parameters

Pred	Predicate type

Parameters

predicate Function to test elements

Returns: True if all elements satisfy the predicate, false otherwise

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 3095 of file functional_adapters.hpp.

                                                                              {
  for (auto&& value : GetDerived()) {
    bool result = false;
    if constexpr (std::invocable<Pred, decltype(value)>) {
      result = predicate(std::forward<decltype(value)>(value));
    } else {
      result = std::apply(predicate, std::forward<decltype(value)>(value));
    }
    if (!result) {
      return false;
    }
  }
  return true;
}

◆ Any()

template<typename Derived >

template<typename Pred >

constexpr bool helios::utils::FunctionalAdapterBase< Derived >::Any ( const Pred & predicate ) const

constexpr

Terminal operation: checks if any element satisfies a predicate.

Template Parameters

Pred	Predicate type

Parameters

predicate Function to test elements

Returns: True if any element satisfies the predicate, false otherwise

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 3078 of file functional_adapters.hpp.

                                                                              {
  for (auto&& value : GetDerived()) {
    bool result = false;
    if constexpr (std::invocable<Pred, decltype(value)>) {
      result = predicate(std::forward<decltype(value)>(value));
    } else {
      result = std::apply(predicate, std::forward<decltype(value)>(value));
    }
    if (result) {
      return true;
    }
  }
  return false;
}

◆ Chain() [1/3]

template<typename Derived >

template<typename R >

constexpr auto helios::utils::FunctionalAdapterBase< Derived >::Chain ( const R & range ) const

inlineconstexprnoexcept

Chains another range after this one.

Template Parameters

R	Range type of the other adapter

Parameters

range The other range to chain

Returns: ChainAdapter that yields elements from both ranges

Definition at line 2838 of file functional_adapters.hpp.

                                                                     {
    return ChainAdapterFromRange(GetDerived(), range);
  }

◆ Chain() [2/3]

template<typename Derived >

template<typename OtherIter >

constexpr auto helios::utils::FunctionalAdapterBase< Derived >::Chain	(	OtherIter	begin,
		OtherIter	end
	)		const

inlineconstexprnoexcept

Chains another range after this one.

Template Parameters

OtherIter Iterator type of the other adapter

Parameters

begin	Begin iterator of the other adapter
end	End iterator of the other adapter

Returns: ChainAdapter that yields elements from both ranges

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 2814 of file functional_adapters.hpp.

                                                                         {
    return ChainAdapter<Derived, OtherIter>(GetDerived().begin(), GetDerived().end(), std::move(begin), std::move(end));
  }

◆ Chain() [3/3]

template<typename Derived >

template<typename R >

constexpr auto helios::utils::FunctionalAdapterBase< Derived >::Chain ( R & range ) const

inlineconstexprnoexcept

Chains another range after this one.

Template Parameters

R	Range type of the other adapter

Parameters

range The other range to chain

Returns: ChainAdapter that yields elements from both ranges

Definition at line 2827 of file functional_adapters.hpp.

                                                                                                                    {
    return ChainAdapterFromRange(GetDerived(), range);
  }

◆ Collect()

template<typename Derived >

constexpr auto helios::utils::FunctionalAdapterBase< Derived >::Collect ( ) const

constexpr

Terminal operation: collects all elements into a vector.

Returns: Vector containing all elements

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 3147 of file functional_adapters.hpp.

                                                             {
  using ValueType = std::iter_value_t<Derived>;
  std::vector<ValueType> result;
  result.reserve(static_cast<size_t>(std::distance(GetDerived().begin(), GetDerived().end())));
  for (auto&& value : GetDerived()) {
    result.push_back(std::forward<decltype(value)>(value));
  }
  return result;
}

◆ CountIf()

template<typename Derived >

template<typename Pred >

constexpr size_t helios::utils::FunctionalAdapterBase< Derived >::CountIf ( const Pred & predicate ) const

constexpr

Terminal operation: counts elements satisfying a predicate.

Template Parameters

Pred	Predicate type

Parameters

predicate Function to test elements

Returns: Number of elements that satisfy the predicate

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 3130 of file functional_adapters.hpp.

                                                                                    {
  size_t count = 0;
  for (auto&& value : GetDerived()) {
    bool result = false;
    if constexpr (std::invocable<Pred, decltype(value)>) {
      result = predicate(std::forward<decltype(value)>(value));
    } else {
      result = std::apply(predicate, std::forward<decltype(value)>(value));
    }
    if (result) {
      ++count;
    }
  }
  return count;
}

◆ Enumerate()

template<typename Derived >

constexpr auto helios::utils::FunctionalAdapterBase< Derived >::Enumerate ( ) const

inlineconstexprnoexcept

Adds an index to each element.

Returns: EnumerateAdapter that pairs indices with values

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 2778 of file functional_adapters.hpp.

                                                                                              {
    return EnumerateAdapter<Derived>(GetDerived().begin(), GetDerived().end());
  }

◆ Filter()

template<typename Derived >

template<typename Pred >

constexpr auto helios::utils::FunctionalAdapterBase< Derived >::Filter ( Pred predicate ) const

inlineconstexprnoexcept

Chains another filter operation on top of this iterator.

Template Parameters

Pred	Predicate type

Parameters

predicate Function to filter elements

Returns: FilterAdapter that applies this adapter then filters

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 2711 of file functional_adapters.hpp.

                                                                                                                     {
    return FilterAdapter<Derived, Pred>(GetDerived().begin(), GetDerived().end(), std::move(predicate));
  }

◆ Find()

template<typename Derived >

template<typename Pred >

constexpr auto helios::utils::FunctionalAdapterBase< Derived >::Find ( const Pred & predicate ) const

constexpr

Terminal operation: finds the first element satisfying a predicate.

Template Parameters

Pred	Predicate type

Parameters

predicate Function to test elements

Returns: Optional containing the first matching element, or empty if none found

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 3112 of file functional_adapters.hpp.

                                                                               {
  using ValueType = std::iter_value_t<Derived>;
  for (auto&& value : GetDerived()) {
    bool result = false;
    if constexpr (std::invocable<Pred, decltype(value)>) {
      result = predicate(std::forward<decltype(value)>(value));
    } else {
      result = std::apply(predicate, std::forward<decltype(value)>(value));
    }
    if (result) {
      return std::optional<ValueType>(std::forward<decltype(value)>(value));
    }
  }
  return std::optional<ValueType>{};
}

◆ Fold()

template<typename Derived >

template<typename T , typename Folder >

constexpr T helios::utils::FunctionalAdapterBase< Derived >::Fold	(	T	init,
		const Folder &	folder
	)		const

constexpr

Terminal operation: reduces elements to a single value using a folder function.

Template Parameters

T	Accumulator type
Folder	Function type that combines accumulator with each element

Parameters

init	Initial accumulator value
folder	Function to fold elements

Returns: Final accumulated value

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 3063 of file functional_adapters.hpp.

                                                                                   {
  for (auto&& value : GetDerived()) {
    if constexpr (std::invocable<Folder, T&&, decltype(value)>) {
      init = folder(std::move(init), std::forward<decltype(value)>(value));
    } else {
      init = std::apply(
          [&init, &folder](auto&&... args) { return folder(std::move(init), std::forward<decltype(args)>(args)...); },
          std::forward<decltype(value)>(value));
    }
  }
  return init;
}

◆ ForEach()

template<typename Derived >

template<typename Action >

constexpr void helios::utils::FunctionalAdapterBase< Derived >::ForEach ( const Action & action ) const

constexpr

Terminal operation: applies an action to each element.

Template Parameters

Action Function type that processes each element

Parameters

action Function to apply to each element

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 3051 of file functional_adapters.hpp.

                                                                                 {
  for (auto&& value : GetDerived()) {
    if constexpr (std::invocable<Action, decltype(value)>) {
      action(std::forward<decltype(value)>(value));
    } else {
      std::apply(action, std::forward<decltype(value)>(value));
    }
  }
}

◆ GetDerived() [1/2]

template<typename Derived >

constexpr const Derived & helios::utils::FunctionalAdapterBase< Derived >::GetDerived ( ) const

inlineconstexprprotectednoexcept

Gets const reference to derived class instance.

Returns: Const reference to derived class

Definition at line 3046 of file functional_adapters.hpp.

3046{ return static_cast<const Derived&>(*this); }

◆ GetDerived() [2/2]

template<typename Derived >

constexpr Derived & helios::utils::FunctionalAdapterBase< Derived >::GetDerived ( )

inlineconstexprprotectednoexcept

Gets reference to derived class instance.

Returns: Reference to derived class

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 3040 of file functional_adapters.hpp.

3040{ return static_cast<Derived&>(*this); }

◆ GroupBy()

template<typename Derived >

template<typename KeyFunc >

constexpr auto helios::utils::FunctionalAdapterBase< Derived >::GroupBy ( const KeyFunc & key_func ) const

constexpr

Terminal operation: groups elements by a key function.

Template Parameters

KeyFunc Key extraction function type

Parameters

key_func Function to extract grouping key from each element

Returns: Map from keys to vectors of elements with that key

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 3268 of file functional_adapters.hpp.

                                                                                    {
  using ValueType = std::iter_value_t<Derived>;
  using KeyType = std::decay_t<std::invoke_result_t<KeyFunc, ValueType>>;
  std::unordered_map<KeyType, std::vector<ValueType>> groups;
 
  for (auto&& value : GetDerived()) {
    KeyType key;
    if constexpr (std::invocable<KeyFunc, decltype(value)>) {
      key = key_func(std::forward<decltype(value)>(value));
    } else {
      key = std::apply(key_func, std::forward<decltype(value)>(value));
    }
    groups[std::move(key)].push_back(std::forward<decltype(value)>(value));
  }
 
  return groups;
}

◆ Inspect()

template<typename Derived >

template<typename Func >

constexpr auto helios::utils::FunctionalAdapterBase< Derived >::Inspect ( Func inspector ) const

inlineconstexprnoexcept

Observes each element without modifying it.

Template Parameters

Func	Inspector function type

Parameters

inspector Function to call on each element

Returns: InspectAdapter for side effects

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 2790 of file functional_adapters.hpp.

                                                                            {
    return InspectAdapter<Derived, Func>(GetDerived().begin(), GetDerived().end(), std::move(inspector));
  }

◆ Into()

template<typename Derived >

template<typename OutIt >

constexpr void helios::utils::FunctionalAdapterBase< Derived >::Into ( OutIt out ) const

constexpr

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 3159 of file functional_adapters.hpp.

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

◆ Map()

template<typename Derived >

template<typename Func >

constexpr auto helios::utils::FunctionalAdapterBase< Derived >::Map ( Func transform ) const

inlineconstexprnoexcept

Transforms each element using the given function.

Template Parameters

Func	Transformation function type

Parameters

transform Function to apply to each element

Returns: MapAdapter that transforms adapted results

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 2723 of file functional_adapters.hpp.

                                                                                                                  {
    return MapAdapter<Derived, Func>(GetDerived().begin(), GetDerived().end(), std::move(transform));
  }

◆ MaxBy()

template<typename Derived >

template<typename KeyFunc >

constexpr auto helios::utils::FunctionalAdapterBase< Derived >::MaxBy ( const KeyFunc & key_func ) const

constexpr

Terminal operation: finds the element with the maximum value according to a key function.

Template Parameters

KeyFunc Key extraction function type

Parameters

key_func Function to extract comparison key from each element

Returns: Optional containing the element with maximum key, or empty if no elements

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 3192 of file functional_adapters.hpp.

                                                                                  {
  using ValueType = std::iter_value_t<Derived>;
  auto iter = GetDerived().begin();
  const auto end_iter = GetDerived().end();
 
  if (iter == end_iter) {
    return std::nullopt;
  }
 
  std::optional<ValueType> max_element;
  max_element.emplace(*iter);
 
  auto get_key = [&key_func](auto&& val) {
    if constexpr (std::invocable<KeyFunc, decltype(val)>) {
      return key_func(std::forward<decltype(val)>(val));
    } else {
      return std::apply(key_func, std::forward<decltype(val)>(val));
    }
  };
 
  auto max_key = get_key(*max_element);
  ++iter;
 
  while (iter != end_iter) {
    auto current = *iter;
    auto current_key = get_key(current);
    if (current_key > max_key) {
      max_key = current_key;
      max_element.emplace(current);
    }
    ++iter;
  }
 
  return max_element;
}

◆ MinBy()

template<typename Derived >

template<typename KeyFunc >

constexpr auto helios::utils::FunctionalAdapterBase< Derived >::MinBy ( const KeyFunc & key_func ) const

constexpr

Terminal operation: finds the element with the minimum value according to a key function.

Template Parameters

KeyFunc Key extraction function type

Parameters

key_func Function to extract comparison key from each element

Returns: Optional containing the element with minimum key, or empty if no elements

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 3230 of file functional_adapters.hpp.

                                                                                  {
  using ValueType = std::iter_value_t<Derived>;
  auto iter = GetDerived().begin();
  const auto end_iter = GetDerived().end();
 
  if (iter == end_iter) {
    return std::nullopt;
  }
 
  std::optional<ValueType> min_element;
  min_element.emplace(*iter);
 
  auto get_key = [&key_func](auto&& val) {
    if constexpr (std::invocable<KeyFunc, decltype(val)>) {
      return key_func(std::forward<decltype(val)>(val));
    } else {
      return std::apply(key_func, std::forward<decltype(val)>(val));
    }
  };
 
  auto min_key = get_key(*min_element);
  ++iter;
 
  while (iter != end_iter) {
    auto current = *iter;
    auto current_key = get_key(current);
    if (current_key < min_key) {
      min_key = current_key;
      min_element.emplace(current);
    }
    ++iter;
  }
 
  return min_element;
}

◆ None()

template<typename Derived >

template<typename Pred >

constexpr bool helios::utils::FunctionalAdapterBase< Derived >::None ( const Pred & predicate ) const

inlineconstexpr

Terminal operation: checks if no elements satisfy a predicate.

Template Parameters

Pred	Predicate type

Parameters

predicate Function to test elements

Returns: True if no elements satisfy the predicate, false otherwise

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 2955 of file functional_adapters.hpp.

                                                                 {
    return !Any(predicate);
  }

◆ Partition()

template<typename Derived >

template<typename Pred >

constexpr auto helios::utils::FunctionalAdapterBase< Derived >::Partition ( const Pred & predicate ) const

constexpr

Terminal operation: partitions elements into two groups based on a predicate.

Template Parameters

Pred	Predicate type

Parameters

predicate Function to test elements

Returns: Pair of vectors: first contains elements satisfying predicate, second contains the rest

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 3167 of file functional_adapters.hpp.

                                                                                    {
  using ValueType = std::iter_value_t<Derived>;
  std::vector<ValueType> matched;
  std::vector<ValueType> not_matched;
 
  for (auto&& value : GetDerived()) {
    bool result = false;
    if constexpr (std::invocable<Pred, decltype(value)>) {
      result = predicate(std::forward<decltype(value)>(value));
    } else {
      result = std::apply(predicate, std::forward<decltype(value)>(value));
    }
 
    if (result) {
      matched.push_back(std::forward<decltype(value)>(value));
    } else {
      not_matched.push_back(std::forward<decltype(value)>(value));
    }
  }
 
  return std::pair{std::move(matched), std::move(not_matched)};
}

◆ Reverse()

template<typename Derived >

constexpr auto helios::utils::FunctionalAdapterBase< Derived >::Reverse ( ) const

inlineconstexprnoexcept

Reverses the order of elements.

Note: Requires bidirectional iterator support

Returns: ReverseAdapter that yields elements in reverse order

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 2848 of file functional_adapters.hpp.

                                                                                            {
    return ReverseAdapter<Derived>(GetDerived().begin(), GetDerived().end());
  }

◆ Skip()

template<typename Derived >

constexpr auto helios::utils::FunctionalAdapterBase< Derived >::Skip ( size_t count ) const

inlineconstexprnoexcept

Skips the first count elements.

Parameters

count Number of elements to skip

Returns: SkipAdapter that skips adapted results

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 2743 of file functional_adapters.hpp.

                                                                                                {
    return SkipAdapter<Derived>(GetDerived().begin(), GetDerived().end(), count);
  }

◆ SkipWhile()

template<typename Derived >

template<typename Pred >

constexpr auto helios::utils::FunctionalAdapterBase< Derived >::SkipWhile ( Pred predicate ) const

inlineconstexprnoexcept

Skips elements while a predicate is true.

Template Parameters

Pred	Predicate type for skip-while operation

Parameters

predicate Predicate to determine when to stop skipping

Returns: SkipWhileAdapter that conditionally skips elements

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 2768 of file functional_adapters.hpp.

                                                                              {
    return SkipWhileAdapter<Derived, Pred>(GetDerived().begin(), GetDerived().end(), std::move(predicate));
  }

◆ Slide()

template<typename Derived >

constexpr auto helios::utils::FunctionalAdapterBase< Derived >::Slide ( size_t window_size ) const

inlineconstexprnoexcept

Creates sliding windows over elements.

Parameters

window_size Size of the sliding window

Returns: SlideAdapter that yields windows of elements

Warning: window_size must be greater than 0

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 2859 of file functional_adapters.hpp.

                                                                                                       {
    return SlideAdapter<Derived>(GetDerived().begin(), GetDerived().end(), window_size);
  }

◆ StepBy()

template<typename Derived >

constexpr auto helios::utils::FunctionalAdapterBase< Derived >::StepBy ( size_t step ) const

inlineconstexprnoexcept

Takes every Nth element.

Parameters

step	Step size between elements

Returns: StepByAdapter that skips elements

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 2801 of file functional_adapters.hpp.

                                                                                                 {
    return StepByAdapter<Derived>(GetDerived().begin(), GetDerived().end(), step);
  }

◆ Stride()

template<typename Derived >

constexpr auto helios::utils::FunctionalAdapterBase< Derived >::Stride ( size_t stride ) const

inlineconstexprnoexcept

Takes every Nth element with stride.

Parameters

stride Number of elements to skip between yields

Returns: StrideAdapter that yields every Nth element

Warning: stride must be greater than 0

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 2870 of file functional_adapters.hpp.

                                                                                                   {
    return StrideAdapter<Derived>(GetDerived().begin(), GetDerived().end(), stride);
  }

◆ Take()

template<typename Derived >

constexpr auto helios::utils::FunctionalAdapterBase< Derived >::Take ( size_t count ) const

inlineconstexprnoexcept

Limits the number of elements to at most count.

Parameters

count Maximum number of elements to yield

Returns: TakeAdapter that limits adapted results

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 2733 of file functional_adapters.hpp.

                                                                                                {
    return TakeAdapter<Derived>(GetDerived().begin(), GetDerived().end(), count);
  }

◆ TakeWhile()

template<typename Derived >

template<typename Pred >

constexpr auto helios::utils::FunctionalAdapterBase< Derived >::TakeWhile ( Pred predicate ) const

inlineconstexprnoexcept

Takes elements while a predicate is true.

Template Parameters

Pred	Predicate type for take-while operation

Parameters

predicate Predicate to determine when to stop taking

Returns: TakeWhileAdapter that conditionally takes elements

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 2755 of file functional_adapters.hpp.

                                                                              {
    return TakeWhileAdapter<Derived, Pred>(GetDerived().begin(), GetDerived().end(), std::move(predicate));
  }

◆ Zip() [1/3]

template<typename Derived >

template<typename R >

constexpr auto helios::utils::FunctionalAdapterBase< Derived >::Zip ( const R & range ) const

inlineconstexprnoexcept

Zips another range with this one.

Template Parameters

R	Other range

Parameters

range The other range to zip with

Returns: ZipAdapter that

Definition at line 2907 of file functional_adapters.hpp.

                                                                                                                      {
    return ZipAdapterFromRange(GetDerived(), range);
  }

◆ Zip() [2/3]

template<typename Derived >

template<typename OtherIter >

constexpr auto helios::utils::FunctionalAdapterBase< Derived >::Zip	(	OtherIter	begin,
		OtherIter	end
	)		const

inlineconstexprnoexcept

Zips another range with this one.

Template Parameters

OtherIter Iterator type to zip with

Parameters

begin	Begin iterator for the other range
end	End iterator for the other range

Returns: ZipAdapter that yields tuples of corresponding elements

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 2883 of file functional_adapters.hpp.

                                                                       {
    return ZipAdapter<Derived, OtherIter>(GetDerived().begin(), GetDerived().end(), std::move(begin), std::move((end)));
  }

◆ Zip() [3/3]

template<typename Derived >

template<typename R >

constexpr auto helios::utils::FunctionalAdapterBase< Derived >::Zip ( R & range ) const

inlineconstexprnoexcept

Zips another range with this one.

Template Parameters

R	Other range

Parameters

range The other range to zip with

Returns: ZipAdapter that

Definition at line 2896 of file functional_adapters.hpp.

                                                                                                                {
    return ZipAdapterFromRange(GetDerived(), range);
  }

	Helios Engine 0.1.0 A modular ECS based data-oriented C++23 game engine

Public Member Functions

Protected Member Functions

Detailed Description

Member Function Documentation

◆ All()

◆ Any()

◆ Chain() [1/3]

◆ Chain() [2/3]

◆ Chain() [3/3]

◆ Collect()

◆ CountIf()

◆ Enumerate()

◆ Filter()

◆ Find()

◆ Fold()

◆ ForEach()

◆ GetDerived() [1/2]

◆ GetDerived() [2/2]

◆ GroupBy()

◆ Inspect()

◆ Into()

◆ Map()

◆ MaxBy()

◆ MinBy()

◆ None()

◆ Partition()

◆ Reverse()

◆ Skip()

◆ SkipWhile()

◆ Slide()

◆ StepBy()

◆ Stride()

◆ Take()

◆ TakeWhile()

◆ Zip() [1/3]

◆ Zip() [2/3]

◆ Zip() [3/3]