helios::utils::TakeAdapter< Iter > Class Template Reference

#include <functional_adapters.hpp>

Inheritance diagram for helios::utils::TakeAdapter< Iter >:

Public Types
using	iterator_category = std::forward_iterator_tag
using	value_type = std::iter_value_t< Iter >
using	difference_type = std::iter_difference_t< Iter >
using	pointer = value_type *
using	reference = value_type

Public Member Functions
constexpr	TakeAdapter (Iter begin, Iter end, size_t count) noexcept(std::is_nothrow_move_constructible_v< Iter > &&std::is_nothrow_copy_constructible_v< Iter >)
	Constructs a take adapter with the given iterator range and count.
constexpr	TakeAdapter (const TakeAdapter &) noexcept(std::is_nothrow_copy_constructible_v< Iter >)=default
constexpr	TakeAdapter (TakeAdapter &&) noexcept(std::is_nothrow_move_constructible_v< Iter >)=default
constexpr	~TakeAdapter () noexcept(std::is_nothrow_destructible_v< Iter >)=default
constexpr TakeAdapter &	operator= (const TakeAdapter &) noexcept(std::is_nothrow_copy_assignable_v< Iter >)=default
constexpr TakeAdapter &	operator= (TakeAdapter &&) noexcept(std::is_nothrow_move_assignable_v< Iter >)=default
constexpr TakeAdapter &	operator++ () noexcept(noexcept(++std::declval< Iter & >()))
constexpr TakeAdapter	operator++ (int) noexcept(std::is_nothrow_copy_constructible_v< TakeAdapter > &&noexcept(++std::declval< TakeAdapter & >()))
constexpr value_type	operator* () const noexcept(noexcept(*std::declval< const Iter & >()))
constexpr bool	operator== (const TakeAdapter &other) const noexcept(noexcept(std::declval< const Iter & >()==std::declval< const Iter & >()))
constexpr bool	operator!= (const TakeAdapter &other) const noexcept(noexcept(std::declval< const TakeAdapter & >()==std::declval< const TakeAdapter & >()))
constexpr bool	IsAtEnd () const noexcept(noexcept(std::declval< const Iter & >()==std::declval< const Iter & >()))
	Checks if the iterator has reached the end.
constexpr TakeAdapter	begin () const noexcept(std::is_nothrow_copy_constructible_v< TakeAdapter >)
constexpr TakeAdapter	end () const noexcept(std::is_nothrow_copy_constructible_v< TakeAdapter >)

Detailed Description

template<typename Iter>
requires TakeAdapterRequirements<Iter>
class helios::utils::TakeAdapter< Iter >

Definition at line 649 of file functional_adapters.hpp.

Member Typedef Documentation

difference_type

template<typename Iter >

using helios::utils::TakeAdapter< Iter >::difference_type = std::iter_difference_t<Iter>

Examples

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

Definition at line 653 of file functional_adapters.hpp.

iterator_category

template<typename Iter >

using helios::utils::TakeAdapter< Iter >::iterator_category = std::forward_iterator_tag

Examples

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

Definition at line 651 of file functional_adapters.hpp.

pointer

template<typename Iter >

using helios::utils::TakeAdapter< Iter >::pointer = value_type*

Examples

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

Definition at line 654 of file functional_adapters.hpp.

reference

template<typename Iter >

using helios::utils::TakeAdapter< Iter >::reference = value_type

Examples

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

Definition at line 655 of file functional_adapters.hpp.

value_type

template<typename Iter >

using helios::utils::TakeAdapter< Iter >::value_type = std::iter_value_t<Iter>

Examples

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

Definition at line 652 of file functional_adapters.hpp.

Constructor & Destructor Documentation

TakeAdapter() [1/3]

template<typename Iter >

constexpr helios::utils::TakeAdapter< Iter >::TakeAdapter ( Iter  begin, Iter  end, size_t  count  )

inlineconstexprnoexcept

Constructs a take adapter with the given iterator range and count.

Parameters

begin	Start of the iterator range
end	End of the iterator range
count	Maximum number of elements to yield

Definition at line 663 of file functional_adapters.hpp.

      : begin_(std::move(begin)), current_(begin_), end_(std::move(end)), initial_count_(count), remaining_(count) {}

TakeAdapter() [2/3]

template<typename Iter >

constexpr helios::utils::TakeAdapter< Iter >::TakeAdapter ( const TakeAdapter< Iter > &  ) const

constexprdefaultnoexcept

TakeAdapter() [3/3]

template<typename Iter >

constexpr helios::utils::TakeAdapter< Iter >::TakeAdapter ( TakeAdapter< Iter > &&  ) const

constexprdefaultnoexcept

~TakeAdapter()

template<typename Iter >

constexpr helios::utils::TakeAdapter< Iter >::~TakeAdapter ( )

constexprdefaultnoexcept

Examples

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

Member Function Documentation

begin()

template<typename Iter >

constexpr TakeAdapter helios::utils::TakeAdapter< Iter >::begin ( ) const

inlineconstexprnoexcept

Examples

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

Definition at line 699 of file functional_adapters.hpp.

                                                                                                              {
    return *this;
  }

end()

template<typename Iter >
requires TakeAdapterRequirements<Iter>

constexpr auto helios::utils::TakeAdapter< Iter >::end ( ) const

constexprnoexcept

Examples

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

Definition at line 749 of file functional_adapters.hpp.

                   {
  auto end_iter = *this;
  end_iter.remaining_ = 0;
  return end_iter;
}

IsAtEnd()

template<typename Iter >

constexpr bool helios::utils::TakeAdapter< Iter >::IsAtEnd ( ) const

inlineconstexprnoexcept

Checks if the iterator has reached the end.

Returns

True if at end, false otherwise

Examples

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

Definition at line 694 of file functional_adapters.hpp.

                                                                                 {
    return remaining_ == 0 || current_ == end_;
  }

operator!=()

template<typename Iter >

constexpr bool helios::utils::TakeAdapter< Iter >::operator!= ( const TakeAdapter< Iter > &  other ) const

inlineconstexprnoexcept

Examples

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

Definition at line 685 of file functional_adapters.hpp.

                                                                                               {
    return !(*this == other);
  }

operator*()

template<typename Iter >

constexpr value_type helios::utils::TakeAdapter< Iter >::operator* ( ) const

inlineconstexprnoexcept

Examples

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

Definition at line 678 of file functional_adapters.hpp.

                                                                                                      {
    return *current_;
  }

operator++() [1/2]

template<typename Iter >
requires TakeAdapterRequirements<Iter>

constexpr auto helios::utils::TakeAdapter< Iter >::operator++ ( )

constexprnoexcept

Examples

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

Definition at line 715 of file functional_adapters.hpp.

                                                                                                       {
  if (remaining_ > 0 && current_ != end_) {
    ++current_;
    --remaining_;
  }
  return *this;
}

operator++() [2/2]

template<typename Iter >
requires TakeAdapterRequirements<Iter>

constexpr auto helios::utils::TakeAdapter< Iter >::operator++ ( int  )

constexprnoexcept

Definition at line 725 of file functional_adapters.hpp.

                                                                                                                  {
  auto temp = *this;
  ++(*this);
  return temp;
}

operator=() [1/2]

template<typename Iter >

constexpr TakeAdapter & helios::utils::TakeAdapter< Iter >::operator= ( const TakeAdapter< Iter > &  )

constexprdefaultnoexcept

Examples

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

operator=() [2/2]

template<typename Iter >

constexpr TakeAdapter & helios::utils::TakeAdapter< Iter >::operator= ( TakeAdapter< Iter > &&  )

constexprdefaultnoexcept

operator==()

template<typename Iter >
requires TakeAdapterRequirements<Iter>

constexpr bool helios::utils::TakeAdapter< Iter >::operator== ( const TakeAdapter< Iter > &  other ) const

constexprnoexcept

Examples

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

Definition at line 734 of file functional_adapters.hpp.

                                                                               {
  // Both are at end if either has no remaining elements or both iterators are at end
  const bool this_at_end = (remaining_ == 0) || (current_ == end_);
  const bool other_at_end = (other.remaining_ == 0) || (other.current_ == other.end_);
 
  if (this_at_end && other_at_end) {
    return true;
  }
 
  return (current_ == other.current_) && (remaining_ == other.remaining_);
}